容器類型
4種內建資料結構（容器類型）
列表：list=>[val1,val2,val3,val4]
元組：tuple=>(val1,val2,val3,val4)
字典：dict=>{key1:val1,key2:val2}
集合：set=>{key1,key2,key3,key4}
一。列表（list）#
列表是處理一組有序項目的資料結構
列表是python中最具靈活性的有序集合物件類型
列表可以包含任何類型的物件：字串、數字甚至其他列表
列表是可變的資料類型，即這種類型的值是可以被修改的
Example:表示一個購物清單
goods=['牛奶'、'運動鞋'、'咖啡'、'手機'、'羊肉'、'葡萄'、'橘子']
列表通過方括號中用逗號分割的項目定義
# 示例
# 定義空列表
>>> lst = []
>>> type(lst)
<class 'list'>
>>> lst2 = list() # 注：工廠函數
>>> type(lst2)
<class 'list'>
# 列表可裝入python的任何物件：
>>> lst3 = list("abc") # 注：字串
>>> lst3
['a', 'b', 'c']
>>> lst = [1,'abc',2.5,True]
>>> lst = [1,'abc',2.5,True,lst3] # 注：其他列表
>>> lst
[1, 'abc', 2.5, True, ['a', 'b', 'c']]
列表基本操作#
索引#
通過下標訪問列表中的元素，下標從 0 開始計數，可取出一個元素
# 示例
>>> lst = [1,2,3]
>>> id(lst)
140078683813384
>>> lst += [4]
>>> id(lst)
140078683813384 # 注：內存地址不變
>>> lst[0]
1
>>> lst[0] = "a" # 注：改變列表裡的元素值
>>> id(lst)
140078683813384
# 下標不能越界（Index Error:list index out of range）
>>> lst
['b', 2, 3, 4]
>>> lst[4] # 注：下標越界 會報錯
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
切片#
切片是通過下標訪問列表中的元素，切片可以取出一個子列表
起止區間：[ start,end )
step:默認=>1
start:默認=>step為正時，start為0；step為負時,start為-1
end:默認=>step為正時，end為列表結尾；step為負時,end為列表開始
注意：三個值都為選填項
# 示例：正切片
>>> a = [1,2,3,4,5,6]
>>> a[0:4] # 注：切片，前4個
[1, 2, 3, 4]
>>> str = "123456"
>>> str[0:4] # 注：切片，前4個
'1234'
>>> a[:4] # 注：效果一樣
[1, 2, 3, 4]
# 示例：負切片，步長為-1
>>> a = [1,2,3,4,5,6]
>>> a[-1:3:-1] # 注：-1指向6， 3指向4，-1從右往左
[6, 5]
>>> a[-1:-4:-1] # 注：-1指向6，-4指向3，-1從右往左
[6, 5, 4]
>>> a[-1:-44:-1] # 注：-1指向6，-44越界，-1從右往左
[6, 5, 4, 3, 2, 1]
>>> a[-1:4:-1] # 注：-1指向6, 4指向5，-1從右往左
[6]
>>> a[-3:4:-1] # 注：-3指向4， 4指向5，4向左取不到5
[] # 注：為空 起始位置有誤時，切出來會是空(不會報錯)
切片物件(slice函數)
slice函數的用途：生成一個slice物件，相當於可以給要切的內容取個名字。
# 示例
>>> a = ["a","b","c","d"]
>>> a
['a', 'b', 'c', 'd']
>>> b = [1,2,3,4,5,6]
>>> s1 = slice(0,3,1) # 注：引用時需要傳參進去
>>> a[s1] # 注：切片 前3個
['a', 'b', 'c']
>>> b[s1] # 注：切片 前3個
[1, 2, 3]
>>> c = ["xx","yy","zz","ee"]
>>> c[s1] # 注：切片 前3個
['xx', 'yy', 'zz']
增加#
增加列表元素的方式
append:在末尾，作為整體追加，類型不限
insert:在index位置插入元素
extend:擴展列表
# 示例
# append
>>> a = ["apple", "orange", 123, 0.1111, "cali"]
>>> a.append("test") # 注：追加字串
>>> a
['apple', 'orange', 123, 0.1111, 'cali', 'test']
>>> lst = ['a','b','c']
>>> lst2 = [1,2,3]
>>> lst.append(lst2) # 注：追加的類型是陣列
>>> lst
['a', 'b', 'c', [1, 2, 3]] # 注：追加的類型是陣列
# insert
>>> lst = ['a','b','c']
>>> lst.insert(1,'d') # 注：在第2個元素前插入資料
>>> lst
['a', 'd', 'b', 'c']
# extend
>>> a = [1,2,3]
>>> str = "abc"
>>> a.extend(str) # 注：擴展字串
>>> a
[1, 2, 3, 'a', 'b', 'c']
extend與+
注意：只限可轉為list的類型(str,list,tuple)
# 示例
>>> a = ['a','b','c']
>>> a2 = [1,2,3]
>>> a.extend(a2)
>>> a
['a', 'b', 'c', 1, 2, 3]
>>> a + ["5"] # 注：+ 法只能list 和 list 相加
['a', 'b', 'c', 1, 2, 3, '5']
>>> a
['a', 'b', 'c', 1, 2, 3] # 注：+ 法 運行結束後 陣列a沒有變化
>>> b = a + ["5"] # 注：賦值給陣列b
>>> b # 注：可以通過 賦值給陣列b的方法來保存 變化
['a', 'b', 'c', 1, 2, 3, '5']
>>> id(a)
140273972677768
>>> a += ["6"]
>>> id(a)
140273972677768 # 注：a += ["6"] 內存地址不變 物件不變，內容改變
>>> a = a + ["7"]
>>> id(a)
140273837551816 # 注：a = a + ["7"]內存地址改變
刪除#
刪除列表元素的方式
pop：刪除元素，默認最後一個（指定index刪除）
remove：刪除指定的元素（要刪除的資料不存在時，會出錯）
del：根據下標刪除
del是python的一個關鍵字，用於刪除變數(的引用)
clear：清空列表
# 示例
# pop
>>> a.pop() # 注：默認刪除最後1個
'7' # 注：返回值，刪除的元素
>>> a.pop(2) # 注：指定索引2 刪除第3個元素
'c'
# remove
>>> a = ["xx","yy","xx"]
>>> a.remove("xx") # 注：刪除指定元素，只刪除第1個
>>> a
['yy', 'xx']
>>> a
['yy', 'xx']
>>> a.remove("zz") # 注：要刪除的資料不存在時，會報錯
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
# del
>>> a = [1,2,3,"xx","yy","zz"]
>>> del a[3] # 注：刪除索引3 第4個
>>> a
[1, 2, 3, 'yy', 'zz']
>>> del a[0:2] # 注：切片刪除
>>> c = 1
>>> del c # 注：del刪除變數的引用
>>> c
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'c' is not defined
# clear
>>> a
[3, 'yy', 'zz']
>>> a.clear()
>>> a
[] # 注：clear清空
修改#
修改元素主要是利用下標和切片來修改或增加、刪除
# 示例
>>> a = [1,2,3,'a','b','c']
>>> a
[1, 2, 3, 'a', 'b', 'c']
>>> a[2] = "x" # 注：修改元素
>>> a
[1, 2, 'x', 'a', 'b', 'c']
>>> a[1:1] # 注：[1,1)
[] # 注：為空
>>> a[1:1] = "abc" # 注：在起始位置 索引為1 處之前 增加列表 str類型轉換為列表
>>> a
[1, 'a', 'b', 'c', 2, 'x', 'a', 'b', 'c']
>>> b = ["a","b","c"]
>>> b[2:2] = ["x","y"] # 注：索引為2處之前 增加列表
>>> b
['a', 'b', 'x', 'y', 'c']
>>> b[2:4] = ["x","y","z"] # 注：索引2、3 的值 替換
>>> b
['a', 'b', 'x', 'y', 'z', 'c']
>>> b[1:5] = "12" # 注：切出來後，再轉換為列表。str類型轉換為列表
>>> b # 注：索引1、2、3、4 的值 替換 為 ‘1’‘2’
['a', '1', '2', 'c']
>>> b
['a', '1', '2', 'c']
>>> b[5:-3]
[]
>>> b[3:-3] # 注：獲取不到
[]
>>> b[3:-3] = "xy" # 注：這個位置開始(start位置開始)，替換成其他的list
>>> b # 注：看 找出的元素是否為空
['a', '1', '2', 'x', 'y', 'c']
>>> c = ["a","b","c","d","1"]
>>> c[1:4] = "hello" # 注：找出b c d 把bcd 替換成h e l l o
>>> c
['a', 'h', 'e', 'l', 'l', 'o', '1']
>>> c = ['a', 'h', 'e', 'l', 'l', 'o', '1']
>>> c[5:3] # 注：獲取不到
[]
>>> c[5:3] = ["x","y"] # 注：c[5:3]為空，在 o (下標5)處插入x y
>>> c
['a', 'h', 'e', 'l', 'l', 'x', 'y', 'o', '1']
反轉#
反轉列表 - reverse 或 切片
# 示例
# 1.負切片 實現反轉，輸出的值反轉
>>> a = [1,2,3,4]
>>> a[::-1] # 注：負切片
[4, 3, 2, 1]
>>> a # 注：a本身的值 沒有反轉
[1, 2, 3, 4]
# 2.reverse 字串的反轉
>>> a
[1, 2, 3, 4]
>>> a.reverse()
>>> a # 注：a本身的值 反轉
[4, 3, 2, 1]
排序#
列表排序 - sort
# 示例
>>> a
[4, 3, 2, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4] # 注：排序後 a本身的值發生改變
# 反向排序
a.sort(reverse=True)
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True) # 注：反向排序，升序變成降序
>>> a
[4, 3, 2, 1] # 注：從大到小排序
# 不支持int和str混合 的排序：
>>> a = ["a",1,"b",2]
>>> a.sort()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
>>> a = ["a","1","b","2"]
>>> a.sort()
>>> a
['1', '2', 'a', 'b']
# 按 編碼排序
>>> a = ["a","1","b","2","A"]
>>> a
['a', '1', 'b', '2', 'A']
統計#
len、count、index
# 示例
# len 總長度
>>> a
['a', '中', '序', '排', '文']
>>> len(a)
5
>>> a.append([1,2,3])
>>> len(a)
6
>>> a
['a', '中', '序', '排', '文', [1, 2, 3]]
>>> a.extend([1,2,3])
>>> len(a)
9
# count統計元素出現的次數
>>> a
['a', '中', '序', '排', '文', [1, 2, 3], 1, 2, 3]
>>> a.count("a")
1
>>> a.count(1)
1
# index返回元素所在的索引位置
>>> a = ["x","y","x",1]
>>> a.count("x")
2
>>> a.index("x")
0
>>> a.index("z") # 注：index通過元素找索引，如果沒有會報錯
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'z' is not in list
遍歷#
遍歷：依次取出物件中的每一項資料
list 是一個可迭代物件（iterable），可以直接用 for 遍歷
# 1.for i in a:
>>> a
['x', 'y', 'x', 1]
>>> for i in a:
... print(f"item is --->{i}")
...
item is --->x
item is --->y
item is --->x
item is --->1
# 2.enumerate()函數
# 特點：會返回元組，元組裡包含每一個下標和值
# 注：用1個i去遍歷，獲取的是元組
>>> for i in enumerate(a):
... print(f"item is --->{i}")
...
item is --->(0, 'x')
item is --->(1, 'y')
item is --->(2, 'x')
item is --->(3, 1)
# 用2個臨時變數，獲取enumerate(a)元組的返回
>>> for i,j in enumerate(a):
... print(f"{i}-->{j}")
...
0-->x
1-->y
2-->x
3-->1
判斷成員關係#
判斷列表中是否有某個資料
# 示例
>>> lst = ['a','b','c','d']
>>> print('a' in lst)
True
>>> print('x' in lst)
False
>>> s = 'a'
>>> print(s, '在' if s in lst else '不在','列表裡')
a 在 列表裡
類型轉換#
字串 (str) 轉列表 (list)
# 示例
>>> str = 'abc 123'
>>> list(str)
['a', 'b', 'c', ' ', '1', '2', '3']
二。元組（tuple）#
元組是處理一組有序項目的資料結構
元組和字串一樣是不可變的,即你不能修改元組
元組可以包含任何類型的物件：字串、數字甚至其他列表
適應場景：性別選擇，資料庫的查詢結果
Example:表示一個購物清單
goods=('牛奶'、'運動鞋'、'咖啡'、'手機'、'羊肉'、'葡萄'、'橘子')
# 示例
# 元組通過圓括號中用逗號分割的項目定義
>>> a = ()
>>> type(a)
<class 'tuple'>
>>> a = (1) # 注：括號還可以代表集合
>>> type(a)
<class 'int'>
# 元組中只有一個元素的時候，需要在元素後面加個，區分這個括號是表示集合還是表示元組
>>> a = (1,) # 注：元組中只有1個元素時，需要加逗號(,)表示元組
>>> type(a)
<class 'tuple'>
>>> a = tuple() # 注：定義空元組
>>> type(a)
<class 'tuple'>
>>> a
()
# 元組可裝入python的任何物件
>>> a = ("a",1,1.2,True,print)
>>> a
('a', 1, 1.2, True, <built-in function print>)
元組基本操作#
索引#
通過下標訪問列表中的元素，下標從 0 開始計數，可取出一個元素
# 示例
>>> a = ("a",1,1.2,True,print)
>>> a[4]
<built-in function print>
>>> a[3]
True
# 下標不能越界，越界會報錯
>>> a = ("a",1,1.2,True,print)
>>> a[5]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
切片#
切片是通過下標訪問元組中的元素，切片可以取出一個子元組
起止區間：[start,end)
step:默認=>1
start:默認=>step為正時，start為0；step為負時,start為-1
end:默認=>step為正時，end為列表結尾；step為負時,end為列表開始
注意：三個值都為選填項
# 示例
>>> a = ("a",1,1.2,True,print)
>>> a[1:3]
(1, 1.2)
不可變性#
# 示例
>>> a
('a', 1, 1.2, True, <built-in function print>)
>>> a[0] = 1 # 注：報錯
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> tu1 = (1,2)
>>> tu2 = (3,4)
>>> tu3 = tu1 + tu2
>>> tu3
(1, 2, 3, 4)
統計#
# 示例
>>> a = ('a','b','c')
>>> print(len(a))
3
遍歷#
# 示例
>>> a = [1,2,3]
>>> for i in enumerate(a):
... print(i)
...
(0, 1) # 注：返回值 是 元組
(1, 2)
(2, 3)
>>> for i,j in enumerate(a):
... print(f"{i}---{j}") # 注：用兩個參數來接收 返回值
...
0---1
1---2
2---3
成員關係#
成員關係： in , not in
# 示例
>>> a = ("a","b","c")
>>> "a" in a
True
>>> "d" not in a
True
三。字典（dict）#
字典是Python中一個鍵值映射的資料結構
字典是無序的
字典是可變物件
key必須是唯一的,所以天生去重
example:
singer={key1:value,key2:value}
singer={"李聖傑":'痴心絕對','張韶涵':'阿刁','汪峰':'普通迪斯高'}
字典的定義
字典的key必須是可hash物件
python中所有字串、數字、元組、布林值、None都是可hash物件
字典的value可以是任何值
# 示例
# 定義空字典
# 方法1：
>>> a = {} # 注：定義空字典
# 方法2：
>>> b = dict() # 注：定義空字典，工廠函數
>>> type(a)
<class 'dict'>
>>> type(b)
<class 'dict'>
# 示例
>>> c = [('root','123456'),('admin','admin')]
>>> d = dict(c) # 注：列表轉換成字典 工廠函數
>>> d
{'root': '123456', 'admin': 'admin'}
>>> e = [1,2,3]
>>> e
[1, 2, 3]
>>> dict(e) # 注：轉換的物件要有 鍵值映射 的格式
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot convert dictionary update sequence element #0 to a sequence
字典基本操作#
取值#
用法1：dicts[key]=>當key不存在時，會引了KeyError錯誤
用法2：dicts.get(key,default)=>當key不存在時，返回default值
# 示例
>>> a = {"a":4,"b":2}
>>> a['a']=3 # 注：修改key=”a”的 value 值
>>> a
{'a': 3, 'b': 2}
>>> a['c']=4 # 注：增加鍵值對
>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a['c'] # 注：取值
4
>>> a['d'] # 注：key不存在，報錯
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'd'
# 推薦使用get
>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a.get('d') # 注：不報錯
>>> c = a.get('d')
>>> print(c)
None # 注：默認值沒有設定
增加 / 修改#
用法：dicts[key]=value
當key不存在時，表示增加一個鍵值對
當key存在時，表示修改對應的value值
# 示例：修改
>>> a
{'a': 3, 'b': 2, 'c': 4}
>>> a['a'] = 5
>>> a
{'a': 5, 'b': 2, 'c': 4}
# 示例：新增
>>> a['d'] = False
>>> a
{'a': 5, 'b': 2, 'c': 4, 'd': False}
刪除#
用法1：dicts.pop(key)
用法2：dicts.popitem()
# 示例：dicts.pop(key)
>>> a = {'a':5,'b':2,'c':4,'d':False}
>>> a.pop('a') # 注：刪除 key=‘a’ 的元素
5 # 注：pop有返回值
>>> c = a.pop('b') # 注：獲取返回值
>>> c
2
>>> a
{'c': 4, 'd': False}
# 示例：dicts.popitem()
# python3裡面刪除的是最後一個
>>> a = {"x":1,"y":2,"z":3}
>>> a.popitem()
('z', 3)
>>> a.popitem()
('y', 2)
>>> a.popitem()
('x', 1)
合併#
用法1：dict1.update(dict2)=>將dict2合併到dict1
用法2：dict(dict1,**dict2)=>將dict1與dict2合併生成一個新字典
# 示例：dict1.update(dict2)
>>> a = {"x":1,"y":3}
>>> b = {"q":2,"w":3}
>>> a.update(b) # 注：a自帶的屬性
>>> a
{'x': 1, 'y': 3, 'q': 2, 'w': 3}
>>> b
{'q': 2, 'w': 3}
# 示例：dict(dict1, **dict2)
>>> a = {"x":1,"y":3}
>>> b = {"q":2,"w":3}
>>> dict(a,**b) # 注：工廠函數，返回一個字典 a和b的合併
{'x': 1, 'y': 3, 'q': 2, 'w': 3}
>>> a # 注：a本身沒有改變
{'x': 1, 'y': 3}
>>> dict()
{}
>>> c = dict(a,**b)
>>> c
{'x': 1, 'y': 3, 'q': 2, 'w': 3}
成員關係#
用法：
item in dicts
item not in dicts
# 示例
>>> a = {"x":1,"y":2,"z":3}
>>> a
{'x': 1, 'y': 2, 'z': 3}
>>> 'x' in a # 注：in 默認 對比的是key值
True
>>> 2 in a
False
>>> 2 in a.values() # 注：a.values()對比的是value值
True
遍歷#
默認遍歷的是 key
# 示例
>>> a
{'x': 1, 'y': 2, 'z': 3}
# 遍歷key值
>>> for i in a:
... print(i)
...
x # 注：遍歷key值
y
z
# 遍歷value值
>>> for i in a.values():
... print(i)
...
1 # 注：遍歷value值
2
3
# 既想獲得key 也想獲得value
# items返回的是元組
# 方式1
>>> for i in a.items():
... print(i)
...
('x', 1)
('y', 2)
('z', 3)
# 方式2
>>> for i,j in a.items(): # 注：2個參數獲取返回值key,value
... print(f"key is {i}, value is {j}")
...
key is x, value is 1
key is y, value is 2
key is z, value is 3
# 方式3
>>> for i in a.items():
... print(f"key is {i[0]}, value is {i[1]}") # 注：索引獲取參數
...
key is x, value is 1
key is y, value is 2
key is z, value is 3
四。集合（set）#
集合是一個無序的，不重複的資料組合
集合是一個只含有key的字典
集合的作用
去重：把一個列表變成集合，就自動去重了
關係測試：測試兩組資料之前的交集、差集、並集等關係
example:
singer={"李聖傑",'張韶涵','汪峰'}
集合的定義
集合通過花括號中，而各個元素用逗號分割
集合元素必須是可hash物件，跟字典一樣
set和dict的唯一区别僅在於沒有存儲對應的value
# 示例
# 定義空集合（2種方式）
>>> a = {1,2,3} # 注：第1種方式
>>> type(a)
<class 'set'>
>>> a = set() # 注：第2種方式
>>> a
set()
>>> type(a)
<class 'set'>
集合基本操作#
添加#
用法：s.add(item)=>添加一項
用法：s.update(someitems)=>添加多項
# 示例
>>> s = {1,2,3}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.update("str") # 注：str被擴展進來，是一個一個被擴展進來的
>>> s
{1, 2, 3, 4, 't', 'r', 's'}
>>> s.update({"x":1,"y":2}) # 注：字典 擴展的是 key值
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 'r', 's'}
移除#
用法1：s.remove(item)=>移除一項(item不存在會出錯KeyError)
用法2：s.discard(item)=>移除一項(item不存在則什麼也不做)
# 示例
# remove
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 'r', 's'}
>>> s.remove('r')
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 's'}
>>> s.remove('p') # 注：“p”不存在，報錯
Traceback (most recent call last):
KeyError: 'p'
# discard
>>> s
{1, 2, 3, 4, 'x', 't', 'y', 's'}
>>> s.discard('o') # 注：不存在 不報錯 什麼也不做
>>> s.discard('x')
>>> s
{1, 2, 3, 4, 't', 'y', 's'}
# pop
>>> a={"a","b","c"}
>>> a.pop()
'c'
>>> a.pop()
'a'
>>> a.pop()
'b'
集合操作#
並集：t和s的並集,返回一個新的set包含s和t中的每一個元素
交集:t和s的交集,返回一個新的set包含s和t中的公共元素
差集:返回一個新的set包含s中有但是t中沒有的元素
對稱差集:返回一個新的set包含s和t中不重複的元素（在t或s中，但不會同時出現在二者中）
# 示例
# 創建集合
>>> set('hello')
{'e', 'o', 'l', 'h'}
# 並集
>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 | s2
{1, 2, 3, 4}
>>> s1.union(s2)
{1, 2, 3, 4}
# 交集
>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 & s2
{2, 3}
>>> s1.intersection(s2)
{2, 3}
# 差集
>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 - s2
{1}
# 注：s1裡面有的,s2裡面沒有的
>>> s2 - s1
{4}
# 對稱差集
>>> s1 = {1,2,3}
>>> s2 = {2,3,4}
>>> s1 ^ s2
{1, 4}
# 注：除了交集 的部分