1. abs()
描述：返回数字的绝对值，不改变数据类型和数据精度
语法：abs( x )
参数：x -- 数值表达式
返回值：x（数字）的绝对值
2. all()
描述：all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True
语法：all(iterable)
参数：iterable -- 元组或列表
返回值：如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；注意：空元组、空列表返回值为True。
3. any()
描述：any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。也就是可迭代参数中的元素有一个为True则返回True，否则返回False。元素除了是 0、空、None、FALSE 外都算 TRUE
语法：any(iterable)
参数：iterable -- 元组或列表
返回值：如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true
4. basestring()
描述：basestring() 方法是 str 和 unicode 的超类（父类），也是抽象类，因此不能被调用和实例化，但可以被用来判断一个对象是否为 str 或者 unicode 的实例，isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。
语法：basestring()
参数：无
返回值：无
5. bin()
描述：bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
语法：bin(x)
参数：x -- int 或者 long int 数字
返回值：字符串
6. bool()
描述：bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。bool 是 int 的子类。转换原则是 0、空、None、FALSE 是Flase，其他的是True。
空列表，空集合，空元组，空字典都是False，否则是True。
语法：class bool([x])
参数：x -- 要进行转换的参数。
返回值：返回 Ture 或 False。
7. bytearray()
描述：bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256（一个字节存储的内容大小）。
语法：class bytearray([source[, encoding[, errors]]])
参数：
- 如果 source 为整数，则返回一个长度为 source 的初始化数组（全0）；
- 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
- 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数（字符串必须是长度为1的字符，然后把字符转为ASCII码）；
- 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
- 如果没有输入任何参数，默认就是初始化数组为0个元素。
返回值：返回 Ture 或 False。
8. callable()
描述：callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。
魔术方法：
__call__使实例能够像函数一样被调用（可调用对象），同时不影响实例本身的生命周期，可以用来改变实例的内部成员的值（改变类实例的状态）。 x() 与 x.__call__() 等同。
__init__ 函数的意义等同于类的构造器（同理，__del__等同于类的析构函数）
语法：callable(object)
参数：object -- 对象
返回值：可调用返回 True，否则返回 False。
9. chr()
描述：chr() 用一个范围在 range（256）内的（就是0～255）整数作参数（ASCII码对应的数值），返回一个对应的字符。
语法：chr(i)
参数：i -- 可以是10进制也可以是16进制（0x或0X）的形式的数字。
返回值：返回值是当前整数对应的 ASCII 字符。
10. classmethod()
描述：classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数（需要传入类本身作为参数，否则访问出错），可以来调用类的属性，类的方法，实例化对象等。将普通方法转为类方法，作用同装饰器@classmethod。在类中调用，将实例方法转为类方法。
语法：classmethod(function)
参数：function -- 类中实例方法。
返回值：返回普通函数（实例方法）的类方法。
11. cmp()
描述：cmp(x,y) 函数用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
数字：数字大小。
字符串：每个字符的ASCII码的大小。
语法：cmp(x, y)
参数：
- x -- 数值表达式。
- y -- 数值表达式。
返回值：如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
12. compile()
描述：compile() 函数将一个字符串编译为字节代码。然后使用exec, eval, single函数执行。
语法：compile(source, filename, mode[, flags[, dont_inherit]])
参数：
- source -- 字符串或者AST（Abstract Syntax Trees）对象。。
- filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
- mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
- flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
- flags和dont_inherit是用来控制编译源码时的标志
返回值：返回表达式执行结果。
13. complex()
描述：complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。字符串必须是“j”，不能是i。
z=a+bi（a,b均为实数）的数称为复数，其中a称为实部，b称为虚部，i称为虚数单位。当z的虚部等于零时，常称z为实数；当z的虚部不等于零时，实部等于零时，常称z为纯虚数。
语法：class complex([real[, imag]])
参数：
- real -- int, long, float或字符串；
- imag -- int, long, float；
返回值：返回一个复数。即使虚部为0（实数），格式也是虚数。
14. delattr()
描述：delattr 函数用于删除类实例对象的属性。再次访问会出错。
delattr(x, 'foobar') 相等于 del x.foobar。
语法：delattr(object, name)
参数：
- object -- 对象。
- name -- 必须是对象的属性。
返回值：无。
访问报错：
Traceback (most recent call last):
File "test.py", line 22, in <module>
print('z = ',point1.z)
AttributeError: Coordinate instance has no attribute 'z'
15. dict()
描述：dict() 函数用于创建一个字典。
语法：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
参数：
- **kwargs -- 关键字
- mapping -- 元素的容器。
- iterable -- 可迭代对象。
返回值：返回一个字典。
>>>dict() # 创建空字典
{}
>>> dict({'three': 3, 'four': 4}) # 传一个字典
>>> 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': 1}
16. dir()
描述：dir() 函数不带参数时，返回当前范围（当前模块）内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息
语法：dir([object])
参数：object -- 对象、变量、类型
返回值：返回模块的属性列表
>>>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']
17. divmod()
描述：python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
在 python 2.3 版本之前不允许处理复数。
语法：divmod(a, b)
参数：
- a: 数字
- b: 数字
返回值：包含商和余数的元组。
18. enumerate()
描述：enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
Python 2.3. 以上版本可用，2.6 添加 start 参数。
语法：enumerate(sequence, [start=0])
参数：
- sequence -- 一个序列、迭代器或其他支持迭代对象。
- start -- 下标起始位置。
返回值：返回 enumerate(枚举) 对象。
19. eval()
描述：eval() 函数用来执行一个字符串表达式，并返回表达式的值。
语法：eval(expression[, globals[, locals]])
参数：
- expression -- 表达式。
- globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
- locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值：返回表达式计算结果。
20. execfile()
描述：execfile() 函数可以用来执行一个文件。
语法：execfile(filename[, globals[, locals]])
参数：
- filename -- 文件名。
- globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
- locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值：返回文件内内容的执行结果。
python3 删去了 execfile()，代替方法如下：
with open('test1.py','r') as f:
exec(f.read())
21. file()
描述：file() 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。
file是类，open才是内置函数。
语法：file(name[, mode[, buffering]])
参数：
- name -- 文件名
- mode -- 打开模式
- buffering -- 0 表示不缓冲,如果为 1 表示进行行缓冲，大于 1 为缓冲区大小。
返回值：文件对象。
22. filter()
描述：filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判别，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
注意: Pyhton2.7 返回列表，Python3.x 返回迭代器对象。 filter 类对象。filter 类实现了 __iter__ 和 __next__ 方法, 可以看成是一个迭代器, 有惰性运算的特性, 相对 Python2.x 提升了性能, 可以节约内存。
语法：filter(function, iterable)
参数：
- function -- 判断函数。
- iterable -- 可迭代对象。
返回值：返回列表。
判断整数：math.sqrt(x) % 1 == 0
23. float()
描述：float() 函数用于将整数和字符串转换成浮点数。（类）
语法：class float([x])
参数：x -- 整数或字符串
返回值：返回浮点数。
24. format()
描述：Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。
语法：str.format(参数)
参数：需要格式化的参数（字符串，整数，浮点数）。
返回值：格式化后的字符串。
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置
'world hello world'
# 设置参数
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
# 传入对象
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
格式化数字：
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
| -1 | {:+.2f} | -1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
| 5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
| 10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
| 13 | {:10d} | 13 | 右对齐 (默认, 宽度为10) |
| 13 | {:<10d} | 13 | 左对齐 (宽度为10) |
| 13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
| 11 |
|
|
进制 |
^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
此外我们可以使用大括号 {} 来转义大括号，如下实例：
print ("{} 对应的位置是 {{0}}".format("runoob"))
25. frozenset()
描述：frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法：class frozenset([iterable]) 类
参数：iterable -- 可迭代的对象，比如列表、字典、元组等等。
返回值：返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
返回不可变集合。
26. getattr()
描述：getattr() 函数用于返回一个对象属性值。
语法：getattr(object, name[, default])
参数：
- object -- 对象。
- name -- 字符串，对象属性（名）。
- default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
返回值：返回对象属性值。
27. globals()
描述：globals() 函数会以字典类型返回当前位置的全部全局变量。
语法：globals()
参数：无。
返回值：返回一个全局变量的字典，除了内置变量，还包括所有导入的变量。
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, 'a': 'runoob', '__package__': None}
Python里只有2种作用域：全局作用域和局部作用域。全局作用域是指当前代码所在模块的作用域，局部作用域是指当前函数或方法所在的作用域。局部作用域里的代码可以读外部作用域（包括全局作用域）里的变量，但不能更改它。如果想更改它，这里就要使用global关键字了。
具体来看分以下几种情况：
1. 当你直接在局部域读取全局变量，可以直接使用。
2. 当你直接在局部域修改全局变量分两种情况：但是我们一定无法直接修改全局变量。
（1）比如a+=1的情况，是必须要首先声明变量才能执行。所以会报错，未声明该变量。
（2）比如a=1的情况，则系统认为你声明a局部变量，所以不会报错。但并不是修改全局变量。
3. 要想在局部域修改全局变量，可以使用global关键字首先声明该变量，然后修改。
4. 如果提前在局部域声明了该全局变量的同名变量，则覆盖全局变量（包括读取和修改）。
在Python 2.x中，闭包只能读外部函数的变量，而不能改写它。为了解决这个问题，Python 3.x引入了nonlocal关键字，在闭包内用nonlocal声明变量，就可以让解释器在外层函数中查找变量名。
注意：关键字nonlocal:是python3.X中出现的,所以在python2.x中无法直接使用.
28. hasattr()
描述：hasattr() 函数用于判断对象是否包含对应的属性。
语法：hasattr(object, name)
参数：
- object -- 对象。
- name -- 字符串，属性名。
返回值：如果对象有该属性返回 True，否则返回 False。
29. hash()
描述：hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
语法：hash(object)
参数：
- object -- 对象；
返回值：返回对象的哈希值。hash 值都是固定长度的。
可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。
在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。
30. help()
描述：help() 函数用于查看函数或模块用途的详细说明。
语法：help([object])
参数：
- object -- 对象；
返回值：返回对象帮助信息。
可以直接传入字符串，比如'sys'，'print'。
还可以直接传入类实例对象，返回该实例对象对应类的帮助信息，直接传入类实例对象的属性，返回该实例对象对应类属性的帮助信息。
31. hex()
描述：hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
语法：hex(x)
参数：
- x -- 10进制整数
返回值：返回16进制数，以字符串形式表示。
32. id()
描述：id() 函数用于获取对象的内存地址。
语法：id([object])
参数：
- object -- 对象（包括数字，字符串，布尔变量，类，类示例等任何对象）。
返回值：返回对象的内存地址。
33. input()
描述：
Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
Python2.x 中 input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。raw_input() 将所有输入作为字符串看待，返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）。
注意：Python2 input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
注意：python3 里 input() 默认接收到的是 str 类型，不要求是合法python表达式。
语法：input([prompt])
参数：
- prompt: 提示信息
返回值：返回输入内容。
34. int()
描述：int() 函数用于将一个字符串或数字转换为整型。对于浮点数向下取整。
语法：class int(x, base=10)
参数：
- x -- 字符串或数字。
- base -- 进制数，默认十进制。（指定输入的x的进制，输出都是十进制）
返回值：返回整型数据。不传入参数时，得到结果0。
35. isinstance()
描述：isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
语法：isinstance(object, classinfo)
参数：
- object -- 实例对象。
- classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组（多个选项）。
返回值：如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。
type(A()) == A
type()函数返回对象类型，但不考虑父类（继承）关系。
基本类型包括：int，float，bool，complex，str(字符串)，list，dict(字典)，set，tuple。
除了基本类型就是类（系统类或自定义）。
36. issubclass()
描述：issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
语法：issubclass(class, classinfo)
参数：
- class -- 类。
- classinfo -- 类。
返回值：如果 class 是 classinfo 的子类返回 True，否则返回 False。
两个类之间的比较。
37. iter()
描述：iter() 函数用来生成迭代器。
语法：iter(object[, sentinel])
参数：
- object -- 支持迭代的集合对象。
- sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
返回值：迭代器对象。
38. len()
描述：len() 方法返回对象（字符、列表、元组、字典、集合等）长度或项目个数。
语法：len( s )
参数：
- s -- 对象（字符、列表、元组、字典、集合等）。
返回值：返回对象长度。
39. list()
描述：list() 方法用于将元组转换为列表。（元组和列表相同包括索引和访问，除了不能修改。而集合和字典都无法使用索引进行访问）
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
语法：list( tup )
参数：
- tup -- 要转换为列表的元组。
返回值：返回列表。
40. locals()
描述：locals() 函数会以字典类型返回当前位置（当前模块或下层局部域，比如类内，函数内等）的全部局部变量。
语法：locals()
参数：
- 无
返回值：返回字典类型的局部变量。
函数的话包括函数的形参及所有定义的其他变量。
41. long()
描述：long() 函数将数字或字符串转换为一个长整型。
语法：class long(x, base=10)
参数：
- x -- 字符串或数字。
- base -- 可选，进制数，默认十进制。
返回值：返回长整型数。输出带有L结尾。
42. map()
描述：map() 会根据提供的函数对指定序列做映射（处理）。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
语法：map(function, iterable, ...)
参数：
- function -- 函数
- iterable -- 一个或多个序列
返回值：
Python 2.x 返回列表。
Python 3.x 返回迭代器。
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
43. max()
描述：max() 方法返回给定参数的最大值，参数可以为序列。
语法：max( x, y, z, .... )
参数：
- x -- 数值表达式。
- y -- 数值表达式。
- z -- 数值表达式。
返回值：返回给定参数的最大值。
1 . 列表数字
直接比较大小即可。
2. 字符串
>>> a='1,2,3,4'
>>> type(a) #类型为字符串
<type 'str'>
>>> max(a) #max 返回了最大值
'4'
3. 列表里面是元组构成元素
按照元素里面元组的第一个元素的排列顺序，输出最大值（如果第一个元素相同，则比较第二个元素，输出最大值）据推理是按ascii码进行排序的，类似于字符串的比较。
4. 比较字典
比较字典里面的最大值，会输出最大的键值。因为键值不重复，所以不会出现元组重复的情况。（注：字典中如果键重复，后一个会覆盖前一个）
44. memoryview()
描述：memoryview() 函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
语法：memoryview(obj)
参数：
- obj -- 对象
返回值：返回元组列表。
Python2
>>>v = memoryview('abcefg')
>>> v[1]
'b'
>>> v[-1]
'g'
>>> v[1:4]
<memory at 0x77ab28>
>>> v[1:4].tobytes()
'bce'
Python3
>>>v = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(v[1])
98
>>> print(v[-1])
103
>>> print(v[1:4])
<memory at 0x10f543a08>
>>> print(v[1:4].tobytes())
b'bce'
45. min()
描述：min() 方法返回给定参数的最小值，参数可以为序列。
语法：min( x, y, z, .... )
参数：
- x -- 数值表达式。
- y -- 数值表达式。
- z -- 数值表达式。
返回值：返回给定参数的最小值。
可变参数：多个数值或数值表达式，输出这几个参数的最小值
多个序列，以序列的形式输出，将单个序列的最小值组成一个序列。
46. next()
描述：next() 返回迭代器的下一个项目。
语法：next(iterator[, default])
参数：
- iterator -- 可迭代对象
- default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
返回值：返回迭代器的元素。
47. object()
描述：返回一个新的无特征对象，object是所有类的基类，有所有Python类实例的通用方法，该函数不接受任何参数。
注意：object没有__dict__方法，所以你不能给某个object类的实例分配任意属性。
其他类可直接设置属性：
#定义一个类A
>>> class A:
pass
>>> a = A()
>>> a.name = 'kim' # 能设置属性
语法：o = object()
参数：无。
返回值：返回一个object的实例对象。
>>> dir(object)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
python的__slots__设计是为了节省内存，也可以用于构造安全的类、如果一个类使用了__slots__那么它的属性就不再自由了。
slots__设置非自由属性
class person(object):
__slots__=('Name','Age')
def __init__(self,name,age):
self.Name=name #注意，__init__的执行在__slots__之后；所以就算在__init__方法里也是不能执行self.ID=007的。
self.Age=age
if__name__=='__main__':
p=person('jiangle',100)
p.ID=7 #这里会报错，由于我们使用了__slots__来声明属性，所以属性再也不是自由的了。
__new__ and __init__
新式类都有一个__new__的静态方法，它的原型是object.__new__(cls[, ...])
cls是一个类对象，当调用C(*args, **kargs)来创建一个类C的实例时，python的内部调用是 ：
- C.__new__(C, *args, **kargs)
- 然后返回值是类C的实例c
- 确认c是C的实例后
- python再调用C.__init__(c, *args, **kargs)来初始化实例c
所以调用一个实例c = C(2)，实际执行的代码为：
c = C.__new__(C, 2)
if isinstance(c, C):
C.__init__(c, 23)#__init__第一个参数要为实例对象
object.__new__()创建的是一个新的，没有经过初始化的实例。当重写__new__方法时，可以不用使用装饰符@staticmethod指明它是静态函数，解释器会自动判断这个方法为静态方法。如果需要重新绑定C.__new__方法时，只要在类外面执行C.__new__ = staticmethod(yourfunc)就可以了。
此外，如果（新式）类中没有重写__new__()方法，即在定义新式类时没有重新定义__new__()时，Python默认是调用该类的直接父类的__new__()方法来构造该类的实例，如果该类的父类也没有重写__new__()，那么将一直按此规矩追溯至object的__new__()方法，因为object是所有新式类的基类。
__repr__ and __str__
print(someobj)会调用someobj.str()， 如果str没有定义，则会调用someobj.repr().
48. oct()
描述：oct() 函数将一个整数转换成8进制字符串。
语法：oct(x)
参数：
- x -- 整数。
返回值：返回8进制字符串。
以0开头。
49. open()
描述：open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
语法：open(name[, mode[, buffering]])
参数：
-
name : 一个包含了你要访问的文件名称的字符串值（文件路径）。
-
mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
-
buffering : 如果 buffering 的值被设为 0，就不会有缓存。如果 buffering 的值取 1，访问文件时会缓存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的缓存区的缓冲大小。如果取负值，缓存区的缓冲大小则为系统默认。
返回值：返回file对象。
| 模式 | 描述 |
|---|---|
| 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() 关闭文件
50. ord()
描述：ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
语法：ord(c)
参数：c -- 字符（长度为1的字符串）
返回值：对应的十进制整数
51. pow()
描述：pow() 方法返回 x^y（x的y次方） 的值。
语法：
math 模块 pow() 方法的语法:
math.pow( x, y )
内置的 pow() 方法
pow(x, y[, z])
函数是计算x的y次方，如果z存在，则再对结果进行取模，其结果等效于pow(x,y) %z
pow(x,y) 等价于 x**y:
pow(x,y,z) 等价于 x**y%z:
注意：pow() 通过内置的方法直接调用，math 模块会把参数转换为 float，内置方法不修改参数类型：py2和py3相同。
math.pow(11.2,3.2)
Out[39]: 2277.7060352240815
math.pow(100, 2)
Out[40]: 10000.0
pow(11.2,3.2)
Out[42]: 2277.7060352240815
pow(100, 2)
Out[43]: 10000
pow(x,y,z) 当 z 这个参数不存在时 x,y 不限制是否为 float 类型, 而当使用第三个参数的时候要保证前两个参数只能为整数。
>>> pow(11.2,3.2)
2277.7060352240815
>>> pow(11.2,3.2,2) # 结果报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: pow() 3rd argument not allowed unless all arguments are integers
参数：
- x -- 数值表达式。
- y -- 数值表达式。
- z -- 数值表达式。
返回值：返回 x^y（x的y次方） 的值。