字典,集合

時間 2019-11-13

原文原文鏈接

昨日回顧

     1. list列表
        寫法:[元素, 元素]
        對元素的數據類型沒有要求
        也有索引和切片
        索引從0開始
        切片
        lst[start: end: step]
            從start到end. 每隔step取一個

        增刪改查
            1. 增長:
                1. append() 追加. 在列表的末尾添加
                2. insert(index, 元素) 在index位置插入元素

            2. 刪除:
                1. pop(i) 默認從末尾刪除, 還能夠指定位置刪除  ##返回刪除的元素
                2. remove(元素) 刪除指定元素
            3. 修改:
                經過索引去修改元素
                lst[3] = "胡辣湯"
            4. 查詢:
                for item in lst: # 拿不到索引
                    print(item)

                for i in range(len(lst)):##能拿到索引,當須要輸出索引或者須要對原來的列表進行修改的時候(對原列表的修改必定要使用索引)
                    print(i,lst[i])

        range(m) 從0到m
        range(m, n) 從m到n
        range(m, n, p) 從m到n. 每P個取一個

        for i in range(len(lst)):
            i  索引
            lst[i] 元素

        元組: 不可變的. 只讀列表. 有索引. 有下標, 有切片.
            不可變: 內部指向

        可變的: list
        不可變的:str, int, bool, tuple

今日內容

    1. 什麼是字典
        字典是以key:value的形式來保存數據
        用{}表示. 存儲的是key:value
    2. 字典的增刪改查(重點)
        1. 添加
            dic[新key] = 值

            setdefault(key,value) key不存在,添加鍵值對
        2. 刪除
            pop(key) 刪除指定鍵的鍵值對, #返回刪除的鍵對應的值
            ## dic.popitem() # 隨機刪除一項(如今的版本通常是彈出最後一項)
            ##del dic["李安"]
            ##dic.clear() # 清空
        3. 修改
            dic[老key] = (新)值
            update() 更新字典(迭代更新,相似於列表的 extend)
        4. 查詢
            dic[key]  ##直接使用key就能夠拿到value
            get(key, 值) ##當key不存在. 返回第二個參數. 默認第二個參數是None
            setdefault(key, value)  key存在,返回對應的 value,key 不存在,先新增,再返回對應的 value
        5. 遍歷,字典是一個可迭代對象

    3. 字典的相關操做
        1. keys() 獲取到全部的鍵
        2. values() 獲取到全部的值
        3. items() 拿到全部的鍵值對
    4. 字典的嵌套
        字典的嵌套. 字典套字典

    5. 集合(不重要). 去重複(##可是無序)
        集合中的元素是不重複的,必須是可哈希的(不可變), 至關於字典中的key(集合自己是可變的,可是它要求它內部的值是不可變的)
        空集合:set()
        空元組:tuple()
        空列表:list()
        非空集合: {123}集合, 集合其實就是不存value的字典(字典也是可變的,可是它要求他內部的 key 是不可變的)

    預習:
        深淺拷貝
        小數據池

        文件操做(帶來的做業)

        函數


    # 關於set集合做業: 寫一個彩票開獎(36選7)
    from random import randint
    randint(1,36)

字典

1. 字典的簡單介紹

lst = ["周杰倫", "林俊杰", "蔡依林"]
lst[0] = "麻花藤"
# 相比列表,字典查找的效率比較高
# 坑: 字典存儲數據的時候是用的hash值來存儲. 哈希是一個算法,不能變的(python內置的)
# 數據必須是不可變的(可哈希). 字典的key必須是可哈希的(不可變).
dic = {"jay":"周杰倫", "jj": "林俊杰", "jolin":"蔡依林"}
print(dic['jay']) # 周杰倫
dic['jay'] = "麻花藤"

print(type(dic)) # <class 'dict'>

# 列表是可變的. 不可哈希
# 元組是不可變的. 可哈希的
print(hash((1,2,3)))
print(hash([1,2,3])) # TypeError: unhashable type: 'list'
dic = {"jay":"周杰倫", "王力宏":["龍的傳人", "惟一", "改變本身"], ["戰狼", "戰狼2"]: "武警"}
print(dic)

View Code

字典(dict)是python中惟一的一個映射類型.他是以{ }括起來的鍵值對組成. 在dict中key是惟一的. 在保存的時候, 根據key來計算出一個內存地址. 而後將key-value保存在這個地址中. 這種算法被稱爲hash算法, 因此, 切記, 在dict中存儲的key-value中的key'必須是可hash的,html

若是你搞不懂什麼是可哈希, 暫時能夠這樣記, 能夠改變的都是不可哈希的, 那麼可哈希就意味着不可變. 這個是爲了能準確的計算內存地址而規定的.python

已知的可哈希(不可變)的數據類型: int, str, tuple, bool算法

不可哈希(可變)的數據類型: list, dict, setapp

#語法 :
{key1: value1, key2: value2....}

注意: key必須是不可變(可哈希)的. value沒有要求.能夠保存任意類型的數據

# 合法
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帥 哥', '美女'], (1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['stu'])
print(dic[(1, 2, 3)])

# 不合法
dic = {[1, 2, 3]: '周杰倫'}  # list是可變的. 不能做爲key
dic = {{1: 2}: "哈哈哈"}  # dict是可變的. 不能做爲key
dic = {{1, 2, 3}: '呵呵呵'}  # set是可變的, 不能做爲key

dict保存的數據不是按照咱們添加進去的順序保存的. 是按照hash表的順序保存的. 而hash表不是連續的. 因此不能進⾏切片工做. 它只能經過key來獲取dict中的數據dom

2. 字典增刪改查和其餘操做

dic = {"意大利": "李雲龍", "美國": "美國往事"}


# 增
dic["日本"] = "東京審判"  # 新key表示添加
dic['韓國'] = "釜山行"

# setdefault (難點)
# 有添加的功能,若是key是存在的. 不添加
# 流程: 判斷你給的key是否在字典中存在了.若是已經存在了. 就再也不新增. 若是不存在. 執行新增操做
dic.setdefault("美國", "三傻大鬧寶萊塢")
print(dic)


# 刪
dic = {"張藝謀":"紅高粱", "李安":"斷臂山", "陳凱歌":"霸王別姬", "郭德綱":"祖宗十九代"}
dic.pop("郭德綱") # 你要記住的
print('>>>>>',dic.pop("郭德綱"))  # >>>>> 祖宗十九代
# dic.popitem() # 隨機刪除一項. 在python早期版本  字典是無序的.##如今是有序的(輸出在屏幕上的顯示是有序的,底層仍是無序的),因此通常刪除的是最後一項
del dic["李安"]
dic.clear() # 清空
print(dic)


# 改
dic = {"河南":"胡辣湯", "開封": "灌湯包", "武漢":"熱乾麪"}
# dic['河南'] = "燴麪" # 老key = 新值
print(dic)

dic1 = {"趙四":"劉曉光", "劉能":"王曉利", "王木生":"範偉"}
dic2 = {"趙四":"寶寶", "劉能":"萌萌", "皮校長":"皮長山"}
# 迭代更新
dic1.update(dic2) # 把dic2懟到dic1裏面. 把dict2中的內容更新到dic1
print(dic1)
print(dic2)


# 查
dic1 = {"趙四":"劉曉光", "劉能":"王曉利", "王木生":"範偉"}

# 1. 直接使用key就能夠拿到value
print(dic1["趙四四"]) # KeyError: '趙四四' key不存在


# 2. get(key)
print(dic1.get("劉能能"))  # None 當key不存在返回None
print(dic1.get("劉能能", "沒有這我的")) # 當key不存在. 返回第二個參數. 默認第二個參數是None

# 3. setdefault() 第一個功能是添加(當key不存在). 第二個功能是查詢(根據你給的key查詢)
# 整個執行流程: 判斷給的key是否存在. 若是存在. 就不執行新增流程.直接查詢出這個key對應的value
# 若是key不存在. 先執行新增操做. 再使用key把對應的value查詢出來
##這裏是與 get(key,value)的區別,當 key不存在的時候,get不執行新增操做,直接返回你給定的 value 值,而 setdefault 先執行新增,再執行查詢操做
ret = dic1.setdefault("皮長山", "皮校長")
print(ret) # 皮校長

ret = dic1.setdefault("王木生", "寶寶")
print(ret) # 範偉

View Code

1. 增長

dic = {}
dic['name'] = '周潤發' # 若是dict中沒有出現這個key, 就會新增一個key-value的組合進dict
dic['age'] = 18
print(dic)

# 若是dict中沒有出現過這個key-value. 能夠經過setdefault設置默認值 
dic.setdefault('李嘉誠') # 也能夠往⾥面設置值.
dic.setdefault("李李嘉誠", "房地產") # 若是dict中已經存在了. 那麼setdefault將不會起做⽤
print(dic)

2. 刪除

ret = dic.pop("jay")
print(ret)

del dic["jay"]
print(dic)

# 隨機刪除.  Python老版本是隨機刪除,如今就是刪除最後一項
ret = dic.popitem()

# 清空字典中的全部內容 
dic.clear()

3. 修改

dic = {"id": 123, "name": 'sylar', "age": 18}
dic1 = {"id": 456, "name": "麻花藤", "ok": "wtf"}
dic.update(dic1) # 把dic1中的內容更新到dic中. 若是key重名. 則修改替換. 若是不存在key, 則新增.
print(dic)
print(dic1)

4. 查詢

查詢通常是用key來查找具體的數據.ide

 print(dic['name'])
# print(dic['sylar']) # 報錯 

print(dic.get("ok"))
print(dic.get("sylar")) # None 
print(dic.get("sylar", "牛B")) # 牛B
# 注意:get(key,value=None):key 不存在返回第二個參數,上面返回的None是默認的

5. 其餘相關操做-字典的遍歷

dic = {"趙四":"劉曉光", "劉能":"王曉利", "王木生":"範偉"}
# 直接for循環
for key in dic: # 直接循環字典拿到的是key, 有key直接拿value
    print(key)
    print(dic[key])

dic = {"趙四":"劉曉光", "劉能":"王曉利", "王木生":"範偉"}

# 不經常使用的
print(dic.keys()) # dict_keys(['趙四', '劉能', '王木生']) 像列表. 山寨列表
for k in dic.keys(): # 拿到的是字典中的每個key
    print(k)

# 當須要單獨獲取到全部value的時候
print(dic.values()) # dict_values(['劉曉光', '王曉利', '範偉'])  全部的value的一個數據集
for v in dic.values():
    print(v)

print(dic.items()) # 全部的鍵值對 dict_items([('趙四', '劉曉光'), ('劉能', '王曉利'), ('王木生', '範偉')])
# 遍歷字典最簡單的方案
for item in dic.items(): # 遍歷字典最簡單的方案##這裏涉及到一個自動解構的過程
    print(item) # ('趙四', '劉曉光')  
    k, v = item  # 解構,##item 是一箇中間變量,能夠直接省略掉
    k = item[0]  
    v = item[1]
    
for k, v in dic.items(): # 遍歷字典最簡單的方案##這裏涉及到一個自動解構的過程
    # k, v = item # 解構,##item 是一箇中間變量,能夠直接省略掉
    print(k, v)


a, b = 1, 2  # 把後面的兩個值分別賦值給前面兩個變量. 解構, 解包
print(a)
print(b)


''' 老師課上講解的總結:
------------------------------------------------------------------------
# a,b = 1,2 #解構必須先後數量相等,不等會報錯
# a,b = (1,2)
# (a,b) = (1,2)#上面的三種寫法是等價的,#元組的括號能夠不加,只要有逗號就是元組類型的
# print(a)
# print(b)

#元組的括號能夠不加,只要有逗號就是元組類型的
# a = 1
# print(type(a)) #<class 'int'>
# a = 1,
# print(type(a)) #<class 'tuple'>
# a = (1,)
# print(type(a))#<class 'tuple'>
-------------------------------------------------------------------------
'''
c = 1,2,3
print(c) # (1, 2, 3) # 元組和列表是能夠解包的

d, e, f = [1,2,3]
print(d)
print(e)
print(f)


# 遍歷字典兩套方案(最經常使用的,須要記憶的)
dic = {"趙四":"劉曉光", "劉能":"王曉利", "王木生":"範偉"}
# 1. 使用for循環直接遍歷字典的key
for key in dic:
    print(key)
    print(dic[key])

# 2. 可使用字典的items()+解構能夠直接獲取到key和value
for k, v in dic.items():
    print(k)
    print(v)

View Code

dic = {"id": 123, "name": 'sylar', "age": 18, "ok": "科⽐"}

print(dic.keys()) # dict_keys(['id', 'name', 'age', 'ok']) 不用管它是什麼.當 成list來用就行
for key in dic.keys():
    print(key)

print(dic.values()) # dict_values([123, 'sylar', 18, '科⽐']) 同樣. 也當list來⽤
for value in dic.values():
    print(value)

print(dic.items()) # dict_items([('id', 123), ('name', 'sylar'), ('age', 18), ('ok', '科⽐比')]) 這個東西也是list. 只不過list中裝的是tuple
for key, value in dic.items(): # ?? 這個是解構
    print(key, value)

# 解構
a, b = 1, 2 
print(a, b)

(c, d) = 3, 4
print(c, d)

e, f = [1, 2, 3]  # 解構的時候注意數量必須匹配,不然報錯
print(e, f)

3. 字典的嵌套

wf = {
    "name":"汪峯",
    "age":52,
    "hobby":["唱歌", "上頭條", "穿皮褲"],
    "wife": {
        "name": "章子怡",
        "age": 49,
        "hobby":["演戲", "上電視", "當導師"],
        "tishen": {
            "name":"萌萌",
            "age":28
        },
        "zhuli":{
           "name":"磊磊",
           "age": 20
        }
    },
    "zhuli":{
        "name":"寶寶",
        "age":23,
        "hobby":["抽菸","喝酒","燙頭"]
    },
    "children":[{"name":"汪老大"}, {"name":"汪老二"}]
}
wf['children'][1]["age"] = 2
print(wf)
# print(wf['zhuli']['name'])

# 汪峯老婆替身的名字
print(wf['wife']['tishen']['name'])
# 汪峯老婆的第二個愛好
print(wf['wife']['hobby'][1])
# 汪峯助理的第三個愛好
print(wf['zhuli']['hobby'][2])


# 汪峯的助理+10歲
wf['zhuli']['age'] = wf['zhuli']['age'] + 10
# 汪峯的老婆添加一個愛好("導戲")
wf['wife']['hobby'].append("導戲") # 添加完畢了
# 刪除汪峯助理的"抽菸"愛好
wf["zhuli"]["hobby"].remove("抽菸")
print(wf)

View Code

# 字典的嵌套 
dic1 = {
    "name": "汪峯", 
    "age": 18, 
    "wife": {
        "name": '章子怡',
        "age": 28 
    },
    "children": ['第一個毛孩子', '第二個毛孩子'],
    "desc": '峯哥不會告我吧. 不要緊. 我想上頭條的' 
}

print(dic1.get("wife").get("name"))
print(dic1.get("children"))
print(dic1.get("children")[1])

set集合

s = {"周潤發", "大潤發", "王潤髮", "周潤發"} # 不重複的
print(s)

# 惟一能用到的點. 去重複(使用強制類型轉化的辦法:列表-->集合(去除重複的元素)-->列表)
lst = ["麻將", "牌九", "骰子", "撲克", "老虎雞", "骰子", "撲克", "老虎雞", "撲克", "老虎雞", "撲克", "老虎雞"]

# 把列表轉化成集合  x 轉化成y類型 y()
s = set(lst)
# print(s)
# 把集合變回列表
lst = list(s)
print(lst) # 順序是亂的(惟一的缺點,可是功(去重複)大於過.排序和去重複都是至關麻煩的一件事)

#增
s = {"劉嘉玲", "趙本山", "萊昂納多迪卡普里奧", "羅納爾多"}
s.add("劉嘉玲") # 記憶(若是實在是想要記憶的話)
print(s)

s.update({"劉嘉玲", "劉能", "趙四"}) # 迭代更新
print(s)


#刪
ret = s.pop() # 隨機刪除(彈出)一個,相似於字典的popitem()
print(s)
print(ret)

s.remove("羅納爾多")
print(s)

# 注意:集合還有字典. 是沒有索引和切片的

#改
#set集合中的數據沒有索引,也沒有辦法去定位一個元素,因此沒有辦法進行直接修改.咱們能夠採用先刪除後添加的方式來完成修改的操做
s = {"劉嘉玲", "趙本山", "萊昂納多迪卡普里奧", "羅納爾多"}
# 把羅納爾多修改爲梅西
s.remove("羅納爾多")#先刪除
s.add("梅西")#後修改
print(s)


#查詢
# 迭代
for el in s:
    print(el)

#下面是一些不常使用的操做
s1 = {"門神", "燈神", "燈神你在笑什麼?"}
s2 = {"門神", "燈神", "你倆在幹什麼?"}

# 交集
print(s1 & s2)
print(s1.intersection(s2))

# 並集
print(s1 | s2)
print(s1.union(s2))

# 差集
print(s1 - s2) # s1中特有的內容
print(s1.difference(s2))

# 反交集
s1={1,2,3,44}
s2={1,2,3,55}
print(s1 ^ s2) # 兩個集合中特有的內容  {55, 44}
print(s1.symmetric_difference(s2))

# 集合自己是可變的數據類型 . 不可哈希
# 集合套集合->不能互相嵌套的
# 集合中的元素必須可哈希(不可變的)
s = {{1,2,3}}  # TypeError: unhashable type: 'set'
print(s)
# # 若是非要集合套集合 下面是不可變集合
s = frozenset({"哈哈","呵呵"}) # 不可變的數據類型(集合)
for el in s:
    print(el)
s = {s}
print(frozenset({"哈哈","呵呵"}))

View Code

set集合是python的一個基本數據類型. 通常不是很經常使用. set中的元素是不重複的.無序的.⾥面的元素必須是可hash的(int, str, tuple,bool), 咱們能夠這樣來記. set就是dict類型的數據可是不保存value, 只保存key. set也用{}表示函數

注意:set集合中的元素必須是可hash的(不可變),可是set自己是不可hash的(可變的).spa

set1 = {'1', 'alex',2,True,[1,2,3]} #報錯
set2 = {'1', 'alex' ,2,True,{1:2}} # 報錯
set3 = {'1', 'alex' ,2,True,(1,2,[2,3,4])}#報錯

set中的元素是不重複的,且無序的.

s = {"周杰倫"， "周杰倫"，」周星星"}
print(s)
結果:
{'周星星'，' 周杰倫'}

使用這個特性，咱們可使用set來去掉重複

#給list去重複
lst = [45，5，"哈哈"，45，"哈哈"，50]
lst = list(set(lst))#把list轉換成set, 而後再轉換回list
print(lst)

set集合增刪改查

1.增長

s = {"劉嘉玲"，'關之琳'，"王祖賢"}
s. add( "鄭裕玲")
print(s)
s. add("鄭裕玲")#重複的內容不會被添加到set集合中
print(s)

s = {"劉嘉玲"，'關之琳'，"王祖賢"}
s. update("麻花藤")#迭代更新
print(s)
s. update(["張曼玉」，" 李若彤" ,"李若彤"])
print(s)

2. 刪除

s = {"劉嘉玲", '關之琳', "王祖賢","張曼玉", "李若彤"} 
item = s.pop() # 隨機彈出一個.
print(s)
print(item)

s.remove("關之琳") # 直接刪除元素
# s.remove("⻢虎疼") # 不存在這個元素. 刪除會報錯 
print(s)

s.clear() # 清空set集合.須要注意的是set集合若是是空的. 打印出來是set() 由於要和 dict區分的.
print(s) # set()

3. 修改

 # set集合中的數據沒有索引. 也沒有辦法去定位⼀一個元素. 因此沒有辦法進⾏直接修改. 
# 咱們能夠採⽤先刪除後添加的方式來完成修改操做
s = {"劉嘉玲", '關之琳', "王祖賢","張曼玉", "李若彤"}
# 把劉嘉玲改爲趙本⼭
s.remove("劉嘉玲") 
s.add("趙本⼭山") 
print(s)

4. 查詢

# set是一個可迭代對象. 因此能夠進⾏for循環 
for el in s:
    print(el)

5. 經常使用操做

s1 = {"劉能", "趙四", "⽪長山"}
s2 = {"劉科⻓", "馮鄉長", "⽪長山"}

# 交集
# 兩個集合中的共有元素
print(s1 & s2) # {'⽪長山'} print(s1.intersection(s2)) # {'⽪長山'}

# 並集
print(s1 | s2) # {'劉科長', '馮鄉長', '趙四', '⽪長山', '劉能'} 
print(s1.union(s2)) # {'劉科長', '馮鄉長', '趙四', '⽪長山', '劉能'}

# 差集
print(s1 - s2) # {'趙四', '劉能'} 獲得第一個中單獨存在的 
print(s1.difference(s2)) # {'趙四', '劉能'}

# 反交集
print(s1 ^ s2) # 兩個集合中單獨存在的數據 {'馮鄉長', '劉能', '劉科長', '趙四'} print(s1.symmetric_difference(s2)) # {'馮鄉長', '劉能', '劉科長', '趙四'}



s1 = {"劉能", "趙四"}
s2 = {"劉能", "趙四", "⽪長山"}

# 子集
print(s1 < s2) # set1是set2的子集嗎? True print(s1.issubset(s2))

# 超集
print(s1 > s2) # set1是set2的超集嗎? False print(s1.issuperset(s2))

set集合自己是能夠發生改變的. 是不可hash的. 咱們可使用frozenset來保存數據. frozenset是不可變的. 也就是一個可哈希的數據類型3d

s = frozenset(["趙本山", "劉能", "⽪長山", "長跪"])
dic = {s:'123'} # 能夠正常使用了 
print(dic)

這個不是很經常使用. 了解一下就能夠了code

今日做業

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。