五星方法如下：
key : min max sorted
function :filter map
normal: reversed zip zip_longest globals locals print sum repr reduce
四星方法：
bytes abs divmod
1、min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。 *****
print(min([1,-2,3,4,100,101])) # -2
print(min([1,-2,3,4,100,101],key=abs)) # 1
应用：
求出年龄最小的那个元组
ls = [('daming',1000),('xiaoming',18),('zhongming',500)]
# 这里的数据还不算复杂，可用之前学过的知识求出
min_age = min([i[1] for i in ls])
for j in ls:
if j[1] == min_age:
print(j)
但是有时候数据复杂的情况下，用之前的知识写，可能会很复杂。
这时可用min()方法，配合自定制的函数进行求值
def func(x):
return x[1] # 1000 18 500
print(min(ls,key=func))
结果：('xiaoming', 18)
min(可迭代对象,key=函数名)：
1,它会将iterable的每一个元素当做函数的参数传进去。
2,它会按照返回值去比较大小。
3,最后返回的是遍历的元素 x
dic = {'a':3,'b':2,'c':1}
def func1(x):
return dic[x]
print(min(dic,key=func1))
结果：c
# 这里传进去的元素是字典的键，比较的返回值是字典的值，最后返回的是遍历的键
def func2(x):
return x[1]
print(min(dic.items(),key=func2))
结果：('c', 1)
# 这里传进去的元素是字典的键和值组成的元组，比较的返回值是字典的值，最后返回的是遍历的元组
2、max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。 *****
print(max([1,2,3,100])) # 100
3、sorted：对所有可迭代的对象进行排序操作。 *****
与列表的sort区分：
列表的sort方法是对原列表进行排序修改，并没有生成新的列表
内置函数sorted方法会形成一个新列表
l1 = [2,3,5,3,1,9,8,6]
l1.sort()
print(l1)
print(sorted(l1)) # 形成了一个新列表
print(l1) # 原列表不变
内置函数sorted还可以与函数结合使用
l2 = [(1,1000),(2,18),(4,250),(3,500)]
def func1(x):
return x[1]
print(sorted(l2,key=func1))
#按第二个元素升序排序 [(2, 18), (4, 250), (3, 500), (1, 1000)]
print(sorted(l2,key=func1,reverse=True))
#按第二个元素降序排序 [(1, 1000), (3, 500), (4, 250), (2, 18)]
4、filter：过滤，通过你的函数，过滤一个可迭代对象(类似于生成器表达式的筛选模式) 生成一个迭代器。 *****
l1 = [1,2,3,4,5,6]
def fun(x):
return x % 2 == 0 #筛选出偶数
g = filter(fun,l1) # filter(fun,l1)生成的是一个迭代器
print(g)
for i in g:
print(i)
结果：
2 4 6
l2 = [(2,1),(3,4),(4,5)]
def fun2(x):
return x[1] % 2 == 1 #筛选出第二个元素为奇数的元组
g = filter(fun2,l2)
for i in g:
print(i)
结果：
(2, 1)
(4, 5)
5、map:会根据提供的函数对指定序列做映射。(循环修改并返回) 生成一个迭代器*****
l1 = [1,2,3,4,5,6]
def fun(x):
return x**2 #返回每个元素的平方
g = map(fun,l1)
for i in g:
print(i)
结果：1 4 9 16 25 36
(min max sorted filter返回的都是遍历的参数，map返回的是return的值)
6、reversed：将一个序列翻转，并返回此翻转序列的迭代器。 *****
6-1、reversed()与列表的reverse()区分：
列表的reverse()只能列表使用：列表.reverse()，对原列表进行翻转，结果返回的还是列表。
内置函数reversed()，将一个序列翻转，结果是返回一个迭代器。
列表的reverse()
l1 = [1,3,4,2,6]
l1.reverse() #将列表进行翻转
print(l1) #返回修改后的列表 [6, 2, 4, 3, 1]
内置函数reversed()
reversed(l1) #生成一个迭代器
print(reversed(l1)) #一个地址
for i in reversed(l1):
print(i)
结果：
用for循环输出迭代器的值
6 2 4 3 1
字符串使用reversed()
s1 = 'abcdefg'
for i in reversed(s1):
print(i)
结果：
g f e d c b a
字典使用reversed() 报错
dic = {'name':'xiaoming','age':1000,'hobby':'oldwomen'} # 不行
7、拉链方法：zip() 将多个iter纵向组成元素为元组的迭代器，默认以长度最小的iterable为标准长度 *****
l1 = [1,2,3,4]
tu1 = ('a','b','c')
dic = {'name':'xiaoming','age':18,'hobby':'girl','hometown':'guangzhou'}
zip(l1,tu1,dic) #迭代器(生成器对象)
print(zip(l1,tu1,dic)) #迭代器地址：<zip object at 0x000002C878E6A6C8>
for i in zip(l1,tu1,dic):
print(i)
#循环输出迭代器的内容：
(1, 'a', 'name')
(2, 'b', 'age')
(3, 'c', 'hobby')
# 若想以最大的iterable为标准长度，则可以使用itertools.zip_longest()
from itertools import zip_longest
x = [1, 3, 5, 7, 9]
y = [2, 4, 6, 8]
for i in zip_longest(x, y):
print(i)
(1, 2)
(3, 4)
(5, 6)
(7, 8)
(9, None)
8、
globals() :返回一个字典(包含全部的全局变量)
locals() ： 返回一个字典(包含的是当前作用域的所有变量)
b = 2
a = 3
print(globals())
print(locals())
结果：
这两个结果一样，因为都是在全局执行的。
def fun():
a = 3
b = 2
print(globals())
print(locals())
fun()
结果：
globals():
{'__name__': '__main__', '__doc__': None, '__package__': None,
'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000228CB787748>,
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
'__file__': 'E:/OldBoy/Knight/PythonProject/day13/t2.py', '__cached__': None, 'b': 2, 'a': 3,
'fun': <function fun at 0x00000228CB351E18>}
locals():{'b': 2, 'a': 3}
9、print
print的参数分析：print(self, *args, sep=' ', end='\n', file=None)
1,*args：可接收多个位置参数
2,sep:打印多个值之间的分隔符，默认为空格
3,end:每一次打印的结尾，默认为换行符
4,file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
print(1,2,3,sep='|') # 1|2|3
print(1,2,end=' ')
print(3,4) # 1 2 3 4
10、sum：对可迭代对象进行求和计算（可设置初始值）。 *****
sum(iterable,start_num)
print(sum([1,2,3,4,100,101])) # 211
print(sum([1,2,3,4,100,101],100)) # 311(第二个参数为初始值)
print(sum([int(i) for i in [1,'2',3,'4','100',101]]))
11、repr:返回一个对象的string形式（原形毕露） *****
print(repr('{"name":"xiaoming"}')) #'{"name":"xiaoming"}'
print('{"name":"xiaoming"}') # {"name":"xiaoming"}
格式化输出%r--->原封不动的写出来(基础数据类型都可接收)
字符串单双引号都默认是单引号
msg = 'xiaoming是%r的人' % ('德高望重')
print(msg) # xiaoming是'德高望重'的人
msg = 'xiaoming是%r的人' % ("德高望重")
print(msg) # xiaoming是'德高望重'的人
msg = 'xiaoming是%r的人' %(18)
print(msg) # xiaoming是18的人
msg = 'xiaoming是%r的人' %(True)
print(msg) # xiaoming是True的人
msg = 'xiaoming是%r的人' %({'name':'xiaming','age':18})
print(msg) # xiaoming是{'name': 'xiaming', 'age': 18}的人
repr():可用于判断json pickle序列化模块 特殊字符串，python字符串的区别
12、reduce
Python3中reduce移到了functools模块中，你可以用过from functools import reduce来使用它。
reduce同样是接收两个参数：func（函数）和seq(序列，如list)
原理：首先将序列中的前两个元素，传入func中，再将得到的结果和第三个元素一起传入func，…，
这样一直计算到最后，得到一个值，把它作为reduce的结果返回。
from functools import reduce
ret = reduce(lambda x,y:x+y, [1, 2, 3, 4])
print(ret) # 10
l = [30, 11, 77, 8, 25, 65, 4]
ret = reduce(lambda x,y: x if x > y else y, l)
print(ret) # 77
13、bytes：unicode ---> bytes类型(单向的编码) ****
编码encode():
s1 = '小明'
b1 = s1.encode('utf-8')
print(b1) # b'\xe5\xb0\x8f\xe6\x98\x8e'
解码decode():
s2 = b1.decode('utf-8')
print(s2) # 小明
用bytes()方法编码(单向)
a1 = '小白'
b1 = bytes(a1,encoding='utf-8')
print(b1) # b'\xe5\xb0\x8f\xe7\x99\xbd'
不能用bytes()方法解码
a2 = bytes(b1,encoding='utf-8')
print(a2) # 报错
只能用decode()解码
a2 = b1.decode('utf-8')
print(a2) # 小白
14、abs：函数返回数字的绝对值。 ****
print(abs(-100)) # 100
15、divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。 ****
print(divmod(12,7)) # (1, 5) (商，余数)
