4. 内置类型 ¶

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

主要内置类型，包括：数值、序列、映射、类、实例及异常。

某些集合类是可变的。添加、减去或原位重新排列其成员且不返回特定项的方法，从不返回集合实例本身而是 None .

某些操作支持几种对象类型；尤其，实际上所有对象都可以被比较、测试真值及转换为字符串 (采用 repr() 函数或稍微不同的 str() 函数)。隐式使用后一函数当对象写入通过 print() 函数。

4.1. 真值测试 ¶

可以测试任何对象的真值，对于用于 if or while condition or as operand of the Boolean operations below. The following values are considered false:

None
False
任何数值类型的零，例如， 0 , 0.0 , 0j .
任何空序列，例如， '' , () , [] .
任何空映射，例如， {} .
用户定义类的实例，若类定义 __bool__() or __len__() 方法，当该方法返回整数 0 或 bool 值 False . [1]

所有其它值被认为是 True — 因此，许多类型的对象始终为 True。

拥有 Boolean (布尔) 结果的运算和内置函数始终返回 0 or False 对于 false 和 1 or True 对于 true，除非另有说明 (重要例外：布尔运算 or and and 始终返回它们的操作数之一)。

4.2. 布尔运算 — `and` , `or` , `not` ¶

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

操作	结果	注意事项
`x or y`	if x 为 False，那么 y ，否则 x	(1)
`x and y`	if x 为 False，那么 x ，否则 y	(2)
`not x`	if x 为 False，那么 `True` , else `False`	(3)

注意事项：

This is a short-circuit operator, so it only evaluates the second argument if the first one is False .
This is a short-circuit operator, so it only evaluates the second argument if the first one is True .
not 拥有比非布尔运算符更低的优先级，所以 not a == b is interpreted as not (a == b) ，和 a == not b 是句法错误。

4.3. 比较 ¶

Python 中存在 8 种比较操作。它们拥有相同优先级 (高于布尔运算)。比较可以任意连锁；例如， x < y <= z 相当于 x < y and y <= z ，除了 y 只评估 1 次 (但在 2 种情况下， z 根本不评估当 x < y 被发现为 False)。

此表汇总了比较操作：

操作	含义
`<`	严格小于
`<=`	小于等于
`>`	严格大于
`>=`	大于等于
`==`	equal
`!=`	不等于
`is`	对象身份
`is not`	否定对象身份

Objects of different types, except different numeric types, never compare equal. Furthermore, some types (for example, function objects) support only a degenerate notion of comparison where any two objects of that type are unequal. The < , <= , > and >= operators will raise a TypeError exception when comparing a complex number with another built-in numeric type, when the objects are of different types that cannot be compared, or in other cases where there is no defined ordering.

Non-identical instances of a class normally compare as non-equal unless the class defines the __eq__() 方法。

Instances of a class cannot be ordered with respect to other instances of the same class, or other types of object, unless the class defines enough of the methods __lt__() , __le__() , __gt__() ，和 __ge__() (一般而言， __lt__() and __eq__() are sufficient, if you want the conventional meanings of the comparison operators).

行为对于 is and is not 操作符无法定制；还可以将它们应用于任何 2 对象，且从不引发异常。

另外，具有相同句法优先级的 2 操作 in and not in , are supported only by sequence types (below).

4.4. 数值类型 — `int` , `float` , `complex` ¶

有 3 种截然不同的数值类型： integers , 浮点数 ，和复数 . In addition, Booleans are a subtype of integers. Integers have unlimited precision. Floating point numbers are usually implemented using double in C; information about the precision and internal representation of floating point numbers for the machine on which your program is running is available in sys.float_info . Complex numbers have a real and imaginary part, which are each a floating point number. To extract these parts from a complex number z ，使用 z.real and z.imag . (The standard library includes additional numeric types, fractions that hold rationals, and decimal that hold floating-point numbers with user-definable precision.)

Numbers are created by numeric literals or as the result of built-in functions and operators. Unadorned integer literals (including hex, octal and binary numbers) yield integers. Numeric literals containing a decimal point or an exponent sign yield floating point numbers. Appending 'j' or 'J' to a numeric literal yields an imaginary number (a complex number with a zero real part) which you can add to an integer or float to get a complex number with real and imaginary parts.

Python fully supports mixed arithmetic: when a binary arithmetic operator has operands of different numeric types, the operand with the “narrower” type is widened to that of the other, where integer is narrower than floating point, which is narrower than complex. Comparisons between numbers of mixed type use the same rule. [2] 构造函数 int() , float() ，和 complex() 可用于产生特定类型的数字。

All numeric types (except complex) support the following operations, sorted by ascending priority (all numeric operations have a higher priority than comparison operations):

操作	结果	注意事项	完整文档编制
`x + y`	和对于 x and y
`x - y`	difference of x and y
`x * y`	乘积对于 x and y
`x / y`	quotient of x and y
`x // y`	floored quotient of x and y	(1)
`x % y`	余数对于 `x / y`	(2)
`-x`	x negated
`+x`	x unchanged
`abs(x)`	absolute value or magnitude of x		`abs()`
`int(x)`	x 被转换成整数	(3)(6)	`int()`
`float(x)`	x 被转换成浮点数	(4)(6)	`float()`
`complex(re, im)`	a complex number with real part re , imaginary part im . im defaults to zero.	(6)	`complex()`
`c.conjugate()`	conjugate of the complex number c
`divmod(x, y)`	对 `(x // y, x % y)`	(2)	`divmod()`
`pow(x, y)`	x 到幂 y	(5)	`pow()`
`x ** y`	x 到幂 y	(5)

注意事项：

Also referred to as integer division. The resultant value is a whole integer, though the result’s type is not necessarily int. The result is always rounded towards minus infinity: 1//2 is 0 , (-1)//2 is -1 , 1//(-2) is -1 ，和 (-1)//(-2) is 0 .
不适用于复数。相反，转换为浮点数使用 abs() 若合适。
Conversion from floating point to integer may round or truncate as in C; see functions math.floor() and math.ceil() for well-defined conversions.
float also accepts the strings “nan” and “inf” with an optional prefix “+” or “-” for Not a Number (NaN) and positive or negative infinity.
Python 定义 pow(0, 0) and 0 ** 0 到 1 , as is common for programming languages.
The numeric literals accepted include the digits 0 to 9 or any Unicode equivalent (code points with the Nd 特性)。

见 http://www.unicode.org/Public/6.3.0/ucd/extracted/DerivedNumericType.txt for a complete list of code points with the Nd 特性。

所有 numbers.Real 类型 ( int and float ) 还包括以下操作：

操作	结果	注意事项
`math.trunc(x)`	x truncated to Integral
`round(x[, n])`	x rounded to n digits, rounding half to even. If n is omitted, it defaults to 0.
`math.floor(x)`	the greatest integral float <= x
`math.ceil(x)`	the least integral float >= x

其它数值运算，见 math and cmath 模块。

4.4.1. 整数类型的按位运算 ¶

Bitwise operations only make sense for integers. Negative numbers are treated as their 2’s complement value (this assumes a sufficiently large number of bits that no overflow occurs during the operation).

The priorities of the binary bitwise operations are all lower than the numeric operations and higher than the comparisons; the unary operation ~ 具有相同优先级，如同其它一元数值运算 ( + and - ).

此表按优先级升序排序，列出按位运算：

操作	结果	注意事项
`x \| y`	bitwise or of x and y
`x ^ y`	bitwise exclusive or of x and y
`x & y`	bitwise and of x and y
`x << n`	x shifted left by n bits	(1)(2)
`x >> n`	x shifted right by n bits	(1)(3)
`~x`	the bits of x inverted

注意事项：

负移位计数是非法的，并会导致 ValueError 要被引发。
向左移位 n 位，相当于乘以 pow(2, n) 没有溢出校验。
向右移位 n 位，相当于除以 pow(2, n) without overflow check.

4.4.2. 额外整数类型方法 ¶

int 类型实现 numbers.Integral 抽象基类。此外，它还提供一些其它方法：

int. bit_length ( ) ¶

int. to_bytes ( length , byteorder , * , signed=False ) ¶

classmethod int. from_bytes ( bytes , byteorder , * , signed=False ) ¶

4.4.3. 额外浮点方法 ¶

浮点类型实现 numbers.Real 抽象基类 . float also has the following additional methods.

float. as_integer_ratio ( ) ¶

float. is_integer ( ) ¶

Two methods support conversion to and from hexadecimal strings. Since Python’s floats are stored internally as binary numbers, converting a float to or from a decimal string usually involves a small rounding error. In contrast, hexadecimal strings allow exact representation and specification of floating-point numbers. This can be useful when debugging, and in numerical work.

float. hex ( ) ¶

classmethod float. fromhex ( s ) ¶

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

A hexadecimal string takes the form:

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

其中可选 sign may by either + or - , integer and fraction are strings of hexadecimal digits, and exponent is a decimal integer with an optional leading sign. Case is not significant, and there must be at least one hexadecimal digit in either the integer or the fraction. This syntax is similar to the syntax specified in section 6.4.4.2 of the C99 standard, and also to the syntax used in Java 1.5 onwards. In particular, the output of float.hex() is usable as a hexadecimal floating-point literal in C or Java code, and hexadecimal strings produced by C’s %a format character or Java’s Double.toHexString are accepted by float.fromhex() .

Note that the exponent is written in decimal rather than hexadecimal, and that it gives the power of 2 by which to multiply the coefficient. For example, the hexadecimal string 0x3.a7p10 represents the floating-point number (3 + 10./16 + 7./16**2) * 2.0**10 ，或 3740.0 :

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

Applying the reverse conversion to 3740.0 gives a different hexadecimal string representing the same number:

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

4.4.4. 数值类型的哈希 ¶

For numbers x and y , possibly of different types, it’s a requirement that hash(x) == hash(y) whenever x == y (见 __hash__() method documentation for more details). For ease of implementation and efficiency across a variety of numeric types (including int , float , decimal.Decimal and fractions.Fraction ) Python’s hash for numeric types is based on a single mathematical function that’s defined for any rational number, and hence applies to all instances of int and fractions.Fraction , and all finite instances of float and decimal.Decimal . Essentially, this function is given by reduction modulo P for a fixed prime P . The value of P is made available to Python as the modulus attribute of sys.hash_info .

CPython 实现细节： 目前，使用的素数是 P = 2**31 - 1 on machines with 32-bit C longs and P = 2**61 - 1 on machines with 64-bit C longs.

这里是详细规则：

若 x = m / n is a nonnegative rational number and n is not divisible by P , define hash(x) as m * invmod(n, P) % P ，其中 invmod(n, P) gives the inverse of n 模 P .
若 x = m / n is a nonnegative rational number and n is divisible by P (但 m is not) then n has no inverse 模 P and the rule above doesn’t apply; in this case define hash(x) to be the constant value sys.hash_info.inf .
若 x = m / n is a negative rational number define hash(x) as -hash(-x) 。若结果哈希为 -1 ，替换它采用 -2 .
The particular values sys.hash_info.inf , -sys.hash_info.inf and sys.hash_info.nan are used as hash values for positive infinity, negative infinity, or nans (respectively). (All hashable nans have the same hash value.)
对于 complex 编号 z , the hash values of the real and imaginary parts are combined by computing hash(z.real) + sys.hash_info.imag * hash(z.imag) , reduced modulo 2**sys.hash_info.width so that it lies in range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)) . Again, if the result is -1 , it’s replaced with -2 .

To clarify the above rules, here’s some example Python code, equivalent to the built-in hash, for computing the hash of a rational number, float ，或 complex :

import sys, math
def hash_fraction(m, n):
    """Compute the hash of a rational number m / n.
    Assumes m and n are integers, with n positive.
    Equivalent to hash(fractions.Fraction(m, n)).
    """
    P = sys.hash_info.modulus
    # Remove common factors of P.  (Unnecessary if m and n already coprime.)
    while m % P == n % P == 0:
        m, n = m // P, n // P
    if n % P == 0:
        hash_ = sys.hash_info.inf
    else:
        # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
        # pow(n, P-2, P) gives the inverse of n modulo P.
        hash_ = (abs(m) % P) * pow(n, P - 2, P) % P
    if m < 0:
        hash_ = -hash_
    if hash_ == -1:
        hash_ = -2
    return hash_
def hash_float(x):
    """Compute the hash of a float x."""
    if math.isnan(x):
        return sys.hash_info.nan
    elif math.isinf(x):
        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
    else:
        return hash_fraction(*x.as_integer_ratio())
def hash_complex(z):
    """Compute the hash of a complex number z."""
    hash_ = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # do a signed reduction modulo 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    hash_ = (hash_ & (M - 1)) - (hash & M)
    if hash_ == -1:
        hash_ == -2
    return hash_

4.5. 迭代器类型 ¶

Python supports a concept of iteration over containers. This is implemented using two distinct methods; these are used to allow user-defined classes to support iteration. Sequences, described below in more detail, always support the iteration methods.

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

container. __iter__ ( ) ¶

The iterator objects themselves are required to support the following two methods, which together form the 迭代器协议 :

iterator. __iter__ ( ) ¶

iterator. __next__ ( ) ¶

Python defines several iterator objects to support iteration over general and specific sequence types, dictionaries, and other more specialized forms. The specific types are not important beyond their implementation of the iterator protocol.

一旦迭代器的 __next__() 方法引发 StopIteration , it must continue to do so on subsequent calls. Implementations that do not obey this property are deemed broken.

4.5.1. 生成器类型 ¶

Python 的 generator s provide a convenient way to implement the iterator protocol. If a container object’s __iter__() method is implemented as a generator, it will automatically return an iterator object (technically, a generator object) supplying the __iter__() and __next__() methods. More information about generators can be found in the documentation for the yield expression .

4.6. 序列类型 — `list` , `tuple` , `range` ¶

There are three basic sequence types: lists, tuples, and range objects. Additional sequence types tailored for processing of 二进制数据 and 文本字符串 are described in dedicated sections.

4.6.1. 常见序列操作 ¶

The operations in the following table are supported by most sequence types, both mutable and immutable. The collections.abc.Sequence ABC is provided to make it easier to correctly implement these operations on custom sequence types.

This table lists the sequence operations sorted in ascending priority. In the table, s and t are sequences of the same type, n , i , j and k are integers and x is an arbitrary object that meets any type and value restrictions imposed by s .

The in and not in operations have the same priorities as the comparison operations. The + (concatenation) and * (repetition) operations have the same priority as the corresponding numeric operations.

操作	结果	注意事项
`x in s`	`True` if an item of s is 等于 x ，否则 `False`	(1)
`x not in s`	`False` if an item of s is 等于 x ，否则 `True`	(1)
`s + t`	the concatenation of s and t	(6)(7)
`s * n` or `n * s`	equivalent to adding s to itself n times	(2)(7)
`s[i]`	i th 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[, i[, j]])`	index of the first occurrence of x in s (at or after index i and before index j )	(8)
`s.count(x)`	total number of occurrences of x in s

Sequences of the same type also support comparisons. In particular, tuples and lists are compared lexicographically by comparing corresponding elements. This means that to compare equal, every element must compare equal and the two sequences must be of the same type and have the same length. (For full details see 比较 in the language reference.)

注意事项：

While the in and not in operations are used only for simple containment testing in the general case, some specialised sequences (such as str , bytes and bytearray ) also use them for subsequence testing:
```
>>> "gg" in "eggs"
True
							
```
Values of n less than 0 are treated as 0 (which yields an empty sequence of the same type as s ). Note that items in the sequence s are not copied; they are referenced multiple times. This often haunts new Python programmers; consider:
```
>>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]
							
```
What has happened is that [[]] is a one-element list containing an empty list, so all three elements of [[]] * 3 are references to this single empty list. Modifying any of the elements of lists modifies this single list. You can create a list of different lists this way:
```
>>> lists = [[] for i in range(3)]
>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]
							
```
Further explanation is available in the FAQ entry How do I create a multidimensional list? .
若 i or j is negative, the index is relative to the end of the string: len(s) + i or len(s) + j is substituted. But note that -0 仍然是 0 .
The slice of s from i to j is defined as the sequence of items with index k 这样 i <= k < j 。若 i or j 大于 len(s) ，使用 len(s) 。若 i 被省略或 None ，使用 0 。若 j 被省略或 None ，使用 len(s) 。若 i >= j , the slice is empty.
The slice of s from i to j with step k is defined as the sequence of items with index x = i + n*k 这样 0 <= n < (j-i)/k . In other words, the indices are i , i+k , i+2*k , i+3*k and so on, stopping when j is reached (but never including j )。若 i or j 大于 len(s) ，使用 len(s) 。若 i or j are omitted or None , they become “end” values (which end depends on the sign of k ). Note, k cannot be zero. If k is None , it is treated like 1 .
Concatenating immutable sequences always results in a new object. This means that building up a sequence by repeated concatenation will have a quadratic runtime cost in the total sequence length. To get a linear runtime cost, you must switch to one of the alternatives below:
- if concatenating str objects, you can build a list and use str.join() at the end or else write to an io.StringIO instance and retrieve its value when complete
- if concatenating bytes objects, you can similarly use bytes.join() or io.BytesIO , or you can do in-place concatenation with a bytearray 对象。 bytearray objects are mutable and have an efficient overallocation mechanism
- if concatenating tuple objects, extend a list 代替
- for other types, investigate the relevant class documentation
Some sequence types (such as range ) only support item sequences that follow specific patterns, and hence don’t support sequence concatenation or repetition.
index 引发 ValueError 当 x 找不到在 s . When supported, the additional arguments to the index method allow efficient searching of subsections of the sequence. Passing the extra arguments is roughly equivalent to using s[i:j].index(x) , only without copying any data and with the returned index being relative to the start of the sequence rather than the start of the slice.

4.6.2. 不可变序列类型 ¶

The only operation that immutable sequence types generally implement that is not also implemented by mutable sequence types is support for the hash() 内置。

This support allows immutable sequences, such as tuple instances, to be used as dict keys and stored in set and frozenset 实例。

Attempting to hash an immutable sequence that contains unhashable values will result in TypeError .

4.6.3. 可变序列类型 ¶

The operations in the following table are defined on mutable sequence types. The collections.abc.MutableSequence ABC is provided to make it easier to correctly implement these operations on custom sequence types.

In the table s is an instance of a mutable sequence type, t is any iterable object and x is an arbitrary object that meets any type and value restrictions imposed by s (例如， bytearray only accepts integers that meet the value restriction 0 <= x <= 255 ).

操作	结果	注意事项
`s[i] = x`	item i of s 被替换通过 x
`s[i:j] = t`	slice of s from i to j is replaced by the contents of the iterable t
`del s[i:j]`	如同 `s[i:j] = []`
`s[i:j:k] = t`	the elements of `s[i:j:k]` are replaced by those of t	(1)
`del s[i:j:k]`	removes the elements of `s[i:j:k]` from the list
`s.append(x)`	追加 x to the end of the sequence (same as `s[len(s):len(s)] = [x]` )
`s.clear()`	removes all items from `s` (same as `del s[:]` )	(5)
`s.copy()`	creates a shallow copy of `s` (same as `s[:]` )	(5)
`s.extend(t)` or `s += t`	extends s 采用 contents of t (for the most part the same as `s[len(s):len(s)] = t` )
`s *= n`	更新 s with its contents repeated n times	(6)
`s.insert(i, x)`	插入 x into s at the index given by i (same as `s[i:i] = [x]` )
`s.pop([i])`	retrieves the item at i and also removes it from s	(2)
`s.remove(x)`	remove the first item from s where `s[i] == x`	(3)
`s.reverse()`	reverses the items of s in place	(4)

注意事项：

t 必须与要替换切片具有相同的长度。
可选自变量 i 默认为 -1 ，因此默认情况下，最后项会被移除并返回。
remove 引发 ValueError 当 x 找不到在 s .
The reverse() method modifies the sequence in place for economy of space when reversing a large sequence. To remind users that it operates by side effect, it does not return the reversed sequence.
clear() and copy() are included for consistency with the interfaces of mutable containers that don’t support slicing operations (such as dict and set )

3.3 版新增： clear() and copy() 方法。
值 n is an integer, or an object implementing __index__() . Zero and negative values of n clear the sequence. Items in the sequence are not copied; they are referenced multiple times, as explained for s * n under 常见序列操作 .

4.6.4. 列表 ¶

列表是通常用于存储同构项 (其相似性的准确程度因应用程序不同而异) 的集合的可变序列。

class list ( [ iterable ] ) ¶

sort ( * , key=None , reverse=None ) ¶

4.6.5. 元组 ¶

Tuples are immutable sequences, typically used to store collections of heterogeneous data (such as the 2-tuples produced by the enumerate() built-in). Tuples are also used for cases where an immutable sequence of homogeneous data is needed (such as allowing storage in a set or dict 实例)。

class tuple ( [ iterable ] ) ¶

For heterogeneous collections of data where access by name is clearer than access by index, collections.namedtuple() may be a more appropriate choice than a simple tuple object.

4.6.6. 范围 ¶

The range type represents an immutable sequence of numbers and is commonly used for looping a specific number of times in for 循环。

class range ( stop ) ¶
class range ( start , stop [ , step ] )

The advantage of the range type over a regular list or tuple is that a range object will always take the same (small) amount of memory, no matter the size of the range it represents (as it only stores the start , stop and step values, calculating individual items and subranges as needed).

Range objects implement the collections.abc.Sequence ABC, and provide features such as containment tests, element index lookup, slicing and support for negative indices (see 序列类型 — 列表、元组、范围 ):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

Testing range objects for equality with == and != compares them as sequences. That is, two range objects are considered equal if they represent the same sequence of values. (Note that two range objects that compare equal might have different start , stop and step attributes, for example range(0) == range(2, 1, 3) or range(0, 3, 2) == range(0, 4, 2) )。

3.2 版改变： Implement the Sequence ABC. Support slicing and negative indices. Test int objects for membership in constant time instead of iterating through all items.

3.3 版改变： Define ‘==’ and ‘!=’ to compare range objects based on the sequence of values they define (instead of comparing based on object identity).

3.3 版新增： The start , stop and step 属性。

4.7. 文本序列类型 — `str` ¶

Python 正文数据的处理是采用 str 对象，或 strings 。字符串是不可变 sequences 的 Unicode 代码点。字符串文字以多种方式编写：

单引号： 'allows embedded "double" quotes'
双引号： "allows embedded 'single' quotes" .
三引号： '''Three single quotes''' , """Three double quotes"""

3 引号字符串可以跨多行 - 所有关联空白都将包括在字符串文字中。

属于单个表达式且它们之间只有空白的字符串文字，将被隐式转换成单字符串文字。也就是说, ("spam " "eggs") == "spam eggs" .

见字符串和 bytes 文字 for more about the various forms of string literal, including supported escape sequences, and the r (“raw”) prefix that disables most escape sequence processing.

也可以从其它对象创建字符串，使用 str 构造函数。

由于不存在单独 "字符" 类型，索引字符串会产生 1 长字符串。也就是说，对于非空字符串 s , s[0] == s[0:1] .

也不存在可变字符串类型，但 str.join() or io.StringIO 可以用于从多个片段，高效构造字符串。

3.3 版改变： For backwards compatibility with the Python 2 series, the u prefix is once again permitted on string literals. It has no effect on the meaning of string literals and cannot be combined with the r 前缀。

class str ( object='' ) ¶
class str ( object=b'' , encoding='utf-8' , errors='strict' )

4.7.1. 字符串方法 ¶

字符串实现了所有的 common 序列操作，及额外方法的描述见下文。

Strings also support two styles of string formatting, one providing a large degree of flexibility and customization (see str.format() , 格式字符串语法 and String Formatting ) and the other based on C printf style formatting that handles a narrower range of types and is slightly harder to use correctly, but is often faster for the cases it can handle ( printf 样式字符串格式化 ).

The 文本处理服务 section of the standard library covers a number of other modules that provide various text related utilities (including regular expression support in the re 模块)。

str. capitalize ( ) ¶

str. casefold ( ) ¶

str. center ( width [ , fillchar ] ) ¶

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

str. encode ( encoding="utf-8" , errors="strict" ) ¶

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

str. expandtabs ( tabsize=8 ) ¶

str. find ( sub [ , start [ , end ] ] ) ¶

str. format ( *args , **kwargs ) ¶

表示	描述
`\n`	换行
`\r`	CR (回车)
`\r\n`	Carriage Return + Line Feed
`\v` or `\x0b`	Line Tabulation
`\f` or `\x0c`	换页
`\x1c`	文件分隔符
`\x1d`	组分隔符
`\x1e`	记录分隔符
`\x85`	Next Line (C1 Control Code)
`\u2028`	行分隔符
`\u2029`	段落分隔符

标志	含义
`'#'`	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).

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

4.9. 集类型 — `set` , `frozenset` ¶

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

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

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

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

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

class set ( [ iterable ] ) ¶

class frozenset ( [ iterable ] ) ¶

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

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

len(s): Return the cardinality of set s .

x in s: 测试 x 为成员资格在 s .

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

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

issubset ( other ) ¶
set <= other: 测试集中的每一元素是否都在 other .

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

issuperset ( other ) ¶
set >= other: Test whether every element in other is in the set.

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

union ( other , ... ) ¶
set | other | ...: 返回带有集和所有其它 others 的元素的新集。

intersection ( other , ... ) ¶
set & other & ...: 返回带有集和所有 others 的共有元素的新集。

difference ( other , ... ) ¶
set - other - ...: 返回新集，且集元素中不在 others 中。

symmetric_difference ( other ) ¶
set ^ other: Return a new set with elements in either the set or other but not both.

copy ( ) ¶: Return a new set with a shallow copy of s .

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

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

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

The subset and equality comparisons do not generalize to a total ordering function. For example, any two nonempty disjoint sets are not equal and are not subsets of each other, so all of the following return False : a<b , a==b ，或 a>b .

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

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

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

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

update ( other , ... ) ¶
set |= other | ...: 更新集，添加来自所有 others 的元素。

intersection_update ( other , ... ) ¶
set &= other & ...: 更新集，仅保持在它和所有 others 中找到的元素。

difference_update ( other , ... ) ¶
set -= other | ...: 更新集，移除在 others 中找到的元素。

symmetric_difference_update ( other ) ¶
set ^= other: 更新集，只保持在集中找到的元素，而不是两者中的元素。

add ( elem ) ¶: 添加元素 elem 到集。

remove ( elem ) ¶: 移除元素 elem 从集。引发 KeyError if elem 未包含在集中。

discard ( elem ) ¶: 移除元素 elem 从集，若存在。

pop ( ) ¶: 移除并返回任意集元素。引发 KeyError 若集为空。

clear ( ) ¶: 移除所有集元素。

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

注意： elem 自变量到 __contains__() , remove() ，和 discard() methods may be a set. To support searching for an equivalent frozenset, the elem set is temporarily mutated during the search and then restored. During the search, the elem set should not be read or mutated since it does not have a meaningful value.

4.10. 映射类型 — `dict` ¶

A 映射对象映射 hashable 值到任意对象。映射是可变对象。目前只有一种标准映射类型， dictionary 。(对于其它容器，见内置 list , set ，和 tuple 类，和 collections 模块。)

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

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

class dict ( **kwarg ) ¶

class dict ( 映射 , **kwarg )

class dict ( iterable , **kwarg )

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

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

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

为阐明，下列范例返回的字典都等于 {"one": 1, "two": 2, "three": 3} :

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

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

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

len(d): 返回项数对于字典 d .

d[key]

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

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

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

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

d[key] = value: Set d[key] to value .

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

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

key not in d: 相当于 not key in d .

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

clear ( ) ¶: 移除所有项从字典。

copy ( ) ¶: 返回字典的浅拷贝。

classmethod fromkeys ( seq [ , value ] ) ¶

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

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

get ( key [ , default ] ) ¶: 返回值为 key if key 在字典中，否则 default 。若 default 不给定，默认为 None ，因此此方法从不引发 KeyError .

项 ( ) ¶: 返回新视图为字典项 ( (key, value) 对)。见视图对象的文档编制 .

keys ( ) ¶: 返回字典键的新视图。见视图对象的文档编制 .

pop ( key [ , default ] ) ¶: 若 key 在字典中，移除它并返回其值，否则返回 default 。若 default 未给定且 key 不在字典中， KeyError 被引发。

popitem ( ) ¶

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

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

setdefault ( key [ , default ] ) ¶: 若 key 在字典中，返回其值。若不在，插入 key 采用值 default 并返回 default . default 默认为 None .

update ( [ other ] ) ¶

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

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

值 ( ) ¶: 返回字典值的新视图。见视图对象的文档编制 .

字典比较相等，当且仅当它们拥有相同 (key, value) pairs. Order comparisons (‘<’, ‘<=’, ‘>=’, ‘>’) raise TypeError .

另请参阅

types.MappingProxyType 可以用于创建只读视图的 dict .

4.10.1. 字典视图对象 ¶

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

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

len(dictview): 返回字典条目数。

iter(dictview)

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

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

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

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

Keys views are set-like since their entries are unique and hashable. If all values are hashable, so that (key, value) pairs are unique and hashable, then the items view is also set-like. (Values views are not treated as set-like since the entries are generally not unique.) For set-like views, all of the operations defined for the abstract base class collections.abc.Set are available (for example, == , < ，或 ^ ).

字典视图的用法范例：

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()
>>> # 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'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'sausage', 'bacon', 'spam'}

4.11. 上下文管理器类型 ¶

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

contextmanager. __enter__ ( ) ¶

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

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

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

contextmanager. __exit__ ( exc_type , exc_val , exc_tb ) ¶

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

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

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

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

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

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

4.12. 其它内置类型 ¶

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

4.12.1. 模块 ¶

模块的唯一特殊操作是属性访问： m.name ，其中 m 是模块和 name 访问定义名称在 m ‘s symbol table. Module attributes can be assigned to. (Note that the import 语句严格来说，并未运转于模块对象； import foo 不要求命名模块对象 foo 的存在，相反，它要求 (外部) definition 对于命名模块 foo 在其它地方)。

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

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

4.12.2. 类和类实例 ¶

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

4.12.3. 函数 ¶

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

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

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

4.12.4. 方法 ¶

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

If you access a method (a function defined in a class namespace) through an instance, you get a special object: a bound method (also called instance method ) object. When called, it will add the self argument to the argument list. Bound methods have two special read-only attributes: m.__self__ is the object on which the method operates, and m.__func__ is the function implementing the method. Calling m(arg-1, arg-2, ..., arg-n) is completely equivalent to calling m.__func__(m.__self__, arg-1, arg-2, ..., arg-n) .

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

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

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

4.12.5. 代码对象 ¶

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

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

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

4.12.6. 类型对象 ¶

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

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

4.12.7. Null 对象 ¶

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

它被写为 None .

4.12.8. 省略对象 ¶

This object is commonly used by slicing (see 切片 ). It supports no special operations. There is exactly one ellipsis object, named Ellipsis (a built-in name). type(Ellipsis)() produces the Ellipsis singleton.

它被写为 Ellipsis or ... .

4.12.9. NotImplemented 对象 ¶

This object is returned from comparisons and binary operations when they are asked to operate on types they don’t support. See 比较 for more information. There is exactly one NotImplemented 对象。 type(NotImplemented)() 产生单例实例。

它被写为 NotImplemented .

4.12.10. 布尔值 ¶

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

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

4.12.11. 内部对象 ¶

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

4.13. 特殊属性 ¶

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

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

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

类。 __bases__ ¶: 类对象的基类元组。

类。 __name__ ¶: The name of the class or type.

类。 __qualname__ ¶

The 合格名称 of the class or type.

3.3 版新增。

类。 __mro__ ¶: This attribute is a tuple of classes that are considered when looking for base classes during method resolution.

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

类。 __subclasses__ ( ) ¶

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

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

脚注

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

[2]	因此，列表 `[1, 2]` 被认为等于 `[1.0, 2.0]` ，和 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.

4. 内置类型 ¶

4.1. 真值测试 ¶

4.2. 布尔运算 — and , or , not ¶

4.3. 比较 ¶

4.4. 数值类型 — int , float , complex ¶

4.4.1. 整数类型的按位运算 ¶

4.4.2. 额外整数类型方法 ¶

4.4.3. 额外浮点方法 ¶

4.4.4. 数值类型的哈希 ¶

4.5. 迭代器类型 ¶

4.5.1. 生成器类型 ¶

4.6. 序列类型 — list , tuple , range ¶

4.6.1. 常见序列操作 ¶

4.6.2. 不可变序列类型 ¶

4.6.3. 可变序列类型 ¶

4.6.4. 列表 ¶

4.6.5. 元组 ¶

4.6.6. 范围 ¶

4.7. 文本序列类型 — str ¶

4.7.1. 字符串方法 ¶

4.7.2. printf 样式字符串格式化 ¶

4.8. 二进制序列类型 — bytes , bytearray , memoryview ¶

4.8.1. Bytes ¶

4.8.2. bytearray 对象 ¶

4.8.3. bytes 和 bytearray 操作 ¶

4.8.4. 内存视图 ¶

4.9. 集类型 — set , frozenset ¶

4.10. 映射类型 — dict ¶

4.10.1. 字典视图对象 ¶

4.11. 上下文管理器类型 ¶

4.12. 其它内置类型 ¶

4.12.1. 模块 ¶

4.12.2. 类和类实例 ¶

4.12.3. 函数 ¶

4.12.4. 方法 ¶

4.12.5. 代码对象 ¶

4.12.6. 类型对象 ¶

4.12.7. Null 对象 ¶

4.12.8. 省略对象 ¶

4.12.9. NotImplemented 对象 ¶

4.12.10. 布尔值 ¶

4.12.11. 内部对象 ¶

4.13. 特殊属性 ¶

内容表

上一话题

下一话题

本页

快速搜索

4.2. 布尔运算 — `and` , `or` , `not` ¶

4.4. 数值类型 — `int` , `float` , `complex` ¶

4.6. 序列类型 — `list` , `tuple` , `range` ¶

4.7. 文本序列类型 — `str` ¶

4.7.2. `printf` 样式字符串格式化 ¶

4.8. 二进制序列类型 — `bytes` , `bytearray` , `memoryview` ¶

4.9. 集类型 — `set` , `frozenset` ¶

4.10. 映射类型 — `dict` ¶