5. 内置类型 ¶

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

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

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

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

In this case no * specifiers may occur in a format (since they require a sequential parameter list).

转换标志字符：

标志	含义
'#'	The value conversion will use the “alternate form” (where defined below).
'0'	The conversion will be zero padded for numeric values.
'-'	The converted value is left adjusted (overrides the '0' conversion if both are given).
' '	(a space) A blank should be left before a positive number (or empty string) produced by a signed conversion.
'+'	A sign character ( '+' or '-' ) will precede the conversion (overrides a “space” flag).

A length modifier ( h , l ，或 L ) may be present, but is ignored as it is not necessary for Python – so e.g. %ld is identical to %d .

转换类型：

转换	含义	注意事项
'd'	有符号整数十进制。
'i'	有符号整数十进制。
'o'	有符号八进制值。	(1)
'u'	过时 type – 它等同于 'd' .	(7)
'x'	有符号十六进制 (小写)。	(2)
'X'	有符号十六进制 (大写)。	(2)
'e'	浮点指数格式 (小写)。	(3)
'E'	浮点指数格式 (大写)。	(3)
'f'	浮点十进制格式。	(3)
'F'	浮点十进制格式。	(3)
'g'	Floating point format. Uses lowercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.	(4)
'G'	Floating point format. Uses uppercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.	(4)
'c'	Single character (accepts integer or single character string).
'r'	字符串 (转换任何 Python 对象使用 repr() ).	(5)
's'	字符串 (转换任何 Python 对象使用 str() ).	(6)
'%'	No argument is converted, results in a '%' character in the result.

注意事项：

1. The alternate form causes a leading zero ( '0' ) to be inserted between left-hand padding and the formatting of the number if the leading character of the result is not already a zero.

2. The alternate form causes a leading '0x' or '0X' (depending on whether the 'x' or 'X' format was used) to be inserted before the first digit.

3. The alternate form causes the result to always contain a decimal point, even if no digits follow it.

   The precision determines the number of digits after the decimal point and defaults to 6.

4. The alternate form causes the result to always contain a decimal point, and trailing zeroes are not removed as they would otherwise be.

   The precision determines the number of significant digits before and after the decimal point and defaults to 6.

5. The %r conversion was added in Python 2.0.

   The precision determines the maximal number of characters used.

6. If the object or format provided is a unicode string, the resulting string will also be unicode .

   The precision determines the maximal number of characters used.

7. 见 PEP 237 .

由于 Python 字符串有明确长度， %s 转换未假定 '\0' 是字符串末尾。

2.7 版改变： %f 转换对于绝对值大于 1e50 的数字不再替换通过 %g 转换。

Additional string operations are defined in standard modules string and re .

5.6.3. XRange Type ¶

The xrange type is an immutable sequence which is commonly used for looping. The advantage of the xrange type is that an xrange object will always take the same amount of memory, no matter the size of the range it represents. There are no consistent performance advantages.

XRange objects have very little behavior: they only support indexing, iteration, and the len() 函数。

5.6.4. 可变序列类型 ¶

List and bytearray objects support additional operations that allow in-place modification of the object. Other mutable sequence types (when added to the language) should also support these operations. Strings and tuples are immutable sequence types: such objects cannot be modified once created. The following operations are defined on mutable sequence types (where x is an arbitrary object):

操作	结果	注意事项
s[i] = x	item i of s 被替换通过 x
s[i:j] = t	slice of s from i to j is replaced by the contents of the iterable t
del s[i:j]	如同 s[i:j] = []
s[i:j:k] = t	the elements of s[i:j:k] are replaced by those of t	(1)
del s[i:j:k]	removes the elements of s[i:j:k] from the list
s.append(x)	如同 s[len(s):len(s)] = [x]	(2)
s.extend(t) or s += t	for the most part the same as s[len(s):len(s)] = t	(3)
s *= n	更新 s with its contents repeated n times	(11)
s.count(x)	return number of i ’s for which s[i] == x
s.index(x[, i[, j]])	return smallest k 这样 s[k] == x and i <= k < j	(4)
s.insert(i, x)	如同 s[i:i] = [x]	(5)
s.pop([i])	如同 x = s[i]; del s[i]; return x	(6)
s.remove(x)	如同 del s[s.index(x)]	(4)
s.reverse()	reverses the items of s in place	(7)
s.sort([cmp[, key[, reverse]]])	sort the items of s in place	(7)(8)(9)(10)

注意事项：

1. t 必须与要替换切片具有相同的长度。

2. The C implementation of Python has historically accepted multiple parameters and implicitly joined them into a tuple; this no longer works in Python 2.0. Use of this misfeature has been deprecated since Python 1.4.

3. t can be any iterable object.

4. 引发 ValueError 当 x 找不到在 s . When a negative index is passed as the second or third parameter to the index() method, the list length is added, as for slice indices. If it is still negative, it is truncated to zero, as for slice indices.

   Changed in version 2.3: 先前， index() didn’t have arguments for specifying start and stop positions.

5. When a negative index is passed as the first parameter to the insert() method, the list length is added, as for slice indices. If it is still negative, it is truncated to zero, as for slice indices.

   Changed in version 2.3: Previously, all negative indices were truncated to zero.

6. The pop() method’s optional argument i 默认为 -1 ，因此默认情况下，最后项会被移除并返回。

7. The sort() and reverse() methods modify the list in place for economy of space when sorting or reversing a large list. To remind you that they operate by side effect, they don’t return the sorted or reversed list.

8. The sort() method takes optional arguments for controlling the comparisons.

   cmp specifies a custom comparison function of two arguments (list items) which should return a negative, zero or positive number depending on whether the first argument is considered smaller than, equal to, or larger than the second argument: cmp=lambda x,y: cmp(x.lower(), y.lower()) 。默认值为 None .

   key specifies a function of one argument that is used to extract a comparison key from each list element: key=str.lower 。默认值为 None .

   reverse 是布尔值。若设为 True ，则对列表元素排序，就好像反转每一比较。

   一般而言， key and reverse conversion processes are much faster than specifying an equivalent cmp function. This is because cmp is called multiple times for each list element while key and reverse touch each element only once. Use functools.cmp_to_key() 以转换旧样式 cmp 函数到 key 函数。

   Changed in version 2.3: 支持 None as an equivalent to omitting cmp 被添加。

   2.4 版改变： 支持 key and reverse 被添加。

9. Starting with Python 2.3, the sort() method is guaranteed to be stable. A sort is stable if it guarantees not to change the relative order of elements that compare equal — this is helpful for sorting in multiple passes (for example, sort by department, then by salary grade).

10. CPython 实现细节： While a list is being sorted, the effect of attempting to mutate, or even inspect, the list is undefined. The C implementation of Python 2.3 and newer makes the list appear empty for the duration, and raises ValueError if it can detect that the list has been mutated during a sort.

11. 值 n is an integer, or an object implementing __index__() . Zero and negative values of n clear the sequence. Items in the sequence are not copied; they are referenced multiple times, as explained for s * n under Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange .

5.7. 集类型 — set , frozenset ¶

A set 对象是无序集合的截然不同 hashable objects. Common uses include membership testing, removing duplicates from a sequence, and computing mathematical operations such as intersection, union, difference, and symmetric difference. (For other containers see the built in dict , list ，和 tuple 类，和 collections 模块。)

2.4 版新增。

Like other collections, sets support x in set , len(set) ，和 for x in set . Being an unordered collection, sets do not record element position or order of insertion. Accordingly, sets do not support indexing, slicing, or other sequence-like behavior.

There are currently two built-in set types, set and frozenset 。 set type is mutable — the contents can be changed using methods like add() and remove() . Since it is mutable, it has no hash value and cannot be used as either a dictionary key or as an element of another set. The frozenset type is immutable and hashable — its contents cannot be altered after it is created; it can therefore be used as a dictionary key or as an element of another set.

As of Python 2.7, non-empty sets (not frozensets) can be created by placing a comma-separated list of elements within braces, for example: {'jack', 'sjoerd'} , in addition to the set 构造函数。

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

class set ( [ iterable ] ) ¶

class frozenset ( [ iterable ] ) ¶

返回新 set 或 frozenset 对象的元素取自 iterable 。集元素必须 hashable 。要表示集的集，内部集必须是 frozenset 对象。若 iterable 未指定，返回新的空集。

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

len(s)

返回元素的数量对于集 s (基数对于 s ).

x in s

测试 x 为成员资格在 s .

x not in s

测试 x 为非成员资格在 s .

isdisjoint ( other ) ¶

返回 True 若集没有元素相同于 other 。集不相交当且仅当它们的交集为空集时。

2.6 版新增。

issubset ( other ) ¶

set <= other

测试集中的每一元素是否都在 other .

set < other

Test whether the set is a proper subset of other ，也就是说， set <= other and set != other .

issuperset ( other ) ¶

set >= other

Test whether every element in other is in the set.

set > other

Test whether the set is a proper superset of other ，也就是说， set >= other and set != other .

union ( *others ) ¶

set | other | ...

返回带有集和所有其它 others 的元素的新集。

2.6 版改变： Accepts multiple input iterables.

intersection ( *others ) ¶

set & other & ...

返回带有集和所有 others 的共有元素的新集。

2.6 版改变： Accepts multiple input iterables.

difference ( *others ) ¶

set - other - ...

返回新集，且集元素中不在 others 中。

2.6 版改变： Accepts multiple input iterables.

symmetric_difference ( other ) ¶

set ^ other

Return a new set with elements in either the set or other but not both.

copy ( ) ¶

返回集的浅拷贝。

注意，非运算符版本的 union() , intersection() , difference() ，和 symmetric_difference() , issubset() ，和 issuperset() methods will accept any iterable as an argument. In contrast, their operator based counterparts require their arguments to be sets. This precludes error-prone constructions like set('abc') & 'cbs' in favor of the more readable set('abc').intersection('cbs') .

Both set and frozenset support set to set comparisons. Two sets are equal if and only if every element of each set is contained in the other (each is a subset of the other). A set is less than another set if and only if the first set is a proper subset of the second set (is a subset, but is not equal). A set is greater than another set if and only if the first set is a proper superset of the second set (is a superset, but is not equal).

实例化的 set are compared to instances of frozenset based on their members. For example, set('abc') == frozenset('abc') 返回 True and so does set('abc') in set([frozenset('abc')]) .

The subset and equality comparisons do not generalize to a total ordering function. For example, any two non-empty disjoint sets are not equal and are not subsets of each other, so all of the following return False : a<b , a==b ，或 a>b . Accordingly, sets do not implement the __cmp__() 方法。

Since sets only define partial ordering (subset relationships), the output of the list.sort() method is undefined for lists of sets.

像字典键的集元素必须 hashable .

二进制操作混合 set 实例与 frozenset return the type of the first operand. For example: frozenset('ab') | set('bc') 返回实例化的 frozenset .

The following table lists operations available for set that do not apply to immutable instances of frozenset :

update ( *others ) ¶

set |= other | ...

更新集，添加来自所有 others 的元素。

2.6 版改变： Accepts multiple input iterables.

intersection_update ( *others ) ¶

set &= other & ...

更新集，仅保持在它和所有 others 中找到的元素。

2.6 版改变： Accepts multiple input iterables.

difference_update ( *others ) ¶

set -= other | ...

更新集，移除在 others 中找到的元素。

2.6 版改变： Accepts multiple input iterables.

symmetric_difference_update ( other ) ¶

set ^= other

更新集，只保持在集中找到的元素，而不是两者中的元素。

add ( elem ) ¶

添加元素 elem 到集。

remove ( elem ) ¶

移除元素 elem 从集。引发 KeyError if elem 未包含在集中。

discard ( elem ) ¶

移除元素 elem 从集，若存在。

pop ( ) ¶

移除并返回任意集元素。引发 KeyError 若集为空。

clear ( ) ¶

移除所有集元素。

注意，非运算符版本的 update() , intersection_update() , difference_update() ，和 symmetric_difference_update() 方法将接受任何可迭代作为自变量。

注意： elem 自变量到 __contains__() , remove() ，和 discard() 方法可能有设置。为支持搜索等效冻结集，临时创建一个从 elem .

另请参阅

Comparison to the built-in set types

Differences between the sets module and the built-in set types.

5.8. 映射类型 — dict ¶

A 映射 对象映射 hashable 值到任意对象。映射是可变对象。目前只有一种标准映射类型， dictionary . (For other containers see the built in list , set ，和 tuple 类，和 collections 模块。)

字典键是 almost 任意值。值不 hashable ，也就是说，包含列表、字典或其它可变类型 (通过值而不是对象标识进行比较) 的值不可以用作键。用作键的数值类型服从正常数值比较规则：若 2 数值比较相等 (譬如 1 and 1.0 ) 那么可以互换使用它们来索引相同字典条目 (不管怎样，注意，由于计算机按近似存储浮点数，因此将它们用作字典键通常是不明智的)。

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

class dict ( **kwarg ) ¶

class dict ( 映射 , **kwarg )

class dict ( iterable , **kwarg )

返回初始化自可选位置自变量和一组可能为空的关键词自变量的新字典。

若位置自变量未给定，创建空字典。若位置自变量有给定且是映射对象，创建字典具有如映射对象的相同键值对。否则，位置自变量必须是 iterable 对象。iterable (可迭代) 中的各项本身必须是恰好具有 2 对象的可迭代。各项的第 1 对象变为新字典键，而第 2 对象变为相应值。若键有出现多次，该键的最后值变为新字典相应值。

若关键词自变量有给定，关键词自变量及其值会被添加到从位置自变量创建的字典。若要添加的 key (键) 已存在，来自关键词自变量的 value (值) 会替换来自位置自变量的值。

为阐明，下列范例返回的字典都等于 {"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
									

如第 1 范例提供的关键词自变量，仅工作于有效 Python 标识符键。否则，可以使用任何有效 key (键)。

2.2 版新增。

Changed in version 2.3: Support for building a dictionary from keyword arguments added.

这些是字典支持的操作 (因此，自定义映射类型也应该支持)：

len(d)

返回项数对于字典 d .

d[key]

返回项在 d 采用键 key 。引发 KeyError if key 不在映射中。

若字典的子类有定义方法 __missing__() and key 不存在， d[key] 操作将调用该方法采用键 key 作为自变量。 d[key] 操作然后返回或引发返回任何或被引发通过 __missing__(key) 调用。其它操作或方法不会援引 __missing__() 。若 __missing__() 未定义， KeyError 被引发。 __missing__() 必须是方法；它不能是实例变量：

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1
											

以上范例展示部分实现为 collections.Counter 。不同 __missing__ 方法被用于 collections.defaultdict .

New in version 2.5: Recognition of __missing__ methods of dict subclasses.

d[key] = value

Set d[key] to value .

del d[key]

移除 d[key] from d 。引发 KeyError if key 不在映射中。

key in d

返回 True if d 拥有键 key ，否则 False .

2.2 版新增。

key not in d

相当于 not key in d .

2.2 版新增。

iter(d)

返回覆盖字典键的迭代器。这是快捷方式为 iterkeys() .

clear ( ) ¶

移除所有项从字典。

copy ( ) ¶

返回字典的浅拷贝。

fromkeys ( seq [ , 值 ] ) ¶

创建新字典采用键来自 seq 并把值设为 value .

fromkeys() 是返回新字典的类方法。 value 默认为 None .

2.3 版新增。

get ( key [ , default ] ) ¶

返回值为 key if key 在字典中，否则 default 。若 default 不给定，默认为 None ，因此此方法从不引发 KeyError .

has_key ( key ) ¶

Test for the presence of key in the dictionary. has_key() is deprecated in favor of key in d .

项 ( ) ¶

Return a copy of the dictionary’s list of (key, value) pairs.

CPython 实现细节： Keys and values are listed in an arbitrary order which is non-random, varies across Python implementations, and depends on the dictionary’s history of insertions and deletions.

若 items() , keys() , values() , iteritems() , iterkeys() ，和 itervalues() are called with no intervening modifications to the dictionary, the lists will directly correspond. This allows the creation of (value, key) pairs using zip() : pairs = zip(d.values(), d.keys()) . The same relationship holds for the iterkeys() and itervalues() 方法： pairs = zip(d.itervalues(), d.iterkeys()) provides the same value for pairs . Another way to create the same list is pairs = [(v, k) for (k, v) in d.iteritems()] .

iteritems ( ) ¶

Return an iterator over the dictionary’s (key, value) pairs. See the note for dict.items() .

使用 iteritems() while adding or deleting entries in the dictionary may raise a RuntimeError or fail to iterate over all entries.

2.2 版新增。

iterkeys ( ) ¶

Return an iterator over the dictionary’s keys. See the note for dict.items() .

使用 iterkeys() while adding or deleting entries in the dictionary may raise a RuntimeError or fail to iterate over all entries.

2.2 版新增。

itervalues ( ) ¶

Return an iterator over the dictionary’s values. See the note for dict.items() .

使用 itervalues() while adding or deleting entries in the dictionary may raise a RuntimeError or fail to iterate over all entries.

2.2 版新增。

keys ( ) ¶

Return a copy of the dictionary’s list of keys. See the note for dict.items() .

pop ( key [ , default ] ) ¶

若 key 在字典中，移除它并返回其值，否则返回 default 。若 default 未给定且 key 不在字典中， KeyError 被引发。

2.3 版新增。

popitem ( ) ¶

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

popitem() 对破坏性迭代字典很有用，这常用于集合算法。若字典为空，调用 popitem() 引发 KeyError .

setdefault ( key [ , default ] ) ¶

若 key 在字典中，返回其值。若不在，插入 key 采用值 default 并返回 default . default 默认为 None .

update ( [ other ] ) ¶

更新字典采用键/值对来自 other ，覆写现有键。返回 None .

update() 接受另一字典对象或键/值对可迭代 (作为 2 长元组或其它可迭代)。若指定关键词自变量，则采用这些键/值对更新字典： d.update(red=1, blue=2) .

2.4 版改变： Allowed the argument to be an iterable of key/value pairs and allowed keyword arguments.

值 ( ) ¶

Return a copy of the dictionary’s list of values. See the note for dict.items() .

viewitems ( ) ¶

返回新视图为字典项 ( (key, value) pairs). See below for documentation of view objects.

2.7 版新增。

viewkeys ( ) ¶

Return a new view of the dictionary’s keys. See below for documentation of view objects.

2.7 版新增。

viewvalues ( ) ¶

Return a new view of the dictionary’s values. See below for documentation of view objects.

2.7 版新增。

字典比较相等，当且仅当它们拥有相同 (key, value) pairs.

5.8.1. 字典视图对象 ¶

对象返回通过 dict.viewkeys() , dict.viewvalues() and dict.viewitems() are 视图对象 . They provide a dynamic view on the dictionary’s entries, which means that when the dictionary changes, the view reflects these changes.

Dictionary views can be iterated over to yield their respective data, and support membership tests:

len(dictview)

返回字典条目数。

iter(dictview)

Return an iterator over the keys, values or items (represented as tuples of (key, value) ) 在字典中。

Keys and values are iterated over in an arbitrary order which is non-random, varies across Python implementations, and depends on the dictionary’s history of insertions and deletions. If keys, values and items views are iterated over with no intervening modifications to the dictionary, the order of items will directly correspond. This allows the creation of (value, key) pairs using zip() : pairs = zip(d.values(), d.keys()) . Another way to create the same list is pairs = [(v, k) for (k, v) in d.items()] .

Iterating views while adding or deleting entries in the dictionary may raise a RuntimeError or fail to iterate over all entries.

x in dictview

返回 True if x is in the underlying dictionary’s keys, values or items (in the latter case, x 应该为 (key, value) 元组)。

Keys views are set-like since their entries are unique and hashable. If all values are hashable, so that (key, value) pairs are unique and hashable, then the items view is also set-like. (Values views are not treated as set-like since the entries are generally not unique.) Then these set operations are available (“other” refers either to another view or a set):

dictview & other

Return the intersection of the dictview and the other object as a new set.

dictview | other

Return the union of the dictview and the other object as a new set.

dictview - other

Return the difference between the dictview and the other object (all elements in dictview that aren’t in other ) as a new set.

dictview ^ other

Return the symmetric difference (all elements either in dictview or other , but not in both) of the dictview and the other object as a new set.

字典视图的用法范例：

>>> 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. 文件对象 ¶

File objects are implemented using C’s stdio package and can be created with the built-in open() function. File objects are also returned by some other built-in functions and methods, such as os.popen() and os.fdopen() 和 makefile() method of socket objects. Temporary files can be created using the tempfile module, and high-level file operations such as copying, moving, and deleting files and directories can be achieved with the shutil 模块。

When a file operation fails for an I/O-related reason, the exception IOError is raised. This includes situations where the operation is not defined for some reason, like seek() on a tty device or writing a file opened for reading.

Files have the following methods:

文件。 close ( ) ¶

Close the file. A closed file cannot be read or written any more. Any operation which requires that the file be open will raise a ValueError after the file has been closed. Calling close() more than once is allowed.

As of Python 2.5, you can avoid having to call this method explicitly if you use the with statement. For example, the following code will automatically close f 当 with block is exited:

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,
									

In older versions of Python, you would have needed to do this to get the same effect:

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

注意

Not all “file-like” types in Python support use as a context manager for the with statement. If your code is intended to work with any file-like object, you can use the function contextlib.closing() instead of using the object directly.

文件。 flush ( ) ¶

Flush the internal buffer, like stdio ’s fflush() . This may be a no-op on some file-like objects.

注意

flush() does not necessarily write the file’s data to disk. Use flush() followed by os.fsync() to ensure this behavior.

文件。 fileno ( ) ¶

Return the integer “file descriptor” that is used by the underlying implementation to request I/O operations from the operating system. This can be useful for other, lower level interfaces that use file descriptors, such as the fcntl 模块或 os.read() and friends.

注意

File-like objects which do not have a real file descriptor should not provide this method!

文件。 isatty ( ) ¶

返回 True if the file is connected to a tty(-like) device, else False .

注意

If a file-like object is not associated with a real file, this method should not be implemented.

文件。 next ( ) ¶

A file object is its own iterator, for example iter(f) 返回 f (unless f is closed). When a file is used as an iterator, typically in a for loop (for example, for line in f: print line.strip() )， next() method is called repeatedly. This method returns the next input line, or raises StopIteration when EOF is hit when the file is open for reading (behavior is undefined when the file is open for writing). In order to make a for loop the most efficient way of looping over the lines of a file (a very common operation), the next() method uses a hidden read-ahead buffer. As a consequence of using a read-ahead buffer, combining next() with other file methods (like readline() ) does not work right. However, using seek() to reposition the file to an absolute position will flush the read-ahead buffer.

2.3 版新增。

文件。 read ( [ size ] ) ¶

读取最多 size bytes from the file (less if the read hits EOF before obtaining size bytes). If the size argument is negative or omitted, read all data until EOF is reached. The bytes are returned as a string object. An empty string is returned when EOF is encountered immediately. (For certain files, like ttys, it makes sense to continue reading after an EOF is hit.) Note that this method may call the underlying C function fread() more than once in an effort to acquire as close to size bytes as possible. Also note that when in non-blocking mode, less data than was requested may be returned, even if no size parameter was given.

注意

This function is simply a wrapper for the underlying fread() C function, and will behave the same in corner cases, such as whether the EOF value is cached.

文件。 readline ( [ size ] ) ¶

Read one entire line from the file. A trailing newline character is kept in the string (but may be absent when a file ends with an incomplete line). 6 若 size argument is present and non-negative, it is a maximum byte count (including the trailing newline) and an incomplete line may be returned. When size is not 0, an empty string is returned only when EOF is encountered immediately.

注意

不像 stdio ’s fgets() , the returned string contains null characters ( '\0' ) if they occurred in the input.

文件。 readlines ( [ sizehint ] ) ¶

Read until EOF using readline() and return a list containing the lines thus read. If the optional sizehint argument is present, instead of reading up to EOF, whole lines totalling approximately sizehint bytes (possibly after rounding up to an internal buffer size) are read. Objects implementing a file-like interface may choose to ignore sizehint if it cannot be implemented, or cannot be implemented efficiently.

文件。 xreadlines ( ) ¶

This method returns the same thing as iter(f) .

2.1 版新增。

从 2.3 版起弃用： 使用 for line in file 代替。

文件。 seek ( offset [ , whence ] ) ¶

Set the file’s current position, like stdio ’s fseek() 。 whence 自变量可选且默认为 os.SEEK_SET or 0 (绝对文件位置)；其它值 os.SEEK_CUR or 1 (寻址相对于当前位置) 和 os.SEEK_END or 2 (seek relative to the file’s end). There is no return value.

例如， f.seek(2, os.SEEK_CUR) advances the position by two and f.seek(-3, os.SEEK_END) sets the position to the third to last.

Note that if the file is opened for appending (mode 'a' or 'a+' ), any seek() operations will be undone at the next write. If the file is only opened for writing in append mode (mode 'a' ), this method is essentially a no-op, but it remains useful for files opened in append mode with reading enabled (mode 'a+' ). If the file is opened in text mode (without 'b' ), only offsets returned by tell() are legal. Use of other offsets causes undefined behavior.

Note that not all file objects are seekable.

2.6 版改变： Passing float values as offset has been deprecated.

文件。 tell ( ) ¶

Return the file’s current position, like stdio ’s ftell() .

注意

在 Windows， tell() can return illegal values (after an fgets() ) when reading files with Unix-style line-endings. Use binary mode ( 'rb' ) to circumvent this problem.

文件。 truncate ( [ size ] ) ¶

Truncate the file’s size. If the optional size argument is present, the file is truncated to (at most) that size. The size defaults to the current position. The current file position is not changed. Note that if a specified size exceeds the file’s current size, the result is platform-dependent: possibilities include that the file may remain unchanged, increase to the specified size as if zero-filled, or increase to the specified size with undefined new content. Availability: Windows, many Unix variants.

文件。 write ( str ) ¶

Write a string to the file. There is no return value. Due to buffering, the string may not actually show up in the file until the flush() or close() 方法被调用。

文件。 writelines ( sequence ) ¶

Write a sequence of strings to the file. The sequence can be any iterable object producing strings, typically a list of strings. There is no return value. (The name is intended to match readlines() ; writelines() does not add line separators.)

Files support the iterator protocol. Each iteration returns the same result as readline() , and iteration ends when the readline() method returns an empty string.

File objects also offer a number of other interesting attributes. These are not required for file-like objects, but should be implemented if they make sense for the particular object.

文件。 closed ¶

bool indicating the current state of the file object. This is a read-only attribute; the close() method changes the value. It may not be available on all file-like objects.

文件。 encoding ¶

The encoding that this file uses. When Unicode strings are written to a file, they will be converted to byte strings using this encoding. In addition, when the file is connected to a terminal, the attribute gives the encoding that the terminal is likely to use (that information might be incorrect if the user has misconfigured the terminal). The attribute is read-only and may not be present on all file-like objects. It may also be None , in which case the file uses the system default encoding for converting Unicode strings.

2.3 版新增。

文件。 errors ¶

The Unicode error handler used along with the encoding.

2.6 版新增。

文件。 mode ¶

The I/O mode for the file. If the file was created using the open() built-in function, this will be the value of the mode parameter. This is a read-only attribute and may not be present on all file-like objects.

文件。 名称 ¶

If the file object was created using open() , the name of the file. Otherwise, some string that indicates the source of the file object, of the form <...> . This is a read-only attribute and may not be present on all file-like objects.

文件。 newlines ¶

If Python was built with 通用换行符 enabled (the default) this read-only attribute exists, and for files opened in universal newline read mode it keeps track of the types of newlines encountered while reading the file. The values it can take are '\r' , '\n' , '\r\n' , None (unknown, no newlines read yet) or a tuple containing all the newline types seen, to indicate that multiple newline conventions were encountered. For files not opened in universal newlines read mode the value of this attribute will be None .

文件。 softspace ¶

Boolean that indicates whether a space character needs to be printed before another value when using the print statement. Classes that are trying to simulate a file object should also have a writable softspace attribute, which should be initialized to zero. This will be automatic for most classes implemented in Python (care may be needed for objects that override attribute access); types implemented in C will have to provide a writable softspace 属性。

注意

This attribute is not used to control the print statement, but to allow the implementation of print to keep track of its internal state.

5.10. memoryview 类型 ¶

2.7 版新增。

memoryview objects allow Python code to access the internal data of an object that supports the buffer protocol without copying. Memory is generally interpreted as simple bytes.

class memoryview ( obj ) ¶

创建 memoryview that references obj . obj must support the buffer protocol. Built-in objects that support the buffer protocol include str and bytearray (but not unicode ).

A memoryview has the notion of an element , which is the atomic memory unit handled by the originating object obj . For many simple types such as str and bytearray , an element is a single byte, but other third-party types may expose larger elements.

len(view) returns the total number of elements in the memoryview, view 。 itemsize attribute will give you the number of bytes in a single element.

A memoryview supports slicing to expose its data. Taking a single index will return a single element as a str object. Full slicing will result in a subview:

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

If the object the memoryview is over supports changing its data, the memoryview supports slice assignment:

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

Notice how the size of the memoryview object cannot be changed.

memoryview has two methods:

tobytes ( ) ¶

Return the data in the buffer as a bytestring (an object of class str ).

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

tolist ( ) ¶

Return the data in the buffer as a list of integers.

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

还有几个可用只读属性：

format ¶

A string containing the format (in struct module style) for each element in the view. This defaults to 'B' , a simple bytestring.

itemsize ¶

The size in bytes of each element of the memoryview.

shape ¶

A tuple of integers the length of ndim giving the shape of the memory as an N-dimensional array.

ndim ¶

An integer indicating how many dimensions of a multi-dimensional array the memory represents.

strides ¶

A tuple of integers the length of ndim giving the size in bytes to access each element for each dimension of the array.

readonly ¶

A bool indicating whether the memory is read only.

5.11. 上下文管理器类型 ¶

2.5 版新增。

Python 的 with statement supports the concept of a runtime context defined by a context manager. This is implemented using two separate methods that allow user-defined classes to define a runtime context that is entered before the statement body is executed and exited when the statement ends.

The 上下文管理协议 consists of a pair of methods that need to be provided for a context manager object to define a runtime context:

contextmanager. __enter__ ( ) ¶

Enter the runtime context and return either this object or another object related to the runtime context. The value returned by this method is bound to the identifier in the as clause of with statements using this context manager.

An example of a context manager that returns itself is a file object. File objects return themselves from __enter__() to allow open() to be used as the context expression in a with 语句。

An example of a context manager that returns a related object is the one returned by decimal.localcontext() . These managers set the active decimal context to a copy of the original decimal context and then return the copy. This allows changes to be made to the current decimal context in the body of the with statement without affecting code outside the with 语句。

contextmanager. __exit__ ( exc_type , exc_val , exc_tb ) ¶

Exit the runtime context and return a Boolean flag indicating if any exception that occurred should be suppressed. If an exception occurred while executing the body of the with statement, the arguments contain the exception type, value and traceback information. Otherwise, all three arguments are None .

Returning a true value from this method will cause the with statement to suppress the exception and continue execution with the statement immediately following the with statement. Otherwise the exception continues propagating after this method has finished executing. Exceptions that occur during execution of this method will replace any exception that occurred in the body of the with 语句。

The exception passed in should never be reraised explicitly - instead, this method should return a false value to indicate that the method completed successfully and does not want to suppress the raised exception. This allows context management code (such as contextlib.nested ) to easily detect whether or not an __exit__() method has actually failed.

Python defines several context managers to support easy thread synchronisation, prompt closure of files or other objects, and simpler manipulation of the active decimal arithmetic context. The specific types are not treated specially beyond their implementation of the context management protocol. See the contextlib module for some examples.

Python 的 generator s and the contextlib.contextmanager 装饰器 provide a convenient way to implement these protocols. If a generator function is decorated with the contextlib.contextmanager decorator, it will return a context manager implementing the necessary __enter__() and __exit__() methods, rather than the iterator produced by an undecorated generator function.

Note that there is no specific slot for any of these methods in the type structure for Python objects in the Python/C API. Extension types wanting to define these methods must provide them as a normal Python accessible method. Compared to the overhead of setting up the runtime context, the overhead of a single class dictionary lookup is negligible.

5.12. 其它内置类型 ¶

解释器支持几种其它种类的对象。这些中的大多数只支持 1 种或 2 种操作。

5.12.1. 模块 ¶

模块的唯一特殊操作是属性访问： m.name ，其中 m 是模块和 name 访问定义名称在 m 的符号表。可以赋值模块属性 (注意， import 语句严格来说，并未运转于模块对象； import foo 不要求命名模块对象 foo 的存在，相反，它要求 (外部) definition 对于命名模块 foo 在其它地方)。

每个模块的特殊属性是 __dict__ 。这是包含模块符号表的字典。修改此字典实际上会改变模块的符号表，但直接赋值 __dict__ 属性是不可能的 (可以编写 m.__dict__['a'] = 1 ，其定义 m.a 到 1 ，但无法编写 m.__dict__ = {} )。修改 __dict__ 直接不推荐。

将模块内置进解释器的编写像这样： <module 'sys' (built-in)> 。若从文件加载，它们被写成 <module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'> .

5.12.2. 类和类实例 ¶

见 对象、值及类型 and 类定义 对于这些。

5.12.3. 函数 ¶

Function objects are created by function definitions. The only operation on a function object is to call it: func(argument-list) .

There are really two flavors of function objects: built-in functions and user-defined functions. Both support the same operation (to call the function), but the implementation is different, hence the different object types.

见 函数定义 了解更多信息。

5.12.4. 方法 ¶

Methods are functions that are called using the attribute notation. There are two flavors: built-in methods (such as append() on lists) and class instance methods. Built-in methods are described with the types that support them.

The implementation adds two special read-only attributes to class instance methods: m.im_self is the object on which the method operates, and m.im_func is the function implementing the method. Calling m(arg-1, arg-2, ..., arg-n) is completely equivalent to calling m.im_func(m.im_self, arg-1, arg-2, ..., arg-n) .

Class instance methods are either bound or unbound , referring to whether the method was accessed through an instance or a class, respectively. When a method is unbound, its im_self 属性将是 None and if called, an explicit self object must be passed as the first argument. In this case, self must be an instance of the unbound method’s class (or a subclass of that class), otherwise a TypeError 被引发。

Like function objects, methods objects support getting arbitrary attributes. However, since method attributes are actually stored on the underlying function object ( meth.im_func ), setting method attributes on either bound or unbound methods is disallowed. Attempting to set an attribute on a method results in an AttributeError being raised. In order to set a method attribute, you need to explicitly set it on the underlying function object:

>>> 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.12.5. 代码对象 ¶

代码对象用于实现以表示 "伪编译" 可执行 Python 代码，譬如：函数本体。它们异于函数对象，因为它们不包含对其全局执行环境的引用。代码对象的返回是通过内置 compile() 函数且可以提取自函数对象透过它们的 func_code 属性。另请参阅 code 模块。

代码对象可以被执行或评估通过将它 (而不是源字符串) 传递给 exec statement or the built-in eval() 函数。

见 标准类型层次结构 了解更多信息。

5.12.6. 类型对象 ¶

Type objects represent the various object types. An object’s type is accessed by the built-in function type() . There are no special operations on types. The standard module types defines names for all standard built-in types.

类型写成像这样： <type 'int'> .

5.12.7. Null 对象 ¶

This object is returned by functions that don’t explicitly return a value. It supports no special operations. There is exactly one null object, named None (a built-in name).

它被写为 None .

5.12.8. 省略对象 ¶

This object is used by extended slice notation (see 切片 ). It supports no special operations. There is exactly one ellipsis object, named Ellipsis (a built-in name).

它被写为 Ellipsis . When in a subscript, it can also be written as ... ，例如 seq[...] .

5.12.9. 未实现对象 ¶

This object is returned from comparisons and binary operations when they are asked to operate on types they don’t support. See 比较 了解更多信息。

它被写为 NotImplemented .

5.12.10. 布尔值 ¶

Boolean values are the two constant objects False and True . They are used to represent truth values (although other values can also be considered false or true). In numeric contexts (for example when used as the argument to an arithmetic operator), they behave like the integers 0 and 1, respectively. The built-in function bool() can be used to convert any value to a Boolean, if the value can be interpreted as a truth value (see section 真值测试 above).

它们被写成 False and True ，分别。

5.12.11. 内部对象 ¶

见 标准类型层次结构 了解此信息。它描述堆栈帧对象、回溯对象及切片对象。

5.13. 特殊属性 ¶

实现将一些相关特殊只读属性添加到对象类型。其中一些不报告通过 dir() 内置函数。

对象。 __dict__ ¶

用于存储对象 (可写) 属性的字典或其它映射对象。

对象。 __methods__ ¶

Deprecated since version 2.2: 使用内置函数 dir() to get a list of an object’s attributes. This attribute is no longer available.

对象。 __members__ ¶

Deprecated since version 2.2: 使用内置函数 dir() to get a list of an object’s attributes. This attribute is no longer available.

instance. __class__ ¶

类实例所属的类。

class. __bases__ ¶

类对象的基类元组。

定义。 __name__ ¶

The name of the class, type, function, method, descriptor, or generator instance.

The following attributes are only supported by 新样式类 es.

class. __mro__ ¶

This attribute is a tuple of classes that are considered when looking for base classes during method resolution.

class. mro ( ) ¶

This method can be overridden by a metaclass to customize the method resolution order for its instances. It is called at class instantiation, and its result is stored in __mro__ .

class. __subclasses__ ( ) ¶

Each new-style class keeps a list of weak references to its immediate subclasses. This method returns a list of all those references still alive. Example:

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

脚注

1

Additional information on these special methods may be found in the Python Reference Manual ( 基本定制 ).

2

因此，列表 [1, 2] 被认为等于 [1.0, 2.0] ，且类似元组。

3

They must have since the parser can’t tell the type of the operands.

4 ( 1 , 2 , 3 , 4 )

Cased characters are those with general category property being one of “Lu” (Letter, uppercase), “Ll” (Letter, lowercase), or “Lt” (Letter, titlecase).

5

To format only a tuple you should therefore provide a singleton tuple whose only element is the tuple to be formatted.

6

The advantage of leaving the newline on is that returning an empty string is then an unambiguous EOF indication. It is also possible (in cases where it might matter, for example, if you want to make an exact copy of a file while scanning its lines) to tell whether the last line of a file ended in a newline or not (yes this happens!).