精华内容
下载资源
问答
  • 因为在实际情况中,我们经常能遇到不同要求的聚合模式,这就导致了很难在短期内将CALCULATE的透彻,微软一共200多个DAX函数,这就代表了无数种可能。 白茶的理解是,打基础两个很重要的点,一是记住各个函数的...

    哈喽,小伙伴们,头几次白茶分享了单条件聚合、多条件聚合、各类占比、以点带面聚合,本期呢,咱们继续研究CALCULATE函数。

    白茶最近思考了一下,就是CALCULATE函数,为什么它是最灵活的,也是使用频率最高的函数?

    因为在实际情况中,我们经常能遇到不同要求的聚合模式,这就导致了很难在短期内将CALCULATE学的透彻,微软一共200多个DAX函数,这就代表了有无数种可能。

    白茶的理解是,打基础有两个很重要的点,一是记住各个函数的用途,别用微软的言语去理解,要用我们的中文概念去理解,去吃透;二是记住几个我们使用频度高的函数,并且记住各个参数要求,这样的话时间久了,遇到问题脑海中就会自然而然的想到相关函数,所欠缺的就是如何衔接公式,这个可以靠不断的试验去慢慢尝试,只要这样记得才会深刻。

    看别人做,知识永远都是别人的,只有自己动手做,并且形成了自己的思维模式,知识才是自己的。

    这是白茶对于学习的理解,好了,闲话不多说,开始今天的案例。

    这是白茶做的一份示例文件,什么意思呢?每个客户每天持有的货物数量、金额都是变动的,我现在想知道每个客户的月末结余库存。可能有的小伙伴会说了,这个简单啊!可是仔细看,这个示例文件能够引申出来很多的概念词语。

    一、累计度量值:

    这个就是我们使用频率最高的度量值,就是可以无限聚合的数值类型。

    比如说销售额,我昨天卖了15元,今天16元,那么求我的总营业额就是无限的累计。

    二、不可累计度量值:

    这个度量值类型有点类似于文本,就是文字大部分时候(不是全部)是不可以累计的,就是为了区分作用。

    比如说省份,辽宁、黑龙江、哈尔滨,一般情况下我们不需要对它进行聚合,这类是不可累计。

    三、半累计度量值:

    半累计是啥意思,就是有时候能累计,有时候不能累计。这是啥意思?看我们的示例文件就知道了,比如我想知道所有客户1月份的库存余额汇总,那么将一月份最后一天三个客户的库存余额相加就可以了,这个之前提到过,CALCULATE+FILTER+MAX就可以搞定了。

    但是,我要显示每个客户每个月的库存余额,这个就是不能完全累加,因为我们需要呈现的是每个客户对应月份里面最后一天的数值。

    这个我们需要咋处理呢?来,跟着白茶学习的思路走。

    将数据导入PowerBI中,进行常规操作,建立日期表、建模定关系。

    这样我们的前期准备工作完成,将数据放在矩阵中呈现如下:

    编写最基础的聚合代码如下:

    DAX=
    SUM('表'[求和项])
    

    放在矩阵中对比。

    可能白茶之前说的太啰嗦了,小伙伴们这回明白没?我要显示的是月末库存,而不是将这些数据聚合到一块,这样是没有意义、错误的。

    编写代码如下:

    月末库存余额=
    CALCULATE(SUM('表'[求和项]),LASTDATE('表'[DATE])//这里要替换成自己的数据
    

    如图:

    这个怎么说呢,LASTDATE的判定是返回最后一个非空白日期,从矩阵中看没啥大问题,但是在表中看有很明显的漏洞。

    优化我们的代码,让CALCULATE重新判定一下:

    优化=
    CALCULATE(SUM('表'[求和项]),FILTER(ALL('日期表'),'日期表'[DATE]=MAX('事实表'[DATE])//替换成自己的数据
    

    结果如下:

    相对于上一个代码,虽然在矩阵中没有任何变化,但是在表中体现的很直接,判定范围为有数据的最大日期,这样是不是更稳妥一点呢?

    (白茶现在没想出来二者别的区别,有的话请各位小伙伴告诉我一声。)


    小伙伴们❤GET了么?

    白茶会不定期的分享一些函数卡片

    (文件在知识星球[PowerBI丨需求圈])

    这里是白茶,一个PowerBI的初学者。

    下面这个知识星球是针对有实际需求的小伙伴,有需要的请加入下面的知识星球。

    展开全文
  • 不过,除了常规函数,你应该也会在代码中见到一些“非常规”函数,它们往往很简短,就一行,并且个很酷炫的名字——lambda,没错,这就是匿名函数。 匿名函数实际工作中同样举足轻重,正确地运用匿名函数,能让...
    img
    

    你好,我是悦创。

    上一节,我们一起学习了 Python 中的“常规”函数,用途十分广泛。不过,除了常规函数,你应该也会在代码中见到一些“非常规”函数,它们往往很简短,就一行,并且有个很酷炫的名字——lambda,没错,这就是匿名函数。

    匿名函数在实际工作中同样举足轻重,正确地运用匿名函数,能让我们的代码更简洁、易读。这节课,我们继续 Python 的函数之旅,一起来学习这个简约而不简单的匿名函数。

    匿名函数基础

    首先,什么是匿名函数呢?以下是匿名函数的格式:

    lambda argument1, argument2,... argumentN : expression
    

    我们可以看到,匿名函数的关键字是 lambda,之后是一系列的参数,然后用冒号隔开,最后则是由这些参数组成的表达式。我们通过几个例子看一下它的用法:

    square = lambda x: x**2
    square(3)
    
    9
    

    这里的匿名函数只输入一个参数 x,输出则是输入 x 的平方。因此当输入是 3 时,输出便是 9。如果把这个匿名函数写成常规函数的形式,则是下面这样:

    def square(x):
        return x**2
    square(3)
     
    9
    

    可以看到,匿名函数 lambda 和常规函数一样,返回的都是一个函数对象(function object),它们的用法也极其相似,不过还是有下面几点区别。

    第一,lambda 是一个表达式(expression),并不是一个语句(statement)。

    • 所谓的表达式,就是用一系列 “公式” 去表达一个东西,比如 x + 2x**2 等等;
    • 而所谓的语句,则一定是完成了某些功能,比如赋值语句 x = 1 完成了赋值,print 语句 print(x) 完成了打印,条件语句 if x < 0: 完成了选择功能等等。

    因此,lambda 可以用在一些常规函数 def 不能用的地方,比如,lambda 可以用在列表内部,而常规函数却不能:

    [(lambda x: x*x)(x) for x in range(10)]
    # 输出
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    

    再比如,lambda 可以被用作某些函数的参数,而常规函数 def 也不能:

    l = [(1, 20), (3, 0), (9, 10), (2, -1)]
    l.sort(key=lambda x: x[1]) # 按列表中元组的第二个元素排序
    print(l)
    # 输出
    [(2, -1), (3, 0), (9, 10), (1, 20)]
    

    常规函数 def 必须通过其函数名被调用,因此必须首先被定义。但是作为一个表达式的 lambda,返回的函数对象就不需要名字了。

    第二,lambda 的主体是只有一行的简单表达式,并不能扩展成一个多行的代码块。

    这其实是出于设计的考虑。Python 之所以发明 lambda,就是为了让它和常规函数各司其职:lambda 专注于简单的任务,而常规函数则负责更复杂的多行逻辑。关于这点,Python 之父 Guido van Rossum 曾发了一篇 文章 解释,你有兴趣的话可以自己阅读。

    为什么要使用匿名函数?

    理论上来说,Python 中有匿名函数的地方,都可以被替换成等价的其他表达形式。

    一个 Python 程序是可以不用任何匿名函数的。不过,在一些情况下,使用匿名函数 lambda,可以帮助我们大大简化代码的复杂度,提高代码的可读性。

    通常,我们用函数的目的无非是这么几点:

    1. 减少代码的重复性;
    2. 模块化代码。

    对于第一点,如果你的程序在不同地方包含了相同的代码,那么我们就会把这部分相同的代码写成一个函数,并为它取一个名字,方便在相对应的不同地方调用。

    对于第二点,如果你的一块儿代码是为了实现一个功能,但内容非常多,写在一起降低了代码的可读性,那么通常我们也会把这部分代码单独写成一个函数,然后加以调用。

    不过,再试想一下这样的情况。你需要一个函数,但它非常简短,只需要一行就能完成;同时它在程序中只被调用一次而已。那么请问,你还需要像常规函数一样,给它一个定义和名字吗?

    答案当然是否定的。这种情况下,函数就可以是匿名的,你只需要在适当的地方定义并使用,就能让匿名函数发挥作用了。

    举个例子,如果你想对一个列表中的所有元素做平方操作,而这个操作在你的程序中只需要进行一次,用 lambda 函数可以表示成下面这样:

    squared = map(lambda x: x**2, [1, 2, 3, 4, 5])
    

    如果用常规函数,则表示为这几行代码:

    def square(x):
        return x**2
    
    squared = map(square, [1, 2, 3, 4, 5])
    

    这里我简单解释一下。函数 map(function, iterable) 的第一个参数是函数对象,第二个参数是一个可以遍历的集合,它表示对 iterable 的每一个元素,都运用 function 这个函数。两者一对比,我们很明显地发现,lambda 函数让代码更加简洁明了。

    再举一个例子,在 Python 的 Tkinter GUI 应用中,我们想实现这样一个简单的功能:

    创建显示一个按钮,每当用户点击时,就打印出一段文字。如果使用 lambda 函数可以表示成下面这样:

    from tkinter import Button, mainloop
    button = Button(
        text='This is a button',
        command=lambda: print('being pressed')) # 点击时调用lambda函数
    button.pack()
    mainloop()
    

    而如果我们用常规函数 def,那么需要写更多的代码:

    from tkinter import Button, mainloop
    
    def print_message():
        print('being pressed')
    
    button = Button(
        text='This is a button',
        command=print_message) # 点击时调用lambda函数
    button.pack()
    mainloop()
    

    显然,运用匿名函数的代码简洁很多,也更加符合 Python 的编程习惯。

    Python 函数式编程

    最后,我们一起来看一下,Python 的函数式编程特性,这与我们今天所讲的匿名函数 lambda,有着密切的联系。

    所谓函数式编程,是指代码中每一块都是不可变的(immutable),都由纯函数(pure function)的形式组成。这里的纯函数,是指函数本身相互独立、互不影响,对于相同的输入,总会有相同的输出,没有任何副作用。

    举个很简单的例子,比如对于一个列表,我想让列表中的元素值都变为原来的两倍,我们可以写成下面的形式:

    def multiply_2(l):
        for index in range(0, len(l)):
            l[index] *= 2
        return l
    

    这段代码就不是一个纯函数的形式,因为列表中元素的值被改变了,如果我多次调用 multiply_2() 这个函数,那么每次得到的结果都不一样。要想让它成为一个纯函数的形式,就得写成下面这种形式,重新创建一个新的列表并返回。

    def multiply_2_pure(l):
        new_list = []
        for item in l:
            new_list.append(item * 2)
        return new_list
    

    函数式编程的优点,主要在于其纯函数和不可变的特性使程序更加健壮,易于调试(debug)和测试;缺点主要在于限制多,难写

    当然,Python 不同于一些语言(比如 Scala),它并不是一门函数式编程语言,不过,Python 也提供了一些函数式编程的特性,值得我们了解和学习。

    Python 主要提供了这么几个函数:map()、filter() 和 reduce(),通常结合匿名函数 lambda 一起使用。这些都是你需要掌握的东西,接下来我逐一介绍。

    首先是 map(function, iterable) 函数,前面的例子提到过,它表示,对 iterable 中的每个元素,都运用 function 这个函数,最后返回一个新的可遍历的集合。

    比如刚才列表的例子,要对列表中的每个元素乘以 2,那么用 map 就可以表示为下面这样:

    l = [1, 2, 3, 4, 5]
    new_list = map(lambda x: x * 2, l) # [2, 4, 6, 8, 10]
    

    我们可以以 map() 函数为例,看一下 Python 提供的函数式编程接口的性能。还是同样的列表例子,它还可以用 for 循环和 list comprehension(目前没有统一中文叫法,你也可以直译为列表理解等)实现,我们来比较一下它们的速度:

    python3 -mtimeit -s'xs=range(1000000)' 'map(lambda x: x*2, xs)'
    2000000 loops, best of 5: 171 nsec per loop
    
    python3 -mtimeit -s'xs=range(1000000)' '[x * 2 for x in xs]'
    5 loops, best of 5: 62.9 msec per loop
    
    python3 -mtimeit -s'xs=range(1000000)' 'l = []' 'for i in xs: l.append(i * 2)'
    5 loops, best of 5: 92.7 msec per loop
    

    你可以看到,map() 是最快的。因为 map() 函数直接由 C 语言写的,运行时不需要通过 Python 解释器间接调用,并且内部做了诸多优化,所以运行速度最快。

    接下来来看 filter(function, iterable) 函数,它和 map 函数类似,function 同样表示一个函数对象。filter() 函数表示对 iterable 中的每个元素,都使用 function 判断,并返回 True 或者 False,最后将返回 True 的元素组成一个新的可遍历的集合。

    举个例子,比如我要返回一个列表中的所有偶数,可以写成下面这样:

    l = [1, 2, 3, 4, 5]
    new_list = filter(lambda x: x % 2 == 0, l) # [2, 4]
    

    最后我们来看 reduce(function, iterable) 函数,它通常用来对一个集合做一些累积操作。

    function 同样是一个函数对象,规定它有两个参数,表示对 iterable 中的每个元素以及上一次调用后的结果,运用 function 进行计算,所以最后返回的是一个单独的数值。

    举个例子,我想要计算某个列表元素的乘积,就可以用 reduce() 函数来表示:

    from functools import reduce
    l = [1, 2, 3, 4, 5]
    product = reduce(lambda x, y: x * y, l) # 1*2*3*4*5 = 120
    

    当然,类似的,filter()reduce() 的功能,也可以用 for 循环或者 list comprehension 来实现。

    通常来说,在我们想对集合中的元素进行一些操作时,如果操作非常简单,比如相加、累积这种,那么我们优先考虑 map()、filter()、reduce() 这类或者 list comprehension 的形式。至于这两种方式的选择:

    • 在数据量非常多的情况下,比如机器学习的应用,那我们一般更倾向于函数式编程的表示,因为效率更高;
    • 在数据量不多的情况下,并且你想要程序更加 Pythonic 的话,那么 list comprehension 也不失为一个好选择。

    不过,如果你要对集合中的元素,做一些比较复杂的操作,那么,考虑到代码的可读性,我们通常会使用 for 循环,这样更加清晰明了。

    总结

    这节课,我们一起学习了 Python 中的匿名函数 lambda,它的主要用途是减少代码的复杂度。需要注意的是 lambda 是一个表达式,并不是一个语句;它只能写成一行的表达形式,语法上并不支持多行。

    匿名函数通常的使用场景是:程序中需要使用一个函数完成一个简单的功能,并且该函数只调用一次。

    其次,我们也入门了 Python 的函数式编程,主要了解了常见的 map(),fiilter() 和 reduce() 三个函数,并比较了它们与其他形式(for 循环,comprehension)的性能,显然,它们的性能效率是最优的。

    思考题

    最后,我想给你留下两道思考题。

    第一问:如果让你对一个字典,根据值进行由高到底的排序,该怎么做呢?以下面这段代码为例,你可以思考一下。

    d = {'mike': 10, 'lucy': 2, 'ben': 30}
    

    第二问:在实际工作学习中,你遇到过哪些使用匿名函数的场景呢?

    欢迎在留言区写下你的答案想法,与我讨论。

    解答

    第一问:sorted(d.items(), key=lambda x: x[1], reverse=True); # reverse=True 从大小排序
    第二问:最开始接触 lambda 匿名函数的时候觉得蛮不理解的,觉得这个函数没有灵魂,用完一次就扔掉。后来在和高阶函数、列表生成式搭配使用以及一些小功能的使用上觉得很好用,这样代码即简洁又易于阅读。
    注:匿名函数最难理解的地方就是要传入的参数是一个可迭代的对象,lambda 内部会调用可迭代对象的 next 方法取值当作参数传入 lambda 函数冒号前面的值,然后把表达式计算的结果进行返回。

    展开全文
  • 哈希表学习总结

    2016-04-15 09:37:16
    什么是哈希表, 哈希函数, 关键字? 关键字: 用户数据 哈希表(Hash Table): 也叫...哈希表有什么用途?用于加密算法; 用于数字签名; 用于文件校验. 在实际应用中, 哈希表的查找性能是极好的. 在合理的假设下, 它查找一
    1. 什么是哈希表, 哈希函数, 关键字?
      关键字: 用户数据
      哈希表(Hash Table): 也叫散列表, 是根据关键码值(Key Value) 直接进行数据访问的数据结构.
      哈希函数: 也叫散列函数, 是key和[结果]的一种关系. k = f(k);

    2. 哈希表有什么用途?

      1. 用于加密算法;
      2. 用于数字签名;
      3. 用于文件校验.
        在实际应用中, 哈希表的查找性能是极好的.
        在合理的假设下, 它查找一个元素的平均时间是O(1);
    3. 哈希函数的构造方法之除留余数法.
      在此方法中, 表长代表所有元素个数, 并不是数组长度.

    除留余数法此方法为最常用的构造散列函数方法。
    对于散列表长为m的散列函数公式为:
    f( key ) = key mod p ( p ≤ m ) (p一般取第一个比m小的质数)
    代码如下:

    /*======================================================================\
    * Author (作者): i.sshe
    * Date (日期): 2016/03/26
    * Others (其他): 寻找<num的最大质数
    \*=======================================================================*/
    int generate_mod_value(int num)
    {
         int i = 0;
         int j = 0;
         int temp = 0;
         int flag = 0;
    
         for (i = num; i > 2; i--)
         {
             flag = 1;
             for (j = 2; j <= i/2; j++)
             {
                  if(i % j == 0) //不是质数
                  {
                      flag = 0;
                      break;
                  }
             }
    
             if (flag == 1)
             {
                  temp = i;
                  break;
             }
         }
     // temp = i;
         if (num < 4)
         {
              temp = num;
         }
    
         printf("除留余数法取得的mod值为:%d\n", temp);
    
         return temp;
    }
    
    1. 哈希表解决冲突方法之 拉链法(链接法/链地址法)
      可以使用单链表或双链表, 双链表更方便删除.
      代码如下:
      相关结构:
    /*=========================================================================*\
     * #struct# *
    \*=========================================================================*/
    typedef struct HASH_NODE_S_
    {
        int data;
        struct HASH_NODE_S_ *prev;
        struct HASH_NODE_S_ *next;
    }HASH_NODE_S;
    
    typedef struct HASH_TABLE_S_
    {
         HASH_NODE_S *hash_node;
    }HASH_TABLE_S;

    创建hash-table操作(create):

    HASH_TABLE_S *create_hash_table(int len, int num)
    {
        HASH_TABLE_S *hash_table = NULL;
        int i = 0;
        int tempvalue = 0;
    
        hash_table = (HASH_TABLE_S *)malloc(len * sizeof(HASH_TABLE_S));
        if (hash_table == NULL)
        {
             printf("hash table malloc error!\n");
             exit(1);
        }
        memset(hash_table, 0, len * sizeof(HASH_TABLE_S));
    
        //还要增加用户输入数据, 重复的需要链接到后面
        printf("请输入数据:\n");
        for (i = 0; i < num; i++)
        {
            scanf("%d", &tempvalue);
            insert_element(hash_table, len, tempvalue);
        }
    
        return hash_table;
    }

    插入操作:
    先查看表中是否已经存在此元素, 不存在 插入.

    int insert_element(HASH_TABLE_S *hash_table, int hash_len, int value)
    {
        int position_num = value % hash_len;
        HASH_NODE_S *node ;
    
        if (search_element(hash_table, hash_len, value))
        {
            return 0;
        }
    
        node = (HASH_NODE_S *)malloc(sizeof(HASH_NODE_S));
        if (node == NULL)
        {
            printf("insert element malloc error!\n");
            exit(1);
        }
    
        node->data = value;
    
        if (hash_table[position_num].hash_node != NULL) //冲突了
        {
             node->next = hash_table[position_num].hash_node;
             hash_table[position_num].hash_node->prev = node;
             hash_table[position_num].hash_node = node;
             node->prev = NULL;
        }
        else
        {
            hash_table[position_num].hash_node = node;
        }
    
        return 1;
    }

    删除操作(delete):
    删除操作要注意删除元素在对应的key下的链表中的位置.(分首个/中间/最后一个三种)

    int delete_element(HASH_TABLE_S *hash_table, int mod_value, int value)
    {
         HASH_NODE_S *current_node = NULL;
         int position_key = value % mod_value;
    
         current_node = hash_table[position_key].hash_node;
         while (current_node != NULL)
         {
              if (current_node->data == value)
              {
                  //此元素的第一个元素
                  if (current_node->prev == NULL && current_node->next != NULL)
                  {
                       hash_table[position_key].hash_node = current_node->next;
                       current_node->next->prev = NULL;
                  }
                  else if (current_node->prev != NULL && current_node->next == NULL)
                  {
                       // 此元素是最后一个元素
                       current_node->prev->next = NULL;
                  }
                  else if(current_node->prev != NULL && current_node->next != NULL)
                  {
                      //此元素是中间的元素
                      current_node->prev->next = current_node->next;
                      current_node->next->prev = current_node->prev;
                  }
                  else
                  {
                       //只剩一个元素
                       hash_table[position_key].hash_node = NULL;
                  }
    
                  free(current_node);
                  printf("删除成功!\n");
                  return 1;
              }
              current_node = current_node->next;
         }
    
         printf("没有此元素!\n");
         return 0;
    
    }

    勿在浮沙筑高台.

    展开全文
  • 关于装饰器、lambda、鸭子类型、魔法函数的理解仍存困惑之处,趁周末时间温故,赶紧去自学了解下相关知识。 1.装饰器是什么:  很多初学者在接触装饰器的时候只做到了肤浅的了解它的概念、组成形态。实际上...

    关于装饰器、lambda、鸭子类型、魔法函数的理解仍存有困惑之处,趁周末有时间温故,赶紧去自学了解下相关知识。

    1.装饰器是什么:

      很多初学者在接触装饰器的时候只做到了肤浅的了解它的概念、组成形态。实际上装饰器是python学习中很难啃的大骨头,一旦涉及到具体用途以及原理,经常会把人绕晕。

      在这里,我们需要明确的一点是:装饰器并不是加速器。装饰器的作用仅仅是为了封装一个函数,使其增加原有的函数功能,却不改变其调用方式。

      而装饰器往往需要具有三大要素:1把想加入的函数C作为参数传入函数A  2.在函数A里面嵌套一个函数B,并在B函数里面调用函数C  3.在函数A里面把函数B作为返回值返回

      具体结构:      def A(C):

              def B():

                C()

              return  B

     

               @A

             def foo():

              cdsvhoush

             foo()

      像这样直接调用foo函数,实际上就是把foo作为参数传入了装饰函数A中,实现函数功能更好的复用。而把函数作为参数使用是python特有的一种用法。

    2.在类中使用装饰器:

      装饰器不仅可以是函数,还可以是类,相比函数装饰器,类装饰器具有灵活度大、高内聚、封装性等优点。

      。。。

    3.有关lambda函数的用法

      lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

      lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。

     

           如下,是lambda函数中的一个常见用法。先忽略下一行不看,光看上一行是不是觉得难以理解?其实,lambda只是一个表达式,函数体比define简单很多。下一行用刚刚命名的f来调用lambda的时候,是不是现在就觉得亲切不少?

           

     

    lambda x,y:x-y   ————lambda后面的内容是输入值,:后的含义是进行的运算规则及返回值。 lambda是可以赋值给一个变量的

     

     

    4. 将lambda函数作为参数传递给其他函数。(注:lambda的常见高能用法,以下是本人在CSDN上摘抄大佬所整理的部分)

      部分Python内置函数接收函数作为参数。典型的此类内置函数有这些。

        (1)filter函数。此时lambda函数用于指定过滤列表元素的条件。例如filter(lambda x: x % 3 == 0, [1, 2, 3])指定将列表[1,2,3]中能够被3整除的元素过滤出来,其结果是[3]。

        (2)sorted函数。此时lambda函数用于指定对列表中所有元素进行排序的准则。例如sorted([1, 2, 3, 4, 5, 6, 7, 8, 9], key=lambda x: abs(5-x))将列表[1, 2, 3, 4, 5, 6, 7, 8, 9]按照元素与5距离从小到大进行排序,其结果是[5, 4, 6, 3, 7, 2, 8, 1, 9]。

    ##我们做过的学生信息查询系统的排序功能时就用到了sorted方法,里面就调用了lambda函数!!

        (3)map函数。此时lambda函数用于指定对列表中每一个元素的共同操作。例如map(lambda x: x+1, [1, 2,3])将列表[1, 2, 3]中的元素分别加1,其结果[2, 3, 4]。

        (4)reduce函数。此时lambda函数用于指定列表中两两相邻元素的结合条件。例如reduce(lambda a, b: '{}, {}'.format(a, b), [1, 2, 3, 4, 5, 6, 7, 8, 9])将列表 [1, 2, 3, 4, 5, 6, 7, 8, 9]中的元素从左往右两两以逗号分隔的字符的形式依次结合起来,其结果是'1, 2, 3, 4, 5, 6, 7, 8, 9'。

    5.鸭子类型 :

      首先,让我们先回顾一下多态是什么:

      当同一个变量在调用同一个方法时,完全可能呈现出多种行为(具体呈现出哪种行为由该变量所引用的对象来决定),这就是所谓的多态(Polymorphism)。

      “鸭子类型”的语言是这么推断的:一只鸟走起来像鸭子、游起泳来像鸭子、叫起来也像鸭子,那它就可以被当做鸭子。也就是说,它不关注对象的类型,而是关注对象具有的行为(方法)。 

      魔法函数:

      先来介绍几个python常用魔法函数。

      1、__init__():

    所有类的超类object,有一个默认包含pass的__init__()实现,这个函数会在对象初始化的时候调用,我们可以选择实现,也可以选择不实现,一般建议是实现的,不实现对象属性就不会被初始化,虽然我们仍然可以对其进行赋值

      2、__str__():

    直接打印对象的实现方法,__str__是被print函数调用的,一般都是return一个什么东西,这个东西应该是以字符串的形式表现的。如果不是要用str()函数转换,我们可以直接print的对象都是实现了__str__这个方法的,比如dict

      3、__new__():

    在object类中存在一个静态的__new__(cls, *args, **kwargs)方法,该方法需要传递一个参数cls,cls表示需要实例化的类,此参数在实例化时由Python解释器自动提供,__new__方法必须有返回值,且返回的是被实例化的实例,只有在该实例返回后才会调用__init__来进行初始化,初始化所用的实例就是__new__返回的结果,也就可以认为是self。

      4、__hasattr__(对象,“字符串”):

    判断对象中是否存在字符串中名字的方法,返回值为False或True。

      5、__getattr__(对象,“字符串”):

    得到对象中对应字符串中名字的方法(前提是经上述hasattr判断,要先存在这样的方法,才可得到)

      6、__setattr__(对象,“字符串”,。。):

    把对象的属性值赋给a = __setattr__(...,...,...)

     


     

      好,现在知识点回顾完毕,现在是第三周的编程刚刚结束,说一下我近期的感受吧。

      刚学完基础语法的时候,发现解决每个问题的难点都在于:把之前固有的解决问题的思路转化为编程语言来描述。也许这是每个初学一门语言的人都要经历的过程,但后来我发现,知识都是死的,但具体怎么解决,是要靠强大的逻辑去支撑的。还有就是,要学会经常复盘。对于做过的每道题题,解决的每个项目,当时觉得做出来很轻松,但当敲过更多的代码,学过更多的知识过后,你需要去思考:我还可以有更好的办法让这个程序代码行数更少。在学完面向对象以后,我个人的强大感受是:整个世界的运转都离不开类和对象。每个实例的不同表现形式是面向对象的多态性、子类就是父类、但是子类可以实现自己定义的多种功能...更神奇的还有,如何把之前做过的每道题用“类和对象”的思路去完成。其实,处理一个问题、或者是大的项目,难点就在于其设计思路的复杂、多样性。解决一个问题之前,应该首先思考的是它的数据存放类型、数据处理模型,一定要首先先思考它的可行性,再去进一步搭框架(不然的话世界上就没那么多程序员想揍产品经理了),之前在做数独这个项目的时候,说句实话我的大脑一片空白。直到老师指导我,细化的告诉我这些数据该怎么存放,具体程序执行的大致流程,我的思路才清晰了一些,才得以独立完成这个项目。

      俗话说,师傅领进门,修行在个人,别人只能帮你解决一个小bug,不可能一直帮你。如何做到活学活用,则要看你敲过的代码行数、你解决过的问题、你自己实现出来的每个项目。当然,积累的越多,收获越大。如何打破自己原有的世界观,进入新的代码天地,需要走上一阵子了。

      实现很容易,设计可一点儿都不简单,因为只有实现过的人才懂得如何去设计,以及这样做可不可以。所以我的建议是,对于初学者,不要每道题解不出就哭爹喊娘不干了,一定要坚持独立思考这个过程,直到实在想不出再去求助别人,不为别的,只有这样做才会有效果。世界上绝大多数难题都是举一反三,老话说,就是“照葫芦画瓢”。同样的南墙,先撞一次,下次再遇到就是老朋友了。我无法描述独立解决一道问题的快感,我只知道,看不见报错提示、也没有逻辑错误的程序跑出来的那一瞬间,我坐在电脑前的5个小时、8个小时、甚至15个小时都值得,仅仅因为:这些知识已经变成我的武器了

      最后一句话送给像娜娜酱1999一样迷茫的人:学而不思则罔,思而不学则殆。最坏的结果不过是大器晚成。❤

      (整理不易,请各位客官点个赞再走呗(#^.^#))

     

    转载于:https://www.cnblogs.com/wmnn/p/11296190.html

    展开全文
  • 14、 static有什么用途?(请至少说明两种) 答: (1)在函数体,一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 (2) 在模块内(但在函数体外),一个被声明为静态的变量可以被模块内所用函数访问,但不能...
  • 常见问题 商业企划书的用途什么 9.4 制作新产品项目进度方案 专家点拨 商务用餐礼仪 chapter 10公司会议安排与会议室使用用管理 10.1 会议室使用预约 10.1.1 导入会议室使用预约表模板 10.1.2 用颜色标出会议室...
  • 可是一大堆的概念和术语往往让人望而生畏,很多朋友问我:XML到底有什么用,我们是否需要学习它?我想就我个人学习过程的心得和经验,写一篇比较全面的介绍文章。首先有两点是需要肯定的:  第一:XML肯定是未来的...
  • 有什么限制? 7 2、Java有没有goto? 8 3、说说&和&&的区别。 8 4、在JAVA中如何跳出当前的多重嵌套循环? 8 5、switch语句能否作用在byte上,能否作用在long上,能否作用在String上? 9 6、short s1 = 1; s1 = s1 + 1...
  • oracle decode用法

    2012-10-15 18:01:05
    最近工作一直在接触Oracle数据库,经常需要写一些Oracle SQL语句,经过学习和实际使用,发现在Oracle里面有一个...DECODE有什么用途呢? 先构造一个例子,假设我们想给智星职员加工资,其标准是:工资在8000元以下的将
  • 虽然并没有什么实际用途,但是作为学习插件开发感觉挺有意思的。 1. 基本思路 基本思路可以归结如下几步: 1)、通过Editor对象可以拿到封装代码编辑框的JComponent对象,即调用如下函数:JComponent component = ...
  • 1.12 关键字auto到底有什么用途? 类型定义(typedef) 1.13 对于用户定义类型,typedef和#define有什么区别? 1.14 我似乎不能成功定义一个链表。我试过typedefstruct{char*item;NODEPTRnext;}*NODEPTR;但是编译器...
  • 1.12 关键字auto到底有什么用途? 7 类型定义(typedef) 7 1.13 对于用户定义类型,typedef 和#define有什么区别? 7 1.14 我似乎不能成功定义一个链表。我试过typedef struct{char *item; NODEPTR next;}* ...
  • 1.12 关键字auto到底有什么用途? 36 类型定义(typedef) 36 1.13 对于用户定义类型,typedef 和#define有什么区别? 36 1.14 我似乎不能成功定义一个链表。我试过typedef struct{char *item; NODEPTR next;}* ...
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    1.12 关键字auto到底有什么用途? 7 类型定义(typedef) 7 1.13 对于用户定义类型,typedef 和#define有什么区别? 7 1.14 我似乎不能成功定义一个链表。我试过typedef struct{char *item; NODEPTR next;}* ...
  • 1.12 关键字auto到底有什么用途? 类型定义(typedef)  1.13 对于用户定义类型,typedef和#define有什么区别? 1.14 我似乎不能成功定义一个链表。我试过typedefstruct{char*item;NODEPTRnext;}*NODEPTR;但是...
  • 1.12 关键字auto到底有什么用途? 类型定义(typedef) 1.13 对于用户定义类型,typedef和#define有什么区别? 1.14 我似乎不能成功定义一个链表。我试过typedefstruct{char*item;NODEPTRnext;}*NODEPTR;但是...
  • 1.12 关键字auto到底有什么用途? 类型定义(typedef) 1.13 对于用户定义类型,typedef 和#define有什么区别? 1.14 我似乎不能成功定义一个链表。我试过typedef struct{char *item; NODEPTR next;}* NODEPTR; 但是...
  • 1.12 关键字auto到底有什么用途? 类型定义(typedef) 1.13 对于用户定义类型,typedef 和#define有什么区别? 1.14 我似乎不能成功定义一个链表。我试过typedef struct{char *item; NODEPTR next;}* NODEPTR; 但是...
  • 排列组合暴力生成穷举密码密码破解必破生成器密码破解小结为啥使用类-代码重用类的一般形式详解self构造函数与析构函数构造函数初始化类的属性最简洁的UI设定窗体的位置以及大小类的实际用途day15down ...
  • 责任提供适当的析构函数,定义显式复制构造函数和显式赋值操作符。本章介绍了在程序员没有提供显 式定义时,将如何隐式地生成成员函数以及这些成员函数的行为。读者还将通过使用对象指针,了解队列 模拟问题,...
  • 责任提供适当的析构函数,定义显式复制构造函数和显式赋值操作符。本章介绍了在程序员没有提供显 式定义时,将如何隐式地生成成员函数以及这些成员函数的行为。读者还将通过使用对象指针,了解队列 模拟问题,...
  • 责任提供适当的析构函数,定义显式复制构造函数和显式赋值操作符。本章介绍了在程序员没有提供显 式定义时,将如何隐式地生成成员函数以及这些成员函数的行为。读者还将通过使用对象指针,了解队列 模拟问题,...
  • o 2.5 关键字 auto 到底有什么用途? o 2.6 我似乎不能成功定义一个链表。我试过 typedef struct { char *item; NODEPTR next; } *NODEPTR; 但是编译器报了错误信息。难道在C语言中一个结构不能包含指向自己的指针...
  • 软件测试经典面试题 (超实用)

    热门讨论 2012-02-16 13:48:08
    6、你觉得bugzilla在使用的过程中,有什么问题? 5 7、描述测试用例设计的完整过程? 6 8、单元测试的策略有哪些? 6 9、LoadRunner分哪三部分? 6 10、LoadRunner进行测试的流程? 6 什么是并发?在lordrunner中,...
  • 你必须知道的495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    1.5 关键字auto 到底有什么用途? . . . . . . . . . . . . . . . . . . . 2 1.6 我似乎不能成功定义一个链表。我试过typedef struct f char *item; NODEPTR next; g *NODEPTR; 但是编译器报了错误信 息。难道在...
  • 这一章是对面向对象的程序设计(OOP)的一个综述,其中包括对“什么是对象”之类的基本问题的回答,并讲述了接口与实现、抽象与封装、消息与函数、继承与合成以及非常重要的多形性的概念。这一章会向大家提出一些...
  • 每一章都配备了练习题、自测题、实践题、本章知识点回顾和小结,从各个方面使读者对本书所内容进行充分地消化和吸收。本书是oca认证考试最权威的辅导教程,也是oracle从业人员必备的参考书。.  本书全面覆盖了oca...

空空如也

空空如也

1 2 3
收藏数 56
精华内容 22
关键字:

学函数有什么实际用途