5内置类型¶

以下部分描述了内置到口译员。

注释

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

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

一些操作由几种对象类型支持；特别地，实际上，所有对象都可以进行比较、测试真值和转换字符串（使用报告（）功能或略有不同str（）功能）。当对象由打印（）功能。

5.1.真值测试¶

可以测试任何对象的真值，以便在如果或虽然条件或作为下面布尔运算的操作数。这个以下值被视为假：

无
False（错误）
任何数字类型的零，例如，0,0升,0,0j个.
例如任何空序列，'',(),[].
任何空映射，例如，{}.
用户定义类的实例，如果该类定义了__非零____（）或__透镜_（）方法，当该方法返回整数零或布尔价值False（错误）.1

所有其他值都被视为true-因此许多类型的对象总是真的。

具有布尔结果的操作和内置函数始终返回0或False（错误）对于false和1或真的为真，除非另有说明。（重要例外：布尔运算或和和总是返回其中一个操作数。）

5.2.布尔运算-`和`,`或`,`不`¶

以下是按优先级升序排列的布尔运算：

操作	结果	笔记
`x个或年`	如果x个是假的，那么年，否则x个	(1)
`x个和年`	如果x个是假的，那么x个，否则年	(2)
`不 x个`	如果x个是假的，那么`真的`,其他的`False（错误）`	(3)

笔记：

这是一个短路运算符，因此它只计算第二个如果第一个为假，则进行辩论。
这是一个短路运算符，因此它只计算第二个如果第一个是真的。
不优先级低于非布尔运算符，因此不一 == b是解释为不（a） == b）、和一 == 不 b是一个语法错误。

5.3.比较¶

所有对象都支持比较操作。他们都有相同的优先级（高于布尔运算的优先级）。比较可以被任意锁链；例如，x个 < 年 <= z相当于x个 < 年和年 <= z，除了那个年仅评估一次（但在这两种情况下z不是当x个 < 年发现错误）。

此表总结了比较操作：

操作	含义	笔记
`<`	严格小于
`<=`	小于或等于
`>`	严格大于
`>=`	大于或等于
`==`	平等的
`!=`	不相等	(1)
`是`	对象标识
`是不`	否定的对象标识

笔记：

!=也可以写<>，但这是一种过时的用法仅为向后兼容而保留。新代码应始终使用!=.

不同类型的对象，不同的数字类型和不同的字符串除外类型，永远不要比较相等；这些对象的顺序是一致的，但任意（这样对异构数组进行排序就会产生一致的结果）。此外，某些类型（例如，文件对象）仅支持退化这种类型的任何两个对象不相等的比较概念。再一次，这些对象是任意但一致地排序的。这个<,<=,>和>=操作员将引发类型错误任何操作数为复数。

类的非同一实例通常比较为非相等实例，除非类定义__等式____（）方法或__cmp_（）方法。

类的实例不能相对于相同的类或其他类型的对象，除非该类定义了足够的丰富的比较方法(__lt____（）,__le____（）,__gt__（）、和__ge____（）)或__cmp_（）方法。

CPython实施细节：不同类型的对象（数字除外）按类型名称排序；不支持正确比较的相同类型的对象按以下顺序排序他们的地址。

另外两个操作具有相同的语法优先级，在里面和不在里面，是仅受序列类型支持（如下）。

5.4.数字类型-`整数`,`浮动`,`长的`,`复杂的`¶

有四种不同的数字类型：纯整数,长的整数,浮点数、和复数.英寸此外，布尔是普通整数的一个子类型。普通整数（也只是打电话整数)使用实现长的单位为C，表示它们的精度至少为32位(sys.maxint系统始终设置为最大值当前平台的纯整数值，最小值为-sys.maxint系统 - 1). 长整数具有无限精度。浮点数字通常使用双重的单位为C；有关的信息浮点数的精度和内部表示运行程序的计算机在中可用系统浮动信息复数有实部和虚部每个都是一个浮点数。从复数中提取这些部分z，使用z.密封和z.imag公司。（标准库包括其他数字类型，分数持有理性，以及十进制的那个使用用户定义的精度保存浮点数字。）

数字是由数字文字或内置函数创建的和操作员。未修饰的整数文字（包括二进制、十六进制和八进制numbers）生成纯整数，除非它们表示的值太大表示为普通整数，在这种情况下，它们生成一个长整数。带“L”或“l”后缀产生长整数(“L”首选，因为1升看起来太像十一岁了！）。数值型的字面值包含小数点或指数符号产生浮点数。附录“j”或“J”对于数字文字，生成一个虚数（实数部分为零的复数）可以加到整数或浮点运算以获得包含实部和虚部的复数。

Python完全支持混合算术：当二进制算术运算符具有不同数字类型的操作数，“较窄”类型的操作数为加宽为另一个，其中普通整数比长整数窄窄于浮点，窄于复数。之间的比较混合类型的数字使用相同的规则。2施工人员int（）,long（）,float（）、和复合（）可用于生成数字特定类型的。

所有内置数字类型都支持以下操作。请参阅电力运营商以及后面的章节，以了解操作员的优先级。

操作	结果	笔记
`x个 + 年`	的总和x个和年
`x个 - 年`	的差异x个和年
`x个 * 年`	的产品x个和年
`x个 / 年`	的商x个和年	(1)
`x个 // 年`	（地板）商x个和年	(4)(5)
`x个 % 年`	剩余的`x个 / 年`	(4)
`-x个`	x个否定的
`+x个`	x个不变
`腹肌（x）`	绝对值或量级x个	(3)
`整数（x）`	x个转换为整数	(2)
`长（x）`	x个转换为长整数	(2)
`浮动（x）`	x个转换为浮点	(6)
`复合（re，im）`	带实数部分的复数重新，虚部感应电动机.感应电动机默认为零。
`c.共轭（）`	复数的共轭c（c）.（实数上的标识）
`divmod（x， y）`	这对`（x） // 是的， x个 % 年）`	(3)(4)
`功率（x，年）`	x个权力年	(3)(7)
`x个 ** 年`	x个权力年	(7)

笔记：

对于（普通或长）整数除法，结果是一个整数。结果是总是朝负无穷大舍入：1/2为0，（-1）/2为-1，1/（-2）为-1，并且（-1）/（-2）为0。请注意，如果任一操作数是长整数，与数值无关。
使用从浮点转换int（）或long（）截断为像相关函数一样为零，math.trunc（）.使用功能数学.floor（）向下取整数学.cell（）使变圆向上。
请参阅内置功能以获取完整描述。
自版本2.3以来已弃用：地板分割操作符、模操作符和divmod（）函数不再为复数定义。相反，请转换为使用绝对值（）功能（如果适用）。
也称为整数除法。结果值是一个整数，尽管结果的类型不一定是int。
float还接受带有可选前缀“+”的字符串“nan”和“inf”或“-”表示非数字（NaN）和正负无穷大。

2.6版中的新增功能。
Python定义功率（0， 0)和0 ** 0成为1，这是常见的编程语言。

全部数字。真实类型(整数,长的、和浮动)还包括以下操作：

操作	结果
`数学trunc（x）`	x个截断为`完整的`
`圆形（x[， n] ）`	x个四舍五入为n个数字，将领带舍入为零。如果n个则默认为0。
`数学地板（x）`	浮点形式的最大整数<=x个
`数学.cell（x）`	最小整数作为浮点>=x个

5.4.1.整数类型的逐位运算¶

按位运算只对整数有意义。负数被处理作为其2的补码值（这假定有足够多的比特操作期间不会发生溢出）。

二进制按位操作的优先级都低于数字操作和高于比较；一元运算~有与其他一元数字运算的优先级相同(+和-).

此表列出了按升序排序的位操作：

操作	结果	笔记
`x个 \| 年`	按位或属于x个和年
`x个 ^ 年`	按位独占或属于x个和年
`x个 & 年`	按位和属于x个和年
`x个 << n个`	x个左移了n个位	(1)(2)
`x个 >> n个`	x个右移了n个位	(1)(3)
`~x个`	the bits ofx个倒置的

笔记：

负移位计数是非法的，并导致值错误待提出。
左移位n个位等于乘以功率（2， n）.A型如果结果超出普通整数的范围，则返回长整数。
右移n个位等于除以功率（2， n）.

5.4.2.关于整数类型的其他方法¶

整数类型实现数字。完整的 抽象基础班。此外，它们还提供了一种方法：

内部。比特长度()¶

长。比特长度()¶

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

>>>n个 = -37
>>>箱子(n个)
“-0b100101”
>>>n个.比特长度()
6

更准确地说，如果x个则为非零x.位长度（）是唯一正整数k个这样的话2**（k-1） <= 腹肌（x） < 2**k个.等效地，当腹肌（x）足够小，可以正确使用四舍五入对数，则k个 = 1 + int（log（abs（x）， 2)).如果x个那么是零x.位长度（）收益0.

相当于：

定义 比特长度(自己):
    秒 = 箱子(自己)       #二进制表示：bin（-37）-->“-0b100101”
    秒 = 秒.l行程(“-0b”) #删除前导零和减号
    返回 伦恩(秒)       #长度（'100101'）-->6

2.7版新增。

5.4.3.浮动的其他方法¶

float类型实现数字。真实 抽象基础班.float还具有以下附加方法。

浮动。作为整数比率()¶: 返回一对整数，其比率正好等于原始浮点数，分母为正。加薪溢出错误关于无穷大和a值错误在名称。

2.6版中的新增功能。

浮动。集成（_I）()¶

返回真的如果float实例是有限的积分值，以及False（错误）否则：

>>>(-2).集成（_I）()
真的
>>>(3.2).集成（_I）()
False（错误）

2.6版中的新增功能。

有两种方法支持转换为以及十六进制字符串。由于Python的浮点是存储的内部为二进制数，将浮点转换为十进制的字符串通常包含较小的舍入错误。在相反，十六进制字符串允许精确表示和浮点数的规范。这在以下情况下很有用调试和数字工作。

浮动。十六进制()¶: 返回浮点数的十六进制表示形式字符串。对于有限浮点数，此表示法将始终包含一个引导0x个和一个尾随对和指数。

2.6版中的新增功能。

浮动。from十六进制(秒)¶: 类方法返回由十六进制表示的浮点一串秒.字符串秒可能有前导和尾随空白。

2.6版中的新增功能。

请注意float.hex（）是实例方法，而float.fromhex（）是一个类方法。

十六进制字符串的格式为：

[签名] [“0x”] 整数 ['.' 分数] [“p” 指数]

其中，可选签名可以通过以下任一方式+或-,整数和分数是十六进制数字的字符串，以及指数是一个带可选前导号的十进制整数。大小写不是有效，并且中必须至少有一个十六进制数字整数或分数。此语法类似于C99标准第6.4.4.2节中规定的语法，以及Java 1.5及以后版本中使用的语法。特别是float.hex（）在中可用作十六进制浮点文字C或Java代码，以及由C生成的十六进制字符串%一个格式字符或Java的双.toHexString被接受float.fromhex（）.

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

>>>浮动.from十六进制(“0x3.a7p10”)
3740

将反向转换应用于3740提供了不同的表示相同数字的十六进制字符串：

>>>浮动.十六进制(3740)
“0x1.d380000000000p+11”

5.5.迭代器类型¶

2.2版中的新增功能。

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

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

容器。__iter公司__()¶: 返回迭代器对象。该对象需要支持迭代器协议描述如下。如果容器支持不同类型的迭代，可以提供额外的方法来具体请求这些迭代类型的迭代器。（支持对象的示例多种形式的迭代将是一个树状结构，它支持宽度优先和深度优先遍历。）此方法对应于tp_输入Python/C中Python对象的类型结构槽应用程序编程接口。

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

迭代器。__iter公司__()¶: 返回迭代器对象本身。这是允许两个容器和迭代器一起使用对于和在里面声明。此方法对应于tp_输入类型结构的插槽Python/C API中的Python对象。

迭代器。下一个()¶: 从容器中返回下一个项目。如果没有其他项目，请提出这个停止迭代例外。此方法对应于tp_外接中Python对象的类型结构的槽Python/C API。

Python定义了几个迭代器对象以支持在通用和特定的序列类型、字典和其他更专业的形式。这个除了迭代器的实现之外，特定类型并不重要协议。

协议的意图是，一旦迭代器下一个（）方法加薪停止迭代，它将在以后的调用中继续这样做。不遵守此属性的实现被视为已损坏。（此在Python2.3中添加了约束；在Python2.2中，各种迭代器被破坏根据这条规则。）

5.5.1.发电机类型¶

Python的发电机s提供了一种实现迭代器的方便方法协议。如果容器对象__iter__（）方法实现为生成器，它将自动返回迭代器对象（从技术上讲生成器对象）提供__iter__（）和next（）方法。可以找到有关发电机的更多信息在里面yield表达式的文档.

5.6.序列类型-`字符串`,`unicode码`,`列表`,`元组`,`字节射线`,`缓冲器`,`润智`¶

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

有关其他容器，请参阅内置字典和设置类，和收藏模块。

字符串文字用单引号或双引号括起来：'xyzzy',“青蛙”。请参阅字符串常量有关字符串文字的更多信息。Unicode字符串与字符串很相似，但在语法中指定使用前导词“u”字符：u‘abc’,u“定义”.此外对于这里描述的功能，还有一些特定于字符串的中描述的方法字符串方法第节。列表包括由方括号构成，用逗号分隔项目：[答：， b、，【抄送】.元组由逗号运算符构造（不在正方形内括号），带或不带括括号，但为空元组必须包含括括号，例如a、， b、， c（c）或().A型单项元组必须有一个尾随逗号，例如（d）.

字节数组对象是使用内置函数创建的字节数组（）.

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

xrange类型的对象与缓冲区类似，因为没有特定的语法创建它们，但它们是使用xrange（）功能。他们没有支持切片、串联或重复，并使用在里面,不在里面,最小（）或最大（）他们的效率很低。

大多数序列类型支持以下操作。这个在里面和不在里面操作具有与比较操作相同的优先级。这个+和*操作与相应的数字操作具有相同的优先级。三提供了其他方法可变序列类型.

此表列出了按优先级升序排序的序列操作。在表格中，秒和t吨是相同类型的序列；n个,我和j个是整数：

操作	结果	笔记
`x个在里面秒`	`真的`如果某项属于秒是等于x个，否则`False（错误）`	(1)
`x个不在里面秒`	`False（错误）`如果某项属于秒是等于x个，否则`真的`	(1)
`秒 + t吨`	的串联秒和t吨	(6)
`秒 * 编号：， n个 * 秒`	相当于添加秒到它本身n个次	(2)
`第[i]节`	我第个项目，共个秒，原点0	(3)
`秒[i:j]`	切片秒从我到j个	(3)(4)
`秒[i:j:k]`	切片秒从我到j个带台阶k个	(3)(5)
`长度`	的长度秒
`分钟`	最小项秒
`最大值（s）`	最大的项目秒
`s.指数（x）`	首次出现的索引属于x个在里面秒
`计数（x）`	出现的总次数x个在里面秒

序列类型也支持比较。特别是元组和列表通过比较对应词进行词典比较元素。这意味着要比较相等，每个元素都必须比较相等，且两个序列必须属于同一类型且具有相同长度。（有关详细信息，请参阅比较用这种语言参考。）

笔记：

什么时候？秒是字符串或Unicode字符串对象在里面和不在里面操作就像子串测试。在2.3之前的Python版本中，x个不得不是长度为1的字符串。在Python 2.3及更高版本中，x个可以是任意字符串长度。
的值n个小于0被视为0（这将生成一个空与相同类型的序列秒). 注意序列中的项目秒未复制；它们被多次引用。这经常出没新的Python程序员；考虑：
```
>>>列表 = [[]] * 三
>>>列表
[[], [], []]
>>>列表[0].追加(三)
>>>列表
[[3], [3], [3]]
```
发生了什么事[[]]是一个包含空列表中的所有三个元素[[]] * 三对这个单一的引用是空的吗列表。修改的任何元素列表修改这个列表。您可以通过以下方式创建不同列表的列表：
```
>>>列表 = [[] 对于 我 在里面 范围(三)]
>>>列表[0].追加(三)
>>>列表[1].追加(5)
>>>列表[2].追加(7)
>>>列表
[[3], [5], [7]]
```
常见问题解答条目中提供了进一步的解释如何创建多维列表？.
如果我或j个为负，则索引相对于序列的末尾秒:长度 + 我或长度 + j个被替换。但请注意-0仍然是0.
的切片秒从我到j个定义为具有索引的项的序列k个这样的话我 <= k个 < j个.如果我或j个大于长度，使用长度.如果我省略或无，使用0.如果j个省略或无，使用长度.如果我大于或等于j个，切片是为空。
的切片秒从我到j个带台阶k个定义为带索引的项x个 = 我 + 不确定这样的话0 <= n个 < （j-i）/k换句话说，这些指数是我,i+k（输入+输出）,i+2*k,i+3*k等等，当j个已达到（但从不包括j个). 什么时候？k个是积极的，我和j个减少到长度如果它们更大。什么时候？k个为负值，我和j个减少到长度 - 1如果它们更大。如果我或j个被省略或无，它们变成“end”值（哪一端取决于k个). 注：，k个不能为零。如果k个是无，它被视为1.
CPython实施细节：如果秒和t吨都是字符串，一些Python实现，例如CPython通常可以对表格秒 = 秒 + t吨或秒 += t吨适用时，此优化使二次运行时间的可能性大大降低。这种优化同时是取决于版本和实现。对于性能敏感的代码最好使用str.接头（）确保一致性的方法跨版本和实现的线性级联性能。

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

5.6.1.字符串方法¶

下面列出了8位字符串和Unicode对象支持。其中一些也可以在上获得字节射线物体。

此外，Python的字符串支持序列类型方法中描述的序列类型-str、unicode、list、tuple、bytearray、buffer、xrange第节。输出格式化字符串使用模板字符串或%中描述的操作员字符串格式操作第节。此外，请参阅重新的模块基于正则表达式的字符串函数。

街道。资本化()¶

返回字符串的副本，第一个字符大写其余部分降低。

对于8位字符串，此方法依赖于区域设置。

街道。中心(宽度[,fillchar（填充字符）])¶: 以字符串为中心返回宽度。填充使用明确规定fillchar（填充字符）（默认为空格）。

在版本2.4中更改：支持fillchar（填充字符）参数。

结构。计数(附属的[,开始[,结束]])¶: 返回子字符串的非重叠出现次数附属的在范围[开始,结束]. 可选参数开始和结束是解释为切片表示法。

街道。解码([编码[,错误]])¶: 使用为注册的编解码器解码字符串编码.编码默认为默认的字符串编码。错误可以设置不同的错误处理方案。默认值为“严格”，意思是编码错误引发Unicode错误。其他可能的值为“忽略”,“替换”以及通过注册的任何其他名称编解码器.register_error（），参见第节编解码器基类.

2.2版中的新增功能。

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

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

街道。编码([编码[,错误]])¶: 返回字符串的编码版本。默认编码为当前默认字符串编码。错误可以设置不同的错误处理方案。的默认值错误是“严格”，意思是编码错误引发Unicode错误。其他可能的值为“忽略”,“替换”,'xmlcharrefreplace','反斜杠替换'和通过注册的任何其他名称编解码器.register_error（），参见第节编解码器基类。有关可能的编码列表，请参阅第节标准编码.

2.0版中的新增功能。

在版本2.3中更改：支持'xmlcharrefreplace'和'反斜杠替换'和其他错误添加了处理方案。

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

街道。以…结尾(后缀[,开始[,结束]])¶: 返回真的如果字符串以指定的后缀，否则返回False（错误）.后缀也可以是要查找的后缀元组。带可选开始，从该位置开始测试。带可选结束，停止比较在那个位置。

在版本2.5中更改：接受元组为后缀.

街道。展开选项卡([标签大小])¶

返回字符串的副本，其中所有制表符都替换为一个或更多空格，具体取决于当前列和给定的选项卡大小。选项卡位置每隔标签大小字符（默认值为8，提供选项卡第0、8、16列等处的位置）。要展开字符串列设置为零，并且逐字符检查字符串。如果字符是制表符(\t吨)，插入一个或多个空格字符直到当前列等于下一个选项卡位置。（不会复制制表符本身。）如果字符是换行符(\n个)或返回(\第页)，它被复制，当前列重置为零。复制任何其他字符时保持不变，当前列为当印刷的。

>>>'01\t吨012\t吨0123\t吨01234'.展开选项卡()
'01      012     0123    01234'
>>>'01\t吨012\t吨0123\t吨01234'.展开选项卡(4)
'01  012 0123    01234'

街道。找到(附属的[,开始[,结束]])¶

返回字符串中的最低索引，其中子字符串附属的在中找到切片s[开始：结束].可选参数开始和结束是解释为切片表示法。返回-1如果附属的找不到。

注释

这个查找（）只有当您需要知道的位置附属的.检查是否附属的是否为子字符串，请使用在里面操作员：

>>>“Py” 在里面 “Python”
真的

街道。格式(*参数,**夸格斯)¶

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

>>>“1+2的总和是{0}".格式(1+2)
'1+2的和是3'

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

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

2.6版中的新增功能。

街道。指数(附属的[,开始[,结束]])¶: 喜欢查找（），但提高值错误当找不到子字符串时。

街道。伊萨努姆()¶

如果字符串中的所有字符都是字母数字且位于至少一个字符，否则为false。

对于8位字符串，此方法依赖于区域设置。

结构。是否字母()¶

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

对于8位字符串，此方法依赖于区域设置。

街道。是数字()¶

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

对于8位字符串，此方法依赖于区域设置。

街道。岛国()¶

如果所有大小写字符均为true4在字符串中是小写的，在至少一个大小写字符，否则为false。

对于8位字符串，此方法依赖于区域设置。

街道。isspace（信息空间）()¶

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

对于8位字符串，此方法依赖于区域设置。

街道。蒸馏水()¶

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

对于8位字符串，此方法依赖于区域设置。

街道。isupper（上）()¶

如果所有大小写字符均为true4字符串中是大写的，并且在至少一个大小写字符，否则为false。

对于8位字符串，此方法依赖于区域设置。

街道。参加(可迭代的)¶: 返回一个字符串，该字符串是可迭代的.如果中有任何Unicode对象可迭代的，则返回Unicode。A类类型错误如果存在任何非字符串或非Unicode，将引发中的对象值可迭代的。元素之间的分隔符是字符串提供此方法。

街道。我只是(宽度[,fillchar（填充字符）])¶: 返回长度为的字符串中左对齐的字符串宽度.填充完成使用指定的fillchar（填充字符）（默认为空格）。原始字符串为如果返回宽度小于或等于长度.

在版本2.4中更改：支持fillchar（填充字符）参数。

街道。降低()¶

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

对于8位字符串，此方法依赖于区域设置。

街道。l行程([焦炭])¶

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

>>>“宽敞”.l行程()
“宽敞”
>>>“www.example.com”.第一次跳闸('cmowz')
'示例.com'

在版本2.2.2中更改：支持焦炭参数。

街道。隔板(九月)¶: 在第一次出现时拆分字符串九月，并返回一个3元组包含分隔符之前的部分、分隔符本身和部分在分离器之后。如果找不到分隔符，则返回包含字符串本身，后面跟着两个空字符串。

2.5版中的新增功能。

街道。代替(古老的,新的[,计数])¶: 返回包含所有子字符串的字符串副本古老的替换为新的。如果可选参数计数只给出了第一个计数引用将被替换。

街道。反向查找(附属的[,开始[,结束]])¶: 返回字符串中的最高索引，其中子字符串附属的发现，例如那个附属的包含在s[开始：结束].可选参数开始和结束被解释为切片表示法。返回-1失败时。

街道。林德克斯(附属的[,开始[,结束]])¶: 喜欢rfind（）但会加薪值错误当子字符串附属的不是找到。

街道。r只是(宽度[,填充字符])¶: 返回长度为的字符串中右对齐的字符串宽度.填充完成使用指定的fillchar（填充字符）（默认为空格）。原始字符串是如果返回宽度小于或等于长度.

在版本2.4中更改：支持fillchar（填充字符）参数。

街道。r分区(九月)¶: 在的最后一次出现时拆分字符串九月，并返回一个3元组包含分隔符之前的部分、分隔符本身和部分在分离器之后。如果找不到分隔符，则返回包含两个空字符串，后跟字符串本身。

2.5版中的新增功能。

街道。rsplit（rsplit）([九月[,最大分割]])¶: 使用返回字符串中单词的列表九月作为分隔符字符串。如果最大分割最多给出个最大分割拆分完成后最右边的个。如果九月未指定或无，任何空白字符串都是分离器。除了从右边分裂，rsplit（）行为类似拆分（）下面详细描述。

2.4版中的新增功能。

结构。rstrip公司([焦炭])¶

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

>>>“宽敞”.第一次旅行()
“宽敞”
>>>“密西西比”.第一次旅行(“ipz”)
“小姐”

在版本2.2.2中更改：支持焦炭参数。

街道。分裂([九月[,最大分割]])¶

使用返回字符串中单词的列表九月作为分隔符字符串。如果最大分割最多给出个最大分割完成拆分（因此，名单上最多有最大拆分+1元素）。如果最大分割不是指定或-1，则拆分次数没有限制（进行了所有可能的拆分）。

如果九月如果给定，则连续的分隔符不会组合在一起，而是被认为界定了空字符串（例如，“1，，2”.split（“，”）收益['1', '', '2']). 这个九月参数可以由多个字符组成（例如，“1<>2<>3”.分割（“<>”）收益['1', '2', '3']).使用指定的分隔符拆分空字符串返回[''].

如果九月未指定或无，另一种分割算法是应用：连续空格的运行被视为单个分隔符，如果字符串具有前导或尾随空格。因此，拆分空字符串或仅由空白组成的字符串无分离器收益[].

例如，' 1 2 三 '.split（）收益['1', '2', '3']、和' 1 2 三 '.split（无， 1)收益['1', '2 三 '].

街道。分割线([保留])¶

返回字符串中的行列表，在行边界处断开。此方法使用通用换行符分割线条的方法。换行符不包括在结果列表中，除非保留是已知且真实。

Python识别“\r”,“\n”、和“\r\n”作为线边界8位字符串。

例如：

>>>‘ab c\\n\n去功能梯度\第页肯尼亚\\r\n'.分割线()
[“ab c”，“”，“de fg”，“kl”]
>>>‘ab c\\n\n去功能梯度\第页肯尼亚\\r\n'.分割线(真的)
['ab c\n'，'\n'，'de fg\r'，'kl\r\n']

不同于拆分（）当分隔符字符串九月给出，这个方法返回空字符串的空列表和终端行中断不会产生额外的行：

>>>"".分割线()
[]
>>>“一行\n个".分割线()
[“一行”]

为了进行比较，拆分（“\n”）给予：

>>>''.分裂('\n个')
['']
>>>'两条线\n个'.分裂('\n个')
[“两行”，“”]

unicode编码。分割线([保留])¶

返回字符串中的行列表，如str.分割线（）.然而，Unicode方法在以下行边界上拆分，是的超集通用换行符因而被认可8位字符串。

代表	描述
`\n个`	换行符
`\第页`	车架返回
`\\r\n`	回车+换行
`\v（v）`或`\x0b个`	线条制表
`\（f）`或`\x0c个`	表单馈送
`\x1c个`	文件分隔符
`\x1d个`	组分隔符
`\x1e个`	记录分隔符
`\x85像素`	下一行（C1控制代码）
`\2028年`	行分隔符
`\2029年`	段落分隔符

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

街道。启动开关(前缀[,开始[,结束]])¶: 返回真的如果字符串以前缀，否则返回False（错误）.前缀也可以是要查找的前缀元组。带可选开始,从该位置开始的测试字符串。带可选结束，停止比较字符串位于该位置。

在版本2.5中更改：接受元组为前缀.

街道。带([焦炭])¶

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

>>>“宽敞”.带()
“宽敞”
>>>“www.example.com”.带(“cmowz。”)
“示例”

在版本2.2.2中更改：支持焦炭参数。

街道。抽汲箱()¶

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

对于8位字符串，此方法依赖于区域设置。

街道。标题()¶

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

该算法使用一个简单的与语言无关的单词定义作为连续字母组。该定义适用于许多情况，但这意味着缩略语和所有格中的撇号构成单词边界，这可能不是期望的结果：

>>>“他们是比尔的英国朋友”.标题()
“他们是比尔的英国朋友”

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

>>>进口 重新
>>>定义 标题酶(秒):
...    返回 重新.附属的(第页“[A-Za-z]+（'[A-Za-z]+）？”,
...                  λ 瞬间: 瞬间.组(0)[0].上面的() +
...                             瞬间.组(0)[1:].降低(),
...                  秒)
...
>>>标题栏(“他们是比尔的朋友。”)
“他们是比尔的朋友。”

对于8位字符串，此方法依赖于区域设置。

街道。翻译(桌子[,删除cars])¶

返回字符串的副本，其中所有字符出现在可选的论点删除cars删除，其余字符已通过给定的转换表映射，转换表必须是一个长度字符串256

您可以使用maketrans（）中的helper函数一串模块创建翻译表。对于字符串对象，将桌子的参数无对于只删除字符的翻译：

>>>'阅读此简短文本'.翻译(无, “aeiou”)
'rd ths shrt txt'

2.6版中的新增功能：支持无 桌子参数。

对于Unicode对象翻译（）方法不接受可选的删除cars论点。相反，它返回秒所有这些已通过给定的翻译表映射了个字符，该表必须是Unicode序号到Unicode序号、Unicode字符串或无.未映射的字符保持不变。映射到的字符无是删除。注意，更灵活的方法是创建自定义字符映射使用解码器模块（参见编码.p1251对于示例）。

街道。上面的()¶

返回包含所有大小写字符的字符串副本4已转换为大写。请注意s.upper（）.isuper（）可能是False（错误）如果秒包含未大写字符，或者如果结果的Unicode类别字符不是“Lu”（字母，大写），而是例如“Lt”（Letter，titlecase）。

对于8位字符串，此方法依赖于区域设置。

街道。zfill公司(宽度)¶: 返回长度字符串中用零填充的数字字符串宽度。符号前缀处理正确。原始字符串是如果返回宽度小于或等于长度.

2.2.2版中的新增功能。

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

unicode。非数字字符()¶: 返回真的如果S中只有数字字符，False（错误）否则。数字字符包括数字字符和所有字符具有Unicode数值属性的，例如U+2155，VULGAR分数五分之一。

unicode。是十进制()¶: 返回真的如果S中只有十进制字符，False（错误）否则。十进制字符包括数字字符和所有字符其可用于形成十进制基数（例如U+0660），阿拉伯数字零。

5.6.2.字符串格式操作¶

字符串和Unicode对象有一个独特的内置操作：%运算符（模）。这也称为字符串格式化或插值操作员。鉴于格式 % 值（其中格式是字符串或Unicode对象），%转换规范格式被替换包含零个或多个元素值.效果与使用类似冲刺（）用C语言编写。如果格式是Unicode对象，或者如果有正在使用转换的对象的%秒转换是Unicode对象，结果也将是一个Unicode对象。

如果格式需要一个参数，值可以是单个非耦合对象。5否则，值必须是一个元组，其数字正好为由格式字符串或单个映射对象（例如字典）。

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

这个'%'字符，它标记说明符的开始。
映射键（可选），由带括号的字符序列组成（例如，（名字）).
转换标志（可选），它会影响某些转换的结果类型。
最小字段宽度（可选）。如果指定为'*'（星号）从中元组的下一个元素读取实际宽度值，以及要转换的对象位于最小字段宽度和可选精度之后。
精度（可选），以'.'（点）后面跟着精度。如果指定为'*'（星号），实际宽度从下一个中元组的元素值，并且要转换的值位于精确度。
长度修改器（可选）。
转换类型。

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

>>>打印 '%（语言）s有%（编号）03d报价类型。' %\...      {“语言”: “Python”, “数字”: 2}
Python有002个引号类型。

在这种情况下没有*说明符可能以某种格式出现（因为它们需要顺序参数列表）。

转换标志字符包括：

标志	含义
`'#'`	值转换将使用“替代形式”（如定义（见下文）。
`'0'`	数字值的转换将为零填充。
`'-'`	转换后的值进行左调整（覆盖`'0'`转换（如果两者都给定）。
`' '`	（空格）正数前应留一个空格（或为空字符串）由签名转换生成。
`'+'`	符号字符(`'+'`或`'-'`)将在转换之前（覆盖“空格”标志）。

长度修改器(小时,我，或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”`	字符串（使用报告（）).	(5)
`“s”`	字符串（使用`str（）`).	(6)
`'%'`	未转换参数，导致`'%'`结果中的字符。

笔记：

替换形式导致前导零('0')插入到如果前导字符为结果的不等于零。
替代形式导致前导“0x”或“0X”（取决于是否这个“x”或“X”格式）插入到第一个数字之前。
备用形式会导致结果始终包含一个小数点，即使后面没有数字。

精度决定小数点后的位数默认为6。
替代形式使结果始终包含小数点，并且后面的零不会像以前那样被删除。

精度决定了小数点，默认为6。
这个%第页Python 2.0中添加了转换。

精度决定了使用的最大字符数。
如果提供的对象或格式是unicode码字符串，结果字符串也将是unicode码.

精度决定了使用的最大字符数。
请参阅政治公众人物237.

由于Python字符串具有显式长度，%秒转换不假定那个'\0'是字符串的末尾。

在版本2.7中更改：%（f）绝对值大于1e50的数字的转换为否更长时间替换为%克转换。

在标准模块中定义了额外的字符串操作一串和重新.

5.6.3.X范围类型¶

这个润智类型是一个不可变序列，通常用于循环。The advantage of the润智类型是一个润智对象将始终占用相同的内存量，无论它表示的范围。没有一致的性能优势。

XRange对象几乎没有什么行为：它们只支持索引、迭代、，和透镜（）功能。

5.6.4.可变序列类型¶

列表和字节射线对象支持允许的其他操作对象的就地修改。其他可变序列类型（添加时语言）也应支持这些操作。字符串和元组是不可变的序列类型：这样的对象一旦创建就不能修改。以下操作是在可变序列类型上定义的（其中x个是任意对象）：

操作	结果	笔记
`第[i]节 = x个`	项目我属于秒被替换为x个
`秒[i:j] = t吨`	切片秒从我到j个替换为的内容可迭代的t吨
`德尔秒[i:j]`	等同于`秒[i:j] = []`
`秒[i:j:k] = t吨`	的元素`秒[i:j:k]`替换为t吨	(1)
`德尔 s[i:j:k]`	删除的元素`秒[i:j:k]`从列表中
`s.附加（x）`	等同于`s[长度：长度] = 【x】`	(2)
`s.延伸（t）`或`秒 += t吨`	大多数情况下与`s[长度：长度] = t吨`	(3)
`秒 *= n个`	更新秒及其内容重复的n个次	(11)
`s.计数（x）`	返回的编号我是的哪一个`第[i]节 == x个`
`s.指数（x[， i[， j] ]）`	返回最小值k个这样的话`秒[k] == x个`和`我 <= k个 < j个`	(4)
`s.插入（i， x）`	等同于`秒[i:i] = 【x】`	(5)
`流行音乐（[i]）`	等同于`x个 = 第[i]节；德尔第[i]节；返回 x个`	(6)
`s.删除（x）`	等同于`德尔 s[s.索引（x）]`	(4)
`s.反转（）`	反转的项目秒在里面地方	(7)
`s.sort（[cmp[，键[，反向]]]）`	对项进行排序秒到位	(7)(8)(9)(10)

笔记：

t吨必须与要替换的切片具有相同的长度。
Python的C实现在历史上接受了多个参数和隐式地将它们连接成一个元组；这在Python2.0中不再有效。的使用自Python 1.4以来，这个错误功能就一直被弃用。
t吨可以是任何可迭代的对象。
加薪值错误什么时候x个在中找不到秒。当负指数为作为第二个或第三个参数传递给索引（）方法，列表对于切片索引，添加长度。如果它仍然为负数，则被截断到零，如切片指数。

在版本2.3中更改：以前，索引（）没有用于指定开始和停止的参数位置。
当负索引作为第一个参数传递给插入（）方法中，对于切片索引，添加列表长度。如果它仍然存在负数，它被截断为零，就像切片索引一样。

在版本2.3中更改：以前，所有负指数都被截断为零。
这个pop（）方法的可选参数我默认为-1，所以默认情况下，最后一项被删除并返回。
这个排序（）和反转（）方法就地修改的列表排序或反转大列表时节省空间。提醒你它们的操作有副作用，不会返回排序或反转的列表。
这个排序（）方法采用可选参数来控制比较。

化学机械抛光指定两个参数（列表项）的自定义比较函数应返回负数、零或正数，具体取决于第一个参数被认为小于、等于或大于第二个参数自变量：cmp=λ x、年： cmp（x.lower（））， y.lower（））。默认值是无.

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

颠倒是一个布尔值。如果设置为真的，则列表元素为就像每个比较都是反向的一样进行排序。

一般来说钥匙和颠倒转换过程比指定等效项化学机械抛光功能。这是因为化学机械抛光被称为每个列表元素多次，同时钥匙和颠倒触摸每个元素仅一次。使用functools.cmp_to_key（）转换老式的化学机械抛光函数到钥匙功能。

在版本2.3中更改：支持无等同于省略化学机械抛光已添加。

在版本2.4中更改：支持钥匙和颠倒已添加。
从Python 2.3开始排序（）该方法具有稳定性。A类如果排序保证不更改元素的相对顺序，则排序是稳定的比较相等-这有助于在多个过程中进行排序（对于例如，按部门排序，然后按薪等排序）。
CPython实施细节：在对列表进行排序时，尝试变异的效果，甚至检查，列表未定义。Python 2.3的C实现和newer使列表在持续时间内显示为空，并引发值错误如果它可以检测到列表在排序。
价值观n个是整数，或是实现的对象__索引__（）。的零值和负值n个清楚的顺序。不复制序列中的项目；它们被引用多次，如所述秒 * n个在下面序列类型-str、unicode、list、tuple、bytearray、buffer、xrange.

5.7.设置类型-`设置`,`冰冻的`¶

A类设置对象是distinct的无序集合可散列的物体。常见的用途包括成员身份测试、从序列中删除重复项，以及计算数学运算，如交集、并、差和对称差异。（有关其他容器，请参阅内置字典,列表,和元组类，以及收藏模块。）

2.4版中的新增功能。

与其他集合一样，集合支持x个在里面设置,长度（套）、和对于 x个在里面设置。作为无序集合，集合不记录元素位置或插入顺序。因此，集合不支持索引、切片或其他类似序列的行为。

目前有两种内置集合类型，设置和冰冻的.这个设置类型是可变的-可以使用方法更改内容喜欢添加（）和删除（）。因为它是可变的，所以没有哈希值，不能用作字典键或的元素另一组。这个冰冻的类型是不可变的，并且可散列的—其内容在创建后不能更改；因此，它可以用作字典键或另一集合的元素。

从Python 2.7开始，可以通过放置大括号中以逗号分隔的元素列表，例如：{“杰克”， “sjoerd”}，除了设置构造函数。

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

班设置([可迭代的])¶

班冰冻的([可迭代的])¶

返回元素取自的新集合或冻结集合对象可迭代的。集合的元素必须是可散列的.至表示集合的集合，内部集合必须是冰冻的物体。如果可迭代的未指定，则新的空集为返回。

的实例设置和冰冻的提供以下内容操作：

长度: 返回集合中的元素数秒（基数秒).

x英寸秒: 测试x个作为会员秒.

x不在s中: 测试x个非会员秒.

不相交(其他)¶: 返回真的如果集合没有与共同的元素其他。集合是不相交当且仅当它们的交集是空集。

2.6版新增。

issubset（发行子集）(其他)¶
集合<=其他: 测试集合中的每个元素是否都在其他.

集合<其他: 测试集合是否是其他也就是说，设置 <= 其他和设置 != 其他.

被取代(其他)¶
集合>=其他: 测试中的每个元素其他在集合中。

集合>其他: 测试集合是否是的适当超集其他也就是说，设置 >= 其他和设置 != 其他.

联盟(*其他)¶
设置|其他|。。。: 返回一个新的集合，其中包含集合中的元素和所有其他元素。

在版本2.6中更改：接受多个输入迭代器。

交叉(*其他)¶
设置其他（&O）。。。: 返回一个新的集合，其中包含集合和所有其他元素的公共元素。

在版本2.6中更改：接受多个输入迭代器。

差异(*其他)¶
设置-其他-。。。: 返回一个新的集合，该集合中的元素不在其他集合中。

在版本2.6中更改：接受多个输入迭代器。

对称_差异(其他)¶
设置^其他: 返回包含集合或其他但并非两者兼而有之。

复制()¶: 返回集合的浅副本。

注意，非运算符版本的联合（）,交集（）,差异（）、和对称性差异（）,issubset（）、和issuperset（）方法将接受任何可迭代的参数。在相比之下，它们基于运算符的对等项要求其参数为套。这就排除了容易出错的结构，如集合（'abc'） & “cbs”有利于更具可读性集合（'abc'）.交集（'cbs'）.

两者都有设置和冰冻的支持集合到集合的比较。两个当且仅当每个集合的每个元素都包含在另一个（每个都是另一个的子集）。如果且只有当第一个集合是第二个集合的适当子集（是子集，但不相等）。当且仅当第一组是第二个集合的适当超集（是超集，但不相等）。

的实例设置与以下实例进行比较冰冻的基于他们的成员。例如，集合（'abc'） == 冰冻（'abc'）收益真的也是如此集合（'abc'）在里面集合（[冻结集合（'abc'）]）.

子集和相等比较不能概括为总排序功能。例如，任何两个非空的不相交集都是不相等的彼此的子集，所以全部的以下报表的False（错误）:a<b,a==b，或a> b条因此，集合不实现__cmp__（）方法。

由于集合仅定义部分排序（子集关系）这个list.sort（）对于集合列表，方法未定义。

集合元素（如字典键）必须是可散列的.

混合的二进制操作设置具有的实例冰冻的返回第一个操作数的类型。例如：冰冻（'ab'） | 集合（'bc'）返回的实例冰冻的.

下表列出了可用于设置那不是应用于的不可变实例冰冻的:

更新(*其他)¶
set |=其他|。。。: 更新集合，添加其他所有元素。

在版本2.6中更改：接受多个输入迭代器。

intersection_update（交叉_更新）(*其他)¶
set&=其他&。。。: 更新集合，只保留在其中找到的元素和所有其他元素。

在版本2.6中更改：接受多个输入迭代器。

差异_更新(*其他)¶
set-=其他|。。。: 更新集合，删除在其他集合中找到的元素。

在版本2.6中更改：接受多个输入迭代器。

symmetric_difference_update（对称差异更新）(其他)¶
设置^=其他: 更新集合，只保留任一集合中的元素，但不保留两者中的元素。

添加(元素)¶: 添加元素元素到集合。

去除(元素)¶: 删除元素元素从设置。加薪键错误如果元素是不包含在集合中。

丢弃(元素)¶: 删除元素元素如果存在，则从集合中删除。

流行音乐()¶: 从集合中移除并返回任意元素。加薪键错误如果集合为空。

清楚的()¶: 从集合中删除所有元素。

请注意更新（）,intersection_update（）,差异更新（）、和symmetric_difference_update（）方法将接受任何可迭代的参数。

注意元素参数__容器_（）,删除（）、和丢弃（）方法可以是一组。支持搜索等效项frozenset，创建一个临时的元素.

另请参见

与内置集合类型的比较: Differences between the套模块和内置集合类型。

5.8.映射类型-`字典`¶

A类映射对象贴图可散列的值设置为任意对象。映射是可变对象。目前只有一个标准映射类型词典.（有关其他容器，请参阅内置列表,设置、和元组类，以及收藏模块。）

字典的键是几乎任意值。不是可散列的，即包含列表、字典或其他可变类型（通过值而不是对象标识进行比较）可能不能用作钥匙。用于键的数字类型遵守以下常规规则数字比较：如果两个数字比较相等（例如1和1)然后可以互换使用它们来索引相同的字典条目。（注意然而，由于计算机将浮点数存储为近似值将它们用作字典键通常是不明智的。）

可以通过放置逗号分隔的键：价值括号内的对，例如：{“杰克”： 4098, “sjoerd”： 4127}或{4098: “杰克”， 4127: “sjoerd”}，或通过字典构造函数。

班字典(**夸格)¶

班字典(映射,**夸格)

班字典(可迭代的,**夸格)

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

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

如果给定关键字参数，则关键字参数及其值为添加到根据位置参数创建的字典中。如果密钥正在添加的值已存在，则关键字参数中的值替换位置参数中的值。

为了进行说明，以下示例都返回一个等于{“一”： 1, “两个”： 2, “三”： 3}:

>>>一 = 字典(一=1, 二=2, 三=三)
>>>b = {“一个”: 1, “两个”: 2, “三个”: 三}
>>>c（c） = 字典(拉链([“一个”, “两个”, “三个”], [1, 2, 三]))
>>>d日 = 字典([(“两个”, 2), (“一个”, 1), (“三个”, 三)])
>>>e（电子） = 字典({“三个”: 三, “一个”: 1, “两个”: 2})
>>>一 == b == c（c） == d日 == e（电子）
真的

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

2.2版中的新增功能。

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

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

长度（d）: 返回字典中的项数d日.

d[键]

返回的项目d日带钥匙钥匙.引发键错误如果钥匙不在地图中。

如果dict的子类定义了一个方法__缺少____（）和钥匙不存在d[键]操作使用键调用该方法钥匙作为参数。这个d[键]然后操作返回或提升由__遗失__（钥匙）呼叫。没有其他操作或方法调用__缺少____（）.如果__缺少____（）未定义，键错误被提起。__缺少____（）必须是方法；它不能是实例变量：

>>>班 计数器(字典):
...    定义 __缺少__(自己, 钥匙):
...        返回 0
>>>c（c） = 计数器()
>>>c（c）[“红色”]
0
>>>c（c）[“红色”] += 1
>>>c（c）[“红色”]
1

上面的示例显示了收藏。计数器。不同的__缺少__方法已使用通过集合.defaultdict.

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

d[键]=值: 设置d[键]到价值.

del d[键]: 删除d[键]从d日.引发键错误如果钥匙不在中地图。

键入d: 返回真的如果d日有一把钥匙钥匙，否则False（错误）.

2.2版中的新增功能。

密钥不在d中: 相当于不钥匙在里面 d日.

2.2版新增。

iter（d）: 返回字典键上的迭代器。这是一条捷径对于iterkey（）.

清楚的()¶: 从字典中删除所有项目。

复制()¶: 返回字典的浅副本。

来自键(序列[,价值])¶

使用中的键创建新词典序列和值设置为价值.

fromkeys（）是返回新字典的类方法。价值默认为无.

2.3版中的新增功能。

得到(钥匙[,违约])¶: 返回的值钥匙如果钥匙在字典里，否则违约.如果违约未给定，默认为无，因此此方法从不提出键错误.

has_key（钥匙）(钥匙)¶: 测试是否存在钥匙在字典里。has_key（）是不赞成赞成钥匙在里面 d日.

项目()¶

返回字典列表的副本（键，值）对。

CPython实施细节：键和值以非随机的任意顺序列出，不同于Python实现，并且取决于字典的插入和删除的历史记录。

如果项目（）,按键（）,值（）,iteritems（）,iterkey（）、和iter值（）在没有干预的情况下被调用修改字典后，列表将直接对应。这个允许创建（值，键）成对使用zip（）:对 = zip（d.值（）， d.按键（））。相同的关系适用于iterkey（）和iter值（）方法：对 = zip（d.itervalues（））， d.iterkey（））为提供相同的值对。创建相同列表的另一种方法是对 = [（v）， k）对于（k， v）在里面 d.iteritems（）].

iter项()¶

返回字典上的迭代器（键，值）对。请参阅注意事项目录项（）.

使用iteritems（）在字典中添加或删除条目时可能会引发访问违例或无法迭代所有条目。

2.2版中的新增功能。

iterkeys公司()¶

在字典的键上返回迭代器。参见注释目录项（）.

使用iterkey（）在字典中添加或删除条目时可能会引发访问违例或无法迭代所有条目。

2.2版中的新增功能。

iter值()¶

返回字典值的迭代器。参见注释目录项（）.

使用iter值（）在中添加或删除条目时字典可能会引发访问违例或者无法遍历所有内容条目。

2.2版中的新增功能。

钥匙()¶: 返回字典键列表的副本。参见注释dict.items（）语句.

流行音乐(钥匙[,违约])¶: 如果钥匙在字典中，将其删除并返回其值，否则返回违约.如果违约未给出，且钥匙不在字典中，一键错误已引发。

2.3版中的新增功能。

popitem（流行项目）()¶

删除并返回任意（键，值）从字典中找出一对。

popitem（）用于在字典上进行破坏性迭代，如常用于集合算法。如果字典为空，则调用popitem（）引发键错误.

设置默认值(钥匙[,违约])¶: 如果钥匙在字典中，返回其值。如果不是，请插入钥匙值为违约然后返回违约.违约默认为无.

更新([其他])¶

使用中的键/值对更新字典其他，正在覆盖现有密钥。返回无.

更新（）接受另一个dictionary对象或的iterable键/值对（作为元组或长度为2的其他迭代）。If关键字参数，然后使用这些参数更新字典键/值对：d.update（红色＝1，蓝色=2）.

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

值()¶: 返回字典值列表的副本。参见注释目录项（）.

查看项目()¶: 返回字典项的新视图(（键，值）对）。请参阅查看视图对象的文档。

2.7版中的新增功能。

视图键()¶: 返回字典键的新视图。请参阅以下文档查看对象。

2.7版中的新增功能。

视图值()¶: 返回字典值的新视图。请参阅以下文档查看对象。

2.7版中的新增功能。

当且仅当字典具有相同时，字典才会进行比较（键，值）对。

5.8.1.字典视图对象¶

返回的对象dict.viewkeys（）,dict.viewvalues（）和dict.viewitems（）语句是查看对象。它们提供了有关字典条目，这意味着当字典更改时，视图反映了这些变化。

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

透镜（dictview）: 返回字典中的条目数。

iter（dictview）

返回键、值或项上的迭代器（表示为（键，值）)在字典里。

键和值以非随机的任意顺序迭代，不同的Python实现不同，并且取决于字典的历史记录插入和删除。如果键、值和项视图被迭代在没有对字典进行任何干预性修改的情况下，项目的顺序将直接对应。这允许创建（值，键）对使用zip（）:对 = zip（d.值（）， d.按键（））。另一种方式创建相同的列表是对 = [（v）， k）对于（k， v）在里面 d.项目（）].

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

dictview中的x: 返回真的如果x个位于基础字典的键、值或项目（在后一种情况下，x个应该是（键，值）元组）。

键视图是集合式的，因为它们的条目是唯一的且可散列的。如果全部值是可哈希的，因此（键、值）对是唯一的且可哈希，那么items视图也是set-like。（值视图不被视为集合因为条目通常不是唯一的。）那么这些设置操作是可用（“其他”是指另一个视图或集合）：

dictview和其他: 返回dictview和另一个对象的交集作为一个新集合。

dictview |其他: 将dictview和另一个对象的并集作为新的集合返回。

dictview-其他: 返回dictview和其他对象（所有元素）之间的差异在里面dictview（字典视图）不在里面的其他)作为一个新的集合。

dictview^其他: 返回对称差（中的所有元素dictview（字典视图）或其他，但不是在两者中）的dictview和另一个对象作为一个新的集合。

字典视图用法示例：

>>>菜 = {“鸡蛋”: 2, “香肠”: 1, “培根”: 1, “垃圾邮件”: 500}
>>>钥匙 = 菜.视图键()
>>>值 = 菜.视图值()

>>>#迭代
>>>n个 = 0
>>>对于 val值 在里面 值:
...    n个 += val值
>>>打印(n个)
504

>>>#键和值以相同的顺序迭代
>>>列表(钥匙)
[“鸡蛋”、“培根”、“香肠”、“垃圾邮件”]
>>>列表(值)
[2, 1, 1, 500]

>>>#视图对象是动态的，反映了dict的更改
>>>德尔 菜[“鸡蛋”]
>>>德尔 菜[“香肠”]
>>>列表(钥匙)
[“帕姆”，“培根”]

>>>#set操作
>>>钥匙 & {“鸡蛋”, “培根”, “沙拉”}
{“巴康”}

5.9.文件对象¶

文件对象是使用C语言实现的标准偏差包，可以是使用内置打开（）功能。文件对象也由其他一些内置函数和方法返回，例如os.popen（）和操作系统.fdopen（）和生成文件（）套接字对象的方法。可以使用临时文件模块和高级文件操作，如复制、，可以使用舒蒂尔模块。

当文件操作因I/O相关原因而失败时，异常IO错误被提起。这包括操作不因为某些原因定义，比如搜索（）在tty设备上或写入文件打开阅读。

文件有以下方法：

文件。关闭()¶

关闭文件。无法再读取或写入已关闭的文件。任何操作要求打开文件将引发值错误之后文件已关闭。打电话关闭（）允许多次。

从Python 2.5开始，如果使用这个具有声明。例如，以下代码将自动关闭（f）当具有块退出：

从 __未来__ 进口 带语句（_S） #这在Python 2.6中不是必需的

具有 打开(“hello.txt”) 作为 （f）:
    对于 线 在里面 （f）:
        打印 线,

在Python的旧版本中，您需要这样做才能获得相同的结果效果：

（f） = 打开(“hello.txt”)
尝试:
    对于 线 在里面 （f）:
        打印 线,
最后:
    （f）.关闭()

注释

并非Python支持中的所有“类文件”类型都用作具有声明。如果您的代码用于任何类似文件对象，您可以使用函数contextlib.closing（）而不是使用直接访问对象。

文件。脸红()¶: 刷新内部缓冲区，如标准件的fflush（）。这可能是对某些类似文件的对象没有操作。

注释

冲洗（）不一定要将文件的数据写入磁盘。使用冲洗（）然后操作系统.fsync（）以确保这种行为。

文件。文件描述符()¶: 返回底层使用的整数“文件描述符”从操作系统请求I/O操作的实现。这可以是适用于使用文件描述符的其他较低级别接口，例如文件锁模块或os.read（）和朋友。

注释

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

文件。伊萨蒂()¶: 返回真的如果文件连接到tty（类）设备，则为elseFalse（错误）.

注释

如果类文件对象没有与真实文件关联，则此方法应不实施。

文件。下一个()¶: 例如，文件对象是它自己的迭代器iter（f）收益（f）（除非（f）关闭）。当文件用作迭代器时，通常在对于循环（例如，对于线在里面传真：打印 line.strip（）)，的next（）方法被重复调用。此方法返回下一个输入线条或凸起停止迭代当文件打开时，点击EOF读取（当文件打开进行写入时，行为未定义）。为了制作一个对于循环-在文件（非常常见的操作）next（）方法使用隐藏的读取头缓冲区。由于使用了读头缓冲区next（）使用其他文件方法（如readline（）)工作不正常。然而，使用搜索（）将文件重新定位到绝对位置将刷新读头缓冲区。

2.3版中的新增功能。

文件。阅读([大小])¶: 最多只能阅读大小文件中的字节数（如果读取在获得大小字节）。如果大小参数为负数或省略，请阅读达到EOF之前的所有数据。字节作为字符串对象返回。安当立即遇到EOF时，返回空字符串。（当然文件，如ttys，在点击EOF后继续读取是有意义的。）注释此方法可以调用底层C函数弗雷德（）超过努力获得一次大小字节。另请注意在非阻塞模式下，请求的数据可能会少于返回，即使没有大小给出了参数。

注释

此函数只是底层的包装器弗雷德（）C函数，并且在角点情况下表现相同，例如是否缓存EOF值。

文件。读行([大小])¶: 从文件中读取一整行。尾随换行符保留在字符串（但当文件以不完整的行结束时可能不存在）。6如果大小参数存在且非负，它是最大字节count（包括尾随换行符）和不完整的行可能是返回。什么时候？大小不是0，则返回空字符串只有当EOF立即遇到。

注释

不同于标准偏差的fgets（），返回的字符串包含空字符('\0')如果它们出现在输入中。

文件。自述行([sizehint（大小提示）])¶: 使用读取到EOFreadline（）并返回包含行的列表这样读。如果可选sizehint（大小提示）参数存在，而不是读数达到EOF，整行总计约sizehint（大小提示）字节（可能在舍入到内部缓冲区大小后）被读取。物体实现类文件接口可能会选择忽略尺寸提示如果是的话不能实现或不能有效地实现。

文件。xreadlines（xreadline）()¶: 此方法返回与iter（f）.

2.1版中的新增功能。

自版本2.3以来已弃用：使用对于线在里面文件而不是。

文件。寻求(抵消[,从哪里])¶

设置文件的当前位置，如标准偏差的fseek（）. The从哪里参数是可选的，默认为操作系统。参见设置或0（绝对文件定位）；其他值为操作系统。搜索CUR（_C）或1（查找相对于当前位置）和操作系统。搜索_结束或2（相对于文件的结束）。没有返回值。

例如，f.seek（2，操作系统。搜索（_CUR）将位置提前两步f.周（-3，操作系统。搜索（_E）将位置设置为倒数第三个。

请注意，如果打开文件进行追加（模式“a”或“a+”)，任何搜索（）操作将在下一次写入。如果文件仅在附加模式（模式“a”)，此方法本质上是no-op，但它对文件仍然有用以附加模式打开，启用读取（模式“a+”). 如果文件是以文本模式打开（无“b”)，仅返回偏移量tell（）是合法。使用其他偏移会导致未定义的行为。

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

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

文件。告诉()¶: 返回文件的当前位置，如标准偏差的ftell（）.

注释

在Windows上，tell（）可以返回非法值（在fgets（）)读取带有Unix样式线条的文件时。使用二进制模式(“rb”)至绕过这个问题。

文件。截断([大小])¶: 截断文件的大小。如果可选大小参数存在，文件被截断为（最多）该大小。大小默认为当前位置。当前文件位置未更改。请注意，如果指定的大小超过文件的当前大小，结果取决于平台：可能性包括文件可能保持不变，增加到指定大小零填充，或使用未定义的新内容增加到指定大小。可用性：Windows，许多Unix变体。

文件。写(字符串)¶: 将字符串写入文件。没有返回值。由于缓冲字符串可能不会实际显示在文件中，直到冲洗（）或关闭（）方法。

文件。书写行(序列)¶: 将字符串序列写入文件。序列可以是任何可迭代的对象生成字符串，通常是字符串列表。没有返回值。（名称旨在匹配读取行（）;写行（）不会添加行分隔符。）

文件支持迭代器协议。每次迭代返回的结果与readline（），当readline（）方法返回空字符串。

文件对象还提供了许多其他有趣的属性。这些不是对于类文件对象是必需的，但如果它们对特定对象。

文件。关闭¶: bool表示文件对象的当前状态。这是只读的属性；这个关闭（）方法更改值。它可能不可用在所有文件类对象上。

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

2.3版中的新增功能。

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

2.6版新增。

文件。模式¶: 文件的I/O模式。如果文件是使用打开（）内置函数，这将是模式参数。这是一个只读属性，并且可能不存在于所有类似文件的对象上。

文件。名称¶: 如果文件对象是使用创建的打开（），文件的名称。否则，会出现一些字符串，指示文件对象的源形式<...>。这是一个只读属性，可能不存在于所有类文件对象。

文件。换行符¶: 如果Python是用通用换行符启用（默认）此只读属性存在，并且对于以通用换行读取方式打开的文件模式，它跟踪在读取文件。它可以采用的值为“\r”,“\n”,“\r\n”,无（未知，尚未读取新行）或包含所有新行类型的元组请参阅，以指示遇到了多个换行约定。对于未在通用换行模式下打开的文件读取此属性的值将无.

文件。软空间¶: 布尔值，指示是否需要在之前打印空格字符使用时的另一个值打印声明。正在尝试的类要模拟文件对象，还应该有一个可写的软空间属性，该属性应初始化为零。这对大多数人来说都是自动的用Python实现的类（对于重写属性访问）；在C中实现的类型必须提供一个可写的软空间属性。

注释

此属性不用于控制打印声明，但发送至允许实现打印跟踪其内部状态。

5.10.内存视图类型¶

2.7版中的新增功能。

内存视图对象允许Python代码访问内部数据支持缓冲区协议而不进行复制的对象。存储器通常被解释为简单字节。

班内存视图(对象)¶

创建一个内存视图引用对象.对象必须支持缓冲协议。支持缓冲区协议的内置对象包括字符串和字节射线（但不是unicode码).

A类内存视图具有要素，这是原始对象处理的原子存储单元对象.对许多人来说简单类型，如字符串和字节射线，一个元素是单字节，但其他第三方类型可能会公开较大的元素。

len（视图）返回内存视图中的元素总数，看法. The项目大小属性将为您提供单个元素中的字节数。

A类内存视图支持切片以公开其数据。拿一张单张索引将返回单个元素作为字符串对象。完全切片将生成子视图：

>>>v（v） = 内存视图(“abcefg”)
>>>v（v）[1]
“b”
>>>v（v）[-1]
“g”
>>>v（v）[1:4]
<0x77ab28处的内存>
>>>v（v）[1:4].千兆字节()
“bce”

如果内存视图覆盖的对象支持更改其数据，则memoryview支持切片分配：

>>>数据 = 字节射线(“abcefg”)
>>>v（v） = 内存视图(数据)
>>>v（v）.只读
False（错误）
>>>v（v）[0] = “z”
>>>数据
字节数组（b'zbefg'）
>>>v（v）[1:4] = '123'
>>>数据
字节数组（b'z123fg'）
>>>v（v）[2] = '垃圾邮件'
回溯（最近一次调用）：文件“<stdin>”，行1，英寸＜模块＞
值错误:无法修改memoryview对象的大小

请注意，无法更改memoryview对象的大小。

内存视图有两种方法：

千兆字节()¶

将缓冲区中的数据作为字节字符串返回（类的对象字符串).

>>>米 = 内存视图(“abc”)
>>>米.千兆字节()
“abc”

托利主义者()¶

以整数列表的形式返回缓冲区中的数据。

>>>内存视图(“abc”).托利主义者()
[97, 98, 99]

还有几个只读属性可用：

格式¶: 包含格式（in结构模块样式）视图中的元素。默认为“B”，一个简单的字节串。

项目大小¶: 内存视图中每个元素的字节大小。

形状¶: 长度为的整数元组印度国防部给出的形状内存作为N维数组。

印度国防部¶: 一个整数，指示多维数组的维数内存表示。

步伐¶: 长度为的整数元组印度国防部以字节为单位为访问数组每个维度的每个元素。

只读¶: 指示内存是否为只读的布尔值。

5.11.上下文管理器类型¶

2.5版新增。

Python的具有语句支持运行时上下文的概念由上下文管理器定义。这是使用两种不同的方法实现的允许用户定义的类定义输入的运行时上下文在执行语句体并在语句结束时退出之前。

这个上下文管理协议由一对需要为上下文管理器对象提供以定义运行时上下文：

上下文管理器。__输入__()¶

输入运行时上下文并返回此对象或另一个对象与运行时上下文相关。此方法返回的值绑定到中的标识符作为第条，共条具有语句使用此上下文管理器。

返回自身的上下文管理器的一个示例是文件对象。文件对象从__enter_（）返回自身以允许打开（）用作中的上下文表达式具有声明。

返回相关对象的上下文管理器示例如下由返回decimal.localcontext（）这些管理器将decimal上下文到原始decimal-上下文的副本，然后返回副本。这允许对正文中的当前十进制上下文进行更改的具有语句，而不影响具有声明。

上下文管理器。__退出__(exc类型,不包括（_V）,不包括（tb）)¶

退出运行时上下文并返回一个布尔标志，指示是否有异常应该抑制这种情况。如果在执行的主体具有语句，参数包含异常类型，值和回溯信息。否则，所有三个参数都是无.

从该方法返回真值将导致具有陈述取消异常并立即继续执行语句遵循具有声明。否则，异常将继续在该方法完成执行后传播。发生的异常在执行此方法期间，将替换的主体具有声明。

传入的异常永远不应显式地重新提示-相反，这是方法应返回一个假值，以指示该方法已完成成功，并且不希望取消引发的异常。这允许上下文管理代码（例如上下文库已测试)便于检测或者不是__退出____（）方法实际上失败了。

Python定义了几个上下文管理器来支持轻松的线程同步，提示关闭文件或其他对象，并简化活动对象的操作十进制算术上下文。除此之外，特定类型未被特别处理他们实现了上下文管理协议。请参阅上下文库模块中的一些示例。

Python的发电机s和contextlib.context管理器 装饰工提供了实现这些协议的方便方法。如果发电机功能为用…装饰contextlib.context管理器decorator，它将返回一个上下文管理器实现必要的__输入____（）和__退出（）方法，而不是由未修饰的发电机功能。

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

5.12.其他内置类型¶

解释器支持其他几种类型的对象。大多数支持只有一两次操作。

5.12.1.模块¶

模块上唯一的特殊操作是属性访问：m.名称，其中米是一个模块名称访问中定义的名称米的符号表。模块属性可以分配给。（注意进口严格来说，语句不是对模块对象的操作；进口 foo公司不需要名为的模块对象foo公司存在，而是需要an（外部）定义对于名为的模块foo公司某处。）

每个模块的一个特殊属性是__字典__。这是包含模块符号表的字典。修改此词典将实际更改模块的符号表，但直接分配给__字典__属性不可能（可以写入m.__dict__['a'] = 1，它定义了机械工程师成为1，但你不会写字月__日__ = {}). 正在修改__字典__直接是不推荐。

解释器中内置的模块如下所示：<模块 “系统” （内置）>。如果从文件加载，则将其写入为<模块 “操作系统” 从 '/usr/local/lib/pythonX。是/否.pyc'>.

5.12.2.类和类实例¶

请参阅对象、值和类型和类别定义对于这些。

5.12.3.功能¶

函数对象由函数定义创建。上的唯一操作函数对象将调用它：函数（参数列表）.

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

请参阅功能定义了解更多信息。

5.12.4.方法¶

方法是使用属性表示法调用的函数。有两种风格：内置方法（例如追加（）列表上）和类实例方法。使用支持的类型描述内置方法他们。

该实现向类实例添加了两个特殊的只读属性方法：m.im_自身是该方法操作的对象，并且m.im_func公司是实现该方法的函数。打电话m（arg-1，参数-2， ..., arg-n）完全等同于调用m.im_func（m.im_自身， arg-1，参数-2， ..., arg-n）.

类实例方法是跳跃或未绑定，表示是否方法是分别通过实例或类访问的。当方法未绑定，其im_自身属性将为无如果被呼叫明确的自己对象必须作为第一个参数传递。在这种情况下，自己必须是未绑定方法类的实例（或的子类该类），否则为类型错误已引发。

与函数对象一样，方法对象支持获取任意属性。然而，由于方法属性实际上存储在底层函数中对象(方法im_func)，在绑定或未绑定上设置方法属性不允许使用方法。尝试在方法上设置属性会导致一个属性错误正在被提升。为了设置方法属性，您需要需要在底层函数对象上显式设置它：

>>>班 C:
...    定义 方法(自己):
...        通过
...
>>>c（c） = C()
>>>c（c）.方法.哇，哇 = '我的名字是方法'  #无法在方法上设置
回溯（最近一次调用）：文件“<stdin>”，行1，英寸＜模块＞
属性错误:“instancemethod”对象没有属性“whoami”
>>>c（c）.方法.输入框（_func）.哇，哇 = “我的名字是方法”
>>>c（c）.方法.哇，哇
'我的名字是方法'

请参阅标准类型层次结构了解更多信息。

5.12.5.代码对象¶

实现使用代码对象表示“伪编译”可执行Python代码，如函数体。它们与功能不同对象，因为它们不包含对其全局执行的引用环境。代码对象由内置compile（）功能并且可以通过它们的函数代码属性。另请参见代码模块。

可以通过传递代码对象（而不是源）来执行或计算代码对象字符串）到执行官语句或内置评估（）功能。

请参阅标准类型层次结构了解更多信息。

5.12.6.类型对象¶

类型对象表示各种对象类型。访问对象的类型通过内置函数类型（）。上没有特殊操作类型。标准模块类型定义所有标准内置的名称类型。

类型如下所示：<类型 “int”>.

5.12.7.Null对象¶

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

它被写成无.

5.12.8.省略号对象¶

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

它被写成省略号。在下标中，也可以写为...例如序列[…].

5.12.9.未实现对象¶

当比较和二进制操作要求对他们不支持的类型进行操作。请参阅比较了解更多信息。

它被写成未实施.

5.12.10.布尔值¶

布尔值是两个常量对象False（错误）和真的。它们是用于表示真值（尽管也可以考虑其他值false或true）。在数字上下文中（例如用作算术运算符），它们的行为分别类似于整数0和1。内置函数布尔（）可用于将任何值转换为布尔值，如果该值可以解释为真值（请参阅第节真值测试以上）。

它们被写成False（错误）和真的分别是。

5.12.11.内部对象¶

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

5.13.特殊属性¶

该实现向几个对象添加了一些特殊的只读属性类型，如果它们相关。其中一些没有报告目录（）内置函数。

对象。__字典__¶: 用于存储对象（可写）的字典或其他映射对象属性。

对象。__方法__¶: 自版本2.2以来已弃用：使用内置功能目录（）获取对象属性列表。此属性不再可用。

对象。__成员__¶: 自版本2.2以来已弃用：使用内置功能目录（）获取对象属性列表。此属性不再可用。

实例。__类__¶: 类实例所属的类。

类。__底座__¶: 类对象的基类元组。

定义。__名称__¶: 类、类型、函数、方法、描述符或生成器实例。

以下属性仅受支持新式类锿。

类。__mro公司__¶: 此属性是查找时考虑的类的元组方法解析期间的基类。

类。mro公司()¶: 此方法可以被元类覆盖以自定义方法其实例的解析顺序。它在类实例化时调用，并且其结果存储在__mro公司__.

类。__子类__()¶

每个新式类都保留一个对其立即数的弱引用列表子类。此方法返回所有仍处于活动状态的引用的列表。例子：

>>>整数.__子类__()
[<键入'bool'>]

脚注

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

5内置类型¶

5.1.真值测试¶

5.2.布尔运算-`和`,`或`,`不`¶

5.3.比较¶

5.4.数字类型-`整数`,`浮动`,`长的`,`复杂的`¶

5.4.1.整数类型的逐位运算¶

5.4.2.关于整数类型的其他方法¶

5.4.3.浮动的其他方法¶

5.5.迭代器类型¶

5.5.1.发电机类型¶

5.6.序列类型-`字符串`,`unicode码`,`列表`,`元组`,`字节射线`,`缓冲器`,`润智`¶

5.6.1.字符串方法¶

5.6.2.字符串格式操作¶

5.6.3.X范围类型¶

5.6.4.可变序列类型¶

5.7.设置类型-`设置`,`冰冻的`¶

5.8.映射类型-`字典`¶

5.8.1.字典视图对象¶

5.9.文件对象¶

5.10.内存视图类型¶

5.11.上下文管理器类型¶

5.12.其他内置类型¶

5.12.1.模块¶

5.12.2.类和类实例¶

5.12.3.功能¶

5.12.4.方法¶

5.12.5.代码对象¶

5.12.6.类型对象¶

5.12.7.Null对象¶

5.12.8.省略号对象¶

5.12.9.未实现对象¶

5.12.10.布尔值¶

5.12.11.内部对象¶

5.13.特殊属性¶

目录

上一个主题

下一个主题

本页

5内置类型¶

5.1.真值测试¶

5.2.布尔运算-和,或,不¶

5.3.比较¶

5.4.数字类型-整数,浮动,长的,复杂的¶

5.4.1.整数类型的逐位运算¶

5.4.2.关于整数类型的其他方法¶

5.4.3.浮动的其他方法¶

5.5.迭代器类型¶

5.5.1.发电机类型¶

5.6.序列类型-字符串,unicode码,列表,元组,字节射线,缓冲器,润智¶

5.6.1.字符串方法¶

5.6.2.字符串格式操作¶

5.6.3.X范围类型¶

5.6.4.可变序列类型¶

5.7.设置类型-设置,冰冻的¶

5.8.映射类型-字典¶

5.8.1.字典视图对象¶

5.9.文件对象¶

5.10.内存视图类型¶

5.11.上下文管理器类型¶

5.12.其他内置类型¶

5.12.1.模块¶

5.12.2.类和类实例¶

5.12.3.功能¶

5.12.4.方法¶

5.12.5.代码对象¶

5.12.6.类型对象¶

5.12.7.Null对象¶

5.12.8.省略号对象¶

5.12.9.未实现对象¶

5.12.10.布尔值¶

5.12.11.内部对象¶

5.13.特殊属性¶

5.2.布尔运算-`和`,`或`,`不`¶

5.4.数字类型-`整数`,`浮动`,`长的`,`复杂的`¶

5.6.序列类型-`字符串`,`unicode码`,`列表`,`元组`,`字节射线`,`缓冲器`,`润智`¶

5.7.设置类型-`设置`,`冰冻的`¶

5.8.映射类型-`字典`¶