重要函数总结

五星方法如下：
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='
', 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'xe5xb0x8fxe6x98x8e'

解码decode():
s2 = b1.decode('utf-8')
print(s2)   # 小明

用bytes()方法编码(单向)
a1 = '小白'
b1 = bytes(a1,encoding='utf-8')
print(b1)    # b'xe5xb0x8fxe7x99xbd'

不能用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) (商，余数)