Python常用的數據結構
- 2022 年 1 月 16 日
- 筆記
- python編程學習
一、list 列表
1、列表的特點
有序的，元素可以重複，列表中的元素可以進行增上改查，可以存放不同的數據類型
2、創建列表
-
中括弧創建並填充 —>[]
-
通過構造函數創建 list()
-
列表推導式 —>
[x for x in li if x ...]
"""創建列表""" # 1、通過構造函數創建 list() li = list() print(li, type(li)) li1 = list('helloworld') print(li1, type(li1)) # 2、中括弧創建並填充 [] li2 = [1, 2, 3, 4, 4] li3 = ['helloworld', 'apple'] li4 = [1, 3.4, True, 'tea', [1, 2, 3]] print(li2, type(li2)) print(li3, type(li3)) print(li4, type(li4)) # 3、列表推導式 li5 = [i for i in range(1, 10) if i % 2 == 0] print(li5, type(li5))
3、列表索引
-
默認正向索引，編號從 0 開始。
-
"列表索引" list1 = [1, 3, 5, 6, 8, 10] # 默認正向索引，編號從 0 開始。 print(list1[0]) print(list1[3]) # 支援反向索引，編號從-1 開始。 print(list1[-6]) print(list1[-3])
4、列表切片 [start:stop:step]
-
start 值: 指示開始索引值，如果沒有指定，則默認開始值為 0；
-
stop 值: 指示到哪個索引值結束，但不包括這個結束索引值。如果沒有指定，則取列表允許的最大索引值；
-
step 值: 步長值指示每一步大小，如果沒有指定，則默認步長值為 1。
-
三個值都是可選的，非必填
li = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's'] print(li[2:4]) print(li[3:6]) print(li[2:7]) print(li[2:]) print(li[3:6:2]) print(li[2:8:4]) print(li[2:8:]) print(li[2::]) print(li[:2]) print(li[::3]) print(li[::-1]) # 逆序列印
5、列表運算符
-
重複
-
使用
*運算符可以重複生成列表元素。
-
-
合併
-
使用
+加號運算符，可以將兩個列表合二為一
li1 = [1, 2] * 5 li2 = [1, 2, 3] li3 = [1, 2, 4, 5] # 重複 使用 `*` 運算符可以重複生成列表元素。 print(li1) # 合併 使用 `+` 加號運算符，可以將兩個列表合二為一。 print(li2 + li3)
6、列表成員檢測
-
-
not in：檢查一個列表是否不包含某個元素。如果不在返回 True，否則返回 False。
li3 = [1, 2, 4, 5] print(1 in li3) print(6 not in li3) print(8 is li3)
-
append()
| 入參：對象 item |
# append() list1 = [] print(list1) list1.append(1) list1.append(3.14) list1.append("apple") print(list1)
- extend()
| 入參：可迭代對象 iterable |
# extend() list1 = [1, 2, 3, 4, 'apple'] print(list1) list1.extend('HelloWorld') # 添加的是字元串的所有字母 list1.extend([8, 89, 185]) # 接收列表的所有元素 list1.extend((1, 5)) # 接收元組的所有元素 list1.extend({"a": 1}) # 接收字典的所有key值 print(list1)
- insert()
| 入參：索引值 index ，一個對象 item |
| 返回：None |
# insert() lis1 = [1, 2, 4, 6, 9] print(lis1) lis1.insert(0, 3) print(lis1) lis1.insert(4, "apple") print(lis1)
- pop()
| 彈出並返回所指定索引的元素。 |
| 入參：索引值 index，可不傳 |
| 返回：指定索引的元素 |
| 返回：未指定索引則返回末尾元素 |
| 如果索引值不正確，或者列表已經為空，則引發 IndexError |
# pop() letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's'] print(letters, len(letters)) # letters.pop(8) # 報錯：IndexError: pop index out of range letters.pop(0) print(letters, len(letters)) letters.pop() print(letters, len(letters)) letters.pop() print(letters, len(letters)) letters.pop(3) print(letters, len(letters))
- remove()
| 移除列表中第一個等於 item 的元素 |
| 入參：指定元素 item |
| 返回：None |
# remove() letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's'] print(letters, len(letters)) # letters.remove('p') # 報錯，不存在 ValueError: list.remove(x): x not in list letters.remove('t') print(letters, len(letters))
- sort()
| 對列表進行原地排序，只使用 < 來進行各項間比較。 |
| 入參：支援 2 個關鍵字參數： |
key：指定帶有一個參數的函數，用於從每個列表元素中提取比較鍵。 |
reverse：默認值為 False 表示升序，為 True 表示降序 |
# sort() nums = [2, 4, 3, 1, 5] print(nums) # 不傳參數，默認升序，數字從小到大排列 nums.sort() print(nums) # 指定key=len，按元素的長度排序 words = ['Python', 'Java', 'R', 'Go'] print(words) words.sort(key=len) print(words) # 指定reverse=True，降序 lis1 = [1, 2, 4, 6, 9] print(lis1) lis1.sort(reverse=True) print(lis1)
- reverse()
| 參數：無 |
| 返回：None |
# reverse() nums = [8, 1, 5, 2, 77] print(nums) nums.reverse() print(nums)
8、列表嵌套
-
創建嵌套列表
-
"""列表嵌套""" # 創建嵌套列表 num = [[1, 2, 3], [3, 8, 98]] print(num, len(num)) # 訪問嵌套列表的元素 print(num[0][1]) print(num[1][2]) num[1].append("李梓傑") print(num)
| 列表推導式是指循環創建列表，相當於 for 循環創建列表的簡化版 |
|---|
| 語法： |
"""列表推導式""" # 語法：[x for x in li if x ...] # 實例1：將 1-10 中的所有偶數平方後組成新的列表 # 普通的 result = [] for a in range(1, 11): if a % 2 == 0: result.append(a ** 2) print(result) # 列表推導式 res = [b ** 2 for b in range(1, 11) if b % 2 == 0] print(res) # 實例2：將 20-30 中的所有基數組成新的列表 # 普通 d = [] for c in range(20, 31): if c % 2 != 0: d.append(c) print(d) # 列表推導式 f = [v for v in range(20, 31) if v % 2 != 0] print(f)
二、tuple 元組
有序，元素可以重複，元組中的元素是不可以修改的，可以存放不同的數據類型
2、創建元組
-
使用逗號分隔
-
通過小括弧填充元素
-
通過構造方法 tuple(iterable)
"""創建元組""" # 1、使用逗號分隔 tup1 = 1, 2, 3 print(tup1, type(tup1)) # 2、過小括弧填充元素 tup2 = (1, 2, 3, 4, 5) tup3 = (1, 2, 4.5, True, "TTTT", (1, 2, 3), [1, 99, 555]) print(tup2, type(tup3)) print(tup3, type(tup3)) # 3、通過構造方法 tuple(iterable) a = tuple() print(a, type(a)) a1 = tuple((1, 2, 3)) # 添加組，單個無法添加 print(a1, type(a1)) a2 = tuple([1, 2, 4]) print(a2, type(a2))
3、元組索引
-
-
反向索引，默認編號從-1 開始
"""元組索引""" # 正向索引，默認編號從 0 開始 tup2 = (1, 2, 3, 4, 5) print(tup2[2]) tup1 = (range(1, 9)) print(tup1[3]) # 反向索引，默認編號從-1 開始 print(tup2[-3]) print(tup1[-3])
"""元組切片""" tup2 = (1, 2, 3, 4, 5, 8, 9) print(tup2[:]) # 列印整個元素 print(tup2[:-2]) print(tup2[2:4]) print(tup2[2:7:2])
5、元組常用方法
| 返回與目標元素相匹配的首個元素的索引。 |
# 1、index() # 查看元組中元素的索引值 tup2 = (1, 2, 3, 4, 5, 8, 9) print(tup2.index(3)) print(tup2.index(9)) # print(tup2.index(20)) # 目標必須在元組中存在的，否則會報錯 ValueError: tuple.index(x): x not in tuple tup3 = ('H', 'e', 'l', 'l', 'o') print(tup3.index('H')) # print(tup3.index('0')) # 目標必須在元組中存在的，否則會報錯 ValueError: tuple.index(x): x not in tuple
- count()
| 入參：對象 item |
tup3 = (1, 1, 1, 1, 3, 3, 8) print(tup3.count(3)) print(tup3.count(1)) print(tup3.count(8))
6、元組的解包
把一個可迭代對象里的元素，一併賦值到由對應的變數組成的元組中。
-
-
使用元組解包，一氣呵成
# 傳統逐個賦值的方式 t = (1, 2, 3) a = t[0] # 索引 b = t[1] c = t[2] print(a, b, c) # 使用元組解包，一氣呵成 a, b, c = (1, 2, 3) print(a, b, c)
7、元組與列表
-
相同點
-
都是有序的，元素可以重複
-
都是異構的，能夠包含不同類型的對象
-
都支援索引和切片
-
-
區別
-
聲明方式不同，元組使用
()，列表使用[] -
列表是可變的，元組是不可變的
-
三、set 集合
1、集合的特點
無序、用大括弧{}包圍、添加或刪除元素、可以存放不同的數據類型、去重
2、創建集合
-
通過使用
{}填充元素 -
通過構造方法 set()
-
通過集合推導式
"""創建集合""" # 1、使用大括弧{}填充元素 set1 = {1, 2, 3, 4.5, "ll"} print(set1) set2 = {1, 1, 2, 3, 3} print(set2) # 去重set() # 2、使用構造方法創建集合 set() a = set('hello') print(a) b = set() # 空集 print(b) # 3、使用集合推導式 set3 = {x for x in range(1, 11)} print(set3) set4 = {x * 2 for x in range(1, 11) if x % 2 == 0} print(set4) # 注意：不要單獨使用{ }來創建空集合 set4 = {} # 這是字典類型 print(set4, type(set4))
-
in 判斷元素是否在集合中存在
-
not in 判斷元素是否在集合中不存在
set1 = {1, 2, 3, 4.5, "ll"}
# in
print(1 in set1)
print(6 in set1)
# not
print("ll" not in set1)
print(6 not in set1)
4、集合方法
-
add()
| 入參：對象 item |
# add() 隨機添加位置 set1 = {1, 2, 3, 5} print(set1, len(set1)) # len()函數 計算長度 set1.add('happy') set1.add(96) set1.add(12) set1.add("hh") set1.add(4.6) print(set1, len(set1))
- update()
| 入參：可迭代對象 iterable |
a = set() print(a) a.update('hello') # 隨機填入 print(a) # 1、批量添加列表中的元素 a.update([1, 2, 3]) print(a) # 2、批量添加元組中的元素 a.update((1, 2, 4)) print(a) # 3、批量添加集合中的元素 a.update({99, 88}) print(a)
- remove()
| 入參：指定元素值 |
| 返回：None |
set1 = {1, 2, 3, 5}
print(set1)
# 1、刪除已存在的元素
set1.remove(1)
print(set1)
# 2、刪除不存在的元素 報錯：KeyError: 6
set1.remove(6)
print(set1)
- discard()
| 入參：指定元素值 |
| 返回：None |
set1 = {1, 2, 3, 6}
print(set1)
set1.discard(6)
print(set1) # 沒有元素，也不會報錯
set1.discard(888)
- pop()
| 入參：無。 |
| 返回：被移除的元組。 |
set1 = {1, 2, 3, 7}
print(set1)
# 1、隨機刪除某個對象
set1.pop()
print(set1)
# 2、集合本身為空會報錯 # KeyError: 'pop from an empty set'
set2 = set()
set2.pop()
print(set2)
- clear()
| 入參：無 |
st = {1, 2, 3, 4, 5}
print(st)
st.clear()
print(st)
| 並集運算 | 差集運算 | |
|---|---|---|
| intersection() | union() | difference() |
| 操作符：& | 操作符：｜ |
"""集合運算""" st = {1, 2, 3, 4, 5} st2 = {5, 8, 7, 1, 2} # 交集運算 # 1 、intersection() # 2、操作符： & print(st.intersection(st2)) print(st & st2) # 並集運算 # 1、union() # 2、操作符：｜ print(st.union(st2)) print(st | st2) # 差集運算 # 1、difference() # 2、操作符： - print(st.difference(st2)) print(st - st2)
語法：{x for x in ... if ...}
# 語法 {x for x in ... if ...} b = set() for y in 'hogwarts': if y in 'hello world': b.add(y) print(b) a = {x for x in 'hogwarts' if x in 'hello world'} print(a)
四、dict 字典
1、字典的特徵
無序的，用大括弧{}包圍，鍵值對的形式，鍵是不可以重複的
2、創建字典
-
使用大括弧填充鍵值對 {}
-
通過構造方法 dict()
-
# 1、使用大括弧填充鍵值對 {} a = {'name': '張學友', "age": 50} print(a, type(a)) # 2、通過構造方法 dict() a1 = dict() print(a1, type(a1)) a2 = dict(name='李梓傑', age=24) print(a2, type(a2)) dc3 = dict([("name", "Harry Potter"), ("age", 18)]) print(type(dc3), dc3) # 3、使用字典推導式 dc4 = {k: v for k, v in [("name", "Harry Potter"), ("age", 18)]} print(type(dc4), dc4)
3、訪問字典中元素
-
-
訪問不存在的key，會報KeyError錯誤
"""訪問字典中元素""" a = {'name': '理財友', "age": 50} # 1、訪問存在的[key] print(a['name'], a['age']) # 2、訪問不存在的key，會報KeyError錯誤 print(a['hobby'])
4、字典操作元素（添加修改）
-
語法：dict[key] = value
-
添加元素
-
-
修改元素
-
鍵已經存在
a = {'name': '理財友', "age": 50}
print(a, type(a))
# 語法：dict[key] = value
# 1、添加元素 鍵不存在
a['hobby'] = '騎馬'
print(a, type(a))
# 2、修改元素 鍵已經存在
a['name'] = '王彬彬'
print(a)
-
嵌套字典
-
字典的值可以是字典對象
"""嵌套字典""" a = {'name': '理財友', "age": 50, 'mark': {'python': 30, 'math': 56}} print(a) # 1、獲取課程math的值 print(a['mark']['math']) # 2、把python分數改成100分 a['mark']['python'] = 89 print(a)
| values() | items() | |
|---|---|---|
| 返回由字典鍵組成的一個新視圖對象。 | 返回由字典值組成的一個新視圖對象。 | 返回由字典項 ((鍵, 值) 對) 組成 |
# keys()、values()、items() dc = {"name": "Harry Potter", "age": 18} # 1、返回由字典鍵組成的一個新視圖對象。 keys() a = dc.keys() print(a) # 2、返回由字典值組成的一個新視圖對象。 values() a1 = dc.values() print(a1) # 3、返回由字典項 ((鍵, 值) 對) 組成的一個新視圖對象。 items() a2 = dc.items() print(a2)
- get()
| 入參: key：字典的鍵，必傳。 |
| 返回： 如果Key存在於字典中，返回Key關聯的Value值 如果Key不存在，則返回None |
dc = {"name": "Harry Potter", "age": 18}
# 1、訪問存在的key
print(dc.get('name'))
# 2、訪問不存在的key
print(dc.get('hobby')) # None
- update()
| 入參：字典對象，必傳 |
dc = {"name": "Harry Potter", "age": 18}
print(dc)
dc.update({'mark': {'english': 30, 'math': 88}})
print(dc)
- pop()
| 入參： key：必傳 |
| 返回： 如果 key 存在於字典中，則將其移除並返回 value 值 |
dc = {"name": "Harry Potter", "age": 18, 'mark': {'english': 30, 'math': 88}}
print(dc)
# 1、彈出
dc.pop('name')
print(dc)
# 2、刪除不存在的key # 報錯KeyError
dc.pop('dog')
print(dc)
7、字典推導式
實例1：給定一個字典對象{'a': 1, 'b': 2, 'c': 3}，找出其中所有大於 1 的鍵值對，同時 value 值進行平方運算。
實例2：給定一個字典對象，請使用字典推導式，將它的key和value分別進行交換。也就是key變成值，值變成key。 輸入: {‘a’: 2, ‘b’: 8, ‘c’: 4} 輸出: {2: ‘a’,8: ‘b’, 4: ‘c’}
"""字典推導式""" """ 實例1：給定一個字典對象{'a': 1, 'b': 2, 'c': 3}，找出其中所有大於 1 的鍵值對，同時 value 值進行平方運算。 """ # 未使用字典推導式的寫法 a = {'a': 1, 'b': 2, 'c': 3} b = dict() for k, v in a.items(): if v > 1: b[k] = v ** 2 print(b) # 使用字典推導式 c = {k: v ** 2 for k, v in a.items() if v > 1} print(c) """ 實例2:給定一個字典對象，請使用字典推導式，將它的key和value分別進行交換。也就是key變成值，值變成key。 輸入: {'a': 2, 'b': 8, 'c': 4} 輸出: {2: 'a',8: 'b', 4: 'c'} """ dc = {'a': 2, 'b': 8, 'c': 4} f = {v: k for k, v in dc.items()} print(f)
