內建型別補充

下面是對Python直譯器中內建的標準型別的一個補充。

Python的主要內建型別有數字、序列、對映、類、例項以及異常。

真值驗證

任何物件都可以作為if或while的條件來做真值驗證，以下情況均為假：

• None
• False
• 數字零，類似0，0.0，0j等
• 任意空序列，類似”，()，[]
• 任意空對映，類似{}
• 使用者自定義類的例項，如果類定義了__bool__()或____len__()方法，當該方法返回數字0或布林值False時

除了上述這些情況，其餘情況都預設為True，因此許多不同型別的物件總為真值。

布林運算子

下表是由優先順序降序排列：

1. or是一個短路操作符，如果x符合條件則不再判斷y
2. and也是一個短路操作符，如果x不符合條件，則不再判斷y
3. not在布林運算子中優先順序最高，但布林運算子對比其他運算子優先順序較低。所以，not a==b被解釋為not (a==b)，而a == not b 是一種語法錯誤。

比較運算子

Python中共有8種比較運算子，且都處在同一優先順序。比較運算子可以做鏈式比較，例如：x < y <= z 等同於x

數字運算子

數字型別主要有三種：整型，浮點數和複數型別。布林值是整數型別的一個子型別。整型為無限精度，浮點型類似C語言中的雙精度。而精度一般是有所用機器的系統決定的，可通過sys.float_info來檢視浮點的精度範圍。複數型別有一個實數部分和一個虛數部分，兩部分都為浮點型別，假設變數z為一個複數，可以通過z.real和z.imag來得到實數和虛數部分。標準庫還包括其他的數字型別，fractions儲存有理數，decimal儲存使用者自定義精度的浮點數。

Python支援不同數字型別的混合運算：當一個二進位制操作符運算不同數字型別的運算數時，“窄”型別的運算元會被轉換成另一種型別後進行運算，寬窄等級如下：整型<浮點型<複數型別。兩個不同型別的數字對比也遵循如上規則。int()、float()、complex()等構造器可以用來構建對應的數字型別。

除了複數之外的所有數字型別都支援如下操作符，這些操作符是以優先順序從小到大排列的。所有數字運算子都要比比較運算子優先順序高。

說明：

1. 與除法相關，結果會傾向於較小的那個整數：1 // 2 返回0，(-1) // 2 返回-1，1 // (-2) 返回-1，(-1) // (-2) 返回0。
2. 這種運算不適用於複數。
3. 將浮點型轉換為整型的小數部分取捨類似於C語言；可以參考math模組中的floor()和ceil()函式。
4. float可以接受字串引數如“nan”和“inf“以及一個設定字首的位置引數”+“或”-“來表示NaN的正負極限。
5. Python定義了pow(0, 0)以及0 ** 0的值為1.
6. 接收0-9數字以及任何Unicode對等量。

所有實數型別可以進行如下操作：

位元運算

整數支援一種只對位元串有效的操作。整數轉換為二進位制，負數被轉換為自身的補碼。

這種二進位制的按位操作的優先順序低於數字運算，但高於對比運算。一元操作符~的優先順序同其他一元數字運算一致（例如+和-）。

以下是位元運算子，以優先順序從低到高排序：

說明：

1. 按位左移和右移的位數不能為負數，否則會引發ValueError異常；
2. 按位左移運算等價於乘以pow(2, n)，且不做溢位檢測；
3. 按位右移運算等價於除以pow(2, n)，且不做溢位檢測。

整型的其他方法

• int.bit_length()

  返回一個整數的二進位制位數。

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

  相當於：

  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

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

  返回一個表示整數的位元組陣列。

  >>> (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() // 8) + 1, byteorder='little')
  b'\xe8\x03'

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

  類方法，返回位元組陣列所表示的整數。

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

浮點型的其他方法

• float.as_integer_ratio()

  返回一個由兩個整陣列成的元組，元組的第一個元素除以第二個元素的值為該浮點數。

  >>> a=1.234
  >>> a.as_integer_ratio()
  (694680242521899, 562949953421312)
  >>> 694680242521899/562949953421312
  1.234

  如果是無限迴圈小數，則丟擲OverflowError異常。而對於NaN則會丟擲ValueError異常。

• float.is_integer()

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

• float.hex()

  返回表示該浮點數的十六進位制字串。對於有限浮點數，這種表示方法總是以0x開頭，並以p結尾。

• float.fromhex(s)

  類方法，返回十六進位制字元所表示的浮點數。

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

數字對比其實就是對比兩者的雜湊值，雜湊值一致，則兩個數相等。

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_

序列型別—str，bytes，bytearray，list，tuple，range

序列通常有如下通用操作：

序列型別支援對比，兩個序列相同的條件是，長度相同、每個元素相同、序列型別相同。

說明：

1. 當序列為字串時，in和not in操作類似檢測是否為子字串；

2. 當n的值小於0時，將一律當做0處理，這種情況下會返回空序列。需要注意的是此時為淺拷貝：

   >>> lists = [[]] * 3
   >>> lists
   [[], [], []]
   >>> lists[0].append(3)
   >>> lists
   [[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. 如果i或j是複數，則索引是從後往前算：len(s) + i 或len(s) + j來替換該負值。但-0依然是0。

4. 如果i或者j比len(s)大，則會替換為len(s)。如果i缺失或者為None，則會替換為0；如果j缺失或者為None，則會替換為len(s)。如果i大於等於j，則切片為空。

5. 從i到j，步長為k的切片，其元素索引為i，i+k，i+2*k，…直到達到或超過j的值，但永不包含j。如果i或j大於len(s)，則替換為len(s)；如果i缺失或為None，則替換為0；如果j缺失或為None，則替換為len(s)。如果k缺失，取預設值1。

6. CPython直譯器細節：如果s和t都為字串，有些Python直譯器例如CPython可以寫成這種格式：s = s + t或s += t。為了增強直譯器相容性，這種情況最好使用字串內建方法str.join([s, t])。

字串格式化操作

這裡的字串格式化方式可能在未來棄用，請關注版本更新資訊

字串物件有一個特殊的內建操作符：%，用來做字串格式化。

當格式化一個值的時候，將被格式化的內容放到操作符%後：

>>> a = "Nemo"
>>> b = "hello %s" % a
>>> b
'hello Nemo'

當格式化多個值時，各個值按照位置關係，通過元組傳入到字串中：

>>> a = "hello"
>>> b = "Nemo"
>>> c = "%s %s" % (a, b)
>>> c
'hello Nemo'

當格式化內容存在字典時：

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

其中%後跟著的字母為佔位符，不同佔位符所支援格式化的型別不同：

range型別

range型別是屬於不可變序列，通常用於迴圈操作。使用range的好處是，不論range長度多少，它都佔用等量的記憶體。

range物件支援索引操作、容器操作、迭代操作、len()函式，以及：

• range.count(x)

  返回range物件中x元素存在的個數。

• range.index(x)

  返回range物件中s[i] == x 的索引值i。如果x不在range物件中，則丟擲ValueError異常。

可變序列

列表和bytearray屬於可變序列，字串和元組屬於不可變序列。可變序列支援對序列中的元素更改，不可變序列中的元素一旦建立不可更改。可變序列有如下操作，需要注意的是列表元素可以為任意元素，bytearray的元素只能是範圍0~256的整數：

說明：

• 可迭代物件t的長度應當與被替換的切片長度一致；

• x可以為任意可迭代物件；

• 當序列s中不包含值為x的元素時，index方法會丟擲ValueError異常；
• 當insert方法傳入負索引時，序列長度會增加。
• pop方法的引數i預設值為-1，即預設刪除序列最後一個元素；
• 當排序或反轉一個大序列時，sort方法和reverse方法開銷較小，但不好的一點是這兩種方法都不返回操作過的序列；
• sort方法必須傳入排序關鍵字引數，作為排序的對比依據。key引數接收一個函式，對序列裡每個值處理後進行排序，例如：key=str.lower，這樣會把序列中的元素。

bytes和bytearray

bytes和bytearray物件，都屬於位元組字串，可以使用字串的所有方法，但bytes不接收str做引數，同理str也不接收bytes做引數。

a = "abc"
b = a.replace("a", "f")
a = b"abc"
b = a.replace(b"a", b"f")

• bytes.decode(encoding=”utf-8”, errors=”strict”) bytesarray.decode(encoding=”utf-8”, errors=”strict”)

  返回位元組解碼後的字串，預設編碼方式為utf-8。errors引數為處理異常的模式，預設為strict，即編碼的時候遇到錯誤會丟擲UnicodeError異常。其他可用值有’ignore’，’replace’等。

• bytes.fromhex(sting) bytesarray.fromhex(string)

  類方法，返回對string解碼後的字元物件。引數string中，每個位元組必須至少包含兩個十六進位制數，空格會被忽略。

  >>> bytes.fromhex('f0 f1f2  ')
  b'\xf0\xf1\xf2'

• bytes.translate(table[, delete]) bytearray.translate(table[, delete])

  返回bytes或bytearray物件的副本，其中刪除了可選引數delete中出現的左右位元組，其餘位元組通過給定轉換表對映，該轉換表必須是長度為256的位元組物件。

  可以通過bytes.maketrans()方法來構造一個轉換表。

  如果只是想刪除字元，可以將table引數設為None。

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

• bytes.maketrans(from, to) bytearray.maketrans(from, to )

  靜態方法，返回一個轉換表，這個表通常提供給bytes.translate()使用。會把from和to中相同位置的字元做對映，而from和to必須為位元組型別並且長度相等。