漫步人生路之Python旅途（五）高山流水

字典dict字典是由大括弧{鍵:值}組成.字典是無序的.字典的鍵是不可變的,不能使用列表作為鍵.但可以使用元祖作為字典的鍵.例如: 新增 setdefault(鍵,值):如果只寫鍵不寫值將列印該鍵所對應的值,如果沒有找到鍵返回Note fromkeys(字典鍵列表,值):如果值是列表,是可變的那麼如 ...

字典dict
字典是由大括弧{鍵:值}組成.字典是無序的.字典的鍵必須是不可變數據類型,不能使用列表作為鍵.但可以使用元祖作為字典的鍵.例如:

dict_ = {"test":"Hello World"}

str_ = "hello"
dict_ = {str_:"霍元甲"}      # 這是正確的

list_ = [1,2,3]
dict_ = {list_:"西游記"}     # 這是錯誤的

tuple_ = (1,2,3)
dic = {tuple_:"紅樓夢"}      # 這是正確的

dict_ = {1:"陳真"}           # 這是正確的

dict_ = {True:"霍東閣"}      # 這是正確的

dict_1 = {"字典":"值"}
dict_ = {dict_1:"三國演義"}   # 這是錯誤的

新增

setdefault(鍵,值):如果只寫鍵不寫值將列印該鍵所對應的值,如果沒有找到鍵返回Note

# dict['鍵'] = '值'
dict_ = {"電視劇":"笑傲江湖"}
dict_["電影"] = "黃飛鴻"

dict_.setdefault("新增","我是新增的")  # setdefault()函數添加鍵值對
print(dic)

# 列印如下內容:
{'電視劇': '笑傲江湖', '電影': '黃飛鴻', '新增': '我是新增的'}

# 如果setdefault(鍵)如果只寫鍵不寫值是查詢鍵的值.
print(dict_.setdefault("新增"))

# 列印如下內容:
我是新增的

fromkeys(字典鍵列表,值):如果值是列表,是可變的那麼如果更改列表中的值會影響整個字典鍵中的值.

dict_ = {}
list_str = ["name","age"]
dict_ = dict_.fromkeys(list_str,[1,2,3])
dict_["name"].append(4)    # 向dict_["name"]中追加元素4                                            
print(dic)

# 列印內容如下:
{'name': [1, 2, 3, 4], 'age': [1, 2, 3, 4]}     # 發現修改name鍵的值後,age鍵的值也發生了改變,和name鍵的值一樣

可以通過重新給鍵賦值的方法,擺攤更改鍵中的值,而影響整個字典中鍵的值.

dic={}
s = ["name","age"]
dic = dic.fromkeys(s,[1,2,3])
dic["name"] = [10,2]
print(dic)

# 列印內容如下:
{'name': [10, 2], 'age': [1, 2, 3]}

刪除

pop(鍵):刪除字典中的鍵值對

dict_ = {"電視劇":"西游記","電影":"少林寺"}
print(dict_.pop("test"))  # pop()如果找不到鍵會報錯

# 列印內容如下:
KeyError: 'test'     # 沒有找到鍵

給pop(鍵,提示信息):添加個參數,用於在沒有找到鍵時提示給用戶

dict_ = {"電視劇":"西游記","電影":"少林寺"}
print(dict_.pop("test","沒有找到該鍵"))  # 可以在pop(鍵,提示信息)

# 列印內容如下:
沒有找到該鍵       # 用於提示用戶這個鍵沒有找到.

pop(鍵,提示語句)是有返回值的,可以返回被刪除的鍵的值.

popitem():沒有參數,返回值是被刪除的鍵值對,Python3.6以上版本刪除最後一項鍵值對,其它版本是隨機刪除一組鍵值對.

dict_ = {"電視劇":"西游記","電影":"少林寺"}
dict_.popitem()
print(dic)

查找

keys():列印字典所有的鍵

dict_ = {"電視劇":"霍元甲","電影":"黃飛鴻"}
print(dict_.keys())

# 列印內容如下:
dict_keys(['電視劇', '電影'])

values():列印字典所有的值

dict_ = {"電視劇":"霍元甲","電影":"黃飛鴻"}
print(dict_.values())

# 列印內容如下:
dict_values(['霍元甲', '黃飛鴻'])

items():列印字典所有的鍵值對
dic = {"電視劇":"霍元甲","電影":"黃飛鴻"}

dict_ = {"電視劇":"霍元甲","電影":"黃飛鴻"}
print(dict_.items())

# 列印內容下:
dict_items([('電視劇', '霍元甲'), ('電影', '黃飛鴻')])

解構(常用操作)

a,b,c = 1,2,3
str_1,str_2 = "a","b"
list_1,list_2 = [1,2,3],["a","b","c"]
dict_1,dict_2 = {"電視劇":"上海灘"},{"電影":"黃飛鴻"}

print("a,b,c:",a,b,c,type(a),type(b),type(c))
print("str1,str2:",str_1,str_2,type(str_1),type(str_2))
print("list_1,list_2:",list_1,list_2,type(list_1),type(list_2))
print("dict_1,dict_2:",dict_1,dict_2,type(dict_1),type(dict_2))

# 列印內容如下:
a,b,c: 1 2 3 <class 'int'> <class 'int'> <class 'int'>
str1,str2: a b <class 'str'> <class 'str'>
list_1,list_2: [1, 2, 3] ['a', 'b', 'c'] <class 'list'> <class 'list'>
dict_1,dict_2: {'電視劇': '上海灘'} {'電影': '黃飛鴻'} <class 'dict'> <class 'dict'>

# 我們發現變數的數據類型和值的類型相同

buf = 1,2,3
buf_1 = "a","b","c"
buf_2 = [1,2,3],["a","b","c"]
buf_3 = {"電視劇":"上海灘"},{"電影":"黃飛鴻"}

print("buf:",buf,type(buf))
print("buf_1:",buf_1,type(buf_1))
print("buf_2:",buf_2,type(buf_2))
print("buf_3:",buf_3,type(buf_3))

# 列印結果如下
buf: (1, 2, 3) <class 'tuple'>
buf_1: ('a', 'b', 'c') <class 'tuple'>
buf_2: ([1, 2, 3], ['a', 'b', 'c']) <class 'tuple'>
buf_3: ({'電視劇': '上海灘'}, {'電影': '黃飛鴻'}) <class 'tuple'>

# 我們發現所有變數的數據類型都是元組tuple

總結:如果=號兩邊變數的數量和值的數量相等,那麼變數的數據類型和值的數據類型相同,如果用一個變數接收用逗號","分隔的多個值時,變數最終的數據類型是tuple元組

通過解構的方式列印字典的鍵和值

dict_ = {"電視劇":"水滸傳","電影":"黃飛鴻"} 
for key_,val_ in dict_.items():   # 通過結構的方式列印鍵和值
print(key_,val_) 

# 列印內容如下:
電視劇 水滸傳 
電影 黃飛鴻

set集合:無序列表,集合的特性是沒有重覆數據.
可以使用大括弧 { } 或者 set() 函數創建集合，註意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典的,還有set集合的值必須是不可變的如:整型,字元串,元祖.不能是列表,字典等可被修改的數據.如下操作:

set_1 = {1,2,3}            # 正確
set_2 = set()              # 定義一個空列表
set_3 = {"a","b","c"}      # 正確
set_4 = {True,False}       # 正確
set_5 = {1,2,"a",(1,2,3)}  # 正確
set_6 = {1,2,"a",[1,2,3]}  # 錯誤的賦值方式,list是可變的
print(set_3)

# 列印內容如下:
TypeError: unhashable type: 'list'

set_7 = {1,2,"a",{"字典":"值"}} # 錯誤的賦值方式,dict是可變的
print(set_7)

# 列印內容如下:
TypeError: unhashable type: 'dict'

set_8 = {1,2,"a",{5,7,9}} # 錯誤的賦值方式,set是可變的
print(set_3)

# 列印內容如下:
TypeError: unhashable type: 'set'

set集合中常用的方法:
新增
add():向集合中添加數據,參數必須是不可改變的.參數類型參考set的賦值.

set_ = {1,2,3}
set_.add(4)
print(set_)

#列印如下內容:
{1, 2, 3, 4}

set_ = {1,2,3}
list_ = ["a","n"]

set_.add(list_)   # 因為列表是可變的,所以不能用作集合的值

# 列印內容如下:
TypeError: unhashable type: 'list'

更新

update(可迭代對象):向集合中添加可迭代數據

set_1 = {1,2,"a"}
set_1.update([10,20,3])
set_1.update(("defghigk"))
set_1.update((10,20,30))
set_1.update({"字典":"鍵"})
print(set_1)

# 列印內容如下
{1, 2, 3, 10, 'g', 'h', 'd', 'a', 'i', 'k', 20, 'f', 'e', '字典', 30}

刪除:

set_3 = {1,2,"a"}
del set_3   # 因為集合是無序的沒有下標,所以用del只能刪除集合

pop():隨機刪除一個元素(測試如果有0,預設先刪除0.其它隨機)

set_3 = {1,2,"a"}
set_3.pop()     # 隨機刪除一個元素
print(set_3)

# 列印內容如下:
{2, 'a'}

remove(元素):根據元素刪除元素,如果刪除一個沒有的元素會報錯

set_3 = {1,2,"a"}
set_3.remove(2)
print(set_3)

# 列印內容如下:
{1, 'a'}

集合的其它操作:
交集:兩個集合裡面都存在的數據,可以使用&或者使用函數intersection來獲取兩個集合的交集.

set_1 = {1,2,3,4}
set_2 = {10,2,40,3}
set_3 = set_1 & set_2  # 通過&符號獲取set_1和set_2的交集
print(set_3)

# 列印內容如下:
{2, 3}

# 通過函數intersection()獲取交集
set_1 = {"a","b","c","d"} 
set_2 = {"z","c","a"} 
set_3 = set_1.intersection(set_2)  # 通過函數獲取set_1和set_2的交集 print(set_3) 

# 列印內容如下: 
{'a', 'c'}

並集:將兩個集合進行合併(集合是去重覆的).使用|符號或者使用union()函數

set_1 = {1,2,3,4}
set_2 = {10,2,40,3}
set_3 = set_1 | set_2 # 使用|符號獲取兩個集合的並集
print(set_3)

# 列印內容如下:
{1, 2, 3, 4, 40, 10}

# 通過函數union()獲取兩個集合的並集
set_1 = {"a","b","c","d"}
set_2 = {"z","c","a"}
set_3 = set_1.union(set_2) # 使用union()函數獲取兩個數的並集
print(set_3)

# 列印內容如下:
{'b', 'z', 'a', 'c', 'd'}

差集:從第一個集合中減去第一個集合和第二個集合共同存在的元素.使用符號-或者使用函數difference()來實現

set_1 = {1,2,3,4}
set_2 = {10,2,40,3}
set_3 = set_1 - set_2 # 通過符號-將set_1和set_2共同存在的元素從set_1中刪除,如果set_2在前就從set_2中刪除
print(set_3)

# 列印內容如下:
{1, 4}

set_1 = {"a","b","c","d"}
set_2 = {"z","c","a"}
set_3 = set_1.difference(set_2) # 通過函數difference()實現
print(set_3)

# 列印內容如下:
{'d', 'b'}

反交集:將兩個集合進行合併,並去除相同的元素,使用符號^或者symmetric_difference

set_1 = {1,2,3,4}
set_2 = {10,2,40,3}
set_3 = set_1 ^ set_2  # 使用^符號實現
print(set_3)

# 列印內容如下:
{1, 4, 40, 10}

set_1 = {"a","b","c","d"}
set_2 = {"z","c","a"}
set_3 = set_1.symmetric_difference(set_2)  # 使用函數實現
print(set_3)

# 列印內容如下:
{'z', 'b', 'd'}

子集:一個集合是否被另一個集合所包含.如果被另一個集合包含返回True,否則返回False.使用<符號或者issubset()

set_1 = {1,2,3,4}
set_2 = {10,2,40,3}
set_3 = set_1 < set_2  # 使用<符號實現
print(set_3)
# 列印內容如下:
False

set_1 = {"a","b","c","d"}
set_2 = {"z","c","a","b","d","e"}
set_3 = set_1.issubset(set_2)    # 使用函數實現
print(set_3)

# 列印內容如下:
True

超級:與子集相反,判斷一個集合是否包含另一個集合,如果包含另一個集合返回True否則返回False.使用符號>或者issuperset()

set_1 = {1,2,3,4,10,50,40}
set_2 = {10,2,40,3}
set_3 = set_1 > set_2   # 使用>符號
print(set_3)

# 列印內容如下:
True

set_1 = {"a","b","c","d"}
set_2 = {"z","c","a","b","d","e"}
set_3 = set_1.issuperset(set_2)   # 使用函數實現
print(set_3)

# 列印內容如下:
False

frozenset(可迭代對象):返回一個凍結的集合.被凍結的集合不能進行修改,刪除,添加等操作.如果不寫參數,則返回一個凍結的空的集合.參數是可迭代對象所以可以是列表,字典等
下麵是一些簡單的事例:

set_1 = {"a","b","c","d"}
dic_1 = {"字典":"值"}
list_1 = [1,2,3]

set_2 = frozenset(set_1)
dic_2 = frozenset(dic_1)
list_2 = frozenset(list_1)

print(type(set_2),set_2)
print(type(dic_2),dic_2)   # 字典只能看鍵不能看值,很多方法都不能用
print(type(list_2),list_2) # 列表的下標也不能使用,大多數函數不能用

# 列印內容如下:
<class 'frozenset'> frozenset({'b', 'd', 'a', 'c'})
<class 'frozenset'> frozenset({'字典'})
<class 'frozenset'> frozenset({1, 2, 3})