↑↑↑點擊上方藍字，回復資料，10個G的驚喜
作者：陳tooyoung@阿裏雲Python訓練營 博客地址： /weixin_43509371/article/details/108522941
Python 是壹種通用編程語言，其在科學計算和機器學習領域具有廣泛的應用。如果我們打算利用 Python 來執行機器學習，那麽對 Python 有壹些基本的了解就是至關重要的。本 Python 入門系列體驗就是為這樣的初學者精心準備的。
列表的定義
列表的創建
向列表中添加元素
刪除列表中的元素
獲取列表中的元素
列表的常用操作符
列表的其他方法
元組
創建和訪問壹個元組
更新和刪除壹個元組
元組相關的操作符
內置方法
解壓元組
列表簡單數據類型
整型
浮點型
布爾型
容器數據類型
列表
元組
字典
集合
字符串
列表的定義列表是有序集合，沒有固定大小，能夠保存任意數量任意類型的 Python 對象，語法為[元素1, 元素2, ..., 元素n]。
關鍵點是「中括號 []」和「逗號 ,」
中括號 把所有元素綁在壹起
逗號 將每個元素壹壹分開
列表的創建 創建壹個普通列表x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(x, type(x))
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x = [2, 3, 4, 5, 6, 7]
print(x, type(x))
# [2, 3, 4, 5, 6, 7]
利用range()創建列表x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9]
x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2]
利用推導式創建列表x = [0] * 5
print(x, type(x))
# [0, 0, 0, 0, 0]
x = [0 for i in range(5)]
print(x, type(x))
# [0, 0, 0, 0, 0]
x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = [i for i in range(1, 10, 2)]
print(x, type(x))
# [1, 3, 5, 7, 9]
x = [i for i in range(10, 1, -2)]
print(x, type(x))
# [10, 8, 6, 4, 2]
x = [i ** 2 for i in range(1, 10)]
print(x, type(x))
# [1, 4, 9, 16, 25, 36, 49, 64, 81]
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))
# [3, 9, 15, 21, 27, 33, 39,
註意：
由於list的元素可以是任何對象，因此列表中所保存的是對象的指針。即使保存壹個簡單的[1,2,3]，也有3個指針和3個整數對象。
x = [a] * 4操作中，只是創建4個指向list的引用，所以壹旦a改變，x中4個a也會隨之改變。
x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]]
創建壹個混合列表mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix, type(mix))
# [1, 'lsgo', 3.14, [1, 2, 3]]
創建壹個空列表empty = []
print(empty, type(empty)) # []
列表不像元組，列表內容可更改 (mutable)，因此附加 (append,extend)、插入 (insert)、刪除 (remove,pop) 這些操作都可以用在它身上。
向列表中添加元素
list.append(obj)在列表末尾添加新的對象，只接受壹個參數，參數可以是任何數據類型，被追加的元素在 list 中保持著原結構類型。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.append('Thursday')
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday']
print(len(x)) # 6
此元素如果是壹個 list，那麽這個 list 將作為壹個整體進行追加，註意append()和extend()的區別。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]
print(len(x)) # 6
list.extend(seq)在列表末尾壹次性追加另壹個序列中的多個值（用新列表擴展原來的列表）
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.extend(['Thursday', 'Sunday'])
print(x)
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']
print(len(x)) # 7
嚴格來說append是追加，把壹個東西整體添加在列表後，而extend是擴展，把壹個東西裏的所有元素添加在列表後。
list.insert(index, obj)在編號index位置插入obj。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']
print(len(x)) # 6
刪除列表中的元素
list.remove(obj)移除列表中某個值的第壹個匹配項
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']x.remove('Monday')
print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']
list.pop([index=-1])移除列表中的壹個元素（默認最後壹個元素），並且返回該元素的值
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']y = x.pop()
print(y) # Friday
y = x.pop(0)
print(y) # Monday
y = x.pop(-2)
print(y) # Wednesday
print(x) # ['Tuesday', 'Thursday']
remove和pop都可以刪除元素，前者是指定具體要刪除的元素，後者是指定壹個索引。
del var1[, var2 ……]刪除單個或多個對象。
如果知道要刪除的元素在列表中的位置，可使用del語句。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x) # ['Wednesday', 'Thursday', 'Friday']
獲取列表中的元素
通過元素的索引值，從列表獲取單個元素，註意，列表索引值是從0開始的。
通過將索引指定為-1，可讓Python返回最後壹個列表元素，索引 -2 返回倒數第二個列表元素，以此類推。
x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]print(x[0], type(x[0])) # Monday
print(x[-1], type(x[-1])) # ['Thursday', 'Friday']
print(x[-2], type(x[-2])) # Wednesday
切片的通用寫法是start : stop : step
"start :"
以step為 1 (默認) 從編號start往列表尾部切片。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(x[3:]) # ['Thursday', 'Friday']
print(x[-3:]) # ['Wednesday', 'Thursday', 'Friday']
": stop"
以step為 1 (默認) 從列表頭部往編號stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[:3]) # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3]) # ['Monday', 'Tuesday']
"start : stop"
以step為 1 (默認) 從編號start往編號stop切片。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[1:3]) # ['Tuesday', 'Wednesday']
print(week[-3:-1]) # ['Wednesday', 'Thursday']
- "start : stop : step"
以具體的step從編號start往編號stop切片。註意最後把step設為 -1，相當於將列表反向排列。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[1:4:2]) # ['Tuesday', 'Thursday']
print(week[:4:2]) # ['Monday', 'Wednesday']
print(week[1::2]) # ['Tuesday', 'Thursday']
print(week[::-1])
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
" : "
復制列表中的所有元素（淺拷貝）。
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']print(week[:])
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
淺拷貝與深拷貝list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 456, 789, 213]
print(list3) # [123, 456, 789, 213]
list1.sort()
print(list2) # [123, 213, 456, 789]
print(list3) # [123, 456, 789, 213]
list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2) # [[123, 456], [789, 213]]
print(list3) # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2) # [[111, 456], [789, 213]]
print(list3) # [[111, 456], [789, 213]]
列表的常用操作符
等號操作符：==
連接操作符+
重復操作符*
成員關系操作符in、not in
「等號 ==」，只有成員、成員位置都相同時才返回True。
列表拼接有兩種方式，用「加號 +」和「乘號 *」，前者首尾拼接，後者復制拼接。
list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]
print(list1 == list2) # False
print(list1 == list3) # True
list4 = list1 + list2 # extend()
print(list4) # [123, 456, 456, 123]
list5 = list3 * 3
print(list5) # [123, 456, 123, 456, 123, 456]
list3 *= 3
print(list3) # [123, 456, 123, 456, 123, 456]
print(123 in list3) # True
print(456 not in list3) # False
前面三種方法（append,extend,insert）可對列表增加元素，它們沒有返回值，是直接修改了原數據對象。 而將兩個list相加，需要創建新的 list 對象，從而需要消耗額外的內存，特別是當 list 較大時，盡量不要使用 “+” 來添加list。
列表的其它方法
list.count(obj)統計某個元素在列表中出現的次數
list1 = [123, 456] * 3
print(list1) # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num) # 3
list.index(x[, start[, end]])從列表中找出某個值第壹個匹配項的索引位置
list1 = [123, 456] * 5
print(list1.index(123)) # 0
print(list1.index(123, 1)) # 2
print(list1.index(123, 3, 7)) # 4
list.reverse()反向列表中元素
x = [123, 456, 789]
x.reverse()
print(x) # [789, 456, 123]
list.sort(key=None, reverse=False)對原列表進行排序。
key-- 主要是用來進行比較的元素，只有壹個參數，具體的函數的參數就是取自於可叠代對象中，指定可叠代對象中的壹個元素來進行排序。
reverse-- 排序規則，reverse = True降序，reverse = False升序（默認）。
該方法沒有返回值，但是會對列表的對象進行排序。
x = [123, 456, 789, 213]x.sort()
print(x)
# [123, 213, 456, 789]
x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]
# 獲取列表的第二個元素
def takeSecond(elem):
return elem[1]
x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]
x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]
元組
「元組」定義語法為：(元素1, 元素2, ..., 元素n)
小括號把所有元素綁在壹起
逗號將每個元素壹壹分開
創建和訪問壹個元組Python 的元組與列表類似，不同之處在於tuple被創建後就不能對其進行修改，類似字符串。
元組使用小括號，列表使用方括號。
元組與列表類似，也用整數來對它進行索引 (indexing) 和切片 (slicing)。
t1 = (1, 10.31, 'python')t2 = 1, 10.31, 'python'
print(t1, type(t1))
# (1, 10.31, 'python')
print(t2, type(t2))
# (1, 10.31, 'python')
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple1[1]) # 2
print(tuple1[5:]) # (6, 7, 8)
print(tuple1[:5]) # (1, 2, 3, 4, 5)
tuple2 = tuple1[:]
print(tuple2) # (1, 2, 3, 4, 5, 6, 7, 8)
創建元組可以用小括號 ()，也可以什麽都不用，為了可讀性，建議還是用 ()。
元組中只包含壹個元素時，需要在元素後面添加逗號，否則括號會被當作運算符使用。
x = (1)print(type(x)) #
x = 2, 3, 4, 5
print(type(x)) #
x = []
print(type(x)) #
x = ()
print(type(x)) #
x = (1,)
print(type(x)) #
print(8 * (8)) # 64
print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)
創建二維元組。
x = (1, 10.31, 'python'), ('data', 11)
print(x)
# ((1, 10.31, 'python'), ('data', 11))
print(x[0])
# (1, 10.31, 'python')
print(x[0][0], x[0][1], x[0][2])
# 1 10.31 python
print(x[0][0:2])
# (1, 10.31)
更新和刪除壹個元組week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week) # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')
元組有不可更改 (immutable) 的性質，因此不能直接給元組的元素賦值，但是只要元組中的元素可更改 (mutable)，那麽我們可以直接更改其元素，註意這跟賦值其元素不同。
t1 = (1, 2, 3, [4, 5, 6])
print(t1) # (1, 2, 3, [4, 5, 6])
t1[3][0] = 9
print(t1) # (1, 2, 3, [9, 5, 6])
元組相關的操作符
等號操作符：==
連接操作符+
重復操作符*
成員關系操作符in、not in
「等號 ==」，只有成員、成員位置都相同時才返回True。
元組拼接有兩種方式，用「加號 +」和「乘號 *」，前者首尾拼接，後者復制拼接。
t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)
print(t1 == t2) # False
print(t1 == t3) # True
t4 = t1 + t2
print(t4) # (123, 456, 456, 123)
t5 = t3 * 3
print(t5) # (123, 456, 123, 456, 123, 456)
t3 *= 3
print(t3) # (123, 456, 123, 456, 123, 456)
print(123 in t3) # True
print(456 not in t3) # False
內置方法
元組大小和內容都不可更改，因此只有count和index兩種方法。
t = (1, 10.31, 'python')
print(t.count('python')) # 1
print(t.index(10.31)) # 1
count('python')是記錄在元組t中該元素出現幾次，顯然是 1 次
index(10.31)是找到該元素在元組t的索引，顯然是 1
解壓元組解壓（unpack）壹維元組（有幾個元素左邊括號定義幾個變量）
t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python
解壓二維元組（按照元組裏的元組結構來定義變量）
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python
如果妳只想要元組其中幾個元素，用通配符「*」，英文叫 wildcard，在計算機語言中代表壹個或多個元素。下例就是把多個元素丟給了rest變量。
t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c) # 1 2 5
print(rest) # [3, 4]
如果妳根本不在乎 rest 變量，那麽就用通配符「*」加上下劃線「_」。
t = 1, 2, 3, 4, 5
a, b, *_ = t
print(a, b) # 1 2