相關鏈接

• 目錄
• Mac M1 Python環境搭建
• Python3.x入門 P1 【基礎】注釋、標識符、變量、數據類型
• Python3.x入門 P2 【基礎】運算符
• Python3.x入門 P3 【基礎】流程語句【循環結構】
• Python3.x入門 P4 【基礎】可變序列（列表list、字典dict、集合set）
• Python3.x入門 P5 【基礎】不可變序列（元組tuple、字符串str）
• Python3.x入門 P6 【字符串格式化】四種方式（手動、%-formatting、str.format()、f-String）
• Python3.x入門 P7 【函數】

一、序列

可變序列：可以對執行序列進行增、刪、改操作，對象地址不發生改變。

① 列表list -> [v1,v2,…]、② 集合set -> {k1,k2,…}、③ 字典dict -> {k1:v1,…}

不可變序列：沒有增、刪、改的操作。由於其不可變特性，在多線程場景下，不需要加鎖。

① 元組tuple -> (v1,v2,…) 、② 字符串str -> ‘’

1.1 可變序列&不可變序列

""" @author GroupiesM @date 2022/6/22 16:11 @introduction 可變序列：列表list、字典dict、集合set 可以對執行序列進行增、刪、改操作，對象地址不發生改變 不可變序列：元組tuple、字符串str 沒有增、刪、改的操作 """
'''可變序列 列表list、字典dict、集合set'''
lst = [10, 20, 45]
lst.append(300)
print(lst) # [10, 20, 45, 300]
'''不可變序列 元組tuple、字符串str'''
t = ('python', 5)
print(t) # ('python', 5)

1.2 不可變序列&多線程

""" @author GroupiesM @date 2022/4/29 09:25 @introduction 不可變序列（元組、字符串）在多個線程場景下，同時操作同一對象時不需要加鎖 注意事項： 元組中存儲的是對象的引用 a) 如果元組中對象本身不可變對象，即指向的內存地址不可變 b) 如果元組中的對象是非基本類型，可以修改其中的數據 """
t = (10, [20, 30], 9)
print(t) # (10, [20, 30], 9)
'''元組中的元素是引用類型時，可以修改引用類型的數據'''
t[1].remove(30) # (10, [20], 9)
print(t) # (10, [20], 9)
'''不可以修改元素的內存地址'''
t[1] = [50]
print(t) # TypeError: 'tuple' object does not support item assignment

1.3 總結

P.S:
1.不可變序列在內存中是不會改變的

2.如果對不可變序列做出改變，會將該序列存儲在新的地址空間中，而原來的序列因為垃圾回收機制，會被回收。

3.可變序列發生改變時，是不會改變地址的，而是改變內存中的值，或者是擴展內存空間。

4.字典是一個可變序列，但是字典的鍵是不可變的，而值是可變的。因為字典結構的原理是偽隨機探測的散列表，它的查找方式是將鍵通過哈希函數，找到值的內存地址。所以哈希後的值一般是唯一的或是沖突比較小的。如果改變鍵的值，name哈希後的值就會發生變化，導致找不到原來的值，所以鍵的值是不可變的。鍵哈希後指向的是內存中的地址，內存中的數據發生變化不影響字典的查找。

二、列表list -> [v1,v2,…]

2.1 簡介

""" @author GroupiesM @date 2022/4/28 09:26 @introduction <class 'list'> 列表：list = ['hello', 'world', 100] 集合: set = {'python', 'hello', 90} 字典：dict = {'name': '張三', 'age': 100} 元組：tuple = ('python','hello',90) 字符串: str = 'python' """
lst = ['hello', 'world', 100]
print(type(lst)) # <class 'list'>
print(lst) # ['hello', 'world', 100]

2.2 創建

""" @author GroupiesM @date 2022/4/28 09:36 @introduction 列表創建方式： 方式一：使用中括號[]，元素之間英文逗號分隔 list = ['hello','python'] 方式二：內置函數 list() 類型轉換 list(('hello','php')) # list -> list list({'name': '張三', 'age': 100}) # 字典 -> list list(['hello','php']) # 元組 -> list list({'python', 'hello', 90}) # 集合 -> list list('hello') # 字符串->list """
'''方式一'''
lst = ['hello', 'python', 13]
print(lst) # ['hello', 'python', 13]
'''方式二'''
'''1.list->list'''
lst1 = list(('hello', 'php')) # list -> list
print('lst1', lst1) # ['hello', 'php']
'''2.字典->list時，自動取字典的key'''
lst2 = list({
'name': '張三', 'age': 100}) # 字典 -> list
print('lst2', lst2) # ['name', 'age']
'''3.元組->list'''
lst3 = list(['hello', 'php']) # 元組 -> list
print('lst3', lst3) # ['hello', 'php']
'''4.集合->list'''
lst4 = list({
'python', 'hello', 90}) # 集合 -> list
print('lst4', lst4) # [90, 'python', 'hello']
'''5.字符串->list'''
lst5 = list('hello') # 字符串->list
print('lst5', lst5) # ['h', 'e', 'l', 'l', 'o']

2.3 特點

""" @author GroupiesM @date 2022/4/28 09:41 @introduction 1.元素有序 2.每個索引映射唯一數據 3.值可重復 4.任意數據類型混合存儲 5.根據需要動態分配和回收內存 6.基本類型：值相同時，內存地址一樣 7.引用類型：值相同時，內存地址不一樣 P.S len()獲取對象長度,不能用於int，float，bool類型 """
list = ['hello', 'hello', ['張三', '李四'], ['張三', '李四'], 50, True]
print(len(list)) # 5
for i in range(0, len(list)):
print(list[i], end="\t")
'''hello hello ['張三', '李四'] ['張三', '李四'] 50 True '''
print()
for i in range(0, len(list)):
print(id(list[i]), end="\t")
''' hello出現了兩次，兩次的id都是4310643824 ['張三', '李四']：兩次出現，id卻不同 4310643824 4310643824 4312636928 4312643456 4321732376 4321512264 '''

2.4 list[n] 查找 索引 -> 值

""" @author GroupiesM @date 2022/4/28 10:10 @introduction 索引->值: 正向索引從0到n-1 list[0] -> list[n-1] 逆向索引從-n到-1 list[-n] -> list[-1] 指定索引不存在，拋出IndexError """
list = ['hello', 'python', 'python', 50, True]
print('--------正向索引遍歷--------')
for i in range(0, len(list)):
print(list[i], end="\t") # # hello python python 50 True
print('\n--------逆向索引遍歷--------')
for i in range(-len(list), 0, 1):
print(list[i], end="\t") # hello python python 50 True

2.5 list.index() 查找 值 -> 索引

""" @author GroupiesM @date 2022/4/28 09:55 @introduction index(): 如果列表中存在n個相同元素，只返回相同元素中第一個元素索引 如果查詢的元素在列表中不存在，則會拋出ValueError 還可以指定的start,stop索引范圍內查找 """
list = ['hello', 'python', 'python', 50, True]
''' index: 0 1 2 3 4 ['hello', 'python', 'python', 50, True] '''
num: int = list.index('python')
print(num)
'''1'''
num: int = list.index(50)
print(num)
'''3'''
num: int = list.index('50')
print(num)
'''ValueError: '50' is not in list'''

2.6 切片 -> 獲取新列表

""" @author GroupiesM @date 2022/4/28 10:15 @introduction 獲取列表中的多個元素 語法格式： 列表名[start:stop:step] 切片操作： 切片的結果：原列表切片，形成新的列表 切片的范圍：[start,stop) step默認為1：簡寫為[start:stop] step為正數：從start開始往後計算切片 [:stop:step]：切片的第一個元素默認是列表的第一個元素 [start::step]：切片的最後一個元素默認是列表的最後一個元素 step為負數：從start開始往前計算切片 [:stop:step]：切片的第一個元素默認是列表的最後一個元素 [start::step]：切片的最後一個元素默認是列表的第一個元素 """
# 0 1 2 3 4 5 6 7 8 9 正向索引
list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# -9 -8 -7 -6 -5 -4 -3 -2 -1 0 逆向索引
'''索引長度'''
print(len(list)) # 10
'''step默認為1'''
print(list[1:8]) # [2, 3, 4, 5, 6, 7, 8]
print(list[1:-2]) # [2, 3, 4, 5, 6, 7, 8]
'''step為正數'''
print(list[:10:2]) # [1, 3, 5, 7, 9]
print(list[0::2]) # [1, 3, 5, 7, 9]
'''step為負數數'''
print(list[:-10:-2]) # [10, 8, 6, 4, 2]
print(list[10::-2]) # [10, 8, 6, 4, 2]

2.7 判斷 in&not in

""" @author GroupiesM @date 2022/4/28 11:12 @introduction 判斷指定元素在列表中是否存在 元素 in 列表名 元素 not in 列表名 """
list = [10, 20, 30, 40]
print('p' in 'python') # True
print(10 in list) # True
print(15 in list) # False
print('abc' not in list) # True

2.8 遍歷

""" @author GroupiesM @date 2022/4/28 11:30 @introduction 列表元素的遍歷 for 迭代遍歷 in 列表名 操作 """
list = [1, 2, 3, 4]
print("----方式一------")
for i in list:
print(i, end="\t") # 1 2 3 4
print("\n----方式二------")
for i in range(len(list)):
print(list[i], end="\t") # 1 2 3 4

2.9 添加的5種方式

1. append(Object obj)：在列表末尾添加一個元素。

2. extend(Iterator iter)：在列表末尾添加一個元素。（遍歷其中所有元素後，添加其中的元素）

3. insert(Integer i,Object obj)：在列表的指定位置添加元素。

4. lst[切片]：先對列表切片，再添加ele。lst[start:stop:step]：三個參數均可以不填。

5. +：兩個列表相加。

P.S ：Object = 任意類型； Iterator = 迭代器類型

2.9.1 append()-添加元素到末尾

""" @author GroupiesM @date 2022/4/28 11:38 @introduction append(Object obj)：在列表末尾添加一個元素。 """
'''添加元素 - 基本類型'''
lst = [10, 20, 30]
lst.append(40)
lst.append(50)
print(lst, id(lst)) # [10, 20, 30, 40, 50] 4378974400 lst重新賦值，id發生改變
'''添加元素 - 列表'''
lst = [10, 20, 30]
tmp = [40, 50]
print(lst, id(lst)) # [10, 20, 30] 4377304000
lst.append(tmp)
print(lst, id(lst)) # [10, 20, 30, [40, 50]] 4377304000,id沒變，說明還是原來的列表

2.9.2 extend()-遍歷元素並添加到末尾

""" @author GroupiesM @date 2022/4/28 11:39 @introduction extend(Iterator iter)：在列表末尾添加一個元素。（遍歷其中所有元素） """
''' 添加元素 - 基本類型(x) extend只適用於迭代器類型元素 '''
lst = [10, 20, 30, 40]
try:
lst.extend(50)
except Exception as e:
print(e) # 'int' object is not iterable
print(lst)
''' 添加元素 - 列表(v) 列表屬迭代器 '''
lst = [10, 20, 30, 40]
tmp = [40, 50]
lst.extend(tmp)
print(lst)

2.9.3 insert()-添加元素到指定位置

""" @author GroupiesM @date 2022/4/28 13:46 @introduction insert(Integer i,Object obj)：在列表的指定位置添加元素。 """
''' 添加元素 - 基本類型 在索引0的位置添加一個元素 'a' '''
lst = [10, 20, 30]
print(lst, id(lst)) # [10, 20, 30] 4305885440
lst.insert(0, 'a')
print(lst, id(lst)) # ['a', 10, 20, 30] 4305885440
''' 添加元素 - 列表 在索引0的位置添加一個列表['a','b'] '''
lst = [10, 20, 30]
tmp = ['a', 'b']
print(lst, id(lst)) # [10, 20, 30] 4305886272
lst.insert(0, tmp)
print(lst, id(lst)) # [['a', 'b'], 10, 20, 30] 4305886272

2.9.4 切片(並替換)

""" @author GroupiesM @date 2022/4/28 13:33 @introduction lst[切片] = ele<iter>：先對列表切片，再添加 1) lst[start:stop:step] = ele<iter> : 1.1 替換操作 1.2 被替換的元素數量，和替換的元素數量，要相等 1.3 其中start，stop，step均可以不填，默認值分別為0，len(lst)，1 2) lst[start:stop] = ele<iter>: 其中start,stop均可以不填，默認值分別為0，len(lst) 2.1 替換操作 2.2 被替換的元素數量，和替換的元素數量，不需要相等 2.3 其中start，stop均可以不填，默認值分別為0，len(lst) 3) lst[start:start] = ele<iter>: 在上面的基礎上，start和stop值一樣，就相當於插入效果 區別：第一種方式前後元素數量要一致，第二種方式前後元素數量沒有要求 """
''' 1) 替換操作 [start:stop:step] 從索引0開始，索引每+2進行一次替換操作，一共進行10/2=5次 '''
lst = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
tmp = ['a', 'b', 'c', 'd', 'e']
lst[0:len(lst):2] = tmp
print(lst) # ['a', 10, 'b', 30, 'c', 50, 'd', 70, 'e', 90]
lst = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
tmp = ['a', 'b', 'c', 'd', 'e']
# lst[::2] 等價於 lst[0:len(lst):2]
lst[::2] = tmp
print(lst) # ['a', 10, 'b', 30, 'c', 50, 'd', 70, 'e', 90] ,與上面測試結果相同，兩種寫法等價
lst = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
tmp = ['a', 'b', 'c', 'd']
try:
lst[::2] = tmp
except Exception as e:
print(e)
""" attempt to assign sequence of size 4 to extended slice of size 5 嘗試將大小為4的序列分配給大小為5的擴展片 """
print(lst)
''' 2) 替換操作 [start:stop] 2.1) 將1-end，替換為新數組 2.2) 將0-1，替換為新數組 '''
lst = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
tmp = ['a', 'b', 'c', 'd', 'e']
lst[1:] = tmp
print(lst) # [0, 'a', 'b', 'c', 'd', 'e']
lst = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
tmp = ['a', 'b', 'c', 'd', 'e']
lst[1:len(lst)] = tmp
print(lst) # [0, 'a', 'b', 'c', 'd', 'e']
''' 3) 添加操作 [start:start] 3.1) 在索引1的位置插入新數組 '''
lst = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
tmp = ['a', 'b', 'c', 'd', 'e']
lst[1:1] = tmp
print(lst) # [0, 'a', 'b', 'c', 'd', 'e', 10, 20, 30, 40, 50, 60, 70, 80, 90]

2.9.5 +

兩個list可以相加 (+)，但是不可以做減法(-)。

""" @author GroupiesM @date 2022/6/29 14:17 @introduction + ：兩個列表相加 """
lst1=[1,2,3,4,5,6]
lst2=[5,6,7,8]
print(lst1 + lst2)#[1, 2, 3, 4, 5, 6, 5, 6, 7, 8]

2.10 刪除的5種方式

1. remove(Object obj)：刪除指定Value的元素。
1）一次刪除一個元素。
2）重復元素只刪除第一個。
3）Value不存在則拋出ValueError。

2. pop(Integer i)：刪除指定index的元素。
1）指定索引不存在拋出IndexError。
2）不指定索引，刪除列表中最後一個元素。

3. clear( )：清空列表。

4. del lst：刪除元素或列表。
1) del lst_name[index]：刪除指定索引。
2) del lst_name[start:end]：按指定范圍刪除元素
3) del lst_name[start:end :step] ：按指定范圍、間隔刪除元素
4) del lst_name ：刪除列表。不只是刪除元素，刪除後整個列表都不存在。
其中參數start（開始位置）、end（結束位置）、step（步長）均可以省略，省略時默認值為 start=0，end=len(lst_name)，step=1。

5. lst[切片]：對列表切片。

2.10.1 remove()-刪除指定Value

""" @author GroupiesM @date 2022/4/28 15:39 @introduction remove(): 刪除指定Value的元素 一次刪除一個元素 重復元素只刪除第一個 Value不存在則拋出ValueError """
lst = [10, 20, 30, 20, 10]
lst.remove(10)
print(lst) # [20, 30, 20, 10]
lst.remove(30)
print(lst) # [20, 20, 10]

2.10.2 pop()-彈出指定索引位置

""" @author GroupiesM @date 2022/4/28 15:39 @introduction pop(): 刪除指定index的元素 指定索引不存在拋出IndexError 不指定索引，刪除列表中最後一個元素 """
lst = [10, 20, 30, 20, 10]
lst.pop(1)
print(lst) # [10, 30, 20, 10]
lst.pop(11) # IndexError: pop index out of range

2.10.3 clear()-清空列表

""" @author GroupiesM @date 2022/4/28 15:39 @introduction clear(): 清空列表 """
lst = [10, 20, 30, 20, 10]
lst.clear()
print(lst) # []

2.10.4 del lst-刪除元素或列表

""" @author GroupiesM @date 2022/4/28 15:39 @introduction del: 刪除元素或列表 1) del lst_name[index]：刪除指定索引 2) del lst_name[start:end]：按指定范圍刪除元素 3) del lst_name[start:end:step] ：按指定范圍、間隔刪除元素 4) del lst_name ：刪除列表。不只是刪除元素，刪除後整個列表都不存在。 其中參數start（開始位置）、end（結束位置）、step（步長）均可以省略，省略時默認值為 start=0，end=len(lst_name)，step=1 """
# 1) del lst_name[index]：刪除指定索引
lst = [10, 20, 30, 40, 50]
del lst[0]
print(1, lst) # [20, 30, 40, 50]
# 2) del lst_name[start:end]：按指定范圍刪除元素
lst = [10, 20, 30, 40, 50]
del lst[:5] # 默認start=0，end=5
print(2, lst) # []
# 3) del lst_name[start:end:step] ：按指定范圍、間隔刪除元素
lst = [10, 20, 30, 40, 50]
del lst[0:3:] # 默認step=1
print(3, lst)
# 4) del lst_name ：刪除列表，
lst = [10, 20, 30, 40, 50]
del lst
# print(4,lst) # NameError: name 'lst' is not defined

2.10.5 切片

""" @author GroupiesM @date 2022/4/28 15:39 @introduction 切片: 刪除指定[范圍]的索引 """
lst = [10, 20, 30, 20, 10]
lst = lst[::2] # 從0開始，到結尾，index每+2，截取一次
print(lst) # [10, 30, 10]

2.11 修改元素

""" @author GroupiesM @date 2022/4/28 15:47 @introduction 列表元素的修改操作 為指定索引的元素賦值一個新值 為指定的切片賦值一個新值 """
''' 單值修改 將索引為2的值修改為100 '''
lst = [10, 20, 30, 40]
lst[2] = 100
print(lst) # [10, 20, 100, 40]
''' 范圍修改 將索引 [1-3) 的值修改為200,300,400,500 '''
lst = [10, 20, 30, 40]
lst[1:3] = [200, 300, 400, 500]
print(lst) # [10, 200, 300, 400, 500, 40]

2.12 排序

""" @author GroupiesM @date 2022/4/28 15:54 @introduction 常見的兩種方式 1) 調用sort()方法，列中的所有元素默認按照從小到大的順序進行排序，可以指定revers=True，進行降序排序 2) 調用內置函數sorted()，可以指定revers=True，進行降序排序 區別： sort() 對原列表進行處理 sorted() 返回一個新列表，原列表不發生改變 """
''' 1) sort排序 指定參數 reverse=True 可以進行倒序排序 調用列表方法 reverse 可以進行反轉實現倒序排序 '''
'''1.1 升序排序'''
lst = [10, 90, 20, 80, 30, 70]
lst.sort()
print(lst) # [10, 20, 30, 70, 80, 90]
'''1.2 降序排序'''
lst = [10, 90, 20, 80, 30, 70]
lst.sort(reverse=True) # reverse=True表示降序排序，默認reverse=False
print(lst) # [90, 80, 70, 30, 20, 10]
'''1.3 降序排序'''
lst = [10, 90, 20, 80, 30, 70]
lst.sort()
lst.reverse()
print(lst) # [90, 80, 70, 30, 20, 10]
''' 2) sorted排序 '''
print("-------------")
'''2.1 升序排序'''
lst = [10, 90, 20, 80, 30, 70]
n_lst = sorted(lst)
print(n_lst) # [10, 20, 30, 70, 80, 90]
'''2.2 降序排序'''
lst = [10, 90, 20, 80, 30, 70]
n_lst = sorted(lst, reverse=True)
print(n_lst) # [90, 80, 70, 30, 20, 10]

2.13 列表生成式

""" @author GroupiesM @date 2022/4/28 16:05 @introduction 全稱"生成列表的公式" 語法格式： [fx(i) for i in range(n,m)] fx(i): 表達式 i : 自定義變量 range(n,m) : 可迭代對象 注意事項： 表示列表元素的表達式中，通常包含自定義變量 """
lst = [i * i for i in range(0,10)]
print(lst) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
''' 第一次循環 i=0, i*i = 0 第二次循環 i=1, i*i = 1 第三次循環 i=2, i*i = 4 第四次循環 i=3, i*i = 9 第五次循環 i=4, i*i = 16 '''

2.14 轉換-zip->list

""" @author GroupiesM @date 2022/6/22 15:22 @introduction 內置函數zip(): 用於將可迭代的對象作為參數，將對象中對應的元素打包成一個元組，然後返回有這些元組組成的列表 key-value數量不一致時，參考短板效應 """
items = ['水果', '書本', '魚缸', '馬桶']
prices = [10, 20, 30]
zip = zip(items, prices)
lst = list(zip)
print(type(zip), zip) # <class 'zip'> <zip object at 0x1046d6e80>
print(type(lst), lst) # <class 'list'> [('水果', 10), ('書本', 20), ('魚缸', 30)]

三、集合set -> {k1,k2,…}

3.1 簡介&特點

特點
1) 屬可變序列
2) 自動去重
3) 集合中元素無序排列

""" @author GroupiesM @date 2022/4/28 17:14 @introduction <class 'set'> 列表：list = ['hello', 'world', 100] 集合: set = {'python', 'hello', 90} 字典：dict = {'name': '張三', 'age': 100} 元組：tuple = ('python','hello',90) 字符串: str = 'python' """
s = {
'python', 'hello', 90, 90}
print(type(s)) # <class 'set'>
print(s) # {90, 'python', 'hello'}

3.2 創建

""" @author GroupiesM @date 2022/4/29 15:21 @introduction 方式一：使用花括號{}，元素之間英文逗號分隔 set = {'python', 'hello', 90} 方式二：內置函數 list() 類型轉換 set(['hello','php']) # 元組->set set('hello') # 字符串->set 集合創建方式： 方式一：使用花括號{}，元素之間英文逗號分隔 set = ['hello','python'] 方式二：內置函數 list() 類型轉換 set(('hello','php')) # list -> set set({'name': '張三', 'age': 100}) # 字典 -> set set(['hello','php']) # 元組 -> set set({'python', 'hello', 90}) # 集合 -> set set('hello') # 字符串->set """
'''方式一'''
s = {
'hello', 'python'}
print(s) # {'python', 'hello'}
'''方式二'''
'''1.list->set'''
set1 = set(('hello', 'php')) # list -> set
print('set1', set1) # {'php', 'hello'}
'''2.字典->set時，自動取字典的key'''
set2 = set({
'name': '張三', 'age': 100}) # 字典 -> set
print('set2', set2) # {'age', 'name'}
'''3.元組->set'''
set3 = set(['hello', 'php']) # 元組 -> set
print('set3', set3) # {'php', 'hello'}
'''4.集合->set'''
set4 = set({
'python', 'hello', 90}) # 集合 -> set
print('set4', set4) # {'python', 90, 'hello'}
'''5.字符串->set'''
set5 = set('hello') # 字符串->set
print('set5', set5) # {'h', 'o', 'l', 'e'}

3.3 判斷in&not in

""" @author GroupiesM @date 2022/4/29 15:32 @introduction in、not in """
s = {
10, 20, 30, 40, 50}
print(10 in s) # True
print(100 in s) # False
print(15 not in s) # True

3.4 添加2種方式

1. add(Object obj)：set集合添加指定元素。

2. extend(Iterator iter)：遍歷序列(列表、元組、集合等)，獲取其中的元素並添加到set集合。

3.4.1 add()-添加指定元素

""" @author GroupiesM @date 2022/6/28 11:06 @introduction add(Object obj)：添加一個元素 """
s = {
10, 20, 30, 40, 50}
s.add(60)
print(s) # {40, 10, 50, 20, 60, 30}

3.4.1 update()-遍歷iterable將元素添加到set

""" @author GroupiesM @date 2022/6/28 11:06 @introduction update(Iterator iter):添加一個迭代器(列表、元組、集合等) """
s = {
10, 20, 30, 40, 50}
s.update(['a', 'b', 'c'])
print(s) # {'a', 40, 10, 50, 20, 'c', 'b', 60, 30}

3.5 刪除4種方式

1. remove(Object obj)：刪除指定Key的元素。
1）一次刪除一個元素。
2）Key不存在則拋出KeyError。

2. discard(Integer i)：刪除指定Key的元素。
1）Key不存在不報錯。

3. pop( )：刪除最左邊的一個元素。（左側彈出）

4. clear()：清空集合。

3.5.1 remove()-刪除指定Key

""" @author GroupiesM @date 2022/6/22 17:14 @introduction remove(Object obj):刪除指定元素，不存在拋出KeyError """
s = {
10, 20, 30, 40, 50}
s.remove(10)
print(s) # {40, 50, 20, 30}

3.5.2 discard()-刪除指定Key（不存在不報錯）

""" @author GroupiesM @date 2022/6/22 17:15 @introduction discard(Object obj):刪除指定元素，不存在不報錯 """
s = {
10, 20, 30, 40, 50}
s.discard(15)
s.discard(20)
print(s) # {40, 10, 50, 30}

3.5.3 pop()-左側彈出1個

""" @author GroupiesM @date 2022/6/22 17:15 @introduction pop():刪除一個任意元素(左側彈出） """
s = {
10, 20, 30, 40, 50}
s.pop()
print(s) # {10, 50, 20, 30}

3.5.4 clear()-清空列表

""" @author GroupiesM @date 2022/6/22 17:15 @introduction clear():清空 """
s = {
10, 20, 30, 40, 50}
s.clear()
print(s) # set()

3.6 判斷-集合關系4種方式

""" @author GroupiesM @date 2022/4/29 15:43 @introduction 集合關系概念： 1.子集：如果a集合是b集合的子集，那麼a集合中的所有元素，在b集合中都存在，那麼a就是b的子集，記作"a∈b" 2.真子集：在上述情況下，b中至少有一個元素不屬於a，那麼a就是b的真子集，記作"A⊊B" 3.超集：如果a是b的真子集，那麼b就是a的超集 判斷集合關系4種方式： 1. 元素是否相等 == 或 != 2. 是否子集 issubset() 3. 是否超集 (這裡超集定義與數學中不同，ab集合元素完全相等時，也互為超集） issuperset() 4. 是否無交集 isdisjoint() """

3.6.1 判斷集合關系-==或!=

""" @author GroupiesM @date 2022/6/22 17:19 @introduction 1. 元素是否相等 == 或 != """
a = {
1, 2}
a1 = {
1, 2}
b = {
1, 2, 3, 4, 5}
c = {
5, 6}
d = {
6, 7}
print('----------元素是否相等----------')
print(a == a1) # True
print(a != a1) # Fasle

3.6.2 判斷集合關系-issubset()

""" @author GroupiesM @date 2022/6/22 17:20 @introduction 2. 是否子集 issubset() """
a = {
1, 2}
a1 = {
1, 2}
b = {
1, 2, 3, 4, 5}
c = {
5, 6}
d = {
6, 7}
print('----------是否子集 issubset()----------')
print(a.issubset(a1)) # True
print(a.issubset(b)) # True
print(a.issubset(c)) # False

3.6.3 判斷集合關系-issuperset()

""" @author GroupiesM @date 2022/6/22 17:20 @introduction 3. 是否超集 (這裡超集定義與數學中不同，ab集合元素完全相等時，也互為超集） issuperset() """
a = {
1, 2}
a1 = {
1, 2}
b = {
1, 2, 3, 4, 5}
c = {
5, 6}
d = {
6, 7}
print('----------是否超集 issuperset()----------')
print(a.issuperset(a1)) # True
print(b.issuperset(a)) # True
print(b.issuperset(c)) # False

3.6.4 判斷集合關系-isdisjoint()

""" @author GroupiesM @date 2022/6/22 17:20 @introduction 4. 是否無交集 isdisjoint() """
a = {
1, 2}
a1 = {
1, 2}
b = {
1, 2, 3, 4, 5}
c = {
5, 6}
d = {
6, 7}
print('----------是否無交集 isdisjoint()----------')
print(a.isdisjoint(a1)) # False
print(b.isdisjoint(c)) # False
print(b.isdisjoint(d)) # True

3.7 數學計算-集合

""" @author GroupiesM @date 2022/4/29 15:59 @introduction 交集： {1,2} & {2,3} => {2} 方式一：intersection() 方式二：& 並集： {1,2} & {2,3} => {1,2,3} 方式一：union() 方式二：| 差集： {1,2} x {2,3} => {1} 方式一：difference() 方式二：- 對稱差集： {1,2} & {2,3} => {1,3} 方式一：symmetric_difference() 方式二：^ => shift + 數字6 """
s1 = {
1, 2}
s2 = {
2, 3}
print('---------交集 {2} --------')
print(s1.intersection(s2))
print(s1 & s2)
print('---------並集 {1, 2, 3}--------')
print(s1.union(s2))
print(s1 | s2)
print('---------差集 {1}--------')
print(s1.difference(s2))
print(s1 - s2)
print('---------對稱差集 {1,3}--------')
print(s1.symmetric_difference(s2))
print(s1 ^ s2)

3.8 集合生成式

""" @author GroupiesM @date 2022/4/29 16:06 @introduction <class 'set'> 全稱"生成集合的公式" 語法格式： {fx(i) for i in range(n,m)} fx(i): 表達式 i : 自定義變量 range(n,m) : 可迭代對象 注意事項： 將{}改為[]，就是list 列表生成式 """
set1 = {
i * 2 for i in range(1, 5)}
print(set1) # {8, 2, 4, 6}

四、字典dict -> {k1:v1,…}

4.1 簡介

""" @author GroupiesM @date 2022/4/28 16:09 @introduction <class 'dict'> 列表：list = ['hello', 'world', 100] 字典：dict = {'name': '張三', 'age': 100} 元組：tuple = ('python','hello',90) 集合: set = {'python', 'hello', 90} 字符串: str = 'python' 字典：python內置的數據結構之一，與列表一樣是一個可變序列 以【鍵值對】方式存儲數據，字典是一個無序數列 m1 = {'name': '張三', 'age': 100} 實現原理：字典的實現原理與查字典類似，查字典實現根據部首或拼音查找相應的頁碼 Python中的字典是根據key查找value所在的位置 id = hash(key) 字典視圖：詳見 4.8 獲取字典視圖種方式 dict_keys: <class 'dict_keys'> dict_values: <class 'dict_values'> dict_items: <class 'dict_items'> """
dict = {
'name': '張三', 'age': 100}
print(type(dict)) # <class 'dict'>
print(dict) # {'name': '張三', 'age': 100}

4.2 創建

""" @author GroupiesM @date 2022/4/28 16:17 @introduction 字典創建方式： 方式一：使用花括號 {}，元素之間英文逗號分隔 scores = {'name': '張三', 'age': 100} 方式二：內置函數 dict() 類型轉換 dict(k1=v1,k2=v2,...) """
'''方式一'''
dct1 = {
'name': '張三', 'age': 100, 'salary': 1888}
print(dct1) # {'name': '張三', 'age': 100, 'salary': 1888}
'''方式二'''
dct2 = dict(name='張三', age=100, salary=1888)
print(dct2) # {'name': '張三', 'age': 100, 'salary': 1888}
'''空字典'''
dct3 = {
} # 空字典
print(dct3) # {}

4.3 特點

""" @author GroupiesM @date 2022/4/28 16:52 @introduction 1) 所有元素都是 k-v鍵值對，key不允許重復，value可以重復 2) 字典中的元素是無序的 3) 字典中的key必須是基本類型（不可變對象） 4) 字典也可以根據需要動態的伸縮 5) 字典會浪費比較大的內存，是一種使用空間換時間的數據結構 """
''' 1) 所有元素都是 k-v鍵值對，key不允許重復，value可以重復 {'name': '李四'} {'name': '張三', 'nickname': '張三'} '''
m1 = {
'name':'張三','name':'李四'}
print(m1)
m1 = {
'name':'張三','nickname':'張三'}
print(m1)

4.4 查找 k->v

""" @author GroupiesM @date 2022/4/28 16:26 @introduction m1 = {'name': '張三', 'age': 100, 'salary': 1888} 方式一： []: 舉例 m1['張三'] 方式二： get(): 舉例 m1.get('張三') 區別： []：如果不存在指定key，拋出keyError異常 get()：如果不存在指定key，返回None，可以通過參數設置默認value，查不到key時返回默認值 """
m1 = {
'name': '張三', 'age': 100, 'salary': 1888}
'''方式一：[]獲取name'''
name = m1['name']
print(name) # 張三
'''方式二：get()獲取age'''
age = m1.get('age')
print(age) # 100
'''方式二：get()獲取不存在的key'''
address = m1.get('address')
print(address) # None
'''方式二：get()獲取不存在的key，並指定默認值'''
address = m1.get('address','china')
print(address) # china
'''方式二：get()獲取存在的key，並指定默認值，默認值不生效'''
salary = m1.get('salary','1萬')
print(salary) # 1888

4.5 判斷 in&not in

""" @author GroupiesM @date 2022/4/28 16:34 @introduction key的判斷 in: 指定key在字典中存在返回True not in:指定key在字典中不存在返回True """
m1 = {
'name': '張三', 'age': 100, 'salary': 1888}
b1 = 'name' in m1
b2 = 'address' in m1
b3 = 'country' not in m1
print(b1) # True
print(b2) # False
print(b3) # True

4.6 添加元素-k=v

""" @author GroupiesM @date 2022/4/28 16:37 @introduction dict['key']= xxx """
m1 = {
'name': '張三', 'age': 100, 'salary': 1888}
m1['country'] = '中國'
print(m1) # {'name': '張三', 'age': 100, 'salary': 1888, 'country': '中國'}

4.7 刪除元素-del

""" @author GroupiesM @date 2022/4/28 16:37 @introduction del dict['key'] """
m1 = {
'name': '張三', 'age': 100, 'salary': 1888}
del m1['salary']
print(m1) # {'name': '張三', 'age': 100}

4.8 獲取字典視圖3種方式

""" @author GroupiesM @date 2022/4/28 16:40 @introduction 方式1：keys() : 獲取字典中所有key 返回值類型：<class 'dict_keys'> 方式2：values() : 獲取字典中所有value 返回值類型：<class 'dict_values'> 方式3：items() : 獲取字典中所有key,value對 返回值類型：<class 'dict_items'> """

4.8.1 獲取字段中所有key-keys()

""" @author GroupiesM @date 2022/6/22 14:51 @introduction <class 'dict_keys'> """
map = {
'name': '張三', 'age': 100, 'salary': 1888}
key_lst = map.keys()
print(key_lst, type(key_lst)) # dict_keys(['name', 'age', 'salary']) <class 'dict_keys'>
''' dict_keys -> list 其中dict_keys是元組類型(), 詳見b1元組tuple '''
print(list(key_lst)) # ['name', 'age', 'salary']

4.8.2 獲取字典中所有value-values()

""" @author GroupiesM @date 2022/6/22 14:51 @introduction <class 'dict_values'> """
map = {
'name': '張三', 'age': 100, 'salary': 1888}
value_lst = map.values()
print(value_lst, type(value_lst)) # dict_values(['張三', 100, 1888]) <class 'dict_values'>
''' dict_keys -> list 其中dict_keys是元組類型(), 詳見b1元組tuple '''
print(list(value_lst)) # ['張三', 100, 1888]

4.8.3 獲取字典中所有kv對-items()

""" @author GroupiesM @date 2022/6/22 14:52 @introduction <class 'dict_items'> """
map = {
'name': '張三', 'age': 100, 'salary': 1888}
item_lst = map.items()
print(item_lst, type(item_lst)) # dict_items([('name', '張三'), ('age', 100), ('salary', 1888)]) <class 'dict_items'>
''' dict_keys -> list 其中dict_keys是元組類型(), 詳見b1元組tuple '''
print(list(item_lst)) # [('name', '張三'), ('age', 100), ('salary', 1888)]

4.9 遍歷

""" @author GroupiesM @date 2022/4/28 16:49 @introduction i是dict的所有key 通過dict.get(i)、或dict[i]獲取每個key對應的value for i in dict: print(i,dict.get(i)) for i in dict: print(i,dict[i]) """
''' 遍歷key-value name 張三 age 100 salary 1888 '''
m1 = {
'name': '張三', 'age': 100, 'salary': 1888}
for k in m1:
print(k, m1.get(k))
''' 遍歷value 張三 100 1888 '''
for v in m1.values():
print(v,end="\t")

4.10 轉換-zip->dict

""" @author GroupiesM @date 2022/6/22 15:22 @introduction 語法格式： {k: v for k, v in zip} k : 自定義變量key v : 自定義變量value zip : 可迭代zip對象 內置函數zip(): 用於將可迭代的對象作為參數，將對象中對應的元素打包成一個元組，然後返回有這些元組組成的列表 key-value數量不一致時，參考短板效應 """
items = ['水果', '書本', '魚缸', '馬桶']
prices = [10, 20, 30]
'''方式一：dict()'''
zip1 = zip(items, prices)
dct1 = dict(zip1)
print(type(zip1), zip1) # <class 'zip'> <zip object at 0x1046d6e80>
print(type(dct1), dct1) # <class 'dict'> {'水果': 10, '書本': 20, '魚缸': 30}
'''方式二：{k: v for k, v in zip}'''
zip2 = zip(items, prices)
dct2 = {
k: v for k, v in zip2} # zip1只能使用一次，如果此處繼續使用zip1，則返回空字典dct2
print(type(dct2), dct2) # <class 'dict'> {'水果': 10, '書本': 20, '魚缸': 30}

22/06/28

M