Python内置函数
一、内置函数
官方文档：点击
# 匿名函数 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']]
list_items = ["id", "name", "age", "phone", "dept", "enroll_data"] with open(r'aa','r',encoding='utf-8') as fp: staff_list = [line.strip().split(',') for line in fp] staff_list =[['1', 'tom', '22', '13651054608', 'IT', '2013-04-01'], ['2', 'rose', '28', '13451024608', 'HR', '2015-01-07']] print(list(zip(*staff_list))) #[('1', '2'), ('tom', 'rose'), ('22', '28'), ('13651054608', '13451024608'), ('IT', 'HR'), ('2013-04-01', '2015-01-07')] print(list(map(list, zip(*staff_list)))) #[['1', '2'], ['tom', 'rose'], ['22', '28'], ['13651054608', '13451024608'], ['IT', 'HR'], ['2013-04-01', '2015-01-07']] print(list(zip(list_items, map(list, zip(*staff_list))))) #[('id', ['1', '2']), ('name', ['tom', 'rose']), ('age', ['22', '28']), ('phone', ['13651054608', '13451024608']), ('dept', ['IT', 'HR']), ('enroll_data', ['2013-04-01', '2015-01-07'])] print(dict(zip(list_items, map(list, zip(*staff_list))))) #{'phone': ['13651054608', '13451024608'], 'name': ['tom', 'rose'], 'enroll_data': ['2013-04-01', '2015-01-07'], 'age': ['22', '28'], 'dept': ['IT', 'HR'], 'id': ['1', '2']}
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'}
二、匿名函数
当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。
匿名函数没有函数名，只使用一次。
在Python中，对匿名函数提供了有限支持。还是以map()函数为例，计算f(x)=x2时，除了定义一个f(x)的函数外，还可以直接传入匿名函数：
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])) [1, 4, 9, 16, 25, 36, 49, 64, 81]
通过对比可以看出，匿名函数lambda x: x * x实际上就是：
def f(x): return x * x
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
>>> f = lambda x: x * x >>> f <function <lambda> at 0x101c6ef28> >>> f(5) 25
同样，也可以把匿名函数作为返回值返回，比如：
def build(x, y): return lambda: x * x + y * y
三、递归
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：
fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n
所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。
于是，fact(n)用递归的方式写出来就是：
def fact(n): if n==1: return 1 return n * fact(n - 1)
上面就是一个递归函数。可以试试：
>>> fact(1) 1 >>> fact(5) 120 >>> fact(100) 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
如果我们计算fact(5)，可以根据函数定义看到计算过程如下：
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120
递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：
>>> fact(1000) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 4, in fact ... File "<stdin>", line 4, in fact RuntimeError: maximum recursion depth exceeded in comparison
解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：
def fact(n): return fact_iter(n, 1) def fact_iter(num, product): if num == 1: return product return fact_iter(num - 1, num * product)
可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。
fact(5)对应的fact_iter(5, 1)的调用如下：
===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120
尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。
遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。
def age(n): if n == 5: return 18 return age(n+1)+2 print(age(1))
l=[1,[2,3,[4,5,[6,7,[8,9,[10,11,[12,13]]]]]]] def func(l): for i in l: if isinstance(i,list): func(i) else: print(i) func(l)
四、高阶函数
函数作为参数传入或者return返回一个函数，满足其中一个条件，这样的函数就称为高阶函数。
1、map函数(映射)
map函数接受两个参数，一个是函数，一个可迭代的对象(iterable),map将传入的函数依次作用到序列的每个元素，并把结果作为新的 可迭代的对象 的结果返回
举例说明，比如我们有一个函数f(x)=x2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：
现在，我们用Python代码实现：
>>> def f(x): ... return x * x ... >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> list(r) [1, 4, 9, 16, 25, 36, 49, 64, 81]
map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
你可能会想，不需要map()函数，写一个循环，也可以计算出结果：
L = [] for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]: L.append(f(n)) print(L)
的确可以，但是，从上面的循环代码，能一眼看明白“把f(x)作用在list的每一个元素并把结果生成一个新的list”吗？
所以，map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x2，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：
>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) ['1', '2', '3', '4', '5', '6', '7', '8', '9']
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
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 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()函数或得该地址的值
3、reduce函数
reduce(function, sequence, initial=None) 在python2可以直接用reduce()函数，在python3需要导入reduce模块 from functools import reduce reduce函数，将function作用sequence序列的元素，每次携带一对(先前的结果以及下一序列的元素)，得到一个最终结果的返回值
reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
比方说对一个序列求和，就可以用reduce实现：
>>> from functools import reduce >>> def add(x, y): ... return x + y ... >>> reduce(add, [1, 3, 5, 7, 9]) 25
当然求和运算可以直接用Python内建函数sum()，没必要动用reduce。
但是如果要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场：
>>> from functools import reduce >>> def fn(x, y): ... return x * 10 + y ... >>> reduce(fn, [1, 3, 5, 7, 9]) 13579
这个例子本身没多大用处，但是，如果考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int的函数：
>>> from functools import reduce >>> def fn(x, y): ... return x * 10 + y ... >>> def char2num(s): ... return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] ... >>> reduce(fn, map(char2num, '13579')) 13579
整理成一个str2int的函数就是：
from functools import reduce def str2int(s): def fn(x, y): return x * 10 + y def char2num(s): return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] return reduce(fn, map(char2num, s))
还可以用lambda函数进一步简化成：
from functools import reduce def char2num(s): return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] def str2int(s): return reduce(lambda x, y: x * 10 + y, map(char2num, s))
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]
4、sorted函数
sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序,key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。
# _*_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))
