5.1. 真值的测试¶

任何对象都可以测试真值，用于if或while的条件或下面布尔运算的操作数。下面的值被视为假：

• None

• False

• 任何数值类型的零，例如，0、 0L、0.0、 0j。

• 任何空的序列，例如， ''、 ()、 []。

• 任何空的映射，例如，{}。

• 用户定义的类的实例，如果该类定义一个__nonzero__()或__len__()的方法，在该方法返回整数零或布尔值False时。[1]

所有其他值都被视为真 — 所以许多类型的对象永远为真。

除非另有说明，结果为布尔值的运算和内建函数总是返回0或False表示假，1或True表示真（重要的例外：布尔操作符or和and始终返回它们的一个操作数。）

5.2. 布尔操作 — and, or, not¶

这些是布尔操作，按升序优先排序：

注：

1. 这是一个短路操作符，因此只有第一个参数为False时才计算第二个参数。
2. 这是一个短路操作符，因此只有第一个参数为True时才计算第二个参数。
3. not比非布尔操作符的优先级低，因此not a == b解释为not (a == b)，a == not b是一个语法错误。

5.3. 比较操作¶

所有对象都支持比较操作。它们都具有相同的优先级（高于布尔操作）。比较可以任意链接；例如，x < y < = z相当于x < y and y < = z，只是y只计算一次（但这两种情况在x < y为假时都不会计算z）。

下表汇总了比较操作：

注：

1. !=也可以写成<>，但这只是用于保持向后兼容性的用法。新的代码应该一直使用!=。

不同类型的对象，不同的数值和字符串类型除外，比较结果永远不会相等；这类对象排序的结果永远一致但是顺序却是随机的（使得异构数组的排序可以生成一致的结果）。此外，某些类型（例如，文件对象）只支持退化的比较概念，该类型的任何两个对象都不相等。同样，这类对象排序的顺序是随机的但是会永远是一致的。当任何一个操作数是复数时，<、 =、 >和> =运算符会引发TypeError异常。

类的非同一个实例比较时通常不相等，除非该类定义__eq__()或__cmp__()方法。

一个类的实例通常不能与同一个类的其它实例或者其他类型的对象排序，除非该类定义足够丰富的比较方法（__ge__()、__le__()、__gt__()、__lt__()）或__cmp__()方法。

还有两个具有相同优先级的操作in和not in只支持序列类型 (见下文)。

5.4. 数值类型 — int, float, long, complex¶

有四种不同的数值类型：普通整数、长整数、浮点数和复数。此外，布尔值是普通整数的一个子类型。普通整数（或者简称整数）使用C中的long实现，其精度至少为32位（sys.maxint始终设置为当前平台最大的普通整数值，最小值是-sys.maxint - 1)。长整数具有无限的精度。浮点数字通常使用C中的double实现；有关你的程序所运行的机器上的浮点数精度及其内部表示形式的信息在sys.float_info中可以获得。复数有实部和虚部，各是一个浮点数。若要从复数z中提取这些部分，请使用z.real和z.imag。（标准库包括额外的数值类型，fractions支持有理数，decimal支持用户自定义精度的浮点数。）

数值通过数字字面值或内建的函数和操作的结果创建。普通的整数字面值（包括二进制、十六进制和八进制数字）产生普通整数，除非它们指定的值太大以致不能用一个普通的整数表示，在这种情况下它们产生一个长整型。带有'L'或'l'后缀的整数字面值产生长整数（偏向使用'L'，因为1l看起来太像十一）。包含小数点或指数符号的数字字面值产生浮点数。将'j'或'J'附加到数字字面值的尾部产生实部为零的复数。复数字面值是实部和虚部的和。

Python完全支持混合的算法：当二元算术运算符的操作数是不同的数值类型时，“较窄”类型的操作数会拓宽成另外一个操作数的类型，其中整数窄于长整数窄于浮点数窄于复数。比较混合型数字之间使用相同的规则。[2]构造函数int()、long()、float()和complex()可用于产生的一种特定类型的数值。

所有内置的数值类型都支持以下操作。运算符的优先级请参阅幂运算符和后面几节。

注：

1. 对于（普通或长）整数除法，结果是一个整数。结果总是向负无穷舍入：1/2是0，(-1)/2是-1，1/(-2)是-1，（-1)/(-2)是0。请注意如果任何一个操作数是长整数，结果都会是一个长整数，与值大小无关。

2. 使用int()或long()函数转换浮点数会向零截断，类似相关的函数math.trunc()函数。使用函数math.floor()以向下取整和math.ceil()以向上取整。

3. 完整的说明请参阅内置函数。

4. 从2.3版开始弃用：整除运算符、取模运算符和divmod()函数不再为复数定义。相反，如果合适，可以使用abs()函数转换为浮点数。

5. 也被称为整数除法。结果的值完全是一个整数，虽然结果的类型不一定是整型。

6. 浮点数还接受可带有可选前缀 “+”或”-“的字符串”nan”和”inf”来表示非数字（NaN)）和正/负无穷。

   在2.6版中新增。

7. Python定义pow(0,0)和0 ** 0为1，这对于编程语言很常见。

所有的numbers.Real类型（int、long和float）还包含以下的操作：

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

>>> float.fromhex('0x3.a7p10')
3740.0

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

5.5. 迭代器类型¶

版本 2.2 新增。

Python支持容器上迭代的概念。这种实现使用两种截然不同的方法；它们都用于允许用户定义的类支持迭代。下面有更多细节描述的序列始终支持迭代方法。

容器对象需要定义一种方法以支持迭代：

container.__iter__()¶

返回迭代器对象。该对象必须支持如下所述的迭代器协议。如果一个容器支持不同类型的迭代，可以提供额外的方法来为这些迭代类型要求特定的迭代器。（对象支持多种迭代形式的一个示例是支持广度和深度优先遍历的树结构）。此方法对应于Python/C API中Python对象的类型结构的tp_iter slot。

迭代器对象本身需要支持以下两种方法，它们组合在一起形成迭代器协议：

iterator.__iter__()¶

返回迭代器对象本身。这允许容器和迭代器都可以在for和in语句中使用。此方法对应于Python/C API中Python对象的类型结构的tp_iter slot。

iterator.next()¶

从容器中返回下一个元素。如果没有元素，引发StopIteration异常。此方法对应于Python/C API中Python对象的类型结构的tp_iternext slot。

Python定义了几个迭代器对象以支持在通用和特定的序列类型、字典以及其他更多特殊形式上的迭代。相比迭代器协议的实现，具体的类型并不重要。

该协议的意图是一旦迭代器的next()方法引发StopIteration，后续调用将继续这样的行为。不遵守此性质的实现被认为是有问题的。（此约束在Python 2.3中添加；在Python 2.2中，有多个迭代器违背了此规则）。

5.6. 序列类型 — str, unicode, list, tuple, bytearray, buffer, xrange¶

有七个序列类型： 字符串、 Unicode字符串、 列表、 元组、 字节数组、 缓冲区和xrange对象。

其他容器请参阅内建的字典和集合类，以及collections模块。

字符串字面值写在单引号或双引号中：'xyzzy'，"frobozz"。字符串字面值的更多信息请参阅字符串字面值。Unicode字符串与字符串非常相似，但是使用特殊的语法即一个前导的字符'u'指定：u'abc'，u"def"。除了这里描述的功能之外，字符串还有特定的方法在字符串方法一节中描述。列表使用方括号构造，元素以逗号分隔：[a, b, c]。元组通过逗号操作符构造（不在方括号中）， 带或者不带圆括号，但是空元组必须具有圆括号，例如a, b, c或()。单个元素的元组必须含有一个尾部的逗号，例如(d,)。

字节数组对象使用内置函数bytearray()来创建。

Python语法不直接支持缓冲区对象，但可以通过调用内置函数buffer()创建。它们不支持连接或重复。

xrange类型的对象类似于缓冲区，没有特定的语法来创建它们，而是使用xrange()函数创建它们。它们不支持切片、 连接或重复，在它们上使用in，not in、 min()或max()效率较低。

大多数的序列类型支持以下操作。in和not in操作具有与比较操作相同的优先级。+和*的操作具有与相应的数值操作相同的优先级。[3]可变序列类型还提供其他的方法。

下标按优先级升序排列序列的操作（在相同格子中的操作具有相同的优先级）。在表中，s和t是类型相同的序列；n、i和j是整数：

序列类型还支持比较。特别地，元组和列表通过比较相应的元素进行比较。这意味着要比较结果相等，每个元素必须比较基于平等且两个序列必须具有相同的类型和相同的长度。（详情请参阅语言参考中的比较操作。）

注：

1. 当s是一个字符串或Unicode字符串对象时，in和not in操作的行为类似子字符串测试。在Python版本2.3之前，x必须是长度为1的字符串。在Python 2.3及以后，x可以是任意长度的字符串。

2. n小于0的值被视为0（产生一个与s类型相同的空序列）。此外注意拷贝是浅拷贝；嵌套的结构不会被复制。这常常困扰着新的Python程序员；请考虑：

   >>> lists = [[]] * 3
   >>> lists
   [[], [], []]
   >>> lists[0].append(3)
   >>> lists
   [[3], [3], [3]]
   

   发生的事情是这样的，[[]]是包含一个空列表的只有一个元素的列表，所以[[]] * 3的所有三个元素都是（指向）这个空列表。修改lists的任何元素都修改这个列表。你可以用下面的方式创建一个包含不同列表的列表：

   >>> lists = [[] for i in range(3)]
   >>> lists[0].append(3)
   >>> lists[1].append(5)
   >>> lists[2].append(7)
   >>> lists
   [[3], [5], [7]]
   

3. 如果i或j是负值，该索引是相对于字符串结尾的值：用len(s) + i或len(s) + j取代。但请注意-0仍然是0。

4. s从i到j的切片定义为索引为k项组成的序列，其中i < = k < j。如果i或j大于len(s)，则使用len(s)。如果i省略或为None，则使用0。如果j省略或为None，则使用len(s)。如果i大于或等于j，则该切片为空。

5. s从i到i步长为k的切片定义为索引x = i + n*k的项组成的序列，其中0 <= n < (j-i)/k。换句话说，索引是i、i+k、i+2*k、i+3*k等等，在到达j（但不包括j）时停止。如果i或j大于len(s)，则使用len(s)。如果i或j省略或为None，那么它们是”终点”值（哪一端取决于标志k）。请注意，k不能为零。如果k是None，它被视为1。

6. CPython 的实现细节：如果s和t是两个字符串，一些Python实现如 CPython通常可以为s = s + t或s += t形式的赋值执行就地优化。当适用时，这种优化使得二次运行时间很少。这种优化依赖于版本和实现。对于性能敏感的代码，它是最好使用str.join()方法，保证一致的线性串联性能跨版本和实现。

   2.4 版本中的更改：之前，字符串永远不会原地连接。

>>> print '%(language)s has %(number)03d quote types.' % \
...       {"language": "Python", "number": 2}
Python has 002 quote types.

5.7. 集合类型 — set, frozenset¶

集合对象是一个不同可哈希对象组成的无序集合。常见的使用包括成员测试、从序列中删除重复项和计算数学运算（如交、并、差和对称差）。（其它容器请参阅内建的字典、列表和元组类和collections模块。）

2.4版中新增。

类似其它容器，集合支持x in set、 len(set)以及for x in set。作为一个无序的集合，集合不记录元素位置和插入顺序。因此，集合不支持索引、 切片、 或其它类似于序列的行为。

目前有两个内置的集合类型，set和frozenset。set类型是可变的 — 可以使用add()和remove()方法来更改内容。因为它是可变的，所以它没有哈希值且不能用作字典的键或另一个集合的元素。frozenset类型是不可变且可哈希的 — 它创建后不能更改其内容；因此可以用作字典的键或另一个集合元素。

到Python 2.7，除了set构造函数之外，还可以通过放置一个逗号分隔的的元素序列于花括号内来创建非空集合（frozensets不可以），例如：{'jack', 'sjoerd'}。

这两个类的构造函数的工作方式相同：

class set([iterable])¶

class frozenset([iterable])¶

返回新的集合或frozenset对象，其元素取自iterable。集合的元素必须是可哈希的。若要表示集合组成的集合，里面的集合必须是frozenset对象。如果iterable未指定，则返回一个新的空集合。

set和frozenset的实例提供以下操作：

len(s)

返回集合s的基数。

x in s

测试x在s中成员关系。

x not in s

测试x在s中的非成员关系。

isdisjoint(other)¶

如果集合与other没有共同的元素，则返回True 。集合是不相交的当且仅当它们的交集是空集。

在2.6版本中新增。

issubset(other)¶

set <= other

测试集合中的每个元素是否在other中。

set < other

测试集合是否是other的一个真子集，即set <= other and set != other。

issuperset(other)¶

set >= other

测试other中的每个元素是否在集合中。

set > other

测试集合是否是other的真超集，即set >= other and set != other。

union(other, …)¶

set | other | ...

返回一个新的集合，元素来自于集合和所有其它的集合。

2.6 版本中的更改：输入接受多个可迭代对象。

intersection(other, …)¶

set & other & ...

返回一个新的集合，元素是结集合和其它集合共有的。

2.6 版本中的更改：输入接受多个可迭代量。

difference(other, …)¶

set - other - ...

返回一个新的集合，元素在集合中但不在其它集合中。

2.6 版本中的更改：输入接受多个可迭代量。

symmetric_difference(other)¶

set ^ other

返回一个新的集合，元素在集合或other中，但不能在两个集合中都存在。

copy()¶

返回一个新的集合，为s的一个浅拷贝。

请注意，非运算符版本的union()、 intersection()、 difference()，和symmetric_difference()、 issubset()、 issuperset()方法将接受任何可作为参数的迭代。与此相反的是，基础运营商同行需要他们的论点是集。这就排除了出错的建筑物，如支持更具可读性的set('abc').intersection('cbs') set('abc') & 'cbs' 。

set和frozenset支持字符集进行比较。两套是平等的当且仅当每个组的每个元素包含在另 （每个都的另一个子集）。一set小于另一个set当且仅当第一组是第二个集的一个子集 （是一个子集，但不是等于）。一套是否大于另一个设置当且仅当第一组的第二套真超集 （是超集，但不是等于）。

Frozenset基于其成员的实例与实例的set进行比较。例如， set('abc') = = frozenset('abc')返回True ，且set('abc') 在 set([frozenset('abc')])也是如此。

子集和相等性比较不推广到全面排序功能。例如，任意两个非空不相交的集合是否不相等和不是子集的对方，那么所有下列返回False： < b， = = b，或> b。因此，集不实现__cmp__()方法。

由于集只定义部分订购 （子集关系）， list.sort()方法的输出是未定义的集列表。

集合的元素，像字典键必须是hashable。

frozenset混合set实例的二元运算返回第一个操作数的类型。例如: frozenset('ab') |set(‘bc’) 返回一个frozenset的实例。

下表列出的操作可用于set但不可用于不可变的frozenset实例：

update(other, …)¶

set |= other | ...

更新的设置，添加从所有其他的元素。

2.6 版本中的更改：接受多个输入可迭代量。

intersection_update(other, …)¶

set &= other & ...

更新集合,只保留集合与其他集合的交集。

2.6 版本中的更改：接受多个输入可迭代量。

difference_update(other, …)¶

set -= other | ...

更新集合，发现在其他元素中删除。

2.6 版本中的更改：接受多个输入可迭代量。

symmetric_difference_update(other)¶

set ^= other

更新集，保持只发现在任一组中，但不是在两个的元素。

add(elem)¶

添加元素elem到集合。

remove(elem)¶

从集合中移除元素元素。如果元素不包含在集合中，提出了KeyError 。

discard(elem)¶

从集合中移除元素元素，如果它存在。

pop()¶

从集合中移除并返回任意元素。如果此集合为空，则引发KeyError 。

clear()¶

从集合中移除所有元素。

请注意，非运算符版本的update ()、 intersection_update()、 difference_update()和symmetric_difference_update()方法将接受任何可作为参数的迭代。

请注意， __contains__()、 remove ()和discard()方法的元素参数可能是一套。为了支持寻找等效的 frozenset，在搜索期间暂时突变，然后还原elem设置。在搜索， elem集不应读或变异因为它没有一个有意义的值。

5.8. 映射类型 — dict¶

一个映射对象将可映射的的值映射到任意对象。映射是可变对象。目前只有一种标准映射类型，字典。（其它容器请参阅内建的列表、集合和元组类，以及collections模块。）

字典的键几乎是任意值。不可哈希的值，也就是包含列表、字典或其它可变类型的值（它们通过值而不是对象ID进行比较）不可以用作键。用于键的数值类型遵守数值比较的正常规则：如果两个数字的比较结果相等（如1和1.0），那么它们可以用于互相索引相同的词典条目。（注意，由于计算机存储的是浮点数的近似值，因此将浮点数作为键值是不明智的。)

字典可以通过放置一个逗号分隔的key: value对列表于花括号中创建，例如：{'jack': 4098, 'sjoerd': 4127}或{4098: 'jack', 4127: 'sjoerd'}，或通过dict构造函数创建。

class dict(**kwarg)¶

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

返回一个新的字典，从一个可选的位置参数和一个可能为空的关键字参数集合初始化。

如果没有给定位置参数，则创建一个空的字典。如果给定位置参数且它是一个映射对象，则创建一个与该映射对象具有相同的键-值对的一个字典。否则，定位参数必须是一个可迭代的对象。可迭代对象中的每个元素必须本身是具有恰好两个对象的可迭代对象。每个元素的第一个对象就成为新字典的键，第二个对象成为对应的值。如果键出现超过一次，该键的最后一个值将成为新字典中相应的值。

如果给出关键字参数，关键字参数和它们的值会被添加到从位置参数创建的字典。如果正在添加的键已存在，来自关键字参数的值将替换来自位置参数的值。

为了说明，下面所有的例子都返回与{"one": 1, "two": 2, "three": 3}相等的一个字典：

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

第一个示例中的关键字参数仅适用于键都是有效的Python标识符。否则，可以使用任何有效的键。

2.2版中新增。

2.3版中的更改：添加支持从关键字参数构建字典。

下面都是字典支持的操作（因此，自定义的映射类型也应该支持）：

len(d)

返回字典d中元素的个数。

d[key]

返回字典d中键为key的元素。如果key不在映射中，则引发一个KeyError。

2.5版中新增：如果字典的一个子类定义方法__missing__()，如果键key不存在，d [key]操作会以key作为参数调用该方法。如果该键不存在，那么d[key]操作将返回或抛出__missing__(key)调用返回或抛出的任何内容。其它操作或方法不会调用__missing__()。如果未定义__missing__()，则引发KeyError。 __missing__()必须是一个方法 ；它不可以是一个实例变量。有关示例，请参见collections.defaultdict。

d[key] = value

设置d[key]的值为value。

del d[key]

从d中删除d[key] 。如果key不在映射中，则抛出KeyError。

key in d

如果d有一个键key，则返回True，否则返回False。

2.2版中新增。

key not in d

相当于not key in d。

2.2版中新增。

iter(d)

返回字典的键上的一个迭代器。这是iterkeys()的快捷方式。

clear()¶

从字典中移除所有项。

copy()¶

返回字典的一个浅拷贝。

fromkeys(seq[, value])¶

与键从seq和值将设置为值创建一个新的字典。

fromkeys()是一个类方法，返回一个新字典。value默认为None。

2.3版中新增。

get(key[, default])¶

如果key在字典中，则返回key对应的值，否则返回default。如果没有预置default的值，则它默认为None，所以此方法永远不会引发KeyError。

has_key(key)¶

测试key是否在字典中存在。has_key()已经被key in d弃用。

items()¶

返回该dictionary的(key, value)对的列表。

CPython的实现细节：键和值以任意但不是随机的顺序列出，应Python的实现而异，并依赖于字典插入和删除的历史。

如果items()、keys()、values()、iteritems()、iterkeys()和itervalues()调用过程中没有对字典进行修改，则列表将完全一致。这允许使用zip()创建(value, key)对：pairs = zip(d.values(), d.keys())。iterkeys()和itervalues()方法具有同样的关系：pairs = zip(d.itervalues(), d.iterkeys())提供相同的pairs值。另一种创建相同列表的方式是pairs = [(v, k) for （k, v） in d.iteritems()]。

iteritems()¶

返回字典的(key, value)对上的一个迭代器。请参阅dict.items()注释。

使用iteritems()过程中添加或删除字典中的项可能引发RuntimeError或遍历所有条目失败 。

2.2版中新增。

iterkeys()¶

返回字典的键上的一个迭代器。请参阅dict.items()注释。

使用iterkeys()过程中添加或删除字典中的项可能引发RuntimeError或遍历所有条目失败 。

2.2中新增。

itervalues()¶

在字典的值返回一个迭代器。请参阅dict.items()注释。

使用itervalues()过程中添加或删除字典中的项可能引发RuntimeError或遍历所有条目失败 。

2.2版中新增。

keys()¶

返回的字典的键列表的副本。请参阅dict.items()注释。

pop(key[, default])¶

如果key在字典中，删除它并返回其值，否则返回default。如果没有给出default且key不是在字典中，则引发一个KeyError。

2.3版中新增。

popitem()¶

从字典中移除并返回任意一个(key, value)对。

popitem()对于破坏性地遍历一个字典很有用，正如在集合算法中经常用到的一样。如果字典为空，调用popitem()将引发一个KeyError。

setdefault(key[, default])¶

如果key在字典中，返回其值。如果不在，则插入值为default的key并返回default。default默认为None。

update([other])¶

依据other更新词典的键/值对，覆盖现有的键。返回None。

update()接受另一个字典对象或可迭代的键/值对（如元组或其它长度为2的可迭代对象）。如果指定的是关键字参数，那么字典使用这些键/值对更新：d.update(red=1, blue=2)。

2.4版中的更改：允许参数是可迭代的键/值对，并允许关键字参数。

values()¶

返回字典的值的列表的副本。请参阅dict.items()注释。

viewitems()¶

返回字典项(key, value)对的一个新视图。有关详细信息，请参阅以下文档的视图对象。

2.7版中新增。

viewkeys()¶

返回字典的键的新的视图。有关详细信息，请参阅以下文档的视图对象。

2.7版中新增。

viewvalues()¶

返回字典的值的新的视图。有关详细信息，请参阅以下文档的视图对象。

2.7版中新增。

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.viewkeys()
>>> values = dishes.viewvalues()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order
>>> list(keys)
['eggs', 'bacon', 'sausage', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['spam', 'bacon']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}

5.9. 文件对象¶

文件对象使用C的stdio包实现并可以用内置的open()函数创建。文件对象也会由一些其它内置的函数和方法返回，如os.popen()和os.fdopen()以及套接字对象的makefile()方法。临时文件可以通过tempfile模块创建，高级的文件操作如复制、移动和删除文件和目录可以通过shutil模块完成。

当文件操作由于I/O原因失败时，将引发IOError异常。它包括出于某种原因该操作未定义的情况，比如在tty设备上seek()或写入只为读取打开的文件。

文件具有以下方法：

file.close()¶

关闭该文件。关闭的文件无法再读取或写入。关闭该文件后，需要该文件被打开的任何操作将引发ValueError。不止一次调用close()是允许的。

到Python 2.5，如果你使用with语句，你可以避免显式调用此方法。例如，当with代码块退出时，下面的代码将自动关闭f：

from __future__ import with_statement # This isn't required in Python 2.6

with open("hello.txt") as f:
    for line in f:
        print line,

在旧版本的Python中，你需要按下面这样做以获得同样的效果：

f = open("hello.txt")
try:
    for line in f:
        print line,
finally:
    f.close()

注

Python中不是所有的”类文件式”类型支持用作with语句的上下文管理器。如果你的代码是用于处理任何类似文件的对象，你可以使用函数contextlib.closing()而不是直接使用对象。

file.flush()¶

冲洗内部缓冲区，类似stdio的fflush()。在某些类文件对象上，这可能是一个不存在的操作。

注

flush()不一定写入文件的数据到磁盘。在flush()后紧接着使用os.fsync()来确保这种行为。

file.fileno()¶

返回”文件描述符”整数，底层的实现用它来从操作系统请求I/O操作。这可用于其它使用文件描述符较低级别的接口，如fcntl模块或os.read()及类似的函数。

注

没有真正的文件描述符的类文件对象不应该提供此方法！

file.isatty()¶

返回True如果文件连接到一个（类）tty的设备，否则返回False。

注

如果类文件对象没有与一个真正的文件相关联，不应该实现此方法。

file.next()¶

文件对象是其自身的迭代器，例如iter(f)返回f （除非f被关闭）。当一个文件用作一个迭代器时，通常在一个for循环 （例如，for line in f: print line.strip()）， next () 方法被反复调用。此方法返回下一个输入的行，当遇到EOF时引发StopIteration （行为是未定义的当文件打开以进行写入）。为了使一个for循环遍历文件 （是很常见的操作） 的行的最有效途径， next () 方法使用隐藏的预读缓冲区。由于采用了预读缓冲区， next ()方法和其他文件方法相结合时 （如readline ()） 不能正常工作。然而，使用seek()来将该文件重新定位到一个绝对位置将刷新预读缓冲区。

新版本 2.3。

file.read([size])¶

最多从文件读取size字节 （如果在读到字节之前就遇到了EOF，则就比size字节少）。如果size参数为负或被省略，读取所有数据，直到达到了 EOF。作为一个字符串对象返回的字节数。立即遇到 EOF，将返回一个空字符串。（对于某些文件，就像 tty，它有道理继续阅读，创下 EOF。）请注意此方法可能会调用底层的 C 函数fread()不止一次在努力获得尽可能大小字节。此外请注意，处于非阻塞模式时，数据比要求少可能会返回，即使没有大小参数给出。

注

此函数是对底层C函数fread() )的简单封装，并且在某些极端情况下和C函数有相同的行为，例如对于EOF是否被缓存。

file.readline([size])¶

从文件中读取一整行。结尾的换行符包含在字符串中 （当文件为非一整行结束时就可能不在）。[6]如果size参数存在且非负数，它是 （包括尾随换行符） 的最大字节数和可能返回不完整的行。当大小不是 0，则返回空字符串仅立即遇到 EOF。

注

Unlike stdio‘s fgets(), the returned string contains null characters (' ') if they occurred in the input.

file.readlines([sizehint])¶

使用readline ()读取直到EOF，并返回一个包含所读取行的列表。如果可选sizehint参数是存在的而不是读到 EOF，则读取整行共计大约sizehint字节 （可能后向上舍入到内部缓冲区的大小）。对象执行一个类似文件的界面可能会选择忽略sizehint ，如果它不能被实现，或者不能有效地实施。

file.xreadlines()¶

此方法返回作为iter(f)同样的事情。

2.1 版中的新增。

从版本 2.3 开始弃用：改用 for line in file。

file.seek(offset[, whence])¶

设置文件的当前位置，像stdio 头文件 fseek()。从那里来的参数是可选的默认值为os。SEEK_SET或0 （绝对文件定位） ；其他值都是os。SEEK_CUR或1 （相对于当前位置寻道） 和os。SEEK_END或2 （相对于文件的末端寻道）。还有没有返回值。

例如，应对 （2， os。SEEK_CUR)的当前位置提升 2 和应对 (-3， os。SEEK_END)将位置设置为第三名至最后。

请注意是否将追加 （模式'a' a +'） 打开该文件，任何seek()操作将撤消在下一个写入操作。如果为写作追加模式 (模式'a')，这种方法是基本上没有 op，但它仍然是有用的因为打开的文件追加模式与阅读，只有打开该文件启用 (模式' a +')。如果在文本模式下 （没有'b') 打开该文件，只由tell()返回的偏移是合法的。使用其他偏移会导致未定义的行为。

请注意并不是所有的文件对象查找。

2.6 版本中的更改：作为偏移量传递的浮点型值已弃用。

file.tell()¶

返回文件的当前位置，类似stdio的ftell()。

注

在 Windows 上， tell()可以返回非法值 （后fgets ()） 时读取与 Unix 风格的行结尾的文件。使用二进制模式 ('rb') 来绕过这一问题。

file.truncate([size])¶

截断文件的大小。如果存在可选大小参数，则该文件将被截断到 （最多） 那种尺寸。到目前位置的默认大小。当前文件位置不会更改。请注意是否指定的大小超过了该文件的当前大小，结果是依赖于平台： 可能的行动包括，该文件可以保持不变，增加到指定的大小仿佛零填充或增加到指定的大小，以定义新的内容。可用性： Windows 中，许多 Unix 变体。

file.write(str)¶

向文件中写入字符串。无返回值。因为要进行缓冲，该字符串可能不会在文件中显示，直到flush()或close ()方法被调用之后才会在文件中显示写入的字符串。

file.writelines(sequence)¶

向文件中写入一个字符串序列。序列可以是任何可迭代的对象产生的字符串，通常的字符串列表。没有返回值。（名称被用于匹配readlines()； writelines()不会添加行分隔符。）

文件支持迭代器协议。每次迭代返回相同的结果作为readline ()，和迭代结束时readline ()方法返回一个空字符串。

文件对象还提供了其他有趣的属性的数目。这些并不需要的文件一样的东西，但如果他们有意义的特定对象应执行。

file.closed¶

返回布尔类型指示的文件对象的当前状态。这是一个只读的属性 ； close ()方法更改值。它可能不可用上所有的类似文件的对象。

file.encoding¶

此文件使用的编码。当 Unicode 字符串写入到文件中时，它们将转换为字节字符串使用此编码。此外，当文件连接到一个终端，该属性给出了编码终端是可能使用 （信息可能是不正确的如果用户具有配置不正确的终端）。属性是只读，并且可能不会显示所有的文件类似对象。它也可能没有，案例文件使用系统默认的编码将 Unicode 字符串转换。

新版本 2.3。

file.errors¶

Unicode 错误处理程序使用的编码。

在 2.6 版本新。

file.mode¶

该文件 I/O 模式。如果该文件使用open ()内置函数创建的这将是模式参数的值。这是一个只读属性，不可能存在于所有的类似文件的对象。

file.name¶

如果该文件对象使用open ()，该文件的名称来创建的。否则，某些字符串指示的源的文件对象的窗体<>......。这是一个只读属性，不可能存在于所有的类似文件的对象。

file.newlines¶

如果 Python 建成通用换行符启用 （默认值） 此只读的属性存在，并为通用换行符读取它跟踪的类型的读取该文件时遇到的换行符的模式中打开的文件。它可以使用的值是'‘， ' '， '‘，没有（未知，没有换行符还读过） 或包含所有换行符的元组类型看，以指示遇到了多个换行符的公约。对于不在通用换行符读取模式打开的文件此属性的值是不会。

file.softspace¶

布尔值，指示是否一个空格字符需要打印另一个值之前，使用print语句时。试图模拟一个文件对象的类也应该有一个可写的softspace属性，应将其初始化为零。这将自动在 Python （护理可能需要重写属性访问权限的对象） ； 实施的大多数类用 c 语言实现的类型将必须提供一个可写的softspace属性。

注

控制print语句，但允许执行打印来跟踪其内部状态，不使用此属性。

5.10. memoryview类型¶

2.7版中新增。

memoryview对象允许Python代码访问对象的内部数据而不用复制，只要该对象支持缓冲区协议。内存通常被视为简单的字节。

class memoryview(obj)¶

创建引用obj的memoryview 。obj必须支持缓冲区的协议。支持缓冲区协议的内置对象包括str和bytearray（但没有unicode）。

memoryview具有元素的概念，它是由原始对象obj处理的原子内存单元。对于许多的简单类型，例如str和bytearray，元素是一个单字节，但是其他第三方的类型可能会使用较大的元素。

len(view)返回memoryview view中元素的总数。itemsize属性给出单个元素的字节数。

memoryview支持切片的方式来访问其数据。接收单个索引将以str对象返回单个元素。完整的切片将生成一个子视图：

>>> v = memoryview('abcefg')
>>> v[1]
'b'
>>> v[-1]
'g'
>>> v[1:4]
<memory at 0x77ab28>
>>> v[1:4].tobytes()
'bce'

如果memoryview所依赖的对象支持更改其数据，则memoryview支持切片赋值：

>>> data = bytearray('abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = 'z'
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = '123'
>>> data
bytearray(b'z123fg')
>>> v[2] = 'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot modify size of memoryview object

请注意memoryview对象的大小不可以更改。

memoryview有两个方法：

tobytes()¶

以一个字节字符串返回缓冲区的数据（类str的一个对象）。

>>> m = memoryview("abc")
>>> m.tobytes()
'abc'

tolist()¶

以一个整数列表返回该缓冲区中的数据。

>>> memoryview("abc").tolist()
[97, 98, 99]

还有几个只读属性可以访问：

format¶

一个字符串，包含视图中每个元素的格式（以struct模块的风格）。默认为'B'，即简单的字节字符串。

itemsize¶

memoryview中每个元素以字节为单位的大小。

shape¶

整数的元组的ndim给形状记忆作为一个 N 维数组的长度。

ndim¶

一个整数，指示该内存表示的多维数组有多少维度。

strides¶

整数的元组的长度ndim大小以字节为单位） 来访问该数组的每个维度的每个元素。

readonly¶

一个布尔值，指示内存是否只读。

5.11. Context Manager Types¶

新版本 2.5 中的。

Python 的with语句支持由上下文管理器定义的运行时上下文的概念。这被实施使用两个单独的方法，允许用户定义类定义之前执行语句体并退出该语句结束时输入一个运行时上下文。

上下文管理协议包括两个需要为要定义的运行时上下文的上下文管理器对象提供的方法：

contextmanager.__enter__()¶

输入运行时上下文，返回此对象或另一个相关的运行时上下文的对象。此方法返回的值是绑定到使用此上下文管理器with语句的as子句中的标识符。

示例返回本身的上下文管理器是一个文件对象。文件对象返回自己从 __enter__() 允许open ()将用作与语句中的表达式上下文。

返回一个对象相关的对象的上下文管理器示例是经由decimal.localcontext()。这些经理将活跃的十进制上下文设置为原始的十进制上下文的副本，然后返回该副本。这允许向当前的十进制上下文的with语句正文中而不会影响外部with语句的代码的更改。

contextmanager.__exit__(exc_type, exc_val, exc_tb)¶

退出运行时上下文并返回一个布尔标志，指示是否应该抑制发生的任何异常。执行主体with语句时发生异常，如果参数不包含异常类型、 值和追踪信息。否则，所有三个参数都没有。

从该方法返回一个 true 值将导致with语句来抑制该异常并且紧跟的语句之后的语句继续执行。否则该异常继续传播此方法执行完。此方法的执行过程中发生的异常将取代with语句正文中发生的任何异常。

传递中的异常应该永远不会被显式-reraised 相反，此方法应返回 false 的值，以指示该方法已成功完成，并不想要抑制引发的异常。这允许上下文管理代码 （如contextlib.nested） 很容易检测__exit__()方法确实发生了故障。

Python 定义几个上下文管理者，以支持简单的线程同步，及时关闭文件或其他对象和活动的十进制算术上下文操作简单。特定类型不被特别超越他们执行上下文管理协议。请参阅contextlib模块的一些例子。

Python 的生成器和contextlib.contextmanager 装饰器提供方便的方法来实现这些协议。一个生成器函数如果被contextlib.contextmanager装饰器装饰，它将返回上下文管理者实施必要的__enter__()和__exit__()方法，而不是由未修饰的生成器函数的迭代器。

请注意没有特定的插槽，为任何 Python/C API 中的 Python 对象，这些类型结构的方法。想要定义这些方法的扩展类型必须提供他们作为正常的 Python 可访问方法。设置运行时上下文的开销相比，单个类字典查找的开销是微不足道的。

5.12. 其它的内建类型¶

解释器支持其它几个种类的对象。其中大多数只支持一个或两个操作。

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'instancemethod' object has no attribute 'whoami'
>>> c.method.im_func.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

5.13. 特殊的属性¶

具体的实现给几个对象类型添加了几个特殊的只读属性，它们是有关联的。其中一些不会被dir()内置函数显式。

object.__dict__¶

一个字典或其它映射对象，用于存储一个对象的（可写）属性。

object.__methods__¶

自2.2版后弃用：使用内置函数dir()来获取对象的属性列表。此属性已不再可用。

object.__members__¶

自2.2版后弃用：使用内置函数dir()来获取对象的属性列表。此属性已不再可用。

instance.__class__¶

类的实例所属的类。

class.__bases__¶

类对象的基类组成的元组。

class.__name__¶

类或类型的名称。

以下属性只有新式类支持。

class.__mro__¶

此属性是一个类组成的元组，它们在方法解析过程中查找基类时会被考虑。

class.mro()¶

此方法可以被元类重写来为它的实例自定义方法的解析顺序。它在类实例化时调用，其结果存储在__mro__中。

class.__subclasses__()¶

每个新式类保留对其直接子类的一个弱引用列表。此方法返回这些所有还活着的引用的列表。示例：

>>> int.__subclasses__()
[<type 'bool'>]

脚注