數學運算（7個）

1、abs(x)：返回一個數的絕對值

abs() 是一個內置函數，用于返回一個數的絕對值。絕對值是一個數不考慮其符號的大小，即一個數距離0的距離。對于正數和零，絕對值就是其本身；對于負數，絕對值是它的相反數。

參數

x -- 這是你想要求其絕對值的數字。

返回值

返回 x 的絕對值。

示例：

print(abs(-10))  # 輸出: 10  

print(abs(10))   # 輸出: 10  

print(abs(-3.14)) # 輸出: 3.14

2、divmod(a,b)：返回a除以b的商和余數

divmod()是一個內置函數，用于返回商和余數，這是當兩個數相除時的結果。這個函數接受兩個參數：被除數和除數，并返回一個包含兩個元素的元組，第一個元素是商，第二個元素是余數。

參數：

a：被除數

b：除數

返回值

返回一個包含兩個元素的元組 (商, 余數)。

示列：

print(divmod(10, 3))  # 輸出: (3, 1)，因為10除以3的商是3，余數是1  

print(divmod(7, 2))   # 輸出: (3, 1)，因為7除以2的商是3，余數是1  

print(divmod(-10, 3)) # 輸出: (-4, 2)，因為-10除以3的商是-3.333...,Ptyhon

注：

因為Python在處理負數的除法時，divmod()函數返回的是“地板除法”的結果，也就是向負無窮方向取整。（**如果算法是向上取整，結果就是（-3，-1）**）

-10/3的結果是-3.3333，向下取整即取比-3.3333更小的最大整數即-4，而2是滿足商為-4時的余數（-4*3+2=10）

3、max(iterable,*[,key,default]) / max(arg1,arg2,*args[,key])：找到給定參數中的最大值

當只有一個參數時，它應該是一個可迭代對象（例如列表、元組、集合、字符串等），max() 返回該可迭代對象中的最大值。

當有兩個或多個參數時，max() 返回這些參數中的最大值。

max() 函數還可以接受關鍵字參數：

key：用于指定一個函數，該函數將應用于可迭代對象的每個元素，并根據函數的返回值進行比較。

default：可選參數，指定在可迭代對象為空時返回的默認值。

例1：找到列表中的最大值

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

print(max(numbers))  # 輸出: 9

例2：找到多個參數中的最大值

print(max(3, 1, 4, 1, 5, 9, 2, 6))  # 輸出: 9

例3：使用key參數來指定比較的方式

words = ["apple", "banana", "cherry", "date"]

print(max(words, key=len))  # 輸出: "banana"，根據字符串長度比較

例4：使用default參數來設置默認值

empty_list = []

print(max(empty_list, default="列表為空"))  # 輸出: "列表為空"

例5：自定義比較

如果默認的比較不滿足你的需求，你可以通過提供 key 參數來定義自己的比較函數。這個比較函數應該接受一個參數并返回一個可以用于比較的值。

例如，如果我們有一個數字列表，并且我們想要找出其中絕對值最大的數字，我們可以這樣做：

numbers = [-10, -5, 0, 5, 10]  

  

def abs_value(num):  

    return abs(num)  

  

print(max(numbers, key=abs_value))  # 輸出: -10

注意事項

• 如果可迭代對象為空，max() 函數會引發 ValueError 異常。
• 如果提供了多個參數并且其中一個是可迭代對象，那么會引發 TypeError 異常。例如，max(3, [1, 2]) 會引發異常。

• key 參數應該是一個函數，它接受一個參數并返回一個用于比較的值。如果 key 不是函數，會引發 TypeError 異常。
• max() 函數在進行比較時會遵循正常的比較規則，這意味著它可以用于不同類型的可迭代對象，只要其中的元素支持比較操作。

4、min(iterable, *[, key, default]) / min(arg1, arg2, *args[, key])：找到給定參數中的最小值

min() 函數與 max() 函數類似。min是minimum的縮寫，即最小值或最小量。

5、pow(x, y, [z])：計算一個數的指數冪

x：底數

y：指數

返回x的y次冪的值。與x**y運算的結果相同。

z[可選]：當指定了這個參數時，計算的結果為：(x**y)%z。這對于大數冪運算取模很有用。

例1：2的3次方

result = pow(2, 3)

print(result)  # 輸出: 8

例2：2的3次方再除5后的余數

result = pow(2, 3, 5)

print(result)  # 輸出: 3，因為 (2 ** 3) % 5 = 8 % 5 = 3

例3：求平方根

print(pow(3, 0.5))    # 輸出: 1.7320508075688772，即 3 的平方根

6、round(number[, ndigits])：將浮點數四舍五入為指定的小數位數或最接近的整數

number：要四舍五入的數字。

ndigits：可選參數，表示要保留的小數位數。默認為 0，表示將 number 四舍五入為最接近的整數。當 ndigits 為正數時，將 number 四舍五入到小數點右側指定的位數；當 ndigits 為負數時，將 number 四舍五入到小數點左側指定的位數（即指定精度）。

例1：

result = round(3.1415926)

print(result)  # 輸出: 3，將 3.1415926 四舍五入為整數

result = round(3.1415926, 2)

print(result)  # 輸出: 3.14，將 3.1415926 四舍五入為小數點后兩位

result = round(12345.6789, -2)

print(result)  # 輸出: 12300.0，將 12345.6789 四舍五入到千位

例2：小數為0.5邊界值時只向偶數向上取整

round(0.5) 結果為 0，

round(1.5) 結果為 2。

round(2.5) 結果為 2。

round(3.5) 結果為 4。

注意：

對于在中間值上的舍入，round() 函數會向最接近的偶數舍入，這與數學中的 "銀行家舍入規則" 相符。

7、sum(iterable, start=0)：計算可迭代對象中所有元素的總和

sum()函數接受一個必需的參數，即要計算總和的可迭代對象。這個可迭代對象可以是列表（list）、元組（tuple）或其他任何可迭代的數據結構。

iterable：要計算總和的可迭代對象。

start：可選參數，用于指定總和的初始值。默認為 0。如果指定了 start，則會將 start 與可迭代對象中的元素逐個相加。

例 1：計算列表中元素的和

numbers = [1, 2, 3, 4, 5]  

total = sum(numbers)  

print(total)  # 輸出：15

例 2：計算元組中元素的和

numbers = (1, 2, 3, 4, 5)  

total = sum(numbers)  

print(total)  # 輸出：15

例3：附上初始值

numbers = [1, 2, 3, 4, 5]

result = sum(numbers, 10)

print(result) # 輸出: 25，計算列表中所有元素的總和，并加上初始值 10

注意事項

• sum()函數只能用于數值類型的數據。如果可迭代對象中包含非數值類型的數據（如字符串、列表等），將會引發TypeError異常。

• 對于空的可迭代對象，sum()函數返回0。

• sum()函數在內部使用循環來計算總和，因此對于大型數據集，使用sum()可能比手動循環遍歷元素求和更高效。

類型轉換（24個）

1、bool([value])：將給定的值轉換為布爾值

bool() 函數接受一個參數，這個參數可以是任何數據類型，包括整數、浮點數、字符串、列表、元組、字典、集合等。

value：

可選參數，要轉換為布爾值的值。如果省略 value 參數，則返回 False。否則，根據 value 的值進行轉換：

如果 value 是假值（如 None、空容器（空列表、空元組、空字典、空集合）、數字 0、布爾值 False 等），則返回 False。

如果 value 是真值（除了上述假值之外的其他值），則返回 True。

例：

print(bool())       # 輸出: False，未提供參數，返回 False

print(bool(0))      # 輸出: False，0 是假值

print(bool([]))     # 輸出: False，空列表是假值

print(bool("hello"))# 輸出: True，非空字符串是真值

print(bool(42))     # 輸出: True，非零數字是真值

需要注意的是

雖然 bool() 函數可以用于將任何值轉換為布爾值，但在 Python 中的條件表達式中，會隱式調用 bool() 函數來判斷條件的真假。例如，在 if 語句中，如果條件為真，則執行 if 語句塊中的代碼；否則，執行 else 語句塊中的代碼。

通過 bool() 函數，你可以輕松地將任何數據類型轉換為一個布爾值，這在編寫條件邏輯時非常有用。

2、int([x], base=10)：將一個數值或字符串轉換為十進制整數

x：要轉換為整數的值。可以是數值型（如整數、浮點數）或字符串型。

base：可選參數，用于指定轉換的進制。默認為 10。如果 x 是字符串，那么 base 表示字符串所表示的進制。

參數為空時輸出0。

例：

print(int('10'))           # 輸出: 10，將字符串 '10' 轉換為十進制整數

print(int('10', 2))        # 輸出: 2，將二進制字符串 '10' 轉換為十進制整數

print(int('10', 16))       # 輸出: 16，將十六進制字符串 '10' 轉換為十進制整數

print(int(3.14))           # 輸出: 3，將浮點數 3.14 轉換為整數，截斷小數部分

print(int(-3.14))          # 輸出: -3，將負浮點數 -3.14 轉換為整數，截斷小數部分

print(int('10', 8))        # 輸出: 8，將八進制字符串 '10' 轉換為十進制整數

print(int('0b10', 0))      # 輸出: 2，將二進制字符串 '0b10' 轉換為十進制整數，根據前綴自動識別進制

需要注意的是

1. 如果 x 是浮點數，int() 函數會將其向零取整（即截斷小數部分）。
2. 如果 x 是字符串，那么字符串必須符合整數的表示方式，否則會拋出 ValueError 異常。
3. x不能是復數，如complex_num = 3 + 4j，否則引發TypeError異常。

3、float([x])：將一個數值或字符串轉換為浮點數

float() 是一個內置函數，用于將一個數值或數值表示的字符串轉換為一個浮點數。

如果參數已經是一個浮點數或整數，那么float() 函數將返回相同的數值，只是類型變為浮點數。

如果參數是一個字符串，那么該字符串必須表示一個有效的浮點數，否則將引發 ValueError 異常。

參數：

x：要轉換為浮點數的值。

x可以是數值型（如整數、浮點數）或字符串型。這個字符串可以包含小數點、指數符號（e 或 E）以及正負號。

例1：將數值轉換為浮點數

# 將整數轉換為浮點數  

num_int = 10  

num_float = float(num_int)  

print(num_float)  # 輸出: 10.0  

print(type(num_float))  # 輸出: <class 'float'>  

  

# 將浮點數轉換為浮點數（實際上不會改變數值，但會改變類型）  

num_float_original = 3.14  

num_float_converted = float(num_float_original)  

print(num_float_converted)  # 輸出: 3.14  

print(type(num_float_converted))  # 輸出: <class 'float'>

例2：將字符串轉換為浮點數

# 字符串轉換為浮點數  

str_num = "3.14"  

float_num = float(str_num)  

print(float_num)  # 輸出: 3.14  

  

# 帶有正負號的字符串也可以轉換  

positive_str = "+42.0"  

negative_str = "-100.5"  

  

positive_float = float(positive_str)  

negative_float = float(negative_str)  

  

print(positive_float)  # 輸出: 42.0  

print(negative_float)  # 輸出: -100.5  

  

# 帶有指數的字符串也可以轉換  

exponential_str = "1.23e-4"  

exponential_float = float(exponential_str)  

print(exponential_float)  # 輸出: 0.000123

注意事項

1. 當使用 float() 函數時，確保傳入的字符串確實表示了一個有效的浮點數，否則將會引發 ValueError 異常。
2. 對于已經是浮點數或整數的參數，float() 函數不會改變其值，但會返回一個新的浮點數對象。
3. 轉換時，如果字符串表示的數值超出了浮點數能夠表示的范圍，將會引發 OverflowError 異常。

4、complex([a=0],[b=0j])：創建一個復數

函數用于創建一個復數。它可以接受兩個參數，分別是實部和虛部，也可以接受一個字符串參數，表示復數的表達式。

兩個參數：

a：第一個參數是復數的實部。

b：第二個參數是復數的虛部。

示例：

# 創建一個復數對象，實部為3，虛部為0

c1 = complex(3)

print(c1)  # 輸出: (3+0j)

# 創建一個復數對象，實部為1，虛部為2

c2 = complex(1, 2)

print(c2)  # 輸出: (1+2j)

# 也可以通過字符串創建復數對象

c3 = complex('5-6j')

print(c3)  # 輸出: (5-6j)

# 創建一個復數，實部為1，虛部為0

c3 = complex(1+0j)  

print(c3)  # 輸出：(1+0j)

復數操作

創建復數后，你可以像操作其他數值類型一樣對其進行操作。例如，可以進行加法、減法、乘法、除法等。

例：

c1 = complex(1, 2)  

c2 = complex(3, 4)  

  

print(c1 + c2)       # 輸出: (4+6j)  

print(c1 - c2)       # 輸出: (-2-2j)  

print(c1 * c2)       # 輸出: (-5+10j)  

print(c1 / c2)       # 輸出: (0.44+0.08j)

print(c1 ** 2)       # 輸出: (-3+4j)

此外，Python的復數還支持一些特殊方法，如共軛（conjugate()）、模（abs() 或 magnitude()）、角度（angle() 或 phase()）等。

例：

c = complex(1, 2)  

print(c.conjugate())    # 輸出: (1-2j)  

print(abs(c))           # 輸出: 2.23606797749979  

print(c.real)           # 輸出: 1.0  

print(c.imag)           # 輸出: 2.0

5、str(object='')：將對象轉換為字符串

str()函數接受一個可選的參數object，該參數可以是任何對象。如果不提供參數，則返回一個空字符串。

這個函數可以接受多種類型的參數，包括數字、列表、元組、字典、其他對象等，并將它們轉換為它們的字符串表示形式。

如果參數是其他對象，str() 函數會嘗試調用該對象的 __str__() 方法來獲取其字符串表示。

例1：將數字轉換為字符串類型

num = 123  

str_num = str(num)  

print(str_num)  # 輸出: '123'  

  

float_num = 3.14  

str_float_num = str(float_num)  

print(str_float_num)  # 輸出: '3.14'  

  

complex_num = complex(1, 2)  

str_complex_num = str(complex_num)  

print(str_complex_num)  # 輸出: '(1+2j)'

另外，如果對象具有__str__()方法，則str()函數將調用該方法以生成其字符串表示形式。這在自定義類中很有用，可以自定義對象的字符串表示形式。

例2：將列表轉換為字符串

my_list = [1, 2, 3, 4, 5]  

str_list = str(my_list)  

print(type(str_list),str_list)  # 輸出:<class 'str'> [1, 2, 3, 4, 5]

例3：將元組轉換為字符串

my_tuple = (1, 2, 3, 4, 5)  

str_tuple = str(my_tuple)  

print(type(str_tuple),str_tuple)  # 輸出: <class 'str'> (1, 2, 3, 4, 5)

例4：將字典轉換為字符串

my_dict = {'a': 1, 'b': 2, 'c': 3}  

str_dict = str(my_dict)  

print(str_dict)  # 輸出: "{'a': 1, 'b': 2, 'c': 3}"

例5：將自定義對象轉換為字符串

如果你有一個自定義的對象，并且你想定義它如何轉換為字符串，你可以在你的類中實現 __str__() 方法。

class Person:  

    def __init__(self, name, age):  

        self.name = name  

        self.age = age  

  

    def __str__(self):  

        return f"Person(name={self.name}, age={self.age})"  

  

person = Person("Alice", 30)  

str_person = str(person)  

print(str_person)  # 輸出: Person(name=Alice, age=30)

注意事項

當使用 str() 函數轉換對象時，它通常調用該對象的 __str__() 方法。這意味著如果你嘗試轉換一個沒有實現 __str__() 方法的對象，Python會提供一個默認的字符串表示，但這可能不是你想要的。

對于復雜的數據結構，如嵌套列表或字典，str() 函數會遞歸地轉換每個元素，生成一個易于閱讀的字符串表示。

如果你想控制如何將對象轉換為字符串，你應該在你的類中實現 __str__() 方法。這個方法應該返回一個字符串，描述了你的對象的狀態。

6、bytearray([source[, encoding[, errors]]])：創建一個可變的字節數組

bytearray() 是 Python 的內置函數，用于創建一個可變的字節數組。字節數組是一個序列，其中包含范圍在 0 <= x < 256 的整數，這些整數表示字節。

參數

source：可選參數，可以是以下幾種類型之一：

一個字節對象，例如從文件或網絡讀取的原始字節。

一個字節數組。

一個字符串，此時需要指定 encoding 參數來指定字符串的編碼方式。

一個可迭代的整數序列，其中每個整數都在 0-255 范圍內。

encoding：可選參數，當 source 是字符串時，此參數指定了字符串的編碼方式。默認是 'utf-8'。

errors：可選參數，當 source 是字符串且編碼/解碼過程中遇到錯誤時，此參數定義了錯誤處理方式。默認是 'strict'，表示拋出異常。

bytearray()函數返回一個新的可變字節數組對象，可以像列表一樣進行修改，包括修改元素值、添加元素、刪除元素等操作。這使得它在需要動態修改字節數據時非常有用。

用法

1：不帶參數，創建一個空的數組

ba = bytearray()  

print(ba)  # 輸出: bytearray(b'')

2：從字節對象創建

b = b'hello'  

ba = bytearray(b)  

print(ba)  # 輸出: bytearray(b'hello')

3：從字符串創建

s = 'hello'  

ba = bytearray(s, 'utf-8')  

print(ba)  # 輸出: bytearray(b'hello')

4：從整數序列創建

numbers = [72, 101, 108, 108, 111]  # ASCII values for 'hello'  

ba = bytearray(numbers)  

print(ba)  # 輸出: bytearray(b'hello')

注意事項

字節數組通常用于低級別的數據處理，例如網絡通信或文件處理，其中直接操作字節是必要的。

與字節數組相對的是不可變的 bytes 類型，你不能修改 bytes 對象的內容。如果你需要一個可以修改的字節序列，應該使用 bytearray。

bytearray 實現了序列協議（例如，它支持索引和切片操作），因此你可以像處理列表或字符串那樣處理它。

7、bytes([source[, encoding[, errors]]])：創建一個不可變的字節對象

字節對象是一個“字節數組”，它用 8 位二進制數字來表示數據。與 bytearray 不同，bytes 對象是不可變的，一旦創建就不能修改。

參數

source：可選參數，可以是以下幾種類型之一：

一個整數，表示要創建的字節對象的長度。

一個字節對象，用于復制。

一個字節數組，用于復制。

一個可迭代的整數序列，其中每個整數都在 0-255 范圍內，用于初始化字節對象。

一個字符串，此時需要指定 encoding 參數來指定字符串的編碼方式。

encoding：可選參數，當 source 是字符串時，此參數指定了字符串的編碼方式。默認是 'utf-8'。

errors：可選參數，當 source 是字符串且編碼/解碼過程中遇到錯誤時，此參數定義了錯誤處理方式。默認是 'strict'。

用法

1. 從整數創建

創建一個指定長度的字節對象，所有字節的初始值都是 0。

b = bytes(5)  

print(b)  # 輸出: b'\x00\x00\x00\x00\x00'

2. 從字節對象或字節數組復制

original_bytes = b'hello'  

copied_bytes = bytes(original_bytes)  

print(copied_bytes)  # 輸出: b'hello'

3. 從整數序列創建

numbers = [72, 101, 108, 108, 111]  # ASCII values for 'hello'  

bytes_obj = bytes(numbers)  

print(bytes_obj)  # 輸出: b'hello'

4. 從字符串創建

s = 'hello'  

bytes_obj = bytes(s, 'utf-8')  

print(bytes_obj)  # 輸出: b'hello'

5.嘗試修改一個 bytes 對象會導致 TypeError  

# b3[0] = 87  # 這將引發錯誤:TypeError: 'bytes' object does not support item assignment

  

6.可以通過索引和切片訪問 bytes 對象的內容  

print(b3[0])  # 輸出: 119，這是 'w' 的 ASCII 值  

print(b3[1:4])  # 輸出: b'orl'

注意事項

1. bytes 對象是不可變的，一旦創建就不能修改。如果你需要一個可以修改的字節序列，應該使用 bytearray。
2. bytes 對象通常用于需要二進制數據表示的場合，如文件讀寫、網絡通信等。
3. 當你需要將字符串轉換為二進制數據時，必須指定一個編碼方式（如 'utf-8'），因為字符串本身是文本數據，而二進制數據是另一種表示方式。
4. bytes 對象支持常見的序列操作，如索引、切片等，但不支持修改操作，如賦值。

8、memoryview(obj)：創建內存視圖對象

在Python中，memoryview 是一個內置類，它提供了一個對底層字節數據的低級別、高效的視圖。使用 memoryview 可以讓你在不復制數據的情況下訪問和修改原始字節序列。這對于處理大型數據塊（如數組、圖像或網絡數據）特別有用，因為它可以減少內存使用和復制操作。

參數

obj：可以是任何實現了緩沖區協議的對象，如字節串（bytes）、字節數組（bytearray）、數組（array）等可緩沖類型對象。

返回值：

返回一個內存視圖對象，可以訪問 obj 對象的內存，但不復制數據。

用法

1、創建 memoryview 對象

# 從字節串創建  

mv_bytes = memoryview(b'hello')  

  

# 從字節數組創建  

ba = bytearray(b'world')  

mv_bytearray = memoryview(ba)  

  

# 從數組創建  

import array  

arr = array.array('i', [1, 2, 3, 4])  

mv_array = memoryview(arr)

2、訪問和修改數據

memoryview 支持切片操作，可以像列表或數組一樣訪問和修改元素。

# 訪問元素  

print(mv_bytes[0])  # 輸出: 104 (ASCII碼中'h'的值)  

  

# 修改元素  

mv_bytearray[0] = ord('H')  

print(ba)  # 輸出: bytearray(b'Hello')  

  

# 切片操作  

print(mv_array[1:3])  # 輸出: <memory at 0x000001A7D25DEC80>

3、將內存視圖對象轉換為字節序列并打印

# 創建一個字節對象

data = b'Hello, world!'

# 創建內存視圖對象

mv = memoryview(data)

# 將內存視圖對象轉換為字節序列并打印

print(mv[1:6].tobytes())  # 輸出：b'ello,'

4、屬性

cast(type, new_flags=0): 創建一個新的 memoryview，其元素類型已更改。

readonly: 一個只讀屬性，指示 memoryview 是否是只讀的。

shape（只讀）: 如果數據具有形狀（如多維數組），則返回形狀。

strides（只讀）: 如果數據具有步幅（如多維數組），則返回步幅。

suboffsets: 如果數據具有子偏移（如嵌套數組），則返回子偏移。

9、ord(c)：返回一個字符的Unicode碼點

Unicode 是一種字符編碼標準，它允許你為每一個字符（不僅僅是字母，還包括符號、數字等）分配一個唯一的數字，這個數字就是碼點。

參數：

c：一個字符（長度為1的字符串）

返回值：

返回一個整數，表示字符 c 的 Unicode 碼點。

用法詳解

ord() 函數非常簡單，只需要傳入一個字符（長度為 1 的字符串），它就會返回這個字符的 Unicode 碼點。

# 示例  

  

# 獲取字符 'A' 的 Unicode 碼點  

code_point = ord('A')  

print(code_point)  # 輸出：65  

  

# 獲取字符 '中' 的 Unicode 碼點  

code_point_zh = ord('中')  

print(code_point_zh)  # 輸出：20013

注意

ord() 函數只能接受長度為 1 的字符串作為參數。如果你嘗試傳入一個長度不為 1 的字符串，Python 會拋出一個 TypeError。

另外，ord() 函數返回的碼點是基于 Unicode 的，所以不同的字符集（如 ASCII、UTF-8 等）可能會有不同的碼點值。例如，在 ASCII 中，大寫字母 'A' 的碼點是 65，而在 Unicode 中也是 65。但對于一些只在 Unicode 中存在的字符（如中文字符），它們的碼點在 ASCII 中是沒有對應的值的。

10、chr(i)：將Unicode碼點轉換為對應的字符。

chr() 函數接受一個整數（即 Unicode 碼點）作為參數，并返回與該整數對應的字符。

參數

i：一個介于 0 和 1,114,111（包含）之間的整數，代表 Unicode 碼點。超出這個范圍的整數會導致 ValueError 異常。

返回值

返回一個字符，該字符的 Unicode 碼點等于傳入的整數 i。

用法詳解

chr() 函數非常直接，只需要傳入一個有效的 Unicode 碼點，它就會返回對應的字符。

# 示例  

  

# 獲取 Unicode 碼點 65 對應的字符  

character = chr(65)  

print(character)  # 輸出：A  

  

# 獲取 Unicode 碼點 20013 對應的字符  

character_zh = chr(20013)  

print(character_zh)  # 輸出：中

注意：

如果傳入的整數不在有效的 Unicode 碼點范圍內，chr() 函數會拋出一個 ValueError 異常。

11、bin(x)：將整數轉換為其二進制字符串表示形式

這個函數返回一個字符串，表示該整數的二進制表示。

參數

x：一個整數，可以是正數、負數或零。

返回值

返回一個字符串，表示整數 x 的二進制表示。這個字符串以 "0b" 或 "0B" 開頭，以指示它是一個二進制字面量。

用法詳解

bin() 函數將整數轉換為二進制字符串。對于正數，它返回該數的二進制表示形式；對于負數，它返回該數的補碼形式的二進制表示。

# 示例  

  

# 將正整數轉換為二進制字符串  

binary_representation = bin(10)  

print(binary_representation)  # 輸出：0b1010  

  

# 將負整數轉換為二進制字符串（補碼形式）  

binary_representation_negative = bin(-10)  

print(binary_representation_negative)  # 輸出：-0b1010  

  

# 將零轉換為二進制字符串  

binary_representation_zero = bin(0)  

print(binary_representation_zero)  # 輸出：0b0

注意：

bin() 函數只能接受整數作為參數。如果你嘗試傳入一個浮點數或非整數類型，Python 會拋出一個 TypeError 異常。

12、oct(x)：將整數轉換為其八進制字符串表示形式

這個函數返回一個字符串，表示該整數的八進制（octal）表示。

參數

x：一個整數，可以是正數、負數或零。

返回值

返回一個字符串，表示整數 x 的八進制表示。這個字符串以 "0o" 或 "0O" 開頭，以指示它是一個八進制字面量。

用法詳解

oct() 函數將整數轉換為八進制字符串。對于正數，它返回該數的八進制表示形式；對于負數，它返回該數的補碼形式的八進制表示。

# 示例  

  

# 將正整數轉換為八進制字符串  

octal_representation = oct(10)  

print(octal_representation)  # 輸出：0o12  

  

# 將負整數轉換為八進制字符串（補碼形式）  

octal_representation_negative = oct(-10)  

print(octal_representation_negative)  # 輸出：-0o12  

  

# 將零轉換為八進制字符串  

octal_representation_zero = oct(0)  

print(octal_representation_zero)  # 輸出：0o0

注意：

oct() 函數只能接受整數作為參數。如果你嘗試傳入一個浮點數或非整數類型，Python 會拋出一個 TypeError 異常。

13、hex(x)：將整數轉換為16進制

hex() 函數是 Python 的內置函數，用于將整數轉換為其十六進制（hexadecimal）字符串表示形式。這個函數返回一個字符串，表示該整數的十六進制表示。

參數

x：一個整數，可以是正數、負數或零。

返回值

返回一個字符串，表示整數 x 的十六進制表示。這個字符串以 "0x" 或 "0X" 開頭，以指示它是一個十六進制字面量。

用法詳解

hex() 函數將整數轉換為十六進制字符串。對于正數，它返回該數的十六進制表示形式；對于負數，它返回該數的補碼形式的十六進制表示。

# 示例  

  

# 將正整數轉換為十六進制字符串  

hexadecimal_representation = hex(255)  

print(hexadecimal_representation)  # 輸出：0xff  

  

# 將負整數轉換為十六進制字符串（補碼形式）  

hexadecimal_representation_negative = hex(-255)  

print(hexadecimal_representation_negative)  # 輸出：-0xff  

  

# 將零轉換為十六進制字符串  

hexadecimal_representation_zero = hex(0)  

print(hexadecimal_representation_zero)  # 輸出：0x0

hex() 函數只能接受整數作為參數。如果你嘗試傳入一個浮點數或非整數類型，Python 會拋出一個 TypeError 異常。

14、tuple(iterable)：創建元組或將其他可迭代對象轉換為元組。

元組也可以使用圓括號包圍元素，元素之間用逗號分隔的方式創建。如a=(1,2,3,'a','b')。

用圓括號創建元組時，如元組只有一個元素，需要在該元素后面添加一個逗號，如b=(1,)。

參數：

iterable：可迭代對象，如列表、字符串、集合等。

返回值：

返回一個新的元組，包含可迭代對象中的元素。

訪問元組元素

可以通過索引來訪問元組中的元素，索引從 0 開始。

例：

# 創建元組

t1 = tuple([1, 2, 3])

print(t1)  # 輸出: (1, 2, 3)

# 將字符串轉換為元組

t2 = tuple("hello")

print(t2)  # 輸出: ('h', 'e', 'l', 'l', 'o')

# 使用 tuple() 函數復制其他可迭代對象

t3 = tuple(range(5))

print(t3)  # 輸出: (0, 1, 2, 3, 4)

# 使用索引輸出元素

print(t3[1])    # 輸出：1

元組操作

由于元組是不可變的，因此不能對元組進行增加、刪除或修改元素的操作。但可以進行一些其他操作，如連接、重復、切片等。

# 連接兩個元組  

t1 = (1, 2, 3)  

t2 = (4, 5, 6)  

t3 &#