一、内置函数
官方文档：
# 匿名函数f=lambda a,b:a+bprint(f(2,3)) # 5# abs() 取绝对值print(abs(-111)) # 111# all() 循环可迭代对象的每个元素，都为真则返回True，否则返回假# 0，None ，"",[],(),{} 是假的print(all([11,22])) # True# any 有一个为真，全部都为真print(any([0,0,None])) #False# ascii 在对象类中找 __repr__，获取返回值class D(): def __repr__(self): return 'hello'd=D()print(ascii(d)) #hello# bin 将十进制转换成2进制# oct() hex()print(bin(11)) #0b1011#各种进制转换成十进制可以用int()print(int('11',base=2)) #将二进制'11'转换成十进制数 3# bytearry 字节列表# chr() 找到数字对于的ascii码# ord() ascii码对应的数字# chr ord 只适用于ascii码print(chr(65)) # Aprint(ord('A')) # 65# callable 后面加个括号是看否能执行#complie() 接受一个字符串，将其转换成函数代码# divmod 返回除法的（值，余数）print(divmod(10,3)) #(3,1)# eval 计算器的功能 返回结果print(eval('a+60',{ 'a':90})) # 150print(eval('3+4*6/7+((1+2)-5)')) # 4.428571428571429#exec,执行python代码,没有返回值exec("for i in range(5):print(i)") # 直接循环输出0，1，2，3，4# filter(函数，可迭代的对象）# 循环可以迭代的对象，传入函数中执行，如果不符合就过滤def fun(s): #定义判断一个数是否是偶数的函数 if s%2==0: return True else: return Falseret=filter(fun,[1,2,3,4,5,6,7,8])for i in ret: print(i) # 打印出2，4，6，8#用匿名函数改写一下ret1=filter(lambda x:x%2==0,[1,2,3,4,5,6,7,8])for i in ret1: print(i) # 2,4,6,8#map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回ret=map(lambda x:x+100,[1,2,3])for i in ret: print(i) # 101,102,103# globals() 获取当前文件的所有全局变量# locals() 获取当前文件的所有局部变量# hash() 获取哈希值# isinstance 看某个对象是不是某个类创建的#iter() 创建一个可以被迭代的对象 next()取下一个值k=iter([1,2,3,4])print(next(k)) # 1# pow() 求指数print(pow(2,10)) #1024# round() 四舍五入# #zipl1=[1,2,3,4]l2=['a','b','c','d']k=zip(l1,l2)for i in k: print(i) #打印出(1,a),(2,b).... """匿名函数:与有名函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字,但是让其有名字就没有意义有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能匿名函数：一次性使用，随时随时定义应用：max，min，sorted,map,reduce,filter"""def func(x,y,z=1): return x+y+zlambda x,y,z=1:x+y+zfunc=lambda x,y,z=1:x+y+z #让其有名字就没有意义func(1,2,3)
"""三元表达式：格式： res=值1 if 条件 else 值2"""name = "tom"res = "是 tom" if name == "tom" else "不是tom"print(res) #是 tom
"""列表推导式：优点：方便，改变了编程习惯，可称之为声明式编程"""lis_gen = [ i for i in range(1,10)] #列表推导式 通过计算生成一个列表print(lis_gen) #[1, 2, 3, 4, 5, 6, 7, 8, 9]lis1_gen = [i for i in range(1,10) if i%2 == 0] #生成一个偶数的列表print(lis1_gen) #[2, 4, 6, 8]lis2_gen = [ i * i for i in range(1,10) if i%2 == 1] #生成以个奇数乘自已本身奇数的列表print(lis2_gen) #[1, 9, 25, 49, 81]
#推导式的套路"""variable = [out_exp_res for out_exp in input_list if out_exp == 2] out_exp_res: 列表生成元素表达式，可以是有返回值的函数。 for out_exp in input_list： 迭代input_list将out_exp传入out_exp_res表达式中。 if out_exp == 2： 根据条件过滤哪些值可以。"""#列表推导式#例一：30以内所有能被3整除的数multiples = [i for i in range(30) if i % 3 is 0]print(multiples) # [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]#例二：30以内所有能被3整除的数的平方def squared(x): return x*xmultiples = [squared(i) for i in range(30) if i % 3 is 0]print(multiples) #[0, 9, 36, 81, 144, 225, 324, 441, 576, 729]#字典推导式mcase = { 'a': 10, 'b': 34}mcase_frequency = {mcase[k]: k for k in mcase}print(mcase_frequency,type(mcase_frequency)) #{34: 'b', 10: 'a'} #集合推导式squared = {x**2 for x in [1, -1, 2]}print(squared) #{1, 4}#求(x,y)其中x是0-5之间的偶数，y是0-5之间的奇数组成的元祖列表print([(x,y) for x in range(5) if x%2==0 for y in range(5) if y %2==1]) #[(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]#求M中3,6,9组成的列表M = [[1,2,3],[4,5,6],[7,8,9]]M = [[1,2,3],[4,5,6],[7,8,9]]print([row[2] for row in M]) #[3, 6, 9]##########################################def func():passprint(callable(func)) # True 判断一个变量是否可以调用 函数可以被调用print(dir(123)) #返回值是列表 # 查看数字类型中含有哪些方法print(eval('1+2-3*4/5')) # 0.6000000000000001 执行字符串数据类型的代码并且将值返回exec('print(123)') #123 执行字符串数据类型的代码但没有返回值##################"""zip函数接收一个或多个可迭代对象作为参数，最后返回一个迭代器：zip(x, y) 会生成一个可返回元组 (m, n) 的迭代器，其中m来自x，n来自y。一旦其中某个序列迭代结束，迭代就宣告结束。 因此迭代长度跟参数中最短的那个序列长度一致。"""x = [1, 3, 5, 7, 9]y = [2, 4, 6, 8]for m, n in zip(x, y): print(m,n)"""1 23 45 67 8"""#如果上面不是你想要的效果，那么你还可以使用 itertools.zip_longest() 函数来代替这个例子中的zip。from itertools import zip_longestx = [1, 3, 5, 7, 9]y = [2, 4, 6, 8]for m, n in zip_longest(x, y): print(m,n)"""1 23 45 67 89 None"""keys = ["name", "age", "salary"]values = ["Andy", 18, 50]print(dict(zip(keys, values))) #{'name': 'Andy', 'salary': 50, 'age': 18}print(list(zip(keys, values))) #[('name', 'Andy'), ('age', 18), ('salary', 50)]print(tuple(zip(keys, values))) #(('name', 'Andy'), ('age', 18), ('salary', 50))print(set(zip(keys, values))) #{('age', 18), ('salary', 50), ('name', 'Andy')} """eval与exec语法： eval(str,[,globasl[,locals]]) exec(str,[,globasl[,locals]])"""#示例1：s='1+2+3'print(eval(s)) #eval用来执行表达式，并返回表达式执行的结果 返回6print(exec(s)) #exec用来执行语句，不会返回任何值，也就是返回None#示例2：dic = "{'x':3}"print(eval(dic),type(eval(dic))) #{'x': 3} print(exec(dic),type(exec(dic))) #返回None # print(eval('for i in range(10):print(i)')) #语法错误，eval不能执行表达式print(exec('for i in range(3):print(i)'))"""012None""" salaries = { 'tom': 3000, 'jack': 122121221, 'rose': 100,}k_and_v = zip(salaries.values(), salaries.keys())print(k_and_v) # print(max(k_and_v)) # (122121221, 'jack')#k_and_v是迭代器，因而只能访问一次# print(min(k_and_v)) #报错了k_and_v2 = zip(salaries.values(), salaries.keys())# print(list(k_and_v2)) # [(3000, 'tom'), (122121221, 'jack'), (100, 'rose')]# print(list(zip(k_and_v2))) #[((3000, 'tom'),), ((122121221, 'jack'),), ((100, 'rose'),)]# print(list(zip(*k_and_v2))) #[(3000, 122121221, 100), ('tom', 'jack', 'rose')]print(list(map(list, zip(*k_and_v2)))) #[[3000, 122121221, 100], ['tom', 'jack', 'rose']] max/min
- max函数处理的是可迭代对象，相当于一个for循环取出每一个元素进行比较
- 注意：不同类型之间不能进行比较
- 每一个元素间进行比较，是从每一个元素的第一个位置依次比较，如果这一个位置分出大小，后面的都不需要比较了，直接得出这两元素的大小
"""max min字典的运算：最小值，最大值，排序迭代字典，取得是key，因而比较的是key的最大和最小值"""salaries={ 'tom':3000, 'jack':122121221, 'rose':100,}#比较的是keyprint(max(salaries)) #tomprint(min(salaries)) #jack#比较的是valuesprint(max(salaries.values())) #122121221print(min(salaries.values())) #100#即要key也要valueprint(max(zip(salaries.values(),salaries.keys()))) #(122121221, 'jack')print(max(salaries)) #jackpeople=[ { 'name':'tom','age':12}, { 'name':'rose','age':50}, { 'name':'jack','age':99},]print('===',max(people,key=lambda dic:dic['age'])) #=== {'age': 99, 'name': 'jack'} 
二、高阶函数
函数作为参数传入或者return返回一个函数，满足其中一个条件，这样的函数就称为高阶函数。
1、map函数(映射)
map函数接受两个参数，一个是函数，一个可迭代的对象(iterable),map将传入的函数依次作用到序列的每个元素，并把结果作为新的 可迭代的对象 的结果返回
number = [1,2,3,4,5,6]#1.用普通函数定义方法def add_one(x): return x+1def map_test(func,arrey): res = [] for i in arrey: i = func(i) res.append(i) return resprint(map_test(add_one,number)) #[2, 3, 4, 5, 6, 7]#2.用lambda函数定义的得到结果，借助1定义的map_test函数print(map_test(lambda x:x+1,number)) #[2, 3, 4, 5, 6, 7]#3.用map()本身函数去定义print(map(lambda x:x+1 ,number)) #
2、filter函数(过滤)
filter()函数用于过滤序列和map()类似，filter()也接受一个函数和一个可迭代的对象(iterable)，不同的是fillter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
# 把列表中空字符串，空元素，都去掉aa = ['A', '', 'B', None, 'C', ' ']#1.自定义函数测试def not_empty(s): return s and s.strip()def filter_test(func,iter): res = [] for i in iter: i = func(i) if i: res.append(i) return resprint(filter_test(not_empty,aa)) #['A', 'B', 'C']#2.用lambda函数定义的得到结果print(filter_test(lambda s:s and s.strip(),aa)) #['A', 'B', 'C']#3.filter内置函数测试print(filter(not_empty,aa))#print(list(filter(not_empty,aa)))#['A', 'B', 'C']#注：filter()函数返回的是一个iterator，内存地址，需要看内存地址的值， 用list()函数或得该地址的值
3、reduce函数
reduce(function, sequence, initial=None) 在python2可以直接用reduce()函数，在python3需要导入reduce模块 from functools import reduce reduce函数，将function作用sequence序列的元素，每次携带一对(先前的结果以及下一序列的元素)，得到一个最终结果的返回值
from functools import reduce#使用reduce()，结合lambda()number1 = [2, 3, 4, 10]print(reduce(lambda x, y: x * y, number1)) # 240# 1.普通函数定义def mul(x, y): return x * y # 返回得到两个数相乘的结果def reduce_test(func, seq, init=None): if init is None: res = seq.pop(0) # seq删除第一个元素，并获取删除这个元素 赋值给res else: res = init for i in seq: res = func(res, i) # 循环一次，执行func这个函数 return resprint(number1) #[2, 3, 4, 10]print(reduce_test(mul, number1)) # 240print(number1) #[3, 4, 10]print(reduce_test(mul, number1, 10)) # 2400print(number1) #[3, 4, 10]# 2.lambda函数，借助reduce_test()函数定义print(reduce_test(lambda x, y: x * y, number1, init=3)) # 720print(number1) #[3, 4, 10]
4、sorted函数
sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序,key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。
# _*_coding:utf-8_*_#sortedprint(sorted([36, 5, -12, 9, -21], key=abs))#[5, 9, -12, -21, 36]print(sorted([36, 5, -12, 9, -21], key=abs, reverse=True)) #reverse=True 倒序#[36, -21, -12, 9, 5]#成绩从高到底排序li = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]print(sorted(li, key=lambda x: x[1], reverse=True))#[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]#以列表中每个元素的第二个字母倒序排序li = ['alex', 'egon', 'smith', 'pizza', 'alen']print(sorted(li, key=lambda x: x[1], reverse=True))#mapname=['alex','wupeiqi','yuanhao','egon']def nb(x): return x+'_nb'res = map(nb,name)print(list(res)) #['alex_nb', 'wupeiqi_nb', 'yuanhao_nb', 'nezha_nb']#用filter函数处理数字列表，将列表中所有的偶数筛选出来num = [1,3,5,6,7,8]def func(x): if x%2 == 0: return Trueret = filter(func,num)print(list(ret)) #[6, 8]#用filter过滤出，单价大于100的股票有哪些portfolio = [{ 'name': 'IBM', 'shares': 100, 'price': 91.1},{ 'name': 'AAPL', 'shares': 50, 'price': 543.22},{ 'name': 'FB', 'shares': 200, 'price': 21.09},{ 'name': 'HPQ', 'shares': 35, 'price': 31.75},{ 'name': 'YHOO', 'shares': 45, 'price': 16.35},{ 'name': 'ACME', 'shares': 75, 'price': 115.65}]f = filter(lambda d:d['price']>=100,portfolio)print(list(f))