[雪峰磁针石博客]python3标准库-中文版2:内置函数

		内置功能
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()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

abs(x)

返回绝对值。 参数能够是整数或浮点数。 若是参数是复数，则返回其大小。

all(iterable)

若是iterable中全部的元素都为True，或iterable为空（empty），返回True。至关于以下: 若是迭代器的全部元素均为真（或迭代器为空），则返回True 。 至关于：

#!python
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

any(iterable)

若是iterable里任何一个元素为True，返回 True。若是iterable为空（empty）,返回 False。至关于以下:

#!python
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

ascii(object)

相似repr()，用 \x，\u 或者\U 进行对非 ASCII 字符转义，相似repr() 在 Python 2 中返回的字符串。

bin(x)

将整数转换为二进制字符串。结果是有效的Python表达式。若是 x 不是 Python int类型的对象，须要定义返回是整数的__index__() 方法。

#!python
>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

去掉0b

#!python
>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

bool([x])

返回布尔值，True 或 False。将会使用真值测标准(truth testing procedure)对x 进行转换。若是 x 的值为 false 或被省略，这将返回 False;不然返回 True。bool 类(bool )是 int 的子类。它不能有子类。其惟一的实例是 False 和 True。

class bytearray([source[, encoding[, errors]]])

返回新的字节数组。bytearray 类整数的可变序列，范围为0 < = x < 256。它包含了可变序列大部分的经常使用方法，参见Mutable Sequence Types, ，同时也包含了bytes 类型的大部分方法，参见Bytes and Bytearray Operations。

可选的source参数能够用几种不一样的方式初始化数组：

• 字符串 string，应该直接在参数中指定编码类型，例如：utf-8(以及可选参数 errors)；bytearray() 将使用 str.encode()按照编码转化字符串为字节序列。
• 整数，则该数组将具备该大小并将用空字节进行初始化。
• 符合缓冲区接口的对象，则将使用该对象的只读缓冲区来初始化字节数组。
• 迭代类型iterable，其整数元素的取值范围是0 <= x < 256，通常用做数组的初始内容。

没有参数，就会建立一个大小为0的数组。

参见 Binary Sequence Types — bytes, bytearray, memoryview和Bytearray Objects.

class bytes([source[, encoding[, errors]]])

返回新的字节对象，在 0<= x < 256之间的不可变的整数序列。 bytes 是 bytearray 的不可变版本 – 它具备一样的非改变性的方法和一样的索引和切片操做

所以，构造函数参数的解释与bytearray()相同。

字节对象也能够用字面值建立，参见字符串和字节字面值。

参考资料: Binary Sequence Types — bytes, bytearray, memoryview, Bytes Objects, 和Bytes and Bytearray Operations.

callable(object)

若是该 object是可调用的，返回 True ,不然返回 False 。若是返回True，调用仍有可能失败；可是若是返回False，对object的调用老是失败。请注意，类是可调用的（调用类将返回实例）。若是实例的类有__call__()方法，则它是可调用；不然是不可调用的。

在 3.2版本的更新:这个函数第一次在 Python 3.0 中被移除，在Python 3.2.中被从新启用

chr(i)

返回Unicode码。例如，chr(97)返回字符串'a'，而chr(8364)返回字符串'€'。它是ord()的逆操做。

参数的有效范围是从0到1,114,111（基于16的0x10FFFF）。若是i超出该范围，则会引起ValueError。

classmethod(function)

将函数转换为类方法。

类方法将类做为隐式第一个参数接收，就像实例方法接收实例同样。要声明一个类方法，使用这个习惯用法：

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

@classmethod形式是一个函数装饰器 —— 查看函数定义中关于函数定义的详细说明。

它既能够在类上调用（如C.f()）也能够在实例上调用（如C().f()）。该实例被忽略，除了它的类。若是一个类方法在子类上调用，那么子类对象被传递为隐式的第一个参数。

类方法与C ++或Java静态方法不一样。若是你须要静态方法，参见本节中的staticmethod()。

关于类方法更多的信息，参考标注类型的层级中的标准类型层级的文档。

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

将source编译成代码或AST对象。代码对象能够由exec()或eval()执行。source能够是普通字符串，字节字符串或AST对象。有关如何使用AST对象的信息，请参阅ast模块文档。

filename参数是要从中读取代码的文件名；若是它不是从文件中读取的话，须要传入一些可识别的内容（一般使用'string'）

mode 参数指定必须编译模式；若是source由语句序列组成，则它能够是'exec'；若是它是单个语句，则可使用'eval'；若是它由单个交互式语句组成，则可使用'single'。（在最后一种状况下，非None语句将会被打印出来）

可选参数flags和dont_inherit控制哪些将来版本的语句（见 PEP 236）会应用于源编译。若是二者都不存在（或二者均为零），则代码将与正在调用compile()的代码中的那些未来的语句一块儿编译。若是给出flags参数而且dont_inherit不是（或为零），那么除了使用flags参数指定的将来语句那些将被使用的东西。若是dont_inherit是一个非零整数，那么flags参数就是它 - 围绕编译调用生效的将来语句将被忽略。

未来的语句由能够按位或运算来指定多个语句的位指定。指定给定特征所需的位域能够在__future__模块中的_Feature实例上的compiler_flag属性中找到。

参数optimize指定编译器的优化级别； -1的默认值选择由-O选项给出的解释器的优化级别。显式级别为0（无优化； __debug__为真），1（声明被删除，__debug__为假 ）或2（docstrings也被删除）。

若是编译的源代码无效，则此函数引起SyntaxError；若是源代码包含空字节，则此函数引起ValueError。

若是要将Python代码解析为其AST表示形式，请参阅ast.parse()。

注意

在'single'或'eval'模式下编译具备多行代码的字符串时，输入必须至少由一个换行符终止。这是为了便于在code模块中检测不完整和完整的语句。

在版本3.2中更改：容许使用Windows和Mac换行符。在'exec'模式下输入也没必要以换行符结束。添加了optimize参数。

在版本3.5中更改：之前，在source中遇到空字节时引起TypeError。

class complex([real[, imag]])

返回值形式为real + imag * 1j的复数，或将字符串或数字转换为复数。若是第一个参数是一个字符串，它将被解释为一个复数，而且该函数必须在没有第二个参数的状况下被调用。第二个参数不能是一个字符串。每一个参数能够是任何数字类型（包括复数）。若是省略imag，则默认为零，构造函数会像int和float同样进行转换。若是省略这两个参数，则返回0j。

注意

从字符串转换时，该字符串不得在中央+或-运算符周围包含空格。For example, complex('1+2j') is fine, but complex('1 + 2j') raises ValueError.

复数类型在数字类型 - int，float，complex中描述。

delattr(object, name)

这是setattr()的相对值。参数是一个对象和一个字符串。该字符串必须是对象属性之一的名称。该函数删除指定的属性，只要该对象容许。For example, delattr(x, 'foobar') is equivalent to del x.foobar.

class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg)

建立一个新的字典。dict对象是字典类。有关此类的文档，请参见dict和映射类型 - dict。

对于其余容器，请参阅内置的列表，集合和元组类以及容器 。

dir([object])

不带参数时, 在当前本地做用域中返回名称列表。带参数时, 尝试返回参数object的有效属性列表。

若是对象具备名为__dir__()的方法，那么将调用此方法，而且必须返回属性列表。这容许实现自定义__getattr__()或__getattribute__()函数的对象自定义dir()报告其属性的方式。

若是对象不提供__dir__()，则函数会尽可能从对象的__dict__属性（若是已定义）和其类型对象中收集信息。结果列表不必定是完整的，而且当对象具备自定义__getattr__()时，可能不许确。

默认的dir()机制对于不一样类型的对象具备不一样的行为，由于它尝试生成最相关，而不是完整的信息：

    若是对象是模块对象，列表包含模块的属性名。
    若是对象是一个类型或类对象，则该列表包含其属性的名称，并递归地显示其基础的属性。
    不然，该列表包含对象的属性名称，其类属性的名称以及其类的基类的属性的递归。

结果列表按字母顺序排序。例如：
>>>

>>> import struct
>>> dir()   # show the names in the module namespace
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

注意

由于dir()主要是方便在交互式环境中使用，它尝试提供一组有用的名称，而不是试图提供完整或一致性的名称集合，具体的行为在不一样的版本之间会有变化。例如，当参数是一个类时，元类属性不在结果列表中。

divmod(a, b)

以两个（非复数）数字做为参数，并在使用整数除法时返回由它们的商和余数组成的一对数字。使用混合操做数类型时，适用二元算术运算符的规则。对于整数，结果与（a // b， a ％ b）相同。对于浮点数，结果为（q， a ％ b），其中q一般为math.floor(a / b)，也有可能比这个结果小1。In any case q * b + a % b is very close to a, if a % b is non-zero it has the same sign as b, and 0 <= abs(a % b) < abs(b).

enumerate(iterable, start=0)

返回一个枚举对象。iterable 必须是一个序列、一个迭代器，或者其它某种支持迭代的对象。enumerate()返回的迭代器的__next__()方法返回一个元组，该元组包含一个计数（从start开始，默认为0）和迭代iterable获得的值。
>>>

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

至关于以下:

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

eval(expression, globals=None, locals=None)

参数是一个字符串和可选的全局变量和局部变量。If provided, globals must be a dictionary. If provided, locals can be any mapping object.

使用globals和locals字典将表达式参数解析并计算为Python表达式（技术上讲是条件列表），并将其做为全局和本地命名空间。若是globals字典存在而且缺乏'__builtins__'，则在解析表达式以前，将当前全局变量复制到全局变量中。这意味着expression一般具备对标准builtins的彻底访问权限，而且传播受限环境。若是省略locals词典，则默认为globals词典。若是两个字典都省略，则在调用eval()的环境中执行表达式。返回值是评估表达式的结果。语法错误被报告为例外。例：
>>>

>>> x = 1
>>> eval('x+1')
2

此函数也可用于执行任意代码对象（例如由compile()建立的代码对象）。在这种状况下，传递一个代码对象而不是一个字符串。若是代码对象已使用'exec'做为mode参数编译，则eval()的返回值将为None 。

提示：exec()函数支持语句的动态执行。globals()和locals()函数分别返回当前的全局和局部字典，能够用于传递给eval或exec()。

请参见ast.literal_eval()这个函数，它能够安全地计算只包含字面值表达式的字符串。

exec(object[, globals[, locals]])

这个函数支持动态执行Python代码。object必须是一个字符串或代码对象。若是它是一个字符串，则将该字符串解析为一组Python语句，而后执行该语句（除非发生语法错误）。[1]若是它是一个代码对象，只是简单地执行它。在全部状况下，执行的代码应该能够做为有效的文件输入（参见“参考手册”中的“文件输入”部分）。请注意，即便在传递给exec()函数的代码上下文中，函数定义外面的return和yield 语句可能不被执行。返回值为None。

在全部状况下，若是省略可选部件，则代码将在当前范围内执行。若是只提供globals，它必须是一个字典，它将用于全局变量和局部变量。若是提供globals和locals，它们分别用于全局变量和局部变量。If provided, locals can be any mapping object. 请记住，在模块级别，全局变量和本地变量是相同的字典。若是exec的globals和locals是独立的两个对象，代码的执行就像它嵌入在类定义中同样。

若是globals字典的__builtins__键没有值，则会给这个赋予一个内置模块builtins字典的引用。这样，你能够在将globals传递给exec()以前插入本身的__builtins__字典，来控制执行的代码可访问的builtins。

注

内置函数globals()和locals()分别返回当前全局和局部字典，它们能够用作传递给exec()的第二和第三个参数。

注意

默认locals的做用与下面的函数locals()描述的同样：不该该尝试修改默认的locals词典。若是在函数exec()返回后，须要在locals上查看代码的效果，请传递一个明确的locals字典。

filter(function, iterable)

用iterable中传入function后返回True的元素构造一个迭代器。iterable能够是序列，支持迭代的容器或迭代器。若是function是None，使用特性函数，即为False的iterable中的元素被移除。

注意filter(function, iterable) 若是函数不是 None等效于生成器表达式 (item for item in iterable if function(item)) 。若是函数是 None ，(item for item in iterable if item)

请参阅itertools.filterfalse()，该函数返回函数返回false的iterable元素。

float

• class float([x])

返回由数字或字符串x构造的浮点数。

若是参数是字符串，它应该为十进制数字，可能以符号开头，而且能够嵌入空格。符号的sign能够是'+'或'–'； '+'对生成的值没有影响。该参数也能够是表示NaN或正或负无穷大的字符串。更确切地说，在删除先后空白字符后，输入必须符合如下语法：

#!python
sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

floatnumber是Python浮点字面值的形式。inf”，“Inf”，“INFINITY”和“iNfINity”对于正无穷大都是可接受的拼写。

若是参数是整数或浮点数，则返回具备相同值（在Python的浮点精度内）的浮点数。若是参数在Python浮点数的范围以外，则引起OverflowError。

对于通常的Python对象x，float(x)借助给x .float()。

若是没有给出参数，则返回0.0。

例子：

#!python
>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

float类型在 [Numeric Types — int, float, complex](https://docs.python.org/3/library/stdtypes.html#typesnumeric)中描述。

在版本3.6中更改：容许使用下划线对代码进行分组。

format(value[, format_spec])

将值转换为“格式化”表示，由format_spec控制。format_spec的解释将取决于值参数的类型，可是存在大多数内置类型使用的标准格式化语法：Format Specification Mini-Language

默认的format_spec是一个空字符串，一般给出与调用str（value）相同的效果。

将格式（值， format_spec）的调用转换为类型（值）.__格式__（值， t4> format_spec），它们在搜索值的__format__()方法时绕过实例字典。若是方法搜索到达object且format_spec不为空，或者format_spec异常，则会引起TypeError t7>或返回值不是字符串。

Changed in version 3.4: object().__format__(format_spec) raises TypeError if format_spec is not an empty string.

class frozenset([iterable])

返回一个新的frozenset对象，可选地使用iterable中的元素。frozenset是一个内置类。有关此类的文档，请参见frozenset和设置类型 - 集合，frozenset。

对于其余容器，请参阅内置的set，list，tuple和dict类以及collections模块。

getattr(object, name[, default])

返回对象的命名属性的值。名称必须是字符串。若是字符串是对象属性之一的名称，则结果是该属性的值。例如，getattr(x, 'foobar')等同于x.foobar。若是这个名字的属性不存在，若是提供default则返回它，不然引起AttributeError。

globals()

返回表示当前全局符号表的字典。这老是当前模块的字典（在函数或方法内部，这是定义它的模块，而不是调用它的模块）。

hasattr(object, name)

参数是一个对象和一个字符串。若是字符串是对象的一个属性，则返回True，不然返回False。（它的实现是经过调用getattr(object, name)并查看它是否引起一个AttributeError）。

hash(object)

返回该对象的哈希值（若是有的话）. 哈希值应该是一个整数。哈希值用于在查找字典时快速地比较字典的键。相等数值的哈希值相同（即便它们的类型不一样，好比1和1.0）.

注意

对于具备自定义__hash__()方法的对象，请注意，hash()根据主机的位宽截断返回值。有关详细信息，请参见__hash__()。

help([object])

调用内置的帮助系统。（此功能用于交互式使用。）若是没有提供参数，则交互式帮助系统将在解释器控制台上启动。若是参数是一个字符串，那么该字符串将被查找为模块，函数，类，方法，关键字或文档主题的名称，并在控制台上打印帮助页面。若是参数是任何其余类型的对象，则会生成对象上的帮助页面。

该函数加入内置函数的名字空间，函数收录在site 模块里.

在版本3.4中更改：对pydoc和inspect的更改意味着可报告的已报告签名如今更加全面和一致。

hex(x)

将整数转换为以“0x”为前缀的小写十六进制字符串,若是x不是Python int对象，它必须定义__index__()方法，返回整数。

#!python
>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

格式化

#!python
>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

要获取浮点型的十六进制字符串表示形式，请使用float.hex()方法。

id(object)

返回一个对象的“身份”。这是一个整数，它保证在该对象的生命周期内是惟一的和恒定的。具备不重叠寿命的两个对象能够具备相同的id()值。

CPython实现细节：这是内存中对象的地址。

input

• input([prompt])

  可选参数prompt输出到标准输出(不带结尾换行符)。函数从输入中读取一行，将其转换为字符串（剥离尾随的换行符），而后返回该行。当读取到EOF时，会产生EOFError。例：

#!python
>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"

若是readline模块已加载，则input()将使用它提供精细的行编辑和历史记录功能。

int: class int(x=0) class int(x, base=10)

从数字或字符串x构造并返回整数对象，若是没有给出参数，则返回0。若是 x定义了 [`__int__()`](https://docs.python.org/3/reference/datamodel.html#object.__int__ "object.__int__")

，返回x.int()。若是x定义了__trunc__() ，则返回x.trunc()。对于浮点数，将向0截断。

若是x不是数字或指定了base，那么x必须是字符串，字节或bytearray实例，它表示以base为基数的整数文字。文字能够在前面加上+或 -(二者之间没有空格)并用空格包围。 base-n文字由数字0到n-1组成，其中a到z（或A到Z）的值为10到35.默认基数为10.容许的值为0和2-36。 base-2，-8和-16文字能够有选择地以0b / 0B，0o / 0O或0x / 0X做为前缀，就像代码中的整数文字同样。基数0表示正确解释为代码字面量，所以实际基数为2,8,10或16，而且int('010', 0)不合法，而int（'010'）是，以及int（'010'，8）。

整数类型在数值类型 - int，float，complex中描述。

版本3.4中更改：若是base不是int的实例，而且基础对象具备基础.__ index__方法，则会调用该方法以获取基础的整数。之前的版本使用base .__ int__而不是base .__ index__。

在版本3.6中更改：容许使用下划线对代码进行分组。

isinstance(object, classinfo)

若是object是clsaainfo的一个实例（或者是classinfo的直接、间接或虚拟子类的实例），那么则返回true。若是object不是给定类型的对象，则该函数始终返回false。若是classinfo是类型对象的元组（或者其余这样的元组），若是object是任何类型的实例，则返回true。若是classinfo不是类型或类型组成的元祖和此类元组，则会引起TypeError异常。

issubclass(class, classinfo)

若是 class 是classinfo的子类(直接、 间接或 虚拟) 则返回 true 。一个类被认为是它本身的一个子类。classinfo may be a tuple of class objects, in which case every entry in classinfo will be checked. 在任何其余状况下，会引起TypeError异常。

iter(object[, sentinel])

返回一个迭代器对象。根据第二个参数的存在，第一个参数被解释得很是不一样。没有第二个参数，object必须是一个支持迭代协议（__iter__()方法）的容器对象，或者它必须支持序列协议（从 0开始的整数参数的__getitem__() 方法）。若是它不支持这些协议任何一个，将引起TypeError。若是给出第二个参数sentinel，那么object必须是一个可调用的对象。这种状况下建立的迭代器将在每次调用时不带参数调用object的__next__()方法；若是返回的值等于sentinel，将引起StopIteration，不然返回这个值。

另见迭代器类型。

iter()第二个参数的有用的一个场景是读取文件的行直至到达某个特定的行。下面的示例读取一个文件，直至readline()方法返回一个空字符串：

with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

len

• len(s)

返回对象的长度(项目数量)。参数能够是一个序列（如字符串，字节，元组，列表或range）或集合(如字典，集合或固定集合)。

list

• class list([iterable])

  list其实是一个可变的序列类型，其文档在Lists and Sequence Types — list, tuple, range。

locals()

更新和返回表示当前局部符号表的字典。当locals()在函数代码块中调用时会返回自由变量，可是在类代码块中不会。

注意

不该该修改这个字典的内容；由于这些变化可能不会影响解释器使用的局部变量和自由变量。

map(function, iterable, ...)

返回一个迭代器，对iterable的每一个项应用function，并yield结果。若是传递多个iterable参数，function必须接受这么多参数，并应用到从iterables并行提取的项中。若是有多个iterable，迭代器在最短的iterable耗尽时中止。对于函数的输入已经排列成参数元组的状况，参见itertools.starmap()。

max

• max(iterable, *[, key, default])
• max(arg1, arg2, *args[, key])

返回最大值。

单个位置参数应该是可迭代的对象，返回迭代器中最大值。若是提供了两个或多个位置参数，则返回最大的位置参数。

有两个可选关键字参数。key参数指定相似于list.sort()。default为iterable为空则要返回的对象。若是迭代器为空且未提供default，则会引起ValueError。

若是多个项为最大值，则返回第一个。这与其余排序稳定性保持工具一致，和sorted(iterable, key=keyfunc, reverse=True)[0]及heapq.nlargest(1, iterable, key=keyfunc)之类的相似。

版本3.4中的新功能： default关键字参数。

memoryview(obj)

返回从给定参数建立的“内存视图”对象。请参阅Memory Views的详细信息。

min

• min(iterable, *[, key, default])
• min(arg1, arg2, *args[, key])

返回最小值。

单个位置参数应该是可迭代的对象，返回迭代器中最小值。若是提供了两个或多个位置参数，则返回最小的位置参数。

有两个可选关键字参数。key参数指定相似于list.sort()。default为iterable为空则要返回的对象。若是迭代器为空且未提供default，则会引起ValueError。

若是多个项为最大值，则返回第一个。这与其余排序稳定性保持工具一致，和sorted(iterable, key=keyfunc, reverse=True)[0]及heapq.nlargest(1, iterable, key=keyfunc)之类的相似。

版本3.4中的新功能： default关键字参数。

next(iterator[, default])

经过调用__next__()方法从迭代器中检索下一个项目。若是给出default，则在迭代器耗尽时返回，不然引起StopIteration。

class object

返回一个新的无特征的对象。object是全部类的基础类.它包含全部Python类实例里都会有的通用方法.该函数不接受任何的参数。

注意

object没有有__dict__，因此你不能指定任何属性给object类的实例。

oct(x)

将整数转换为八进制字符串。结果是一个有效的Python表达式。若是x不是Python int对象，则必须定义一个返回整数的__index__()方法。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

打开 file 并返回一个相应的 文件对象.若是文件不能被打开, 抛出 OSError 异常.

参数 file 是一个字符串表示的文件名称，或者一个数组表示的文件名称。文件名称能够是相对当前目录的路径，也能够是绝对路径表示。（若是给出了一个文件描述器，则当关闭返回的I / O对象时除外，除非closefd设置为False。

参数 mode 是指明打开文件的模式。默认值是'r'，表示使用文本的方式打开文件来读取。其余常见值为'w'用于写入（若是文件已经存在则截断文件），'x'用于排他性建立，'a' （在某些 Unix系统上，意味着所有写入追加到文件的末尾，而无论当前的查找位置）。在文本模式下，若是未指定encoding，则使用的编码取决于平台：locale.getpreferredencoding（False）以获取当前语言环境编码。（对于读取和写入原始字节，使用二进制模式，不指定编码。可用的模式有：
字符	含义
'r'	打开阅读（默认）
'w'	打开写入，首先截断文件
'x'	打开独占建立，若是文件已经存在则失败
'a'	打开写入，追加到文件末尾（若是存在）
'b'	二进制模式
't'	文本模式（默认）
'+'	打开磁盘文件进行更新（读取和写入）
'U'	通用换行符模式（已弃用）

默认模式为'r'（打开阅读文本，'rt'的同义词）。对于二进制读写访问，模式'w b'打开并将文件截断为0字节。'r b'打开文件而不截断。

如概述中所述，Python区分二进制和文本I / O。以二进制模式打开的文件（包括模式参数中的'b'）将内容做为字节对象，而不进行任何解码。在文本模式（默认状况下，或当't'包括在模式参数中）时，文件的内容将做为str ，这些字节已经使用平台相关编码首先解码，或者若是给出则使用指定的编码。

注意

Python不依赖于底层操做系统的文本文件的概念；全部的处理都是由Python自己完成的，所以是平台无关的。

参数 buffering是用于设置缓冲策略的可选整数。经过0以关闭缓冲（仅在二进制模式下容许），1选择行缓冲（仅在文本模式下可用）和整数当未给出buffers参数时，默认缓冲策略工做以下：

    二进制文件以固定大小的块缓冲；使用启发式尝试肯定底层器件的“块大小”并回退到io.DEFAULT_BUFFER_SIZE来选择缓冲区的大小。在许多系统上，缓冲区一般为4096或8192字节长。
    “交互式”文本文件（isatty()返回True的文件）使用行缓冲。其余文本文件使用上述策略用于二进制文件。

参数 encoding是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。默认编码是平台相关的（不管locale.getpreferredencoding()返回），可是可使用Python支持的任何文本编码。有关支持的编码列表，请参阅编解码器模块。

参数 errors是一个可选字符串，指定如何处理编码和解码错误 - 这不能在二进制模式下使用。虽然使用codecs.register_error()注册的任何错误处理名称也有效，但仍提供了多种标准错误处理程序（在错误处理程序下列出）。标准名称包括：

    'strict'引起ValueError例外，若是存在编码错误。默认值None具备相同的效果。
    'ignore'忽略错误。请注意，忽略编码错误可能会致使数据丢失。
    'replace'会致使替换标记（例如'？'）插入到存在格式错误的数据的位置。
    'surrogateescape'将表示任何不正确的字节，做为从U DC80到U DCFF范围内的Unicode私人使用区域中的代码点。当写入数据时使用surrogateescape错误处理程序时，这些专用代码点将被转回相同的字节。这对于处理未知编码中的文件颇有用。
    仅当写入文件时，才支持'xmlcharrefreplace'。编码不支持的字符将替换为相应的XML字符引用
    'backslashreplace'经过Python的反斜杠转义序列替换格式错误的数据。
    'namereplace'（也仅在编写时支持）用\ N {...}转义序列替换不支持的字符。

参数 newline控制通用换行符模式的工做原理（仅适用于文本模式）。它能够是None、''、'\n'、'\r'、'\r\n'。它的工做原理以下：

    从流读取输入时，若是newline为None，则启用通用换行符模式。输入中的行能够以'\n'，'\r'或'\r\n'结尾，它们在返回给调用者以前被转换成'\n'。若是它是''，则启用通用换行符模式，但行结尾将返回给调用者而不会转换。若是它具备任何其它合法值，则输入行仅由给定字符串终止，而且行结尾被返回给调用者而不会转换。
    将输出写入流时，若是newline为None，则写入的任何'\n'字符都将转换为系统默认行分隔符os.linesep。若是newline是''或'\n'，则不会进行转换。若是newline是任何其余合法值，写入的任何'\n'字符都将转换为给定字符串。

若是closefd是False而且给出了文件描述器而不是文件名，则当文件关闭时，基本文件描述器将保持打开。若是给定文件名，则closefd必须为True（默认值），不然将产生错误。

经过传递可调用对象opener可使用自定义开启器。而后经过调用opener（文件，标志）获取文件对象的基础文件描述器。opener必须返回一个打开的文件描述器（传递os.open为opener 结果相似的功能 None）。

新建立的文件为non-inheritable。

如下示例使用os.open()函数的dir_fd参数打开相对于给定目录的文件：
>>>

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

由open()函数返回的file object的类型取决于模式。当open()用于以文本模式打开文件时（'w'，'r'，'wt'，'rt'等），它返回io.TextIOBase的子类（特别是io.TextIOWrapper）。当用缓冲区以二进制模式打开文件时，返回的类是io.BufferedIOBase的子类。确切的类有所不一样：在读取二进制模式下，它返回一个io.BufferedReader；在写入二进制和附加二进制模式时，它返回一个io.BufferedWriter，而且在读/写模式下，它返回一个io.BufferedRandom。当禁用缓冲时，将返回原始流（io.RawIOBase，io.FileIO的子类）。

See also the file handling modules, such as, fileinput, io (where open() is declared), os, os.path, tempfile, and shutil.

在版本3.3中已更改：添加了开启程序参数。添加了'x'模式。IOError曾经被提出，它如今是OSError的别名。FileExistsError is now raised if the file opened in exclusive creation mode ('x') already exists.

在版本3.4中更改：此文件如今是不可继承的。

自版本3.4起弃用，将在版本4.0中删除： 'U'模式。

Changed in version 3.5: If the system call is interrupted and the signal handler does not raise an exception, the function now retries the system call instead of raising an InterruptedError exception (see PEP 475 for the rationale).

在版本3.5中更改：添加了'namereplace'错误处理程序。

ord(c)

给定一个表示一个Unicode字符的字符串，返回一个表示该字符的Unicode代码点的整数。For example, ord('a') returns the integer 97 and ord('€') (Euro sign) returns 8364. 这是chr()的逆操做。

pow

• pow(x, y[, z])

返回x的y次方; 若是提供z参数， 返回x 的y次方再除以z的余数 (计算效率比pow(x, y) % z更高)。双参数形式pow(x, y)等效于使用幂操做符号：x**y 。

参数必须有数字类型。对于混合操做数类型，适用于二元算术运算符的强制规则。对于int操做数，除非第二个参数为负数，不然结果与操做数（强制后）的类型相同。在这种状况下，全部参数都将转换为浮点数并传递浮点结果。例如，102返回 100，可是10-2返回0.01。若是第二个参数是负数，则必须省略第三个参数。若是存在z，则x和y必须是整数类型，而且y必须是非负的。

print

• print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

将objects打印到文本流file，以sep分隔，而后以end结尾。 必须将sep，end，file和flush(若是存在)做为关键字参数给出。

全部非关键字参数都会像 str()同样转换为字符串写入流中，并由sep和end结尾进行分隔。 sep和end都必须是字符串; 它们也能够是None，这意味着使用默认值。 若是没有给出对象只写结束。

file参数必须支持write(string); 若是它不存在或None，则将使用sys.stdout。 因为打印的参数转换为文本字符串，print()不能用于二进制模式文件对象,请改用file.write（...）。

输出是否缓冲一般由文件决定，但若是flush关键字参数为true，则强制刷新流。

版本3.3中更改：添加了flush关键字参数。

class property(fget=None, fset=None, fdel=None, doc=None)

返回一个property 属性。

fget是获取属性值的函数。fset是用于设置属性值的功能。fdel is a function for deleting an attribute value. 而doc为该属性建立一个文档字符串。

典型的用法是定义一个托管属性x：

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

若是c是C的实例，则c.x将调用getter，c.x = value将调用setter，del c.x将调用deleter。

If given, doc will be the docstring of the property attribute. 不然，该属性将复制fget的文档字符串（若是存在）。这使得可使用property()做为装饰器轻松建立只读属性：

class Parrot:
    def __init__(self):
        self._voltage = 100000

    [@property](https://my.oschina.net/property)
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

@property装饰器将voltage()方法转换为具备相同名称的只读属性的“getter”，并设置为voltage的文档字符串为“Get the current voltage.”。

Property对象具备可用做装饰器的getter、setter和deleter方法，用于建立property的副本，并将相应的访问器函数设置为装饰的功能。这能够用一个例子来解释：

class C:
    def __init__(self):
        self._x = None

    [@property](https://my.oschina.net/property)
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

此代码与第一个示例彻底等效。请务必给予附加函数与原始属性相同的名称（在本例中为x）。

返回的property对象还具备对应于构造函数参数的属性fget、fset和fdel。

在3.5版本中已更改：属性对象的docstrings如今是可写的。

range(stop) range(start, stop[, step])

range其实是一个不可变的序列类型，如Ranges和Sequence Types — list, tuple, range中所记录。

repr(object)

返回一个包含对象可打印表示的字符串。对于许多类型，此函数尝试返回一个字符串，该字符串在传递给eval()时会产生一个具备相同值的对象，不然该表示是一个用尖括号括起来的字符串，其中包含名称该对象的类型以及常常包括该对象的名称和地址的附加信息。一个类能够经过定义一个__repr__()方法来控制该函数为其实例返回的内容。

reversed(seq)

返回一个反向iterator。seq必须是具备__reversed__()方法或支持序列协议（__len__()方法和__getitem__()方法，整数参数从0开始）。

round(number[, ndigits])

返回number舍入到小数点后ndigits位的浮点值。若是省略ndigits，将返回最接近输入的整数。底层调用的是number.__round__(ndigits)。

对于支持round()的内建类型，值舍入到10的最接近的负ndigits次幂的倍数；若是离两个倍数的距离相等，则舍入选择偶数（所以，round(0.5)和round(-0.5)都是0，而round(1.5)是2）。若是使用一个参数调用返回值是一个整数，不然其类型与number相同。

注意

浮点数round()的行为可能让人惊讶，例如round(2.675, 2)给出的是2.67而不是指望的2.68。这不是一个错误：由于事实上大部分十进制小数不能用浮点数精确表示。更多信息，请参阅浮点数运算：问题和限制。

class set([iterable])

返回一个新的set对象，可选地使用iterable中的元素。set是一个内置类。有关此类的文档，请参阅set和Set Types — set, frozenset。

对于其余容器，请参阅内置的frozenset，list，tuple和dict类以及collections模块。

setattr(object, name, value)

它与getattr()相对应。参数是一个对象、一个字符串和一个任意值。该字符串能够命名现有的属性或新的属性。若是该对象容许，该函数将该值分配给该属性。例如，setattr(x, 'foobar', 123)等同于x.foobar = 123。

class slice(stop) class slice(start, stop[, step])

返回表示由范围（start， stop， step）指定的一组索引的slice对象 T2>。start和step参数默认为None。Slice对象具备仅读取参数值（或其默认值）的只读数据属性start，stop和step。他们没有其余明确的功能；然而，它们被Numerical Python和其余第三方扩展使用。当使用扩展索引语法时，也会生成切片对象。例如：a[start:stop:step]或者a[start:stop, i]。请参见itertools.islice()中另一个返回迭代器的版本。

sorted

• sorted(iterable[, key][, reverse])

返回排好序的列表。

具备两个必须指明为关键字参数可选参数。

key为带有一个参数的函数，它用于从列表的每一个元素中提取比较的关键字，如key=str.lower。默认值是None(直接比较元素)。

reverse是布尔值。若是设置为True，那么列表中元素反过来排序。

functools.cmp_to_key()用于将老式的cmp函数转换为key函数。

参考：Sorting HOW TO.

staticmethod(function)

为函数返回一个静态方法。

静态方法不会收到隐式的第一个参数。要声明一个静态方法，使用这个习惯用法：

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

@staticmethod形式是一个函数装饰器 - 有关详细信息，请参阅函数定义中的函数定义的描述。

它能够在类上（如C.f()）或实例上（如C().f()）调用。该实例被忽略，除了它的类。

Python中的静态方法相似于Java或C ++中的方法。另请参见classmethod()了解用于建立备用类构造函数的变体。

有关静态方法的详细信息，请参阅标准类型层次结构中标准类型层次结构的文档。

str

• class str(object='')
• class str(object=b'', encoding='utf-8', errors='strict')

返回object的str版本。参见str() str是内置字符串类。有关字符串的信息，请参阅 Text Sequence Type — str。

sum

• sum(iterable[, start])

从左到右总计start和可迭代的项目并返回总数。开始默认为0。可迭代的项目一般是数字，而且起始值不容许为字符串。

对于某些使用状况有很好的替代sum()的方法。链接字符串序列的首选方法是经过调用''.join(sequence)。要以扩展精度添加浮点值，请参见 math.fsum()。要链接可迭代对象，请考虑使用itertools.chain()。

super([type[, object-or-type]])

返回一个代理对象，它委托方法给父类或者type的同级类。这对于访问类中被覆盖的继承方法颇有用。除了跳过type自己以外，搜索顺序与getattr()所使用的顺序相同。

type的__mro__属性列出getattr()和super()使用的方法解析顺序。该属性是动态的，而且能够在继承层次结构更新时更改。

若是省略第二个参数，则返回的super对象是未绑定的。若是第二个参数是一个对象，则isinstance(obj, type)必须为真。若是第二个参数是类型，则issubclass(type2, type)必须为真（这对类方法颇有用）。

super有两种典型的使用状况。在具备单继承的类层次结构中，可使用super来引用父类，而没必要明确命名它们，从而使代码更易于维护。这种使用很是相似于在其余编程语言中super的使用。

第二种使用状况是在动态执行环境中支持协同多继承。这种使用状况是Python独有的，在静态编译语言或仅支持单继承的语言中找不到。这使得能够实现“菱形图”，其中多个基类实现相同的方法。良好的设计指出此方法在每种状况下具备相同的调用顺序（由于调用的顺序在运行时肯定，由于该顺序适应类层次结构中的更改，而且由于该顺序能够包括在运行时以前未知的兄弟类）。

对于这两种使用状况，典型的超类调用看起来像这样：

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

注意，super()只实现显式点分属性查找的绑定过程，例如super().__getitem__(name)。它经过实现本身的__getattribute__()方法来实现这一点，以便以支持协同多继承须要的以可预测的顺序搜索类。所以，super()没有定义隐式的查找语句或操做，例如super()[name]。

还要注意，若是不是零个参数的形式，没有限制super()在方法内部使用。若是两个参数的形式指定准确的参数，就能进行正确的引用。零个参数的形式只在类定义中工做，由于编译器填充必要的细节以正确检索正在定义的类，原理相似访问当前实例的普通方法。

有关如何使用super()设计协同类的实用建议，请参阅使用super()的指南。

tuple([iterable])

tuple其实是一个不可变的序列类型，而不是一个函数。Tuples和Sequence Types — list, tuple, range中有记录。

class type(object) class type(name, bases, dict)

使用一个参数，返回对象的类型。返回值是一个类型对象，而且一般与object.__class__返回的对象相同。

建议使用isinstance()内置函数来测试对象的类型，由于它考虑了子类。

有三个参数，返回一个新的类型对象。这本质上是class语句的动态形式。The name string is the class name and becomes the __name__ attribute; the bases tuple itemizes the base classes and becomes the __bases__ attribute; and the dict dictionary is the namespace containing definitions for class body and is copied to a standard dictionary to become the __dict__ attribute. 例如，如下两条语句建立相同的type对象：
>>>

>>> class X:
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))

另见Type Objects。

vars([object])

返回一个模块、字典、类、实例或者其它任何一个具备__dict__属性的对象的__dict__属性。

模块和实例这样的对象的__dict__属性能够更新；可是其它对象可能对它们的__dict__属性的写操做具备限制（例如，类使用types.MappingProxyType来阻止对字典直接更新）。

若是不带参数，vars()的行为就像locals()。注意，locals字典只用于读取，由于对locals字典的更新会被忽略。

zip(*iterables)

建立一个迭代器，聚合来自每一个迭代器的元素。

返回一个由元组构成的迭代器，其中第i个元组包含来自每一组参数序列或可迭代量的第i元素。当最短的输入迭代耗尽时，迭代器中止。使用单个迭代参数，它将返回1元组的迭代器。没有参数，它返回一个空的迭代器。至关于以下:

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

可保证迭代的从左到右的评估顺序。这使得使用zip(*[iter(s)]*n)将数据序列聚类为n长度组成为可能。这将重复相同的迭代器n次，以便每一个输出元组都有n调用结果到迭代器。这具备将输入划分为n长度块的效果。

zip()当迭代器元素不一致时，循环中止在较短的迭代器元素，较长的迭代器元素会被舍弃。若是这些值很重要，请改用itertools.zip_longest()。

zip()结合*运算符可用于解压缩列表：
>>>

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

import(name, globals=None, locals=None, fromlist=(), level=0)

注意

与importlib.import_module()不一样，这是一种平常Python编程中不须要的高级函数。

经过 import 语句调用此函数。他可以被替代(经过导入builtins 模块，赋值给 builtins.__import__)去改变 import 语句的语义, 可是强烈 不鼓励，由于一般使用import钩子 (见 PEP 302) 更容易达到相同的目标，并且不会对使用了默认import实现的代码形成任何问题。直接使用__import__()也不鼓励使用importlib.import_module()。

该函数导入模块名称，可能使用给定的globals和locals来肯定如何解释包上下文中的名称。fromlist给出了应从name给出的模块导入的对象或子模块的名称。标准实现不使用其 locals 参数，仅仅使用 globals 肯定 导入 语句的包的上下文。

级别指定是使用绝对导入仍是相对导入。0（默认）意味着只执行绝对导入。level的正值表示相对于调用__import__()的模块的目录搜索的父目录的数量（参见 PEP 328了解详情）。

当name变量​​的形式为package.module时，一般会返回顶级包（名称直到第一个点），not < / t3>由名称命名的模块。可是，若是给出非空的fromlist参数，则返回由name命名的模块。

例如，语句import spam致使字节码相似于如下代码：

spam = __import__('spam', globals(), locals(), [], 0)

语句import spam.ham致使此调用：

spam = __import__('spam.ham', globals(), locals(), [], 0)

请注意，__import__()在此返回顶层模块，由于这是经过import语句绑定到名称的对象。

On the other hand, the statement from spam.ham import eggs, sausage as saus results in

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

这里，spam.ham模块从__import__()返回。从这个对象中，要导入的名称被检索并分配给它们各自的名称。

若是你只是想要按名称导入模块 ，使用 importlib.import_module()。

在版本3.3中更改：再也不支持level的负值（它也将默认值更改成0）。

脚注 [1] 请注意，解析器只接受Unix风格的行结束约定。若是你从文件中读取代码，请确保要使用换行符转换模式转换 Windows 或者 Mac 风格的换行符。