一、數(shù)據(jù)容器概念
相關(guān)介紹：
- 一種可以容納多份數(shù)據(jù)的數(shù)據(jù)類型，容納的每一份數(shù)據(jù)稱之為一個元素。每一個元素，可以是任意類型的數(shù)據(jù)
- 分為五類：列表[list]、元組(tuple)、字符串(str)、集合{set}、字典{dict}
相應(yīng)區(qū)別：
| 列表 | 元祖 | 字符串 | 集合 | 字典 | |
|---|---|---|---|---|---|
| <元素數(shù)量> | 多個 | 多個 | 多個 | 多個 | 多個 |
| <元素類型> | 任意 | 任意 | 僅字符 | 任意 | key(除字典外任意):value(任意) |
| <下表索引> | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| <重復(fù)元素> | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| <可否修改> | 支持 | 不支持 | 不支持 | 支持 | 支持 |
| <數(shù)據(jù)有序> | 是 | 是 | 是 | 否 | 否 |
相應(yīng)特點：
都支持for循環(huán)，集合、字典不支持（無法下標索引）
- 列表： 有一批數(shù)據(jù)，需要可修改、可重復(fù)的存儲場景
- 元祖： 有一批數(shù)據(jù)，不可以修改、但可以重復(fù)的存儲場景
- 字符串：一串文本字符串的存儲場景
- 集合： 有一批數(shù)據(jù)，需要去重存儲場景
- 字典： 有一批數(shù)據(jù)，需要用key檢索value的存儲場景
二、數(shù)據(jù)容器-列表[list]
解釋：存放數(shù)據(jù)，但可以修改
語法：[元素1,元素2,...]
1. 列表的創(chuàng)建
# 案例
name_list = ['1','sadas',True,'4','5'] # 多種類型，也可以嵌套多個列表
print(name_list)
print(type(name_list)) # 輸出都是列表類型： <class 'list'>
2. 列表的方法
2.1. 查詢元素
語法：列表.index(元素)
# 案例
my_list = ["python","wl","1"]
index = my_list.index("python")
print(f"index的下表索引值是: {index}") # 輸出：0
2.2. 索引獲取元素
# 案例
name_list = ['1','sadas',True,'4','5'] # 代表0,1,2,3,4,5 或者 -5.-4,-3,-2,-1
print(name_list[0]) # 輸出：1
print(name_list[-5]) # 輸出：1
# 案例
name_list = [['1','sadas'],[True,'4','5']] # 嵌套多個列表
print(name_list[0][0]) # 輸出：1
print(name_list[1][0]) # 輸出：True
2.3. 修改索引元素
語法：列表[下標] = 值
# 案例
my_list = ["python","wl","1"]
my_list[2] = 2 # 正向下標
print(f"修改后my_list值: {my_list}") # 輸出：['python', 'wl', 2]
my_list[-1] = -1 # 正向下標
print(f"修改后my_list值: {my_list}") # 輸出：['python', 'wl', -1]
2.4. 插入列表元素
語法：列表.insert(下標,元素) ，指定索引位置插入
# 案例
my_list = ["python","wl","1"]
my_list.insert(0,"888")
print(f"插入一個數(shù)888后：{my_list}") # 輸出：['888', 'python', 'wl', '1']
2.5. 追加元素
語法：列表.append(元素), 追加到尾部
# 案例
my_list = ["python","wl","1"]
my_list.append("999") # 也可以追加新列表 my_list.append([555,222])
print(f"最后追加元素999：{my_list}") # 輸出：['python', 'wl', '1', '999']
2.6. 刪除元素
語法1： del 列表[下標] del 僅僅完成刪除
# 案例
my_list = ["python","wl","1"] # 語法1
del my_list[0] # 注意括號，del 僅僅完成刪除
print(f"刪除第一個python: {my_list}") # 輸出：['wl', '1']
語法2： 列表.pop(下標) 不僅刪除元素，還可以返回值得到它
#案例
my_list = ["python","wl","1"] # 語法2
my_pop = my_list.pop(0) # 注意括號，pop不僅刪除，還可以返回值得到它
print(f"刪除第一個python: {my_list},刪除的是 {my_pop}") # 輸出：['wl', '1'],刪除的是 python
語法3： 列表.remove(元素) 刪除某一個元素，從前往后第一個刪除
# 案例
my_list = ["python","python","wl","1"] # 語法3
my_list.remove('python') # 只刪除第一個
print(f"刪除第一個python: {my_list}") # 輸出：['python', 'wl', '1']
2.7. 清空元素
語法： 列表.clear()
# 案例
my_list = ["python","wl","1"]
my_list.clear()
print(f"全部清空列表,結(jié)果是：{my_list}") # 輸出：[]
2.8. 統(tǒng)計某個元素
語法： 列表.count()
# 案例
my_list = [1,2,2,1,3,4]
count = my_list.count(1)
print(f"列表1的數(shù)量是：{count}") # 輸出：2
2.9. 統(tǒng)計所有元素
語法：len(列表)
# 案例
my_list = ["python","wl","1"]
print(len(my_list)) # 輸出：3
3. 列表的遍歷
3.1. 利用while循環(huán)獲取元素
解釋：1.自定循環(huán)條件，自行控制 2.通過條件控制做到無限循環(huán)
# 案例 依次取出列表元素
my_list = ["python","wl","1"]
print(type(my_list))
index = 0
while index < len(my_list): # len 表示列表中總數(shù)小于0，進行循環(huán)
a = my_list[index]
print(f"列表的 {index}元素：{a}")
index += 1 # index = index + 1
3.2. 利用for循環(huán)獲取元素
解釋：1.不可以自定循環(huán)條件，只能從容器里取出數(shù)據(jù) 2.理論不可以無限循環(huán)
# 案例 依次取出列表元素
my_list = ["python",3,4,5]
for a in my_list:
print(f"列表的元素：{a}")
3.3. 利用pandas制作表格，并存儲
# 案例
import pandas as pd
list = [{'mtime': '2022-12-05', 'title': '國家衛(wèi)健委', 'digest': '全國累計報告接種新冠病毒疫苗344429.5萬劑次'}, {'mtime': '2022-12-05', 'title': '5日0—12時重慶', 'digest': '新增本土確診病例73例和本土無癥狀感染者919例'}]
data = pd.DataFrame(list)
print(data)
# 輸出：
# mtime title digest
# 0 2022-12-05 國家衛(wèi)健委 全國累計報告接種新冠病毒疫苗344429.5萬劑次
# 1 2022-12-05 5日0—12時 重慶 新增本土確診病例73例和本土無癥狀感染者919例
# 存入數(shù)據(jù),utf-8-sig編碼防止中文亂碼
data.to_csv("sj1.csv",encoding="utf-8-sig")
3.4. 使用for循環(huán)依次打印數(shù)據(jù)
# 案例
list = [{'mtime': '2022-12-05', 'title': '國家衛(wèi)健委', 'digest': '全國累計報告接種新冠病毒疫苗344429.5萬劑次'}, {'mtime': '2022-12-05', 'title': '5日0—12時重慶', 'digest': '新增本土確診病例73例和本土無癥狀感染者919例'}]
for item in list:
mtime = item["mtime"]
title = item["title"]
digest = item["digest"]
print(f"{mtime}, {title}, {digest}")
# 輸出：
# 2022-12-05, 國家衛(wèi)健委, 全國累計報告接種新冠病毒疫苗344429.5萬劑次
# 2022-12-05, 5日0—12時重慶, 新增本土確診病例73例和本土無癥狀感染者919例
3.5. 使用while循環(huán)依次打印數(shù)據(jù)
# 案例
list = [{'mtime': '2022-12-05', 'title': '國家衛(wèi)健委', 'digest': '全國累計報告接種新冠病毒疫苗344429.5萬劑次'}, {'mtime': '2022-12-05', 'title': '5日0—12時重慶', 'digest': '新增本土確診病例73例和本土無癥狀感染者919例'}]
x = 0
while x < len(list):
mtime = list[x]["mtime"]
title = list[x]["title"]
digest = list[x]["digest"]
print(f"{mtime}, {title}，{digest}")
x += 1
# 輸出：
# 2022-12-05, 國家衛(wèi)健委, 全國累計報告接種新冠病毒疫苗344429.5萬劑次
# 2022-12-05, 5日0—12時重慶, 新增本土確診病例73例和本土無癥狀感染者919例
三、數(shù)據(jù)容器-元祖(tuple)
解釋：存放數(shù)據(jù)，不可修改(只讀方式)，但可以修改元素內(nèi)容；
語法：(元素1，元素2，...)
1. 元祖的創(chuàng)建
# 案例
my1_tuple = ("python","wl","1")
my2_tuple = () # 空元祖方式1
my3_tuple = tuple() # 空元祖方式2
my4_tuple = ("python",) # 注意：定義一個元祖，需要加,否則就成了字符串類型
my5_tuple = (["python","wl"],"1") # 注意：元祖里的列表可以刪除，修改等
print(f"my1_tuple類型是: {type(my1_tuple)},內(nèi)容是：{my1_tuple}")
print(f"my2_tuple類型是: {type(my2_tuple)},內(nèi)容是：{my2_tuple}")
print(f"my3_tuple類型是: {type(my3_tuple)},內(nèi)容是：{my3_tuple}")
print(f"my4_tuple類型是: {type(my4_tuple)},內(nèi)容是：{my4_tuple}")
print(f"my5_tuple類型是: {type(my5_tuple)},內(nèi)容是：{my5_tuple}")
my5_tuple[0][1] = "修改內(nèi)容"
print(f"修改的內(nèi)容后：{my5_tuple}") # 輸出：(['python', '修改內(nèi)容'], '1')
del my5_tuple[0][0] # 刪除元祖中的列表值
print(f"刪除元祖中列表第一個值：{my5_tuple}") # 輸出：(['wl'], '1')
2. 元祖的方法
2.1. 元祖-獲取元素
# 案例
my_tuple = ((1,2,3),(7,8,9)) # 元祖支持嵌套
print(f"my_tuple取出9的數(shù)據(jù): {my_tuple[1][2]}") # 輸出9
2.2. 元祖-查詢元素
語法： 元祖.index
# 案例
my_tuple = ('python','wl',1,'python')
print(my_tuple.index('python')) # 輸出：0
2.3. 元祖-統(tǒng)計某個元素
語法： 元祖.count
# 案例
my_tuple = ('python','wl',1,'python')
print(my_tuple.count('python')) # 輸出：2
2.4. 統(tǒng)計-統(tǒng)計所有元素
語法： 元祖.count
# 案例
my_tuple = ('python','wl',1,'python')
print(len(my_tuple)) # 輸出：4
3. 元祖的遍歷
3.1. 利用while循環(huán)獲取元素
解釋：1.自定循環(huán)條件，自行控制 2.通過條件控制做到無限循環(huán)
# 案例 依次取出元祖元素
my_tuple = ("python","wl","1")
print(type(my_tuple))
index = 0
while index < len(my_tuple): # len 表示列表中總數(shù)小于0，進行循環(huán)
a = my_tuple[index]
print(f"元祖的 {index}元素：{a}")
index += 1 # index = index + 1
3.2. 利用for循環(huán)獲取元素
解釋：1.不可以自定循環(huán)條件，只能從容器里取出數(shù)據(jù) 2.理論不可以無限循環(huán)
# 案例 依次取出元祖元素
my_tuple = ("python",3,4,5)
print(type(my_tuple))
for a in my_tuple:
print(f"元祖的元素：{a}")
四、數(shù)據(jù)容器-字符串(str)
特點：不支持修改
1. 字符串的方法
1.1. 字符串-索引獲取元素
注意：空格也算一個字符
# 案例
my_str = "i is wl"
v1 = my_str[0]
v2 = my_str[-1]
print(f"首個值v1：{v1},最后值v2：{v2}") # 輸出：v1：i, v2：c
1.2. 字符串-查找元素
語法：字符串.index(值)
# 案例
my_str = "i is wl"
v = my_str.index("is")
print(f"and的起始下標v：{v}") # 輸出：2
1.3. 字符串-替換元素
語法：字符串.replace(原值，現(xiàn)值)
# 案例
my_str = "i is wl"
v = my_str.replace("i","t")
print(f"把所有的i替換成t：{v}") # 輸出：t ts wl
1.4. 字符串-分割元素
語法：字符串.split(分割值)
# 案例
my_str = "i is wl"
v = my_str.split( ) # 空格切分
print(f"用空格風(fēng)格my_str：{v}") # 輸出：['i', 'is', 'wl']
1.5. 字符串-規(guī)整元素
語法：字符串.strip(去除值) ，空代表去除前后空格
# 案例
my_str = "12i is wl21"
v = my_str.strip("12") # 去除12,實際去除“1”和“2”
print(f"去掉12后my_str：{v}") # 輸出：i is wl
1.6. 字符串-統(tǒng)計某個元素
語法：字符串count(統(tǒng)計值)
#案例
my_str = "i is wl"
v = my_str.count("i")
print(f"i出現(xiàn)的次數(shù)：{v}") # 輸出：2
1.7. 字符串-統(tǒng)計所有元素
語法：字符串len()
#案例
my_str = "i is wl"
v = len(my_str)
print(f"my_str總數(shù)長度是：{v}") # 輸出：8
五、數(shù)據(jù)容器-集合{set}
特點：相比其他，不支持重復(fù)集合，自帶去重，并且輸出是無序的
語法 ： 變量 = {元素1，元素2....}
1. 集合的創(chuàng)建
#案例
my_set = {"python","wl",4,"wl"}
print(my_set) # 輸出：{'python', 4, 'wl'}，故是無序的，不支持下標
2. 集合的方法
2.1. 集合-增加元素
# 案例
my_set = {"python","wl",4,"wl"}
my_set.add("Python") # 如果增加相同數(shù)據(jù)等于沒有寫
print(f"增加一個數(shù)my_set結(jié)果是：{my_set}") # 輸出：{'wl', 'Python', 'python', 4}
2.2. 集合-移除元素
# 案例
my_set = {"python","wl",4,"wl"}
my_set.remove("python") # 刪除所有，再去重
print(f"移除一個數(shù)my_set結(jié)果是：{my_set}") # 輸出：{'wl', 4}
2.3. 集合-隨機取出元素
# 案例
my_set = {"python","wl",4,"wl"}
element = my_set.pop() # 隨機取，無法指定
print(f"{element}") #
print(f"隨機取一個數(shù)my_set結(jié)果是：{my_set}") #
2.4. 集合-清空元素
# 案例
my_set = {"python","wl",4,"wl"}
my_set.clear()
print(f"清空my_set結(jié)果是：{my_set}") # 輸出：set()
2.5. 集合-取(消除)兩個集合的差
# 案例
set1 = {1,2,3}
set2 = {2,3,4}
f_set = set1.difference(set2)
print(f"除set1中有而set2沒有的結(jié)果是：{f_set}") # 輸出：{1}
set1.difference_update(set2) # 消除差集，集合2不變化
print(set1) # 輸出：{1}
print(set2) # 輸出：{2, 3, 4}
2.6. 集合-合并元素
# 案例
set1 = {1,2,3}
set2 = {2,3,4}
set3 = set1.union(set2)
print(f"集合合并后set3：{set3}") # 輸出：（去重）：{1, 2, 3, 4}
2.7. 集合-統(tǒng)計元素數(shù)量（去重）
# 案例
set1 = {1,2,3,2,3,4}
num = len(set1)
print(f"集合合并后set3：{num}") # 輸出（去重）：4
3. 集合的遍歷
說明：因為不支持下標索引，所以while循環(huán)不支持,支持for循環(huán)
# 案例
set1 = {1,2,3,2,3,4}
for a in set1:
print(f"集合元素有：{a}")
六、數(shù)據(jù)容器-字典{dict}
解釋：字和其相關(guān)聯(lián)的含義
注意：字典可以任意類型，不允許重復(fù)，會覆蓋
語法： 變量 = {key:value,key:value.....}
1. 字典的創(chuàng)建
# 案例
my_dict = {"張三":99,"李四":98,"王五":90}
print(f"my_dict類型是：{type(my_dict)}，內(nèi)容是：{my_dict}") # 輸出：<class 'dict'>
2. 字典的方法
2.1. 字典-key取值
# 案例
my_dict = {"張三":99,"李四":98,"王五":90}
s = my_dict['張三']
print(f"張三對應(yīng)的值是：{s}") # 輸出:99
2.2. 字典-嵌套取值
# 案例
my_dict = {
"張三":{
"語文":99,"數(shù)學(xué)":70
},"李四":{
"語文":88,"數(shù)學(xué)":80
},"王五":{
"語文":80,"數(shù)學(xué)":68
}
}
s = my_dict["王五"]["數(shù)學(xué)"]
print(f"王五對應(yīng)的數(shù)學(xué)值是：{s}") # 輸出：68
2.3. 字典-新增元素
# 案例
my_dict = {"張三":99,"李四":98,"王五":90}
my_dict['趙六'] = 77
print(f"新增趙六成績后：{my_dict}")
2.4. 字典-更新元素
# 案例
my_dict = {"張三":99,"李四":98,"王五":90}
my_dict['張三'] = 77
print(f"新增趙六成績后：{my_dict}")
2.5. 字典-刪除元素
# 案例
my_dict = {"張三":99,"李四":98,"王五":90}
my_dict.pop("張三")
print(f"刪除張三后：{my_dict}")
2.6. 字典-清空元素
# 案例
my_dict = {"張三":99,"李四":98,"王五":90}
my_dict.clear()
print(f"清空后：{my_dict}")
2.7. 字典-取key、value值
# 案例
my_dict = {"張三":99,"李四":98,"王五":90}
s = my_dict.keys()
print(f"{s}")
for s in my_dict: # for循環(huán)輸出value值,不支持while循環(huán)
print(f"{my_dict[s]}")
2.8. 字典-統(tǒng)計所有元素
# 案例
my_dict = {"張三":99,"李四":98,"王五":90}
num = len(my_dict)
print(f"數(shù)量是：{num}") # 輸出：3
3. 字典的綜合案例
要求：對名次為3的語文增加10分，并晉升一名次
# 案例
my_dict = {
"張三":{
"名次":8,
"語文":99,
"數(shù)學(xué)":70
},"李四":{
"名次":10,
"語文":88,
"數(shù)學(xué)":80
},"王五":{
"名次":3,
"語文":80,
"數(shù)學(xué)":68
}
}
print(f"升級之前是：{my_dict}")
for name in my_dict:
if my_dict[name]["名次"] == 3: # 當名次為3時，
my_dict[name]["名次"] = 2 # 晉升一名次，改為2,
my_dict[name]["語文"] += 10 # 語文成績+10分
print(f"升級之后是：{my_dict}")
七、數(shù)據(jù)容器的切片
解釋：從一個序列中，取出子序列
語法：序列[起始下標:結(jié)束下標:步長] 步長1表示，一個個取；2表示間隔一個取
1. 列表list
# 案例
my_list = [0,1,2,3,4,5,6,7,8,9]
result_1 = my_list[1:3] # 步長默認是1，可以不寫
print(f"從第二個到四個取，result_1結(jié)果是：{result_1}")
2. 元祖tuple
# 案例
my_tuple = (0,1,2,3,4,5,6,7,8,9)
result_2 = my_tuple[::2] # 空代表從頭到尾,2代表步長
print(f"從頭到尾，間隔1，result_2結(jié)果是：{result_2}")
3. 字符串
# 案例
my_str = "0123456789"
result_3 = my_str[::-2]
print(f"從尾到頭，間隔1，result_3結(jié)果是：{result_3}")
# 案例 正常取出數(shù) "我是你哥"
my_str = "哥大我叫請，啊哥你是我，好你"
s1 = my_str[::-1][3:7] # 先倒轉(zhuǎn)，再取值。注意最后的下標索引
print(f"方式s1結(jié)果是：{s1}")
s2 = my_str[7:11][::-1] # 先取值，再倒轉(zhuǎn)。注意最后的下標索引
print(f"方式s2結(jié)果是：{s2}")
s3 = my_str.split("，")[1].replace("啊","")[::-1] # 先用，分割取值第二個再把“啊”替換掉 最后倒序
print(f"方式s3結(jié)果是：{s3}")
八、數(shù)據(jù)容器的通用操作（排序、轉(zhuǎn)換）
# 案例
my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str = "abcdefgh"
my_set = {1,2,3,4,5}
my_dict = {"key1":1,"key2":2,"key3":3}
1. 容器取值（max）
print(f"列表 最大元素是：{max(my_list)}")
print(f"元祖 最大元素是：{max(my_tuple)}")
print(f"字符串 最大元素是：{max(my_str)}")
print(f"集合 最大元素是：{max(my_set)}")
print(f"字典 最大元素是：{max(my_dict)}")
2. 容器轉(zhuǎn)列表
print(f"列表 轉(zhuǎn)列表是：{list(my_list)}")
print(f"元祖 轉(zhuǎn)列表是：{list(my_tuple)}")
print(f"字符串 轉(zhuǎn)列表是：{list(my_str)}")
print(f"集合 轉(zhuǎn)列表是：{list(my_set)}")
print(f"字典 轉(zhuǎn)列表是：{list(my_dict)}")
3. 容器轉(zhuǎn)元祖
print(f"列表 轉(zhuǎn)元祖是：{tuple(my_list)}")
print(f"元祖 轉(zhuǎn)元祖是：{tuple(my_tuple)}")
print(f"字符串 轉(zhuǎn)元祖是：{tuple(my_str)}")
print(f"集合 轉(zhuǎn)元祖是：{tuple(my_set)}")
print(f"字典 轉(zhuǎn)元祖是：{tuple(my_dict)}")
4. 容器轉(zhuǎn)字符串、集合
解釋：字典dict不支持，缺少鍵值對；字符串、集合都是無序)文章來源：http://www.zghlxwxcb.cn/news/detail-674922.html
5. 容器的排序
5.1. 排序
語法：sorted(容器,reverse=False)文章來源地址http://www.zghlxwxcb.cn/news/detail-674922.html
print(f"列表 排序是：{sorted(my_list)}")
print(f"元祖 排序是：{sorted(my_tuple)}")
print(f"字符串 排序是：{sorted(my_str)}")
print(f"集合 排序是：{sorted(my_set)}")
print(f"字典 排序是：{sorted(my_dict)}")
5.2. 降序
print(f"列表 排序是：{sorted(my_list,reverse=True)}")
print(f"元祖 排序是：{sorted(my_tuple,reverse=True)}")
print(f"字符串 排序是：{sorted(my_str,reverse=True)}")
print(f"集合 排序是：{sorted(my_set,reverse=True)}")
print(f"字典 排序是：{sorted(my_dict,reverse=True)}")
5.3. 根據(jù)數(shù)字下標定義排序方法 sort
my_list = [["a",67],["a",7],["a",52]]
# 方式1
def sort_key(element):
return element[1]
my_list.sort(key=sort_key,reverse=False) # True/flase:表示升序降序
# 方式2 利用匿名函數(shù)lambda
my_list.sort(key=lambda element:element[1],reverse=False)
print(my_list)
到了這里，關(guān)于Python數(shù)據(jù)容器（列表list、元組tuple、字符串str、字典dict、集合set）詳解的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
