python内置了一些非常精巧且强大的函数，对初学者来说，一般不怎么用到，但是偶尔会碰到，我也是用了一段时间python之后才发现，哇还有这么好的函数，每个函数都非常经典，而且经过严格测试，使用内置函数，不用自己闭门造车，并且代码简洁易读了很多，真是方便又实用，值得花时间进行体系化研究学习。
01、abs()描述：返回数字绝对值或复数的模
语法：abs( x )
参数：x 数值表达式。
案例：
abs(-6)6 abs(5j+4)6.4031242374328485
02、all()描述：接受一个迭代器，如果迭代器(元组或列表)的所有元素都为真，那么返回True，否则返回False，元素除了是 0、空、None、False 外都算 True。
注意：空元组、空列表返回值为True，这里要特别注意。
语法：all(iterable)
参数：iterable -- 元组或列表
案例：
all([1,0,3,6])False all([1,9,3,6])True all(['a', 'b', '', 'd'])Falseall([]) #空列表为真True all(()) #空元组为真True
03、any()描述：接受一个迭代器，如果迭代器里有一个元素为真，那么返回True，否则返回False，元素除了是 0、空、None、False 外都算 True。
语法：any(iterable)
参数：iterable -- 元组或列表
案例：
any([0,0,0,[]])False any([0,0,1])True any((0, '', False)) False any([]) # 空列表False any(()) # 空元组False
04、ascii()描述：ascii() 函数返回任何对象（字符串，元组，列表等）的可读版本。
ascii() 函数会将所有非 ascii 字符替换为转义字符：
å 将替换为 \xe5。
语法：ascii(object)
参数：object--对象，可以是元组、列表、字典、字符串、set()创建的集合。
案例：
ascii('中国')"'\\u4e2d\\u56fd'"ascii('新冠肺炎')"'\\u65b0\\u51a0\\u80ba\\uascii("My name is Ståle")"'My name is St\\xe5le'"print(ascii((1,2))) #元组(1, 2)print(type(ascii((1,2))))<class 'str'>print(ascii([1,2])) #列表[1, 2]print(type(ascii([1,2])))<class 'str'>print(ascii('？')) #字符串，非 ASCII字符，转义'\uff1f'print(type(ascii("？")))<class 'str'>print(ascii({1:2,'name':5})) #字典{1: 2, 'name': 5}print(type(ascii({1:2,'name':5})))<class
05、bin()描述：bin() 返回一个整数 int 或者长整数 long int 的二进制表示。将十进制转换为二进制
语法：bin(x)
参数：x -- int 或者 long int 数字
案例：
bin(2)'0b10'bin(20)'0b10100'06、oct()描述：将十进制转换为八进制
语法：oct(x)
参数：x -- 整数。
案例：
oct(8)'0o10'oct(43)'0o53'07、hex()描述：hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
语法：hex(x)
参数：x -- 10进制整数。
案例：
将十进制转换为十六进制hex(43)'0x2b'#43等于2Bhex(15)'0xf'
08、bool()描述：测试一个对象是True, 还是False.bool 是 int 的子类。
语法：class bool([x])
参数：x -- 要进行转换的参数。
案例：
bool([0,0,0])Truebool([])Falseissubclass(bool, int) # bool 是 int 子类True09、bytes()描述：将一个字符串转换成字节类型
语法：class bytes([source[, encoding[, errors]]])
参数：
如果 source 为整数，则返回一个长度为 source 的初始化数组；如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。如果没有输入任何参数，默认就是初始化数组为0个元素。案例：
s = "apple"bytes(s,encoding='utf-8')b'apple'bytes([1,2,3,4])b'\x01\x02\x03\x04'
10、str()描述：str() 函数将对象转化为适于人阅读的形式。将字符类型、数值类型等转换为字符串类型
语法：class str(object='')
参数：object -- 对象。
案例：
integ = 100str(integ)'100'dict = {'baidu': 'baidu.com', 'google': 'google.com'};str(dict)"{'baidu': 'baidu.com', 'google': 'google.com'}"
11、callable()描述：判断对象是否可以被调用，能被调用的对象就是一个callable 对象，对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。
语法：callable(object)
参数：object -- 对象
案例：
callable(0)Falsedef add(x, y): return x + ycallable(add)True
12、chr()描述：chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
语法：chr(i)
参数：i -- 可以是10进制也可以是16进制的形式的数字。
案例：
查看十进制整数对应的ASCII字符chr(65)'A'可以参考4案例中的表
13、ord()描述：查看某个ascii对应的十进制数
语法：ord(c)
参数：c -- 字符。
案例：
ord('A')65ord('~')12614、classmethod()描述：classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
语法：classmethod
参数：无
案例：
class Sample(object): bar = 1 def fun1(self): print ('foo') @classmethod def fun2(cls): print ('fun2') print (cls.bar) cls().fun1() # 调用 foo 方法 Sample.fun2() # 不需要实例化fun21foo
15、compile()描述：compile() 函数将一个字符串编译为字节代码。
语法：compile(source, filename, mode[, flags[, dont_inherit]])
参数：
source -- 字符串或者AST（Abstract Syntax Trees）对象。。filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。mode -- 指定编译代码的种类。可以指定为 exec, eval, single。flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。flags和dont_inherit是用来控制编译源码时的标志案例：
将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译。s = "print('helloworld')"r = compile(s,"<string>", "exec") r<code object <module> at 0x000000000F819420, file "<string>", line 1>exec(r)helloworldstr = "for i in range(0,5): print(i)" c = compile(str,'','exec') # 编译为字节代码对象 c<code object <module> at 0x000001EB82C91ED0, file "", line 1>exec(c)01234
16、complex()描述：创建一个复数
语法：class complex([real[, imag]])
参数：
real -- int, long, float或字符串；imag -- int, long, float；案例：
complex(1,2)(1+2j) complex('1')(1+0j)complex("1+2j")
(1+2j)
17、delattr()描述：删除对象的属性
语法：delattr(object, name)
参数：
object -- 对象。name -- 必须是对象的属性。案例：
class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print('x = ',point1.x)x = 10print('y = ',point1.y)y = -5print('z = ',point1.z)z = 0delattr(Coordinate, 'z') print('--删除 z 属性后--')print('z = ',point1.z)# 触发错误AttributeError: 'Coordinate' object has no attribute 'z'dir(Coordinate)['__class__省略部分 'x', 'y'18、dict()描述：创建数据字典
语法：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
参数：
**kwargs -- 关键字mapping -- 元素的容器。iterable -- 可迭代对象。案例：
#创建空字典dict() {}#传入关键字dict(a='a', b='b', t='t') {'a': 'a', 'b': 'b', 't': 't'}# 映射函数方式来构造字典dict(zip(['one', 'two', 'three'], [1, 2, 3])) {'three': 3, 'two': 2, 'one': 1} #可迭代对象方式来构造字典dict([('one', 1), ('two', 2), ('three', 3)]) {'three': 3, 'two': 2, 'one':
19、dir()描述：dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
语法：dir([object])
参数：object -- 对象、变量、类型。
案例：
dir() # 获得当前模块的属性列表['In', 'Out', '_', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '_dh', '_i', '_i1', '_ih', '_ii', '_iii', '_oh', 'exit', 'get_ipython', 'quit']dir([ ])# 查看列表的方法dir(list())# 查看列表的方法['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']print(dir(str))#获取所有的方法print(dir(list))#获取所有的方法print(dir(dict))#获取所有的不带参数时返回当前范围内的变量，方法和定义的类型列表；带参数时返回参数的属性，方法列表。
20、divmod()描述：divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
语法：divmod(a, b)
参数：a: 数字--被除数
b: 数字--除数
案例：
divmod(11,3)(3, 2)divmod(20,4)(5, 0)21、enumerate()描述：enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。返回一个可以枚举的对象，该对象的next()方法将返回一个元组。
语法：enumerate(sequence, [start=0])
参数：sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。
案例：
L = ['Spring', 'Summer', 'Fall', 'Winter']enumerate(L)<enumerate at 0x226e1ee1138>#生成的额迭代器，无法直接查看list(enumerate(L))#列表形式，可以看到内部结构，默认下标从0开始[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] list(enumerate(L, start=1)) #下标从 1 开始[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]for i,v in enumerate(L): print(i,v)0 Spring1 Summer2 Fall3 Winterfor i,v in enumerate(L,1): print(i,v)1 Spring2 Summer3 Fall4 Winters = ["a","b","c"] for i ,v in enumerate(s,2): print(i,v)2 a3 b4 c普通的 for 循环i = 0seq = ['one', 'two', 'three']for element in seq: print (i, seq[i]) i+= 10 one1 two2 three 在看一个普通循环的对比案例 for 循环使用 enumerate seq = ['one', 'two', 'three']for i, element in enumerate(seq): print (i, element) 0 one1 two2 three seq = ['one', 'two', 'three']for i, element in enumerate(seq,2): print (i, element)2 one3 two
22、eval()描述：将字符串str 当成有效的表达式来求值并返回计算结果取出字符串中内容
语法：eval(expression[, globals[, locals]])
参数：
expression -- 表达式。globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。案例：
s = "1 + 3 +5"eval(s)9#要统计图片的数量str1 = "['
23、exec()描述：执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。
语法：exec(object, globals, locals)
参数：
object-- 要执行的表达式。globals -- 可选。包含全局参数的字典。locals -- 可选。包含局部参数的字典。案例：
执行字符串或compile方法编译过的字符串，没有返回值s = "print('helloworld')"r = compile(s,"<string>", "exec")exec(r)helloworldx = 10expr = """z = 30sum = x + y + zprint(sum)"""def func(): y = 20 exec(expr) exec(expr, {'x': 1, 'y': 2}) exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4}) func()603334
24、filter()描述：filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
过滤器，构造一个序列，等价于：[ item for item in iterables if function(item)]
在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据。
语法：filter(function, iterable)
参数：
function -- 判断函数。iterable -- 可迭代对象。案例：
fil = filter(lambda x: x>10,[1,11,2,45,7,6,13])fil <filter at 0x28b693b28c8>list(fil)[11, 45, 13]def is_odd(n): return n % 2 == 1 newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])print(list(newlist))[1, 3, 5, 7, 9]25、float()描述：将一个字符串或整数转换为浮点数
语法：class float([x])
参数：x -- 整数或字符串
案例：
float(3)3.0float('123') # 字符串 123.0
26、format()描述：Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。使用format()来格式化字符串时，使用在字符串中使用{}作为占位符，占位符的内容将引用format()中的参数进行替换。可以是位置参数、命名参数或者兼而有之。
format 函数可以接受不限个参数，位置可以不按顺序。
语法：format(value, format_spec)
参数：
案例：
# 位置参数'{}:您{}购买的{}到了！请下楼取快递。'.format('快递小哥','淘宝','快递')'快递小哥:您淘宝购买的快递到了！请下楼取快递。'#给批量客户发短息n_list=['马云','马化腾','麻子','小红','李彦宏','二狗子']for name in n_list: print('{0}：您淘宝购买的快递到了！请下楼取快递！'.format(name))马云：您淘宝购买的快递到了！请下楼取快递！马化腾：您淘宝购买的快递到了！请下楼取快递！麻子：您淘宝购买的快递到了！请下楼取快递！小红：您淘宝购买的快递到了！请下楼取快递！李彦宏：您淘宝购买的快递到了！请下楼取快递！二狗子：您淘宝购买的快递到了！请下楼取快递！ #名字进行填充 for n in n_list: print('{0}：您淘宝购买的快递到了！请下楼取快递！'.format(n.center(3,'*'))) *马云：您淘宝购买的快递到了！请下楼取快递！马化腾：您淘宝购买的快递到了！请下楼取快递！*麻子：您淘宝购买的快递到了！请下楼取快递！*小红：您淘宝购买的快递到了！请下楼取快递！李彦宏：您淘宝购买的快递到了！请下楼取快递！二狗子：您淘宝购买的快递到了！请下楼取快递！'{0}, {1} and {2}'.format('gao','fu','shuai')'gao, fu and shuai'x=3y=5'{0}+{1}={2}'.format(x,y,x+y)# 命名参数'{name1}, {name2} and {name3}'.format(name1='gao', name2='fu', name3='shuai')'gao, fu and shuai'# 混合位置参数、命名参数'{name1}, {0} and {name3}'.format("shuai", name1='fu', name3='gao')'fu, shuai and gao'#for循环进行批量处理["vec_{0}".format(i) for i in range(0,5)]['vec_0', 'vec_1', 'vec_2', 'vec_3', 'vec_4']['f_{}'.format(r) for r in list('abcde')]['f_a', 'f_b', 'f_c', 'f_d',
27、frozenset()描述：frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法：class frozenset([iterable])
参数：iterable -- 可迭代的对象，比如列表、字典、元组等等。
案例：
创建一个不可修改的集合。frozenset([1,1,3,2,3])frozenset({1, 2, 3})
28、getattr()描述：获取对象的属性
语法：getattr(object, name[, default])
参数：
object -- 对象。name -- 字符串，对象属性。default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。案例：
class Age(object): age = 1 my_a = Age()getattr(my_a, 'age') # 获取属性 bar 值 1getattr(my_a, 'age1')'Age' object has no attribute 'age1'
29、gobals()描述： 函数会以字典类型返回当前位置的全部全局变量。
语法：globals()
参数：无
案例：
a='runoob'print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。30、hasattr()描述：函数用于判断对象是否包含对应的属性。
语法：hasattr(object, name)
参数：
object -- 对象。name -- 字符串，属性名。案例：
class Coordinate: x = 10 y = -5 z = 0 point1 = Coordinate() print(hasattr(point1, 'x'))Trueprint(hasattr(point1, 'y'))Trueprint(hasattr(point1, 'z'))Trueprint(hasattr(point1, 'no')) # 没有该属性False31、hash()描述：返回对象的哈希值
语法：hash(object)
参数：object -- 对象；
案例：
hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。 在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。 class Test: def __init__(self, i): self.i = ifor i in range(10): t = Test(1) print(hash(t), id(t)) hash(point1)16294976 hash('返回对象的哈希值')4919828709165481160hash() 函数的用途hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，也用于校验程序在传输过程中是否被第三方（木马）修改，如果程序（字符）在传输过程中被修改hash值即发生变化，如果没有被修改，则 hash 值和原始的 hash 值吻合，只要验证 hash 值是否匹配即可验证程序是否带木马（病毒）。 name1='正常程序代码'name2='正常程序代码带病毒' print(hash(name1)) # -3048480827538126659print(hash(name2)) # -906572618724296132832、help()描述：返回对象的帮助文档
语法：help([object])
参数：object -- 对象
案例：
help('sys') # 查看 sys 模块的帮助help('str') # 查看 str 数据类型的帮助a = [1,2,3]help(a) # 查看列表 list 帮助信息 help(a.append) # 显示list的append方法的帮助33 、id()描述：id() 函数返回对象的唯一标识符，标识符是一个整数。CPython 中 id() 函数用于获取对象的内存地址。
语法：id([object])
参数：object -- 对象。
案例：
返回对象的内存地址a = 'runoob'id(a)26031672034、input()描述：Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。获取用户输入内容
语法：input([prompt])
参数：prompt: 提示信息
案例：
a = input("input:")input:1234print(a)12335、int()描述：int() 函数用于将一个字符串或数字转换为整型。 x可能为字符串或数值，将x 转换为一个普通整数。如果参数是字符串，那么它可能包含符号和小数点。如果超出了普通整数的表示范围，一个长整数被返回。
语法：int(x, base =10)
参数：
x -- 字符串或数字。base -- 进制数，默认十进制。案例：
int('12',16)18int('12',10)1236、isinstance()描述：isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
语法：isinstance(object, classinfo)
参数：
object -- 实例对象。classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。案例：
a = 2isinstance (a,int)Trueisinstance (a,str)Falseisinstance (a,(str,int,list))#是元组中的一个返回 TrueTrue
37、issubclass()描述：issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。如果class是classinfo类的子类，返回True：
语法：issubclass(class, classinfo)
参数：
class -- 类。classinfo -- 类。案例：
class A: passclass B(A): pass print(issubclass(B,A)) # 返回 True
38、iter()描述：iter() 函数用来生成迭代器。
语法：iter(object[, sentinel])
参数：
object -- 支持迭代的集合对象。sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。返回一个可迭代对象, sentinel可省略，sentinel 理解为迭代对象的哨兵，一旦迭代到此元素，立即终止：案例：
lst = [1,3,5]iter(lst)<list_iterator at 0xf8359e8>for i in iter(lst): print(i)135
39、len()描述：len() 函数返回对象（字符、列表、元组等）长度或项目个数。
语法：len(s)
参数：s -- 对象。
案例：
#字典的长度dic = {'a':1,'b':3}len(dic)2#字符串长度s='aasdf'len(s)5#列表元素个数l = [1,2,3,4,5]len(l)
40、list()描述：list() 函数创建列表或者用于将元组转换为列表。
语法：list( tup )
参数：tup -- 要转换为列表的元组。
案例：
atuple = (123, 'xyz', 'zara', 'abc')aList = list(atuple)aList[123, 'xyz', 'zara', 'abc']
41、map()描述：map() 会根据提供的函数对指定序列做映射。返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器
语法：map(function, iterable, ...)
参数：
function -- 函数iterable -- 一个或多个序列案例：
def square(x) : # 计算平方数 return x ** 2list(map(square, [1,2,3,4,5])) # 计算列表各个元素的平方[1, 4, 9, 16, 25]list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) # 使用 lambda 匿名函数[1, 4, 9, 16, 25]# 提供了两个列表，对相同位置的列表数据进行相加list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))[3, 7, 11, 15, 19]list(map(lambda x: x%2==1, [1,3,2,4,1]))[True, True, False, False, Tru
42、max()描述：max() 方法返回给定参数的最大值，参数可以为序列。
语法：max( x, y, z, .... )
参数：
x -- 数值表达式。y -- 数值表达式。z -- 数值表达式。案例：
最大值：max(3,1,4,2,1)4di = {'a':3,'b1':1,'c':4}max(di)'c'
43、min()描述：min() 方法返回给定参数的最小值，参数可以为序列。
语法：min( x, y, z, .... )
参数：
x -- 数值表达式。y -- 数值表达式。z -- 数值表达式。案例：
min(80, 100, 1000)80min([80, 100, 1000])80
44、memoryview()描述：memoryview() 函数返回给定参数的内存查看对象(Momory view)。返回由给定实参创建的“内存视图”对象， Python 代码访问一个对象的内部数据，只要该对象支持缓冲区协议 而无需进行拷贝
语法：memoryview(obj)
参数：obj -- 对象
案例：
v = memoryview(bytearray("abcefg", 'utf-8'))v[1]98v[-1]98 v[1:4]<memory at 0x0000028B68E26AC8>v[1:4].tobytes()b'bce'
45、next()描述：next() 返回迭代器的下一个项目。next() 函数要和生成迭代器的iter() 函数一起使用。
语法：next(iterator[, default])
参数：
iterator -- 可迭代对象default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。案例：
it = iter([5,3,4,1])next(it)5 next(it)3 next(it)4
46、object()描述：Object类是Python中所有类的基类，如果定义一个类时没有指定继承哪个类，则默认继承object类。返回一个没有特征的新对象。object 是所有类的基类。
语法：object()
参数：无
案例：无
47、open()描述：open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
语法：open(name[, mode[, buffering]])
参数：
name : 一个包含了你要访问的文件名称的字符串值。mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。模式
描述
r
以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+
打开一个文件用于读写。文件指针将会放在文件的开头。
rb+
以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w
打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb
以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+
打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+
以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a
打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+
打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
file 对象方法
file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。
file.readline()：返回一行。
file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。
for line in f: print（line ）：通过迭代器访问。
f.write("hello\n")：如果要写入字符串以外的数据,先将他转换为字符串。
f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。
f.seek(偏移量,[起始位置])：用来移动文件指针。
偏移量: 单位为比特，可正可负起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾f.close() 关闭文件
案例：
f=open('test.txt',encoding='utf-8') #打开文件data=f.read()#文件操作print(data)f.close() #关闭文件
48、pow()描述：pow() 方法返回 xy（x的y次方） 的值。函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z
语法：pow(x, y[, z])
参数：
x -- 数值表达式。y -- 数值表达式。z -- 数值表达式。案例：
pow(10, 2)100pow(4,3,5) 4等价于4**3%5
49、print()描述：打印对象，此函数不解释
语法：
参数：
案例：
50、property()描述：property() 函数的作用是在新式类中返回属性值。
语法：class property([fget[, fset[, fdel[, doc]]]])
参数：
fget -- 获取属性值的函数fset -- 设置属性值的函数fdel -- 删除属性值函数doc -- 属性描述信息案例：
暂不解释
51、range()描述：range() 函数可创建一个整数列表，一般用在 for 循环中。
语法：range(start, stop[, step])
参数：
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
案例：
list(range(10))[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] list(range(1, 11)) # 从 1 开始到 11[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]list(range(0, 30, 5))[0, 5, 10, 15, 20, 25]for i in range(5): print(i)0123
52、reversed()描述：reversed 函数返回一个反转的迭代器。
语法：reversed(seq)
参数：seq -- 要转换的序列，可以是 tuple, string, list 或 range。
案例：
#反转列表rev = reversed([1,4,2,3,1])list(rev)[1, 3, 2, 4, 1]for i in rev: print(i)13241 #反转字符串rev = reversed('我爱中国')list(rev)['国', '中', '爱', '我']for i in rev: print(i)国中爱
53、round()描述：round() 函数返回浮点数x的四舍五入值。
语法：round( x [, n] )
参数：
x -- 数值表达式。n --代表小数点后保留几位案例：
round(10.0222222, 3)10.022
54、set()描述：set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
语法：class set([iterable])
参数：iterable -- 可迭代对象对象；
案例：
#返回一个set对象，可实现去重：a = [1,4,2,3,1]set(a){1, 2, 3, 4}
55、slice()描述：slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。返回一个表示由 range(start, stop, step) 所指定索引集的 slice对象
语法：
class slice(stop)
class slice(start, stop[, step])
参数：
start -- 起始位置stop -- 结束位置step -- 间距案例：
a = [1,4,2,3,1]a[slice(0,5,2)] #等价于a[0:5:2][1, 2, 1]
56、sorted()描述：sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作；list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
语法：sorted(iterable, key=None, reverse=False)#cmp 3.x已经没有了
参数：
iterable -- 可迭代对象。key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。案例：
a = [5,7,6,3,4,1,2]b = sorted(a) # 保留原列表a [5, 7, 6, 3, 4, 1, 2]b[1, 2, 3, 4, 5, 6, 7] #利用keyL=[('b',2),('a',1),('c',3),('d',4)]sorted(L, key=lambda x:x[1]) [('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)] #降序排列a = [1,4,2,3,1]sorted(a,reverse=True) [4, 3, 2, 1, 1]
57、staticmethod描述：staticmethod 返回函数的静态方法。该方法不强制要求传递参数，如下声明一个静态方法：
语法：
class C(object):
@staticmethod
def f(arg1, arg2, ...):
以上实例声明了静态方法 f，从而可以实现实例化使用 C().f()，当然也可以不实例化调用该方法 C.f()。
参数：无
案例：
class C(object): @staticmethod def f(): print('runoob'); C.f(); # 静态方法无需实例化cobj = C()cobj.f() # 也可以实例化后调用
58 、str()描述：返回一个 str版本的 object，str 是内置字符串 class
语法：class str(object='')
参数：object -- 对象。
案例：
dict = {'runoob': 'runoob.com', 'google': 'google.com'};str(dict)"{'google': 'google.com', 'runoob': 'runoob.com'}"
59、sum()描述：sum() 方法对系列进行求和计算。
语法：sum(iterable[, start])
参数：
iterable -- 可迭代对象，如：列表、元组、集合。start -- 指定相加的参数，如果没有设置这个值，默认为0。案例：
a = [1,4,2,3,1]sum(a)11 sum(a,10) #求和的初始值为1021
60、super（）描述：super() 函数是用于调用父类(超类)的一个方法。
super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
语法：super(type[, object-or-type])
参数：
type -- 类。object-or-type -- 类，一般是 self
案例：
class A: def add(self, x): y = x+1 print(y)class B(A): def add(self, x): super().add(x)b = B()b.add(2) # 33
61、tuple()描述： 元组 tuple() 函数将列表转换为元组。
语法：tuple( iterable )
参数：iterable -- 要转换为元组的可迭代序列。
案例：
tuple([1,2,3,4])(1, 2, 3, 4) tuple({'a':2,'b':4}) #针对字典 会返回字典的key组成的tuple ('a', 'b')
62、type()描述：type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。isinstance() 会认为子类是一种父类类型，考虑继承关系。如果要判断两个类型是否相同推荐使用 isinstance()。
语法：
type(object)
type(name, bases, dict)
参数：
name -- 类的名称。bases -- 基类的元组。dict -- 字典，类内定义的命名空间变量。案例：
type([2])listtype({0:'zero'})dictx = 1 type( x ) == int # 判断类型是否相等True # 三个参数class X(object): a = 1X = type('X', (object,), dict(a=1)) # 产生一个新的类型 XX __main_
63、zip()描述：zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
语法：zip([iterable, ...])
参数：iterable 一个或多个迭代器
案例：
创建一个聚合了来自每个可迭代对象中的元素的迭代器：x = [3,2,1]y = [4,5,6]list(zip(y,x))[(4, 3), (5, 2), (6, 1)]#搭配for循环，数字与字符串组合 a = range(5)b = list('abcde')[str(y) + str(x) for x,y in zip(a,b)]['a0', 'b1', 'c2', 'd3', 'e4']list1 = [2,3,4]list2 = [5,6,7]for x,y in zip(list1,list2): print(x,y,'--',x*y)2 5 -- 103 6 -- 184 7 -- 28#元素个数与最短的列表一致list(zip(x,b)) [(3, 'a'), (2, 'b'), (1, 'c')]#与 zip 相反，zip(* ) 可理解为解压，返回二维矩阵式a1, a2 = zip(*zip(a,b)) a1(0, 1, 2, 3, 4)a2('a', 'b', 'c', 'd', 'e'
