Python标准库(三.x): 内建函数扫除文盲，python叁.x
| abs() | dict() | help() | min() | setattr() |
| all() | dir() | hex() | next() | slice() |
| any() | divmod() | id() | object() | sorted() |
| ascii() | enumerate() | input() | oct() | staticmethod() |
| bin() | eval() | int() | open() | str() |
| bool() | exec() | isinstance() | ord() | sum() |
| bytearray() | filter() | issubclass() | pow() | super() |
| bytes() | float() | iter() | print() | tuple() |
| callable() | format() | len() | property() | type() |
| chr() | frozenset() | list() | range() | vars() |
| classmethod() | getattr() | locals() | repr() | zip() |
| compile() | globals() | map() | reversed() | |
| complex() | hasattr() | max() | round() | |
| delattr() | hash() | memoryview() | set() |
python有局地常用的停放函数：
1.abx(x)
回到2个数的相对值。参数只怕是一个见惯不惊或长整型，恐怕四个浮点数。借使参数是一个复数，再次来到它的积。
abs(x)
求3个数的相对值。
>>> abs(13)
13
>>> abs(-15)
15
数学函数
2.all(iterable)
倘使迭代的有所因素都以真就赶回真。
abs(x)
求三个数的绝对值。
>>> abs(13)
13
>>> abs(-15)
15
all(iterable)
如若迭代器中的全数值都为“真”则赶回 True, 不然赶回 False
注意: 如若迭代器为空，重回 True
>>> all([1,1,1])
True
>>> all([1,0,1])
False
>>> all([])
True
abs() 获取相对值
3.any(iterable)
若果迭代中有3个成分为真就回来真。
all any
all(iterable)
要是迭代器中的所有值都为“真”则赶回 True, 不然赶回
False
注意:
假如迭代器为空，重返 True
>>> all([1,1,1])
True
>>> all([1,0,1])
False
>>> all([])
True
any(iterable)
即使迭代器中的放四多少个值为“真”则赶回 True, 不然赶回
False
注意: 一旦迭代器为空，再次回到 False
>>> any([1,0,0])
True
>>> any([0,0,0])
False
>>> any([])
False
min()求最小值
ascii
any(iterable)
假诺迭代器中的率性三个值为“真”则赶回 True, 不然赶回
False
注意:如若迭代器为空，重回 False
>>> any([1,0,0])
True
>>> any([0,0,0])
False
>>> any([])
False
ascii(object)
该函数重返表示对象的可打印ascii字符串，如若字符串中隐含非ascii字符，则以\x,
\u 或者 \U 编码来代表
函数实际是回来了目的的 __repr__() 方法的值
>>> a = 123
>>> a.__repr__()
'123'
>>> ascii(a)
'123'
>>>
>>> b = 'test'
>>> b.__repr__()
"'test'"
>>> ascii(b)
"'test'"
>>>
>>> class MyTest:
... def __repr__(self):
... return 'Hello, world.'
...
>>> t = MyTest()
>>> t.__repr__()
'Hello, world.'
>>> ascii(t)
'Hello, world.'
max()求最大值
bin
ascii(object)
该函数再次回到表示对象的可打字与印刷ascii字符串，假使字符串中带有非ascii字符，则以\x,
\u 或者 \U 编码来代表
函数实际是回来了对象的 __repr__() 方法的值
>>> a = 123
>>> a.__repr__()
'123'
>>> ascii(a)
'123'
>>>
>>> b = 'test'
>>> b.__repr__()
"'test'"
>>> ascii(b)
"'test'"
>>>
>>> class MyTest:
... def __repr__(self):
... return 'Hello, world.'
...
>>> t = MyTest()
>>> t.__repr__()
'Hello, world.'
>>> ascii(t)
'Hello, world.'
bin(x)
将整型调换为2进制的字符串，字符串以’0b’ 起初.
然而身为将整型转变为贰进制，其实是将目标的__index__()
方法重返的值转变为二进制字符串
注意: 倘诺目的未有__index__() 方法，将会发出非凡
>>> bin(11)
'0b1011'
>>> class MyTest():
... def __index__(self):
... return 5
...
>>> t = MyTest()
>>> bin(t)
'0b101'
hash()获取3个目标（字符串或数值）的哈希值
bool([x])
将一个值转换为Boolean,使用正规的真测试程序。假若x是假或忽略了，将赶回False;不然将回到True.bool也是1个class，它是int的1个子类，bool类不可能进一步子类化。它仅有False和True三个实例。
bool
bin(x)
将整型转换为贰进制的字符串，字符串以’0b’ 开首.
可是身为将整型调换为2进制，其实是将对象的__index__()
方法重临的值调换为贰进制字符串
注意: 固然目的未有__index__() 方法，将会发生分外
>>> bin(11)
'0b1011'
>>> class MyTest():
... def __index__(self):
... return 5
...
>>> t = MyTest()
>>> bin(t)
'0b101'
bool(x)
假如目标为“真”则赶回 True, 不然赶回 False
>>> bool(0)
False
>>> bool(1)
True
pow()，c风格的两次方，math.pow(x, y)
bytearray
bool(x)
若是目的为“真”则赶回 True, 不然赶回
False
>>> bool(0)
False
>>> bool(1)
True
bytearray([source[, encoding[, errors]]**])
制造二个 “可变的”
byte数组，能够应用整型，字符串和迭代器来开端化
参数为字符串时，字符串中的每四个字符将转移为数组的要素，因而供给提供编码类型，类似utf-8,
ascii等
参数为整型时，整形值将作为数组的发轫化大小，数组的因素则始于化为0
参数为迭代器时，迭代器的每一个要素将用作数组的成分，由此迭代器的值必须为0-255的整型，否则将发出分外。
>>> a = bytearray(10)
>>> a
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
>>> a[0]
0
>>> len(a)
10
>>>
>>> b = bytearray('abc', 'utf-8')
>>> b
bytearray(b'abc')
>>> b[0]
97
>>>
>>> c = bytearray(range(1,5))
>>> c
bytearray(b'\x01\x02\x03\x04')
>>> c[0]
1
>>>
>>> d = bytearray([1,2,3])
>>> d
bytearray(b'\x01\x02\x03')
>>> d[1] = 20
>>> d
bytearray(b'\x01\x14\x03')
sum()，对队列进行求和
bytes
bytearray([source[, encoding[, errors]]**])
创造三个 “可变的”
byte数组，能够使用整型，字符串和迭代器来起先化
参数为字符串时，字符串中的每1个字符将改换为数组的因素，由此要求提供编码类型，类似utf-8, ascii等
参数为整型时，整形值将用作数组的开首化大小，数组的成分则开首化为0
参数为迭代器时，迭代器的每1个因素将作为数组的因素，因而迭代器的值必须为0-25五的整型，不然将时有产生10分。
>>> a = bytearray(10)
>>> a
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
>>> a[0]
0
>>> len(a)
10
>>>
>>> b = bytearray('abc', 'utf-8')
>>> b
bytearray(b'abc')
>>> b[0]
97
>>>
>>> c = bytearray(range(1,5))
>>> c
bytearray(b'\x01\x02\x03\x04')
>>> c[0]
1
>>>
>>> d = bytearray([1,2,3])
>>> d
bytearray(b'\x01\x02\x03')
>>> d[1] = 20
>>> d
bytearray(b'\x01\x14\x03')
bytes([source[, encoding[, errors]]**])
bytes是bytearray的3个不可变的本子，其余的能够参见bytearray
>>> d = bytes([1,2,3])
>>> d
b'\x01\x02\x03'
>>> d[1] = 20
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment
round(x[, n])重返浮点数的四舍伍入，n表示小数点后留下位数，默感觉0.
callable(object)
要是object参数能够调用就再次来到True,不然再次来到False。假如回到True,它依旧或然调用退步，不过若是回去False，就长久不或然调用成功。注类是可调用的（调用1个类重临2个实例）;类的实举例果有一个__call__()方法正是可调用的。
callable
bytes([source[, encoding[, errors]]**])
bytes是bytearray的一个不可变的版本，别的的可以参照bytearray
>>> d = bytes([1,2,3])
>>> d
b'\x01\x02\x03'
>>> d[1] = 20
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment
callable(object)
判断目的是否能够调用，要是得以则赶回 True, 不然赶回
False
类是可调用的，调用后再次回到1个类的实例。对象假如含有了__call__()办法也是可调用的。
其实，只要可以写成 object() 的，都是callable的
>>> def foo():
... pass
...
>>> callable(foo)
True
>>>
>>> class MyTest:
... def __call__(self):
... pass
...
>>> callable(MyTest)
True
>>> a = MyTest()
>>> callable(a)
True
>>>
>>> b = 1
>>> callable(b)
False
进制调换
chr(x)
回去1个ascii码是整数x的字符的字符串。举个例子，chr(玖7)重回string
‘a’.那和ord()刚好相反。
callable(object)
判别目的是还是不是能够调用，假设得以则赶回 True, 不然赶回
False
类是可调用的，调用后回到一个类的实例。对象借使带有了__call__()主意也是可调用的。
其实，只要能够写成
object()
的，都是callable的
>>> def foo():
... pass
...
>>> callable(foo)
True
>>>
>>> class MyTest:
... def __call__(self):
... pass
...
>>> callable(MyTest)
True
>>> a = MyTest()
>>> callable(a)
True
>>>
>>> b = 1
>>> callable(b)
False
chr(i)
返回Unicode对应的字符。
参数范围为 0 — 1114111, 超越此限制将时有产生拾贰分
>>> chr(97)
'a'
>>> chr(1666)
'ڂ'
>>> chr(1200000)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)
bin()重返三个整型int或long int的二进制表示
classmethod(function)
回到函数的一个类措施。
chr(i)
返回【金沙注册送58】内建函数扫除文盲，內建函数。Unicode相应的字符。
参数范围为 0 —
1114111, 超过此限制将发生非常
>>> chr(97)
'a'
>>> chr(1666)
'ڂ'
>>> chr(1200000)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)
classmethod(function)
一般作为函数装饰器 @classmethod
将类中的二个措施钦赐为类形式。被钦赐的类措施第三个参数必须为cls(方法所在的类)
类方法的调用能够平素通过类调用，即C.f();
也足以由此实例调用，即C().f()
类格局有二个相比较便利的用处正是作为类似C++中的开首化函数重载
class MyTest():
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
@classmethod
def from_string(cls, date_string):
year, month, day = map(int, date_string.split('-'))
return cls(year, month, day)
def output(self):
print('Birthday: {}-{}-{}'.format(self.year, self.month, self.day))
>>> a = MyTest(1989, 12, 26)
>>> a.output()
Birthday: 1989-12-26
>>>
>>> b = MyTest.from_string('1990-1-1')
>>> b.output()
Birthday: 1990-1-1
oct()将二个平头转变来捌进制字符串
compile(string, filename, kind[, flags[, dont_inherit]])
编译string为四个代码对象。代码对象能够通过exec语句施行也许通过调用eval()计算。这filename参数钦定代码从哪些文件读取。假诺不从文件中读取，就须传递一些可甄其余值（常常采纳”）。kind参数内定哪种代码被编写翻译;假如是包涵壹三种语句组成的子符串能够‘exec’,假如是由三个表明式组成，就’eval’,假若由一个互动语句组成就‘singlw’(表明式语句计算的结果不是None将打字与印刷出来)。
当编写翻译三个多行语句时，应用多个警示：必须以’\n’作为行停止符，同时输入必须至少以1个’\n’作为达成。假若是以’\r\n’作为行终止，使用string的repalce()方法将其改为‘\n’.
可选的参数flags和dont_inherit调节影响string编写翻译的future语句。
classmethod(function)
一般作为函数装饰器 @classmethod
将类中的一个办法钦定为类情势。被钦定的类措施第二个参数必须为cls(方法所在的类)
类方法的调用能够直接通过类调用，即C.f();
也足以因而实例调用，即C().f()
类格局有3个相比较便于的用处正是作为类似C++中的开端化函数重载
class MyTest():
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
@classmethod
def from_string(cls, date_string):
year, month, day = map(int, date_string.split('-'))
return cls(year, month, day)
def output(self):
print('Birthday: {}-{}-{}'.format(self.year, self.month, self.day))
>>> a = MyTest(1989, 12, 26)
>>> a.output()
Birthday: 1989-12-26
>>>
>>> b = MyTest.from_string('1990-1-1')
>>> b.output()
Birthday: 1990-1-1
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
该函数将富含python语句的字符串编写翻译成可实行的字节码，编写翻译的结果合营
eval, 或 exec 使用。
source — 须要编写翻译的字符串
filename — 存款和储蓄字符串的文书
mode — ‘eval’ 配合 eval 使用, ‘exec’ 合营多语句的 exec
使用，’single’ 合营单语句的 exec 使用
注：实地衡量中，编写翻译的时候会剖断mode, 可是推行的时候利用
exec 或者 eval，结果一律
>>> a = compile('1+2', filename='', mode='eval')
>>> eval(a)
3
>>>
>>> b = compile('for i in range(3): print(i)', filename='', mode='exec')
>>> exec(b)
0
1
2
>>>
>>> c = compile('print("Hello, world.")', filename='', mode='exec')
>>> exec(c)
Hello, world.
hex() 将拾进制整数转变为1陆进制
complex( [real[, imag]])
成立多少个复数real + imag*j大概将二个string恐怕number转化为贰个复数.
要是第二个参数是二个字符串,它将作为复数解释，函数将被调用，而忽略第一个参数。第3个参数不容许是三个字符串。每三个参数都恐怕是三个数字类型包罗复数.即使imag省略了,
它暗中同意为0，函数将用作七个数字转换函数像 int(), long() and
float().假如参数都简短了，将回到0j.
complex
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
该函数将含有python语句的字符串编写翻译成可实施的字节码，编写翻译的结果合营
eval, 或
exec
使用。
source — 须求编写翻译的字符串
filename — 存款和储蓄字符串的文件
mode — ‘eval’ 配合 eval 使用, ‘exec’
协作多语句的 exec
使用，’single’ 合营单语句的 exec 使用
注：实地衡量中，编译的时候会判定mode,
可是实行的时候利用 exec 或者 eval，结果1致
>>> a = compile('1+2', filename='', mode='eval')
>>> eval(a)
3
>>>
>>> b = compile('for i in range(3): print(i)', filename='', mode='exec')
>>> exec(b)
0
1
2
>>>
>>> c = compile('print("Hello, world.")', filename='', mode='exec')
>>> exec(c)
Hello, world.
complex([real[, imag]])
再次回到2个复数。复数值为 real + imag\1j*
参数也得以为三个代表复数的字符串，不过字符串中不可能有空格。使用字符串作为参数时，未有第1个参数。***
注1: 七个参数的缺省值均为0
注2: 直接用复数表达式 a+bj 创设的对象也是 complex
类型
>>> a = complex(1, 2)
>>> a
(1+2j)
>>>
>>> b = 2+3j
>>> type(b)
<class 'complex'>
>>>
>>> c = complex('5+6j')
>>> c
(5+6j)
>>>
>>> d = complex(1+2j, 1+2j)
>>> d
(-1+3j)
类型转变
copyright
complex([real[, imag]])
再次回到3个复数。复数值为 real + imag\1j*
参数也足感到三个表示复数的字符串，不过字符串中不可能有空格。使用字符串作为参数时，未有首个参数。***
注1:
四个参数的缺省值均为0
注2:
直接用复数表明式 a+bj
成立的目的也是 complex 类型
>>> a = complex(1, 2)
>>> a
(1+2j)
>>>
>>> b = 2+3j
>>> type(b)
<class 'complex'>
>>>
>>> c = complex('5+6j')
>>> c
(5+6j)
>>>
>>> d = complex(1+2j, 1+2j)
>>> d
(-1+3j)
delattr(object, name)
删除对象的2个性格（不能够是目的的点子），不过不会影响该类的别样对象。同
del object.name
**注: 参数* name 是3个字符串
>>> class MyTest():
... def __init__(self):
... self.test = 'test'
...
>>> a = MyTest()
>>> a.test
'test'
>>> b = MyTest()
>>> b.test
'test'
>>> delattr(a, 'test')
>>> a.test
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'test'
>>>
>>> b.test
'test'
int()将一个字符串或数字传换来整数，int(x, base=10)
credits
delattr(object, name)
删除对象的三个性格（不可能是目的的不二等秘书技），可是不会影响该类的别的对象。同
del
object.name
**注: 参数* name 是3个字符串
>>> class MyTest():
... def __init__(self):
... self.test = 'test'
...
>>> a = MyTest()
>>> a.test
'test'
>>> b = MyTest()
>>> b.test
'test'
>>> delattr(a, 'test')
>>> a.test
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'test'
>>>
>>> b.test
'test'
dict(\*kwarg) dict(mapping, **kwarg) dict(iterable, **kwarg*)
创制并回到一个字典对象。初叶化参数能够有两种传播格局。
关键字方式，将直接依据首要字生成字典
迭代器方式，迭代器中的对象必须只有八个要素，第二个成分将用作key，第二个作为值
映射情势，其实也是1种迭代器格局
注: 当然也足以一向使用字典作为参数来开端化
>>> dict(one=1, two=2, three=3)
{'two': 2, 'one': 1, 'three': 3}
>>>
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))
{'one': 1, 'two': 2, 'three': 3}
>>>
>>> dict([('one', 1), ('two', 2), ('three', 3)])
{'one': 1, 'two': 2, 'three': 3}
>>>
>>> dict({'one':1, 'two':2, 'three':3})
{'one': 1, 'two': 2, 'three': 3}
float()将整数和字符串调换到浮点数
delattr( object, name)
与setattr()相对的，参数是一个目的和贰个string.string必须是目的的三个属性。函数删除object那些名字为string的质量。举个例子，delattr(x,
‘foobar’)等价于del x.foobar
dict(\*kwarg) dict(mapping, **kwarg) dict(iterable, **kwarg*)
创建并赶回三个字典对象。开头化参数能够有二种传播格局。
关键字格局，将直接根据主要字生成字典
迭代器格局，迭代器中的对象必须唯有八个要素，第三个要素将作为key，第一个作为值
映射方式，其实也是一种迭代器格局
注: 当然也足以一向动用字典作为参数来开始化
>>> dict(one=1, two=2, three=3)
{'two': 2, 'one': 1, 'three': 3}
>>>
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))
{'one': 1, 'two': 2, 'three': 3}
>>>
>>> dict([('one', 1), ('two', 2), ('three', 3)])
{'one': 1, 'two': 2, 'three': 3}
>>>
>>> dict({'one':1, 'two':2, 'three':3})
{'one': 1, 'two': 2, 'three': 3}
dir([object])
很有用的鼎力相助函数。展现当前定名空间，对象大概类的享有属性和艺术。
object 可以为对象或许类，假如轻松表示近来的命名空间
>>> class MyTest():
... pass
...
>>> def foo():
... pass
...
>>> a = 1
>>>
>>> dir()
['MyTest', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'foo']
>>>
>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
>>>
>>> d = dict()
>>> dir(d)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
complex()用于成立一个复数，形如real+imag*j
dict( [arg])
以叁个可选的职位参数或壹组第二词参数开端化二个字典。假若未有交给参数，重返1个空的字典。假设地方参数arg是1个炫目对象，再次来到3个字典映射与映射对象同样的keys对应一律的值。那么地点参数应是二个队列，支持迭代的器皿，恐怕是2个迭代目标。参数的每三个因素也非得是内部的壹种，同时每1个饱含八个对象。第壹个作为新字典的key,同时第2个作为那一个key的值。借使给定的key不只出现1遍，那新字典将涵盖最终叁个值。
即使给出的是重中之重词参数，关键词和与其生死相依的值都将用作字典的项加多到字典中。假使3个ke既作为任务参数和作为多个根本词参数，关键词关联的值将保存在字典中。
归来都等价于{“one”: 2, “two”: 叁}
dir([object])
很有用的扶助函数。突显当前定名空间，对象恐怕类的享有属性和艺术。
object
可以为目的只怕类，倘诺轻易表示最近的命名空间
>>> class MyTest():
... pass
...
>>> def foo():
... pass
...
>>> a = 1
>>>
>>> dir()
['MyTest', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'foo']
>>>
>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
>>>
>>> d = dict()
>>> dir(d)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
divmod(a, b)
返回 (a // b, a % b) 的元组
注：a，b可以为整型恐怕浮点型，但是不能够是复数
>>> divmod(7, 3)
(2, 1)
>>>
>>> divmod(4.3, 1.5)
(2.0, 1.2999999999999998)
>>>
>>> (4.3 // 1.5, 4.3 % 1.5)
(2.0, 1.2999999999999998)
chr() 将0～25伍限量内的整数转变为对应的ascii字符
dir( [object])
即便未有参数，重临当前local符号表中名字的列表。假诺有二个参数将尝试重临那些参数对象的有效性属性。从目的的__dict__（倘诺定义了）属性，类或type对象搜聚新闻。那几个列表不自然是1体化的。假若目标是多个模块对象，list包蕴模块属性的列表。假如目的是一个type或class对象，列表将含有属性的名字，同时递归其营地的习性。不然，列表将富含对象属性的名字，类天性的名字，递归若基类的属性名字。结果列表按字母顺序排序。
divmod(a, b)
返回 (a // b, a
% b) 的元组
注：a，b可以为整型也许浮点型，但是不能够是复数
>>> divmod(7, 3)
(2, 1)
>>>
>>> divmod(4.3, 1.5)
(2.0, 1.2999999999999998)
>>>
>>> (4.3 // 1.5, 4.3 % 1.5)
(2.0, 1.2999999999999998)
enumerate(iterable, start=0)
重返一个可迭代的枚举类型。
迭代器中的对象，第二个因素为序号（默许从start=0先导），第三个要素为流传迭代器中的对象。
注: 多用于for遍历进程中，须要同时获取序号的状态。
>>> names = ['Tom', 'Jack', 'Lily']
>>> for i, name in enumerate(names, start=1):
... print(i ,name)
...
1 Tom
2 Jack
3 Lily
ord() 意义和chr()相反，以字符为参数，再次来到对应的ascii数值。
divmod( a, b)
用八个数字（不是复数）作为参数，重返long除法得到的商和余数组成的壹对数字。使用混合的操作类型，混合的种类，将应用使用二进制算术操作。对于一般和长整数，结果与(a
// b, a % b)同样。对于浮点数结果和(q, a % b)同样，q经常是math.floor(a /
b)，但若是是比一小，就为一.在别的动静下q * b + a % b与a很类似，假诺a %
b是非0的，它与b有一样的标记，同时0 <= abs(a % b) < abs(b).
divmod
enumerate(iterable, start=0)
重临1个可迭代的枚举类型。
迭代器中的对象，第3个要素为序号（默许从start=0初始），首个成分为流传迭代器中的对象。
注: 多用于for遍历进程中，须求同时得到序号的状态。
>>> names = ['Tom', 'Jack', 'Lily']
>>> for i, name in enumerate(names, start=1):
... print(i ,name)
...
1 Tom
2 Jack
3 Lily
eval(expression, globals=None, locals=None)
将二个表示python表明式的字符串编写翻译成python话语并进行（慎用！）
再次来到值，假使传入参数是字符串或许mode=’eval’编译的字节码，则赶回交互式运营结果，不然重回None
globals和locals为高等用法，此处不开始展览。私下认可使用当前命名空间。
注1: 语句必须是单条语句
注2: 字符串中得以教导变量，但变量必须在命令空间中定义。
注3: 能够相配compile()使用
>>> eval('2+5')
7
>>> x = 3
>>> eval('x**2 + 3*x + 5')
23
bool()将加以参数调换为布尔类型，假使没有参数，重回False。bool是int的子类。
enumerate( iterable)
归来enumerate对象. iterable必须是2个行列, 三个迭代,
可能其他对象它帮忙迭代.enumerate()再次回到的iterator的next()方法
重临三个元组包蕴一定的数量（从0初叶）和从迭代中获得的相应的值。
eval(expression, globals=None, locals=None)
将多少个代表python表明式的字符串编写翻译成python说话并施行（慎用！）
重返值，借使传入参数是字符串只怕mode=’eval’编写翻译的字节码，则赶回交互式运营结果，不然重返None
globals和locals为高端用法，此处不开始展览。暗中认可使用当前定名空间。
注1: 语句必须是单条语句
注2: 字符串中能够引导变量，但变量必须在指令空间中定义。
注3: 能够同盟compile()使用
>>> eval('2+5')
7
>>> x = 3
>>> eval('x**2 + 3*x + 5')
23
exec(object, [globals[, locals]])
将三个表示python表明式的字符串编写翻译成python言语并实施（慎用！）
重返值为None
globals和locals为高等用法，此处不开始展览。暗许使用当前命名空间。
注1: 语句能够是多条
注2: 字符串中得以辅导变量，但变量必须在指令空间中定义。
注3: 能够兼容compile()使用
>>> exec('for i in range(5): print(i)')
0
1
2
3
4
str()将对象转化为适应阅读的样式
eval( expression[, globals[, locals]])
该参数是七个字符串和可选的globals和locals。倘诺提供globals，globals必须是二个字典。要是提供locals，locals能够是其它映射对象。
expression参数是用作1个Python表达式被分析和评价（本事上来说，二个标准列表）使用globals以及locals字典作为global和local名字空间。假如提供了globals字典但未有’__builtins__’，当前globals在表达式被解析前被复制到globals中。那象征表达式能够完全访问规范__builtin__模块和受限的境遇。假诺locals字典省略则暗中同意为globals字典。要是八个字典都被轻松，表达式在调用eval的意况中实行。重返值是计量表明式的结果。语法错误报告为exceptions。
举个例子:
>>> x = 1
>>> print eval(‘x+1’)
2
此函数也得以用来实施放4代码的靶子（如compile()创造的）。在那种情景下，传入1个代码对象，而不是三个字符串。该代码对象必须已编写翻译传给’eval’作为那种参数。
晋升：EXEC语句扶助是动态实践语句。execfile（）函数协助从一个文本中试行语句。globals()和locals()函数分别再次回到当前的global和local字典，那对利用eval（）或execfile（）很有帮带
exec(object, [globals[, locals]])
将一个意味python表明式的字符串编写翻译成python讲话并实践（慎用！）
重临值为None
globals和locals为高等用法，此处不开展。暗中同意使用当前命名空间。
注1: 语句能够是多条
注2: 字符串中能够带领变量，但变量必须在指令空间中定义。
注3: 可以匹配compile()使用
>>> exec('for i in range(5): print(i)')
0
1
2
3
4
filter(function, iterable)
将二个可迭代的靶子按传入的函数实行过滤。函数再次来到 True
的成分将保存，别的将被过滤掉。
>>> a = [1,2,3,4,5,6,7,8,9]
>>> list(filter(lambda x: x % 2, a))
[1, 3, 5, 7, 9]
列表、元组、字典相关函数
exec
filter(function, iterable)
将一个可迭代的靶子按传入的函数实行过滤。函数重临 True
的成分将保存，其余将被过滤掉。
>>> a = [1,2,3,4,5,6,7,8,9]
>>> list(filter(lambda x: x % 2, a))
[1, 3, 5, 7, 9]
float([x]金沙注册送58 ，)
成立并回到三个浮点型的对象。
x可以为1个数要么多少个代表浮点数的字符串，缺省值为0
>>> float(3)
3.0
>>> float('1.23')
1.23
dict() 生成字典，dict()生成空字典，dict(a=’e’, b=’f’,
c=’g’)，传加入关贸总协定组织键字，{‘a’:’e’, ‘b’:’f’, ‘c’:’g’}，dict(zip([‘one’,
‘two’, ‘three’], [1, 2, 3]))，dict([(‘one’, 1), (‘two’, 2),
(‘three’, 3)])
exit()
退出
float([x])
创建并再次回到一个浮点型的对象。
x可认为三个数只怕2个意味浮点数的字符串，缺省值为0
>>> float(3)
3.0
>>> float('1.23')
1.23
format(value [, format_spec])
将value按格式化转化为字符串，并再次回到。
近期较多的用法是调用字符串的format方法。
format_spec 钦命格式化格局，此处不开始展览（将会有专题博文）。
>>> format(10, 'b')
'1010'
>>> format('555', '0>5')
'00555'
list()将元组转变为列表
filter( function, iterable)
function重临true时从iterable的要素中组织1个列表。迭代可以是二个体系，贰个支撑迭代的容器，或二个迭代器，假若Iterable的是三个字符串或3个元组，其结果也有这种类型的，不然它始终是一个列表。要是function是None，假定它是恒等函数，即，迭代是false其全部因素都被去除。
请留心，filter(function,iterable)，要是函数不为None等价于[item for item
in iterable if function(item)]，假使函数为None等价于[item for item in
iterable if item]。
format(value [, format_spec])
将value按格式化转化为字符串，并赶回。
近日较多的用法是调用字符串的format方法。
format_spec
钦点格式化方式，此处不实行（将会有专题博文）。
>>> format(10, 'b')
'1010'
>>> format('555', '0>5')
'00555'
frozenset([iterable])
传入叁个可迭代的靶子，创设叁个不可变的汇聚。除了成分无法增加删除却，其余和可变集结类似。
如若未有参数，则开创三个空群集。
>>> a = frozenset([1,2,2,3,4,5])
>>> a
frozenset({1, 2, 3, 4, 5})
>>> 2 in a
True
tuple()将列表转变为元组
float(x)
将字符串或数字调换或一个浮点数。假若参数是3个字符串，它必须包涵三个可能带符号的十进制或浮点数，恐怕嵌入空格。不然，参数能够是三个惯常或长整数或浮点数，再次回到二个与之一样值的浮点数（在Python的浮点精度内）。假若未有交给参数，重返0.0。
frozenset([iterable])
传入多个可迭代的目标，创制2个不可变的联谊。除了成分不可能增加删除此之外，别的和可变集合类似。
如若未有参数，则开创一个空群集。
>>> a = frozenset([1,2,2,3,4,5])
>>> a
frozenset({1, 2, 3, 4, 5})
>>> 2 in a
True
getattr(object, name [, default])
获取对象的多少个属性的值。
假诺目标存在该属性则再次来到属性值。
倘诺属性不存在，当传了default时返回default的值，不然产生非凡。
注:参数 name 是三个字符串
>>> class MyTest():
... def __init__(self):
... self.test = 'test'
...
>>> a = MyTest()
>>> getattr(a, 'test')
'test'
>>> getattr(a, 'foo', 'attr not exist')
'attr not exist'
>>>
>>> getattr(a, 'foo')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'foo'
all()，any()的参数都以元组或列表，分裂：all()借使全体因素都不是0、”、False只怕iterable为空，重返True，不然再次回到False；any()如若持有因素为空、0、False则赶回False，如若不都为空、0、False，则赶回True；all()参数是空驶列车表或空元组，重回True，any(）重临False。
format
getattr(object, name [, default])
获取对象的八本品质的值。
倘若目的存在该属性则重回属性值。
如果属性不设有，当传了default时返回default的值，不然产生1贰分。
注:参数 name 是3个字符串
>>> class MyTest():
... def __init__(self):
... self.test = 'test'
...
>>> a = MyTest()
>>> getattr(a, 'test')
'test'
>>> getattr(a, 'foo', 'attr not exist')
'attr not exist'
>>>
>>> getattr(a, 'foo')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'foo'
globals()
再次来到当前全局域的{对象: 值} 字典
>>> globals()
{'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__doc__': None, 'a': <__main__.MyTest object at 0x7f04880fb780>, '__spec__': None, 'MyTest': <class '__main__.MyTest'>}
slice(stop)，或slice(start, stop[, step])实现切成条对象。print([1, 2,
3, 4, 5, 6, 7][slice(3)])
frozenset( [iterable])
回来3个frozenset对象，其成分来自于Iterable。
Frozensets组未有更新的法门，但足以哈希和任何组成员或当作字典键使用。贰个frozenset的要素必须是不足退换。内部sets也应是frozenset对象。要是迭代不曾点名，重临1个新的空集，frozenset
([])。
globals()
再次回到当前全局域的{对象: 值} 字典
>>> globals()
{'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__doc__': None, 'a': <__main__.MyTest object at 0x7f04880fb780>, '__spec__': None, 'MyTest': <class '__main__.MyTest'>}
hasattr(object, name)
判别2个对象是还是不是存在内定的习性。存在再次来到 True, 不然赶回
False
**注: 参数*name *是3个字符串***
>>> class MyTest():
... def __init__(self):
... self.test = 'test'
...
>>> a = MyTest()
>>> hasattr(a, 'test')
True
>>> hasattr(a, 'foo')
False
filter()用于过滤类别，函数再次回到filter对象
getattr( object, name[, default])
回来object名叫name属性的值。名称必须是二个字符串。假如该字符串是目的的里边属性名字，结果是该属性的值。比方，getattr(x,
‘foobar’)约等于x.foobar。假诺钦赐的习性不存在，则赶回暗许提供的，不然抛出AttributeError
hasattr(object, name)
推断一个目标是或不是留存钦命的性子。存在重临 True, 不然赶回
False
**注: 参数*name
*是叁个字符串***
>>> class MyTest():
... def __init__(self):
... self.test = 'test'
...
>>> a = MyTest()
>>> hasattr(a, 'test')
True
>>> hasattr(a, 'foo')
False
hash(object)
再次来到3个对象的hash值，就算目的不可hash会发出卓殊。
>>> hash(10)
10
>>>
>>> hash('test')
2595417156033713210
>>>
>>> hash((1,2,3))
2528502973977326415
>>>
>>> hash([1,2,3])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
eg。
globals()
再次来到代表当前global符号表字典的字典。那平素是近期模块字典（在2个函数或措施内，是在它被定义的模块，而不是被调用的模块）。
hash(object)
再次来到2个对象的hash值，假使目的不可hash会发生相当。
>>> hash(10)
10
>>>
>>> hash('test')
2595417156033713210
>>>
>>> hash((1,2,3))
2528502973977326415
>>>
>>> hash([1,2,3])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
help([object])
彰显对象的扶植新闻。假设没有参数则进入帮衬的交互情势。
>>> help(eval)
Help on built-in function eval in module builtins:
eval(source, globals=None, locals=None, /)
Evaluate the given source in the context of globals and locals.
The source may be a string representing a Python expression
or a code object as returned by compile().
The globals must be a dictionary and locals can be any mapping,
defaulting to the current globals and locals.
If only globals is given, locals defaults to it.
def is_odd(n):
return n % 2 == 1
aList = filter(is_odd, [1, 2, 3, 4, 5, 6, 7])
print(list(aList))
hasattr( object, name)
该参数是一个目的和1个字符串。如果字符串是目标的中间3个性子，结果为True，假使未有回去False。
（那是因此调用的getattr（对象名称），看是还是不是吸引那几个与否。）
help([object])
显示对象的帮带信息。借使没有参数则进入协助的互动方式。
>>> help(eval)
Help on built-in function eval in module builtins:
eval(source, globals=None, locals=None, /)
Evaluate the given source in the context of globals and locals.
The source may be a string representing a Python expression
or a code object as returned by compile().
The globals must be a dictionary and locals can be any mapping,
defaulting to the current globals and locals.
If only globals is given, locals defaults to it.
hex(x)
再次回到x的1陆进制字符串，字符串以’0x’开首，字符串中的字符都是小写格局表示。
当x不是三个int型对象时，则对象必须定义二个__index__()
方法，则赶回整型值，不然将时有产生12分。
>>> hex(64)
'0x40'
>>> hex(-10)
'-0xa'
迭代相关函数
hash()
回来对象（尽管局地话）的哈希值。哈希值是整数。它们被用来在词典查找时，作为二个火速比较字典keys键。具备同等的哈希值，数值相等（即便它们属于不相同的系列，因为是一和壹.0的景况）。
hex(x)
重返x的16进制字符串，字符串以’0x’开端，字符串中的字符都以小写情势表示。
当x不是二个int型对象时，则对象必须定义3个__index__()
方法，则赶回整型值，不然将产生卓殊。
>>> hex(64)
'0x40'
>>> hex(-10)
'-0xa'
id(object)
再次回到对象的在那之中ID值。
>>> id(123)
10923328
>>> id('test')
140589176043704
>>> id([1,2,3])
140589199591816
next(iterator[,defaul]) 再次来到迭代器的下二个档案的次序。
help(object)
调用内置的帮手系统。
（此功效是为互相使用。）借使未有付诸参数，交互式援救系统运营解释调节台。固然参数是三个字符串，然后是字符串被当做2个module，function，class，method，keyword或文书档案大旨名称和支援页面名字实行查找后在调节台上打印出来。若是参数是其它别的门类的对象，将时有爆发该目标的几个增派页面。
id(object)
重返对象的内部ID值。
>>> id(123)
10923328
>>> id('test')
140589176043704
>>> id([1,2,3])
140589199591816
input([prompt])
接收标准输入转为字符串并再次回到。
prompt 为输入提示字符串，可以省略。
注：万一读到 EOF 将产生相当。
>>> s = input('Enter: ')
Enter: hello
>>> s
'hello'
sorted(iterable, key=None,
reverse=False)，key用来进展相比较的因素，内定可迭代对象的多少个要一直拓展排序，reverse排序规则，True为降序，False为升序。和list.sort()的分别：sorted会修改原始的list，list.sort()再次来到为None；别的list.sort()只为list定义，sorted函数能够承受任何iterable。eg：print(sorted({一:’A’,
二:”B”, 3:”C”}))
hex(x)
改动二个（任意大小）整数为十陆进制字符串。
input([prompt])
接收标准输入转为字符串并回到。
prompt
为输入提醒字符串，能够省略。
注：如若读到 EOF 将产生非凡。
>>> s = input('Enter: ')
Enter: hello
>>> s
'hello'
int(x=0) int(x, base=10)
再次回到1个整型数。输入参数能够是3个数要么3个字符串（当然能够是其余对象，但那边不上课那种肥猪流用法）。
参数为三个数时，重临对象的__int__()方法的值，对于整型对象便是作者的值，对于浮点型对象正是整数有的。
参数为三个字符串时，字符串必须代表三个2、捌、拾、1六进制，并传播相应的base值。
>>> int(3)
3
>>> int(1.25)
1
>>> int('101', 2)
5
>>> int('54', 8)
44
>>> int('123', 10)
123
>>> int('F3', 16)
243
iter()用于转移迭代器
id(object)
回到对象的“identity”。那是多个平头（或长整型），那是确定保障是唯1的，与目标的生命周期同样长。三个非重叠的生命周期的目的可能有壹致的ID（）值。
（落成注意：那是目的的地址。）
int(x=0) int(x, base=10)
再次回到三个整型数。输入参数能够是五个数依然一个字符串（当然能够是任何对象，但此处不上课那种社会的遗弃者用法）。
参数为3个数时，重临对象的__int__()方法的值，对于整型对象正是自身的值，对于浮点型对象便是整数片段。
参数为2个字符串时，字符串必须代表二个二、八、10、1陆进制，并传到相应的base值。
>>> int(3)
3
>>> int(1.25)
1
>>> int('101', 2)
5
>>> int('54', 8)
44
>>> int('123', 10)
123
>>> int('F3', 16)
243
isinstance(object, classinfo)
决断目的是或不是属于钦命的类。（能够合作 type 使用）
注1: 倘若钦赐类是近日目的的父类，推断结果也是 True
**注2: 如果* classinfo
参数是三个元组，那么只要对象属于内部的一个类即再次回到 True
>>> a = 12
>>> b = 25
>>> isinstance(a, int)
True
>>> isinstance(a, type(b))
True
>>> class A:
... pass
...
>>> class B(A):
... pass
...
>>> a = A()
>>> b = B()
>>> isinstance(a, A)
True
>>> isinstance(b, B)
True
>>> isinstance(a, B)
False
>>> isinstance(b, A)
True
>>> isinstance(a, (A,B))
True
面向对象相关函数
input()
收获用户输入的值
isinstance(object, classinfo)
剖断目的是或不是属于钦赐的类。（能够协作 type 使用）
注1: 假若钦命类是近期目的的父类，判别结果也是 True
**注2: 如果* classinfo 参数是1个元组，那么只要对象属于内部的二个类即重回 True
>>> a = 12
>>> b = 25
>>> isinstance(a, int)
True
>>> isinstance(a, type(b))
True
>>> class A:
... pass
...
>>> class B(A):
... pass
...
>>> a = A()
>>> b = B()
>>> isinstance(a, A)
True
>>> isinstance(b, B)
True
>>> isinstance(a, B)
False
>>> isinstance(b, A)
True
>>> isinstance(a, (A,B))
True
issubclass(class, classinfo)
判别二个类是不是为钦命类的子类。
注1: 类都以本身的子类
注2: 如果 classinfo参数是三个元组，那么只要类属于内部八个类的子类即再次来到 True
>>> class A:
... pass
...
>>> class B(A):
... pass
...
>>> issubclass(B, A)
True
>>> issubclass(A, B)
False
>>> issubclass(A, A)
True
>>> issubclass(A, (A,B))
True
setattr(object, name, value)，getattr(object,
name)用于安装和收获属性，该属性必须存在。hasattr(object,
name)用于判定属性是还是不是留存。
int( [x[, radix]])
转移为字符串或数字为纯整数。假如参数是三个字符串，它必须带有一个大概有标识的10进制数作为1个Python整数，只怕嵌入空格。以radix参数给出的基数为根基进行转变（那是私下认可十），可以是别的在[2，36]限定内的平头，或零。如若基数为零，依照字符串的始末测度准确的基数。若是内定的基数x是否五个字符串，引发TypeError十分。不然，参数能够是1个一般性或长整数或浮点数。转变浮点数截断为整数（直到零）。假如参数是整数范围之外的，将回到三个long
object。假诺没有提交参数，重回0
issubclass(class, classinfo)
判别二个类是还是不是为钦点类的子类。
注1: 类都是本身的子类
注2: 如果 classinfo 参数是一个元组，那么只要类属于内部二个类的子类即重临
True
>>> class A:
... pass
...
>>> class B(A):
... pass
...
>>> issubclass(B, A)
True
>>> issubclass(A, B)
False
>>> issubclass(A, A)
True
>>> issubclass(A, (A,B))
True
iter(object [, sentinel])
重临三个迭代器对象，用于遍历，一般与 next() 同盟使用。
就算 sentinel 参数未有传来则 object 必须是3个可迭代的靶子。
假设 sentinel 参数有值，则object 必须是叁个 callable
的对象，此时的遍历将另行调用object, 直到再次来到值等于
sentinel（将发生StopIteration异常）
>>> it = iter([1,2,3])
>>> next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>
>>> for i in iter([1,2,3]):
... print(i)
...
1
2
3
>>> f = open('test.txt', 'r')
>>> itf = iter(f.readline, '')
>>> next(itf)
'test line 1\n'
>>> next(itf)
'test line 2\n'
>>> next(itf)
'test line 3\n'
>>> next(itf)
'\n'
>>> next(itf)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>> f.close()
delattr(object, attr) 用于删除属性
isinstance( object, classinfo)
重返true若是该object参数是classinfo的四个实例，或其（直接或直接）子类的实例。也回到true假诺classinfo是壹种type对象（new-style
class）和是该品种或其（直接或直接）子类的对象。要是object不是class一个的实例大概给定类型的目的，函数重返false。假诺classinfo既不是3个类的靶子也不是3个type的靶子，它也许是一个包罗类或项目的对象的tuple，也或许带有其余的递归元组（类别类型不接受）。假若classinfo不是三个类，类型或元组类，类型，可能那种元组，将抛出叁个TypeError极度。
iter(object [, sentinel])
重返二个迭代器对象，用于遍历，一般与 next() 同盟使用。
假如 sentinel 参数没有传到则 object 必须是多个可迭代的对象。
假使 sentinel 参数有值，则object 必须是三个 callable
的目的，此时的遍历将再度调用object, 直到重临值等于
sentinel（将发出StopIteration异常）
>>> it = iter([1,2,3])
>>> next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>
>>> for i in iter([1,2,3]):
... print(i)
...
1
2
3
>>> f = open('test.txt', 'r')
>>> itf = iter(f.readline, '')
>>> next(itf)
'test line 1\n'
>>> next(itf)
'test line 2\n'
>>> next(itf)
'test line 3\n'
>>> next(itf)
'\n'
>>> next(itf)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>> f.close()
len(s)
再次回到对象的长短。对象一般是三个行列和2个集中。
假使是其余对象，则对象必须包蕴 __len__()
方法，不然会发生十二分。
>>> a = [1, 2, 3]
>>> len(a)
3
>>> b = 'abcdefg'
>>> len(b)
7
>>>
>>> class MyTest:
... def __len__(self):
... return 5
...
>>> c = MyTest()
>>> len(c)
5
hasattr(object, attr)用于剖断一个对象是还是不是有某一性质
issubclass( class, classinfo)
回去true倘若class是classinfo（直接或直接）的子类。三个类被认为是和煦的子类。
classinfo大概是类对象元组，在那种景观下元组中的每一个classinfo项将被开始展览测试。在别的任何情况下，抛出四个TypeError格外。
len(s)
重返对象的长度。对象一般是三个队列和1个聚众。
若是是别的对象，则对象必须带有 __len__()
方法，否则会时有发生十分。
>>> a = [1, 2, 3]
>>> len(a)
3
>>> b = 'abcdefg'
>>> len(b)
7
>>>
>>> class MyTest:
... def __len__(self):
... return 5
...
>>> c = MyTest()
>>> len(c)
5
list([iterable])
创建并回到3个列表对象。要是未有传到参数，则赶回三个空驶列车表。
传入的参数必须是二个可迭代的，迭代器中的每二个对象将作为列表的一个要素。
>>> list('abcd')
['a', 'b', 'c', 'd']
>>> list([1,2,3])
[1, 2, 3]
id()用于获取对象的内部存款和储蓄器地址
iter( o[, sentinel])
回去三个迭代器对象。第1个参数有例外的讲明，视第2个参数的留存与否而定。假若未有第一个参数，o必须是三个对象的聚焦，援救迭代协议（__iter__（）方法），只怕它必须援助类别协议（以整数0始发的参数__getitem__()方法）。假如它不支持这几个协议，将抛出TypeError至极。若是第三个参数，sentinel，给出，然后o必须是可调用的靶子。在那种气象下开创的每3个迭代器无参调用o它的next（）方法，要是再次回到值等于sentinel，将抛出StopIteration，不然将重返其余的值。
list([iterable])
创立并赶回3个列表对象。如若未有传来参数，则赶回3个空驶列车表。
传入的参数必须是叁个可迭代的，迭代器中的每二个目的将用作列表的三个要素。
>>> list('abcd')
['a', 'b', 'c', 'd']
>>> list([1,2,3])
[1, 2, 3]
locals()
再次来到当前命名空间的{对象: 值} 字典。
>>> def foo():
... i = 1
... j = 2
... k = 3
... print(locals())
...
>>> foo()
{'i': 1, 'k': 3, 'j': 2}
isinstance()
用于判断一个目的是还是不是是某壹品类，类似type，但type不会认为子类是父类类型，isinstance会认为子类是父类类型
len(s)
再次来到二个目的的尺寸。参数能够是2个体系（字符串，元组或列表）或映射（词典）。
locals()
再次来到当前定名空间的{对象: 值} 字典。
>>> def foo():
... i = 1
... j = 2
... k = 3
... print(locals())
...
>>> foo()
{'i': 1, 'k': 3, 'j': 2}
map(function, iterable, …)
重临一个迭代器。迭代器中的各类目的将是流传的迭代器依照function的映照。
假诺超出多个参数，前边的参数适用于 function
有四个参数的图景，由此后边的迭代器的尺寸不能够小于 iterable
>>> for i in map(lambda x: x**2, [1,2,3]):
... print(i)
...
1
4
9
>>> for i in map(lambda x,y: x**y, [2,2,2], [1,2,3]):
... print(i)
...
2
4
8
issubclass(B, A)用于判别B是还是不是是A的子类，A、B都以类名
license
map(function, iterable, …)
重回三个迭代器。迭代器中的每三个目的将是流传的迭代器依据function的照射。
借使赶过四个参数，前边的参数适用于 function
有多个参数的图景，由在此以前边的迭代器的长度不能够小于 iterable
>>> for i in map(lambda x: x**2, [1,2,3]):
... print(i)
...
1
4
9
>>> for i in map(lambda x,y: x**y, [2,2,2], [1,2,3]):
... print(i)
...
2
4
8
max(iterable [, key, default]) max(arg1, arg2, \args [, key]*)
重回最大值。要相比的参数能够是3个可迭代的目的，也足以一贯传入对象列表。
参数 key 能够变动私下认可的可比艺术。
当传入的是2个迭代器时，若是迭代器为空，则赶回default值，借使未有传来default将发出相当。
>>> max([3,5,1,7,9,2])
9
>>> max('aaa', 'bbb', 'ccc')
'ccc'
>>>
>>> max([(4,2), (3,3), (2,4)], key=lambda x: x[1])
(2, 4)
>>> max([], default='empty')
'empty'
super() 用于调用父类的2个艺术
list( [iterable])
回到3个列表的items与可迭代的品种雷同的次第且一样的items。可迭代能够是八个队列，3个器皿，协助迭代，或3个迭代器对象。假诺可迭代已经是1个列表，将重回1个别本，类似的于iterable[:]。例如，list(‘abc’)返回[‘a’,
‘b’, ‘c’]和list( (1, 2, 3) )
返回[1，2，3]。倘使未有提交参数，再次来到一个新的空列表，[]。
max(iterable [, key, default]) max(arg1, arg2, \args [, key]*)
再次来到最大值。要比较的参数能够是三个可迭代的对象，也能够一直传入对象列表。
参数 key 能够更改暗许的可比艺术。
当传入的是2个迭代器时，就算迭代器为空，则赶回default值，假如未有传来default将产生十分。
>>> max([3,5,1,7,9,2])
9
>>> max('aaa', 'bbb', 'ccc')
'ccc'
>>>
>>> max([(4,2), (3,3), (2,4)], key=lambda x: x[1])
(2, 4)
>>> max([], default='empty')
'empty'
memoryview(obj)
重返多少个内部存款和储蓄器阅览对象。传入的目的必须补助缓冲区协商，内建目的中帮忙的有
bytes 和 bytearray 。
内部存款和储蓄器观望对象提供贰个共享的内部存储器，能够在不要求复制的动静以分裂的点子访问共享内部存款和储蓄器。在大气数据管理时相比有用。
>>> a = memoryview(b'abcdefg')
>>> a
<memory at 0x7f22addc3e88>
>>> a[0]
97
>>> a[1]
98
>>> a.tolist()
[97, 98, 99, 100, 101, 102, 103]
>>> a.tobytes()
b'abcdefg'
>>> a[1:3].tobytes()
b'bc'
staticmethod修饰符，评释静态方法，类不供给实例化就足以调用该措施。
locals()
立异并赶回一个意味当前local符号表的字典。警告：本词典的始末不应有被修改，改动或然不会潜移默化由interpreter用作一些变量的值。
memoryview(obj)
再次来到三个内部存款和储蓄器观察对象。传入的对象必须补助缓冲区琢磨，内建目的中援助的有
bytes 和
bytearray
。
内部存款和储蓄器观望对象提供四个共享的内部存款和储蓄器，能够在不要求复制的状态以差别的诀窍访问共享内部存款和储蓄器。在大气数据管理时相比有用。
>>> a = memoryview(b'abcdefg')
>>> a
<memory at 0x7f22addc3e88>
>>> a[0]
97
>>> a[1]
98
>>> a.tolist()
[97, 98, 99, 100, 101, 102, 103]
>>> a.tobytes()
b'abcdefg'
>>> a[1:3].tobytes()
b'bc'
min(iterable [, key, default]) min(arg1, arg2, \args [, key]*)
重返最小值。用法与 max 类似
>>> min([3,5,1,7,9,2])
1
>>> min('aaa', 'bbb', 'ccc')
'aaa'
>>> min((4,2), (3,3), (2,4), key=lambda x: x[1])
(4, 2)
>>> min([], default='empty')
'empty'
classmethod修饰符，证明类方法，类方式的率先个参数是cls，和实例方法的self意义同样。假设有继续关系，子类方法调用类方法时，传递的类变量cls时子类，而非父类。
map( function, iterable, …)
利用function在iterable的每三个项上并回到1个列表。假诺有任何可迭代的参数，函数必须利用繁多参数应用于来自全部iterables项。借使二个迭代比另3个短，将以None实行扩大。假诺function是None，将要是为identity
function，如若有八个参数，map()重回二个列表包括全数iterables相应的项目标元组组成。可迭代的参数恐怕是三个队列或其余可迭代的目的，结果三番五次三个列表。
min(iterable [, key, default]) min(arg1, arg2, \args [, key]*)
再次来到最小值。用法与 max 类似
>>> min([3,5,1,7,9,2])
1
>>> min('aaa', 'bbb', 'ccc')
'aaa'
>>> min((4,2), (3,3), (2,4), key=lambda x: x[1])
(4, 2)
>>> min([], default='empty')
'empty'
next(iterator [, default])
重回迭代器中的下2个。一般与 iter() 合作使用。
当迭代成功今后，即使传入了default参数，则返回default的值，不然产成StopIteration异常
>>> it = iter([1,2,3])
>>> next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>
>>> it = iter([1,2,3])
>>> next(it, default='end')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: next() takes no keyword arguments
>>> next(it, 'end')
1
>>> next(it, 'end')
2
>>> next(it, 'end')
3
>>> next(it, 'end')
'end'
class A:
@classmethod
def cm(cls):
print(‘类方法调用者：’, cls.__name__)
@staticmethod
def sm():
print(‘静态方法调用’)
class B(A):
pass
A.cm()
B.cm()
A.sm()
B.sm()
max( iterable[, args…][key])
贰个Iterable参数，重回当中一个最大的非空可迭代项，（如1个字符串，元组或列表）。如有八个参数，重临最大的参数。
可选的key参数钦赐带一个参数的排序函数，用于list.sort（）。key参数，假使有，必须在以keyword的款型（举个例子，”max(a,b,c,key=func)”）。
next(iterator [, default])
重临迭代器中的下二个。一般与 iter() 协作使用。
当迭代产生未来，若是传入了default参数，则返回default的值，否则产成StopIteration异常
>>> it = iter([1,2,3])
>>> next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>
>>> it = iter([1,2,3])
>>> next(it, default='end')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: next() takes no keyword arguments
>>> next(it, 'end')
1
>>> next(it, 'end')
2
>>> next(it, 'end')
3
>>> next(it, 'end')
'end'
object()
创设2个为主目的。该类是全体类的基类。
>>> a = object()
>>> dir(a)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
其它
memoryview
object()
创造二个主干对象。该类是全数类的基类。
>>> a = object()
>>> dir(a)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
oct(x)
重回x的捌进制字符串，字符串以’0o’发轫，字符串中的字符都是小写形式表示。
当x不是贰个int型对象时，则对象必须定义一个__index__()
方法，则赶回整型值，不然将发出十三分。
>>> oct(10)
'0o12'
>>> oct(16)
'0o20'
open()用于展开一个文本，创制三个file对象
min( iterable[, args…][key])
八个Iterable参数，再次来到在那之中三个纤维的非空可迭代项，（如3个字符串，元组或列表）。如有三个参数，再次来到最小的参数。
可选的key参数内定带3个参数的排序函数，用于list.sort（）。key参数，假诺有，必须在以keyword的样式（举个例子，”max(a,b,c,key=func)”）。
oct(x)
再次来到x的八进制字符串，字符串以’0o’开首，字符串中的字符都是小写情势表示。
当x不是一个int型对象时，则对象必须定义3个__index__()
方法，则赶回整型值，不然将时有产生非常。
>>> oct(10)
'0o12'
>>> oct(16)
'0o20'
open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
打开2个文本，重回三个文本的靶子。open的使用十分丰硕，那里为扫除文盲，只表达最常用最核心的用法。
参数 file, 文件名，路线可认为相对，也足以为相对。
参数 encoding，以何种编码方式展开文件，举例 ‘utf-8‘,
‘gbk‘等。
参数 mode，张开格局
- ‘r’, 只读格局，如若文件不设有将生出1贰分。
- ‘w’,
写格局展开，要是文件存在，原版的书文件将被覆盖，要是不设有将创制新文件。
- ‘x’，创立2个新文件并张开，要是文件存在将发出十三分。
- ‘a’,
追加方式张开，借使文件存在，张开后指针指向文件尾巴部分，假设不设有将创造新文件。
- ‘b’, 二进制格局张开。
- ‘t’, 文本形式展开（缺省）
- ‘+’, 读写格局打开，同盟r, w, a使用
在那之中常用组合情势，r+, rb+, w+, wb+, a+, ab+
注: 为保证使用安全性，常合营 with 使用
>>> f = open('test.txt', 'r', encoding='utf-8')
>>> f.readline()
'test line1\n'
>>> f.close()
>>>
>>> with open('test.txt', 'r') as f:
... print(f.readline())
...
test line1
format()格式化函数
next
open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
张开贰个文本，再次回到三个文本的靶子。open的选用非凡足够，这里为扫除文盲，只表达最常用最大旨的用法。
参数 file,
文件名，路线可感觉相对，也足感觉相对。
参数 encoding，以何种编码情势张开文件，举例’utf-8‘,
‘gbk‘等。
参数 mode，展开形式
- ‘r’, 只读格局，即使文件不设有将爆发10分。
- ‘w’,
写方式张开，若是文件存在，最初的文章件将被覆盖，借使不存在将开创新文件。
- ‘x’，创设2个新文件并打开，如若文件存在将发出十分。
- ‘a’,
追加形式展开，倘若文件存在，打开后指针指向文件后面部分，假使不存在将开立异文件。
- ‘b’, 二进制方式张开。
- ‘t’, 文本方式展开（缺省）
- ‘+’, 读写形式打开，合营r, w, a使用
个中常用组合情势，r+, rb+, w+, wb+, a+, ab+
注: 为保障使用安全性，常合营 with 使用
>>> f = open('test.txt', 'r', encoding='utf-8')
>>> f.readline()
'test line1\n'
>>> f.close()
>>>
>>> with open('test.txt', 'r') as f:
... print(f.readline())
...
test line1
ord(c)
重返字符的unicode码，该函数是chr()反向操作。
注: 参数必须是单一的字符
>>> ord('a')
97
>>> ord(chr(99))
99
>>> chr(ord('k'))
'k'
zip()将可迭代的靶子作为参数，将对象中对应的因素打包成1个个元组，然后回来zip对象。假如各种迭代器的成分个数差异，则zip对象涵盖的列表长度与最短的目的一样，利用*号操作符，能够将元组解压为zip对象。
object()
回来叁个新特点的靶子。object是兼备new style
class的基类。它的法子是新样式类的持有实例共有的。
ord(c)
重返字符的unicode码，该函数是chr()反向操作。
注: 参数必须是单一的字符
>>> ord('a')
97
>>> ord(chr(99))
99
>>> chr(ord('k'))
'k'
pow(x, y [, z])
求 x 的 y 次方。结果相当于 x \* y*
假如传入了参数 z，则相当于 (x \* y) % z*
**注:* 如果 y 是负数，则不可能传回 z
>>> pow(2, 3)
8
>>> pow(2, 4, 5)
1
a = [1, 2, 3]
b = [‘one’, ‘two’, ‘three’]
zipped = zip(a, b)
zipList = []
for it in zipped:
print(it)
zipList.append(it)
print(zipList)
for it in zip(*zipList):
print(it)
oct(x)
改造一（任性大小）整数到2个8进制字符串。
pow(x, y [, z])
求 x
的 y
次方。结果也正是 x
\* y*
假诺传入了参数 z，则相当于
(x \* y) %
z*
**注:* 如果 y 是负数，则不能够传回 z
>>> pow(2, 3)
8
>>> pow(2, 4, 5)
1
print(\objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False*)
打字与印刷函数。可以三遍打字与印刷八个目的。sep, end, file, flush
假使急需修改，需以第2字格局钦赐。
参数sep，四个目的的打字与印刷内容之间的分割符。
参数end，全数目的内容输出完成后输出的字符。
参数file,
输出的地点，暗中同意是标准输出，能够修改成文件等富有write()
方法的靶子。
参数flush, 是或不是及时输出。False 大概会暂且放入缓冲区。
注: 对于自定义的对象，假设想被print调用，内需具备
__str__() 方法
>>> print('hello,world')
hello,world
>>> print('hello', 'world')
hello world
>>> print('hello', 'world', sep='---')
hello---world
>>> print('hello', 'world', end='\n\n\n')
hello world
>>> print('hello', 'world', '123', flush=True)
hello world 123
>>>
>>> class MyTest:
... def __str__(self):
... return 'test'
...
>>> a = MyTest()
>>> print(a)
test
range(stop)
open( filename[, mode[, bufsize]])
开发三个文书,`File
Objects’。若是文件不可能开辟，IOError相当引发。当张开一个文件，最佳调用open（），而不是直接用file构造。
前七个参数与stdio的fopen（）函数同样：filename是要开垦的公文名，mode是2个字符串，表示该文件是什么被展开。
mode，最常用的值是’r’读，’w’写（文件假诺已存在就截断），和’a’追加（在有的Unix系统意味着全部写入追加到文件后面部分，无论其现在的seek地点）。假使形式被总结，默感到’r’等。当张开叁个2进制文件，你应该形式值加上’b’，张开2进制形式，从而抓牢可行性。
（在少数不区分二进制文件和文件文件的连串扩大‘b’，，它将作为文书档案）。上边是mode的恐怕值：
可选bufsize参数钦命文件的所需缓冲区大小：0表示无缓冲，一意味着行缓冲，任何其余的正数使用其大小（在约）的多个缓冲区。负数bufsize，使用系统私下认可，这tty设备经常使用行缓冲和其余文件的一点1滴缓冲。假诺简单，使用系统暗中同意。
形式’r+’,
‘w+’和’a+’展开文件举办更新（请小心，’w+’截断该公文）。附加’b’的格局在界别二进制和文件文件的系统上以贰进制格局张开文件，系统上从不那么些不一致，加入了’b’没有成效。
print(\objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False*)
打字与印刷函数。能够1遍打字与印刷八个目的。sep, end, file,
flush 假若需求修改，需以重大字方式内定。
参数sep，八个目的的打字与印刷内容之间的分割符。
参数end，全体目的内容输出落成后输出的字符。
参数file,
输出的地点，默许是职业输出，可以修改成文件等有着write()
方法的目标。
参数flush,
是或不是及时输出。False
或许会一时半刻放入缓冲区。
注: 对于自定义的靶子，假诺想被print调用，亟需持有
__str__() 方法
>>> print('hello,world')
hello,world
>>> print('hello', 'world')
hello world
>>> print('hello', 'world', sep='---')
hello---world
>>> print('hello', 'world', end='\n\n\n')
hello world
>>> print('hello', 'world', '123', flush=True)
hello world 123
>>>
>>> class MyTest:
... def __str__(self):
... return 'test'
...
>>> a = MyTest()
>>> print(a)
test
property(fget=None, fset=None, fdel=None, doc=None)
属性装饰器。能够方便的走访对象的某部属性，幸免直接操作内部属性。
函数再次来到八个装潢属性，将涉嫌 fget, fset, fdel 函数
参数doc提供二个增派音信。
当用@property装饰类方法时，方法主力作为装饰属性，方法定义为只读。此时借使需求set和del须要非凡@method.setter和@method.deleter使用
注1: 三种完结格局中，get, set 和 del 都不是必须全方位设有的
注2: 三种达成情势中，get函数都只可以有self参数
class MyTest:
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, v):
self._x = v
def delx(self):
del self._x
x = property(getx, setx, delx, "The '_x' property")
class MyTest2:
def __init__(self):
self._x = None
@property
def x(self):
return self._x
@x.setter
def x(self, v):
self._x = v
@x.deleter
def x(self):
del self._x
>>> a = MyTest()
>>> a.x
>>>
>>> a = MyTest()
>>> print(a.x)
None
>>> a.x = 'test'
>>> print(a.x)
test
>>> del a.x
>>> print(a.x)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/home/taopeng/Workspace/CodeWars/tmp.py", line 7, in getx
return self._x
AttributeError: 'MyTest' object has no attribute '_x'
>>> b = MyTest2()
>>> print(b.x)
None
>>> b.x = 3
>>> print(b.x)
3
>>> del b.x
>>> print(b.x)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/home/taopeng/Workspace/CodeWars/tmp.py", line 25, in x
return self._x
AttributeError: 'MyTest2' object has no attribute '_x'
range(start, stop[,step])
ord(x)
给定叁个尺寸为一的字符串，重临四个平头，当参数是三个Unicode对象，代表字符的Unicode代码，或参数是贰个8人字符串，代表其字节值，。举个例子，ord(‘a’)再次来到整数玖柒，ord(u’\u2020′)再次回到82贰四。那是8人串chr()和用来Unicode对象的unichr（）的逆函数。要是给出Unicode参数和Python是UCS2Unicode的，字符的代码点必须在界定[0 ..
65535]内，不然字符串的长度是贰，抛出1个TypeErro。
property(fget=None, fset=None, fdel=None, doc=None)
属性装饰器。能够便宜的拜会对象的有些属性，防止直接操作内部属性。
函数再次来到七个装饰属性，将涉及 fget, fset, fdel 函数
参数doc提供一个协助消息。
当用@property装饰类方法时，方法新秀作为装修属性，方法定义为只读。此时如果须要set和del须求相称@method.setter和@method.deleter使用
注1: 三种落成方式中，get, set 和 del 都不是必须1切设有的
注2: 三种落成情势中，get函数都不得不有self参数
class MyTest:
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, v):
self._x = v
def delx(self):
del self._x
x = property(getx, setx, delx, "The '_x' property")
class MyTest2:
def __init__(self):
self._x = None
@property
def x(self):
return self._x
@x.setter
def x(self, v):
self._x = v
@x.deleter
def x(self):
del self._x
>>> a = MyTest()
>>> a.x
>>>
>>> a = MyTest()
>>> print(a.x)
None
>>> a.x = 'test'
>>> print(a.x)
test
>>> del a.x
>>> print(a.x)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/home/taopeng/Workspace/CodeWars/tmp.py", line 7, in getx
return self._x
AttributeError: 'MyTest' object has no attribute '_x'
>>> b = MyTest2()
>>> print(b.x)
None
>>> b.x = 3
>>> print(b.x)
3
>>> del b.x
>>> print(b.x)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/home/taopeng/Workspace/CodeWars/tmp.py", line 25, in x
return self._x
AttributeError: 'MyTest2' object has no attribute '_x'
range(stop) range(start, stop [, step])
生成一个数字连串迭代器。
当唯有2个参数时，类别为0到stop(不包含stop值)， 步进为1
当有八个参数时，系列为start到stop(不包罗stop值)，步进为壹
八个参数时，就能够自定义步进
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(3,9))
[3, 4, 5, 6, 7, 8]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]
再次回到可迭代对象，start默感觉0，step默以为一。
pow( x, y[, z])
再次来到x的Y次方，假设给出z，重回x的y次方，模Z（比pow(x, y) %
z更使得）的。这多个参数的情势pow(x, y)，也正是：x ** y
range(stop) range(start, stop [, step])
生成3个数字类别迭代器。
当只有3个参数时，连串为0到stop(不包涵stop值)， 步进为一
当有五个参数时，类别为start到stop(不包罗stop值)，步进为一
五个参数时，就能够自定义步进
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(3,9))
[3, 4, 5, 6, 7, 8]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]
repr(object)
和 ascii() 类似，重回对象的可打字与印刷字符串。
自定义对象如若急需 repr()，须求定义__repr__() 方法
>>> a = 123
>>> repr(a)
'123'
>>> b = 'test'
>>> repr(b)
"'test'"
>>> class MyTest:
... def __repr__(self):
... return 'Hello, world'
...
>>> c = MyTest()
>>> repr(c)
'Hello, world'
print()
打印
repr(object)
和 ascii()
类似，重返对象的可打字与印刷字符串。
自定义对象要是急需 repr()，要求定义__repr__()
方法
>>> a = 123
>>> repr(a)
'123'
>>> b = 'test'
>>> repr(b)
"'test'"
>>> class MyTest:
... def __repr__(self):
... return 'Hello, world'
...
>>> c = MyTest()
>>> repr(c)
'Hello, world'
reversed(seq)
重临2个连串逆序的迭代器。
即使是自定义对象，供给落成 __reversed__()
方法也许协助体系协议
>>> list(reversed([1,2,3,4,5]))
[5, 4, 3, 2, 1]
property( [fget[, fset[, fdel[, doc]]]])
reversed(seq)
重临二个行列逆序的迭代器。
假如是自定义对象，必要实现 __reversed__()
方法或许帮忙种类协议
>>> list(reversed([1,2,3,4,5]))
[5, 4, 3, 2, 1]
round(number [, ndigits])
保留钦定的小数位，重返一个最周围的数。
参数 ndigits 默以为None， 即只保留整数部分。
注1: 该函数当发展和向下取近似距离同样时，优先取一点都不大的偶数。
注2: ndigits 假若填0，尽管只保留整数位，不过会回去浮点型
>>> round(1.1)
1
>>> round(1.8)
2
>>> round(1.5)
2
>>> round(2.5)
2
>>> round(3.5)
4
>>> round(3.14, 1)
3.1
>>> round(3.16, 0)
3.0
quit
round(number [, ndigits])
保留钦点的小数位，重临一个最周边的数。
参数 ndigits
暗中认可为None， 即只保留整数部分。
注1: 该函数当发展和向下取近似距离一样时，优先取异常的小的偶数。
注2: ndigits
假如填0，即使只保留整数位，可是会重回浮点型
>>> round(1.1)
1
>>> round(1.8)
2
>>> round(1.5)
2
>>> round(2.5)
2
>>> round(3.5)
4
>>> round(3.14, 1)
3.1
>>> round(3.16, 0)
3.0
set([iterable])
创立3个凑合对象。若是未有参数则创制2个空群集。
参数必须是可迭代的。迭代器中的一样的对象将只会保留四个。
>>> set([1,2,3])
{1, 2, 3}
>>> set([1,1,2,2,3])
{1, 2, 3}
>>> set(range(10))
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
range( [start,] stop[, step])
这是二个通用函数来成立包括算术级数的列表，那是不时利用于循环。该参数必须是无独有偶整数。假设step参数被略去，默以为一。假设轻巧start参数，默感到0。step无法为零（不然引发ValueError）
set([iterable])
创设2个成团对象。要是没有参数则开创一个空群集。
参数必须是可迭代的。迭代器中的相同的目标将只会保留3个。
>>> set([1,2,3])
{1, 2, 3}
>>> set([1,1,2,2,3])
{1, 2, 3}
>>> set(range(10))
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
setattr(object, name, value)
给对像的钦赐属性赋值。借使目的不存在该属性，将先创制该属性。
注: 参数 name 是三个字符串***
>>> class MyTest():
... pass
...
>>> a = MyTest()
>>> setattr(a, 'test', 'hello')
>>> getattr(a, 'test')
'hello'
>>> setattr(a, 'test', 'hello, world')
>>> getattr(a, 'test')
'hello, world'
>>> a.test
'hello, world'
reduce()
reduce函数会对参数种类兰秋素进行积攒
setattr(object, name, value)
给对像的钦命属性赋值。假设目标不存在该属性，将先创设该属性。
注:参数 name 是一个字符串***
>>> class MyTest():
... pass
...
>>> a = MyTest()
>>> setattr(a, 'test', 'hello')
>>> getattr(a, 'test')
'hello'
>>> setattr(a, 'test', 'hello, world')
>>> getattr(a, 'test')
'hello, world'
>>> a.test
'hello, world'
slice(stop) slice(start, stop [, step])
生成2个分片对象。用于对队列举行分片。
当只有多少个参数时，体系为0到stop(不包括stop值)， 步进为1
当有多少个参数时，体系为start到stop(不包涵stop值)，步进为一
八个参数时，就可以自定义步进
可是貌似能够平昔在类别中用分片语法，比方 a为3个列表，分片语法为:
a[start:stop:step]
>>> myslice = slice(1,5,1)
>>> a = [1,2,3,4,5,6,7,8,9]
>>> a[myslice]
[2, 3, 4, 5]
>>> a[1:5:1]
[2, 3, 4, 5]
repr(object)
归来二个字符串，在那之中带有叁个对象的可打印方式。有时是对能够访问三个通常的函数的操作很有用。对于众多品种，该函数使得试图再次来到一个字符串，会产生2个对象与传递给eval()同样的值发生的靶子同样。
slice(stop) slice(start, stop [, step])
生成叁个分片对象。用于对队列举行分片。
当唯有3个参数时，体系为0到stop(不包含stop值)， 步进为1
当有五个参数时，系列为start到stop(不包含stop值)，步进为一
多少个参数时，就可以自定义步进
然而貌似能够一向在类别中用分片语法，举个例子 a为三个列表，分片语法为:
a[start:stop:step]
>>> myslice = slice(1,5,1)
>>> a = [1,2,3,4,5,6,7,8,9]
>>> a[myslice]
[2, 3, 4, 5]
>>> a[1:5:1]
[2, 3, 4, 5]
sorted(iterable, \, key=None, reverse=False*)
重临二个经过排序的列表。key, reverse参数必须以注重字方式传播。
供给排序的靶子必须是可迭代的。
参数key，排序的机要字。
参数reverse，是不是逆序，暗中同意从小到大。
注: 参数*能够忽略。
>>> a = [5,6,3,1,7,4,9]
>>> sorted(a)
[1, 3, 4, 5, 6, 7, 9]
>>> sorted(a, reverse=True)
[9, 7, 6, 5, 4, 3, 1]
>>> b = ['B', 'a', 'g', 'F', 'z', 'K']
>>> sorted(b)
['B', 'F', 'K', 'a', 'g', 'z']
>>> sorted(b, key=str.lower)
['a', 'B', 'F', 'g', 'K', 'z']
reversed(seq)
重返一个反向迭代器。seq必须是多少个帮助系列协议的对象（__len__（）方法和__getitem__（）以0开首的平头参数的点子）
sorted(iterable, \, key=None, reverse=False*)
再次回到三个透过排序的列表。key,
reverse参数必须以爱护字格局传播。
要求排序的目的必须是可迭代的。
参数key，排序的根本字。
参数reverse，是或不是逆序，暗中同意从小到大。
注: 参数*能够忽略。
>>> a = [5,6,3,1,7,4,9]
>>> sorted(a)
[1, 3, 4, 5, 6, 7, 9]
>>> sorted(a, reverse=True)
[9, 7, 6, 5, 4, 3, 1]
>>> b = ['B', 'a', 'g', 'F', 'z', 'K']
>>> sorted(b)
['B', 'F', 'K', 'a', 'g', 'z']
>>> sorted(b, key=str.lower)
['a', 'B', 'F', 'g', 'K', 'z']
staticmethod(function)
一般作为函数装饰器使用 @staticmethod 。类似 classmethod
将类中的一个措施钦命为静态方法。
静态方法的调用能够直接通过类调用，即C.f();
也可以因此实例调用，即C().f()
个人感到静态方法适合将函数归类打包
注:静态方法是足以延续的
>>> class MyTest:
... @staticmethod
... def static_test():
... print('This is a static method')
...
>>>
>>> a = MyTest()
>>> a.static_test()
This is a static method
>>>
>>> MyTest.static_test()
This is a static method
round( x[, n])
回到浮点值x四舍五入到小数点后n位后数字。若是n被轻便，默许为零。结果是三个浮点数。
staticmethod(function)
一般作为函数装饰器使用 @staticmethod 。类似 classmethod
将类中的贰个方法钦赐为静态方法。
静态方法的调用能够向来通过类调用，即C.f();
也足以通超过实际例调用，即C().f()
个人以为静态方法适合将函数归类打包
注:静态方法是能够一连的
>>> class MyTest:
... @staticmethod
... def static_test():
... print('This is a static method')
...
>>>
>>> a = MyTest()
>>> a.static_test()
This is a static method
>>>
>>> MyTest.static_test()
This is a static method
str(object=”) str(object=b”, encoding=’utf-8′, errors=’strict’)
创设并赶回八个字符串对象。
能够行使钦点的对象来初阶化。开始化将动用对象的 __str__()
方法再次回到的值。
>>> str(12345)
'12345'
>>> str('test')
'test'
>>> str([1,2,3])
'[1, 2, 3]'
>>> class MyTest:
... def __str__(self):
... return 'Hello'
...
>>> a = MyTest()
>>> str(a)
'Hello'
set( [iterable])
再次回到其成分都以从iterable得到的set。成分必须是不行改造的。假使iterable未有点名，重临叁个新的空集，设置([])
str(object=”) str(object=b”, encoding=’utf-8′, errors=’strict’)
创制并回到1个字符串对象。
能够应用钦命的靶子来早先化。初叶化将选择对象的 __str__()
方法重回的值。
>>> str(12345)
'12345'
>>> str('test')
'test'
>>> str([1,2,3])
'[1, 2, 3]'
>>> class MyTest:
... def __str__(self):
... return 'Hello'
...
>>> a = MyTest()
>>> str(a)
'Hello'
sum(iterable [, start])
对二个系列求和。
参数start， 钦定2个起首值，默许是0
>>> sum(range(5))
10
>>> sum(range(5), 3)
13
>>> sum({1,2,3})
6
setattr( object, name, value)
与getattr（）相呼应。该参数是三个目标，贰个字符串和三个放4值。该字符串能够是存活属性名称或一个新的性子。函数分配给该属性值，只要该目的允许的话。举个例子，setattr(x,
‘foobar’, 123)，也正是x.foobar = 1二3。
sum(iterable [, start])
对2个体系求和。
参数start， 钦命多少个开始值，暗中同意是0
>>> sum(range(5))
10
>>> sum(range(5), 3)
13
>>> sum({1,2,3})
6
super([type [, object-or-type]])
再次回到父类的主意、对象。一般用于后续管理中，尤其是起首化。
在最先化中，super的参数能够轻松。
class A:
def __init__(self):
print('Class A init')
class B(A):
def __init__(self):
super().__init__()
print('Class B init')
class C(A):
def __init__(self):
super(C, self).__init__()
print('Class C init')
>>> b = B()
Class A init
Class B init
>>> c = C()
Class A init
Class C init
slice( [start,] stop[, step])
回去一个切丝对象，它意味着的是range(start, stop,
step)内定的界定。start和step参数私下认可为None。切丝对象有只读数据属性start，stop和step，它只是回来参数值（或私下认可）。未有其他显然的功力，但它们的作为数值Python和任何第3方扩展使用。当使用扩张索引语法时也发生切块对象。举个例子：“a[start:stop:step]”或“a[start:stop,
i]”。
super([type [, object-or-type]])
重返父类的方式、对象。一般用来后续管理中，尤其是开头化。
在初叶化中，super的参数能够省略。
class A:
def __init__(self):
print('Class A init')
class B(A):
def __init__(self):
super().__init__()
print('Class B init')
class C(A):
def __init__(self):
super(C, self).__init__()
print('Class C init')
>>> b = B()
Class A init
Class B init
>>> c = C()
Class A init
Class C init
tuple([iterable])
创建并回到贰个元组对象。
能够使用八个可迭代对象伊始化元组。
>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>> tuple('test')
('t', 'e', 's', 't')
sorted( iterable[, cmp[, key[, reverse]]])
回去三个新的排序的列表，包涵Iterable的项。
可选参数cmp，key，reverse与list.sort()具同样涵义
cmp钦赐带五个参数（Iterable的因素），重返自二个负数，零或正数的函数“cmp=lambda
x,y: cmp(x.lower(), y.lower())“。
key内定带叁个参数的函数，用来从列表每一种成分中领取三个相比key：“key=str.lower”
reverse是多少个布尔值。若是设置为True，则对列表中的元素实行排序，同时每3回相比都是逆向的。
诚如来说，key和reverse调换进程是遥远快于钦赐一个也便是cmp的功效。那是因为cmp是为每一种列表成分调用很数次，而key和reverse接触每一种成分唯有三回。
tuple([iterable])
创设并回到贰个元组对象。
可以行使二个可迭代对象开头化元组。
>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>> tuple('test')
('t', 'e', 's', 't')
type(object) type(name, bases, dict)
多个效益。传入的参数个数差别，成效各异
三个参数时，重返对象所属的类。
八个参数时，动态成立二个自定义类的靶子。
当需求动态创设1个类时，
参数name, 类名
参数bases, 类的基类，使用多少个元组传入，因而能够有多个父类。
参数dict, 类的习性和方法字典。{属性名=属性值，方法名=函数名},
当中“函数名”是二个业已定义的函数
注: 直接通过字典传入的主意是1个静态方法。
>>> a = [1,2,3]
>>> type(a)
<class 'list'>
>>>
>>> def test_func():
... print('This is a test func.')
...
>>> b = type('MyTest', (object, ), dict(test_attr='Hello', test_method=test_func))
>>> type(b)
<class 'type'>
>>> b.test_attr
'Hello'
>>> b.test_method()
This is a test func.
staticmethod( function)
函数重临3个静态方法。静态方法未有抽取一个富含的首先个参数
type(object) type(name, bases, dict)
三个效率。传入的参数个数不一样，功用不一
2个参数时，再次回到对象所属的类。
多个参数时，动态创造2个自定义类的目的。
当须要动态成立1个类时，
参数name, 类名
参数bases, 类的基类，使用2个元组传入，因而得以有多个父类。
参数dict, 类的性质和方式字典。{属性名=属性值，方法名=函数名},
个中“函数名”是二个曾经定义的函数
注: 直接通过字典传入的方法是2个静态方法。
>>> a = [1,2,3]
>>> type(a)
<class 'list'>
>>>
>>> def test_func():
... print('This is a test func.')
...
>>> b = type('MyTest', (object, ), dict(test_attr='Hello', test_method=test_func))
>>> type(b)
<class 'type'>
>>> b.test_attr
'Hello'
>>> b.test_method()
This is a test func.
vars([object])
再次来到对象新增添长的性能字典。若是未有参数，再次回到当前定名空间革新的质量字典。
实际上函数重返的正是目标 __dict__ 属性的值。
注: 在初阶化时累加的属性不会放入 __dict__
>>> class MyTest:
... def __init__(self):
... a = 1
... b = 2
...
>>> a = MyTest()
>>>
>>> vars(a)
{}
>>> a.c = 3
>>> vars(a)
{'c': 3}
>>> a.__dict__
{'c': 3}
>>>
>>> vars()
{'MyTest': <class '__main__.MyTest'>, 'a': <__main__.MyTest object at 0x7f1ca394f828>, '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}
str( [object])
回来一个字符串，个中含有对象可打字与印刷的叙说。对于字符串，那将回来字符串本身。与repr(object)不一样的是，str(object)）并不总是试图再次来到一个eval（）可以接受的字符串，其目的是再次来到一个可打字与印刷字符串。假诺未有交给参数，再次来到空字符串，”。
vars([object])
重返对象新扩大长的个性字典。要是未有参数，再次回到当前定名空间立异的品质字典。
实际上函数再次来到的便是目的 __dict__
属性的值。
注: 在初阶化时拉长的习性不会放入 __dict__
>>> class MyTest:
... def __init__(self):
... a = 1
... b = 2
...
>>> a = MyTest()
>>>
>>> vars(a)
{}
>>> a.c = 3
>>> vars(a)
{'c': 3}
>>> a.__dict__
{'c': 3}
>>>
>>> vars()
{'MyTest': <class '__main__.MyTest'>, 'a': <__main__.MyTest object at 0x7f1ca394f828>, '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}
zip(\iterables*)
将四个系列进行重新组合，再次来到3个元组列表。
各类元组从各种种类中各提取三个值。由此元组的个数由最短的系列决定。
>>> list(zip([1,1,1], [2,2,2], [3,3,3]))
[(1, 2, 3), (1, 2, 3), (1, 2, 3)]
>>>
>>> list(zip([1,2,3], [4,5,6], [7,8,9]))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>>
>>> list(zip([1,1,1], [2,2,2], [3,3]))
[(1, 2, 3), (1, 2, 3)]
): 内建函数扫除文盲，python三.x
Built-in Functions abs() dict() help() min() setattr() all() dir() hex()
next() slice() any() divmod() id() object() sorted() a…
sum( iterable[, start])
求start和可迭代的从左至右的项和并赶回总和。start默认为0。在可迭代的项，日常是数字，不能够是字符串。快捷，正确的连天的字符串连串的法子是通过调用”.join(sequence)。注意sum(range(n),
m)也便是reduce(operator.add, range(n), m)
zip(\iterables*)
将八个连串进行重新组合，再次来到3个元组列表。
各种元组从各类连串中各提取1个值。由此元组的个数由最短的系列决定。
>>> list(zip([1,1,1], [2,2,2], [3,3,3]))
[(1, 2, 3), (1, 2, 3), (1, 2, 3)]
>>>
>>> list(zip([1,2,3], [4,5,6], [7,8,9]))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>>
>>> list(zip([1,1,1], [2,2,2], [3,3]))
[(1, 2, 3), (1, 2, 3)]
super( type[, object-or-type])
归来类型的超类。若是第1个参数被总结，重返的特等对象是未绑定。假若首个参数是2个对象，isinstance(obj,
type)必须是true。假使第一个参数是三个品种，issubclass(type贰,
type)必须是true。super() 只可以用来最新类。
tuple( [iterable])
归来3个元组的items与可迭代的iterable是1致的且有一致的1一。iterable或然是一个行列，容器帮忙迭代，或迭代器对象。借使iterable已是元组，间接回到。比方，tuple(‘abc’)重临(‘a’,
‘b’, ‘c’) 和tuple([1, 2, 3])重回(一, 2,
三)。倘诺未有交给参数，再次回到四个新的空元组，()。
type( object)
回去对象的项目。重临值是八个连串对象。
vars( [object])
若果未有参数，根据以往的local符号表重回多少个字典。如若是1个模块，类或类的实例对象作为参数（或任何任何有__dict__性子），根据目的的符号表重临叁个字典。再次回到的字典不应被被改造：在相应符号表上的震慑是未定义的。
zip( [iterable, …])
本条函数重回贰个元组列表，在那之中的第i元组包罗每二个行列或iterables的第i个因素。再次回到的列表被截断长度为参数最短的队列的尺寸。当有两个参数是同1长度，zip()类似于用无参数起首化的map()
。三个独立种类参数，它回到二个元组的列表。不带参数，它回到贰个空列表