Python内置函数及其用法

  Python有许多内置的函数和类型，刚开始学习可能会不太熟悉。下面是官网给出的所有的内置函数和类型。

abs(x)

返回一个数字的绝对值。这个参数可能是一个整数或浮点数。如果这个参数是一个复数，它的大小就会返回。

all(iterable)

如果迭代的所有元素都是True(或者迭代是空的)，返回True。等价于:

def all(iterable):
	for element in iterable:
		if not element:
			return False
	return Ture

any(iterable)

如果迭代的任何元素都是True，则返回True。如果迭代是空的，则返回False。等价于:

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

ascii(object)

作为repr()，返回包含一个对象的可打印表示的字符串，但是可以转义由repr()使用x、u或u转义的字符串中的非ascii字符。这将生成类似于Python 2中的repr()返回的字符串。

bin(x)

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

class bool([x])

返回一个布尔值，即为真或假。使用标准的真相测试程序，对x进行转换。如果x是假的或省略的，则返回false;否则返回True。bool类是int的子类(参见数值类型-int、float、complex)。它不能进一步细分。它的唯一实例是False和True(参见布尔值)。

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

返回一个新的字节数组。bytearray类是在范围0<=x<256的范围内的一个可变序列。它有大多数常用的可变序列方法,在可变序列类型中描述，以及bytes类型所拥有的大多数方法，可以看到bytes and Bytearray操作。
可选的源参数可用于以几种不同的方式初始化数组:

• 如果是字符串，您还必须提供编码(以及可选的错误)参数;bytearray()然后使用str.encode()将字符串转换为字节。
• 如果它是一个整数，那么数组将具有该大小，并将用空字节进行初始化。
• 如果它是一个符合缓冲区接口的对象，那么对象的只读缓冲区将被用来初始化字节数组。
• 如果它是一个可迭代的，那么它必须是在范围0<=x<256的范围内的整数，它被用作数组的初始内容。
  如果没有参数，就会创建一个大小为0的数组。
  还可以看Binary Squence Types-bytes,bytearray,memoryview和Bytearray Objects

callable(object)

返回True，如果对象参数显示为可调用，则False。如果这个返回true，调用失败仍然可能，但是如果它是false，调用对象将永远不会成功。注意，类是可调用的(调用类返回一个新的实例);如果类具有_call_()方法，则可以调用实例。

chr(i)

返回字符串，表示Unicode代码点是整数i的字符。例如，chr(97)返回字符串'a',这是ord()的逆。
该参数的有效范围是从0到1,114111(在16中为0x10FFFF)。如果我在这个范围之外，将会增加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)

将源代码编译成一个代码或AST对象。代码对象可以由exec()或eval()执行。源可以是一个普通的字符串，一个字节字符串，或者一个AST对象。有关如何使用ast对象的信息，请参阅ast模块文档。
文件名参数应该给出代码被读取的文件;如果没有从文件中读取，则传递一些可识别的值(通常使用的是'<string>')。
模式参数指定什么样的代码必须被编译,它可以'exec'如果源由一系列的语句,'eval'如果它包含一个表达式,或'single'如果它包括一个交互式的声明(在后一种情况下,表达式语句评估以外的东西都将打印)。
可选的参数标记和dont继承控制，未来的语句(参见PEP 236)会影响源的编译。如果两者都不存在(或者两者都是零)，那么代码就会用那些在调用compile()的代码中产生的未来语句编译。如果给出了标志参数，并且dont继承不是(或者是零)，那么除了那些将被使用的标记参数之外，还将使用标志参数指定的未来语句。如果dont继承是一个非零的整数，那么标志参数就是它——在调用编译的过程中所产生的未来语句将被忽略。
未来的语句是由位元指定的，可以通过位元来指定多个语句。指定一个给定特性所需的位字段可以在未来模块的特性实例上被发现为编译器标志属性。
参数优化指定了编译器的优化级别;-1的默认值选择了-O选项所给出的解释器的优化级别。显式级别为0(没有优化，_debug_ is Ture)，1(断言被删除，_debug_ is false)或2(docstring也被删除)。
如果编译源是无效的，那么这个函数就会产生SyntaxError，如果源包含空字节，则会产生ValueError。
如果您想要将Python代码解析为它的AST表示，请参见ast.parse()。

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

class complex([real[, imag]])

返回一个复数real+imag*1j或将一个字符串或数字转换为复数的复数。如果第一个参数是字符串，那么它将被解释为一个复数，并且必须在没有第二个参数的情况下调用该函数。第二个参数永远不可能是字符串。每个参数可能是任何数值类型(包括复杂的)。如果省略了imag，它就默认为0，构造函数就像int和float那样的数值转换。如果省略了两个参数，则返回0j。

注意当从字符串转换时，字符串必须不包含中心+或-操作符周围的空格。例如，complex('1+2 j')很好，但是complex('1+2j')会增加ValueError。

delattr(object, name)

这是setattr()的一个相对关系。参数是一个对象和一个字符串。字符串必须是对象的一个属性的名称。如果对象允许，该函数将删除指定的属性。例如，delattr(x，“foobar”)相当于del x.foobar。

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

创建一个新字典。该对象是字典类。参见dict和Mapping Types-dict类型。
对于其他容器，可以看到内置的list、set、tuple类以及collections模块。

dir([object])

如果没有参数，则返回当前局部范围内的名称列表。使用一个参数，尝试返回该对象的有效属性列表。
如果对象有一个名为_dir-()的方法，那么这个方法将被调用，并且必须返回属性列表。这允许实现自定义_getattr_()或_getattribute_()函数的对象，以自定义dir()报告其属性的方式。
如果该对象不提供_dir_()，那么该函数将尽力从对象的object.If属性中收集信息，如果定义了，以及它的类型对象。结果列表不一定是完整的，并且当对象有一个定制的_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。在任何情况下，q*b+a%b非常接近a，如果a%b是非0的，它和b有相同的符号，而0<=abs(a%b)<aba(b)。

enumerate(iterable, start=0)

返回一个枚举对象。迭代必须是一个序列，一个迭代器，或者其他支持迭代的对象。由enumerate()返回的迭代器的_next()_方法返回一个包含计数(从开始到0)的元组，以及从遍历迭代中获得的值。

>>> 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)

参数是一个字符串和可选的全局变量和局部变量。如果提供了，全局变量必须是一个字典。如果提供了，当地人可以是任何映射对象。
表达式参数被解析为Python表达式(从技术上说，是条件列表)，使用全局和局部字典作为全局和本地名称空间。如果全局库是存在的，并且缺少'_builtins_'，那么当前的全局变量在解析表达式之前就会被复制到全局变量中。这意味着该表达式通常能够完全访问标准的builtins模块，并传播受限制的环境。如果省略了本地字典，那么它将默认为全局字典。如果省略了两个字典，那么表达式就会在调用eval()的环境中执行。返回值是求值表达式的结果。语法错误被报告为异常。例子:

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

这个函数也可以用来执行任意的代码对象(例如由compile()创建的对象)。在本例中，传递一个代码对象而不是一个字符串。如果代码对象以'exec'作为模式参数编译，那么eval()的返回值将为None

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

该函数支持Python代码的动态执行。对象必须是字符串或代码对象。如果是字符串，则将字符串解析为一组Python语句，然后执行这些语句(除非发生语法错误)。如果它是一个代码对象，那么它就是简单地执行。在所有情况下，所执行的代码都是作为文件输入有效的(参阅参考手册中的“文件输入”部分)。请注意，即使在传递给exec()函数的代码的上下文中，返回和收益语句也不能被使用到函数定义之外。返回值是None。
在所有情况下，如果省略了可选部分，那么代码就会在当前的范围内执行。如果只提供全局变量，那么它必须是一个字典，它将用于全局变量和局部变量。如果全局变量和局部变量被给定，它们分别被用于全局变量和局部变量。如果提供了，当地人可以是任何映射对象。请记住，在模块级别，全局变量和局部变量是相同的字典。如果exec将两个独立的对象作为全局变量和局部变量，那么代码将被执行，就像嵌入到类定义中一样。
如果globals字典不包含键内置的值，那么就会在该键下插入内置模块内置字典的引用。通过这种方式，您可以通过将自己的内置字典插入到globals，然后将其传递给exec()，从而控制所执行代码的可用性。

注意内置函数globals()和local()分别返回当前的全局和本地字典，这可能有助于将其作为第二个和第三个参数传递给exec()。
注意默认的局部行为是如下所描述的locals():对默认的本地字典的修改不应该尝试。如果您需要在函数exec()返回后看到代码对本地代码的影响，请通过一个显式的本地字典。

class float([x])

返回一个由数字或string x构建的浮点数。
如果参数是字符串，那么它应该包含一个十进制数，可选地在前面加上一个符号，并可选地嵌入到空格中。可选的符号可能是“+”或“-”;“+”的符号对产生的值没有影响。这个参数也可能是一个代表一个NaN(非数字)的字符串，或者一个正或负无穷。更准确地说，输入必须符合下列语法:在引导和后面的空格字符被删除:

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

这里的浮点数是Python浮点文字的形式，在浮点数中描述。情形并不重要，因此，例如，“Inf”、“INFINITY”和“iNflNity”都是正无穷大的可接受的拼写。
否则，如果参数是一个整数或浮点数，则返回一个具有相同值的浮点数(在Python的浮点精度内)。如果参数超出了Python浮动的范围，那么将会出现一个溢出错误。
对于一般的Python对象x，float(x)委托给x.float()`。
如果没有给出参数，则返回0。
例子:

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

format(value[, format_spec])

将一个值转换为一个“格式化的”表示，由格式spec控制。格式规范的解释取决于值参数的类型，但是有一种标准格式语法，大多数内置类型都使用它:格式规范的迷你语言。
默认格式规范是一个空字符串，通常会产生与调用str(值)相同的效果。
对格式(值，格式规范)的调用被转换为类型(值)。format(值，格式spec)在搜索值的format()方法时绕过了实例字典。如果方法搜索到达对象，并且格式规范是非空的，或者格式规范或返回值不是字符串，那么就会抛出一个类型错误异常。

class frozenset([iterable])

返回一个新的frozenset对象，可以选择从迭代中获取的元素。frozenset是一个内置的类。有关这个类的文档，请参见frozenset和设置类型-Set、frozenset。
对于其他容器，可以看到内置的集、列表、tuple和类，以及集合模块。

getattr(object, name[, default])

返回对象的命名属性的值。名称必须是字符串。如果字符串是对象的一个属性的名称，那么结果就是该属性的值。例如，getattr(x，'foobar')等同于x.foobar。如果指定的属性不存在，那么如果提供了默认值，否则将引发属性错误。

globals()

返回一个表示当前全局符号表的字典。这始终是当前模块的字典(在函数或方法中，这是它定义的模块，而不是它所调用的模块)。

hasattr(object, name)

参数是一个对象和一个字符串。如果字符串是对象的一个属性的名称，则结果为真，如果不是。(这是通过调用getattr(object、name)来实现的，并查看它是否会引发属性错误。)

hash(object)

返回对象的散列值(如果它有一个)。散列值是整数。它们用于在字典查找期间快速比较字典键。比较相等的数字值具有相同的散列值(即使它们是不同类型的，如1和1.0的情况一样)。

对于带有定制散列()方法的对象，请注意，散列()根据主机机器的位宽度来截去返回值。详情见__hash__()。

help([object])

调用内置的帮助系统。(此函数用于交互使用。)如果没有给出参数，交互帮助系统将从解释器控制台启动。如果参数是字符串，那么字符串会被查找为模块、函数、类、方法、关键字或文档主题的名称，并在控制台上打印一个帮助页面。如果该参数是任何其他类型的对象，则会生成该对象的帮助页面。
该函数由站点模块添加到内置的名称空间中。

hex(x)

将一个整数数转换为使用“0x”前缀的一个小写的十六进制字符串，例如:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

如果x不是一个Python int对象，它必须定义一个返回一个整数的index()方法。
请参阅int()，用于将16个十六进制字符串转换为一个整数。

注意为了获得一个浮点数的十六进制字符串表示，使用浮动.十六进制()方法。

id(object)

返回一个对象的“标识”。这是一个整数，它保证在它的生命周期中为这个对象是唯一的和常量。两个具有非重叠生存期的对象可能具有相同的id()值。
**CPython实现细节:**这是内存中对象的地址。

input([prompt])

如果出现了提示参数，则将其写入标准输出，而不需要跟踪新行。然后该函数从输入中读取一行，将其转换为字符串(删除一个拖后的换行符)，并返回该字符串。当读取时，EOFError会被提高。例子:

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

如果加载了readline模块，则输入()将使用它来提供详细的行编辑和历史特性。

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

返回一个由数字或字符串x构造的整数对象，如果没有给出参数，则返回0。如果x是一个数字，返回x.int()。对于浮点数，这个截尾是0。
如果x不是一个数字，或者是给定的基数，那么x必须是一个string、bytes或bytearray实例，表示基数基数的整数。可选地，文字可以在前面加上+或-(在中间没有空格)，并被空格包围。一个base-n文字由数字0到n-1的数字组成，有一个到z(或A到z)的值为10到35。默认的基数是10。允许的值是0和2-36。基-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型。

isinstance(object, classinfo)

如果对象参数是classinfo参数的一个实例，或者是它的一个(direct,indirect or virtual)子类，那么返回true。如果对象不是给定类型的对象，那么函数总是返回false。如果classinfo是类型对象的一个元组(或者递归地，其他的元组)，如果对象是任何类型的实例，则返回true。如果classinfo不是类型的类型或元组和元组，则会增加类型错误异常。

issubclass(class, classinfo)

如果类是classinfo的子类(direct,indirect or virtual)，则返回true。类被认为是自身的子类。classinfo可能是类对象的一个元组，在这种情况下，将检查classinfo中的每一个条目。在其他任何情况下，都将出现一个类型错误异常。

iter(object[, sentinel])

返回一个迭代器对象。第一个参数的解释非常不同，取决于第二个参数的存在。如果没有第二个参数，对象必须是支持迭代协议(iter()方法)的集合对象，或者它必须支持序列协议(getitem()方法，该方法从0开始)，如果它不支持这两种协议，那么就会出现TypeError。如果第二个参数是哨兵，那么对象必须是可调用对象。在本例中创建的迭代器将调用对象，不为它的next()方法调用任何参数;如果返回的值等于哨兵，则停止迭代，否则将返回值。
参见迭代器类型。
iter()第二种形式的一个有用的应用程序是读取文件的行，直到到达某个行为止。下面的例子读取一个文件，直到readline()方法返回一个空字符串:

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

len(s)

返回一个对象的长度(条目的数量)。该参数可能是一个序列(例如字符串、字节、元组、列表或范围)或集合(如字典、集合或冻结集)。

class list([iterable])

list实际上不是一个函数，而是一个可变的序列类型，如列表和序列类型中记录的那样—list、tuple、range

locals()

更新并返回一个代表当前本地符号表的字典。当在函数块中调用Free变量时，由locals()返回，而不是在类块中。

注意 本词典的内容不应被修改;更改可能不会影响翻译器使用的本地和自由变量的值。

map(function, iterable, …)

返回一个迭代器，该迭代器将函数应用于可迭代的所有项，并产生结果。如果传递了额外的可迭代参数，那么函数必须接受多个参数，并将其应用于所有迭代器中的项。有了多个迭代器，当迭代器耗尽时，迭代器就会停止。对于函数输入已经被安排成参数元组的情况，看itertools.starmap().

*max(iterable, [, key, default])

*max(arg1, arg2, args[, key])

返回一个可迭代的最大项或两个或多个参数中最大的项。
如果提供了一个位置参数，那么它应该是可迭代的。可以返回迭代中最大的项。如果提供了两个或多个位置参数，则返回最大的位置参数。
有两个可选的关键字参数。键参数指定了一个单参数的排序函数，类似于list.sort()。如果所提供的迭代是空的，则默认参数指定要返回的对象。如果迭代是空的，并且没有提供默认值，那么就会增加一个ValueError。
如果多个项是最大的，那么函数将返回第一个遇到的项。这与排序(i terable, key=keyfunc,reverse=Ture)[0]和heapq.nlargest(1, iterable,key= keyfunc)。

memoryview(obj)

返回一个从给定参数创建的“内存视图”对象。有关更多信息，请参见内存视图。

*min(iterable, [, key, default])

*min(arg1, arg2, args[, key])

将最小的项返回到可迭代的或最小的两个或多个参数中。
如果提供了一个位置参数，那么它应该是可迭代的。可以返回迭代中最小的项。如果提供了两个或多个位置参数，则返回位置参数的最小值。
有两个可选的关键字参数。键参数指定了一个单参数的排序函数，类似于list.sort()。如果所提供的迭代是空的，则默认参数指定要返回的对象。如果迭代是空的，并且没有提供默认值，那么就会增加一个ValueError。
如果多个项目都是最小的，那么函数将返回第一个遇到的项目。这与排序(i terable, key=keyfunc,reverse=Ture)[0]和heapq.nlargest(1, iterable,key= keyfunc)。

next(iterator[, default])

通过调用next()方法从迭代器中检索下一个项目。如果给定了默认值，则在迭代器被耗尽时返回，否则将停止迭代。
class object
返回一个新的无特征的对象。对象是所有类的基础。它有一些对Python类的所有实例都很常见的方法。这个函数不接受任何参数。

注意对象没有一个对象，因此您不能为对象类的一个实例分配任意的属性。

oct(x)

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

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

打开文件并返回相应的文件对象。如果文件不能打开，就会产生OSError。
file是一个类似路径的对象，它提供要打开的文件的路径名(绝对的或相对于当前工作目录的)，或者是要包装的文件的一个整数文件描述符。(如果给定一个文件描述符，当返回的输入/输出对象关闭时，它将被关闭，除非将关闭该对象设置为False。)
模式是一个可选的字符串，它指定了打开文件的模式。它默认为“r”，这意味着在文本模式下打开阅读。其他常见的值是用于写入的“w”(如果已经存在的话就会截断该文件)、用于创建的“x”和用于应用程序的“a”(在某些Unix系统上，这意味着所有的写入都在文件的末尾附加到该文件的末尾，而不考虑当前的查找位置)。在文本模式下，如果没有指定编码，则使用的编码是依赖于平台的:locale.getpreferredencoding(False)被调用以获得当前的地区编码。(用于读取和写入原始字节，使用二进制模式，并保留未指定的编码。)可用的模式是:

缓冲是用于设置缓冲策略的可选整数。通过0来切换缓冲(只允许在二进制模式下)，1选择行缓冲(只能在文本模式中使用)，以及一个整数大于1来表示固定大小块缓冲区的字节大小。当没有提供缓冲参数时，默认的缓冲策略如下:

• 二进制文件在固定大小的块中进行缓冲;缓冲区的大小使用启发式方法来确定底层设备的“block size”，然后返回到io.DEFAULT_BUGER_SIZE。在许多系统上，缓冲区通常是4096或8192字节。
• “交互式”文本文件(isatty()的文件返回True)使用行缓冲。其他文本文件使用上面描述的二进制文件的策略。
  编码是用于解码或编码文件的编码的名称。这只应该在文本模式中使用。默认的编码是基于平台的(无论 locale.getpreferredencoding()返回)，但是任何由Python支持的文本编码都可以被使用。有关支持编码的列表，请参见codecs模块。
  错误是一个可选的字符串，它指定如何处理编码和解码错误，这不能在二进制模式下使用。可以使用各种标准错误处理程序(在错误处理程序中列出)，但是在codecs.register error()中注册的任何错误处理名称也是有效的。标准的名称包括:
• 如果存在编码错误，则需要strict来提高一个ValueError异常。None的缺省值具有相同的效果。
• ignore忽略错误。注意，忽略编码错误可能导致数据丢失。
• replace会导致一个替换标记(比如“?”)，在有畸形数据的地方插入。
  *“surrogateescape”将表示任何不正确的字节，作为Unicode私有使用范围内的代码点，范围从u+dc 80到u+dcff。这些私有代码点在写入数据时，将被转换为相同的字节。这对于处理未知编码中的文件非常有用。
• 只有在写入文件时才会支持xmlcharplace place。不支持编码的字符将被适当的XML字符引用和nnn替换。
  *backslashreplace取代了Python的“反斜杠转义序列”，取代了畸形数据。
• namereplace(也只在写作时支持)用N代替不受支持的字符。}转义序列。

newline控制了通用换行模式的工作方式(它只适用于文本模式)。它可以是零，“n”，“r”和“r n”。它的工作原理如下:

• 当读取来自流的输入时，如果换行是None，则启用通用的换行模式。输入中的行可以以’n’、‘r’或’r’结尾，然后这些行被转换成’n’，然后再返回给调用者。如果是“通用换行模式”，则返回到调用者未翻译的行。如果它有任何其他的合法值，输入行仅被给定的字符串终止，并且行结束返回给调用者未翻译。
• 在向流写入输出时，如果newline是None，那么写入的任何“n”字符将被转换为系统默认的行分隔符os.linesep。如果新行是’或’n’，则没有翻译。如果newline是其他任何法律值，那么写入的任何“n”字符都将被转换为给定的字符串。
  如果关闭文件是False，而文件描述符而不是文件名，那么在关闭文件时，底层的文件描述符将保持打开状态。如果一个文件名被指定为True(默认值)，否则将会出现一个错误。
  一个定制的开罐器可以通过一个可调用的开罐器来使用。然后通过调用打开器(文件，标志)来获取文件对象的底层文件描述符。打开器必须返回一个打开的文件描述符(传递操作系统。打开就像打开了一个类似于没有的功能的功能)。
  新创建的文件是不可继承的。
  下面的例子使用了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

ord©

给定一个表示Unicode字符的字符串，返回一个表示该字符的Unicode代码点的整数。例如，ord('a')返回整数97和ord(’$’)返回8364。这是chr()的倒数。

pow(x, y[, z])

返回x到幂y，如果z是存在的，返回x到y，模组z(比pow(x，y)%z更有效的计算)，双参数形式pow(x，y)等价于使用幂运算符:x**y。
参数必须有数字类型。使用混合操作数类型，对二进制算术运算符的强制规则应用。对于int操作数，结果具有与操作数相同的类型(在强制之后)，除非第二个参数是负的;在这种情况下，所有的参数都转换为浮点数，并传递一个浮点结果。例如，10**2返回100，但10**2返回0.01。如果第二个参数是负的，那么第三个参数必须被省略。如果z是存在的，那么x和y一定是整数类型，而y必须是非负的。

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

将对象打印到文本流文件中，由sep分开，然后以结束结束。如果出现，则必须以关键字参数作为参数。
所有非关键字参数都被转换为字符串，如str()，并将其写入到流中，由sep分隔，然后以结束结束。sep和end都必须是字符串;它们也可以是None，这意味着使用默认值。如果没有对象，print()只会写结束。
文件参数必须是一个带有写(string)方法的对象;如果它不存在或没有，则系统。将使用标准输出。因为打印的参数被转换为文本字符串，所以不能使用二进制模式文件对象来使用print()。对于这些，使用file.write(.)代替。
输出是否缓冲通常由文件决定，但是如果刷新关键字参数是true，则流将被强制刷新。

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

返回一个财产属性。
fget是获取属性值的函数。fset是设置属性值的函数。fdel是删除属性值的函数。doc为该属性创建一个docstring。
一个典型的用法是定义一个受管理的属性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.")

如果给定，doc将是属性属性的docstring。否则，属性将复制fget的docstring(如果存在的话)。这样就可以很容易地使用property()作为decorator来创建只读属性。

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

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

@property修饰器将voltage()方法转换为具有相同名称的只读属性的“getter”，并设置用于“Get the current vltage”的电压的docstring。
一个属性对象有getter、setter和deleter方法，这些方法可以作为修饰符，创建属性的副本，并将相应的访问函数设置为修饰函数。最好用一个例子来解释这个问题:

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

    @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)。
返回的属性对象还具有与构造函数参数对应的fget、fset和fdel。

range(stop)

range(start, stop[, step])

范围实际上不是一个函数，而是一个不可变的序列类型，正如在范围和序列类型中所记录的那样——list、tuple、range。

repr(object)

返回包含对象的可打印表示的字符串。对于许多类型,这个函数试图返回一个字符串,将产生一个对象具有相同的价值传递给eval(),否则表示是用尖括号括起来的字符串,它包含的类型对象的名称加上额外的信息通常包括对象的名称和地址。一个类可以通过定义一个repr()方法来控制这个函数返回的实例。

reversed(seq)

返回一个反向迭代器。seq必须是一个reversed()方法或支持序列协议(len()方法和getitem()方法的对象，该方法从0开始就有整数参数)。

round(number[, ndigits])

内置类型支持轮(),四舍五入为最接近的值10的倍数- ndigits;如果两个同样倍数接近,甚至舍入完成向的选择(例如,两轮(0.5),(-0.5)是0,和圆(1.5)2)。任何一个整数值有效ndigits(正、零或负)。如果用一个参数调用返回值，则返回值是一个整数，否则与number相同。
对于一般的Python对象编号，圆(数字，n位数)代表到number.round(n位数)。

class set([iterable])

返回一个新的集合对象，可选地使用从迭代中获取的元素。set是一个内置的类。参见设置和设置类型-set、frozenset，用于关于这个类的文档。
对于其他容器，可以看到内置的frozenset、list、tuple和dict classes，以及collections模块。

setattr(object, name, value)

这是getattr()的对应。参数是一个对象、一个字符串和一个任意值。该字符串可以命名一个现有属性或一个新属性。如果对象允许，函数将值赋值给属性。例如，setattr(x，‘foobar’，123)等价于x。foobar = 123。

class slice(stop)

class slice(start, stop[, step])

返回一个切片对象，表示由范围指定的索引集合(开始、停止、步骤)。start和step参数默认为None。Slice对象具有只读的数据属性，开始、停止和步骤仅返回参数值(或它们的默认值)。它们没有其他明确的功能;但是它们被数字Python和其他第三方扩展所使用。当使用扩展索引语法时，也会生成切片对象。

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

从可迭代的项目中返回一个新的排序列表。
有两个可选参数，必须指定为关键字参数。
键指定一个参数的函数，该参数用于从每个列表元素中提取一个比较键:键=str.低层。默认值是None(直接比较元素)。
反向是一个布尔值。如果设置为True，那么列表元素就会被排序，就好像每个比较都被颠倒了一样。
使用functools.cmp_to_key()将一个旧式cmp函数转换为一个键函数。
内置的sorted()函数保证是稳定的。如果它保证不更改比较相等的元素的相对顺序，那么排序是稳定的，这有助于在多个通道中进行排序(例如，按部门排序，然后按工资级别排序)。
对于排序示例和简单的排序教程，请参阅Aorting HOW TO。

staticmethod(function)

返回一个函数的静态方法。
静态方法不会接收到隐式的第一个参数。要声明一个静态方法，请使用这个习语:

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

@staticmethod表单是一个函数修饰符——查看函数定义中的函数定义的描述，以了解详细信息。
可以在类上调用它(such as C.f())，也可以在实例上调用(例如C().f())。除了类，该实例被忽略。
Python中的静态方法与Java或C++中的静态方法相似。还可以看到classmethod()用于创建替代类构造函数的变体。
有关静态方法的更多信息，请参考标准类型层次结构中标准类型层次结构的文档

class str(object=’’)

class str(object=b’’, encoding=‘utf-8’, errors=‘strict’)

返回一个str版本的对象。有关详细信息,请参阅str()。
str是内置的字符串类。有关字符串的一般信息，请参阅文本序列类型-str。

sum(iterable[, start])

开始和从左到右的迭代的项，并返回总数。默认为0开始。迭代的项通常是数字，而起始值不允许是字符串。
对于一些用例来说，有很好的sum()。通过调用' '.join(sequence)，连接一系列字符串的首选快捷方式是。要使用扩展精度添加浮点值，请参见math.fsum()。为了连接一系列的迭代，请考虑使用itertools.chain()。

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

返回代理对象，该代理对象将方法调用委托给父类或同级类。这对于访问在类中被覆盖的继承方法很有用。搜索顺序与getattr()所使用的相同，只是跳过了类型本身。
类型的_mro_属性列出了getattr()和super()所使用的方法解析搜索顺序。属性是动态的，并且在继承层次结构更新时可以更改。
如果省略了第二个参数，则返回的超对象是未绑定的。如果第二个参数是一个对象，isinstance(obj，type)必须为真。如果第二个参数是类型，issubclass(type2,type)必须是true(这对于class方法是有用的)。
超级有两种典型的用例。在具有单继承的类层次结构中，可以使用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()是未定义的。
还要注意的是，除了零参数形式之外，super()并不仅限于在内部方法中使用。这两个参数形式精确地指定了参数，并给出了适当的引用。零参数形式只在类定义中起作用，因为编译器会填充必要的细节，以正确地检索被定义的类，以及访问普通方法的当前实例。
关于如何使用super()设计合作类的实用建议，请参阅使用super()的指南。

tuple([iterable])

tuple实际上不是一个函数，它实际上是一个不可变的序列类型，正如在元组和序列类型中所记录的那样——list、tuple、range。

class type(object)

class type(name, bases, dict)

有一个参数，返回一个对象的类型。返回值是一个类型对象，通常与object.class返回的对象相同。
isinstance()内置函数被推荐用于测试对象的类型，因为它将子类考虑在内。
有了三个参数，返回一个新的类型对象。这实际上是类语句的动态形式。名称字符串是类名，并成为name属性;基元组将基类元素化，并成为基类属性;而字典是包含类体定义的名称空间，并被复制到一个标准字典中，以成为该字典的属性。例如，下面的两个语句创建了相同的类型对象:

class X:
… a = 1
…

X = type(‘X’, (object,), dict(a=1))

vars([object])

返回一个模块、类、实例或任何其他带有一个属性的对象的属性。
诸如模块和实例之类的对象具有可更新的dict;然而，其他对象可能对它们的dict有写限制(例如，类使用类型。MappingProxyType来阻止直接的字典更新)。
没有参数，vars()就像locals()一样。注意，本地字典只对读取有用，因为对本地字典的更新被忽略了

*zip(iterables)

创建一个迭代器，它从每个迭代器中聚合元素。
返回一个元组的迭代器，其中i-th元组包含每个参数序列或迭代器的i-th元素。当最短的输入迭代被耗尽时，迭代器就停止了。使用一个迭代的参数，它返回一个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)

注意 这是一个高级的函数，在日常的Python编程中不需要，与importlib.import_module()不同。

该函数由import语句调用。它可以取代(通过导入内置模块和分配builtins.import)为了改变import语句的语义,但不提倡这样做,因为它通常是更简单的使用进口挂钩(见PEP 302)达到相同的目标,不会导致问题的代码假定默认实现使用的进口。直接使用import()也不鼓励导入import模块()。
该函数导入模块名，可能使用给定的全局变量和局部变量来确定如何在包上下文中解释名称。fromlist给出了应该从名称中导入的模块的对象或子模块的名称。标准实现根本不使用它的本地参数，并且使用它的全局变量来确定导入语句的包上下文。
级别指定是否使用绝对或相对的导入。0(默认值)表示只执行绝对导入。级别的正值指示要搜索的父目录的数量与调用import()模块的目录相关(请参阅PEP 328以获得详细信息)。
当名称变量是表单包时。模块，通常，顶级包(直到第一个点的名称)返回，而不是由名称命名的模块。但是，当给出一个非空的fromlist参数时，将返回以名称命名的模块。
例如，语句导入垃圾邮件的结果是类似于以下代码的字节码:

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

声明进口垃圾邮件。火腿的结果是:

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

注意import()如何返回toplevel模块，因为这是通过import语句绑定到一个名称的对象。
另一方面，垃圾邮件的声明。火腿进口鸡蛋，香肠的结果是

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

这里的垃圾邮件。从import()返回火腿模块。从这个对象中，检索到的名称将被检索并分配给它们各自的名称。
如果您只是想在名称中导入一个模块(可能在一个包中)，那么请使用 importlib.import_module().。

更详细的内容看官网
如有错误，请多多指出