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 開始，

• 支持反向索引，編號從-1 開始，

"串列索引"
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、串列成員檢測

• in：檢查一個物件是否在串列中，如果在則回傳 True，否則回傳 False，

• not in：檢查一個串列是否不包含某個元素，如果不在回傳 True，否則回傳 False，

li3 = [1, 2, 4, 5]
print(1 in li3)
print(6 not in li3)
print(8 is li3)

7、串列方法

• append()

# append()
list1 = []
print(list1)
list1.append(1)
list1.append(3.14)
list1.append("apple")
print(list1)

• extend()

# 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()

# insert()
lis1 = [1, 2, 4, 6, 9]
print(lis1)
lis1.insert(0, 3)
print(lis1)
lis1.insert(4, "apple")
print(lis1)

• pop()

# 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()

# 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()

# 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()

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

9、串列推導式

"""串列推導式"""
# 語法：[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 元組

1、元組的特點

有序，元素可以重復，元組中的元素是不可以修改的，可以存放不同的資料型別

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、元組索引

• 正向索引，默認編號從 0 開始

• 反向索引，默認編號從-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])

4、元組切片[start: stop: step]

"""元組切片"""
tup2 = (1, 2, 3, 4, 5, 8, 9)
print(tup2[:])  # 列印整個元素
print(tup2[:-2]) 
print(tup2[2:4]) 
print(tup2[2:7:2])

5、元組常用方法

• index()

# 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()

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

3、集合成員檢測

• 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()

# 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()

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

set1 = {1, 2, 3, 5}
print(set1)
# 1、洗掉已存在的元素
set1.remove(1)
print(set1)
# 2、洗掉不存在的元素  報錯：KeyError: 6
set1.remove(6)
print(set1)

• discard()

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)

5、集合運算

"""集合運算"""
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)

6、集合的推導式

語法：{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

• 訪問不存在的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)

5、字典嵌套

• 嵌套字典

• 字典的值可以是字典物件

"""嵌套字典"""
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)

6、字典方法

# 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()

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

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)

本文來自博客園，作者：{jiuyou-emperor}，轉載請注明原文鏈接：{https://www.cnblogs.com/jiuyou-emperor/}

標籤：Python

上一篇：Python采集某手視頻，1080P高清無水印，完整資料來源分析+完整代碼

下一篇：Python實訓day07pm【Selenium操作網頁、爬取資料-下載歌曲】