day13——重要内置函数、匿名函数、闭包
day13
内置函数2
重要的
abs（）：求绝对值——返回的都是正数
# lst = [-1,-2,-3]
# for i in lst:
# print(abs(i))
# print([abs(i) for i in lst])
# s = -123
# print(abs(s))
enumerate（'可迭代对象'，'序号的起始值'）：枚举，默认的起始值是0
# lst = [-1, -2, -3]
# print([i for i in enumerate([abs(i) for i in lst])])
# lst = [11, 2, 3, 4, 5, 6, 7]
# new_lst = []
# for i in enumerate(lst):
# new_lst.append(i)
# print(new_lst)
# print([i for i in enumerate(lst,1000)])
max（'可迭代对象',key = abs）：求最大值，比的是当前编码集的值
# lst = [11, 2, 3, 4, 5, 6, 7,1231,2131]
# print(max(lst))
min（'可迭代对象',key = abs）：取最小值
# lst = [11, 2, 3, 4, 5, 6, 7,1231,2131]
# print(min(lst))
sum（[1,2,3,4,5],100（前面总数加这个数））：求和
# lst = [11, 2]
# print(sum(lst,100)) # 结果是113
print(sep=‘ ’，end=‘\n’) sep多个元素的连接符
# print(sep=' ', end='\n') # 默认
# print(1,2,3,sep='$')
# print(1,2,3,end='%')
# print(4,5)
range（）
# python3:
# g = range(0,10) # 可迭代对象
# g.__iter__()
# python2:
# range(0,10) # 获取是一个列表
# xrange(0,10) # 获取是一个可迭代对象
---------------------------------------------------------
# from collections import Iterable,Iterator
# print(isinstance(g,Iterable))# 判断是否是可迭代对象
# print(isinstance(g,Iterator))# 判断是否是迭代器
open()：写入文件
# print(12345,file=open("t1.txt","w",encoding="utf-8"))
list()
# print(list('alex')) # 结果是['a', 'l', 'e', 'x']
dict()
# print(dict(key=1,a='alex'))
# print(dict(((1,2),(2,3),(3,4))))
# print(dict([i for i in enumerate(range(20),1)]))
zip（'可迭代对象','可迭代对象'）：拉链，按照最少的进行合并
# lst1 = [1,2,3,4,5]
# lst2 = ['a',"b","c","d","f","e"]
# print(dict(list(zip(lst1,lst2))))
# print(dict(zip(lst1,lst2)))
dir（）：查看当前函数的方法
# print(dir(list)) # 查看当前函数的方法
匿名函数——一行函数
f = lambda x,y:x+y
print(f(1,2))
f = lambda x,y:(x,y)
print(f(1,2)) # 结果为元组
print((lambda x:x)(2))# 同一行定义 同一行调用
匿名函数的名字就是lambda
lambda 关键字——定义函数
x,y：形参——可以不写
x+y：返回值（必须写，可以写None）——只能返回一个数据类型
# f = lambda x,y:x+y
# print(f(1,2))
# print((lambda x,y:x+y)(1,2))
# print(type((lambda x,y:(x,y))(1,2)))
---------------------------------------------------------
# f = lambda x,y:x+y
# print(f(1,2))
# print(f.__name__)
# print((lambda x:x)(2))
---------------------------------------------------------
# lst = [lambda i:i*i for i in range(10)]
# print(lst[2](20))
# lst = []
# for i in range(10):
# def func(i):
# return i*i
# lst.append(func)
# print(lst[2](20))
---------------------------------------------------------
# lst = [lambda :i*i for i in range(10)]
# print(lst[2]())
# lst = []
# for i in range(10):
# def func():
# return i*i
# lst.append(func)
# print(lst[2]())
---------------------------------------------------------
# lst = list((lambda i:i*i for i in range(5)))
# print(lst[1](55))
# lst = [x for x in (lambda :i**i for i in range(5))]
# print(lst[2]())
---------------------------------------------------------
# lst = []
# def func():
# for i in range(5):
# def foo():
# return i**i
# yield foo
# for x in func():
# print(x)
# lst.append(x)
# print((lst[2]()))
最重要的内置函数（面试比较重要的）
format（）函数
format（13，>20）：右对齐（不常用）
format（13，<20）：左对齐（不常用）
format（13，^20）：居中（不常用）
format（13，'08b'）：转换成二进制——08（可有可无）
format（13，'08d'）：转换成十进制——08（可有可无）
format（13，'08o'）：转换成八进制——08（可有可无）
format（13，'08x'）：转换成十六进制——08（可有可无）
# print(format(13,">20")) # 右对齐
# print(format(13,"<20")) # 左对齐
# print(format(13,"^20")) # 居中
------------------------------------
# print(format(13,"08b")) # 2
# print(format(13,"08d")) # 10
# print(format(13,"08o")) # 8
# print(format(12,"08x")) # 16
filter（）：过滤
filter（'函数'，'可迭代对象'）
写函数的时候可以指定过滤条件
# lst = [1,2,3,4,5,8,5,6,76,7,7]
# def func(s):
# return s > 3
# print(list(filter(func,lst)))
# func就是自己定义一个过滤条件,lst要迭代的对象
# print(list(filter(lambda s:s>3 ,lst)))
map（）：对象映射
map（'函数'，'可迭代对象'）
对可迭代对象中每个元素进行加工
# lst = [1,2,3,4,5]
# def func(s):
# return s*s
# mp = map(func,lst)
# print(mp)
# print(list(mp))
--------------------------------------
# print(list(map(lambda s:s*s,lst)))
reversed（）：翻转
对可迭代对象进行翻转
支持所有可迭代对象（有序），原数据不变
# lst = [1,2,3,4,5]
# lst1 = list(reversed(lst))
# print(lst)
# print(lst1)
sorted（）：排序
sorted（'可迭代对象',key='函数名'，reverse = True）
key是指定排序的规则
# lst = [1,23,34,4,5,213,123,41,12,32,1]
# print(sorted(lst)) # 升序
# print(lst)
# print(sorted((lst),reverse=True)) # 降序
# dic = {"key":1,"key1":78,"key3":56}
# print(sorted(dic,key=lambda x:dic[x],reverse=True))
不用加list（），默认升序，加了reverse = True变成降序，原数据不变
reduce：累计算
reduce('函数'，'可迭代对象')
# from functools import reduce
# print(reduce(lambda x,y:x-y,[1,2,3,4,5]))
高阶函数（有key）：sorted、filter、map、max、min、reduce
闭包
-
闭包：在嵌套函数内，使用非全局变量（且不是本层变量）就是闭包
-
闭包的作用：
保证数据的安全性
装饰器的本质
-
验证是否是闭包：closure
了解:
# print(ret.__code__.co_freevars) # 获取的是自由变量
# print(ret.__code__.co_varnames) # 获取的是局部变量
# def func():
# a = 1
# def f1():
# def foo():
# print(a)
# return foo
# return f1
# ret = func()
# a = ret()
# a()
# func()()()
---------------------------------------------------------
# avg_lst = []
# def func(pirce):
# avg_lst.append(pirce)
# avg = sum(avg_lst) / len(avg_lst)
# return avg
# print(func(150000))
# print(func(160000))
# print(func(170000))
# print(func(150000))
# print(func(150000))
---------------------------------------------------------
# def func():
# avg_lst = []
# def foo(pirce):
# avg_lst.append(pirce)
# avg = sum(avg_lst) / len(avg_lst)
# return avg
# return foo
# ret = func()
# print(ret(150000))
# print(ret(160000))
# print(ret(170000))
# print(ret(150000))
# print(ret(180000))
# print(ret.__closure__) # (<cell at 0x0030F150: list object at 0x002B35A8>,)
