1、内置函数
官方文档：点击 html
# 匿名函数 f=lambda a,b:a+b print(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)) # A print(ord('A')) # 65 # callable 后面加个括号是看否能执行 #complie() 接受一个字符串，将其转换成函数代码 # divmod 返回除法的（值，余数） print(divmod(10,3)) #(3,1) # eval 计算器的功能 返回结果 print(eval('a+60',{'a':90})) # 150 print(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 False ret=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() 四舍五入 # #zip l1=[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+z lambda x,y,z=1:x+y+z func=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*x multiples = [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'} <class 'dict'> #集合推导式 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():pass print(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 2 3 4 5 6 7 8 """ #若是上面不是你想要的效果，那么你还能够使用 itertools.zip_longest() 函数来代替这个例子中的zip。 from itertools import zip_longest x = [1, 3, 5, 7, 9] y = [2, 4, 6, 8] for m, n in zip_longest(x, y): print(m,n) """ 1 2 3 4 5 6 7 8 9 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用来执行表达式，并返回表达式执行的结果 返回6 print(exec(s)) #exec用来执行语句，不会返回任何值，也就是返回None #示例2： dic = "{'x':3}" print(eval(dic),type(eval(dic))) #{'x': 3} <class 'dict'> print(exec(dic),type(exec(dic))) #返回None <class 'NoneType'> # print(eval('for i in range(10):print(i)')) #语法错误，eval不能执行表达式 print(exec('for i in range(3):print(i)')) """ 0 1 2 None """
salaries = { 'tom': 3000, 'jack': 122121221, 'rose': 100, } k_and_v = zip(salaries.values(), salaries.keys()) print(k_and_v) # <zip object at 0x0000000000C07BC8> 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, } #比较的是key print(max(salaries)) #tom print(min(salaries)) #jack #比较的是values print(max(salaries.values())) #122121221 print(min(salaries.values())) #100 #即要key也要value print(max(zip(salaries.values(),salaries.keys()))) #(122121221, 'jack') print(max(salaries)) #jack people=[ {'name':'tom','age':12}, {'name':'rose','age':50}, {'name':'jack','age':99}, ] print('===',max(people,key=lambda dic:dic['age'])) #=== {'age': 99, 'name': 'jack'}
2、高阶函数
函数做为参数传入或者return返回一个函数，知足其中一个条件，这样的函数就称为高阶函数。python
一、map函数(映射)
map函数接受两个参数，一个是函数，一个可迭代的对象(iterable),map将传入的函数依次做用到序列的每一个元素，并把结果做为新的 可迭代的对象 的结果返回编程
number = [1,2,3,4,5,6] #1.用普通函数定义方法 def add_one(x): return x+1 def map_test(func,arrey): res = [] for i in arrey: i = func(i) res.append(i) return res print(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)) #<map object at 0x00000000010EAC18> 返回一个可迭代对象 print(list(map(lambda x:x+1 ,number))) #[2, 3, 4, 5, 6, 7] #注：map（）得出的结果是一个iterator ，须要用list（）函数让它个整个序列都计算出来返回一个list
二、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 res print(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))#<filter object at 0x00000000010FAC18> print(list(filter(not_empty,aa)))#['A', 'B', 'C'] #注：filter()函数返回的是一个iterator，内存地址，须要看内存地址的值， 用list()函数或得该地址的值
三、reduce函数
reduce(function, sequence, initial=None) 在python2能够直接用reduce()函数，在python3须要导入reduce模块 from functools import reduce reduce函数，将function做用sequence序列的元素，每次携带一对(先前的结果以及下一序列的元素)，获得一个最终结果的返回值app
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 res print(number1) #[2, 3, 4, 10] print(reduce_test(mul, number1)) # 240 print(number1) #[3, 4, 10] print(reduce_test(mul, number1, 10)) # 2400 print(number1) #[3, 4, 10] # 2.lambda函数，借助reduce_test()函数定义 print(reduce_test(lambda x, y: x * y, number1, init=3)) # 720 print(number1) #[3, 4, 10]
四、sorted函数
sorted()函数也是一个高阶函数，它还能够接收一个key函数来实现自定义的排序,key指定的函数将做用于list的每个元素上，并根据key函数返回的结果进行排序。ide
# _*_coding:utf-8_*_ #sorted print(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)) #map name=['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 True ret = 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))