匿名函数，内置函数，闭包

1.匿名函数

匿名函数只能构建简单的函数，一句话函数
def func(x,y):
    return x + y
print(func(1, 2))
匿名函数构建
func = lambda x,y: x + y
print(func(1,2))
匿名函数最经常使用的就是与内置函数结合使用

2.内置函数

1.eval 剥去字符串的外衣，返回里面的本质  =>  有值
  exce 代码流，过程
s1 = "{1: 'alex'}"
s2 = '1 + 3'
print(eval(s1))
print(eval(s2))
s3 = '''
for i in range(3):
    print(i)
'''
exec(s3)
2.hash() 哈希值
print(hash(123214134))  =>  整型值是它自己
print(hash('fkljdsaklgjdfs'))  =>  可变的值
3.help()  详细说明
print(help(str.count))
4.callable()  是否可执行  **
def a():
    pass
b = 3433
print(callable(a))
print(callable(b))
5.int  **
print(int(3.14))   取整
print(int('123'))  数据类型转换
6.print(bin(100))  将十进制转化成二进制。 **
print(oct(10))   将十进制转化成八进制字符串并返回。
print(hex(17))   将十进制转化成十六进制字符串并返回。 **
print(hex(15))       0xf
print(hex(31))   =>  0x1f
print(hex(47))       0x2f
7.divmod()  计算除数与被除数的结果，返回一个包含整除的商与余数的元祖(a//b,a%b)  =>  分页用到
8.round()   保留小数的有效位数
print(round(3.1485926,2))
9.pow(3,3,2)  =>  3**3%2
10.ord()  输入字符寻找其在unicode的位置
11.chr()  输入数字找出其对应的字符
12.repr  原形毕露
print('太白')
print(repr('太白'))
13.all()  可迭代对象元素有一个False,就返回False
   any()  可迭代对象元素有一个True,就返回True

1.sep 设定分隔符
  end 默认是换行
print(1, 2, sep='|')
print(1, 2, end=' ')
2.file 写入文件
f = open('log','w',encoding='utf-8')
f.write('写入文件')
print('写入文件', file=f)
3.list
li=list("asdf")
print(li)  =>  ["a","s","d","f"]
4.dict
建立字典的集中方式
dic={"key":"value"}
dic["key"]=value
字典推导式
dic=dict(one=1,two=2)
fromkeys("ab",1)  =>  {"a":1,"b":1}
5.abs()  取绝对值
6.sum()  数字相加求和
print(sum([1,2,3,4]))
print(sum([1, 2, 3, 4], 100))   100为起始值
*****
7.min  能够加功能
l1 = [('alex',73), ('武大',35), ('太白',18)]    #找年龄最小的元组
print(min(l1))  =>  自动比较每一个元祖的第一个元素，若是是数字比大小，若是是字符串则比较第一个字符的ASCII码
def func(x):  
     return x[1]
#min会遍历可迭代对象的元素做为实参传给x，返回值是什么就按照什么比较最小的，将该元素便是 ('太白', 18) 返回
print(min(l1,key=func))
print(min(l1,key=lambda x: x[1]))
# 练习：
dic = {'a':3,'b':2,'c':1}
# 将dic值最小的键返回。
print(min(dic,key= lambda x:dic[x]))
# 将dic值最小的值返回。
print(dic[min(dic,key= lambda x:dic[x])])

dic = {'A':['李业', 67],'b': ['怼哥', 95],'c': ['冯垚', 85]}
# 将成绩最低的从属于的那个列表返回。
print(dic[min(dic,key=lambda x:dic[x][1])])
# 将成绩最低的分数返回。
print(dic[min(dic,key=lambda x:dic[x][1])][1])
8.max  同min
9.reversed  对一个可迭代对象进行翻转，返回的是一个迭代器
s = 'alex'
for i in reversed(s):
    print(i)
10.bytes()  编码
s='太白'
编码   print(s.encode('utf-8'))
      print(bytes(s,encoding='utf-8'))
b = b'\xe5\xa4\xaa\xe7\x99\xbd'
解码   print(b.decode('utf-8'))
      print(str(b, encoding='utf-8'))
11.zip   拉链方法，返回一个迭代器
l1=[1,2,3,4]
tu=('a','b','c')
s='python23'
print(list(zip(l1,tu,s)))
12.sorted  排序
l1.sort()
print(l1)     =>      列表原有的方法
print(sorted(l1))
print(l1)     =>      sorted造成新列表
list1 = [
    {'name': 'alex', 'age': 73},
    {'name': 'wusir', 'age': 35},
    {'name': '太白', 'age': 25},
]
加key  =>  按某一元素排列
print(sorted(list1))
print(sorted(list1, key=lambda x:x['age']))               =>  默认升序
print(sorted(list1, key=lambda x:x['age'],reverse=True))  =>  reverse,降序
13.filter   生成器表达式的筛选模式，返回一个迭代器器
l1 = [56, 67, 12, 34, 78, 90,]
print([i for i in l1 if i > 60])
print(list(filter(lambda x: x>60,l1)))  =>  返回值为True的留下来

lst = [{'id':1,'name':'alex','age':50},
        {'id':1,'name':'wusir','age':17},
        {'id':1,'name':'taibai','age':16},]
print(list(filter(lambda x:x['age']<30,lst)))
14.map   生成器表达式的循环模式，生成一个迭代器
l1 = [56, 67, 12, 34, 78, 90,]
print([i**2 for i in l1])
print(list(map(lambda x:x**2,l1)))  =>  注意返回的不是参数，是值
15.from functools import reduce（reduce在python3x中 从内置函数剔除了）  求和，能够用字符串拼接
print(reduce(lambda x,y: x+y,[1,2,3,4,5]))
print(reduce(lambda x,y: 2*x+y, [1,2,3]))
print(reduce(lambda x,y: x+y, ['alex','s','b']))

3.闭包

def make_average():

    l1 = []        =>自由变量
    def average(price):
        l1.append(price)     =>闭包：闭包函数的空间不会随着函数的结束而消失，被引用的l1变量则不会消失
        total = sum(l1)
        return total/len(l1)

    return average
avg = make_average()
print(avg(100000))
print(avg(110000))
print(avg(120000))
闭包造成的条件：
1.闭包存在于嵌套函数中
2.内层函数对外层函数的全局变量引用  =>  自由变量
  （参考函数名逐层返回，直至返回到最外层）
判断一个函数是否是闭包 => 闭包函数有没有自由变量    print(avg.__code__.co_freevars)
闭包的应用：  保证数据安全，装置器的本质