5. 内置类型

以下各节描述内置于解释器的标准类型。

历史上(直到2.2版的发布),Python 的内置类型不同于用户定义的类型,因为不可能用内置类型作为面向对象继承的基类。这种限制目前不再存在。

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

某些操作被几种对象类型支持;特别需要注意的是,几乎所有对象都可以比较、测试真值、转换为字符串(其实就是用repr()函数,或略有差异的str()函数来转换)。后者在对象使用print()函数写出时隐式地调用。

5.1. Truth Value Testing

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

  • None

  • False

  • 任何数值类型的零,例如,00L0.00j

  • 任何空的序列,例如, '' () []

  • 任何空的映射,例如,{}

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

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

除非另有说明,结果为布尔值的运算和内建函数总是返回0False表示假,1True表示真(重要的例外:布尔操作符orand始终返回它们的一个操作数。)

5.2. Boolean Operations — and, or, not

这些是布尔操作,按升序优先排序:

操作 结果
x or y 如果x为假,那么返回y,否则返回x (1)
x and y 如果x为假,那么返回x,否则返回y (2)
not x 如果x为假,那么返回True,否则返回False (3)

注:

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

5.3. Comparisons

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

下表汇总了比较操作:

操作 含义
< 严格地小于  
<= 小于或等于  
> 严格地大于  
>= 大于或等于  
== 等于  
!= 不等于 (1)
is 对象的ID  
is not 不同的对象ID  

注:

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

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

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

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

CPython 的实现细节:除数值以外不同类型的对象按它们的类型名称进行排序;不支持合适比较的相同类型的对象按它们的地址进行排序。

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

5.4. Numeric Types — int, float, long, complex

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

数字被创建数字文本或作为内置函数和运算符的结果。朴实无华的整数 (包括二进制、 十六进制和八进制数字) 除非它们表示的值太大,作为一个普通的整数,表示他们在这种情况下产生一个长整型,产生普通整数。整数带有'L''l'后缀产量 ('L'是首选,因为1 l看起来太像十一 !) 的长整数。数字的文本包含小数点或浮点数的指数符号率。'j''J'附加到数字的文字产生与零实部的复数。复杂的数字文字是真实和虚构的部分的总和。

Python 完全支持混合的算法: 当二元算术运算符具有不同的数值类型的操作数时,与"狭义"的类型操作数扩大到了其他的普通整数在哪里窄窄比浮点数比复杂窄长整数比。比较混合型数字之间使用相同的规则。[2]构造函数int () long() float()complex()可用于产生的一种特定类型的数字。

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

操作 结果
x + y xy  
x - y xy的差  
x * y xy的积  
x / y xy的商 (1)
x // y xy的(整除)商 (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) xy次方 (3)(7)
x ** y xy次方 (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 * 01,因为是很常见的编程语言。

All numbers.Real types (int, long, and float) also include the following operations:

操作 结果
math.trunc(x) x截取成整数  
round(x[, n]) x舍入到n位,实行四舍五入。如果n省略,默认为0。  
math.floor(x) 小于等于x的最大浮点整数  
math.ceil(x) 大于等于x的最小浮点整数  

5.4.1. 整数类型的位操作

整数的按位运算才有意义。负数被视为他们 2 补值 (这假定足够大量的操作过程中发生的没有溢出的位)。

二进制的位运算的优先事项是所有低于数值运算和高于比较 ;一元操作~具有相同的优先级的其他一元数字运算 (+-)。

此表列出了按优先级升序按位运算 (在同一个盒子中的操作具有相同的优先级):

操作 结果
x | y xy的按位  
x ^ y xy的按位异或  
x & y xy的按位  
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. 浮点数的其它方法

浮点类型实现自numbers.Real 抽象基类浮点数还具有以下的其它方法。

float.as_integer_ratio()

返回一对整数,它们的比例准确地等于浮点数的原始值,且分母为正数。无穷引发ValueError,NaNs引发OverflowError

2.6版中新增。

float.is_integer()

如果浮点数实例仅有整数,则返回True,否则返回False

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

2.6版中新增。

两种方法都支持与十六进制字符串的相互转换。由于Python的浮点数内部存储为二进制数,浮点数和十进制字符串通之间的相互转化通常会有一个小的舍入误差。与此相反的是,十六进制字符串能够精确表示浮点数。这在调试时和数值工作中很有用。

float.hex()

返回浮点数的十六进制字符串表示形式。对于有限的浮点数,这种表示形式总是包括一个前导的0x和尾部p及指数。

2.6版中新增。

float.fromhex(s)

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

2.6版中新增。

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

十六进制字符串的形式为:

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

可选的sign可以为+-integerfraction是十六进制数的字符串,exponent是带有可选的前导符号的十进制整数。大小写不敏感,且整数或小数至少有一个十六进制数字。此语法类似于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. Iterator Types

版本 2.2 新增。

Python 支持容器的迭代的概念。这被实施使用两种截然不同的方法 ;这些都用来允许用户定义的类,以支持迭代。序列,如下所述,在更多的细节,一如既往地支持迭代方法。

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

container.__iter__()

返回迭代器对象。该对象必须支持迭代器协议如下所述。如果一个容器支持不同类型的迭代,可以为这些迭代类型向具体要求迭代器提供额外的方法。(支持多种形式的迭代对象的一个示例会支持广度和深度优先遍历的树结构)。此方法对应于Python/C API中Python对象的类型结构的tp_iter 部分。

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

iterator.__iter__()

返回迭代器对象本身。这被需要,使容器和迭代器与的语句一起使用。此方法对应于 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. 生成器类型

发电机提供方便的方法来实现迭代器协议。如果作为一台发电机,实现了一个容器对象的__iter__()方法,它将自动返回迭代器对象 (从技术上讲,生成器对象) 提供的__iter__()next ()方法。发电机的更多信息可以发现有关产量表达式的文档中。

5.6. Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange

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

其他容器请参阅内建的dictset类,以及collections模块。

字符串常量写在单引号或双引号中:'xyzzy'"frobozz"See String literals for more about string literals. Unicode字符串与字符串非常相似,但是使用特殊的语法即一个前导的字符'u'指定:u'abc'u"def"In addition to the functionality described here, there are also string-specific methods described in the String Methods section. Lists are constructed with square brackets, separating items with commas: [a, b, c]. 元组通过逗号操作符构造(不在方括号中), 带或者不带圆括号,但是空元组必须具有圆括号,例如a, b, c()A single item tuple must have a trailing comma, such as (d,).

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

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

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

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

下标按优先级升序排列序列的操作(在相同格子中的操作具有相同的优先级)。在表中,st是类型相同的序列;nij是整数:

操作 结果
x in s True if an item of s is equal to x, else False (1)
x not in s False if an item of s is equal to x, else True (1)
s + t the concatenation of s and t (6)
s * n, n * s n shallow copies of s concatenated (2)
s[i] ith item of s, origin 0 (3)
s[i:j] slice of s from i to j (3)(4)
s[i:j:k] slice of s from i to j with step k (3)(5)
len(s) length of s  
min(s) smallest item of s  
max(s) largest item of s  
s.index(x) index of the first occurrence of x in s  
s.count(x) total number of occurrences of x in s  

序列类型还支持比较。特别是,将元组和列表比较字典,相应的元素进行比较。这意味着要比较结果相等,每个元素必须比较基于平等和两个序列必须具有相同的类型并具有相同的长度。(详情请参阅比较语言参考中。)

注释:

  1. s是一个字符串或 Unicode 字符串对象操作表现得像一个子字符串测试。在 Python 版本 2.3 之前, x必须是长度为 1 的字符串。在 Python 2.3 和超越, x可能任意长度的字符串。

  2. N小于0的值被视为0 (其中收益的类型相同的s序列为空)。此外注意到副本比较浅。嵌套结构的结构不会被复制。这常常困扰着新的 Python 程序员 ;请考虑:

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

    发生了什么事是那[[]]是一个包含一个空列表,所以[[]] * 3所有三个要素是 (指向) 的一个元素列表这单一的空列表。修改的任何列表元素修改此单的列表。这种方式你可以创建一个列表的不同列表:

    >>> lists = [[] for i in range(3)]
    >>> lists[0].append(3)
    >>> lists[1].append(5)
    >>> lists[2].append(7)
    >>> lists
    [[3], [5], [7]]
    
  3. 如果第一或j是负值,该索引值与字符串的结尾: len(s) + len(s) + j取代。但请注意, -0仍然是0

  4. Sij的切片定义为具有指数k项的序列, < = k < j如果第一或j大于len(s),使用len(s)如果省略或没有使用0如果省略了j没有使用len(s)如果大于或等于j该切片是空的。

  5. i到步骤k j s的切片定义为具有索引项的序列x = + n * k这样0 < = n < (j i) /k换句话说,第一 + k,以指数中,第一 + 2 * k第一 + 3 * k等等,在j达成 (但不是包括j) 时停止。如果第一或j大于len(s),使用len(s)如果省略了第一或j或他们没有成为"终结"值 (哪一端取决于k的标志)。请注意, k不能为零。如果kNone,它被视为1

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

    2.4 版本中的更改:从前,字符串串联永远不会发生的地方。

5.6.1. 字符串的方法

如下所列的字符串的方法,即 8 位字符串和 Unicode 对象支持。他们有些还可用bytearray对象上。

此外,Python 的字符串支持中所述的序列类型方法序列类型 — — str,unicode,列表、 元组、 bytearray,缓冲区,xrange节。要输出格式化的字符串使用模板字符串格式设置操作一节中描述的%运算符。请参阅重新模块,用于基于正则表达式的字符串函数。

str.capitalize()

返回字符串的副本,其第一个字符大写与小写的休息。

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

str.center(width[, fillchar])

返回字符串的长度宽度中居中。做了填充使用指定的fillchar (默认为一个空格)。

2.4 版本中的更改:Fillchar参数的支持。

str.count(sub[, start[, end]])

在 [启动结束] 范围内返回的子串的非重叠出现的次数。可选参数,开始结束都是解释为以切片表示法。

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

使用 encoding 中注册的编解码器,对字符串进行解码。编码默认为默认字符串的编码。错误可能会给以设置不同的错误处理方案。默认值是'严格',意思编码错误引发UnicodeError其他可能的值是'忽略' '替换'和通过codecs.register_error()注册的任何其他名称,请参阅编解码器基类

新版本 2.2 中的。

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

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

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

返回该字符串的已编码的版本。默认编码是当前默认字符串编码。错误可能会给以设置不同的错误处理方案。错误的默认值是'严格',意思编码错误引发的UnicodeError其他可能的值是'忽略' '替换' 'xmlcharrefreplace' 'backslashreplace'和通过codecs.register_error()注册的任何其他名称,请参阅编解码器基类可能的编码的列表,请参阅部分标准编码

版本 2.0 新增。

版本 2.3 中的更改: 'Xmlcharrefreplace''backslashreplace'和其他错误处理方案添加支持。

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

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

如果字符串以指定的suffix结尾则返回True,否则返回Falsesuffix也可以是一个元组。使用可选的启动,测试,从该位置开始。随着可选结束,停止在这一立场比较。

2.5 版本中的更改:接受作为后缀的元组。

str.expandtabs([tabsize])

返回一个字符串的副本,其中所有制表符由一个或多个空格替换,具体取决于当前列和给定的制表符大小。制表位位置发生每tabsize字符 (默认值为 8,给制表位位置在列 0,8,16,等等)。若要展开的字符串,当前的列被设置为零并检查字符串的字符。如果字符是一个选项卡 ( ),直到当前列等于下一个选项卡位置在结果中插入一个或多个空格字符。(制表符字符本身则不复制)。如果字符是换行符 ( ) 或返回 ( ),它复制,而且当前的列重置为零。任何其他字符被复制不变并且当前列递增一无论打印时字符的表示方式。

>>> '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 [开始: 结束]可选参数,开始结束都是解释为以切片表示法。如果未找到,则返回-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。

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

str.isspace()

如果有只有空白字符在字符串中,否则还有虚假的至少一个字符,则返回 true。

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

str.istitle()

如果字符串是标题类型的字符串且至少包含一个字符,则返回 true。例如:大写字符可能只能跟着非标题类(数字、符号和转义字符)的字符和小写字符。 否则返回 false。

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

str.isupper()

如果所有大小写敏感的字符[4]在字符串中都大写,并且嵌套中的至少一个字符,则返回 true;否则返回false。

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

str.join(iterable)

返回一个字符串,为iterable可迭代对象中字符串的连接。元素之间的分隔符是提供该方法的字符串。

str.ljust(width[, fillchar])

返回字符串的长度宽度中左对齐一个字符串。做了填充使用指定的fillchar (默认为一个空格)。如果width小于或等于len(s)则返回原始字符串。

2.4 版本中的更改:Fillchar参数的支持。

str.lower()

返回转换为小写字符串的所有套管井的字符[4]的副本。

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

str.lstrip([chars])

返回删除前导字符的字符串的副本。Chars参数是一个字符串,指定要移除的字符集。如果省略或没有 chars参数默认为删除空格。Chars参数不是一个前缀 ;相反,被剥夺了其值的所有组合:

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

2.2.2 版本中的更改:Chars参数的支持。

str.partition(sep)

分隔符首次出现位置拆分字符串,并返回包含分隔符之前部分、分隔符本身和分隔符之后部分的3元组。如果找不到分隔符,返回包含字符串本身,跟着两个空字符串的 3 元组。

新版本 2.5 中的。

str.replace(old, new[, count])

返回字符串的一个拷贝,其中所有的子串old通过new替换。如果指定了可选参数count,则只有前面的count个出现被替换。

str.rfind(sub[, start[, end]])

返回被搜索子串最后一次出现在字符串的索引位置, 字符串被搜索范围为[start:end]可选参数,开始结束都是解释为以切片表示法。失败返回-1

str.rindex(sub[, start[, end]])

类似rfind() ,但未找到子字符串时引发ValueError

str.rjust(width[, fillchar])

返回字符串的长度宽度中右对齐的字符串。做了填充使用指定的fillchar (默认为一个空格)。返回原始字符串宽度是否小于或等于len(s)

2.4 版本中的更改:Fillchar参数的支持。

str.rpartition(sep)

拆分 ( sep),最后一个匹配项的字符串,并返回包含分隔符,分隔符本身和部分之前的部分在分隔符之后的 3 元组。如果找不到分隔符,返回包含两个空字符串,后面跟有字符串本身的 3 元组。

新版本 2.5 中的。

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

在字符串中,使用sep作为分隔符字符串返回一个单词列表。如果给出了maxsplit ,顶多分裂为maxsplit+1个元素,从最右边开始。如果未指定sep没有任何空格的字符串是一个分隔符。除了从右边分裂, rsplit()split ()在下面详细描述。

在 2.4 版本新。

str.rstrip([chars])

返回一个移去尾部字符后的字符串的拷贝。Chars参数是一个字符串,指定要移除的字符集。如果省略或没有 chars参数默认为删除空格。Chars参数不是一个后缀 ;相反,被剥夺了其值的所有组合:

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

2.2.2 版本中的更改:Chars参数的支持。

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

Return a list of the words in the string, using sep as the delimiter string. 如果给出maxsplitmaxsplit拆分顶多做 (因此,列表中将有最多maxsplit + 1的元素)。如果没有指定maxsplit ,则或为-1,然后还有的分割 (所有可能分裂由) 的数量没有限制。

如果给定了sep ,连续分隔符不组合在一起,并被视为空字符串进行分隔 (例如, ' 1,,2'.split(',')返回['1' ', '2'])。Sep参数可能由多个字符组成 (例如, 1 <> 2 <> 3'.split ('<> ')返回['1', '2' '3'])。用指定的分隔符劈空字符串返回[']

如果sep不指定或者,采用一种不同的分裂算法: 运行连续的空格被视为一个单一的分隔符,和结果将包含没有开始或结尾的空字符串,如果该字符串有前导或尾随空白。因此,分隔符拆分为空字符串或只是空白由组成的字符串返回[]

例如, ' 1 2 3 '.split()返回['1' '2' '3'],和' 1 2 3 '.split (忠县 1)返回['1' 2 3 ']

str.splitlines([keepends])

在字符串中,打破在行边界返回行的列表。此方法使用劈裂线的通用换行符方法。换行符不包含在结果列表中,除非keepends是给定和真实。

例如, ' ab c de fg kl'.splitlines()返回['ab c', ', 'de fg', 'kl'],而与splitlines(True)相同的调用返回['ab c ', ' ', ' de fg', ' kl'].

不同split ()当分隔符字符串sep给定的此方法返回一个空的列表为空字符串,和终端的换行符不会导致额外的一行。

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

如果字符串以prefix开头则返回True,否则返回Falseprefix也可以是一个需要查找的前缀元组。可选的start表示从该位置开始测试字符串。可选的end表示在该位置停止字符串比较。

2.5 版本中的更改:接受元组作为prefix

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

返回一个 titlecased 版本的地方以大写字符开头的单词并剩余的字符是小写的字符串。

该算法利用一个简单的独立语言定义的一句话作为连续的字母组。定义在很多情况下工作,但它意味着撇号在收缩和所有格构成词的边界,这可能不是预期的结果:

>>> "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 的副本。

可以使用字符串模块中的maketrans() helper 函数以创建一个翻译表。对于字符串对象,将参数设置为None只删除字符的翻译:

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

新在 2.6 版本:Support for a None table argument.

对于 Unicode 对象, translate()方法不接受可选的deletechars参数。相反,它将返回s的一个副本的所有字符将已被都映射,将会通过给定的翻译表必须映射到 Unicode 序数,Unicode 字符串或没有Unicode 序号。未映射的字符是原封不动的。字符映射到没有被删除。请注意,更灵活的方法是创建自定义字符映射编解码器使用编解码器模块 (见encodings.cp1251为例)。

str.upper()

返回字符串的一个拷贝,其中所有大小写有区别的字符[4]转换为大写。注意,str.upper().isupper()可能为False如果s不包含大小写有区别的字符或生成的字符的Unicode类别不是"Lu"(大写字母)而是"Lt"(首字母大写)。

对于8比特字符串,此方法依赖于区域设置。

str.zfill(width)

在数值字符串的左边填充零至长度为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对象有一个独特的内置操作:%(取模)操作符。这也被称为字符串格式化插值操作符。给出format % values(其中format是字符串或Unicode对象),转换规范format中的%转换说明被替换为values的零个或多个元素。效果类似于C语言中使用的sprintf()如果format是一个Unicode对象,或者正在使用进行转换的任何对象是Unicode对象,结果也将是一个Unicode对象。

如果format需要一个单一的参数,values可以是一个单个的非元组对象。[5]否则,values必须是一个元组且其元素个数与格式字符串指定的完全相同,或者是一个单一的映射对象(例如,一个字典)。

转换说明符包含两个或多个字符并具有以下组件,必须按以下顺序发生:

  1. '%'字符,它标记指示符的起点。
  2. 映射的键(可选),由圆括号括起来的字符序列组成(例如,(somename))。
  3. 转换的标志(可选),它们影响某些转换类型的结果。
  4. 字段最小的宽度(可选)。如果用'*'(星号)表示,则真正的宽度从元组values中下一个元素读取,字段最小宽度值后面的是将要转换的对象和可选的精度。
  5. 精度(可选),用'.'(点号)后面跟上精度给出。如果用'*'(星号)表示,真正的宽度从元组values中的下一个元素读取,精度后面的是将要转换的值。
  6. 长度调整器(可选)。
  7. 转换的类型。

当右侧参数是一个字典(或其它映射类型)时,那么字符串中的formats必须包含一个圆括号括起来的键,其来自于%字符后立即插入的那个字典。映射的键从映射中选择要格式化的值。举个例子:

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

在这种情况下format中不可以出现*指示符(因为它们需要一个连续的参数列表)。

转换标志字符包括:

Flag Meaning
'#' 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).

长度修饰符 (h lL) 可能存在,但将被忽略,因为它不是 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

Since Python strings have an explicit length, %s conversions do not assume that '' is the end of the string.

2.7 版本中的更改: %f转换为数字的绝对值是在 1e50 不再取而代之%g转换的影响。

在标准模块的字符串重新定义额外的字符串操作。

5.6.3. XRange Type

Xrange类型是不可变的序列,这常用的循环。 Xrange类型的好处是内存的xrange对象将始终以相同数量,无论区域的大小,它代表着。没有一致的性能优势。

XRange 对象具有很少的行为: 他们仅支持索引、 迭代和len()函数。

5.6.4. Mutable Sequence Types

列表和bytearray对象支持允许就地修改该对象的附加操作。其他可变有序类型 (在添加到语言) 时也应支持这些操作。字符串和元组是不可变的序列类型: 这类物体不能修改一旦创建。在可变有序类型 (其中x是一个任意的对象) 上定义的以下操作:

Operation Result Notes
s[i] = x item i of s is replaced by 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] same as 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) same as s[len(s):len(s)] = [x] (2)
s.extend(x) same as s[len(s):len(s)] = x (3)
s.count(x) return number of i‘s for which s[i] == x  
s.index(x[, i[, j]]) return smallest k such that s[k] == x and i <= k < j (4)
s.insert(i, x) same as s[i:i] = [x] (5)
s.pop([i]) same as x = s[i]; del s[i]; return x (6)
s.remove(x) same as 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. 历史上Python的C实现接受多个参数并隐式地将它们组合成一个元组;Python 2.0不再这样。自Python 1.4已经弃用这个错误的设计。

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

  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,则列表元素以相反的方式排序。

    一般情况下,keyreverse转换的过程比指定等效的cmp函数快得多。这是因为cmp对于每个列表元素调用多次,而keyreverse对每个元素只调用一次。使用functools.cmp_to_key()可以将旧式的cmp函数转换成一个key函数。

    版本 2.3 中的更改:添加支持省略cmp,并使用None代替。

    2.4 版本中的更改:添加对keyreverse的支持。

  9. 从Python 2.3开始, sort()方法被保证是稳定的。排序是稳定的,如果它保证不会改变比较结果相等的元素的相对顺序 — 这在依据多个途径进行排序时非常有用 (例如,先根据部门然后根据薪酬等级排序)。

  10. CPython 的实现细节:当列表正在排序时,对列表进行改变甚至是检查的效果是未定义的。Python 2.3和更新版本的C实现和使列表在这段时间里看上去是空的,且如果它可以检测到列表在排序期间已改变会引发ValueError

5.7. Set Types — set, frozenset

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

在 2.4 版本新。

像其他收藏集中,设置支持x 设置 len(set),以及 x 设置作为一个无序的集合,集不记录元素位置或者插入顺序。因此,集不支持索引、 切片、 或其他类似于序列的行为。

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

到 Python 2.7 通过放置一个逗号分隔的列表的大括号内的元素,例如可以创建非空集合 (而不是 frozensets): {'杰克' 'sjoerd'},除了设置构造函数之外。

这两个类的构造函数的工作,同时:

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

返回新的集或 frozenset 对象,将其元素取自可迭代集合的元素必须是hashable若要表示套套,内部集必须是frozenset对象。如果可迭代是未指定,则返回新的空集。

设置frozenset的实例提供以下操作:

len(s)

返回的集合基数。

x in s

s中测试x为会员。

x not in s

s中测试x为非会员。

isdisjoint(other)

如果该集合与其他任何元素,则返回True 集是不相交的当且仅当它们的交集是空集。

在 2.6 版本新。

issubset(other)
set <= other

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

set < other

测试集是否其他的一个子集,即设置 < = 其他设置 ! = 其他

issuperset(other)
set >= other

测试中其他每个元素是否在集合中。

set > other

测试集是否真超集的其他,那就是,设置 > = 其他设置 ! = 其他

union(other, ...)
set | other | ...

返回从集和所有其他人的一套新的元素。

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

intersection(other, ...)
set & other & ...

返回一组新元素共同集和所有其他人。

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

difference(other, ...)
set - other - ...

不是在别人的集合中返回一套新的元素。

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

symmetric_difference(other)
set ^ other

集或其他,但不是能同时在要么返回一套新的元素。

copy()

返回一组新的浅表副本的s

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

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

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

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

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

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

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

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

update(other, ...)
set |= other | ...

更新集合,添加所有来自其他集合的元素。

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

intersection_update(other, ...)
set &= other & ...

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

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

difference_update(other, ...)
set -= other | ...

更新集合,删除与其他集合共有的元素。

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

symmetric_difference_update(other)
set ^= other

更新集合,仅保留集合和other等其他集合的对称差集。

add(elem)

添加元素elem到集合。

remove(elem)

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

discard(elem)

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

pop()

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

clear()

从集合中移除所有元素。

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

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

请参见

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

5.8. Mapping Types — dict

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

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

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

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

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

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

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

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

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

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

2.2版中新增。

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

下面都是字典支持的操作(因此,自定义的映射类型也应该支持):

len(d)

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

d[key]

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

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

d[key] = value

设置d[key]的值为value

del d[key]

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

key in d

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

2.2版中新增。

key not in d

相当于not key in d

2.2版中新增。

iter(d)

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

clear()

从字典中移除所有项。

copy()

返回字典的一个浅拷贝。

fromkeys(seq[, value])

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

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

2.3版中新增。

get(key[, default])

如果key在字典中,则返回key对应的值,后者返回default如果default不给出,则它默认为None,所以此方法永远不会引发KeyError

has_key(key)

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

items()

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

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

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

iteritems()

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

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

2.2版中新增。

iterkeys()

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

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

2.2中新增。

itervalues()

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

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

2.2版中新增。

keys()

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

pop(key[, default])

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

2.3版中新增。

popitem()

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

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

setdefault(key[, default])

如果key在字典中,返回其值。如果不在,则插入值为defaultkey并返回defaultdefault默认为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版中新增。

5.8.1. Dictionary view objects

dict.viewkeys() dict.viewvalues()dict.viewitems()返回的对象的视图对象他们提供一个动态视图的字典条目,这意味着当这本词典更改时,视图会反映出这些变化。

可以遍历字典视图产生他们各自的数据,并支持会员测试:

len(dictview)

在字典中返回条目的数。

iter(dictview)

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

键和值迭代的顺序是任意的但非随机,因Python的实现而异,取决于字典插入和删除操作的历史。如果键、值和项的视图的遍历过程中不对字典作任何修改,项的顺序将始终一致。这允许使用zip()创建(value, key)对:pairs = zip(d.values(), d.keys())另一种创建相同列表的方式是pairs = [(v, k) for (k, v) in d.items()]

迭代视图过程中添加或删除字典中的项可能引发RuntimeError或遍历所有条目失败 。

x in dictview

返回True,如果x在底层字典的键、值或项中(在后者的情况下,x应该是(key, value)元组)。

键视图很像集合,因为它们的条目是唯一且可哈希的。如果所有的值都是可哈希的,那么(key, value) 对就是唯一且可哈希的,那么项目视图也类似集合。(值视图不被作为类似集合的因为它们的条目通常不是唯一的。)那么下面这些集合的操作也可用("other"是指另外一个视图或集合):

dictview & other

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

dictview | other

返回dictview和其它对象的并集作为一个新的集合。

dictview - other

返回dictview和其它对象的差(所有在dictview中但不在other中的元素)作为一个新的集合。

dictview ^ other

返回dictview和另一个对象的对称差(在dictviewother中,但不是在两个中都存在的所有元素)作为一个新的集合。

字典视图用法的一个示例:

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

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

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

文件具有以下方法:

file.close()

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

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

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

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

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

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

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

file.flush()

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

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

file.fileno()

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

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

file.isatty()

返回True如果文件连接到一个(类)tty的设备,否则返回False

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

file.next()

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

新版本 2.3。

file.read([size])

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

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

file.readline([size])

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

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

file.readlines([sizehint])

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

file.xreadlines()

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

2.1 版中的新增。

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

file.seek(offset[, whence])

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

例如,f.seek( 2, os.SEEK_CUR)的当前位置提升 2 和f. seek( -3, os.SEEK_END)将位置设置为倒数第三。

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

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

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

file.tell()

返回文件的当前位置,类似stdioftell()

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

file.truncate([size])

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

file.write(str)

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

file.writelines(sequence)

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

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

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

file.closed

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

file.encoding

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

新版本 2.3。

file.errors

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

在 2.6 版本的新特性

file.mode

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

file.name

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

file.newlines

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

file.softspace

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

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

5.10. memoryview type

2.7版中新增。

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

class memoryview(obj)

创建引用objmemoryview obj必须支持缓冲区的协议。支持缓冲区协议的内置对象包括strbytearray(但没有unicode)。

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

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

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

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

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

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

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

memoryview有两个方法:

tobytes()

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

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

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

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

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

format

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

itemsize

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

shape

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

ndim

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

strides

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

readonly

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

5.11. Context Manager Types

新版本 2.5 中的。

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

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

contextmanager.__enter__()

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

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

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

contextmanager.__exit__(exc_type, exc_val, exc_tb)

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

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

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

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

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

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

5.12. 其它的内建类型

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

5.12.1. 模块

唯一特殊的模块上操作属性访问权限: m.name,其中m是一个模块,名称访问m符号表中定义的名称。模块属性可以分配给。(请注意import语句,严格地说,不是模块对象上的一个操作;导入 foo不需要模块对象名为foo存在,相反,它需要 (外部) 的定义为一个名为foo某个模块)。

每个模块一个特殊属性是__dict__这是字典,它包含该模块的符号表。修改这个字典实际上将会修改该模块的符号表,但不能直接赋值给__dict__属性(你可以写m.__dict__ ['a'] = 1,它定义m.a1,但是你不可以写成m.__dict__ = {})。建议您不要直接修改__dict__

模块内置于解释器这样写: < 模块 sys (内置) >如果从文件中加载,他们都写成< 模块 os ' / 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, 参数 2, ......, arg n)

类的实例方法的绑定未绑定,指的是否访问的方法是通过一个实例或类,分别。当一个方法是未绑定的时,其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属性的函数对象中提取。请参阅代码模块。

代码对象可以执行,或者通过将它 (而不是源字符串) 传递给exec语句或内置eval ()函数计算。

更多的信息,请参阅标准类型层次结构

5.12.6. 类型对象

类型对象代表不同的对象类型。通过内置函数type()访问对象的类型。没有特别的操作类型。标准模块类型定义所有标准的内置类型的名称。

类型这样写: < 类型 int >

5.12.7. Null 对象

此对象被经由不显式返回值的函数。它支持任何特殊的操作。还有一个空对象,名为(内置名称)。

这是写为None

5.12.8. Ellipsis 对象

此对象使用扩展的切片表示法 (见分片)。它支持任何特殊的操作。有是一个省略号对象,名叫省略号(内置名称)。

这是写作为省略号当在下标,它也可以写为...,例如seq [......]

5.12.9. NotImplemented 对象

当比较和二元操作被要求操作它们不支持的类型时,返回该对象。更多的信息,请参阅比较操作

它写成NotImplemented

5.12.10. 布尔值

布尔值是两个常量对象FalseTrue它们用来表示真值(尽管其它值也可以被认为是假或者是真)。在数字上下文中(例如,用作算术运算符的参数时),它们的行为分别像整数0和1。内置函数bool()可用于将任何值转换为一个布尔值,如果值可以解释为真值(见上面真值的测试一节)。

它们分别写成FalseTrue

5.12.11. 内部对象

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

5.13. Special Attributes

执行将几个特殊的只读属性添加到几种对象类型,他们在哪里有关。其中一些不会被dir()内置函数显示。

object.__dict__

一本字典或其他绘图对象,该对象用于存储对象 (写) 属性。

object.__methods__

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

object.__members__

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

instance.__class__

类属于一个类实例。

class.__bases__

此元组的基类的类对象。

class.__name__

类或类型的名称。

新样式类es 仅支持以下属性。

class.__mro__

此属性是一个元组时寻找基类,这些类在方法解析过程中考虑到的类。

class.mro()

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

class.__subclasses__()

每个新样式类保留对其立即子类的弱引用的列表。此方法返回所有这些引用的列表还活着。示例:

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

脚注

[1]Additional information on these special methods may be found in the Python Reference Manual (Basic customization).
[2]As a consequence, the list [1, 2] is considered equal to [1.0, 2.0], and similarly for tuples.
[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!).