python之路17--之内置函数与匿名函数
一、内置函数
1、内置函数说明
截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。它们就是python提供给你直接可以拿来使用的所有函数。这些函数有些我们已经用过了，有些我们还没用到过，还有一些是被封印了，必须等我们学了新知识才能解开封印的。那下面我们就一起来认识一下python的内置函数。
上面就是内置函数的表，68个函数都在这儿了。这个表的顺序是按照首字母的排列顺序来的，
下面我们就总六个方面说一下这些内置函数，
1、作用域相关的内置函数（2个）
基于字典的形式获取局部变量和全局变量
globals()——获取全局变量的字典
print(globals()) #返回全局作用域中所有变量及操作方法的名字
locals()——获取执行本方法所在命名空间内的局部变量的字典
print(locals()) #返回本地作用域中所有变量及操作方法的名字
说明：这两个内置函数和关键字global、nonlocal不一样，global、nonlocal是关键字
2、其他类内置函数（12个）
dir() ---- 查看内置属性
print(dir(str)) #打印字符串类型的所有内置操作方法
callable() ---- 调用相关
print(callable(print)) #这里返回为True，因为print是一个内置函数，执行方法为：print()a = 1print(callable(a)) #这里就返回了一个False，因为a不是函数，不可以a()这么执行 总结：callable:判断这个方法是不是一个可调用的函数，是则返回True，不是则返回False
help() ---- 帮助
help(str) #查看字符串类型的帮助
import ---- 模块相关
impoort time #import是调用__import__(time)方法 说明：import:调用模块，实际是调用__import__()函数
open() ---- 文件相关 #必会
两种打开文件的方法： 1、 f = open('file',mode='r',encoding='utf-8') #f = open(文件，打开方法，字符集) 2、 with open('file',mode='r',encoding='utf-8') as f: #with open(文件，打开方法，字符集) as f：
内存相关（id、hash）
id() ---- 查看变量的内存地址
id(变量名) #返回的结果是该变量的内存地址
hash() ---- 判断数据类型可不可hash #必会
判断数据类型可不可以hash，对于相同可hash数据的hash值再一次程序的执行过程中总是不变的 print(hash(123)) #可hash print(hash(('k','v'))) #可hash print(hash([])) #列表是不可以hash的，报错TypeError: unhashable type: 'list'
input() ---- 用户输入 #必会
chioce = input("please input >>：") #用户输入，输入后得到的数据类型都是字符串类型，
print() ---- 输出 #必会
print("www.yisou.co\n",end='') #print()里默认有end参数，默认end参数的值是回车，这里指定end为空 print(1,2,3,4,sep='*') #sep：指定输出的分割符，结果为：1*2*3*4 #print()实现写文件的操作 f = open('file','w') print("yisou.co",file=f) #fiel=：指定输出的位置，表示将yisou.co字符串写入到file这个文件中了 f.close() #使用print实现进度条 #自带的打印进度条的模块：progress Bar import time for i in range(0,101,2): #打印0-100个数，间隔是2 time.sleep(0.1) #睡眠1秒 char_num = i//2 #打印多少个* per_str = '\r%s%% : %s\n' %(i, '#' * char_num) if i == 100 else '\r%s%% : %s' %(i,'#' * char_num) #\r不换行回到行首 print(per_str,end='',flush=True) #flush:立即把内容输出不做缓存
字符串类型的代码执行（exec、eval、compile）
print(exec('1+2+3')) #exec:可以计算结果，没有返回值，结果为：None print(eval('1+2+3')) #eval:可以计算结果,有返回值，结果为：6，尽量少用（不安全），明确知道要执行的代码是什么的时候可以用，否则少用 #eval:适合处理有结果的简单计算 #exec:适合处理简单流程控制 code = '''for i in range(10): print("**",i)''' exec(code)
compile
compile说明：
1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。
2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。
3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。
#1、流程控制语句 code1 = 'for i in range(0,10): print (i)' compile1 = compile(code1,'','exec') exec (compile1) #2、简单求值表达式语句 code2 = '1 + 2 + 3 + 4' compile2 = compile(code2,'','eval') print(eval(compile2)) #3、交互语句用single code3 = 'name = input("please input your name:")' compile3 = compile(code3,'','single') exec(compile3) #执行时显示交互命令，提示输入 print(name) #执行后name变量有值
3、数据相关
3.1、数据类型相关（四个）
bool() ---- 布尔值 #必会
bool(1) #结果为True，不为零的数转换为布尔值都是True、零为False
int() ---- 整型 #必会
str1 = '1234' str2 = int(str1) #将字符串类型转换为整型，前提字符串类型必须都是数字才可以转换，否则会出错
float() ----浮点数 #必会
浮点数 ：有限循环小数和无限循环小数属于浮点数，无限不循环小数不属于浮点数
complex() ---- 复数
虚数：虚无缥缈的数，python中的虚数用j表示
5 + 12j(5*1 + 12*j) :复数，复数之间是不能比较大小的 #虚部，实部
3.2、进制转换
bin() ---- 转换为二进制
print(bin(10)) #将10转换成二进制，0b：代表二进制
oct() ---- 转换为八进制
print(oct(10)) #将10转换成八进制，0o：代表八进制
hex() ---- 转换为十六进制
print(hex(10)) #将10转换成十六进制，0x：代表十六进制
3.3、数学运算
abs() ---- 计算绝对值
#求绝对值(绝对值：负的转正的，正的还是正的) print(abs(-5)) #结果为5
divmod() ---- 除\余运算
#除余方法：divmod : div:除法，mod:取余 print(divmod(7,2)) #(3, 1)：7除以2等于3，余1 print(divmod(9,5)) #(1, 4)：9除以5等于1，余4
round() ----小数精确
print(round(3.141592657,2)) #将圆周率精确到两位小数，结果为：3.14
pow() ---- 幂运算
print(pow(2,3)) #传两个参数就是求幂运算，pow(2,3):2*2*2结果为：8 print(pow(3,2,2)) #传三个参数就是先求幂，然后再取余，pow(3,2,2):3*3%2结果为：1
sum() ---- 求和运算 #必会
ret = sum([1,2,3,4,5]) #求和运算，sum(必须为可迭代类型，可迭代类型里面必须为数字),结果为：15 ret = sum([1,2,3,4,5],10) #结果为25，就是前面的值计算完后加后面的值
min() ---- 求最小值 #必会
print(min([-4,1,2,3,4])) #获取min()括号里面的最小值,结果为：-4 print(min(1,2,3,-4,key = abs)) #以绝对值的形式来判断最小值，结果为：1
max() ---- 求最大值 #必会
print(max([-2,1,5,3,4])) #获取max()括号里面的最大值，结果为：5 print(max(1,2,3,4,-6,key = abs)) #一绝对值的形式来判断最大值，结果为：-6，
4、数据结构相关
reverse() ---- 列表倒叙
l = [1,2,3,4] l.reverse() #列表的反转 l2 = reversed(l) #保留原列表，返回一个反向的迭代器 print(l,"333",l2) #结果为：[4, 3, 2, 1] 333 <list_reverseiterator object at 0x00000164C6211EB8>
slice() ---- 切片
l = (1,2,23,213,5612,342,43) sli = slice(1,5,2) #切片，从第一个到切到第五个，步长是2 print(l[sli]) #结果为：(2, 213) print(l[1:5:2]) #列表自带的切片方法，从第一个到切到第五个，步长是2，结果为：(2, 213)
format() ---- 格式换输出 #必会， 参考博客地址：www.cnblogs.com/Eva-J/articles/7266245.html
#字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐 print(format('test', '<20')) print(format('test', '>20')) print(format('test', '^20')) #整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None >>> format(3,'b') #转换成二进制 '11' >>> format(97,'c') #转换unicode成字符 'a' >>> format(11,'d') #转换成10进制 '11' >>> format(11,'o') #转换成8进制 '13' >>> format(11,'x') #转换成16进制 小写字母表示 'b' >>> format(11,'X') #转换成16进制 大写字母表示 'B' >>> format(11,'n') #和d一样 '11' >>> format(11) #默认和d一样 '11' #浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None >>> format(314159267,'e') #科学计数法，默认保留6位小数 '3.141593e+08' >>> format(314159267,'0.2e') #科学计数法，指定保留2位小数 '3.14e+08' >>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示 '3.14E+08' >>> format(314159267,'f') #小数点计数法，默认保留6位小数 '314159267.000000' >>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数 '3.141593' >>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数 '3.14159267' >>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数 '3.1415926700' >>> format(3.14e+1000000,'F') #小数点计数法，无穷大转换成大小字母 'INF' #g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数 >>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点 '3e-05' >>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点 '3.1e-05' >>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点 '3.14e-05' >>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写 '3.14E-05' >>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点 '3' >>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点 '3.1' >>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点 '3.14' >>> format(0.00003141566,'.1n') #和g相同 '3e-05' >>> format(0.00003141566,'.3n') #和g相同 '3.14e-05' >>> format(0.00003141566) #和g相同 '3.141566e-05'
bytes() ---- 转换为bytes类型 #必会
print(bytes('www.yisoutv.com',encoding='utf-8')) #unicode转换成utf-8的bytes，结果为：b'www.yisoutv.com' print(bytes('易 搜 tv',encoding='gbk')) #unicode转换成gbk的bytes 结果为：b'\xd2\xd7 \xcb\xd1 tv' #网络编程：只能用二进制 #照片和视频也是以二进制存储 #html网页爬取到的也是编码
bytearray()
b_array = bytearray('你好',encoding='utf-8') print(b_array) #16进制 print(b_array[0]) #将十六进制转换为10进制
memoryview() ---- 切片：以字节的形式展现出来（不占用内存空间），但是如果想看内容就会转换成字符串的形式（又占用内存空间了）
ret = memoryview(bytes('你好',encoding='utf-8')) print(len(ret)) print(bytes(ret[:3]).decode('utf-8')) print(bytes(ret[3:]).decode('utf-8'))
ord() ---- 字符按照unicode转换为数字
print(ord('搜')) #结果为：25628 print(ord('b')) #结果为：98
chr() ---- 数字按照unicode转换为字符
print(chr(98))
ascii() ---- 只要是ascii码中的内容就打印出来，不是就转换为\u
print(ascii('搜')) #结果为：'\u641c' print(ascii('1')) #结果为：'1'
repo() ---- 打印类型的符号
print(repr([1,2])) #结果为：[1, 2] # print(repr('1')) #结果为：'1' # print(repr(1)) #结果为：1
dict() ---- 字典
set() ---- 集合
frozenset() ---- 不可变集合
5、重要的内置函数
len() ---- 计算长度
print(len('str')) #结果为3
enumerate() ---- 枚举
shopping_list = [ ("电脑",5000), ("鼠标",100), ("茶叶",80), ("键盘",1000) ] for k, v in enumerate(shopping_list): print(k+1, v) 结果为： 1 ('电脑', 5000) 2 ('鼠标', 100) 3 ('茶叶', 80) 4 ('键盘', 1000)
all() ---- 接收一个可迭代的类型，该可迭代的类型里有一个False则为False，全为True则返回True
print(all(['a','',123])) #结果为False，‘’空字符串为False print(all(['a',123])) #结果为True print(all([0,123])) #结果为False，0为False
any() ---- 接受一个可迭代类型，该可迭代类型里有一个True则为True，全是False则为False
print(any(['',True,0,[]])) #结果True，因为该可迭代类型里有一个True
zip() ---- 组合方法，同时又叫拉链方法，将集合数据类型合并，以最短的为基准合并为元组
l = [1,2,3,4,5] l2 = ['a','b','c'] l3 = (1,2,['1','2'],"*","**")for i in zip(l,l2,l3): print(i)
结果为：
(1, 'a', 1)
(2, 'b', 2)
(3, 'c', ['1', '2'])
filter()
#filter和map函数的相关博客地址：http://www.cnblogs.com/Eva-J/articles/7266192.html
1、使用filter过滤奇数 def is_oss(x): return x % 2 == 1 ret = (filter(is_oss,[1,4,6,7,9,12,17])) #filter(函数，可迭代类型) print(ret) #返回值是一个迭代器 for i in ret: print(i) #结果为：1，7，9，17 #2、使用filter过滤字符串 def is_str(s): if type(s) == str: #简写：return type(s) == str return s ret = (filter(is_str,[1,4,6,'yisou',7,9,12,17])) #filter(函数，可迭代类型) print(ret) #返回值是一个迭代器 for i in ret: print(i) #结果为：yisou #3、去除空格 def is_str(s): return s and str(s).strip() ret = filter(is_str,[1,'hello','',' ',None,[],6,'world']) print(ret) #返回值是一个迭代器 for i in ret: print(i)
map()
1、打印绝对值 ret = map(abs,[1,-4,6,-8]) #map(函数名，可迭代类型) print(ret) for i in ret: print(i) 2、处理字符串，在字符串后面加上_sb name = ['yisou','qiyi','111','zhangsan'] def func(item): #定义函数 return item+'_sb' #函数做什么 ret = map(func,name) #map(函数名，可迭代类型) for i in ret: print(i) 结果为： yisou_sb qiyi_sb 111_sb zhangsan_sb
总结：filter：执行了filter之后的结果集合<=执行前的个数， map：执行前后元素个数不变，值可能发生改变
sort() ---- 在原列表的基础上排序
l = [1,-4,6,5,-10] l.sort(key = abs) print(l) #结果为：[1,-4,6,5,-10]
sorted() ---- 在原列表的基础上生成一个新列表
#使用场景：列表不大的情况下，想要保留原列表，同时想对列表进行排序 l = [1,-4,6,5,-10] print(sorted(l)) #结果为：[-10, -4, 1, 5, 6] print(sorted(l,key=abs,reverse=True)) #reverse=True:反转 结果为：[-10, 6, 5, -4, 1] 2、按照字符串的长度排序 l = ['***',[1,2],'hello world'] new_l = sorted(l,key=len) print(new_l) #结果为：[[1, 2], '***', 'hello world']
5、五个带有key字段的内置函数
max、min、filter、map、sorted
使用方法：
1、max()
print(max(1,2,3,4,-6,key = abs)) #一绝对值的形式来判断最大值，结果为：-6，
2、min()
print(min(1,2,3,-4,key = abs)) #以绝对值的形式来判断最小值，结果为：1
3、filter（）
打印偶数 num = [1,3,5,6,7,8] def func(ou): if ou % 2 == 0: return ou ret = filter(func,num) #filter（函数，可迭代类型），将可迭代类型当参数传给函数，返回值为：迭代器 for i in ret: print(i) #结果为：6，8
4、map（）
在字符串后加_sb name = ['yisou','qiyi','111','zhangsan'] def func(item): return item+'_sb' ret = map(func,name) #ret是一个迭代器 for i in ret: print(i) 结果为： yisou_sb qiyi_sb 111_sb zhangsan_sb
5、sorted()
l = ['***',[1,2],'hello world'] new_l = sorted(l,key=len) print(new_l) #结果为：[[1, 2], '***', 'hello world']
二、匿名函数
匿名函数：为了解决那些功能很简单的需求而设计的一句话函数，参考博客地址：www.cnblogs.com/Eva-J/articles/7206498.html
匿名函数格式说明：函数名 = lambda 参数1，参数2：返回值1+返回值2 #参数可以是一个或多个，多个用，逗号隔开
画图说明：
1、一个简单的乘法运算的匿名函数
num1 = lambda x:x*x print(num1(3)) #结果为：9
2、加法运算
test = lambda x,y:x+y print(test(1,2))
匿名函数总结：
1、匿名函数写法
函数名 = lambda 参数1,参数2:返回值
参数可以有一个到多个，用逗号隔开
匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
返回值和正常函数一样可以是任意数据类型
带参数key得内置函数有：max min filter map sorted 都可以和lambda合作使用
3、判断字典里values最大的key
dic = {'k1':10,'k2':100,'k3':30}
print(max(dic,key=lambda k:dic[k]))
4、列表中的每个值求平方
ret = map(lambda x:x**2,[1,2,3,6,7]) for i in ret: print(i)
5、筛选列表中大于10的数字
ret = filter(lambda x:x>10,[5,8,11,9,26]) for i in ret: print(i)
6.1、求最终结果
d = lambda p:p*2 # t = lambda p:p*3 # x = 2 # x = d(x) #x = 4 # x = t(x) #x = 12 # x = d(x) #x = 24 # print(x) #结果为:24
6.2、现在有两个元组(('a'),('b')),(('c'),('d')),请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]
print(list(map(lambda d:{d[0]:d[1]},zip((('a'),('b')),(('c'),('d')))))) #结果为：[{'a': 'c'}, {'b': 'd'}]
7、求结果
def multipliers(): return [lambda x:i*x for i in range(4)] print([m(2) for m in multipliers()]) 结果为：[6,6,6,6]
说明：
平时工作中相对更常用的方法推荐一下，请务必重点掌握：
其他：input,print,type,hash,open,import,dir
str类型代码执行：eval,exec
数字：bool,int,float,abs,divmod,min,max,sum,round,pow
序列——列表和元组相关的：list和tuple
序列——字符串相关的：str，bytes，repr
序列：reversed，slice
数据集合——字典和集合：dict，set，frozenset
数据集合：len，sorted，enumerate，zip，filter，map
参考文档：
https://docs.python.org/3/library/functions.html#object
浙公网安备 33010602011771号