內(nèi)置類型

以下部分描述了解釋器中內(nèi)置的標(biāo)準(zhǔn)類型。

公司主營業(yè)務(wù)：網(wǎng)站設(shè)計(jì)制作、網(wǎng)站設(shè)計(jì)、移動(dòng)網(wǎng)站開發(fā)等業(yè)務(wù)。幫助企業(yè)客戶真正實(shí)現(xiàn)互聯(lián)網(wǎng)宣傳，提高企業(yè)的競(jìng)爭(zhēng)能力。成都創(chuàng)新互聯(lián)是一支青春激揚(yáng)、勤奮敬業(yè)、活力青春激揚(yáng)、勤奮敬業(yè)、活力澎湃、和諧高效的團(tuán)隊(duì)。公司秉承以“開放、自由、嚴(yán)謹(jǐn)、自律”為核心的企業(yè)文化，感謝他們對(duì)我們的高要求，感謝他們從不同領(lǐng)域給我們帶來的挑戰(zhàn)，讓我們激情的團(tuán)隊(duì)有機(jī)會(huì)用頭腦與智慧不斷的給客戶帶來驚喜。成都創(chuàng)新互聯(lián)推出蠡縣免費(fèi)做網(wǎng)站回饋大家。

主要內(nèi)置類型有數(shù)字、序列、映射、類、實(shí)例和異常。

有些多項(xiàng)集類是可變的。 它們用于添加、移除或重排其成員的方法將原地執(zhí)行，并不返回特定的項(xiàng)，絕對(duì)不會(huì)返回多項(xiàng)集實(shí)例自身而是返回 None。

有些操作受多種對(duì)象類型的支持；特別地，實(shí)際上所有對(duì)象都可以比較是否相等、檢測(cè)邏輯值，以及轉(zhuǎn)換為字符串（使用 repr() 函數(shù)或略有差異的 str() 函數(shù)）。 后一個(gè)函數(shù)是在對(duì)象由 print() 函數(shù)輸出時(shí)被隱式地調(diào)用的。

邏輯值檢測(cè)

任何對(duì)象都可以進(jìn)行邏輯值的檢測(cè)，以便在 if 或 while 作為條件或是作為下文所述布爾運(yùn)算的操作數(shù)來使用。

一個(gè)對(duì)象在默認(rèn)情況下均被視為真值，除非當(dāng)該對(duì)象被調(diào)用時(shí)其所屬類定義了 __bool__() 方法且返回 False 或是定義了 __len__() 方法且返回零。 1 下面基本完整地列出了會(huì)被視為假值的內(nèi)置對(duì)象:

• 被定義為假值的常量: None 和 False。

• 任何數(shù)值類型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)

• 空的序列和多項(xiàng)集: '', (), [], {}, set(), range(0)

產(chǎn)生布爾值結(jié)果的運(yùn)算和內(nèi)置函數(shù)總是返回 0 或 False 作為假值，1 或 True 作為真值，除非另行說明。 （重要例外：布爾運(yùn)算 or 和 and 總是返回其中一個(gè)操作數(shù)。）

布爾運(yùn)算 —- and, or, not

這些屬于布爾運(yùn)算，按優(yōu)先級(jí)升序排列:

注釋：

1. 這是個(gè)短路運(yùn)算符，因此只有在第一個(gè)參數(shù)為假值時(shí)才會(huì)對(duì)第二個(gè)參數(shù)求值。

2. 這是個(gè)短路運(yùn)算符，因此只有在第一個(gè)參數(shù)為真值時(shí)才會(huì)對(duì)第二個(gè)參數(shù)求值。

3. not 的優(yōu)先級(jí)比非布爾運(yùn)算符低，因此 not a == b 會(huì)被解讀為 not (a == b) 而 a == not b 會(huì)引發(fā)語法錯(cuò)誤。

比較運(yùn)算

在 python 中有八種比較運(yùn)算符。 它們的優(yōu)先級(jí)相同（比布爾運(yùn)算的優(yōu)先級(jí)高）。 比較運(yùn)算可以任意串連；例如，x < y <= z 等價(jià)于 x < y and y <= z，前者的不同之處在于 y 只被求值一次（但在兩種情況下當(dāng) x < y 結(jié)果為假值時(shí) z 都不會(huì)被求值）。

此表格匯總了比較運(yùn)算:

除不同的數(shù)字類型外，不同類型的對(duì)象不能進(jìn)行相等比較。== 運(yùn)算符總有定義，但對(duì)于某些對(duì)象類型（例如，類對(duì)象），它等于 is 。其他 <、<=、> 和 >= 運(yùn)算符僅在有意義的地方定義。例如，當(dāng)參與比較的參數(shù)之一為復(fù)數(shù)時(shí)，它們會(huì)拋出 TypeError 異常。

具有不同標(biāo)識(shí)的類的實(shí)例比較結(jié)果通常為不相等，除非類定義了 __eq__() 方法。

一個(gè)類的實(shí)例不能與相同類的其他實(shí)例或其他類型的對(duì)象進(jìn)行排序，除非定義該類定義了足夠多的方法，包括 __lt__(), __le__(), __gt__() 以及 __ge__() (而如果你想實(shí)現(xiàn)常規(guī)意義上的比較操作，通常只要有 __lt__() 和 __eq__() 就可以了)。

is 和 is not 運(yùn)算符無法自定義；并且它們可以被應(yīng)用于任意兩個(gè)對(duì)象而不會(huì)引發(fā)異常。

還有兩種具有相同語法優(yōu)先級(jí)的運(yùn)算 in 和 not in，它們被 iterable 或?qū)崿F(xiàn)了 __contains__() 方法的類型所支持。

數(shù)字類型 —- int, float, complex

There are three distinct numeric types: integers, floating point numbers, and complex numbers. 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, use z.real and z.imag. (The standard library includes the additional numeric types fractions.Fraction, for rationals, and decimal.Decimal, for floating-point numbers with user-definable precision.)

數(shù)字是由數(shù)字字面值或內(nèi)置函數(shù)與運(yùn)算符的結(jié)果來創(chuàng)建的。 不帶修飾的整數(shù)字面值（包括十六進(jìn)制、八進(jìn)制和二進(jìn)制數(shù)）會(huì)生成整數(shù)。 包含小數(shù)點(diǎn)或冪運(yùn)算符的數(shù)字字面值會(huì)生成浮點(diǎn)數(shù)。 在數(shù)字字面值末尾加上 'j' 或 'J' 會(huì)生成虛數(shù)（實(shí)部為零的復(fù)數(shù)），你可以將其與整數(shù)或浮點(diǎn)數(shù)相加來得到具有實(shí)部和虛部的復(fù)數(shù)。

Python 完全支持混合運(yùn)算：當(dāng)一個(gè)二元算術(shù)運(yùn)算符的操作數(shù)有不同數(shù)值類型時(shí)，”較窄”類型的操作數(shù)會(huì)拓寬到另一個(gè)操作數(shù)的類型，其中整數(shù)比浮點(diǎn)數(shù)窄，浮點(diǎn)數(shù)比復(fù)數(shù)窄。不同類型的數(shù)字之間的比較，同比較這些數(shù)字的精確值一樣。2

構(gòu)造函數(shù) int()、 float() 和 complex() 可以用來構(gòu)造特定類型的數(shù)字。

所有數(shù)字類型（復(fù)數(shù)除外）都支持下列運(yùn)算（有關(guān)運(yùn)算優(yōu)先級(jí)，請(qǐng)參閱：運(yùn)算符優(yōu)先級(jí)）:

注釋：

1. 也稱為整數(shù)除法。 結(jié)果值是一個(gè)整數(shù)，但結(jié)果的類型不一定是 int。 運(yùn)算結(jié)果總是向負(fù)無窮的方向舍入: 1//2 為 0, (-1)//2 為 -1, 1//(-2) 為 -1 而 (-1)//(-2) 為 0。

2. 不可用于復(fù)數(shù)。 而應(yīng)在適當(dāng)條件下使用 abs() 轉(zhuǎn)換為浮點(diǎn)數(shù)。

3. 從浮點(diǎn)數(shù)轉(zhuǎn)換為整數(shù)會(huì)被舍入或是像在 C 語言中一樣被截?cái)?；?qǐng)參閱 math.floor() 和 math.ceil() 函數(shù)查看轉(zhuǎn)換的完整定義。

4. float 也接受字符串 “nan” 和附帶可選前綴 “+” 或 “-“ 的 “inf” 分別表示非數(shù)字 (NaN) 以及正或負(fù)無窮。

5. Python 將 pow(0, 0) 和 0 ** 0 定義為 1，這是編程語言的普遍做法。

6. 接受的數(shù)字字面值包括數(shù)碼 0 到 9 或任何等效的 Unicode 字符（具有 Nd 特征屬性的代碼點(diǎn)）。

   See https://www.unicode.org/Public/14.0.0/ucd/extracted/DerivedNumericType.txt for a complete list of code points with the Nd property.

所有 numbers.Real 類型 (int 和 float) 還包括下列運(yùn)算:

有關(guān)更多的數(shù)字運(yùn)算請(qǐng)參閱 math 和 cmath 模塊。

整數(shù)類型的按位運(yùn)算

按位運(yùn)算只對(duì)整數(shù)有意義。 計(jì)算按位運(yùn)算的結(jié)果，就相當(dāng)于使用無窮多個(gè)二進(jìn)制符號(hào)位對(duì)二的補(bǔ)碼執(zhí)行操作。

二進(jìn)制按位運(yùn)算的優(yōu)先級(jí)全都低于數(shù)字運(yùn)算，但又高于比較運(yùn)算；一元運(yùn)算 ~ 具有與其他一元算術(shù)運(yùn)算 (+ and -) 相同的優(yōu)先級(jí)。

此表格是以優(yōu)先級(jí)升序排序的按位運(yùn)算列表:

注釋：

1. 負(fù)的移位數(shù)是非法的，會(huì)導(dǎo)致引發(fā) ValueError。

2. 左移 n 位等價(jià)于乘以 pow(2, n) 。

3. 右移 n 位等價(jià)于除以 pow(2, n) ，作向下取整除法。

4. 使用帶有至少一個(gè)額外符號(hào)擴(kuò)展位的有限個(gè)二進(jìn)制補(bǔ)碼表示（有效位寬度為 1 + max(x.bit_length(), y.bit_length()) 或以上）執(zhí)行這些計(jì)算就足以獲得相當(dāng)于有無數(shù)個(gè)符號(hào)位時(shí)的同樣結(jié)果。

整數(shù)類型的附加方法

int 類型實(shí)現(xiàn)了 numbers.Integral abstract base class。 此外，它還提供了其他幾個(gè)方法:

int.bit_length()

返回以二進(jìn)制表示一個(gè)整數(shù)所需要的位數(shù)，不包括符號(hào)位和前面的零:

 
 
 
 

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

更準(zhǔn)確地說，如果 x 非零，則 x.bit_length() 是使得 2**(k-1) <= abs(x) < 2**k 的唯一正整數(shù) k。 同樣地，當(dāng) abs(x) 小到足以具有正確的舍入對(duì)數(shù)時(shí)，則 k = 1 + int(log(abs(x), 2))。 如果 x 為零，則 x.bit_length() 返回 0。

等價(jià)于:

 
 
 
 

  
  
  
  
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
 
 
 
 

3.1 新版功能.

int.bit_count()

返回整數(shù)的絕對(duì)值的二進(jìn)制表示中 1 的個(gè)數(shù)。也被稱為 population count。示例:

 
 
 
 

  
  
  
  
>>> n = 19
  
  
  
  
>>> bin(n)
  
  
  
  
'0b10011'
  
  
  
  
>>> n.bit_count()
  
  
  
  
3
  
  
  
  
>>> (-n).bit_count()
  
  
  
  
3
 
 
 
 

等價(jià)于:

 
 
 
 

  
  
  
  
def bit_count(self):
  
  
  
  
 return bin(self).count("1")
 
 
 
 

3.10 新版功能.

int.to_bytes(length=1, byteorder=’big’, **, signed=False*)

返回表示一個(gè)整數(shù)的字節(jié)數(shù)組。

 
 
 
 

  
  
  
  
>>> (1024).to_bytes(2, byteorder='big')
  
  
  
  
b'\x04\x00'
  
  
  
  
>>> (1024).to_bytes(10, byteorder='big')
  
  
  
  
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
  
  
  
  
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
  
  
  
  
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
  
  
  
  
>>> x = 1000
  
  
  
  
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
  
  
  
  
b'\xe8\x03'
 
 
 
 

The integer is represented using length bytes, and defaults to 1. An OverflowError is raised if the integer is not representable with the given number of bytes.

The byteorder argument determines the byte order used to represent the integer, and defaults to "big". If byteorder is "big", the most significant byte is at the beginning of the byte array. If byteorder is "little", the most significant byte is at the end of the byte array.

signed 參數(shù)確定是否使用二的補(bǔ)碼來表示整數(shù)。 如果 signed 為 False 并且給出的是負(fù)整數(shù)，則會(huì)引發(fā) OverflowError。 signed 的默認(rèn)值為 False。

The default values can be used to conveniently turn an integer into a single byte object. However, when using the default arguments, don’t try to convert a value greater than 255 or you’ll get an OverflowError:

 
 
 
 

  
  
  
  
>>> (65).to_bytes()
  
  
  
  
b'A'
 
 
 
 

等價(jià)于:

 
 
 
 

  
  
  
  
def to_bytes(n, length=1, byteorder='big', signed=False):
  
  
  
  
 if byteorder == 'little':
  
  
  
  
 order = range(length)
  
  
  
  
 elif byteorder == 'big':
  
  
  
  
 order = reversed(range(length))
  
  
  
  
 else:
  
  
  
  
 raise ValueError("byteorder must be either 'little' or 'big'")
  
  
  
  
  
  
  
  
 return bytes((n >> i*8) & 0xff for i in order)
 
 
 
 

3.2 新版功能.

在 3.11 版更改: Added default argument values for length and byteorder.

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

返回由給定字節(jié)數(shù)組所表示的整數(shù)。

 
 
 
 

  
  
  
  
>>> int.from_bytes(b'\x00\x10', byteorder='big')
  
  
  
  
16
  
  
  
  
>>> int.from_bytes(b'\x00\x10', byteorder='little')
  
  
  
  
4096
  
  
  
  
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
  
  
  
  
-1024
  
  
  
  
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
  
  
  
  
64512
  
  
  
  
>>> int.from_bytes([255, 0, 0], byteorder='big')
  
  
  
  
16711680
 
 
 
 

bytes 參數(shù)必須為一個(gè) bytes-like object 或是生成字節(jié)的可迭代對(duì)象。

The byteorder argument determines the byte order used to represent the integer, and defaults to "big". If byteorder is "big", the most significant byte is at the beginning of the byte array. If byteorder is "little", the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value.

signed 參數(shù)指明是否使用二的補(bǔ)碼來表示整數(shù)。

等價(jià)于:

 
 
 
 

  
  
  
  
def from_bytes(bytes, byteorder='big', signed=False):
  
  
  
  
 if byteorder == 'little':
  
  
  
  
 little_ordered = list(bytes)
  
  
  
  
 elif byteorder == 'big':
  
  
  
  
 little_ordered = list(reversed(bytes))
  
  
  
  
 else:
  
  
  
  
 raise ValueError("byteorder must be either 'little' or 'big'")
  
  
  
  
  
  
  
  
 n = sum(b << i*8 for i, b in enumerate(little_ordered))
  
  
  
  
 if signed and little_ordered and (little_ordered[-1] & 0x80):
  
  
  
  
 n -= 1 << 8*len(little_ordered)
  
  
  
  
  
  
  
  
 return n
 
 
 
 

3.2 新版功能.

在 3.11 版更改: Added default argument value for byteorder.

int.as_integer_ratio()

返回一對(duì)整數(shù)，其比率正好等于原整數(shù)并且分母為正數(shù)。 整數(shù)的比率總是用這個(gè)整數(shù)本身作為分子，1 作為分母。

3.8 新版功能.

浮點(diǎn)類型的附加方法

float 類型實(shí)現(xiàn)了 numbers.Real abstract base class。 float 還具有以下附加方法。

float.as_integer_ratio()

返回一對(duì)整數(shù)，其比率正好等于原浮點(diǎn)數(shù)并且分母為正數(shù)。 無窮大會(huì)引發(fā) OverflowError 而 NaN 則會(huì)引發(fā) ValueError。

float.is_integer()

如果 float 實(shí)例可用有限位整數(shù)表示則返回 True，否則返回 False:

 
 
 
 

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

兩個(gè)方法均支持與十六進(jìn)制數(shù)字符串之間的轉(zhuǎn)換。 由于 Python 浮點(diǎn)數(shù)在內(nèi)部存儲(chǔ)為二進(jìn)制數(shù)，因此浮點(diǎn)數(shù)與 十進(jìn)制數(shù) 字符串之間的轉(zhuǎn)換往往會(huì)導(dǎo)致微小的舍入錯(cuò)誤。 而十六進(jìn)制數(shù)字符串卻允許精確地表示和描述浮點(diǎn)數(shù)。 這在進(jìn)行調(diào)試和數(shù)值工作時(shí)非常有用。

float.hex()

以十六進(jìn)制字符串的形式返回一個(gè)浮點(diǎn)數(shù)表示。 對(duì)于有限浮點(diǎn)數(shù)，這種表示法將總是包含前導(dǎo)的 0x 和尾隨的 p 加指數(shù)。

classmethod float.fromhex(s)

返回以十六進(jìn)制字符串 s 表示的浮點(diǎn)數(shù)的類方法。 字符串 s 可以帶有前導(dǎo)和尾隨的空格。

請(qǐng)注意 float.hex() 是實(shí)例方法，而 float.fromhex() 是類方法。

十六進(jìn)制字符串采用的形式為:

 
 
 
 

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

可選的 sign 可以是 + 或 -，integer 和 fraction 是十六進(jìn)制數(shù)碼組成的字符串，exponent 是帶有可選前導(dǎo)符的十進(jìn)制整數(shù)。 大小寫沒有影響，在 integer 或 fraction 中必須至少有一個(gè)十六進(jìn)制數(shù)碼。 此語法類似于 C99 標(biāo)準(zhǔn)的 6.4.4.2 小節(jié)中所描述的語法，也是 Java 1.5 以上所使用的語法。 特別地，float.hex() 的輸出可以用作 C 或 Java 代碼中的十六進(jìn)制浮點(diǎn)數(shù)字面值，而由 C 的 %a 格式字符或 Java 的 Double.toHexString 所生成的十六進(jìn)制數(shù)字符串由為 float.fromhex() 所接受。

請(qǐng)注意 exponent 是十進(jìn)制數(shù)而非十六進(jìn)制數(shù)，它給出要與系數(shù)相乘的 2 的冪次。 例如，十六進(jìn)制數(shù)字符串 0x3.a7p10 表示浮點(diǎn)數(shù) (3 + 10./16 + 7./16**2) * 2.0**10 即 3740.0:

 
 
 
 

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

對(duì) 3740.0 應(yīng)用反向轉(zhuǎn)換會(huì)得到另一個(gè)代表相同數(shù)值的十六進(jìn)制數(shù)字符串:

 
 
 
 

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

數(shù)字類型的哈希運(yùn)算

對(duì)于可能為不同類型的數(shù)字 x 和 y，要求 x == y 時(shí)必定 hash(x) == hash(y) (詳情參見 __hash__() 方法的文檔)。 為了便于在各種數(shù)字類型 (包括 int, float, decimal.Decimal 和 fractions.Fraction) 上實(shí)現(xiàn)并保證效率，Python 對(duì)數(shù)字類型的哈希運(yùn)算是基于為任意有理數(shù)定義統(tǒng)一的數(shù)學(xué)函數(shù)，因此該運(yùn)算對(duì) int 和 fractions.Fraction 的全部實(shí)例，以及 float 和 decimal.Decimal 的全部有限實(shí)例均可用。 從本質(zhì)上說，此函數(shù)是通過以一個(gè)固定質(zhì)數(shù) P 進(jìn)行 P 降模給出的。 P 的值在 Python 中可以 sys.hash_info 的 modulus 屬性的形式被訪問。

CPython 實(shí)現(xiàn)細(xì)節(jié)： 目前所用的質(zhì)數(shù)設(shè)定，在 C long 為 32 位的機(jī)器上 P = 2**31 - 1 而在 C long 為 64 位的機(jī)器上 P = 2**61 - 1。

詳細(xì)規(guī)則如下所述:

• 如果 x = m / n 是一個(gè)非負(fù)的有理數(shù)且 n 不可被 P 整除，則定義 hash(x) 為 m * invmod(n, P) % P，其中 invmod(n, P) 是對(duì) n 模 P 取反。

• 如果 x = m / n 是一個(gè)非負(fù)的有理數(shù)且 n 可被 P 整除（但 m 不能）則 n 不能對(duì) P 降模，以上規(guī)則不適用；在此情況下則定義 hash(x) 為常數(shù)值 sys.hash_info.inf。

• 如果 x = m / n 是一個(gè)負(fù)的有理數(shù)則定義 hash(x) 為 -hash(-x)。 如果結(jié)果哈希值為 -1 則將其替換為 -2。

• 特殊值 sys.hash_info.inf 和 -sys.hash_info.inf 分別用于正無窮或負(fù)無窮的哈希值。

• 對(duì)于一個(gè) complex 值 z，會(huì)通過計(jì)算 hash(z.real) + sys.hash_info.imag * hash(z.imag) 將實(shí)部和虛部的哈希值結(jié)合起來，并進(jìn)行降模 2**sys.hash_info.width 以使其處于 range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)) 范圍之內(nèi)。 同樣地，如果結(jié)果為 -1 則將其替換為 -2。

為了闡明上述規(guī)則，這里有一些等價(jià)于內(nèi)置哈希算法的 Python 代碼示例，可用于計(jì)算有理數(shù)、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_value = 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_value = (abs(m) % P) * pow(n, P - 2, P) % P
  
  
  
  
 if m < 0:
  
  
  
  
 hash_value = -hash_value
  
  
  
  
 if hash_value == -1:
  
  
  
  
 hash_value = -2
  
  
  
  
 return hash_value
  
  
  
  
  
  
  
  
def hash_float(x):
  
  
  
  
 """Compute the hash of a float x."""
  
  
  
  
  
  
  
  
 if math.isnan(x):
  
  
  
  
 return object.__hash__(x)
  
  
  
  
 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_value = 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_value = (hash_value & (M - 1)) - (hash_value & M)
  
  
  
  
 if hash_value == -1:
  
  
  
  
 hash_value = -2
  
  
  
  
 return hash_value
 
 
 
 

迭代器類型

Python 支持在容器中進(jìn)行迭代的概念。 這是通過使用兩個(gè)單獨(dú)方法來實(shí)現(xiàn)的；它們被用于允許用戶自定義類對(duì)迭代的支持。 將在下文中詳細(xì)描述的序列總是支持迭代方法。

容器對(duì)象要提供 iterable 支持，必須定義一個(gè)方法:

container.__iter__()

返回一個(gè) iterator 對(duì)象。 該對(duì)象需要支持下文所述的迭代器協(xié)議。 如果容器支持不同的迭代類型，則可以提供額外的方法來專門地請(qǐng)求不同迭代類型的迭代器。 （支持多種迭代形式的對(duì)象的例子有同時(shí)支持廣度優(yōu)先和深度優(yōu)先遍歷的樹結(jié)果。） 此方法對(duì)應(yīng)于 Python/C API 中 Python 對(duì)象類型結(jié)構(gòu)體的 tp_iter 槽位。

迭代器對(duì)象自身需要支持以下兩個(gè)方法，它們共同組成了 迭代器協(xié)議:

iterator.__iter__()

返回 iterator 對(duì)象本身。 這是同時(shí)允許容器和迭代器配合 for 和 in 語句使用所必須的。 此方法對(duì)應(yīng)于 Python/C API 中 Python 對(duì)象類型結(jié)構(gòu)體的 tp_iter 槽位。

iterator.__next__()

iterator 中返回下一項(xiàng)。 如果已經(jīng)沒有可返回的項(xiàng)，則會(huì)引發(fā) StopIteration 異常。 此方法對(duì)應(yīng)于 Python/C API 中 Python 對(duì)象類型結(jié)構(gòu)體的 tp_iternext 槽位。

Python 定義了幾種迭代器對(duì)象以支持對(duì)一般和特定序列類型、字典和其他更特別的形式進(jìn)行迭代。 除了迭代器協(xié)議的實(shí)現(xiàn)，特定類型的其他性質(zhì)對(duì)迭代操作來說都不重要。

一旦迭代器的 __next__() 方法引發(fā)了 StopIteration，它必須一直對(duì)后續(xù)調(diào)用引發(fā)同樣的異常。 不遵循此行為特性的實(shí)現(xiàn)將無法正常使用。

生成器類型

Python 的 generator 提供了一種實(shí)現(xiàn)迭代器協(xié)議的便捷方式。 如果容器對(duì)象 __iter__() 方法被實(shí)現(xiàn)為一個(gè)生成器，它將自動(dòng)返回一個(gè)迭代器對(duì)象（從技術(shù)上說是一個(gè)生成器對(duì)象），該對(duì)象提供 __iter__() 和 __next__() 方法。 有關(guān)生成器的更多信息可以參閱 yield 表達(dá)式的文檔。

序列類型 —- list, tuple, range

有三種基本序列類型：list, tuple 和 range 對(duì)象。 為處理 二進(jìn)制數(shù)據(jù) 和 文本字符串 而特別定制的附加序列類型會(huì)在專門的小節(jié)中描述。

通用序列操作

大多數(shù)序列類型，包括可變類型和不可變類型都支持下表中的操作。 collections.abc.Sequence ABC 被提供用來更容易地在自定義序列類型上正確地實(shí)現(xiàn)這些操作。

此表按優(yōu)先級(jí)升序列出了序列操作。 在表格中，s 和 t 是具有相同類型的序列，n, i, j 和 k 是整數(shù)而 x 是任何滿足 s 所規(guī)定的類型和值限制的任意對(duì)象。

in 和 not in 操作具有與比較操作相同的優(yōu)先級(jí)。 + (拼接) 和 * (重復(fù)) 操作具有與對(duì)應(yīng)數(shù)值運(yùn)算相同的優(yōu)先級(jí)。 3

相同類型的序列也支持比較。 特別地，tuple 和 list 的比較是通過比較對(duì)應(yīng)元素的字典順序。 這意味著想要比較結(jié)果相等，則每個(gè)元素比較結(jié)果都必須相等，并且兩個(gè)序列長度必須相同。 （完整細(xì)節(jié)請(qǐng)參閱語言參考的 比較運(yùn)算 部分。）

可變序列的正向和逆向迭代器使用一個(gè)索引來訪問值。 即使底層序列被改變?cè)撍饕矊⒊掷m(xù)向前（或向后）步進(jìn)。 迭代器只有在遇到 IndexError 或 a StopIteration 時(shí)才會(huì)終結(jié)（或是當(dāng)索引降至零以下）。

注釋：

1. 雖然 in 和 not in 操作在通常情況下僅被用于簡(jiǎn)單的成員檢測(cè)，某些專門化序列 (例如 str, bytes 和 bytearray) 也使用它們進(jìn)行子序列檢測(cè):

      
      
      
      
   
       
       
       
       
   >>> "gg" in "eggs"
       
       
       
       
   True
      
      
      
      

2. 小于 0 的 n 值會(huì)被當(dāng)作 0 來處理 (生成一個(gè)與 s 同類型的空序列)。 請(qǐng)注意序列 s 中的項(xiàng)并不會(huì)被拷貝；它們會(huì)被多次引用。 這一點(diǎn)經(jīng)常會(huì)令 Python 編程新手感到困擾；例如:

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

   具體的原因在于 [[]] 是一個(gè)包含了一個(gè)空列表的單元素列表，所以 [[]] * 3 結(jié)果中的三個(gè)元素都是對(duì)這一個(gè)空列表的引用。 修改 lists 中的任何一個(gè)元素實(shí)際上都是對(duì)這一個(gè)空列表的修改。 你可以用以下方式創(chuàng)建以不同列表為元素的列表:

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

   進(jìn)一步的解釋可以在 FAQ 條目 如何創(chuàng)建多維列表？ 中查看。

3. 如果 i 或 j 為負(fù)值，則索引順序是相對(duì)于序列 s 的末尾: 索引號(hào)會(huì)被替換為 len(s) + i 或 len(s) + j。 但要注意 -0 仍然為 0。

4. s 從 i 到 j 的切片被定義為所有滿足 i <= k < j 的索引號(hào) k 的項(xiàng)組成的序列。 如果 i 或 j 大于 len(s)，則使用 len(s)。 如果 i 被省略或?yàn)?None，則使用 0。 如果 j 被省略或?yàn)?None，則使用 len(s)。 如果 i 大于等于 j，則切片為空。

5. s 從 i 到 j 步長為 k 的切片被定義為所有滿足 0 <= n < (j-i)/k 的索引號(hào) x = i + n*k 的項(xiàng)組成的序列。 換句話說，索引號(hào)為 i, i+k, i+2*k, i+3*k，以此類推，當(dāng)達(dá)到 j 時(shí)停止 (但一定不包括 j)。 當(dāng) k 為正值時(shí)，i 和 j 會(huì)被減至不大于 len(s)。 當(dāng) k 為負(fù)值時(shí)，i 和 j 會(huì)被減至不大于 len(s) - 1。 如果 i 或 j 被省略或?yàn)?None，它們會(huì)成為“終止”值 (是哪一端的終止值則取決于 k 的符號(hào))。 請(qǐng)注意，k 不可為零。 如果 k 為 None，則當(dāng)作 1 處理。

6. 拼接不可變序列總是會(huì)生成新的對(duì)象。 這意味著通過重復(fù)拼接來構(gòu)建序列的運(yùn)行時(shí)開銷將會(huì)基于序列總長度的乘方。 想要獲得線性的運(yùn)行時(shí)開銷，你必須改用下列替代方案之一：

   • 如果拼接 str 對(duì)象，你可以構(gòu)建一個(gè)列表并在最后使用 str.join() 或是寫入一個(gè) io.StringIO 實(shí)例并在結(jié)束時(shí)獲取它的值

   • 如果拼接 bytes 對(duì)象，你可以類似地使用 bytes.join() 或 io.BytesIO，或者你也可以使用 bytearray 對(duì)象進(jìn)行原地拼接。 bytearray 對(duì)象是可變的，并且具有高效的重分配機(jī)制

   • 如果拼接 tuple 對(duì)象，請(qǐng)改為擴(kuò)展 list 類

   • 對(duì)于其它類型，請(qǐng)查看相應(yīng)的文檔

7. 某些序列類型 (例如 range) 僅支持遵循特定模式的項(xiàng)序列，因此并不支持序列拼接或重復(fù)。

8. 當(dāng) x 在 s 中找不到時(shí) index 會(huì)引發(fā) ValueError。 不是所有實(shí)現(xiàn)都支持傳入額外參數(shù) i 和 j。 這兩個(gè)參數(shù)允許高效地搜索序列的子序列。 傳入這兩個(gè)額外參數(shù)大致相當(dāng)于使用 s[i:j].index(x)，但是不會(huì)復(fù)制任何數(shù)據(jù)，并且返回的索引是相對(duì)于序列的開頭而非切片的開頭。

不可變序列類型

不可變序列類型普遍實(shí)現(xiàn)而可變序列類型未實(shí)現(xiàn)的唯一操作就是對(duì) hash() 內(nèi)置函數(shù)的支持。

這種支持允許不可變類型，例如 tuple 實(shí)例被用作 dict 鍵，以及存儲(chǔ)在 set 和 frozenset 實(shí)例中。

嘗試對(duì)包含有不可哈希值的不可變序列進(jìn)行哈希運(yùn)算將會(huì)導(dǎo)致 TypeError。

可變序列類型

以下表格中的操作是在可變序列類型上定義的。 collections.abc.MutableSequence ABC 被提供用來更容易地在自定義序列類型上正確實(shí)現(xiàn)這些操作。

表格中的 s 是可變序列類型的實(shí)例，t 是任意可迭代對(duì)象，而 x 是符合對(duì) s 所規(guī)定類型與值限制的任何對(duì)象 (例如，bytearray 僅接受滿足 0 <= x <= 255 值限制的整數(shù))。

注釋：

1. t 必須與它所替換的切片具有相同的長度。

2. 可選參數(shù) i 默認(rèn)為 -1，因此在默認(rèn)情況下會(huì)移除并返回最后一項(xiàng)。

3. 當(dāng)在 s 中找不到 x 時(shí) remove() 操作會(huì)引發(fā) ValueError。

4. 當(dāng)反轉(zhuǎn)大尺寸序列時(shí) reverse() 方法會(huì)原地修改該序列以保證空間經(jīng)濟(jì)性。 為提醒用戶此操作是通過間接影響進(jìn)行的，它并不會(huì)返回反轉(zhuǎn)后的序列。

5. 包括 clear() 和 copy() 是為了與不支持切片操作的可變?nèi)萜?(例如 dict 和 set) 的接口保持一致。 copy() 不是 collections.abc.MutableSequence ABC 的一部分，但大多數(shù)具體的可變序列類都提供了它。

   3.3 新版功能: clear() 和 copy() 方法。

6. n 值為一個(gè)整數(shù)，或是一個(gè)實(shí)現(xiàn)了 __index__() 的對(duì)象。 n 值為零或負(fù)數(shù)將清空序列。 序列中的項(xiàng)不會(huì)被拷貝；它們會(huì)被多次引用，正如 通用序列操作 中有關(guān) s * n 的說明。

列表

列表是可變序列，通常用于存放同類項(xiàng)目的集合（其中精確的相似程度將根據(jù)應(yīng)用而變化）。

class list([iterable])

可以用多種方式構(gòu)建列表：

• 使用一對(duì)方括號(hào)來表示空列表: []

• 使用方括號(hào)，其中的項(xiàng)以逗號(hào)分隔: [a], [a, b, c]

• 使用列表推導(dǎo)式: [x for x in iterable]

• 使用類型的構(gòu)造器: list() 或 list(iterable)

構(gòu)造器將構(gòu)造一個(gè)列表，其中的項(xiàng)與 iterable 中的項(xiàng)具有相同的的值與順序。 iterable 可以是序列、支持迭代的容器或其它可迭代對(duì)象。 如果 iterable 已經(jīng)是一個(gè)列表，將創(chuàng)建并返回其副本，類似于 iterable[:]。 例如，list('abc') 返回 ['a', 'b', 'c'] 而 list( (1, 2, 3) ) 返回 [1, 2, 3]。 如果沒有給出參數(shù)，構(gòu)造器將創(chuàng)建一個(gè)空列表 []。

其它許多操作也會(huì)產(chǎn)生列表，包括 sorted() 內(nèi)置函數(shù)。

列表實(shí)現(xiàn)了所有 一般 和 可變 序列的操作。 列表還額外提供了以下方法：

• sort(**, key=None, reverse=False*)

  此方法會(huì)對(duì)列表進(jìn)行原地排序，只使用 < 來進(jìn)行各項(xiàng)間比較。 異常不會(huì)被屏蔽 —— 如果有任何比較操作失敗，整個(gè)排序操作將失?。ǘ斜砜赡軙?huì)處于被部分修改的狀態(tài)）。

  sort() 接受兩個(gè)僅限以關(guān)鍵字形式傳入的參數(shù) (僅限關(guān)鍵字參數(shù)):

  key 指定帶有一個(gè)參數(shù)的函數(shù)，用于從每個(gè)列表元素中提取比較鍵 (例如 key=str.lower)。 對(duì)應(yīng)于列表中每一項(xiàng)的鍵會(huì)被計(jì)算一次，然后在整個(gè)排序過程中使用。 默認(rèn)值 None 表示直接對(duì)列表項(xiàng)排序而不計(jì)算一個(gè)單獨(dú)的鍵值。

  可以使用 functools.cmp_to_key() 將 2.x 風(fēng)格的 cmp 函數(shù)轉(zhuǎn)換為 key 函數(shù)。

  reverse 為一個(gè)布爾值。 如果設(shè)為 True，則每個(gè)列表元素將按反向順序比較進(jìn)行排序。

  當(dāng)順序大尺寸序列時(shí)此方法會(huì)原地修改該序列以保證空間經(jīng)濟(jì)性。 為提醒用戶此操作是通過間接影響進(jìn)行的，它并不會(huì)返回排序后的序列（請(qǐng)使用 sorted() 顯示地請(qǐng)求一個(gè)新的已排序列表實(shí)例）。

  sort() 方法確保是穩(wěn)定的。 如果一個(gè)排序確保不會(huì)改變比較結(jié)果相等的元素的相對(duì)順序就稱其為穩(wěn)定的 —- 這有利于進(jìn)行多重排序（例如先按部門、再接薪級(jí)排序）。

  有關(guān)排序示例和簡(jiǎn)要排序教程，請(qǐng)參閱 排序指南 。

  CPython 實(shí)現(xiàn)細(xì)節(jié)： 在一個(gè)列表被排序期間，嘗試改變甚至進(jìn)行檢測(cè)也會(huì)造成未定義的影響。 Python 的 C 實(shí)現(xiàn)會(huì)在排序期間將列表顯示為空，如果發(fā)現(xiàn)列表在排序期間被改變將會(huì)引發(fā) ValueError。

元組

元組是不可變序列，通常用于儲(chǔ)存異構(gòu)數(shù)據(jù)的多項(xiàng)集（例如由 enumerate() 內(nèi)置函數(shù)所產(chǎn)生的二元組）。 元組也被用于需要同構(gòu)數(shù)據(jù)的不可變序列的情況（例如允許存儲(chǔ)到 set 或 dict 的實(shí)例）。

class tuple([iterable])

可以用多種方式構(gòu)建元組：

• 使用一對(duì)圓括號(hào)來表示空元組: ()

• 使用一個(gè)后綴的逗號(hào)來表示單元組: a, 或 (a,)

• 使用以逗號(hào)分隔的多個(gè)項(xiàng): a, b, c or (a, b, c)

• 使用內(nèi)置的 tuple(): tuple() 或 tuple(iterable)

構(gòu)造器將構(gòu)造一個(gè)元組，其中的項(xiàng)與 iterable 中的項(xiàng)具有相同的值與順序。 iterable 可以是序列、支持迭代的容器或其他可迭代對(duì)象。 如果 iterable 已經(jīng)是一個(gè)元組，會(huì)不加改變地將其返回。 例如，tuple('abc') 返回 ('a', 'b', 'c') 而 tuple( [1, 2, 3] ) 返回 (1, 2, 3)。 如果沒有給出參數(shù)，構(gòu)造器將創(chuàng)建一個(gè)空元組 ()。

請(qǐng)注意決定生成元組的其實(shí)是逗號(hào)而不是圓括號(hào)。 圓括號(hào)只是可選的，生成空元組或需要避免語法歧義的情況除外。 例如，f(a, b, c) 是在調(diào)用函數(shù)時(shí)附帶三個(gè)參數(shù)，而 f((a, b, c)) 則是在調(diào)用函數(shù)時(shí)附帶一個(gè)三元組。

元組實(shí)現(xiàn)了所有 一般 序列的操作。

對(duì)于通過名稱訪問相比通過索引訪問更清晰的異構(gòu)數(shù)據(jù)多項(xiàng)集，collections.namedtuple() 可能是比簡(jiǎn)單元組對(duì)象更為合適的選擇。

range 對(duì)象

range 類型表示不可變的數(shù)字序列，通常用于在 for 循環(huán)中循環(huán)指定的次數(shù)。

class range(stop)

class range(start, stop[, step])

range 構(gòu)造器的參數(shù)必須為整數(shù)（可以是內(nèi)置的 int 或任何實(shí)現(xiàn)了 __index__() 特殊方法的對(duì)象）。 如果省略 step 參數(shù)，則默認(rèn)為 1。 如果省略 start 參數(shù)，則默認(rèn)為 0。 如果 step 為零，則會(huì)引發(fā) ValueError。

如果 step 為正值，確定 range r 內(nèi)容的公式為 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。

如果 step 為負(fù)值，確定 range 內(nèi)容的公式仍然為 r[i] = start + step*i，但限制條件改為 i >= 0 且 r[i] > stop.

如果 r[0] 不符合值的限制條件，則該 range 對(duì)象為空。 range 對(duì)象確實(shí)支持負(fù)索引，但是會(huì)將其解讀為從正索引所確定的序列的末尾開始索引。

元素絕對(duì)值大于 sys.maxsize 的 range 對(duì)象是被允許的，但某些特性 (例如 len()) 可能引發(fā) OverflowError。

一些 range 對(duì)象的例子:

 
 
 
 

  
  
  
  
>>> list(range(10))
  
  
  
  
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  
  
  
  
>>> list(range(1, 11))
  
  
  
  
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  
  
  
  
>>> list(range(0, 30, 5))
  
  
  
  
[0, 5, 10, 15, 20, 25]
  
  
  
  
>>> list(range(0, 10, 3))
  
  
  
  
[0, 3, 6, 9]
  
  
  
  
>>> list(range(0, -10, -1))
  
  
  
  
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
  
  
  
  
>>> list                                                

                                                本文標(biāo)題：創(chuàng)新互聯(lián)Python教程：內(nèi)置類型                                                

                                                分享鏈接：http://www.fisionsoft.com.cn/article/dhjiodo.html