内置函数
截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。
1.1作用域相关
locals ：函数会以字典的类型返回当前位置的全部局部变量。
globals：函数以字典的类型返回全部全局变量。
1 a = 1
2 b = 2
3 print(locals())
4 print(globals())
5 # 这两个一样，因为是在全局执行的。
6
7
8 q = 666
9 def wrapper(argv):
10 a = 3
11 print(locals()) # {a:3,argv:2} 注意传的参数，相当于在该函数下面赋值，为局部变量
12 def inner(argv1):
13 b = 4
14 c = 5
15 print(locals()) # {b:4 c:5,argv1:6}
16 inner(6)
17
18 wrapper(2)
19 print(globals())
# 全局变量：{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002704A5A87B8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/python_test/14/内置函数.py', '__cached__': None, 'L': [('a', 1), ('c', 2), ('d', 4), ('b', 3)], 'a': 1, 'b': 2, 'q': 666, 'wrapper': <function wrapper at 0x000002704A232E18>}
1.2其他相关
1.2.1 字符串类型代码的执行 eval，exec
eval：执行字符串类型的代码，并返回最终结果。
1 print(eval('1 + 2')) # 3
2 print(eval('1' + '2')) # 12 注意是1和2 不是12
3 print(eval('1 + 5 * 8')) # 41 做计算用
4
5 # print(eval('dsf')) # NameError: name 'dsf' is not defined 字符串中如果只包含字母，去掉引号之后，
6 # 相当于一个变量名，但是未定义，所以报错
7 print(eval('{"name": "alex"}'),type(eval('{"name": "alex"}'))) # {'name': 'alex'} <class 'dict'> 拿到字符串中的数据类型
exec:执行字符串类型的代码，不会拿到结果
1 # print(exec('dsaf')) # NameError: name 'dsaf' is not defined 同eval()
2 exec('''
3 for i in range(5):
4 print(i)
5 ''') # 执行字符串中的内容
有返回值的字符串形式的代码用eval，没有返回值的字符串形式的代码用exec;
1.2.2 输入输出相关 input，print
input:函数接受一个标准输入数据，返回为 string 类型。注意python2 与python3中input()的区别
print:打印输出。
1 ''' 源码分析
2 def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
3 """
4 print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
5 file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
6 sep: 打印多个值之间的分隔符，默认为空格
7 end: 每一次打印的结尾，默认为换行符
8 flush: 立即把内容输出到流文件，不作缓存
9 """
10 '''
11 注意：不能接收**kwargs
12
13 print(111,222,333,sep='*') # 111*222*333
14
15 print(111,end='')
16 print(222) #两行的结果 111222
17
18 f = open('log','w',encoding='utf-8')
19 print('写入文件',file=f,flush=True)
1.2.3内存相关 hash id
hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
1 print(hash('name')) # 每一次计算的结果都不一样，但是位数都是19位 -5724095628916473671
2 print(hash('alex')) # 3914978466267277800
注意：hash(1) ---> 1 即哈希一个数字得到的是数字本身。
id:用于获取对象的内存地址。
1.2.3文件操作相关
open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
1.2.4模块相关__import__
__import__：函数用于动态加载类和函数 。
# import------>sys----->__import__() # 调用import模块 时内部 为操作系统调用 _impore_() import test test.say_hi() import 'test'#报错 module_name='test' m=__import__(module_name) m.say_hi()
1.2.5帮助
help：函数用于查看函数或模块用途的详细说明。
print(help(str)) # 查看源码
1.2.6调用相关
callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
>>>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.2.7查看内置属性
dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
>>>dir() # 获得当前模块的属性列表 ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice'] >>> dir([ ]) # 查看列表的方法 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
1.3 迭代器生成器相关
range：函数可创建一个整数对象，一般用在 for 循环中。
next：内部实际使用了__next__方法，返回迭代器的下一个项目。
iter_i = [1, 2, 3, 4, 5].__iter__() # 也是for循环机制
while True:
try:
print(next(iter_i))
except StopIteration:
break
iter：函数用来生成迭代器（将一个可迭代对象，生成迭代器）。
li = [1, 2, 3, 4, 5] print(li) # [1, 2, 3, 4, 5] print(iter(li)) # <list_iterator object at 0x000001F4497FCF60> 可迭代对象的内存地址
1.4 基础数据类型相关
1.4.1数字相关（14）
数据类型（4）：
bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。
int：函数用于将一个字符串或数字转换为整型。
print(int('123')) # 123
print(int(1.55)) # 1，没有四舍五入
print(int()) # 注意 0
print(bool()) # False
print(bool(0)) # False
float：函数用于将整数和字符串转换成浮点数。
complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
print(float(1.55)) # 1.55
print(float(100)) # 100.0
print('%f' % 1.556) # 1.556000
print('%.2f' % 1.556 ) # 1.56 保留2为小数
print('%.2f %%' % 98.9666) # 98.97 % 会四舍五入
i = 3.1415
print(i, type(i)) # 3.1415 <class 'float'>
print(complex(3, 4)) # (3+4j)
print(complex(3)) # (3+0j) # 数字
print(complex('1')) # (1+0j) # 当做字符串处理
print(complex('1+2j')) # (1+2j) # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错ValueError: complex() arg is a malformed string
进制转换（3）：
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'>
数学运算（7）：
abs：函数返回数字的绝对值。
# print(abs(-5)) # 5 返回数字的绝对值
自定制最大值，最小值的写法
divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
round：保留浮点数的小数位数，默认保留整数。
pow：求x**y次幂。（三个参数为x**y的结果对z取余）
print(divmod(10, 3)) # (3, 1) 第一个数是10//3 第二个数是10%3 做分页使用 print(round(17/6, 3)) # 2.833 print(round(17/6)) # 3 默认保留整数 print(pow(2, 3)) # 8 2的3次方 print(pow(2, 3, 3)) # 2 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.4.2和数据结构相关（24）
列表和元祖（2）
list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。
l = list((1,2,3))
print(l)
l = list({1,2,3})
print(l)
l = list({'k1':1,'k2':2})
print(l)
tu = tuple((1,2,3))
print(tu)
tu = tuple([1,2,3])
print(tu)
tu = tuple({'k1':1,'k2':2})
print(tu)
相关内置函数（2）
reversed：将一个序列翻转，并返回此翻转序列的迭代器。
slice：构造一个切片对象，用于列表的切片。
li = [1, 2, 3400, -8, 500, -1, -1000] print(reversed(li)) # <list_reverseiterator object at 0x00000198D066CF60> print(list(reversed(li))) # [-1000, -1, 500, -8, 3400, 2, 1]
li = ['a','b','c','d','e','f','g'] sli_obj = slice(3) print(li[sli_obj]) sli_obj = slice(0,7,2) print(li[sli_obj])
字符串相关（9）
str：将数据转化成字符串。
format:与具体数据相关，用于计算各种小数，精算等。
#字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
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：用于不同编码之间的转化。
s = '你好'
bs = s.encode('utf-8')
print(bs)
s1 = bs.decode('utf-8')
print(s1)
bs = bytes(s,encoding='utf-8')
print(bs)
b = '你好'.encode('gbk')
b1 = b.decode('gbk')
print(b1.encode('utf-8'))
bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
ret = bytearray('alex',encoding='utf-8')
print(id(ret))
print(ret)
print(ret[0])
ret[0] = 65 # 通过改索引，改掉字符串，
print(ret)
print(id(ret)) # 直接对原来字符串进行了修改，没有形成新的字符串
memoryview
ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret))
print(ret)
print(bytes(ret[:3]).decode('utf-8')) # 实现按对字节切片 取值
print(bytes(ret[3:]).decode('utf-8'))
ord:输入字符找该字符编码的位置
chr:输入位置数字找出其对应的字符
ascii:是ascii码中的返回该值，不是就返回/u...
# ord 输入字符找该字符编码的位置
# print(ord('a'))
# print(ord('中'))
# chr 输入位置数字找出其对应的字符
# print(chr(97))
# print(chr(20013)) # 是unicode编码
# 是ascii码中的返回该值，不是就返回/u...
# print(ascii('a'))
# print(ascii('中')) # # 是unicode编码
repr:返回一个对象的string形式（原形毕露）。
name = 'goulonghui'
print(name) # goulonghui
print(repr(name)) # 'goulonghui'
# repr 原形毕露
print(repr('{"name":"gou"}')) # '{"name":"gou"}'
print('{"name":"gou"}') # {"name":"gou"}
数据集合（3）
dict：创建一个字典。
set：创建一个集合。
frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
相关内置函数（8）
len:返回一个对象中元素的个数。
sorted：对所有可迭代的对象进行排序操作。
L = [('a', 1), ('c', 3), ('d', 4),('b', 2), ]
print(sorted(L)) # [('a', 1), ('b', 2), ('c', 3), ('d', 4)] 按ascii吗的排序
sorted(L, key=lambda x:x[1]) # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2]) # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
sorted(students, key=lambda s: s[2], reverse=True) # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
enumerate:枚举，返回一个枚举对象。
for i in enumerate([1,2,3],100): # 可定义初始值为100
print(i)
all：可迭代对象中，全都是True才是True
any：可迭代对象中，有一个True 就是True
zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
拉链函数，它可以和sorted(),min(),max()等函数套用：
l1 = [1,2,3,]
l2 = ['a','b','c',5]
l3 = ('*','**',(1,2,3))
for i in zip(l1,l2,l3):
print(i)
下面函数具体见http://www.cnblogs.com/glh-ty/p/8254766.html
filter：过滤·。
map:会根据提供的函数对指定序列做映射。
1 # print(abs(-1)) ### 1 ###
2
3 # print(all([1,2,3,''])) ### False ###
4 # print(all('')) ### True ###
5
6 # print(any([1,2,0])) ### True ###
7 # print(any([0])) ### False ### 有一个为真即为真
8 #空，None，0的布尔值为False，其余都为True
9
10 # print(bin(10)) #10进制->2进制
11 # print(hex(12)) #10进制->16进制
12 # print(oct(12)) #10进制->8进制
13
14 # name = '你好'
15 # print(bytes(name,encoding='utf-8')) ## # 编码
16 # print(bytes(name,encoding='utf-8').decode('utf-8')) ### 解码
17 # print(bytes(name,encoding='gbk')) ## # 编码
18 # print(bytes(name,encoding='gbk').decode('gbk')) ### 解码
19 ### 用什么编码 就用什么解码 ###
20
21 # print(chr(97)) 97 在ascii中的表示方式
22 # print(ord('a'))
23
24 # print(divmod(10,3)) 分页使用
25
26 # dic={'name':'gou'}
27 # dic_str=str(dic)
28 # print(dic_str)
29
30 #可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型
31 # print(hash('12sdfdsaf3123123sdfasdfasdfasdfasdfasdfasdfasdfasfasfdasdf'))
32 # print(hash('12sdfdsaf31231asdfasdfsadfsadfasdfasdf23'))
33 #
34 # name='gou'
35 # print(hash(name))
36 # print(hash(name))
37 #
38 #
39 # print('--->before',hash(name))
40 # name='sb'
41 # print('=-=>after',hash(name))
42
43
44 # print(isinstance(1,int)) ### 判断 1 是不是 int 型
45 # print(isinstance('abc',str))
46 # print(isinstance([],list))
47 # print(isinstance({},dict))
48 # print(isinstance({1,2},set))
49
50 # l=[1,3,100,-1,2]
51 # print(max(l))
52 # print(min(l))
53
54 print(list(zip(('a','n','c'),(1,2,3))))
55 print(list(zip(('a','n','c'),(1,2,3,4))))
56 print(list(zip(('a','n','c','d'),(1,2,3)))) # zip 即实现一个一一对应的关系
57
58 # p={'name':'gou','age':18,'gender':'none'}
59 # print(list(p.keys()))
60 # print(list(p.values()))
61 # print(list(zip(p.keys(),p.values())))
62
63 # age_dic={'gou_age':18,'long_age':20,'zsc_age':100,'lhf_age':30}
64 # # print(max(age_dic)) 默认比较字典的keys
65 # # print(max(age_dic.values())) 比较values
66 # print(max(zip(age_dic.values(),age_dic.keys()))) ### 借助zip 可同时获得k ,v
67 ####### max和min 函数 ##########
68 ### ① max函数处理的是可迭代对象，相当于一个for循环取出每一个元素进行比较。注意：不同类型之间不能比较。
69 ### ② 每个元素之间比较，是从每个元素第一个位置依次比较，如果这一个位置分出大小，后面的就不需要比较了，
70 ### 直接得出这两个元素的大小。
71
72 people=[
73 {'name':'gou','age':1000},
74 {'name':'long','age':10000},
75 {'name':'hui','age':9000},
76 {'name':'guan','age':18},
77 ]
78 # max(people,key=lambda dic:dic['age'])
79 print(max(people,key=lambda dic:dic['age']))
80 print(min(people,key=lambda dic:dic['age']))
81
82 # ret=[] ### 上述相当于这个 ###
83 # for item in people:
84 # ret.append(item['age'])
85 # print(ret)
86 # max(ret)
87
88
89
90 # print(pow(3,3)) #3**3 算3的3次方
91 # print(pow(3,3,2)) #3**3%2 算3的3次方 再求余
92
93
94
95 # l=[1,2,3,4]
96 # print(list(reversed(l))) 顺序反过来
97 # print(l)
98
99 #
100 # print(round(3.5)) 四舍五入
101
102 # print(set('hello'))
103
104 # l='hello'
105 # s1=slice(3,5) ### 切片功能
106 # s2=slice(1,4,2)
107 # # print(l[3:5])
108 # print(l[s1])
109 # print(l[s2])
110 # print(s2.start)
111 # print(s2.stop)
112 # print(s2.step)
113
114
115
116 # l=[3,2,1,5,7]
117 # l1=[3,2,'a',1,5,7]
118 # print(sorted(l))
119 # # print(sorted(l1)) 报错 # 排序本质就是在比较大小，不同类型之间不可以比较大小
120 people=[
121 {'name':'gou','age':1000},
122 {'name':'long','age':10000},
123 {'name':'hui','age':9000},
124 {'name':'guan','age':18},
125 ]
126 print(sorted(people,key=lambda dic:dic['age']))
127
128 name_dic={
129 'abhui': 11900,
130 'gou':1200,
131 'long':300,
132 }
133 print(sorted(name_dic)) # 默认key排序
134
135 print(sorted(name_dic,key=lambda key:name_dic[key])) # 用values 排序
136
137 print(sorted(zip(name_dic.values(),name_dic.keys()))) # 借助zip 一一对应后 排序
138
139
140 l=[1,2,3,4]
141 # print(sum(l)) # 求和
142 # print(sum(range(5)))
143 #
144 #
145 # print(type(1))
146 #
147 msg='123'
148
149 # if type(msg) is str:
150 # msg=int(msg)
151 # res=msg+1
152 # print(res)
153 #
154 # def test():
155 # msg='撒旦法阿萨德防撒旦浪费艾丝凡阿斯蒂芬'
156 # print(locals())
157 # print(vars())
158 # test()
159 # print(vars(int)) # 打印int下的所有方法 名称
160
161 #import------>sys----->__import__() # 调用import模块 时内部 为操作系统调用 _impore_()
162 # import test
163 # test.say_hi()
164
165 # import 'test'#报错
166 # module_name='test'
167 # m=__import__(module_name)
168 # m.say_hi()
169
170 内置函数
171
172 内置函数
来源：https://www.cnblogs.com/glh-ty/p/9052317.html