元組

如果想要儲存多個資料，但是這些資料是不能修改的資料，怎麼辦？
答：列表可以一次性儲存多個資料，但是列表中的資料允許修改
一個元組可以儲存多個資料，元組內的資料是不能修改的。

一、定義元組

元組的特點：定義元組使用小括號，且逗號隔開各個資料，資料可以是不同的資料型別

t = (1)
print(t)			# 1
print(type(t))		# <class 'int'>

t = (1,)
print(t)			#(1,)
print(type(t))		# <class 'tuple'>

二、元組的常見操作

元組資料不支援修改，只支援查詢，具體如下：
1、按下標查詢資料：

2、index():查詢某個資料，如果資料存在返回對應的下標，否則報錯，語法和列表、字串的index()方法相同。

3、count():統計某個資料在當前元組出現的次數。

三、元組資料的修改操作

注意：元組內的直接資料如果修改則立即報錯

但是如果元組裡面有列表，修改列表裡面的資料則是支援的

t2 = ('aa', 'bb', ['cc', 'dd'])
print(t2[2])		# ['cc', 'dd']
print(t2[2][0])		# cc
t2[2][0] = 'TOM'
print(t2[2])		# ['TOM', 'dd']

字典

思考1：如果有多個資料，例如：’Tom’, ‘男’, ‘20’，如何快速儲存？
答：列表 list1 = [‘Tom’, ‘男’, 20]
思考2：如何查詢到資料’Tom’
答：查詢到下標為0的資料即可。list1[0]
思考3：如果將來資料順序發生改變，如下所示，還能用list[0]訪問到資料’Tom’嗎？
list1 = [‘男’, 20, ‘Tom’]
答：不能，資料’Tom’此時下標為2.
思考4：資料順序發生改變，每個資料的下標也會隨之改變，如何保證資料順序變化前後能使用同一的標準查詢資料呢？
答：字典，字典裡面的資料是以鍵值對形式出現，字典資料和資料順序沒有關係，即字典不支援下標，後期無論資料如何變化，只需要按照對應的鍵的名字查詢資料即可。

建立字典的語法

注意：一般冒號前面的為鍵(key) 簡稱k；冒號後面的為值(value)，簡稱v。

字典的常見操作

1.增

寫法：字典序列[key] = 值
注意，如果key存在則修改這個key 對應的值；如果key不存在則新增此鍵值對。

注意：字典為可變型別。

2.刪

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# del 刪除字典或指定的鍵值對
del(dict1)
print(dict1)

字典dict1已經被刪除了

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['name']
print(dict1)		# {'age': 20, 'gender': '男'}
# 刪除了鍵值對'name': 'Tom'以及中間的連線字元  ，

del dict1['names']
print(dict1)	
# 如果k不存在，便報錯	
dict1.clear()		# clear():清空字典
print(dict1)        #{}

3.改

寫法：字典序列[key] = 值
注意： 如果key存在則修改這個key對應的值；如果key不存在則新增此鍵值對。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

dict1['name'] = 'lily'
print(dict1)			# {'name': 'lily', 'age': 20, 'gender': '男'}

4. 查

key值查詢

如果當前查詢的key存在，則返回對應的值；否則則報錯。

get()

語法:
字典序列.get(key, 預設值)
注意：如果當前查詢的key不存在則返回第二個引數(預設值),如果省略第二個引數，則返回
None。

# 2.2 keys()        # 查詢字典中所有的key，返回可迭代帶向
print(dict1.keys())


# 2.3 values()        查詢字典中的所有的value，返回課迭代物件
print(dict1.values())
# 2.4 items()          
# 查詢字典中所有的鍵值對，返回可迭代物件，裡面的資料是元組，元組資料1是字典的key，元組資料2是字典的值
print(dict1.items())

字典的迴圈遍歷

遍歷字典的key(利用for)

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for key in dict1.keys():
    print(key)
# name  age  gender

遍歷字典的value

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for value in dict1.values():
    print(value)
# Tom  20  男

遍歷字典的元素

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for item in dict1.items():
    print(item)

遍歷字典的鍵值對

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

for value, key in dict1.items():
    print(f'{value} = {key}')

集合

一、建立集合

集合是可變型別
建立集合使用{} 或set(),但是如果要創造空集合之鞥你使用set()，因為{}用來創造空字典。

s1 = {10, 20, 30, 40, 50}
print(s1)
# {40, 10, 50, 20, 30}
# 集合沒有順序，所以沒有下標操作

# 重複資料
s2 = {10, 10, 20, 30, 40}
print(s2)
# {40, 10, 20, 30}
# 自動去除重複資料

s3 = set('abcdefg')
print(s3)				# {'g', 'e', 'd', 'a', 'b', 'f', 'c'}
s4 = set('123456')
print(s4)				# {'2', '5', '1', '3', '4', '6'}
# 使用set（）建立集合，會使（）中的字串自動分開。
# 123456必須要帶上‘ ’，否則會報錯，說明了set（）函式內部只允許輸入字串

# 創造空集合只能使用set函式：
s6 = set()
s7 = {}
print(type(s6))			# <class 'set'>
print(type(s7))			# <class 'dict'>

集合沒有順序，所以沒有下標操作

二、 集合常見操作方法

增加資料：add()

s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1)
# {100， 10， 20}
# 集合有去重功能，所以）並不會執行 s1.add（10） 此操作
# 此外，add函式不能增加序列否則會報錯。

增加序列 update():追加的資料是序列。

s1.update([10, 20, 30, 40])
print(s1)
#{40， 10， 20， 30}

錯誤注意！
s1.update(100)
print(s1)

update(中只能儲存序列)

a = [11]
s1.update(a)
print(s1)

# 如果是以字母進行輸入會自動辨識為變數名，要求你提前定義，如上圖a = [11]

remove():刪除集合中的指定資料，如果資料不存在則報錯。

ss = {10, 20, 30, 40, 50}

# remove(): 刪除指定資料，如果資料不存在報錯
ss.remove(10)
print(ss)
ss.remove(10)		# error
print(ss)

第一次print正常輸出，第二次由於集合當中再也沒有10這個元素了所以報錯。

discard():刪除集合中的指定資料，如果資料不存在也不會報錯。

# discard(): 刪除指定資料，如果資料不存在不報錯
ss.discard(10)
print(ss)			# {40, 50, 20, 30}
ss.discard(10)
print(ss)			# {40, 50, 20, 30}

pop():隨機刪除集合中的某個資料，並返回這個資料。

（可以設立一個新的變數接受被刪除的值）

del_num = ss.pop()
print(del_num)		 # 40
print(ss)			# {10, 50, 20, 30}

查詢資料

in :判斷資料在集合序列
not in:判斷資料不在集合序列

sz = {10, 20, 30, 40, 50}
print(10 in sz)			#Ture

print(10 not in sz)		#False

公共操作

一、運算子

str1 = 'aa'
str2 = 'bb'

list1 = [1,2]
list2 = [3,4]

s1 = (1,2)
s2 = (3,4)

dict1 = {'name':'Tom'}
dict2 = {'age': 18}

# +:合併
print(str1+str2)
print(list1 + list2)
print(s1 + s2)
print(dict1 + dict2)

字典不支援 + 運算子 所以報錯

print(str1 * 5)
print('-' * 10)
print(list1 * 5)
print(s1 * 5)

類似的，字典也不支援*運算子
in:
not in:

print('a' in str1)					# True
print('a' not in str1)				# False
print(1 in list1)					# True
print(1 not in list1)				# False
print(dict1.keys())					# dict_keys(['name'])	
print('name' in dict1.keys())		# True
print('name' in dict1.values())		# False

二、公共方法

len(), del

str1 = 'abcdefg'
lsst = [10, 20, 30, 40, 50]
t1 = (10, 20, 30, 40, 50)
s1 = {10, 20, 30, 40, 50}
dict1 = {'name': 'tom', 'age': 18}
# len()的使用
print(len(str1))	# 7
print(len(lsst))	# 5
del lsst[0]
print(lsst)
del lsst
print(lsst)

報錯原因：del函式刪除lsst之後，lsst列表消失了，print無法找到lsst列表，print要求重新定義一個lsst列表

min() 和 max()

str1 = 'abcdefg'
list1 = [10, 20, 30, 40, 50]

# max()
print(f'{max(str1)}')		# g
print(max(list1))			# 50

# min()
print(min(str1))			# a
print(min(list1))			# 10

range()

range(start,end,step)的使用:生成從start到end的數字，步長為step，供for迴圈使用
注意：range的使用方法和切片一樣，左閉右開，即取得到start的數字取不到end的數字
預設步長為1，預設start為0；

for i in range(1, 10, 1):
    print(i, end=' ')			# 1 2 3 4 5 6 7 8 9
print()
for i in range(1, 10, 2):
    print(i, end=' ')			# 1 3 5 7 9
print()
for i in range(10):
    print(i, end=' ')			# 0 1 2 3 4 5 6 7 8 9
print()

enumerate()

語法
enumerate(可遍歷物件, start = 0)
注意： start引數用來設定遍歷資料的下標的起始值，預設為0。

list1 = ['a', 'b', 'c', 'd', 'e']
# enumerate 返回結果是元組，元組第一個資料是原迭代物件的資料對應的下標，元組第二個資料是原迭代物件的資料
for i in enumerate(list1):
    print(i)

for i in enumerate(list1, start=1):
    print(i)

for index,char in enumerate(list1):
    print(f'下標為{index}，對應的字元為{char}')

三、 容器型別轉換

# tuple():將某個序列轉換成元組
# list():將某個序列轉換成列表
# set():將某個序列轉換成集合
list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}
t1 =('a', 'b', 'c', 'd', 'e')
print(tuple(list1))
print(tuple(s1))
print(list(s1))
print(list(t1))
print(set(list1))
print(set(t1))

注意：1.集合可以快速完成列表去重
2.集合不支援下標

推導式

一、列表推導式

作用：用一個表示式建立一個有規律的列表或控制一個有規律列表。
列表推導式又叫列表生成式。

需求： 建立一個0-10的列表。

# While迴圈實現：
# 需求：0， 1， 2， 3, 4 ...
# 1.迴圈實現； 2.列表推導式（化簡程式碼：建立或控制有規律的列表）
"""
1. 建立空列表
2. 迴圈將有規律的資料寫入到列表

"""
list1 = []
i = 0
while i < 10:
    list1.append(i)
    i += 1
print(list1)		# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# for 迴圈實現-----
list1 = []
for i in range(10):
    list1.append(i)
print(list1) 		#同樣的結果

# 列表推導式實現   放在中括號裡表示的是列表推導式  在列表推導式裡面讀與寫都從for迴圈開始
# 第一個i：i是整個列表推導式 列表裡面要返回的資料 第二個i：是range10裡面從0開始的到9為止的數

list1 = [i for i in range(10)]
print(list1)		#同樣的結果

帶if的列表推導式

需求：建立0-10的偶數列表

# 方法1：range()步長實現
list1 = [i for i in range(0, 10, 2)]
print(list1)
# [0, 2, 4, 6, 8]

# 方法2：if實現
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)
# [0, 2, 4, 6, 8]

多個 for迴圈實現列表推導式

需求：建立列表如下：
[(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]

listt = []
for i in range(1, 3):
    for j in range(3):
        # 列表裡面追加元組： 迴圈前準備一個空列表，然後這裡追加元組資料到列表
        listt.append((i,j))
print(listt)



list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)
# 多for 的列表推導式等同於for迴圈巢狀

二、字典推導式

思考：如果有如下兩個列表：
list1 = [‘name’, ‘age’, ‘gender’]
list2 = [‘Tom’, 20, ‘man’]
如何快速合併為一個字典？
字典推導式作用： 快速合併列表為字典或提取字典中目標資料。

# 1.	建立一個字典：字典key是1-5數字，value是這個數字的2次方。
dict1 = {i: i**2 for i in range(1, 5) }
print(dict1)		#{1: 1, 2: 4, 3: 9, 4: 16}
# 2.	將兩個列表 合併成為一個字典
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)		#{'name': 'Tom', 'age': 20, 'gender': 'man'}
# 3. 提取字典中目標資料
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
count1 = {key: value for key, value in counts.items() if value >= 200}
print(counts.items())
print(count1)
# dict_items([('MBP', 268), ('HP', 125), ('DELL', 201), ('Lenovo', 199), ('acer', 99)])
# {'MBP': 268, 'DELL': 201}

總結：

1. 如果兩個列表資料個數相同，len統計任何一個列表的長度都可以
2. 如果兩個列表資料個數不同，len統計數居多的列表資料個數會報錯；len統計資料少的列表資料個數不會報錯

三、集合推導式

需求：建立一個集合，資料為下方列表的2次方。
list = {1, 1, 2}

list1 = {1, 1, 2}
set1 = {i ** 2 for i in list1}
print(set1)				#{1, 4}

注意：集合有資料去重功能。