2.内置函数

2.内置函数

python解释器有多个函数和类型，内建其中，它们总是可用的，以字母顺序列在这里。

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)

返回真值，如果所有元素或迭代都是真值（或迭代是空），等于：

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

any(iterable)

返回真值，如果任意迭代元素是真值。如果迭代是空，返回假值。等于：

def any(iterable):

    for element in iterable:

        if element:

            return True

    return False

ascii(object)

如repr()，返回一个字符串包含一个对象可打印的代表，但是在字符串中转义非ASCII码字符，由repr()返回使用\x,\u或\U转义。这个生成一个字符串与在python2中repr()返回的相似。

bin(x)

转换一个整数到二进制字符。结果是合法python表达式。如果x不是python整数对象，它必须定义一个__index__()方式来返回一个整数。

class bool([x])

返回一个布尔值，如一个True或False。x被使用标准真值测试转换过程。如果x是假或被忽略，返回False。这个布尔类是整形int的子类（查看数字类型--int，float，complex）。它不能被进一步子类。它只有两个实例，False和True（查看布尔值）。

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

返回一个新的字节数组。这个bytearray类是可变整形在0<=x<256范围的数列。它有大部分通常可变数列的方式，在可变数列类型中描述，还有大部分方式bytes类型也有，查看Bytes和Bytearray操作。

可选参数source能被初始化数组，用不同的方式：

• 如果是字符串，你必须得到编码参数（还有可选的errors）；bytearray()然后转换这个字符串到字节使用str.encode()。
• 如果是个整形，这个数组将有那个大小，都被初始化为null字节。
• 如果是个符合缓冲接口的对象，一个只读的对象将被用来初始化字节数组。
• 如果是个迭代，它必须是个在0<=x<256范围的整形迭代，这将被用来初始化数组的内容。

没有一个参数，大小为0的数组被创建。

查看二进制数列类型--bytes, bytearray, memoryview和Bytearray对象。

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

返回一个新的bytes对象，这是不可变更范围在0<=x<256的整型数列。bytes是bytearray的不可变更版本--有着同样的不可变更方式和同样的引索和分切动作。

同样的，创建参数像bytearray()那样被解析。

Bytes对象也能被用语法创建，查看字符串和字节语法。

也可查看二进制序列类型--bytes, bytearray, memoryview, Bytes和Bytes与Bytearray操作。

callable(object)

返回真值，如果这个object参数能调用，不行就为假。如果返回为真，它仍有可能调用失败，但是假的话，调用object决不会成功。注意classes是能够调用的（调用一个类返回一个新的实例）；实例能被调用如果它们的类有__call__()方式。

版本3.2新加：这个函数在3.0被移除然后在3.2被引入回来。

chr(i)

返回Unicode是这个整形i代表的字符。例如，chr(97)返回字符串'a'，而chr(8364)返回字符串'€'。这是ord()的反向。

这个参数合法的范围是从0到1,114,111(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)

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

编译source到代码或AST项目。代码项目可被exec()或eval()执行。source参数既可是普通字符串，字节串或是AST项目。参考ast模块文档获取如何用AST项目工作的信息。

filename参数是给的读取代码的那个文件；传入一些识别值如果它不能从文件读取（'<string>'通常被用）。

mode参数指定什么样的代码被编译；它可被'exec'如果source包含一系列语句，'eval'如果它包含单独表达式，或'single'如果它包含单独交互语句（在随后例子，表达式语句等于不是None的什么，将被打印）。

可选参数flags和dont_inherit控制哪些特性语句作用source的兼容。如果不存在（或都为零）这个代码被兼容那些在调用compile()代码中的特性语句。如果有flags参数而dont_inherit没有（或为零）那么flags参数被添加的时候的特性语句。如果dont_inherit是非零整形那么flags参数就会--在调用编译影响的特性语句被忽略。

特性语句由那些被合并特定多行语句的位指定。位区块要求指定能在__future__模块中的_Feature实例中被找到作为compiler_flag属性的特性。

optimize指定编译的优化级别；默认值-1选择编译器优化级别，作为-0选项。确定等级是0（无优化；__debug__是真），1（asserts被移除，__debug__是假）或2（docstring也被移除）。

这个函数生成SyntaxError如果被编译的源码不合法，要么ValueError如果源码包含null字节。

如果你要解析python代码到它的AST形式，查看ast.parse()。

注意

当便宜多行代码的字符串，以'single'或'eval'模式，输入必须被终止用至少一个换行符。这是功能检查不完整和完整语句在code模块中。

版本3.2的变化：允许使用windows和mac换行符。还有以'exec'模式输入不必用换行符结束。添加优化参数。

版本3.5的变化：预先TypeError被生成当null字节在源码中遇到。

class complex([real[, imag]])

返回一个值为real+imag*j的复数或转换一个字符串或数字到复数。如果第一个参数是字符串，它将被解释成为复数而第二个参数将忽略。第二个参数不能是字符串。每个参数可能是数字类型（包括复数）。如果imag被忽略，它就默认为零那么构造函数相当于int和float的数字转换。如果两个参数都被忽略，则返回0j。

注意

当从字符串转换的时候，字符串不能在+或-操作符处包含空格。如，complex('1+2j')是可以，但是complex('1 + 2j')生成ValueError错误。

复数类型在数值类型--int，float，complex中详细介绍。

版本3.6的改变：在代码中用下划线组合位被允许。

delattr(object, name)

这个与setattr()相对。参数是对象和字符串。字符串必须是这个对象的属性的名字。函数删除这个给出名字的属性，提供对象允许。如，delattr(x, 'foobar')等于del x.foobar。

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

创建一个新的字典对象。这个dict对象是个字典类。查看dict和Mapping Types--dict关于这个类的文档。

对于其它容器查看内置类list，set和tuple，还有collections模块。

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小于1的话。在任何情况下q*b+a%b是非常靠近a，如果a%b是非零那么它有b同样的符号，并且0<=abs(a%b)<abs(b)。

enumerate(iterable, start=0)

返回一个枚举对象。iterable必须是序列，一个迭代器，或一些其它支持迭代的对象。迭代器的__next__()方法被enumerate()调用返回一个tuple包含着数字(从默认为0的start开始)和值通过迭代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')]

Equivalent to:

def enumerate(sequence, start=0):

    n = start

    for elem in sequence:

        yield n, elem

        n+=1

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

这些参数是字符串和可选的globals与locals。如果提供，globals必须是个字典，locals可以是任何映射对象。

expression参数被解析和求值作为python表达式（从技术上说，一个条件列表）使用globals和locals字典作为global和local命名空间。如果globals字典存在并缺少'__builtins__'，当前的globals被复制到globals参数中在expression参数被解析之前。这意味着expression参数通常可以完全进入标准的builtins模块和被传播的严格环境。如果locals参数字典被忽略那么它默认到globals字典。如果两个字典都省略，expression在eval()被调用的环境执行。返回值是被计算表达式的结果。语法错误被作为异常报告。例如：

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

这个函数可以被用来执行任意代码对象（如那些被compile()创建的）。在这个情况下传递代码对象来代替字符串。如果代码对象已经用exec编译作为模块参数，eval()的返回值将是None。

提示：动态执行语句被exec()支持。globals()和locals()函数返回当前全局和本地目录，这会很有用在使用eval()或者exec()传递时。

查看ast.literal_eval()为能安全计算带表达式字符串的函数。

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

这个函数支持动态执行python代码。object参数可以是字符串或代码对象。如果是字符串，字符串被解析为一组python语句然后被执行（除非语法错误发生）。如果是代码对象，它就直接被执行。在这些情况中，被执行的代码被要求是合法的作为文件输入（查看在手册的“文件输入”部分）。注意return和yield语句不能被用于函数定义外即使在被传递到exec()函数的代码内容。返回值是None。

所有的情况中，如果可选部分被省略，就在当前范围的代码被执行。如果只有globals被提供，它必须是字典，将被用于global和local变量。如果globals和locals都给出，他们被分别用于global和local变量。如果locals被提供就能是任何映射对象。记住在模块级别，globals和locals是同样的目录。如果exec得到两个单独的对象作为globals和locals，代码将被执行就像它被嵌入到类定义中。

如果globals字典没有包含一个key为__buitins__的值，到built-in模块的builtins引用被插入在这个key下。那样你能控制什么样的builtins可用于被执行代码通过插入你自己的__builtins__目录到globals在传递它到exec()之前。

注意

内置函数globals和locals返回当前global和local目录，分别，这个会非常有用在作exec()为第二和第三个参数。

注意

默认locals动作被描述的作为locals()函数下面：修改到默认locals目录应该不试图。传递确切的locals目录如果你要看到代码在locals的效果在函数exec()返回之后。

filter(function, iterable)

构建迭代器从那些迭代元素只有function返回真。迭代可能数列，容器只要支持迭代过程，或者迭代器。如果function是None，特定函数被指定，迭代的所有元素是假就被移除。

注意filter(function, iterable)等价于生成表达式(item for item in iterable if function(item))如果函数不为None而(item for item in iterable if item)就是function为None。

查看itertools.filterfalse()为互补函数返回迭代元素当function返回假时。

class float([x])

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

如果参数是字符串，它应包含十进制数字，可选前缀符号，和可选的嵌入空格。可选符号是’+‘或’-‘；’+‘号对值的产生没有效果。参数也可能是字符串代表NaN(非数字)，或正负无穷。更准确说，输入必须遵从下面的语法在前缀和后尾空格被移除后：

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

这儿floatnumber是python浮点语法形式，在浮点语法中描述。大小写是不敏感，所以，例如，“inf”，“Inf”，“INFINITY”和“iNfINity”都是可介绍的拼写代表正无穷。

否则，如果参数是整形或浮点数，有同样值的浮点数被返回。如果蚕食超过python浮点范围，OverflowError错误将被生成。

对于通常python对象x，float(x)代表x.__float__()。

如果没有参数给定，0.0被返回。

例如：

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

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

版本3.6变化：带下划线的一组数被允许。

format(value[, format_spec])

转换一个值到格式化的表现，由format_spec控制。format_spec的解析将决定于value参数的类型，但是标准格式化符号被用于大部分内置类型：格式化规格迷你语言。

默认format_spec是空字符串将给出像调用str(value)同样的效果。

调用format(value, format_spec)转换到type(value).__format__(value, format_spec)，传递实例字典当查找value的__format__()方法。TypeError异常产生如果方法查询到对象和format_spec是非空，或如果format_spec或返回值不是字符串。

版本3.4变化：object().__format__(format_spec)产生TypeError如果format_spec不是空字符串。

class frozenset([iterable])

返回新的frozenset对象，可选的从迭代来的元素。frozenset是内置类。查看frozenset和Set类型--set，frozenset文档关于此类。

对于其它容器查看内置set，list，tuple和dict类，还有collections模块。

getattr(object, name[, default])

返回对象属性名的值。名字必须是字符串。如果字符串是对象属性的名字，结果就是这个属性的值。例如，getattr(x, 'foobar')等价于x.foobar。如果属性名字不存在，参数default被返回如果提供，否则AttributeError异常产生。

globals()
返回字典类型表示当前的全局符号表。这总是当前模块的字典（在函数或方法内部，这是此处定义的模块，不是模块来自被调用。）

hasattr(object, name)
参数是对象和字符串。结果是真如果字符串是对象属性的名字，不是就为假。（这由调用getattr(object, name)然后查看是否产生AttributeError异常。）

hash(object)
返回对象的哈希值（如果它有的话）。哈希值是整数。他们被用于快速比较字典keys在字典查找时。数值比较相等有同样的哈希值（即使他们是不同类型，比如1和1.0的情形）。
注意
对于对象的自定__hash__()模块，注意hash()以主机位宽方式切断返回值。查看__hash__()来了解细节。

help([object])
调用内置帮助系统。（这个函数为交互目的使用。）如果没有参数给定，交互帮助系统开始在解析控制台。如果参数是字符串，那么字符串将被作为模块，类，方法，关键字或文档主题名查询，然后帮助页在控制台被打印。如果参数是任意其它对象，关于对象的帮助页面被生成。
这个函数被site模块添加到内置名字空间。
版本3.4变化：pydoc和inspect的变化，被报告的印记对于可调用现在更理解和准确。

hex(x)
转换一个整形数字到小写的十六进制字符串以“0x”作为前缀，例如：

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

如果x不是python整形对象，它必须定义__index__()方式来返回一个整数。
查看int()关于转换十六进制字符串到使用16进制的整数。
注意
要得到十六进制字符串表示浮点数，使用float.hex()方式。

id(object)
返回对象的识别码（id）。这是整数被授予唯一和不变的对于这个对象在它的生命时间里。两个对象可能有相同的id()值在不重叠的生命时间里。
CPython实现细节：这是对象在内存中的地址。

input([prompt])
如果prompt参数存在，它被写到标准输出不带尾部换行符。函数然后读取从输入读取一行，转换到字符串（去掉末尾换行），返回这个。当EOF被读取，EOFError异常产生。例如：

>>> s = input('--> ') 
--> Monty Python's Flying Circus
>>> s 
"Monty Python's Flying Circus"
如果readline模块被载入，那么input()将使用它来提供详细的行编辑和历史记录特性。

class int(x=0)
class int(x, base=10)
返回整数对象从一个数或字符串x构建，或者返回0如果没有参数给定。如果x是个数，返回x.__int__()。对于浮点数，这将截断到零。
如果x不是数字或base被给定，那么x必须是string，bytes，或bytearray实例表示一个字面整数以基于的进制。可选的，文字可被处理如+或-（之间没有空格）和空格包围。base-n文字包含位数0到n-1，和a到z（或A到Z）具有对应的10到35值。默认的base是10.
这允许的值是0到2-36。base-2，-8，和-16文字能被可选前缀和0b/0B，0o/0O，或者0x/0X，在代码中的整数文字。base0意味解释为代码文字，那么可用base是2，8，10或16，所以int('010', 0)不合法，而int('010')也是int('010', 8)。

整数类型在数值类型中描述--int，float，complex。
版本3.4变化：如果base不是个整形实例而且base对象有个base.__index__方式，这个方式被调用为base得到一个整数。之前版本使用base.__int__代替base.__index__。
版本3.6变化：带下划线数字组合作为代码文字被允许。

isinstance(object, classinfo)
返回真如果object参数是classinfo参数的实例，或（直接，间接或虚拟）子类。如果对象不是被给定类型的对象，函数总是返回假。如果classinfo参数是tuple类型对象（或其他这样的tuples），返回真如果对象是这个类型中任意一个的实例。如果classinfo不是type或tuple类型和这样的tuples，TypeError异常产生。

issubclass(class, classinfo)
返回真如果class是classinfo子类（直接，间接或虚拟）。一个类被认为是它自己的子类。classinfo可能是tuple形式的类对象，其中每一个都被检查。其他情况，TypeError异常产生。

iter(object[, sentinel])
返回一个迭代器对象。第一个参数是被不同解释基于第二个参数存在。没有第二个参数，对象必须是collection对象并支持迭代协议（__iter__()方法），或它必须支持序列协议（__getitem__()方法所带整数参数开始为零）。如果它不支持这些协议，TypeError异常产生。如果第二个参数，sentinel，被给定，那么对象必须是可调用对象。在这个情况下创建的迭代器将调用对象不带参数对它的__next__()方法；如果值返回等于sentinel，StopIteration将产生，否则值将返回。
查看Iteratro Types章节。
一个有用的应用采用iter()第二种形式来读取文件的行直到特定行到达。下面的例子读取文件直到readline()方法返回空字符串：

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

 

len(s)
返回对象长度（项目数量）。参数可能是序列（如string，bytes，tuple，list或range）或是collection（如dict，set或frozenset）

class list([iterable])
不止是个函数，list是可变序列类型，在文档Lists and Sequence Types-list，tuple，range。

locals()
更新和返回一个字典表示当前本地符号表。不同变量被返回通过locals()当它被调用在函数块中，不在class块中。
注意
这个字典内容不能更改；改变不能影响到本地值和任意变量被解析器使用。

map(function, iterable, ...)
返回function参数应用到iterable每个项目生成的迭代器，产生结果。如果另外的iterable参数被传递，function必须接受这些参数然后并行应用到所有iterable的项目。有多个iterables，迭代器停止当最短iterable耗完。如function输入已经被安排到参数tuple，查看itertools.starmap()。

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
返回最大的项目在iterable中或最大的多个参数中。
如果位置参数提供，它应是iterable。iterable中最大的项目被返回。如果两个或更多位置参数提供，最大的这些位置参数被返回。
这有两个可选只有keyword参数。key参数指定一个参数顺序函数如list.sort()。默认参数指定对象来返回如果提供iterable是空。如果iterable是空并且默认不被提供，ValueError异常产生。
如果多个项目是最大的，函数返回第一个遇到的。这是一致的跟其它排列工具如sored(iterable, key=keyfunc, reverse=True)和heapq.nlargest(1, iterable, key=keyfunc)。
版本3.4新增：默认keyword-only参数。

memoryview(obj)
返回内存查看对象创建来自被给定参数。查看Memory Views关于更多信息。

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
返回最小项目在iterable中或多个参数中最小的。
如果一个位置参数提供，它应该是iterable。在iterable中最小的项目被返回。如果两个或更多位置参数被提供，最小的位置参数被返回。
这里有两个可选keyword-only参数。key参数指定一个参数排列函数如list.sort()。默认参数指定对象来返回如果提供的iterable为空。如果iterable为空并且默认没有提供，ValueError异常产生。
如果多个项目是最小的，函数返回第一个遇到的。这是一致的跟其它排列工具如sorted(iterable, key=keyfunc)[0]和heapq.nsmallest(1, iterable, key=keyfunc)。
版本3.4新增：默认keyword-only参数。

next(iterator[, default])
获得下一个项目从迭代器通过调用它的__next__()方法。如果默认被给定，它将被返回如果迭代器被消耗完，否则StopIteration产生。

class object
返回一个新的无特性对象。对象是所有类的基类。它有对所有python类的实例的方法。这个函数不接受任何参数。
注意
对象没有__dict__属性，所以你不能随意指定属性到object类的实例。

oct(x)
转换整数到八进制字符串。结果是合法的python表达式。如果x不是python整形对象，它必须定义一个__index__()方法来返回整数。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
打开文件然后返回绑定的文件对象。如果文件不能打开，OSError异常产生。
文件是像路径的对象按给出文件的路径名（决定或相对于当前的工作目录）打开或者一个整数文件描述被包含。（如果一个文件描述器被给定，它被关闭当返回的I/O对象被关闭，除非closefd被设置为假。）

mode参数是可选字符串来指定文件被打开的模式。它默认是‘r’将以文本模式读取打开。其它通常值是‘w’来写入（截断文件如果它已经存在），‘x’来排他创建还有‘a’来添加（这个在一些Unix系统，意味着所有的写入附加到文件的末尾无论当前的寻找位置）。在文本模式中，如果encoding没有被指定那么encoding使用依赖平台的编码：locale.getpreferredencoding(False)被调用来得到当前本地编码。（对于读和写原始字节使用二进制模式，不用指定编码。）可用的模式有：
字符表示
'r' 读取打开（默认）
'w' 写入打开，首先截断文件
'x' 专属创建打开，失败如果文件已存在
'a' 写入打开，附加到文件末尾如果存在
'b' 二进制模式
't' 文本模式（默认）
'+' 打开一个硬盘文件更新（读和写）
'U' 通用换行模式（废弃）

默认模式‘r’（读取文本打开，如‘rt’）。对于二进制读写进入，模式‘w+b’打开和截断文件到0字节。‘r+b’打开文件不进行截断。
在大致上提到的，python在二进制和文本输入输出上区分。文件以二进制打开（在mode参数中包含‘b’）返回bytes对象的内容不进行任何编码。在文本模式中（默认，或当‘t’被包含在mode参数中时），文件的内容被返回作为str对象，这是bytes已经先解码使用依赖平台的编码或用给的指定编码。
注意
python不依靠操作系统潜在的文本标志；所有处理被由python自己完成，但是也有依赖平台。

buffering参数是可选整数被用来设置缓冲政策。传递0来关闭缓冲（只有在二进制模式），1来选择行缓冲（只用在文本模式），还有整数>1来表示字节大小固定的堆缓冲。当没有buffering参数给定时，默认缓冲政策作用如下：
二进制文件缓冲在固定大小堆；缓冲的大小被选择使用启发式来决定设备潜在的“块大小”然后落回到io.DEFAULT_BUFFER_SIZE。在多个系统中，缓冲一般是4096或8192字节长。
“交互”文本文件（isatty()返回真的文件）使用行缓冲。其它文本文件使用上面描述的对于二进制文件。
encoding参数是使用来解码或编码文件的编码名字。这必须是用文本模式。默认编码是依赖平台（locale.getpreferredencoding()返回的），但是任何被python支持的文本编码都可以使用。查看编码模块关于支持的编码列表。
errors是可选字符串来指定编码和解码的错误如何来处理，这不能被用于二进制模式。不同的标准错误处理可用（列于Error Handlers），那么任何错误处理名字已经被codecs.register_error()注册是合法的。这个标准名字包括：
'strict'来产生ValueError异常如果有编码错误。默认None的值有同样的效果。
'ignore' 忽略错误。注意忽略编码错误会导致数据损失。
'replace' 引起一个代替的标志（如'?'）插入到不正确的数据处。
'surrogateescape'将表示任何不正确字节作为代码点在Unicode私有使用空间从U+DC80到U+DCFF。这些私有代码点将会转回到同一字节当surrogateescape错误处理被使用当写数据时。这是有用的对于处理不知道编码的文件。
'xmlcharrefreplace' 只有当写入到文件时支持。不被编码支持的字符被用相应的XML字符引用&#nnn;替代。
'backslashreplace' 替代不正确格式数据用python的反斜杠序列。
'namereplace' （也只有在写入时支持）替代不支持的字符用\N{...}序列表示。
newline参数控制如何newlines模式作用（它只应用于文本模式）。它可以是None，''，'\n'，'\r'，和'\r\n'。它作用如下：
当从流读取输入，如果newline是None，通用newlines模式启用。行在输入中可以以'\n','\r',或'\r\n'结尾，并且这些被转换到'\n'在被返回到调用者之前。如果它是''，通用newlines模式被启用，但是行结束被返回到调用者不进行转换。如果它有任何其它合法值，输入行只被给定字符串结束，然后行结束被返回到调用者不进行转换。
当输出写入到流，如果newline是None，任何被写的'\n'字符转换到系统默认行分隔符，os.linesep。如果newline是''或'\n'，没有转换发生。如果newline是任意其它合法值，任何'\n'字符被写入转换到给定字符串。
如果closefd是假并且一个文件描述符不是被给文件名，潜在的文件描述符将保持打开当文件关闭时。如果文件名被给定closefd必须是True（默认）否则错误将产生。
自定opener参数能被用来传递调用作为打开者。潜在文件描述符对于文件对象得到通过调用打开者用（file，flags）。opener参数必须返回打开文件表述符（传递os.open作为打开者结果在功能上与传递None相似）。
新创建文件是非继承的。
下面例子使用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()函数返回依赖mode。当open()被用来打开文件以文本模式('w','r','wr','rt',etc。),它返回io.TextIOBase子类（特别io.BufferedIOBase）。当以二进制打开文件使用缓冲，返回类是io.BufferedIOBase基类。类不相同：在读取二进制模式，它返回BufferedReader;以写二进制和附加模式，它返回io.BufferedWriter，然后在读/写模式，它返回io.BufferedRandom。当缓冲禁止时，原始流，io.RawIOBase的子类，io.FileIO被返回。
查看file handling模块，如，fileiput，io（这里open()被描述），os，os.path，tempfile，和shutil。
版本3.3变化：
opener参数被添加。
'x'模式被添加
生成的IOError，它现在是OSError同义词。
FileExistsError现在生成如果文件被打开于专属模式。
创建模式（‘x’）已经存在。
版本3.4变化：
文件现在不是继承的。
废弃从版本3.4开始，将在版本4.0移除：‘U’模式。
版本3.5变化：
如果系统调用被中断并且信号处理没有产生异常，函数现在重试系统调用代替产生InterruptedError异常（查看PEP 475）。
'namereplace'错误处理被添加。
版本3.6变化：
支持添加接受对象实现os.PathLike。
在Windows，打开控制台缓冲可能返回io.RawIOBase子类而不是io.FileIO。

ord(c)
给用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。
参数必须是数字类型。与混合的操作类型，优先规则应用二元操作符。对于整形操作数，结果跟操作数是同样类型（在强制转换之后）除非第二个参数是负数；在那样的情况中，所有参数被转换到浮点和浮点结果。例如，10**2返回100，但是10**-2返回0.01.如果第二个参数是负数，那么第三个参数必须省略。如果z存在，x和y必须是整数类型，y必须是非负。

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
打印对象到文本流文件，分隔由sep参数并且跟着end参数。sep，end和file参数，如果存在，必须以keyword参数给定。
所有非keyword参数都被转换到字符串像str()的结果然后写到流，分隔由sep和跟随由end。sep和end都必须是字符串；它们也能是None，意味着使用默认值。如果没有对象给定，print()将写end参数。
file参数必须是个对象带有write(string)方法；如果它不存在或为None，sys.stdout将被使用。由于被打印的参数转换到字符串，print()不能用于二进制模式文件对象。对于这些，用file.write(...)instead。
输出是否缓冲通常由文件决定，但是如果flush关键字参数为真，流是强制flushed。
版本3.3变化：添加flush关键字参数。

class property(fget=None, fset=None, fdel=None, doc=None)
返回一个property属性。
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.")
如果c是C的实例，c.x将调用getter，c.x=value将调用setter然后del c.x调用deleter。
如果被给定，doc将是属性的docstring。否则，属性将复制fget的docstring（如果它存在）。这使它能够方便创建只读属性使用property()作为修饰符：
class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage
这个@property修饰符转换voltage()方法到“getter”方法来用同样的名字只读属性，它为voltage设置docstring到“Get the current vltage.”
property对象有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。）
返回的property对象也有属性fget，fset，和fdel与构建参数相关联。
版本3.5变化：property对象的docstring现在可以写入。

range(stop)
range(start, stop[, step])
并非函数，range实际上是不可变序列类型，如文档Ranges and Sequence Type--list，tuple，range所示。

repr(object)
返回字符串包含对象可打印出的表示。对于大多数类型，这个函数试图返回字符串能够产生同样的结果当传递给eval()，否则表示是个在三角括号的字符串包含对象类型的名字和额外的信息通常是名字和对象的内存地址。类能够控制这个函数返回结果为它的实例通过定义__repr__()方法。

reversed(seq)
返回逆序的迭代器。seq参数必须是对象具有__reversed__()方法或者支持序列协议（__len__()方法和__getitem__()方法跟整数参数开始为0）。

round(number[, ndigits])
返回浮点值数字到ndigits参数位在小数点后。如果ndigits省略或为None，它返回到它输入的最近整数。调用number.__round__(ndigits)。
对于支持round()的内置类型，值是最近的10的倍数；如果两个数字相近，那么就朝向偶数的选择（如，round(0.5)和round(-0.5)都是0，round(1.5)是2）。返回值是整数如果被调用使用一个参数，否则与number相同类型。
注意
round()行为关于floats可能意外：例如，round(2.675)结果是2.67而不是2.68。这并不是bug：它是确实的结果大部分小数分数不能以浮点精确的表示。查看Floating Point Arithmetic:Issues and Limitations来得到更多信息。

class set([iterable])
返回一个新的set对象，可选的元素来自iterable。set是内置类。查看set and Set Types--set, frozenset的文档关于这个类。
对于其它容器查看内置frozenset,list,tuple and dict classes,还有collections模块。

setattr(object, name, value)
这是getattr()的另一部分。参数是个对象，字符串和任意值。字符串可能命名存在的属性或新的属性。函数将值付给属性，提供的对象才允许。如，setattr(x, 'foobar', 123)等价于x.foobar=123。

class slice(stop)
class slice(start, stop[, step])
返回切片对象表示一组范围range(start, stop, step)。start和step参数默认为None。切片对象有只读数据参数start, stop和step仅仅返回参数值（或它们的默认）。它们有其它确切功能；但是它们被用于数值python和其它三方扩展。切片对象也生成当扩展引索符号被使用。例如：a[start: stop: step]或a[start: stop, i]。查看itertools.islice()变形版本返回一个迭代器。

sorted(iterable[, key][, reverse])
返回新的已排列列表从迭代中的项目。
有两个可选参数必须指定为关键字参数。
key参数指定一个参数使用的函数来提取一个比较的key从每个列表元素：key=str.lower。默认值为None（直接比较元素）。
reverse参数是布尔值。如果设置为真，那么列表元素被排列好像每个比较相反。
使用functools.cmp_to_key()来转换一个老风格比较函数到key函数。
内置sorted()函数是稳定性的。排列是稳定的如果它不随意改变相等元素的相对顺序--这是有用的对于排列多次（例如，以部门排列，然后工薪等级排列）。
对于排列列子和大概的排列指南，查看如何排序。

staticmethod(function)
返回一个静态方法为函数。
静态方法不接受隐含的第一个参数。声明静态方法，使用这样形式：
class C:
    @staticmethod
    def f(arg1, arg2, ...): ...
这个@staticmethod形式是函数修饰符--查看函数定义描述在Function definition章节的细节。
它能在类上被调用（如C.f()）或实例（如C().f()）。实例被忽略除了它的类。
在python中的静态方法与Java或C++中的相似。也可查看classmethod()非常有用来创建不同的类构造函数。
关于静态方法的更多信息，参考文档的标准类型层级在标准类型层级章节。

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
返回字符串版本的对象。查看str()得到细节。
str是内置字符串类。关于通常的字符串信息，查看Text Sequence Type-str。

sum(iterable[, start])
sum开始和迭代项目从左到右然后返回总数。start参数默认为0。迭代的项目通常是数字，而start值不允许是字符串。
对于一些使用状况，有更好的sum（）变体版本。进行快速连接一列字符串通过调用''.join(sequence)。加总浮点值用扩展精度，查看math.fsum()。连接一系列迭代，考虑使用itertools.chain()。

super([type[, object-or-type]])
返回一个代理对象来委托方法调用一个父类或兄妹类。这是有用的对于进入继承的方法已经在类中被重载。查找顺序与使用getattr()相同除了自己类型被跳过。
这个类型__mro__属性列出方法查找顺序同样被getattr()和super()使用的。属性是动态的并且会改变当继承层级被更新。
如果第二个参数被省略，这个被返回的super对象是未绑定的。如果第二个参数是个对象，那么isinstance(obj, type)必须为真。如果第二个参数是个类型，issubclass(type2, type)必须是真（这是有用的对于类方法）。
对于super有两种典型使用情况。在一个单继承的类层级，supr可被用来引用父类而不用明确指明它们，这样使代码更具有维护性。这种使用非常相似与其它程序语言中的super使用。
第二种使用情况是支持组合的多继承在动态执行环境。这个使用情况是python唯一的且不能在静态便宜语言或只支持单继承的语言中找到。这使它可能实现“钻石样式”具有多基类实现相同方法。好的设计要求这个方法有同样的调用符号在每种情况中（因为调用顺序在运行时被决定，因为顺序适应类层级的变化，并且因为顺序能包含兄妹类在运行时不知道优先级）。
对于两种使用情况，一个典型superclass调用像这样：
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()，查看手册的using supeer()部分。

tuple([iterable])
相对说是函数，tuple实际上是不可变序列类型，如文档中所示Tuples and sequence Types--list, tuple, range。

class type(object)
class type(name, bases, dict)
带有一个参数，返回对象的类型。返回值是个类型对象通常同样与object.__class__返回对象。
isinstance()内置函数推荐用于测试对象类型，因为它接受子类。
带有三个参数，返回新的类型对象。这是类语句的基本动态形式。name字符串是类名并成为__name__属性；bases参数tuple基类项目并成为__bases__属性；dict参数字典是名字空间包含类体定义并被复制到标准字典成为__dict__属性。例如，接下来两个语句创建相似类对象：
>>> class X:
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))
也可查看Type Objects部分。
版本3.6变化：子类类型不能覆盖type.__new__不在使用一个参数形式来得到对象类型。

vars([object])
返回__dict__属性为模块，类，实例或任何其它对象具有__dict__属性。
对象如模块和实例有更新表__dict__属性；但是其它对象有写限制在它们的__dict__属性（例如，类使用types.MappingProxyType来阻止字典更新）。
不带参数，vars()行为像locals()。注意，locals字典只有用在读取当更新到locals字典被忽略。

zip(*iterables)
生成迭代器通过集合元素来自迭代的每一个。
返回tuples的迭代器，这个中第i位tuple包含第i位元素来自参数序列或迭代的每一个。迭代器停止当最短的输入迭代耗尽。带单独一个迭代参数，它返回1-tuples迭代器。不带参数，它返回空迭代器。等价于：
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)
自左到右迭代计算顺序被授予。这使一个形式可能聚集数据系列到n长度组合使用zip(*[iter(s)]*n)。这重复同样迭代器n次所以每个输出tuple有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__()也是不鼓励而支持importlib.import_module()。
这个函数导入模块名，潜在使用被给定的全局和本地来决定如何中断包内的名字。来自列表给定对象或子模块名字应该被导入从被给定的模块名。标准实现不使用它的locals参数，只使用它的globals参数来决定包内容的导入语句。
level参数指定是否使用完全或相对导入。0（默认）意味着只进行绝对导入。level的正值指示父目录的数量来查找相对模块目录通过调用__import__()(查看PEP 328获得细节)。
当name变量是package.module形式，通常，最外包（名字直到上面第一个点）被返回，不是模块名。但是非空来自列表被给定，模块名被返回。
例如，import语句垃圾结果以字节码形式类似下面代码：
spam = __import__('spam', globals(), locals(), [], 0)
spam = __import__('spam.ham', globals(), locals(), [], 0)
注意__import__()如何返回最上层模块因为这是对象绑定到名字通过import语句。
在另一方面，语句从spam.ham导入鸡蛋
_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）。

转载于:https://my.oschina.net/u/2601985/blog/822800