概述

????????在上一節，我們介紹了Python的基礎語法，包括：編碼格式、標識符、關鍵字、注釋、多行、空行、縮進、引號、輸入輸出、import、運算符、條件控制、循環等內容。Python是一種動態類型的編程語言，這意味著當你創建一個變量時，不需要提前聲明它的數據類型。Python會自動處理這種情況，并在需要時進行類型轉換。

????????Python提供了豐富多樣的數據類型，以滿足各種不同的編程需求。理解和掌握這些數據類型的特點、屬性和用法，對于編寫高效、可靠的Python代碼至關重要。Python中的數據類型可以分為兩種：基礎類型和復雜類型。基礎類型包括：數字、字符串等，復雜類型包括：列表、元組、集合、字典等。

????????Python的數據類型可以分為兩個大類：不可變數據類型和可變數據類型。

????????不可變數據類型是指：當該數據類型對應變量的值發生了改變，它對應的內存地址也會發生改變。不可變數據類型包括：數字、字符串、元組。比如：變量a=66后，再賦值a=88，這里實際是新生成了一個數字對象88，再讓 a指向它，而原來的數字對象66被丟棄；此時并沒有改變a的值，相當于新生成了a。

????????可變數據類型是指：當該數據類型對應變量的值發生了改變，它對應的內存地址不會發生改變。可變數據類型包括：列表、集合、字典。比如：變量a=[98, 99, 100]后，再賦值a[1]=50，只是將a的第二個元素值更改，a本身沒有修改。

Number（數字）

????????Python中的數字支持4種類型，分別為：int、float、bool和complex。

????????整型（int）：用于表示正整數、負整數和0，其取值范圍是無限的。

????????浮點型（float）：用于表示帶有小數點的數值，浮點型的大小也是無限的，可以表示很大的浮點數。

????????布爾型（bool）：用于表示真、假兩種狀態，只有兩個取值：True和False，常用于邏輯運算和控制語句。

????????復數型（complex）：由實部和虛部組成，可以用a + bj的形式表示，其中，a為實部，b為虛部。在Python中，還可以使用complex函數來創建一個復數，比如：a = complex(66, 88)。

????????那么，如何區分這4種數字類型呢？可以使用type函數和isinstance函數。type函數用于獲取某個變量的數據類型，isinstance函數用于判斷某個變量是否為某個數據類型的實例（包括父類實例和子類實例）。

a = 10
b = 6.9
c = True
d = 25 + 36j
# 輸出：<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
print(type(a), type(b), type(c), type(d))# 以下均輸出：True
print(isinstance(a, int))
print(isinstance(b, float))
print(isinstance(c, bool), isinstance(c, int))
print(isinstance(d, complex))

????????另外，布爾型是整型的子類，這也就意味著，True和False可以與數字進行算數運算。True相當于1，False相當于0。

a = True + 5
b = 9 - False
# 輸出：6 9 True True
print(a, b, True == 1, False == 0)

String（字符串）

????????字符串是Python中的文本數據，用于表示一串字符。字符串是由單引號、雙引號或三引號括起來的多個字符組成的序列，其長度（即字符數）可以是任意的。字符串從左邊算起時，索引從0開始計數；從右邊算起時，索引從-1開始計數。

?????????要獲取字符串的子串，可以使用變量[下標]或變量[頭下標:尾下標]的格式。變量[下標]只能獲取包含單個字符的字符串，變量[頭下標:尾下標]能獲取頭下標到尾下標之間（注意：包括頭下標，不包括尾下標）的字符串。頭下標不寫時，默認為0；尾下標不寫時，默認為到最右邊的所有字符。字符串的下標可以超過索引范圍，超過后，會自動被限制為可用的極限值。

a = 'hello'
# 輸出：hello
print(a)
# 輸出：e
print(a[1])
# 輸出：hell
print(a[0:-1])
# 輸出：hello
print(a[0:])
# 輸出：hell
print(a[:-1])
# 輸出：hello
print(a[:])
# 輸出：el
print(a[1:-2])
# 輸出：hel
print(a[-5:3])
# 輸出：hello
print(a[-16:99])

????????字符串還可以使用+符號進行拼接，使用*符號進行拷貝，使用\符號轉義特殊字符。當然，如果不想讓\符號發生轉義，也是可以的：在字符串前面添加一個r或R即可，以表示后面的是一個原始字符串。

a = 'hello'
b = a + ' CSDN'
# 輸出：hello CSDN
print(b)c = a * 2
# 輸出：hellohello
print(c)d = 3 * a
# 輸出：hellohellohello
print(d)e = 'hello\nCSDN'
# 輸出：hello
#CSDN
print(e)f = r'hello\nCSDN'
# 輸出：hello\nCSDN
print(f)

????????與C/C++、Java等語言不同，Python中的字符串不能被改變。試圖向字符串的索引位置賦值時，比如：a[1]='P'，會提示類似下面的錯誤信息：'str' object does not support item assignment。Python也沒有單獨的字符類型（比如：C/C++中的char類型），一個字符就是長度為1的字符串。

List（列表）

????????列表是Python中的有序集合數據類型，可以包含任意類型的元素（同一個列表中的數據類型可以不同）。列表是通過方括號括起來，用逗號進行分隔的元素序列，支持各種操作，包括：元素的添加、刪除、修改、查找等。

????????與字符串一樣，列表也可以被索引和截取。列表被截取后，返回一個包含所需元素的新列表。

a = [10, 20, 30, 40, 50]
# 輸出：20 50 [30, 40] [30, 40, 50]
print(a[1], a[-1], a[2:-1], a[2:])
# 輸出：[10, 20, 30, 40, 50]
print(a[-10:10])

????????列表還可以使用+符號進行拼接，使用*符號進行拷貝。如果要判斷一個元素是否在列表中，可以使用in關鍵字。如果要遍歷一個列表，則可以使用for in。反向遍歷時，使用[::-1]。第一個冒號兩邊省略數字，表示所有元素；第二個冒號右邊為-1，表示列表元素反向遍歷。

a = [10, 20, 30]
# 輸出：[10, 20, 30, 10, 20, 30]
print(a * 2)
# 輸出：[10, 20, 30, 1, 2]
print(a + [1, 2])
# 輸出：False True
print(66 in a, 20 in a)
# 正向遍歷，依次輸出：10 20 30
for item in a:print(item)
# 反向遍歷，依次輸出：30 20 10
for item in a[::-1]:print(item)

????????Python中包含一些全局方法，用于獲取列表的元素個數、列表元素的最大值、列表元素的最小值、列表元素的總和，分別為：len、max、min、sum。

a = [10, 20, 30]
# 輸出：3
print(len(a))
# 輸出：30
print(max(a))
# 輸出：10
print(min(a))
# 輸出：60
print(sum(a))

????????除了全局方法，列表自身還有一些成員方法，用于對列表進行添加、插入、移除、統計、反轉等操作，分別為：append、insert、remove、count、reverse等。

a = [10, 20, 30]
a.append(66)
a.append(20)
# 輸出：[10, 20, 30, 66, 20]
print(a)
# 統計元素20的個數，輸出：2
print(a.count(20))
# 查找第一個值匹配的元素的位置，輸出：2
print(a.index(30))
# 100不在列表中，運行會報錯：100 is not in list
# print(a.index(100))
# 移除最后一個元素并返回，輸出：20
print(a.pop())
# 輸出：[10, 20, 30, 66]
print(a)
# 在某個位置插入一個元素
a.insert(0, 99)
# 輸出：[99, 10, 20, 30, 66]
print(a)
# 反轉列表
a.reverse()
# 輸出：[66, 30, 20, 10, 99]
print(a)
# 移除第一個值匹配的元素
a.remove(30)
# 輸出：[66, 20, 10, 99]
print(a)
# 35不在列表中，運行會報錯：x not in list
# a.remove(35)
# 追加另一個序列中的元素
a.extend(["hello", "CSDN"])
# 輸出：[66, 20, 10, 99, 'hello', 'CSDN']
print(a)
# 清空列表
a.clear()
# 輸出：[]
print(a)

????????注意：列表的index和remove方法在找不到元素時，運行時會報錯，而不是像其他語言一樣返回-1，或者什么也不做。因此，使用index和remove方法，更好的方式是像下面這樣。

a = [10, 20, 30]
index = a.index(66) if 66 in a else -1
# 輸出：-1
print(index)
if 20 in a:a.remove(20)
# 輸出：[10, 30]
print(a)

????????列表的比較可以直接使用>、<、==、!=等運算符。只有當兩個列表的元素個數、每個位置上的元素的類型和值都相等時，兩個列表才相等。注意：不同類型的列表不能比較，運行時會報類似下面的錯誤信息：'<' not supported between instances of 'int' and 'str'。

a = [10, 20, 30]
b = [20, 10, 30]
# 輸出：False
print(a > b)
b = [10, 20, 30]
# 輸出：True
print(a == b)
b = ['hello', 'CSDN']
# 不同類型的列表比較會報錯，提示：'<' not supported between instances of 'int' and 'str'
# print(a < b)

Tuple（元組）

????????元組與列表類似，是由小括號括起來的元素序列，通常用于表示一組固定的數據。與列表不同，元組是不可變的，也就是說，無法修改元組中的元素。

????????注意：當元組中只包含一個元素時，需要在該元素后面添加逗號。否則，小括號會被當作運算符使用，導致類型不正確。

a = ('hello', 'CSDN', 'Go')
# 輸出：<class 'tuple'>
print(type(a))
a = ()
# 空元組，輸出：<class 'tuple'>
print(type(a))
a = (66)
# 一個元素時，沒有逗號，a被認為是整型，輸出：<class 'int'>
print(type(a))
a = (66, )
# 一個元素時，有逗號，a被認為是元組，輸出：<class 'tuple'>
print(type(a))

????????與字符串、列表一樣，元組也可以被索引和截取，并支持+符號拼接、*符號拷貝，以及len、max、min、sum等全局方法，這里就不再贅述了。元組中的元素是不允許被修改的，嘗試給其賦值（比如：a[0] = 66）會提示類似下面的錯誤信息：'tuple' object does not support item assignment。

a = (10, 20, 30, 40, 50)
# 輸出：20 50 (30, 40) (30, 40, 50)
print(a[1], a[-1], a[2:-1], a[2:])
# 輸出：(10, 20, 30, 40, 50)
print(a[-10:10])a = (10, 20, 30)
# 輸出：(10, 20, 30, 10, 20, 30)
print(a * 2)
# 輸出：(10, 20, 30, 1, 2)
print(a + (1, 2))
# 輸出：False True
print(66 in a, 20 in a)
# 正向遍歷，依次輸出：10 20 30
for item in a:print(item)
# 反向遍歷，依次輸出：30 20 10
for item in a[::-1]:print(item)a = (10, 20, 30)
# 輸出：3
print(len(a))
# 輸出：30
print(max(a))
# 輸出：10
print(min(a))
# 輸出：60
print(sum(a))

Set（集合）

????????Python中的集合是由大括號括起來的無序的元素序列，不能包含重復的元素。集合支持數學中的集合運算，比如：并集、交集、差集等。要創建一個集合，可以使用大括號{}或者set函數。注意：創建一個空集合，必須使用set函數，而不能使用{}，因為{}被用來創建下面將要介紹的空字典。

a = {66, 88, 99}
# 使用大括號創建集合，輸出：{88, 66, 99}
print(a)
a = {66, 88, 99, 66, 88}
# 集合會自動移除重復元素，輸出：{88, 66, 99}
print(a)
a = set(['a', 'b', 'c'])
# 使用set函數從列表創建集合，輸出：{'a', 'c', 'b'}
print(a)
a = set('CSDN')
# 使用set函數從字符串創建集合，輸出：{'S', 'N', 'D', 'C'}
print(a)
a = set()
# 使用set函數創建空集合，輸出：set()
print(a)

????????向集合中添加元素可以使用add函數，向集合中添加元素、列表、元組、字典可以使用update函數。如果元素在集合中已存在，則不進行任何操作。從集合中移除元素可以使用remove函數和discard函數，其區別在于：如果元素不存在，remove函數會報錯，而discard函數則不會報錯。pop函數可以隨機移除集合中的一個元素，當集合為空時，pop函數會報錯。clear函數用于清空集合中的所有元素。

a = {66, 88, 99}
# 輸出：3
print(len(a))
a.add(100)
# 輸出：{88, 66, 99, 100}
print(a)
a.update([1, 2, 3])
# 輸出：{1, 66, 99, 100, 2, 3, 88}
print(a)
a.remove(1)
# 輸出：{66, 99, 100, 2, 3, 88}
print(a)
a.discard(2)
a.discard(5)
# 輸出：{66, 99, 100, 3, 88}
print(a)
a.pop()
# 輸出：{99, 100, 3, 88}
print(a)
a.clear()
# 輸出：set()
print(a)

????????集合還支持數學中的集合運算，比如：并集、交集、差集等。運算符|、&、-、^分別用于計算兩個集合的并集、交集、差集、異或集，對應函數union、intersection、difference、symmetric_difference。

a = set('hello')
b = set('hope')
# 計數集合a和b的并集，輸出：{'e', 'p', 'h', 'o', 'l'}
print(a | b)
# 計數集合a和b的交集，輸出：{'e', 'h', 'o'}
print(a & b)
# 計數在集合a，不在集合b的元素，輸出：{'l'}
print(a - b)
# 計算不同時包含于集合a和b的元素，輸出：{'l', 'p'}
print(a ^ b)# 計數集合a和b的并集，輸出：{'e', 'p', 'h', 'o', 'l'}
print(a.union(b))
# 計數集合a和b的交集，輸出：{'e', 'h', 'o'}
print(a.intersection(b))
# 計數在集合a，不在集合b的元素，輸出：{'l'}
print(a.difference(b))
# 計算不同時包含于集合a和b的元素，輸出：{'l', 'p'}
print(a.symmetric_difference(b))

Dictionary（字典）

????????字典是Python中的鍵值對數據類型，用于存儲鍵值對映射關系。字典是由鍵值對組成的無序集合，鍵必須是唯一的，值可以不唯一。字典的內容在大括號{}內，鍵值對之間使用逗號進行分隔，鍵值之間使用冒號進行分隔。

a = {}
# 空字典，輸出：{} 0 <class 'dict'>
print(a, len(a), type(a))
a = {'red': 6, 'blue': 9, 'green': 12}
# 輸出：9
print(a['blue'])
# 鍵不存在時，運行會報錯：KeyError: 'black'
# print(a['black'])
if 'white' not in a:print('white not in a')
# 移除某個鍵，必須確保鍵存在，否則運行時會報錯
del a['green']
# 輸出：{'red': 6, 'blue': 9}
print(a)

????????字典提供快速查找、訪問鍵值對的功能和接口。

????????get(key, default=None)：返回指定鍵的值，如果鍵不在字典中，則返回default設置的默認值。

????????setdefault(key, default=None)：如果key在字典中，返回對應的值。如果不在字典中，則插入key及設置的默認值 default，并返回 default。

????????pop(key[,default])：刪除字典key所對應的值，返回被刪除的值。

????????popitem()：返回并刪除字典中的最后一對鍵和值。

????????items()：返回一個鍵值對的視圖對象。

????????keys()：返回一個鍵的視圖對象。

????????values()：返回一個值的視圖對象。

????????clear()：刪除字典內所有元素。

????????fromkeys(seq[, value])：創建一個新字典，以序列seq中的元素做字典的鍵，value為字典所有鍵對應的初始值。

a = {'red': 6, 'blue': 9, 'green': 12}
# 輸出：9
print(a.get('blue'))
# 輸出：100
print(a.get('black', 100))
# 輸出：12
print(a.setdefault('green'))
# 輸出：100
print(a.setdefault('white', 100))
# 輸出：{'red': 6, 'blue': 9, 'green': 12, 'white': 100}
print(a)
a.pop('red')
# 輸出：{'blue': 9, 'green': 12, 'white': 100}
print(a)
a.popitem()
# 輸出：{'blue': 9, 'green': 12}
print(a)
# 依次輸出：blue 9, green 12
for m, n in a.items():print(m, n)
# 依次輸出：blue, green
for k in a.keys():print(k)
# 依次輸出：9, 12
for v in a.values():print(v)
a.clear()
# 輸出：{}
print(a)
a = dict.fromkeys(['lemon', 'apple', 'banana'], 99)
# 輸出：{'lemon': 99, 'apple': 99, 'banana': 99}
print(a)