一、内置函数
python为了方便我们使用，提供给我们已经编好的60多种内置函数，我们在程序可以直接进行调用。我们按照几个大类进行学习。
1.1、作用域相关的函数
locals：函数会以字典的类型返回当前位置的全部局部变量。
globals：函数会以字典的类型返回全部的全局变量
1 a = 1 2 b = 2 3 print(locals()) 4 print(globals()) 5 # 这两个打印的内容是相同的，因为同处于全局作用域内
1 def func(argv): 2 c = 2 3 print(locals()) 4 print(globals()) 5 func(3) 6 # locals（）的返回值 {'c': 2, 'argv': 3} 7 # globals（）的返回值和上一个全局变量的例子是一样的
1.2、字符串相关的函数
eval：执行字符串类型的代码，并返回最终结果，我理解就是给字符串类型的代码脱去字符串的外衣，回归他的本质。
1 # eval：执行字符串类型的代码，并返回最终结果，相当于将字符串扒去一层保留代码原来的本质 2 s = "{'name':'liu'}" 3 print(type(s)) 4 print(eval(s)) 5 print(type(eval(s)))
exec：执行字符串类型的代码，直接执行字符串内部代码代表的功能。
1 # exec：执行字符串类型的代码，直接运行代码 2 s2 = ''' 3 for i in range(5): 4 print(i) 5 ''' 6 print(s2) 7 exec(s2)
compile：将字符串类型的代码编译，代码对象能够通过exec语句来执行或者eval()进行求值。
''' 参数说明： 1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。 2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。 3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。 ''' >>> #流程语句使用exec >>> code1 = 'for i in range(0,10): print (i)' >>> compile1 = compile(code1,'','exec') >>> exec (compile1) >>> #简单求值表达式用eval >>> code2 = '1 + 2 + 3 + 4' >>> compile2 = compile(code2,'','eval') >>> eval(compile2) >>> #交互语句用single >>> code3 = 'name = input("please input your name:")' >>> compile3 = compile(code3,'','single') >>> name #执行前name变量不存在 Traceback (most recent call last): File "<pyshell#29>", line 1, in <module> name NameError: name 'name' is not defined >>> exec(compile3) #执行时显示交互命令，提示输入 please input your name:'pythoner' >>> name #执行后name变量有值 "'pythoner'"
1.3、输入输出功能相关
input：函数接受一个标准输入数据，返回string类型
print：打印输出
# 输入输出相关input print # input()返回的是字符串格式的数据 print(111,222,333) # 默认打印模式 print(111,222,333,sep="|") # sep= 设置打印项目中间的连接符 print(111,end="") # end= 可以选择打印结尾的符号，默认为换行符 print(222) f = open('log','w',encoding='utf-8') print('写入文件',file=f,flush=True) # 写入文件操作，不常用
1.4、内存相关函数
hash：获取一个对象（可哈希对象：int，str，bool，tuple）的哈希值
id：用于获取对象的内存地址
1 print(hash(12322)) 2 print(hash('123')) 3 print(hash('arg')) 4 print(hash('alex')) 5 print(hash(True)) 6 print(hash(False)) 7 print(hash((1,2,3))) 8 9 print(id(123)) # 1674055952 10 print(id('abc')) # 2033192957072
1.5、文件操作相关函数
open：函数用于打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
1.6、模块相关__import__
__import__：函数用于动态加载类和函数
1.7、调用相关函数
callable：函数用于检查一个对象是否是可调用的，如果返回True，对象仍可能调用失败，但是如果返回False，调用对象绝对不会成功。
>>>callable(0) False >>> callable("runoob") False >>> def add(a, b): ... return a + b ... >>> callable(add) # 函数返回 True True >>> class A: # 类 ... def method(self): ... return 0 ... >>> callable(A) # 类返回 True True >>> a = A() >>> callable(a) # 没有实现 __call__, 返回 False False >>> class B: ... def __call__(self): ... return 0 ... >>> callable(B) True >>> b = B() >>> callable(b) # 实现 __call__, 返回 True
1.8、查看内置属性的函数
dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表，带参数时，返回参数的属性、方法列表，如果参数包含方法__dir__()，该方法将被调用，如果参数不包含__dir__()，该方法将最大限度的收集参数的信息。
1.9、迭代器生成器相关的函数
range：函数可创建一个整数对象，一般用在for循环中。
next：内部实际使用了__next__方法，返回迭代器的下一个项目。
iter：函数用来生成迭代器（将一个可迭代对象，生成迭代器）。
# 首先获得Iterator对象: it = iter([1, 2, 3, 4, 5]) # 循环: while True: try: # 获得下一个值: x = next(it) print(x) except StopIteration: # 遇到StopIteration就退出循环 break from collections import Iterable from collections import Iterator l = [1,2,3] print(isinstance(l,Iterable)) # True print(isinstance(l,Iterator)) # False l1 = iter(l) print(isinstance(l1,Iterable)) # True print(isinstance(l1,Iterator)) # True
1.20、数据类型函数
bool：用于将给定参数转化为布尔类型，如过没有参数，返回False。
int：函数用于将一个字符串或数字转换为整型。
float：函数用于将整数和字符串转换成浮点数。
complex：函数用于创建一个值为real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
1 print(int()) # 0 2 print(int('12')) # 12 3 print(int(3.6)) # 3 4 print(int('0100',base=2)) # 将2进制的 0100 转化成十进制。结果为 4 5 6 >>>complex(1, 2) 7 (1 + 2j) 8 >>> complex(1) # 数字 9 (1 + 0j) 10 >>> complex("1") # 当做字符串处理 11 (1 + 0j) 12 # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 13 >>> complex("1+2j") 14 (1 + 2j)
bin：将十进制转化成二进制并返回。
oct：将十进制转化成八进制字符串并返回。
hex：将十进制转化成十六进制字符串并返回。
print(bin(10),type(bin(10))) # 0b1010 <class 'str'> print(oct(10),type(oct(10))) # 0o12 <class 'str'> print(hex(10),type(hex(10))) # 0xa <class 'str'>
abs：函数返回数字的绝对值
divmod：计算除数与被除数的结果，返回一个包含商和余数的元组（a//b，a%b）
round：保留浮点数的小数位，默认保留整数。
pow：求x**y次幂。（三个参数为x**y的结果对z取余）
print(abs(-5)) # 5 print(divmod(7,2)) # (3, 1) print(round(7/3,2)) # 2.33 print(round(7/3)) # 2 print(round(3.32567,3)) # 3.326 print(pow(2,3)) # 两个参数为2**3次幂 print(pow(2,3,3)) # 三个参数为2**3次幂，对3取余。
sum：对可迭代对象进行求和计算（可设置初始值）
min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
print(sum([1,2,3])) print(sum((1,2,3),100)) print(min([1,2,3])) # 返回此序列最小值 ret = min([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最小值 print(ret) dic = {'a':3,'b':2,'c':1} print(min(dic,key=lambda x:dic[x])) # x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键 print(max([1,2,3])) # 返回此序列最大值 ret = max([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最大值 print(ret) dic = {'a':3,'b':2,'c':1} print(max(dic,key=lambda x:dic[x])) # x为dic的key，lambda的返回值（即dic的值进行比较）返回最大的值对应的键
1.21、数据结构相关函数
list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
tuple：将一个可迭代对象转化成元组（如果是字典，默认将key作为元组的元素）。
reversed：将一个序列翻转，并返回此翻转序列的迭代器。
slice：构造一个切片对象，用于列表切片。
1 ite = reversed(['a',2,3,'c',4,2]) 2 for i in ite: 3 print(i) 4 5 li = ['a','b','c','d','e','f','g'] 6 sli_obj = slice(3) 7 print(li[sli_obj]) 8 9 sli_obj = slice(0,7,2) 10 print(li[sli_obj])
str：将数据转化成字符串
format：与具体数据相关，用于计算各种小数，精算等。
1 #字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐 2 print(format('test', '<20')) 3 print(format('test', '>20')) 4 print(format('test', '^20')) 5 6 #整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None 7 >>> format(3,'b') #转换成二进制 8 '11' 9 >>> format(97,'c') #转换unicode成字符 10 'a' 11 >>> format(11,'d') #转换成10进制 12 '11' 13 >>> format(11,'o') #转换成8进制 14 '13' 15 >>> format(11,'x') #转换成16进制 小写字母表示 16 'b' 17 >>> format(11,'X') #转换成16进制 大写字母表示 18 'B' 19 >>> format(11,'n') #和d一样 20 '11' 21 >>> format(11) #默认和d一样 22 '11' 23 24 #浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None 25 >>> format(314159267,'e') #科学计数法，默认保留6位小数 26 '3.141593e+08' 27 >>> format(314159267,'0.2e') #科学计数法，指定保留2位小数 28 '3.14e+08' 29 >>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示 30 '3.14E+08' 31 >>> format(314159267,'f') #小数点计数法，默认保留6位小数 32 '314159267.000000' 33 >>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数 34 '3.141593' 35 >>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数 36 '3.14159267' 37 >>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数 38 '3.1415926700' 39 >>> format(3.14e+1000000,'F') #小数点计数法，无穷大转换成大小字母 40 'INF' 41 42 #g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数 43 >>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点 44 '3e-05' 45 >>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点 46 '3.1e-05' 47 >>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点 48 '3.14e-05' 49 >>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写 50 '3.14E-05' 51 >>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点 52 '3' 53 >>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点 54 '3.1' 55 >>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点 56 '3.14' 57 >>> format(0.00003141566,'.1n') #和g相同 58 '3e-05' 59 >>> format(0.00003141566,'.3n') #和g相同 60 '3.14e-05' 61 >>> format(0.00003141566) #和g相同 62 '3.141566e-05'
bytes：用于不同编码之间的转化。
1 s = '你好' 2 bs = s.encode('utf-8') 3 print(bs) 4 s1 = bs.decode('utf-8') 5 print(s1) 6 bs = bytes(s,encoding='utf-8') 7 print(bs) 8 b = '你好'.encode('gbk') 9 b1 = b.decode('gbk') 10 print(b1.encode('utf-8'))
bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
1 ret = bytearray('alex',encoding='utf-8') 2 print(id(ret)) 3 print(ret) 4 print(ret[0]) 5 ret[0] = 65 6 print(ret) 7 print(id(ret))
memoryview：
1 ret = memoryview(bytes('你好',encoding='utf-8')) 2 print(len(ret)) 3 print(ret) 4 print(bytes(ret[:3]).decode('utf-8')) 5 print(bytes(ret[3:]).decode('utf-8'))
ord:输入字符找该字符编码的位置。
chr:输入位置数字找出其对应的字符。
ascii:是ascii码中的返回该值，不是就返回/u...。
1 # ord 输入字符找该字符编码的位置 2 print(ord('a')) 3 print(ord('中')) 4 # chr 输入位置数字找出其对应的字符 5 print(chr(97)) 6 print(chr(20013)) 7 # 是ascii码中的返回该值，不是就返回/u... 8 print(ascii('a')) 9 print(ascii('中'))
repr:返回一个对象的string形式（原形毕露）。
1 # repr,返回一个对象的string形式（原形毕露） 2 print(repr("中国")) 3 print(repr('{"name":"alex"}')) 4 5 s12 = '我是%s人' % ('中国') 6 s14 = '我是%r人' % ('中国') 7 print(s12) 8 print(s14)
dict：创建一个字典。
set：创建一个集合。
frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
len:返回一个对象中元素的个数。
sorted：对所有可迭代的对象进行排序操作。
1 L = [('a', 1), ('c', 3), ('d', 4),('b', 2), ] 2 sorted(L, key=lambda x:x[1]) # 利用key 3 [('a', 1), ('b', 2), ('c', 3), ('d', 4)] 4 5 students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] 6 sorted(students, key=lambda s: s[2]) # 按年龄排序 7 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] 8 9 sorted(students, key=lambda s: s[2], reverse=True) # 按降序 10 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
enumerate:枚举，返回一个枚举对象。
1 print(enumerate([1,2,3])) 2 for i in enumerate([1,2,3]): 3 print(i) 4 for i in enumerate([1,2,3],100): 5 print(i)
all：可迭代对象中，全都是True才是True
any：可迭代对象中，有一个True 就是True
1 print(all([1,2,True,0])) 2 print(any([1,'',0]))
zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
1 # zip函数，用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组， 2 # 然后返回由这些元组组成的迭代器，如果各个迭代器的元素个数不一致，则 3 # 返回列表中长度与最短的对象相同，相当于拉链原则 4 l1 = [1,2,3] 5 l2 = ["a","b","c",5,6] 6 l3 = ["@","@@","@@@","@@@@",6] 7 print(zip(l1,l2,l3)) # 可迭代对象<zip object at 0x014EC850> 8 # print(len(zip(l1,l2,l3))) # zip对象没有len 9 for i in zip(l1,l2,l3): 10 print(i)
filter：过滤·。
# filter函数，过滤 def func(x): return x % 2 == 0 ret = filter(func,[1,2,3,4,5,6,7]) # 返回可迭代对象<filter object at 0x02EF15D0> print(ret) for i in ret: print(i)
map:会根据提供的函数对指定序列做映射。
1 # map函数，会根据提供的函数对指定序列做映射 2 l1 = [1,2,3,4,5] 3 def func(x): 4 return x*x 5 ret = map(func,l1) # 返回可迭代对象<map object at 0x01081650> 6 print(ret) 7 for i in ret: 8 print(i)
二、匿名函数
没有函数名，用一行表示，lambda
1 l=[3,2,100,999,213,1111,31121,333] 2 print(max(l)) 3 dic={'k1':10,'k2':100,'k3':30} 4 print(max(dic)) 5 print(dic[max(dic,key=lambda k:dic[k])]) 6 7 res = map(lambda x:x**2,[1,5,7,4,8]) 8 for i in res: 9 print(i) 10 11 res = filter(lambda x:x>10,[5,8,11,9,15]) 12 for i in res: 13 print(i)