元組

1.什么是元組(tuple)

python提供的容器型數(shù)據(jù)類型，不可變并且有序。（元組就是不可變的列表）
不可變 - 不支持增刪改，只支持查
有序 - 每個元素對應(yīng)一個確定的下標(biāo)

2.字面量和元素

（元素1，元素2，元素3···）
其中的元素可以是任何類型的數(shù)據(jù)，并且類型可以不一樣，同樣的元素可以有多個

注意：如果小括號里只有一個元素，那么就是這個元素本身。只有在元素后添加一個逗號，才代表這是一個元組。

空的元組：tuple1 = ()

只有一個元素的元組：tuple2 = (1,)

直接將多個元素用逗號隔開，不加小括號，表示的也是一個元組：tuple3 = 1, 2, 3

3.元組獲取元素和列表是一樣的

獲取單個元素：tuple[index]

獲取部分，切片，生成的是新的元組：tuple[index:index:step]

遍歷

補(bǔ)充：

特殊的獲取方式：
1.變量1，變量2··· = 元組 --- 用左邊的變量依次獲取元組中元素的值。（要求左邊的變量個數(shù)要和元組中元素的個數(shù)相同）
2.變量1，*變量2 = 元組 --- 通過帶*號的變量獲取元組中剩余的部分；
注意：這個結(jié)構(gòu)中帶*號的變量只能有一個，不帶*號的變量可以有多個
3.*號取出來的是一個列表

name, *scores = ('小明', 100, 89, 67, 99)
print(name,scores)

name, num, *scores = ('小明', 100, 89, 67, 99)
print(name, num, scores)

*info, num1, num2 = (('小明', 100, 89, 67, 99))
print(info, num1, num2)

info1, *nums, num1 = ('小明', 100, 89, 67, 99)
print(info1, nums, num1)

補(bǔ)充：

1.獲取元組和列表中的數(shù)據(jù)

nums = (1, 2, 3)
nums2 = [11, 22, 33]
print('===：',*nums, *nums2)
print(1, 2, 3)
print(nums,nums2)

input:
===： 1 2 3 11 22 33 # 取出來的是int
1 2 3
(1, 2, 3) [11, 22, 33]

4.相關(guān)運(yùn)算（和列表一樣）

+, *
in / not in
len(), max(), min(), sum(), tuple() 元素內(nèi)容類型必須要一樣

5.排序

sorted(序列) - 對序列中的元素排序，產(chǎn)生一個新的列表(不管是什么序列，排完后最后都是列表)
原序列不變
注意：列表.sort() -- 修改原列表中元素的順序; sorted(列表) -- 產(chǎn)生一個新的列表

6.join的使用

字符串.join(序列) - 將序列中的元素取出，用指定的字符串連2在一起
要求序列中的元素必須是字符串。

字典

1.什么是字典（dict）

python提供的容器類型數(shù)據(jù)，可變且無序
可變 - 支持元素的增刪改
無序 - 不支持下標(biāo)操作

2.字面量和元素

大括號括起來，里面多個鍵值對，每個鍵值對用逗號隔開。鍵值對就是字典的元素。
{key1:value1, key2:value2, key3:value3...}
鍵值對 - 鍵/key:值/value(鍵值對)；鍵值對必須成對出現(xiàn)，而且脫離字典單獨(dú)出現(xiàn)沒有意義
鍵/key - 必須是不可變的，而且是唯一的。實際一般將字符串作為鍵
值/value - 可以是任意類型的數(shù)據(jù)

注意：字典存儲數(shù)據(jù)，實質(zhì)是通過值來存儲的。key是值對應(yīng)的標(biāo)簽和獲取值的方式

空字典：dict1 = {}
dict1 = {'a':100, 10:200, (1,2):'abc','a':111}
'a':100 會被 'a':111 覆蓋

3.什么時候使用字典

什么時候使用字典：多個不同意義的數(shù)據(jù)（需要區(qū)分），就使用字典。例如：保存一個人的信息，一輛車的不同信息
什么時候使用列表：存儲多個相同意義的數(shù)據(jù)（不需要區(qū)分），就是用列表。例如：保存一個班的學(xué)生信息，保存所有的價格

4.字典元素的增刪改查

1.查（獲取值value）
注意：字典中的鍵值對單獨(dú)取出來沒有任何意義

a.
字典[key] - 獲取字典中key對應(yīng)值
注意：當(dāng)key不存在的時候，會報KeyError

b.
字典.get(key)- 獲取字典中key對應(yīng)值;當(dāng)key不存在的時候不會報錯，并且取到一個默認(rèn)值None
字典.get(key,值1) - 獲取字典中key對應(yīng)值;當(dāng)key不存在的時候不會報錯，并且取到指定的值1

c.
遍歷字典
注意：直接通過for-in遍歷字典取到的是key
遍歷字典的values(), 獲取所有的值（不建議使用，當(dāng)處理的數(shù)據(jù)多時，內(nèi)存消耗大）
遍歷字典的items(), 直接獲取key和value（不建議使用，當(dāng)處理的數(shù)據(jù)多時，內(nèi)存消耗大）

dict1 = {'a':100, 'b':200, 'c':300}
# 遍歷字典取到的是key（推薦使用）
for key in dict1:
    # key
    print(key,end=' ')
    # value
    print(dict1[key])

# 遍歷字典的values(), 獲取所有的值（不建議使用，當(dāng)處理的數(shù)據(jù)多時，內(nèi)存消耗大）
for value in dict1.values():
    print(value)

# 遍歷字典的items(), 直接獲取key和value（不建議使用，當(dāng)處理的數(shù)據(jù)多時，內(nèi)存消耗大）
for k,value in dict1.items():
    print(k,value)

2.增、改
字典[key] = 值 - 當(dāng)key不存在時，就是添加鍵值對；當(dāng)key存在時，就是修改key對應(yīng)的值

3.刪（刪除鍵值對）
a.
del 字典[key] - 刪除字典中指定的key對應(yīng)的鍵值對
b.
字典.pop(key) - 取出字典中指定的key對應(yīng)的鍵值對

5.字典的適用方法

1.比較運(yùn)算
==,!=
注意：
判斷兩個字典是否相等，只看鍵值對數(shù)量，長相是否一樣，不管鍵值對的順序
字典不支持比較大小

2. in / not in
   key in 字典
key not in 字典

3.len(),max(),min()
dict(數(shù)據(jù)) - 數(shù)據(jù)要求是序列，并且序列中的元素都是只有兩個元素的子序列，一般這個序列是字典。

print(dict([(1,2), ('a', 'b'),[10, 'abc']]))

input:{1: 2, 'a': 'b', 10: 'abc'}

補(bǔ)充：關(guān)于字典轉(zhuǎn)列表/元組/集合

dict2 = {'name':'xiaohua', 'color':'black', 'height':170}
print(list(dict2)) 

input:['name', 'color', 'height']

字典轉(zhuǎn)列表/元組/集合都是將字典中的key取出來作為列表/元組/集合的元素

4.相關(guān)方法
1.字典.clear() - 清空字典
注意：清空容器推薦使用clear操作，而不是重新賦一個空的容器。這樣節(jié)省電腦資源
只有容器本身不存在的時候，才使用賦一個空容器
2.字典.copy() - 復(fù)制字典中的元素，產(chǎn)生一個新的字典
原理和列表切片一樣，如果直接賦值，修改其中一個字典的元素，會影響另外一個字典中的元素。因為地址相同
補(bǔ)充：拷貝賦值，會產(chǎn)生新的地址，賦值后互不影響

3. dict.fromkeys(序列, 值) -- 以序列中所有的元素作為key，指定的值作為value創(chuàng)建一個新的字典

new_dict = dict.fromkeys('abc', (10, 20, 30))
print(new_dict)

new_dict = dict.fromkeys(['name', 'age', 'tel'], 0)
print(new_dict)

input:{'a': (10, 20, 30), 'b': (10, 20, 30), 'c': (10, 20, 30)}
{'name': 0, 'age': 0, 'tel': 0}

4
字典.keys() - 將字典所有的key取出產(chǎn)生一個新的序列
字典.values() - 將字典所有的value取出產(chǎn)生一個新的序列
字典.items() - 將字典所有的key和value做為一個元祖取出產(chǎn)生一個新的序列
沒啥用

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
print(dict2.keys(), dict2.values(), dict2.items())

input:
dict_keys(['name', 'color', 'height']) 
dict_values(['xiaohua', 'black', 170])
dict_items([('name', 'xiaohua'), ('color', 'black'), ('height', 170)])

5.字典.setdefault(key, value=None)
字典.setdefault(key) - 當(dāng)key不存在的時候，添加鍵值對key:None
字典.setdefault(key, value) - 當(dāng)key不存在的時候，添加鍵值對key:value
注意：這個操作當(dāng)key存在的時候，不會修改

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}

dict2.setdefault('name2', '小胡')
dict2.setdefault('sex')
print(dict2)

input:{'name': 'xiaohua', 'color': 'black', 'height': 170, 'name2': '小胡', 'sex': None}

6.字典1.update(字典2/只有2個元素的序列)
使用字典2中的鍵值對去更新字典1;如果字典2中的key，字典1中本身存在就是修改,不存在就添加

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
dict2.update({'height': 180, 'age': 18})
print(dict2)

dict2.update([('a', 100), ('age', 30)])
print(dict2)

input:{'name': 'xiaohua', 'color': 'black', 'height': 180, 'age': 18}
{'name': 'xiaohua', 'color': 'black', 'height': 180, 'age': 30, 'a': 100}

集合

1.什么是集合（set）

可變的，無序的；元素是唯一并且不可變

2.字面量

{元素1，元素2，元素3···}

補(bǔ)充：
1.空集合：set1 = set()
2.集合自帶去重功能

3.增刪改查

1.查
集合不能單獨(dú)地獲取單個元素，只能一個一個的遍歷，因為無序。
2.增
a.集合.add(元素)- 在集合里添加指定的元素
b.集合.update(序列) - 將序列中的元素添加到集合中
# 如果集合內(nèi)的數(shù)字為連續(xù)數(shù)字，那么集合會自動排序這幾個數(shù)字，且添加時數(shù)字之間不會插入添加的元素

set1 = {6,7,4,5,8}
set1.add('abc')
print(set1)

set1.update('abc')
print(set1)

set1.update({'aa':10, 'bb':20})  # 如果序列是字典，只把key添加進(jìn)去
print(set1)

3,刪
集合.remove(元素) --- 刪除集合中指定的元素

4.數(shù)學(xué)集合運(yùn)算

交集（&）：獲取兩個集合公共的元素，產(chǎn)生一個新的集合
并集（|）：將兩個集合中的元素合并在一起，產(chǎn)生一個新的集合
差集（-）：集合1 - 集合2 ：求集合1中去掉集合2中元素還剩下的元素
補(bǔ)集（^）：將兩個集合合并在一起，去掉公共的部分，剩下的部分產(chǎn)生新的集合，并集-交集
子集的判斷：
集合1>集合2 --- 判斷集合1中是否包含集合2,集合2元素全部在集合1中才是包含
集合1<集合2 --- 判斷集合2中是否包含集合1.