Python 内置函数
内置函数，也就是Python为我们提供的可以直接拿来用的函数，比如，print，input。
作用域相关的函数，globals（）和locals（），locals是返回当前作用域中的名字，而globals则是返回全局作用域中的名字。
def func(): a = 10 print(locals()) # 当前作用域中的内容 print(globals()) # 全局作用域中的内容 print("今天内容很简单") func() 结果为： {'a': 10} {'__name__': '__main__', '__doc__': 'Automatically created module for IPython interactive environment', '__package__': None, '__loader__': None, '__spec__': None, '__builtin__': <module 'builtins' (built-in)>, '__builtins__': <module 'builtins' (built-in)>, '_ih': ['', 'def func():\n a = 10\n print(locals()) # 当前作用域中的内容\n print(globals()) # 全局作用域中的内容\n print("今天内容很简单")\n \nfunc()'], '_oh': {}, '_dh': ['F:\\xpccode'], 'In': ['', 'def func():\n a = 10\n print(locals()) # 当前作用域中的内容\n print(globals()) # 全局作用域中的内容\n print("今天内容很简单")\n \nfunc()'], 'Out': {}, 'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x0000000002F18D68>>, 'exit': <IPython.core.autocall.ZMQExitAutocall object at 0x00000000056B6CC0>, 'quit': <IPython.core.autocall.ZMQExitAutocall object at 0x00000000056B6CC0>, '_': '', '__': '', '___': '', '_i': '', '_ii': '', '_iii': '', '_i1': 'def func():\n a = 10\n print(locals()) # 当前作用域中的内容\n print(globals()) # 全局作用域中的内容\n print("今天内容很简单")\n \nfunc()', 'func': <function func at 0x00000000057B3598>} 今天内容很简单
标识 id：返回对象的唯一标识，CPython返回内存地址
a = "str" id(a) 结果为： 4754040
哈希 hash()：返回一个对象的哈希值，散列值，dict就是使用的这个，所以查找效率高。应该注意列表是不可哈希的。
hash("ab") 结果为： 6056149156013437086
bin将一个十进制的数字转换为二进制，hex转换为16进制，oct八进制。
print(bin(22))#将一个十进制的数，转换为二进制 print(hex(22))#十六进制 print(oct(22))#八进制 结果为： 0b10110 0x16 0o26
类型 type()：返回对象的类型
a = 3.14
type(a)
结果为：
float
类型转换：float() int() bin() hex() oct() bool() list() tuple() dict() set() complex() bytes() bytearray()
a = 3.14 int(a) 结果为3 a = 3.64 int(a) 结果为： 3
输入 input([prompt])：接收用户输入，返回一个字符串
打印 print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)：打印输出，默认使用空格分割、换行结尾，输出到控制台
对象长度 len(s)：返回一个集合类型的元素个数
isinstance(obj, class_or_tuple)：判断对象obj是否属于某种类型或者元组中列出的某个类型，isinstance(True, int)
isinstance(True, int)
结果为：
True
isinstance(True,(bool,int,str))
结果为：
True
issubclass(cls, class_or_tuple)：判断类型cls是否是某种类型的子类或元组中列出的某个类型的子类， issubclass(bool, int)
issubclass(bool, int)
结果为：
True
绝对值abs(x) x为数值
abs(-12)
结果为：
12
最大值max() 最小值min()：返回可迭代对象中最大或最小值，或者返回多个参数中最大或最小值
lst = [1,2,3,4,5,6,7] print(max(lst)) print(min(lst))
结果为：
7 1
round(x) 四舍六入五取偶，round(-0.5)
print(round(3.5)) print(round(2.4)) print(round(1.3)) 结果为： 4 2 1
pow(x , y) 等价于 x**y
pow(2,3) 2**3 结果都为： 8
range(stop) 从0开始到stop-1的可迭代对象；range(start, stop[, step])从start开始到stop-1结束步长为step的可迭代对象
divmod(x, y) 等价于 tuple (x//y, x%y)
divmod(10, 3)
结果为：
(3, 1)
sum(iterable[, start]) 对可迭代对象的所有数值元素求和
lis = list(range(5)) print(sum(lis,6)) sum(lis) 结果为： 16 10
sum(range(1,100,2))
结果为：
2500
chr(i) 给一个一定范围的整数返回对应的字符
chr(97) 结果为： 'a' chr(20013) 结果为： '中'
chr(8)
结果为：
'\x08'
chr(13)
结果为：
'\r'
chr(10)
结果为：
'\n'
ord(c) 返回字符对应的整数
ord('a') 结果为： 97 ord('中') 结果为： 20013 hex(ord("a")) 结果为： '0x61'
sorted(iterable[, key][, reverse]) 排序，返回一个新的列表，默认升序，reverse是反转 。
sorted([1, 5, 3]) 结果为： [1, 3, 5] sorted([1, 3, 5], reverse=True) 结果为： [5, 3, 1] sorted({'c':1, 'b':2, 'a':1}) 结果为： ['a', 'b', 'c'] a = [1,3,6,4] a.sort() print(a) [1, 3, 4, 6]
翻转 reversed(seq):返回一个翻转元素的迭代器
list(reversed("13579")) 结果为： ['9', '7', '5', '3', '1'] { reversed((2, 4)) } # 有几个元素？ 结果为： {<reversed at 0x5c9c128>} for x in reversed(['c','b','a']): print(x) 结果为： a b c reversed(sorted({1, 5, 9})) 结果为： <list_reverseiterator at 0x5c9c8d0> a = reversed(sorted({1, 5, 9})) for i in a: print(i) 结果为： 9 5 1
枚举 enumerate(seq, start=0):迭代一个序列，返回索引数字和元素构成的二元组,start表示索引开始的数字，默认是0
for x in enumerate([2,4,6,8]): print(x) for x in enumerate("abcde"): print(x,end=" ") 结果为： (0, 2) (1, 4) (2, 6) (3, 8) (0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e')
for i in enumerate(range(5)):
print(i)
结果为：
(0, 0) (1, 1) (2, 2) (3, 3) (4, 4)
for k,v in enumerate(range(5)):
print(k,v,end="\t")
结果为：
0 0 1 1 2 2 3 3 4 4
迭代器和取元素 iter(iterable)、next(iterator[, default])：iter将一个可迭代对象封装成一个迭代器，next对一个迭代器取下一个元素。如果全部元素都取过了，再次next会抛StopIteration异常。next内部实现实际使用了__next__()方法，而iter()内部内部实际使用的是__iter__()方法。
lst = ["da", "ba", "ca"] it = iter(lst) # __iter__() print(it.__next__()) print(next(it)) # __next__() print(next(it)) print(next(it)) 结果为： da ba ca --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-5-953ee1687321> in <module> 4 print(next(it)) # __next__() 5 print(next(it)) ----> 6 print(next(it)) StopIteration:
it = iter(range(5))#it是一个迭代器 print(next(it)) print(next(it)) type(it) 结果为： 0 1 range_iterator it = reversed([1,3,5]) next(it) 结果为： 5
可迭代对象：能够通过迭代一次次返回不同的元素的对象。
上面所说的相同不是指值是否相同，而是元素在容器中是否是同一个，例如列表中值可以重复的，['a','a']，虽然这个列表有2个元素，值一样，但是两个'a'是不同的元素。
可迭代对象可以迭代，但是未必有序，未必可索引，包括有list、tuple、string、bytes、bytearray、range、set、dict、生成器等
可迭代对象可以使用成员操作符in、not in，in本质上就是在遍历对象
3 in range(10) 3 in (x for x in range(10)) 3 in {x:y for x,y in zip(range(4),range(4,10))} 结果都为： True
迭代器：特殊的对象，一定是可迭代对象，具备可迭代对象的特征，通过iter方法把一个可迭代对象封装成迭代器，通过next方法，迭代 迭代器对象， 生成器对象，是迭代器对象，但迭代器不一定是生成器。
g = (x for x in range(10)) print(type(g)) print(next(g)) print(next(g)) 结果为： <class 'generator'> 0 1 for x in iter(range(5)): print(x) 结果为： 0 1 2 3 4 type(iter(range(5))) 结果为： range_iterator
拉链函数zip(*iterables) ：像拉链一样，把多个可迭代对象合并在一起，返回一个迭代器，将每次从不同对象中取到的元素合并成一个元组。
list(zip(range(10),range(10),range(5))) 结果为： [(0, 0, 0), (1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)] list(zip(range(10),range(10))) 结果为： [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9)] list(zip(range(10),range(10),range(5),range(10))) 结果为： [(0, 0, 0, 0), (1, 1, 1, 1), (2, 2, 2, 2), (3, 3, 3, 3), (4, 4, 4, 4)] dict(zip(range(10),range(10))) 结果为： {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9} {str(x):y for x,y in zip(range(10),range(10))} 结果为： {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
