补充知识点：

def func(*args):
    for i in args:
        for j in i:
            yield i
print(list(func('asdf',(1,2,3))))     #list可以将生成器中的所有元素添加到列表中。

#简化上述函数：
def func(*args):
    for i in args:
        yield from i  #优化了内层循环，提高了运行效率。

1. 匿名函数（用lambda构建）：一语句函数，比较简单的函数。形式：lambda 参数 : 返回值

   def func(a,b):
       return a+b
   
   #构建匿名函数：
   func1 = lambda a,b:a+b
   print(func1(1,2))
   

   • lambda 参数 : 返回值：lambda后直接加形参，形参加多少都可以，但一般只用位置参数，参数之间需要用”，“隔开。

   #例1：接受一个可切片的数据，以元祖形式返回索引位0与2的对应元素
   func = lambda a:(a[0],a[2])
   
   #例2：接收两个int参数，将较大的数据返回。
   func = lambda a,b:a if a>b else b
   

2. 内置函数：

   • int()：将字符串类型转换为int类型；取整（舍尾法）

   • float()：将int和str转换为float。

   • list()：将一个可迭代对象转换成列表

   • tuple()：将一个可迭代对象转换成元组

   • dict()：通过相应的方式创建字典。

   • abs()：返回绝对值

   • sum()：求和

   • reversed()：将一个序列翻转，返回翻转序列的迭代器。与列表的方法l1 .reverse()区分.

   • complex：创建一个值为real+imag*j的复数；转换一个str或int为复数，如果第一个参数为str则不需要传递第二个参数。(复数：complex)

     print(complex('1'))    #(1+0j)
     

   • bin：将十进制转换为二进制字符串并返回。

   • oct：将十进制转换为八进制字符串并返回。

   • hex：将十进制转换为十六进制字符串并返回。

   • divmod：计算除数与被除数的结果，返回一个包含商和余数的元祖（a//b,a%b)

   • round：保留浮点数的位数，默认保留整数。

   • pow：求x**y的次幂，并可以对所求结果对第三个参数取余

     print(pow(2,2))      #2**2   4
     print(pow(2,2,3))    #(2**2)%3    1  
     

   • bytes：用于不同编码之间的转换。

     s1 = '你好'
     bs1 = s1.encode('utf-8')
     print(bs1)
     #b'\xe4\xbd\xa0\xe5\xa5\xbd'
     
     s2 = bs1.decode('utf-8')
     print(s1)
     #你好
     
     s3 = '你好'
     bs2 = bytes(s3,encoding='utf-8')
     print(bs2)
     #b'\xe4\xbd\xa0\xe5\xa5\xbd'
     
     bs3 = str(bs2,encoding='utf-8')
     print(bs3)
     #你好
     

   • ord()：输入字符找该字符编码的位置。（如果在ASCII码中就用ASCII码，否则用Unicode）

   • chr()：输入位置数字找出其对应的字符。（如果在ASCII码中就用ASCII码，否则用Unicode）

   • repr()：返回一个对象的string形式。（str带有引号的形式），在格式化输出时常用（%r）。

     s1 = 'python'
     print('i love %r'%(s1))   #i love 'python'
     

   • print()：源码分析：print(self, *args, sep=' ', end='\n', file=None):
     print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
     file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
     sep: 打印多个值之间的分隔符，默认为空格
     end: 每一次打印的结尾，默认为换行符
     flush: 立即把内容输出到流文件，不作缓存

     print(1,2,3)   #1 2 3
     print(1,2,3,sep='@')   # 1@2@3
     print(1,2,3,end='')   #不换行
     

   • all()：可迭代对象中，全为True才是True。

   • any()：可迭代对象中，有一True即为True。

   • zip()： 拉链方法；函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回。

     lst1 = [1,2,3]
     lst2 = ['a','b','c','d']
     lst3 = (11,12,13,14,15)
     for i in zip(lst1,lst2,lst3):
         print(i)
     #(1, 'a', 11)  (2, 'b', 12)  (3, 'c', 13)
     

   • min()：求最小值，可以与函数结合(key：自动将可迭代对象中的每个元素按照顺序传入key对应的函数中，然后以返回值比较大小,key=一定是函数名，不能加（)，。min/max默认会按照字典的键去比较大小，但可以自己规定。

     #以绝对值的方式取最小值
     l1 = [1,2,-1,-5,3]
     def func(s):
         return abs(s)
     print(min(l1,key=func))   #1
     #也可以直接使用匿名函数：
     print(min(l1,key=lambda s:abs(s)))    #1
     
     dic = {'a':3,'b':2,'c':1}
     min(dic)   #a     默认以键排序，返回键 
     
     #以值比较：
     print(min(dic,key=lambda s:dic[s]))   #c   以值排序，返回键（返回的是循环的元素，而不是经函数转换后比较的值。
     

   • max()：求最大值，可以与函数结合,同min()。

   • sorted()：排序函数；语法: sorted(iterable,key=None,reverse=False)

     iterable: 可迭代对象

     key: 排序规则(排序函数)，返回列表。在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序

     reverse: 是否是倒叙,True：倒叙；False：正序

     lst = [1,3,2,5,4]
     lst2 = sorted(lst)
     print(lst)  # 原列表不会改变
     print(lst2)  # 返回的新列表是经过排序的
     
     lst3 = sorted(lst,reverse=True)
     print(lst3)  # 倒叙
     
     #字典使用sorted排序
     dic = {1: 'a',3: 'c',2: 'b'}
     print(sorted(dic))  #[1,2,3] 字典排序返回的就是排序后的key 
     
     
     #和函数组合使用
     # 定义一个列表,然后根据一元素的长度排序
     lst = ['1','111','11','1111']
     # 计算字符串的长度
     def func(s):
         return len(s)
     print(sorted(lst,key=func))  #['1','11','111','1111']
     
     lst = [{'id': 1,'name': 'a','age': 18},
            {'id': 2,'name': 'b','age': 17},
            {'id': 3,'name': '3','age': 16},]
     # 按照年龄对学生信息进行排序
     print(sorted(lst,key=lambda e: e['age']))
     
     #[{'id': 3,'name': 'taibai','age': 16},{'id': 2,'name': 'wusir','age': 17},{'id': 1,'name': 'alex','age': 18}]
     

   • filter()：筛选过滤，返回一个迭代器（可与列表推导式的筛选模式进行对比）；语法: filter(function,iterable)

     function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据iterable:可迭代对象

   • lst = [{'id':1,'name':'a','age':18},
             {'id':2,'name':'b','age':17},
             {'id':3,'name':'c','age':16},]
     
     ls = filter(lambda e:e['age'] > 16,lst)
     print(list(ls))
     
     #[{'id': 1, 'name': 'alex', 'age': 18},{'id': 1, 'name': 'wusir', 'age': 17}]
     

   • map()：映射函数，反悔一格迭代器（可与列表推导式的循环模式对比）；语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function。

     #例1;计算列表中每个元素的平方,返回新列表
     lst = [1,2,3,4,5]
     print(map(lambda s:s*s,lst))   #<map object at 0x000002B2A4F04B88>
     print(list(map(lambda s:s*s,lst)))
     
     #例2;计算两个列表中相同位置的数据的和
     lst1 = [1, 2, 3, 4, 5]
     lst2 = [2, 4, 6, 8, 10]
     print(list(map(lambda x, y: x+y, lst1, lst2)))
     

   • reduce()：reduce(函数名,可迭代对象) # 这两个参数必须都要有,缺一个不行

     from functools import reduce
     def func(x,y):
         return x + y
     ret = reduce(func,[1,2,3])
     print(ret)  # 结果 6
     #reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推。注意:我们放进去的可迭代对象没有更改
     
     #现在有[1,2,3,4]想让列表中的数变成1234
     from functools import reduce
     def func(x,y):
     	return x * 10 + y
     l1 = reduce(func,[1,2,3,4])
     print(l1)
     # 第一次的时候 x是1 y是2  x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了
     # 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了
     # 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了
     
     
     #进阶：使用匿名函数版
     l = reduce(lambda x,y:x*10+y,[1,2,3,4])
     print(l)
     

     在Python2.x版本中recude是直接 import就可以的, Python3.x版本中需要从functools这个包中导入。

3. 闭包：全局变量，数据不安全。使用局部变量，保证数据的安全。当内层函数对外层函数非全局变量的引用（使用）时，就会形成闭包。被引用的非全局变量也称作*变量，这个*变量会与内层函数产生一个绑定关系，令*变量不会再内存中消失。闭包现象只能存在函数的嵌套中。

   • 判断一个函数有没有*变量：

     def func1():
         l1= []
         def func2(num):
             l1.append(num)
             return l1
         return func2
     a = func1()
     # 函数名.__code__.co_freevars 查看函数的*变量
     print(a.__code__.co_freevars)  # ('l1',)
     
     # 函数名.__code__.co_varnames 查看函数的局部变量
     print(a.__code__.co_varnames)  # ('num',)
     
     # 函数名.__closure__ 获取具体的*变量对象，也就是cell对象。
     print(a.__closure__)
     #(<cell at 0x000001EE151AC738: list object at 0x000001EE135851C8>,)
     
     # cell_contents *变量具体的值
     print(a.__closure__[0].cell_contents)  # []