5. 内置类型 — Python 文档

来自菜鸟教程
Python/docs/2.7/library/stdtypes
跳转至：导航、​搜索

5. 内置类型

以下部分描述了内置于解释器中的标准类型。

笔记

从历史上看（直到 2.2 版），Python 的内置类型与用户定义的类型不同，因为不可能使用内置类型作为面向对象继承的基础。 此限制不再存在。


主要的内置类型是数字、序列、映射、文件、类、实例和异常。

某些操作由多种对象类型支持； 特别是，几乎所有对象都可以进行比较、测试真值并转换为字符串（使用 repr() 函数或略有不同的 str() 函数）。 当对象由 print() 函数写入时，后一个函数被隐式使用。

5.1. 真值测试

可以测试任何对象的真值，用于 if 或 while 条件或作为以下布尔运算的操作数。 以下值被认为是错误的：


  • None

  • False

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

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

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

  • 用户定义类的实例，如果类定义了 __nonzero__() 或 __len__() 方法，当该方法返回整数零或 bool 值 False 时。 1

所有其他值都被认为是真——所以许多类型的对象总是真。

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


5.2. 布尔运算—— 和 , 或者 , 不是

这些是布尔运算，按优先级升序排列：

操作 结果 笔记
x or y 如果 x 为假，则 y，否则为 x (1)
x and y 如果 x 为假，则为 x，否则为 y (2)
not x 如果 x 为假，则为 True，否则为 False (3)

注意事项：

  1. 这是一个短路运算符，因此它仅在第一个参数为假时才计算第二个参数。
  2. 这是一个短路运算符，因此它仅在第一个参数为真时才计算第二个参数。
  3. not 的优先级低于非布尔运算符，因此 not a == b 被解释为 not (a == b)，而 a == not b 是语法错误。


5.3. 比较

所有对象都支持比较操作。 它们都具有相同的优先级（高于布尔运算的优先级）。 比较可以任意链接； 例如，x < y <= z 等价于 x < y and y <= z，除了 y 只被评估一次（但在这两种情况下 z x < y被发现是假的）。

下表总结了比较操作：

操作 意义 笔记
< 严格小于
<= 小于或等于
> 严格大于
>= 大于或等于
== 平等
!= 不相等 (1)
is 对象身份
is not 否定对象身份

注意事项：

  1. != 也可以写成 <>，但这是一个过时的用法，只是为了向后兼容。 新代码应始终使用 !=。

不同类型的对象，除了不同的数值类型和不同的字符串类型，从不比较相等； 这些对象的排序是一致但任意的（因此对异构数组进行排序会产生一致的结果）。 此外，某些类型（例如，文件对象）仅支持退化的比较概念，其中该类型的任何两个对象都不相等。 同样，这些对象的排序是任意但一致的。 当任何操作数是复数时，<、<=、> 和 >= 运算符将引发 TypeError 异常。

除非类定义了 __eq__() 方法或 __cmp__() 方法，否则类的不相同实例通常比较为不相等。

类的实例不能相对于同一类的其他实例或其他类型的对象进行排序，除非该类定义了足够丰富的比较方法（__lt__()、__le__()、[ X209X] 和 __ge__()）或 __cmp__() 方法。

另外两个具有相同句法优先级的操作，in 和 not in，仅由序列类型支持（如下）。


5.4. 数字类型 — 整数 , 漂浮 , 长 , 复杂的

有四种不同的数字类型：普通整数、长整数、浮点数和复数。 此外，布尔值是普通整数的子类型。 普通整数（也称为 integers）在 C 中使用 long 实现，这使它们至少有 32 位精度（sys.maxint 始终设置为最大普通整数当前平台的值，最小值为 -sys.maxint - 1）。 长整数具有无限的精度。 浮点数在C中通常使用double来实现； sys.float_info 中提供了有关运行程序的机器的浮点数的精度和内部表示的信息。 复数有实部和虚部，每个都是浮点数。 要从复数 z 中提取这些部分，请使用 z.real 和 z.imag。 （标准库包括其他数字类型，fractions 保存有理数，以及 decimal 保存具有用户可定义精度的浮点数。）

数字由数字文字创建或作为内置函数和运算符的结果创建。 未修饰的整数文字（包括二进制、十六进制和八进制数）产生纯整数，除非它们表示的值太大而无法表示为纯整数，在这种情况下它们产生长整数。 带有 'L' 或 'l' 后缀的整数文本产生长整数（'L' 是首选，因为 1l 看起来太像 11 了！）。 包含小数点或指数符号的数字文字产生浮点数。 将 'j' 或 'J' 附加到数字字面量会产生一个虚数（实部为零的复数），您可以将其添加到整数或浮点数上以获得具有实部和虚部的复数部分。

Python 完全支持混合算术：当一个二元算术运算符具有不同数值类型的操作数时，具有“窄”类型的操作数被加宽到另一个类型的操作数，其中普通整数比长整数窄，比浮点窄，比浮点窄复杂的。 混合类型数字之间的比较使用相同的规则。 2 构造函数 int()、long()、float() 和 complex() 可以用于生成特定类型的数字。

所有内置数字类型都支持以下操作。 有关运算符的优先级，请参阅 权力运算符 和后面的部分。

操作 结果 笔记
x + y x 和 y 之和
x - y x 和 y 的区别
x * y x 和 y 的乘积
x / y x 和 y 的商 (1)
x // y x 和 y 的（落地）商 (4)(5)
x % y x / y 的余数 (4)
-x x 否定
+x x 不变
abs(x) x 的绝对值或大小 (3)
int(x) x 转换为整数 (2)
long(x) x 转换为长整数 (2)
float(x) x 转换为浮点数 (6)
complex(re,im) 一个复数，实部 re，虚部 im。 im 默认为零。
c.conjugate() 复数 c 的共轭。 （实数上的恒等式）
divmod(x, y) 对 (x // y, x % y) (3)(4)
pow(x, y) x 到 y 的幂 (3)(7)
x ** y x 到 y 的幂 (7)

注意事项：

  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. 也称为整数除法。 结果值是一个整数，尽管结果的类型不一定是 int。

  6. float 还接受带有可选前缀“+”或“-”的字符串“nan”和“inf”，用于表示非数字 (NaN) 和正无穷大或负无穷大。

    2.6 版中的新功能。

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

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

操作 结果
math.trunc(x) x 截断为 Integral
round(x[, n]) x 四舍五入为 n 位，四舍五入远离零。 如果省略 n，则默认为 0。
math.floor(x) 最大整数作为浮点数 <= X
math.ceil(x) 作为浮点数的最小整数 >= x

5.4.1. 整数类型的按位运算

按位运算只对整数有意义。 负数被视为它们的 2 的补码值（这假设有足够多的位在操作期间不会发生溢出）。

二元按位运算的优先级均低于数值运算，高于比较； 一元运算 ~ 与其他一元数值运算（+ 和 -）具有相同的优先级。

下表列出了按优先级升序排列的按位运算：

操作 结果 笔记
y x 和 y 的按位 或
x ^ y x 和 y 的按位 异或
x & y x 和 y 的按位 和
x << n x 左移 n 位 (1)(2)
x >> n x 右移 n 位 (1)(3)
~x x 的位反转

注意事项：

  1. 负移位计数是非法的，会导致 ValueError 升高。
  2. 左移 n 位相当于乘以 pow(2, n)。 如果结果超出普通整数的范围，则返回一个长整数。
  3. 右移 n 位相当于除以 pow(2, n)。


5.4.2. 整数类型的附加方法

整数类型实现了 numbers.Integral 抽象基类 。 此外，他们提供了另一种方法：

int.bit_length()
long.bit_length()

返回表示二进制整数所需的位数，不包括符号和前导零：

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

更准确地说，如果 x 非零，则 x.bit_length() 是唯一的正整数 k，使得 2**(k-1) <= abs(x) < 2**k。 等效地，当 abs(x) 足够小以具有正确舍入的对数时，则 k = 1 + int(log(abs(x), 2))。 如果 x 为零，则 x.bit_length() 返回 0。

相当于：

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

2.7 版中的新功能。


5.4.3. 浮动的附加方法

float 类型实现了 numbers.Real 抽象基类 。 float 还具有以下附加方法。

float.as_integer_ratio()

返回一对整数，其比率恰好等于原始浮点数且分母为正。 在无穷大上提高 OverflowError，在 NaN 上提高 ValueError。

2.6 版中的新功能。

float.is_integer()

如果浮点实例有限且具有整数值，则返回 True，否则返回 False：

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

2.6 版中的新功能。

有两种方法支持与十六进制字符串的转换。 由于 Python 的浮点数在内部存储为二进制数，因此将浮点数转换为 decimal 字符串通常会涉及一个小的舍入误差。 相比之下，十六进制字符串允许精确表示和指定浮点数。 这在调试和数值工作时很有用。

float.hex()

以十六进制字符串形式返回浮点数的表示形式。 对于有限浮点数，此表示将始终包括前导 0x 和尾随 p 和指数。

2.6 版中的新功能。

float.fromhex(s)

返回由十六进制字符串 s 表示的浮点数的类方法。 字符串 s 可能有前导和尾随空格。

2.6 版中的新功能。

注意 float.hex() 是一个实例方法，而 float.fromhex() 是一个类方法。

十六进制字符串采用以下形式： 

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

其中可选的 sign 可以是 + 或 -，integer 和 fraction 是十六进制数字字符串，[ X134X] 是带有可选前导符号的十进制整数。 大小写不重要，整数或分数中必须至少有一个十六进制数字。 此语法类似于 C99 标准第 6.4.4.2 节中指定的语法，也类似于 Java 1.5 中使用的语法。 特别是，float.hex() 的输出可用作 C 或 Java 代码中的十六进制浮点文字，以及由 C 的 %a 格式字符或 Java 的 Double.toHexString 被 float.fromhex() 接受。

请注意，指数以十进制而不是十六进制书写，并且它给出了乘以系数的 2 的幂。 例如，十六进制字符串 0x3.a7p10 表示浮点数 (3 + 10./16 + 7./16**2) * 2.0**10，或 3740.0： 

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

对 3740.0 应用反向转换会给出一个不同的十六进制字符串，表示相同的数字： 

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

5.5. 迭代器类型

2.2 版中的新功能。


Python 支持容器迭代的概念。 这是使用两种不同的方法实现的； 这些用于允许用户定义的类支持迭代。 下面更详细描述的序列始终支持迭代方法。

需要为容器对象定义一种方法来提供迭代支持：

container.__iter__()
返回一个迭代器对象。 该对象需要支持下面描述的迭代器协议。 如果容器支持不同类型的迭代，则可以提供额外的方法来专门为这些迭代类型请求迭代器。 （支持多种形式迭代的对象的一个例子是一个支持广度优先和深度优先遍历的树结构。）这个方法对应于 Python 对象的类型结构的 tp_iter 槽Python/C API。

迭代器对象本身需要支持以下两种方法，它们共同构成了迭代器协议：

iterator.__iter__()
返回迭代器对象本身。 这是允许容器和迭代器与 for 和 in 语句一起使用所必需的。 此方法对应于 Python/C API 中 Python 对象的类型结构的 tp_iter 槽。
iterator.next()
从容器中返回下一个项目。 如果没有其他项目，则引发 StopIteration 异常。 此方法对应于 Python/C API 中 Python 对象的类型结构的 tp_iternext 槽。

Python 定义了几个迭代器对象来支持对一般和特定序列类型、字典和其他更特殊形式的迭代。 除了迭代器协议的实现之外，特定类型并不重要。

该协议的意图是，一旦迭代器的 next() 方法引发 StopIteration，它将在后续调用中继续这样做。 不遵守此属性的实现被视为已损坏。 （此约束是在 Python 2.3 中添加的；在 Python 2.2 中，根据此规则破坏了各种迭代器。）

5.5.1. 发电机类型

Python 的 generators 提供了一种方便的方法来实现迭代器协议。 如果容器对象的 __iter__() 方法被实现为生成器，它将自动返回一个迭代器对象（技术上，一个生成器对象）提供 __iter__() 和 next()[ X202X] 方法。 有关生成器的更多信息，请参见 产量表达式 的文档。


5.6. 序列类型 — 字符串 , 统一码 ,list , 元组 , 字节数组 , 缓冲 , 范围

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

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

字符串文字用单引号或双引号表示：'xyzzy'、"frobozz"。 有关字符串文字的更多信息，请参阅 字符串文字 。 Unicode 字符串很像字符串，但在语法中使用前面的 'u' 字符指定：u'abc'、u"def"。 除了此处描述的功能外，String Methods 部分还描述了特定于字符串的方法。 列表用方括号构造，用逗号分隔项目：[a, b, c]。 元组由逗号运算符（不在方括号内）构造，带或不带括号，但空元组必须有括号，例如 a, b, c 或 ()。 单个项目元组必须有一个尾随逗号，例如 (d,)。

Bytearray 对象是使用内置函数 bytearray() 创建的。

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

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

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

此表列出了按优先级升序排列的序列操作。 表中s和t为同类型序列； n、i 和 j 是整数：

操作 结果 笔记
x in s True 如果 s 的一项等于 x，否则为 False (1)
x not in s False 如果 s 的一项等于 x，否则为 True (1)
s + t s 和 t 的串联 (6)
s * n, n * s 相当于将 s 添加到自身 n 次 (2)
s[i] i第s项，原点0 (3)
s[i:j] s 从 i 到 j 的切片 (3)(4)
s[i:j:k] s 从 i 到 j 的切片 k (3)(5)
len(s) s 的长度
min(s) s 的最小项
max(s) s 的最大项目
s.index(x) x 在 s 中第一次出现的索引
s.count(x) x 在 s 中出现的总次数

序列类型也支持比较。 特别是，元组和列表通过比较相应的元素按字典顺序进行比较。 这意味着要比较相等，每个元素必须比较相等，并且两个序列必须具有相同的类型和相同的长度。 （有关完整的详细信息，请参阅语言参考中的 Comparisons。）

注意事项：

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

  2. n 小于 0 的值被视为 0（产生与 s 相同类型的空序列）。 请注意，序列 s 中的项目不会被复制； 它们被多次引用。 这常常困扰着新的 Python 程序员； 考虑：

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

    发生的事情是 Python/docs/2.7/library 是一个包含空列表的单元素列表，因此 Python/docs/2.7/library * 3 的所有三个元素都是对这个空列表的引用。 修改 lists 的任何元素都会修改这个单个列表。 您可以通过以下方式创建不同列表的列表：

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

    FAQ条目如何创建多维列表？中提供了进一步的解释。

  3. 如果 i 或 j 为负，则索引相对于序列的末尾 s： 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到j的片段k定义为索引为x = i + n*k的项目序列使得 0 <= n < (j-i)/k。 换句话说，索引是i、i+k、i+2*k、i+3*k等等，当达到j时停止（但从不包括 j）。 当k为正时，i和j如果更大则减少为len(s)。 当k为负数时，i和j如果更大则减少为len(s) - 1。 如果省略 i 或 j 或 None，它们将成为“结束”值（结束取决于 k 的符号）。 注意，k 不能为零。 如果 k 是 None，则将其视为 1。

  6. 2.4 版更改： 以前，字符串连接从未就地发生。

5.6.1. 字符串方法

下面列出了 8 位字符串和 Unicode 对象都支持的字符串方法。 其中一些也可用于 bytearray 对象。

此外，Python 的字符串支持 序列类型 — str、unicode、列表、元组、字节数组、缓冲区、xrange 部分中描述的序列类型方法。 要输出格式化字符串，请使用模板字符串或 字符串格式化操作 部分中描述的 % 运算符。 另请参阅 re 模块以了解基于正则表达式的字符串函数。

str.capitalize()

返回字符串的副本，其中第一个字符大写，其余字符小写。

对于 8 位字符串，此方法取决于语言环境。

str.center(width[, fillchar])

以长度为 宽度 的字符串为中心返回。 填充是使用指定的 fillchar（默认为空格）完成的。

2.4 版更改： 支持 fillchar 参数。

str.count(sub[, start[, end]])
返回子串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 和 end 被解释为切片符号。
str.decode([encoding[, errors]])

使用为 encoding 注册的编解码器解码字符串。 encoding 默认为默认字符串编码。 可以给出 errors 来设置不同的错误处理方案。 默认值为 'strict'，意味着编码错误会引发 UnicodeError。 其他可能的值是 'ignore'、'replace' 和通过 codecs.register_error() 注册的任何其他名称，请参阅部分 Codec Base Classes。

2.2 版中的新功能。

2.3 版更改： 添加了对其他错误处理方案的支持。

2.7 版更改： 添加了对关键字参数的支持。

str.encode([encoding[, errors]])

返回字符串的编码版本。 默认编码是当前的默认字符串编码。 可以给出 errors 来设置不同的错误处理方案。 errors 的默认值为 'strict'，这意味着编码错误会引发 UnicodeError。 其他可能的值是 'ignore'、'replace'、'xmlcharrefreplace'、'backslashreplace' 和通过 codecs.register_error() 注册的任何其他名称，请参阅部分 编解码器基类 。 有关可能的编码列表，请参阅 标准编码 部分。

2.0 版中的新功能。

2.3 版更改： 支持 'xmlcharrefreplace' 和 'backslashreplace' 以及添加其他错误处理方案。

2.7 版更改： 添加了对关键字参数的支持。

str.endswith(suffix[, start[, end]])

如果字符串以指定的 后缀 结尾，则返回 True，否则返回 False。 suffix 也可以是要查找的后缀元组。 使用可选的 start，从该位置开始测试。 使用可选的 end，在该位置停止比较。

2.5 版更改： 接受元组为 后缀 。

str.expandtabs([tabsize])

返回字符串的副本，其中所有制表符都被一个或多个空格替换，具体取决于当前列和给定的制表符大小。 制表符位置每 tabsize 个字符出现一次（默认为 8，在第 0、8、16 列等处给出制表符位置）。 为了扩展字符串，当前列设置为零，并逐个字符地检查字符串。 如果字符是制表符 (\t)，则在结果中插入一个或多个空格字符，直到当前列等于下一个制表符位置。 （不复制制表符本身。）如果字符是换行符 (\n) 或回车符 (\r)，则复制它并将当前列重置为零。 任何其他字符都被原封不动地复制，并且无论打印时字符的表示方式如何，当前列都会增加 1。

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'
str.find(sub[, start[, end]])

返回字符串中的最低索引，其中在切片 s[start:end] 中找到子字符串 sub。 可选参数 start 和 end 被解释为切片符号。 如果未找到 sub，则返回 -1。

笔记

只有在需要知道 sub 的位置时，才应使用 find() 方法。 要检查 sub 是否是子字符串，请使用 in 运算符：

>>> 'Py' in 'Python'
True
str.format(*args, **kwargs)

执行字符串格式化操作。 调用此方法的字符串可以包含由大括号 {} 分隔的文字文本或替换字段。 每个替换字段包含位置参数的数字索引或关键字参数的名称。 返回字符串的副本，其中每个替换字段都替换为相应参数的字符串值。

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

有关可以在格式字符串中指定的各种格式选项的说明，请参阅 格式字符串语法 。

这种字符串格式化方法是 Python 3 中的新标准，应该优先于新代码中 字符串格式化操作 中描述的 % 格式化。

2.6 版中的新功能。

str.index(sub[, start[, end]])
类似于 find()，但在未找到子字符串时引发 ValueError。
str.isalnum()

如果字符串中的所有字符都是字母数字并且至少有一个字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法取决于语言环境。

str.isalpha()

如果字符串中的所有字符都是字母并且至少有一个字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法取决于语言环境。

str.isdigit()

如果字符串中的所有字符都是数字并且至少有一个字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法取决于语言环境。

str.islower()

如果字符串中的所有大小写字符 4 都是小写并且至少有一个大小写字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法取决于语言环境。

str.isspace()

如果字符串中只有空白字符且至少有一个字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法取决于语言环境。

str.istitle()

如果字符串是带标题的字符串并且至少有一个字符，则返回 true，例如，大写字符只能跟在非大小写字符之后，而小写字符只能跟在大小写字符之后。 否则返回 false。

对于 8 位字符串，此方法取决于语言环境。

str.isupper()

如果字符串中的所有大小写字符 4 都是大写并且至少有一个大小写字符，则返回 true，否则返回 false。

对于 8 位字符串，此方法取决于语言环境。

str.join(iterable)
返回一个字符串，它是 iterable 中字符串的串联。 如果 iterable 中有任何 Unicode 对象，则返回一个 Unicode 对象。 如果 iterable 中有任何非字符串或非 Unicode 对象值，则会引发 TypeError。 元素之间的分隔符是提供此方法的字符串。
str.ljust(width[, fillchar])

在长度为 宽度 的字符串中返回左对齐的字符串。 填充是使用指定的 fillchar（默认为空格）完成的。 如果 width 小于或等于 len(s)，则返回原始字符串。

2.4 版更改： 支持 fillchar 参数。

str.lower()

返回所有大小写字符 4 转换为小写的字符串副本。

对于 8 位字符串，此方法取决于语言环境。

str.lstrip([chars])

返回删除前导字符的字符串副本。 chars 参数是一个字符串，指定要删除的字符集。 如果省略或 None，chars 参数默认为删除空格。 chars 参数不是前缀； 相反，它的值的所有组合都被剥离了：

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

在 2.2.2 版更改： 支持 chars 参数。

str.partition(sep)

在第一次出现 sep 时拆分字符串，并返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身和分隔符之后的部分。 如果未找到分隔符，则返回一个包含字符串本身的 3 元组，后跟两个空字符串。

2.5 版中的新功能。

str.replace(old, new[, count])
返回所有出现的子字符串 old 替换为 new 的字符串副本。 如果给出了可选参数 count，则仅替换第一个 count 次出现。
str.rfind(sub[, start[, end]])
返回字符串中找到子字符串 sub 的最高索引，这样 sub 包含在 s[start:end] 中。 可选参数 start 和 end 被解释为切片符号。 失败时返回 -1。
str.rindex(sub[, start[, end]])
与 rfind() 类似，但在未找到子字符串 sub 时引发 ValueError。
str.rjust(width[, fillchar])

在长度为 宽度 的字符串中返回右对齐的字符串。 填充是使用指定的 fillchar（默认为空格）完成的。 如果 width 小于或等于 len(s)，则返回原始字符串。

2.4 版更改： 支持 fillchar 参数。

str.rpartition(sep)

在最后一次出现 sep 时拆分字符串，并返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身和分隔符之后的部分。 如果未找到分隔符，则返回一个包含两个空字符串的 3 元组，后跟字符串本身。

2.5 版中的新功能。

str.rsplit([sep[, maxsplit]])

返回字符串中单词的列表，使用 sep 作为分隔符字符串。 如果给出 maxsplit，则最多完成 maxsplit 次分割， 最右边的 次分割。 如果未指定 sep 或 None，则任何空白字符串都是分隔符。 除了从右侧拆分外，rsplit() 的行为类似于 split()，下面将对其进行详细描述。

2.4 版中的新功能。

str.rstrip([chars])

返回删除尾随字符的字符串副本。 chars 参数是一个字符串，指定要删除的字符集。 如果省略或 None，chars 参数默认为删除空格。 chars 参数不是后缀； 相反，它的值的所有组合都被剥离了：

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

在 2.2.2 版更改： 支持 chars 参数。

str.split([sep[, maxsplit]])

返回字符串中单词的列表，使用 sep 作为分隔符字符串。 如果给定 maxsplit，则最多完成 maxsplit 次拆分（因此，列表最多包含 maxsplit+1 元素）。 如果未指定 maxsplit 或 -1，则分割次数没有限制（进行所有可能的分割）。

如果给出 sep，则连续的分隔符不会组合在一起并被视为分隔空字符串（例如，'1,,2'.split(',') 返回 ['1', , '2']）。 sep 参数可以由多个字符组成（例如，'1<>2<>3'.split('<>') 返回 ['1', '2', '3']）。 用指定的分隔符拆分空字符串返回 []。

如果未指定 sep 或 None，则应用不同的拆分算法：将连续空白的运行视为单个分隔符，结果将不包含开头或如果字符串有前导或尾随空格，则结束。 因此，用 None 分隔符拆分空字符串或仅由空格组成的字符串将返回 []。

例如，' 1  2   3  '.split() 返回 ['1', '2', '3']，'  1  2   3  '.split(None, 1) 返回 ['1', '2   3  ']。

str.splitlines([keepends])

返回字符串中的行列表，在行边界处断开。 此方法使用 通用换行符 方法来拆分行。 除非给出 keepends 并且为真，否则结果列表中不包含换行符。

Python 将 "\r"、"\n" 和 "\r\n" 识别为 8 位字符串的行边界。

例如：

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

与给定分隔符字符串 sep 时的 split() 不同，此方法返回空字符串的空列表，并且终端换行不会导致额外的行：

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

为了比较，split('\n') 给出：

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']
unicode.splitlines([keepends])

返回字符串中的行列表，如 str.splitlines()。 但是，Unicode 方法在以下行边界上拆分，这些边界是为 8 位字符串识别的 通用换行符 的超集。

代表

说明

\n

换行

\r

回车

\r\n

回车 + 换行

\v 或 \x0b

线制表

\f 或 \x0c

换页

\x1c

文件分隔符

\x1d

组分隔符

\x1e

记录分隔符

\x85

下一行（C1 控制代码）

\u2028

行分隔符

\u2029

段落分隔符

在 2.7 版更改：\v 和 \f 添加到线边界列表。

str.startswith(prefix[, start[, end]])

如果字符串以 前缀 开头，则返回 True，否则返回 False。 prefix 也可以是要查找的前缀元组。 使用可选的 start，测试字符串从该位置开始。 使用可选的 end，停止在该位置比较字符串。

2.5 版更改： 接受元组为 前缀 。

str.strip([chars])

返回删除前导和尾随字符的字符串副本。 chars 参数是一个字符串，指定要删除的字符集。 如果省略或 None，chars 参数默认为删除空格。 chars 参数不是前缀或后缀； 相反，它的值的所有组合都被剥离了：

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

在 2.2.2 版更改： 支持 chars 参数。

str.swapcase()

返回字符串的副本，其中大写字符转换为小写，反之亦然。

对于 8 位字符串，此方法取决于语言环境。

str.title()

返回字符串的标题版本，其中单词以大写字符开头，其余字符为小写。

该算法使用一个简单的独立于语言的单词定义为连续字母组。 该定义在许多情况下都适用，但这意味着收缩和所有格中的撇号形成单词边界，这可能不是预期的结果：

>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

可以使用正则表达式构造撇号的解决方法：

>>> import re
>>> def titlecase(s):
...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0)[0].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

对于 8 位字符串，此方法取决于语言环境。

str.translate(table[, deletechars])

返回字符串的副本，其中删除了可选参数 deletechars 中出现的所有字符，其余字符已通过给定的转换表进行映射，该表必须是长度为 256 的字符串。

您可以使用 string 模块中的 maketrans() 辅助函数来创建转换表。 对于字符串对象，将 table 参数设置为 None 以进行仅删除字符的翻译：

>>> 'read this short text'.translate(None, 'aeiou')
'rd ths shrt txt'

2.6 版新功能： 支持 None table 参数。

对于 Unicode 对象，translate() 方法不接受可选的 deletechars 参数。 相反，它返回 s 的副本，其中所有字符都已通过给定的转换表映射，该表必须是 Unicode 序数到 Unicode 序数、Unicode 字符串或 None 的映射。 未映射的字符保持不变。 映射到 None 的字符被删除。 请注意，更灵活的方法是使用 codecs 模块创建自定义字符映射编解码器（请参阅 encodings.cp1251 示例）。

str.upper()

返回所有大小写字符 4 转换为大写的字符串副本。 注意 s.upper().isupper() 可能是 False 如果 s 包含未区分大小写的字符或者如果结果字符的 Unicode 类别不是“Lu”（字母，大写），但是例如 “Lt”（字母，标题）。

对于 8 位字符串，此方法取决于语言环境。

str.zfill(width)

在长度为 宽度 的字符串中返回用零填充的数字字符串。 正确处理符号前缀。 如果 width 小于或等于 len(s)，则返回原始字符串。

2.2.2 版中的新功能。

以下方法仅存在于 unicode 对象上：

unicode.isnumeric()
如果 S 中只有数字字符，则返回 True，否则返回 False。 数字字符包括数字字符，以及所有具有 Unicode 数值属性的字符，例如 U+2155，粗俗分数五分之一。
unicode.isdecimal()
如果 S 中只有十进制字符，则返回 True，否则返回 False。 十进制字符包括数字字符，以及所有可以用来构成十进制基数的字符，例如 U+0660，阿拉伯-印度数字零。


5.6.2. 字符串格式化操作

字符串和 Unicode 对象有一个独特的内置操作：% 运算符（模）。 这也称为字符串 formatting 或 interpolation 运算符。 给定 format % values（其中 format 是字符串或 Unicode 对象），format 中的 % 转换规范被替换为 的零个或多个元素]值。 效果类似于在C语言中使用sprintf()。 如果 format 是 Unicode 对象，或者使用 %s 转换的任何对象是 Unicode 对象，则结果也将是 Unicode 对象。

如果 format 需要单个参数，则 values 可能是单个非元组对象。 5 否则，values 必须是一个元组，它的项数正好是格式字符串指定的项数，或者是单个映射对象（例如，字典）。

转换说明符包含两个或更多字符，并具有以下组件，必须按此顺序出现：

  1. '%' 字符，标记说明符的开始。
  2. 映射键（可选），由带括号的字符序列组成（例如，(somename)）。
  3. 转换标志（可选），影响某些转换类型的结果。
  4. 最小字段宽度（可选）。 如果指定为 '*'（星号），则从 values 中元组的下一个元素读取实际宽度，并且要转换的对象在最小字段宽度和可选精度之后。
  5. 精度（可选），以 '.'（点）后跟精度的形式给出。 如果指定为 '*'（星号），则从 values 中元组的下一个元素读取实际宽度，并且要转换的值在精度之后。
  6. 长度修饰符（可选）。
  7. 转换类型。

当正确的参数是字典（或其他映射类型）时，字符串 中的格式必须 包括一个带括号的映射键，该键插入到该字典中，紧跟在 '%' 字符之后。 映射键从映射中选择要格式化的值。 例如： 

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

在这种情况下，格式中不能出现 * 说明符（因为它们需要顺序参数列表）。

转换标志字符为：

旗帜 意义
'#' 值转换将使用“替代形式”（定义如下）。
'0' 转换将为数值填充零。
'-' 转换后的值左调整（如果两者都给出，则覆盖 '0' 转换）。
' ' （一个空格）在有符号转换产生的正数（或空字符串）之前应该留一个空格。
'+' 符号字符（'+' 或 '-'）将在转换之前（覆盖“空格”标志）。

长度修饰符（h、l 或 L）可能存在，但被忽略，因为它不是 Python 所必需的——例如 %ld 与 %d 相同。

转换类型有：

转换 意义 笔记
'd' 有符号整数十进制。
'i' 有符号整数十进制。
'o' 有符号八进制值。 (1)
'u' 过时类型 – 与 'd' 相同。 (7)
'x' 有符号的十六进制（小写）。 (2)
'X' 有符号的十六进制（大写）。 (2)
'e' 浮点指数格式（小写）。 (3)
'E' 浮点指数格式（大写）。 (3)
'f' 浮点十进制格式。 (3)
'F' 浮点十进制格式。 (3)
'g' 浮点格式。 如果指数小于 -4 或不小于精度，则使用小写指数格式，否则使用十进制格式。 (4)
'G' 浮点格式。 如果指数小于 -4 或不小于精度，则使用大写指数格式，否则使用十进制格式。 (4)
'c' 单字符（接受整数或单字符串）。
'r' 字符串（使用 repr() 转换任何 Python 对象）。 (5)
's' 字符串（使用 str() 转换任何 Python 对象）。 (6)
'%' 不转换任何参数，结果中会出现 '%' 字符。

注意事项：

  1. 如果结果的前导字符不是零，则替代形式会导致在左侧填充和数字格式之间插入前导零 ('0')。

  2. 替代形式导致在第一个数字之前插入前导 '0x' 或 '0X'（取决于是否使用 'x' 或 'X' 格式）。

  3. 替代形式导致结果始终包含小数点，即使后面没有数字也是如此。

    精度决定小数点后的位数，默认为 6。

  4. 替代形式导致结果始终包含小数点，并且不会像其他情况那样删除尾随零。

    精度决定小数点前后的有效位数，默认为 6。

  5. %r 转换是在 Python 2.0 中添加的。

    精度决定了使用的最大字符数。

  6. 如果提供的对象或格式是 unicode 字符串，则结果字符串也将是 unicode。

    精度决定了使用的最大字符数。

  7. 见 PEP 237。

由于 Python 字符串具有明确的长度，因此 %s 转换不假定 '\0' 是字符串的结尾。

在 2.7 版更改：绝对值超过 1e50 的数字的 %f 转换不再被 %g 转换替换。


额外的字符串操作在标准模块 string 和 re 中定义。


5.6.3. XRange 类型

xrange 类型是一个不可变的序列，通常用于循环。 xrange 类型的优点是 xrange 对象将始终占用相同数量的内存，无论它代表的范围的大小。 没有一致的性能优势。

XRange 对象的行为很少：它们只支持索引、迭代和 len() 函数。


5.6.4. 可变序列类型

List 和 bytearray 对象支持允许就地修改对象的附加操作。 其他可变序列类型（当添加到语言中时）也应该支持这些操作。 字符串和元组是不可变的序列类型：此类对象一旦创建就无法修改。 以下操作是在可变序列类型上定义的（其中 x 是一个任意对象）：

操作 结果 笔记
s[i] = x s的i替换为x
s[i:j] = t s 从 i 到 j 的切片被可迭代 t 的内容替换
del s[i:j] 与 s[i:j] = [] 相同
s[i:j:k] = t s[i:j:k] 的元素替换为 t 的元素 (1)
del s[i:j:k] 从列表中删除 s[i:j:k] 的元素
s.append(x) 与 s[len(s):len(s)] = [x] 相同 (2)
s.extend(t) 或 s += t 大部分与 s[len(s):len(s)] = t 相同 (3)
s *= n 更新 s 其内容重复 n 次 (11)
s.count(x) 返回 i 的数量，其中 s[i] == x
s.index(x[, i[, j]]) 返回最小的 k 使得 s[k] == x 和 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() 将 s 的项目原地反转 (7)
s.sort([cmp[, key[, reverse]]]) 将 s 的项目就地排序 (7)(8)(9)(10)

注意事项：

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

  2. Python 的 C 实现历来接受多个参数并将它们隐式地连接成一个元组； 这不再适用于 Python 2.0。 自 Python 1.4 起，不推荐使用此错误功能。

  3. t 可以是任何可迭代对象。

  4. 当在 s 中找不到 x 时，提高 ValueError。 当负索引作为第二个或第三个参数传递给 index() 方法时，添加列表长度，就像切片索引一样。 如果它仍然是负数，则将其截断为零，就像切片索引一样。

    2.3 版更改： 以前，index() 没有用于指定开始和停止位置的参数。

  5. 当负索引作为第一个参数传递给 insert() 方法时，添加列表长度，就像切片索引一样。 如果它仍然是负数，则将其截断为零，就像切片索引一样。

    2.3 版更改： 以前，所有负索引都被截断为零。

  6. pop() 方法的可选参数 i 默认为 -1，因此默认情况下删除并返回最后一项。

  7. sort() 和 reverse() 方法在排序或反转大列表时修改列表以节省空间。 提醒您它们是通过副作用操作的，它们不会返回排序或反转的列表。

  8. sort() 方法采用可选参数来控制比较。

    cmp 指定两个参数（列表项）的自定义比较函数，根据第一个参数是否被认为小于、等于或大于第二个参数，该函数应返回负数、零或正数： cmp=lambda x,y: cmp(x.lower(), y.lower())。 默认值为 None。

    key 指定一个参数的函数，用于从每个列表元素中提取一个比较键：key=str.lower。 默认值为 None。

    reverse 是一个布尔值。 如果设置为 True，则列表元素的排序就像每次比较都颠倒了一样。

    通常，key 和 reverse 转换过程比指定等效的 cmp 函数快得多。 这是因为 cmp 为每个列表元素被多次调用，而 key 和 reverse 只接触每个元素一次。 使用 functools.cmp_to_key() 将旧式 cmp 函数转换为 key 函数。

    2.3 版更改： 支持 None 相当于省略 cmp。

    2.4 版更改： 添加了对 键 和 反向 的支持。

  9. 从 Python 2.3 开始，sort() 方法保证稳定。 如果排序保证不改变比较相等的元素的相对顺序，则它是稳定的——这有助于多次排序（例如，按部门排序，然后按工资等级排序）。

  11. 值 n 是一个整数，或一个实现 __index__() 的对象。 n 的零值和负值清除序列。 序列中的项目不被复制； 它们被多次引用，如 序列类型下的 s * n 所述 - str、unicode、列表、元组、字节数组、缓冲区、xrange。


5.7. 设置类型 — 放 , 冻结集

set 对象是不同的 hashable 对象的无序集合。 常见用途包括成员资格测试、从序列中删除重复项以及计算交集、并集、差和对称差等数学运算。 （对于其他容器，请参阅内置的 dict、list 和 tuple 类，以及 collections 模块。）

2.4 版中的新功能。


与其他集合一样，集合支持 [X37X]、len(set) 和 for x in set。 作为一个无序集合，集合不记录元素位置或插入顺序。 因此，集合不支持索引、切片或其他类似序列的行为。

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

从 Python 2.7 开始，除了 set 构造函数之外，还可以通过在大括号内放置一个逗号分隔的元素列表来创建非空集（不是frozensets），例如：{'jack', 'sjoerd'} .

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

class set([iterable])
class frozenset([iterable])

返回一个新的 set 或frozenset 对象，其元素取自 iterable。 集合的元素必须是 hashable。 为了表示集合的集合，内部集合必须是 frozenset 对象。 如果未指定 iterable，则返回一个新的空集。

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

len(s)

返回集合 s 中元素的数量（s 的基数）。

x in s

测试 x 在 s 中的成员资格。

x not in s

在 s 中测试 x 是否为非会员。

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(*others)
set | other | ...

返回一个包含集合中的元素和所有其他元素的新集合。

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

intersection(*others)
set & other & ...

返回一个新的集合，其中包含集合和所有其他元素共有的元素。

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

difference(*others)
set - other - ...

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

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

symmetric_difference(other)
set ^ other

返回一个新的集合，其中包含集合或 other 中的元素，但不能同时包含两者。

copy()

返回集合的浅拷贝。

请注意，union()、intersection()、difference() 和 symmetric_difference()、[ X138X]issubset() 和 issuperset() 方法将接受任何可迭代对象作为参数。 相比之下，它们的基于运算符的对应物需要设置它们的参数。 这排除了像 set('abc') & 'cbs' 这样容易出错的结构，而有利于更易读的 set('abc').intersection('cbs')。

set 和 frozenset 都支持 set 设置比较。 两个集合相等当且仅当每个集合的每个元素都包含在另一个集合中（每个都是另一个的子集）。 一个集合小于另一个集合当且仅当第一个集合是第二个集合的一个真子集（是一个子集，但不相等）。 一个集合大于另一个集合当且仅当第一个集合是第二个集合的真超集（是一个超集，但不相等）。

set 的实例根据其成员与 frozenset 的实例进行比较。 例如，set('abc') == frozenset('abc') 返回 True，set('abc') in set([frozenset('abc')]) 也是如此。

子集和相等比较不能推广到总排序函数。 例如，任意两个非空的不相交集不相等，也不是彼此的子集，所以下面的 all 返回 False: a<b, a==b 或 a>b。 因此，集合不实现 __cmp__() 方法。

由于集合仅定义部分排序（子集关系），因此 list.sort() 方法的输出对于集合列表是未定义的。

集合元素，如字典键，必须是 可散列 。

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

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

update(*others)
set |= other | ...

更新集合，添加所有其他元素。

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

intersection_update(*others)
set &= other & ...

更新集合，只保留在其中找到的元素和所有其他元素。

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

difference_update(*others)
set -= other | ...

更新集合，删除在其他集合中找到的元素。

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

symmetric_difference_update(other)
set ^= other

更新集合，只保留在任一集合中找到的元素，但不保留在两个集合中。

add(elem)

将元素 elem 添加到集合中。

remove(elem)

从集合中移除元素 elem。 如果集合中不包含 elem，则引发 KeyError。

discard(elem)

如果存在，则从集合中删除元素 elem。

pop()

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

clear()

从集合中删除所有元素。

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

请注意，__contains__()、remove() 和 discard() 方法的 elem 参数可能是一个集合。 为了支持搜索等效的frozenset，从elem 创建了一个临时的。

也可以看看

与内置集合类型的比较
sets 模块与内置集合类型的区别。


5.8. 映射类型 — 字典

mapping 对象将 hashable 值映射到任意对象。 映射是可变对象。 目前只有一种标准映射类型，即 字典 。 （对于其他容器，请参阅内置的 list、set 和 tuple 类，以及 collections 模块。）

字典的键是 几乎 任意值。 不是 hashable 的值，即包含列表、字典或其他可变类型（按值而不是按对象标识进行比较）的值不能用作键。 用于键的数字类型遵循数字比较的正常规则：如果两个数字比较相等（例如 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)

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

如果没有给出位置参数，则创建一个空字典。 如果给出了一个位置参数并且它是一个映射对象，则使用与映射对象相同的键值对创建一个字典。 否则，位置参数必须是 iterable 对象。 可迭代对象中的每个项目本身必须是一个恰好有两个对象的可迭代对象。 每个项目的第一个对象成为新字典中的键，第二个对象成为相应的值。 如果某个键出现多次，则该键的最后一个值将成为新字典中的相应值。

如果给出了关键字参数，则关键字参数及其值将添加到从位置参数创建的字典中。 如果要添加的键已经存在，则来自关键字参数的值将替换来自位置参数的值。

为了说明，以下示例都返回一个等于 {"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项。 如果 键 不在地图中，则引发 KeyError。

如果 dict 的子类定义了一个方法 __missing__() 并且 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 的部分实现。 collections.defaultdict 使用了不同的 __missing__ 方法。

2.5 版新功能：识别 dict 子类的 __missing__ 方法。

d[key] = value

将 d[key] 设置为 值 。

del d[key]

从 d 中移除 d[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 中的键和设置为 value 的值创建一个新字典。

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

2.3 版中的新功能。

get(key[, default])

如果 key 在字典中，则返回 key 的值，否则返回 default。 如果未给出 default，则默认为 None，因此该方法永远不会引发 KeyError。

has_key(key)

测试字典中是否存在 key。 has_key() 已弃用，取而代之的是 key in d。

items()

返回字典的 (key, value) 对列表的副本。

如果 items(), keys(), values(), iteritems(), iterkeys() , 和 itervalues() 被调用而不对字典进行干预修改，列表将直接对应。 这允许使用 zip(): pairs = zip(d.values(), d.keys()) 创建 (value, key) 对。 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 版中的新功能。

字典比较相等当且仅当它们具有相同的 (key, value) 对。

5.8.1. 字典视图对象

dict.viewkeys()、dict.viewvalues()和dict.viewitems()返回的对象是视图对象。 它们提供了字典条目的动态视图，这意味着当字典发生变化时，视图会反映这些变化。

可以迭代字典视图以产生各自的数据，并支持成员资格测试：

len(dictview)
返回字典中的条目数。
iter(dictview)

返回字典中键、值或项目（表示为 (key, value) 的元组）的迭代器。

键和值以任意顺序迭代，该顺序是非随机的，因 Python 实现而异，并取决于字典的插入和删除历史。 如果在没有对字典进行干预的情况下迭代键、值和项目视图，项目的顺序将直接对应。 这允许使用 zip(): pairs = zip(d.values(), d.keys()) 创建 (value, key) 对。 创建相同列表的另一种方法是 pairs = [(v, k) for (k, v) in d.items()]。

在字典中添加或删除条目时迭代视图可能会引发 RuntimeError 或无法迭代所有条目。

x in dictview
如果 x 在底层字典的键、值或项中，则返回 True（在后一种情况下，x 应该是一个 (key, value) 元组）。

键视图是类似设置的，因为它们的条目是唯一且可散列的。 如果所有值都是可散列的，因此 (key, value) 对是唯一且可散列的，则项目视图也是类似设置的。 （值视图不被视为类集合，因为条目通常不是唯一的。）然后这些集合操作可用（“其他”指的是另一个视图或集合）：

dictview & other
将 dictview 和另一个对象的交集作为新集合返回。
dictview | other
将 dictview 和另一个对象的并集作为新集合返回。
dictview - other
返回 dictview 和其他对象（dictview 中不在 other 中的所有元素）之间的差异作为新集合。
dictview ^ other
将 dictview 和另一个对象的对称差异（所有元素在 dictview 或 other 中，但不是在两者中）作为新集合返回。

字典视图使用示例： 

>>> 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.closure() 而不是直接使用该对象。

file.flush()

刷新内部缓冲区，如 stdio 的 fflush()。 这可能对某些类文件对象无效。

笔记

flush() 不一定会将文件的数据写入磁盘。 使用 flush() 后跟 os.fsync() 来确保这种行为。

file.fileno()

返回底层实现用于从操作系统请求 I/O 操作的整数“文件描述符”。 这对于使用文件描述符的其他较低级别的接口非常有用，例如 fcntl 模块或 os.read() 和朋友。

笔记

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

file.isatty()

如果文件连接到 tty(-like) 设备，则返回 True，否则返回 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 个字节（如果在获得 size 个字节之前读取达到 EOF，则更少）。 如果 size 参数为负数或省略，则读取所有数据直到达到 EOF。 字节作为字符串对象返回。 当立即遇到 EOF 时返回一个空字符串。 （对于某些文件，例如 ttys，在命中 EOF 后继续读取是有意义的。）请注意，此方法可能会多次调用底层 C 函数 fread() 以努力获取接近 ]size 字节尽可能。 还要注意，在非阻塞模式下，即使没有给出 size 参数，也可能返回比请求少的数据。

笔记

此函数只是底层 fread() C 函数的包装器，并且在极端情况下的行为相同，例如是否缓存 EOF 值。

file.readline([size])

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

笔记

与 stdio 的 fgets() 不同，如果它们出现在输入中，则返回的字符串包含空字符 ('\0')。

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()。 whence 参数可选，默认为 os.SEEK_SET 或 0（绝对文件定位）； 其他值是 os.SEEK_CUR 或 1（相对于当前位置搜索）和 os.SEEK_END 或 2（相对于文件末尾搜索）。 没有返回值。

例如，f.seek(2, os.SEEK_CUR) 将位置向前移动两个，而 f.seek(-3, os.SEEK_END) 将位置设置为倒数第三个。

请注意，如果打开文件进行追加（模式 'a' 或 'a+'），则任何 seek() 操作将在下次写入时撤消。 如果文件仅以追加模式（模式 'a'）打开用于写入，则此方法本质上是无操作的，但对于在启用读取的追加模式下打开的文件（模式 'a+'）仍然有用]）。 如果文件以文本模式打开（没有 'b'），则只有 tell() 返回的偏移量是合法的。 使用其他偏移量会导致未定义的行为。

请注意，并非所有文件对象都是可查找的。

2.6 版更改： 不推荐将浮点值作为偏移量传递。

file.tell()

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

笔记

在 Windows 上，tell() 可以在读取带有 Unix 样式行结尾的文件时返回非法值（在 fgets() 之后）。 使用二进制模式（'rb'）来规避这个问题。

file.truncate([size])
截断文件的大小。 如果存在可选的 size 参数，则文件将被截断为（最多）该大小。 大小默认为当前位置。 当前文件位置不会改变。 请注意，如果指定的大小超过文件的当前大小，则结果取决于平台：可能包括文件可能保持不变、增加到指定大小就像填充零一样，或者增加到具有未定义新内容的指定大小。 可用性：Windows，许多 Unix 变体。
file.write(str)
将字符串写入文件。 没有返回值。 由于缓冲，在调用 flush() 或 close() 方法之前，该字符串可能实际上不会出现在文件中。
file.writelines(sequence)
将字符串序列写入文件。 序列可以是任何产生字符串的可迭代对象，通常是一个字符串列表。 没有返回值。 （该名称旨在匹配 readlines()；writelines() 不添加行分隔符。）

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

文件对象还提供了许多其他有趣的属性。 这些不是类文件对象所必需的，但如果它们对特定对象有意义，则应该实现。

file.closed
bool 指示文件对象的当前状态。 这是一个只读属性； close() 方法更改值。 它可能不适用于所有类似文件的对象。
file.encoding

此文件使用的编码。 将 Unicode 字符串写入文件时，将使用此编码将它们转换为字节字符串。 此外，当文件连接到终端时，该属性给出了终端可能使用的编码（如果用户错误地配置了终端，该信息可能不正确）。 该属性是只读的，可能不会出现在所有类似文件的对象上。 它也可能是 None，在这种情况下，文件使用系统默认编码来转换 Unicode 字符串。

2.3 版中的新功能。

file.errors

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

2.6 版中的新功能。

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

如果文件对象是使用 open() 创建的，则为文件名。 否则，一些指示文件对象来源的字符串，格式为 <...>。 这是一个只读属性，可能不会出现在所有类似文件的对象上。

file.newlines
如果 Python 构建时启用了 universal newlines（默认），则此只读属性存在，并且对于以通用换行读取模式打开的文件，它会跟踪读取文件时遇到的换行类型。 它可以采用的值是 '\r'、'\n'、'\r\n'、None（未知，尚未读取换行符）或包含所有看到的换行符类型的元组, 表示遇到了多个换行约定。 对于未以通用换行读取模式打开的文件，此属性的值将为 None。
file.softspace

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

笔记

该属性不用于控制 print 语句，而是允许执行 print 来跟踪其内部状态。


5.10. 内存视图类型

2.7 版中的新功能。


memoryview 对象允许 Python 代码访问支持缓冲协议的对象的内部数据而无需复制。 内存通常被解释为简单的字节。

class memoryview(obj)

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

memoryview 具有 element 的概念，它是由原始对象 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. 上下文管理器类型

2.5 版中的新功能。


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

上下文管理协议由一对需要提供给上下文管理器对象来定义运行时上下文的方法组成：

contextmanager.__enter__()

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

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

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

contextmanager.__exit__(exc_type, exc_val, exc_tb)

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

从此方法返回真值将导致 with 语句抑制异常并继续执行紧跟在 with 语句之后的语句。 否则，此方法执行完毕后，异常将继续传播。 执行此方法期间发生的异常将替换 with 语句主体中发生的任何异常。

传入的异常永远不应该被显式地重新引发——相反，这个方法应该返回一个 false 值来指示该方法成功完成并且不想抑制引发的异常。 这允许上下文管理代码（例如 contextlib.nested）轻松检测 __exit__() 方法是否实际失败。

Python 定义了几个上下文管理器来支持简单的线程同步、文件或其他对象的提示关闭以及对活动十进制算术上下文的更简单操作。 除了上下文管理协议的实现之外，不会对特定类型进行特殊处理。 有关一些示例，请参阅 contextlib 模块。

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

请注意，在 Python/C API 中 Python 对象的类型结构中，这些方法中的任何一个都没有特定的插槽。 想要定义这些方法的扩展类型必须将它们作为普通的 Python 可访问方法提供。 与设置运行时上下文的开销相比，单个类字典查找的开销可以忽略不计。


5.12. 其他内置类型

解释器支持几种其他类型的对象。 其中大部分只支持一两个操作。

5.12.1. 模块

模块上唯一的特殊操作是属性访问：m.name，其中 m 是一个模块，而 name 访问在 m' 中定义的名称s 符号表。 可以分配模块属性。 （请注意，import 语句严格来说不是对模块对象的操作；import foo 不需要名为 foo 的模块对象存在，而是它对于某处名为 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. 类和类实例

有关这些，请参阅 对象、值和类型 和 类定义 。


5.12.3. 职能

函数对象由函数定义创建。 对函数对象的唯一操作是调用它：func(argument-list)。

函数对象实际上有两种风格：内置函数和用户定义函数。 两者都支持相同的操作（调用函数），但实现不同，因此对象类型不同。

有关详细信息，请参阅 函数定义 。


5.12.4. 方法

方法是使用属性符号调用的函数。 有两种风格：内置方法（例如列表上的 append()）和类实例方法。 内置方法用支持它们的类型来描述。

该实现为类实例方法添加了两个特殊的只读属性：m.im_self 是方法操作的对象，m.im_func 是实现该方法的函数。 调用m(arg-1, arg-2, ..., arg-n)完全等同于调用m.im_func(m.im_self, arg-1, arg-2, ..., arg-n)。

类实例方法要么是bound，要么是unbound，分别指的是方法是通过实例访问还是通过类访问。 当方法未绑定时，其 im_self 属性将为 None，如果调用，则必须将显式 self 对象作为第一个参数传递。 在这种情况下，self 必须是未绑定方法的类（或该类的子类）的实例，否则会引发 TypeError。

与函数对象一样，方法对象支持获取任意属性。 但是，由于方法属性实际上存储在底层函数对象 (meth.im_func) 上，因此不允许在绑定或未绑定方法上设置方法属性。 尝试在方法上设置属性会导致 AttributeError 被引发。 为了设置方法属性，您需要在底层函数对象上显式设置它： 

>>> 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 语句或内置的 eval() 函数来执行或评估代码对象。

有关详细信息，请参阅 标准类型层次结构 。


5.12.6. 类型对象

类型对象代表各种对象类型。 对象的类型由内置函数 type() 访问。 类型没有特殊操作。 标准模块 types 定义了所有标准内置类型的名称。

类型是这样写的：<type 'int'>。


5.12.7. 空对象

此对象由未显式返回值的函数返回。 它不支持特殊操作。 正好有一个空对象，名为 None（一个内置名称）。

写成None。


5.12.8. 省略号对象

此对象由扩展切片表示法使用（请参阅 Slicings）。 它不支持特殊操作。 只有一个省略号对象，名为 Ellipsis（一个内置名称）。

写成Ellipsis。 在下标时，也可以写成...，例如seq[...]。


5.12.9. 未实现的对象

当要求比较和二进制操作对它们不支持的类型进行操作时，将返回此对象。 有关详细信息，请参阅 比较 。

写成NotImplemented。


5.12.10。 布尔值

布尔值是两个常量对象 False 和 True。 它们用于表示真值（尽管其他值也可以被视为假或真）。 在数字上下文中（例如，当用作算术运算符的参数时），它们的行为分别类似于整数 0 和 1。 内置函数 bool() 可用于将任何值转换为布尔值，前提是该值可以解释为真值（请参阅上面的 真值测试 部分）。

它们分别写为 False 和 True。


5.12.11。 内部对象

有关此信息，请参阅 标准类型层次结构 。 它描述了堆栈帧对象、回溯对象和切片对象。


5.13. 特殊属性

该实现向几个相关的对象类型添加了一些特殊的只读属性。 dir() 内置函数没有报告其中一些。

object.__dict__
用于存储对象（可写）属性的字典或其他映射对象。
object.__methods__

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

object.__members__

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

instance.__class__
类实例所属的类。
class.__bases__
类对象的基类元组。
definition.__name__
类、类型、函数、方法、描述符或生成器实例的名称。

以下属性仅受 new-style classes 支持。

class.__mro__
此属性是在方法解析期间查找基类时要考虑的类的元组。
class.mro()
此方法可以被元类覆盖以自定义其实例的方法解析顺序。 它在类实例化时被调用，其结果存储在 __mro__ 中。
class.__subclasses__()

每个新样式的类都保存了一个对其直接子类的弱引用列表。 此方法返回所有那些仍然存在的引用的列表。 例子：

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

脚注

1
关于这些特殊方法的更多信息可以在 Python 参考手册 ( 基本定制 ) 中找到。
2
因此，列表 [1, 2] 被认为等于 [1.0, 2.0]，对于元组也是如此。
3
他们必须有，因为解析器不能告诉操作数的类型。
4(1,2,3,4)
大小写字符是具有一般类别属性为“Lu”（字母，大写）、“Ll”（字母，小写）或“Lt”（字母，标题大写）之一的字符。
5
因此，要仅格式化元组，您应该提供一个单例元组，其唯一元素是要格式化的元组。
6
保留换行符的优点是返回一个空字符串是一个明确的 EOF 指示。 也可以（在可能重要的情况下，例如，如果您想在扫描文件行时制作文件的精确副本）判断文件的最后一行是否以换行符结尾（是的，这种情况会发生！）。



取自“https://cainiaojiaocheng.com/index.php?title=Python/docs/2.7/library/stdtypes&oldid=22834”
Powered by MediaWiki