黄色网页视频 I 影音先锋日日狠狠久久 I 秋霞午夜毛片 I 秋霞一二三区 I 国产成人片无码视频 I 国产 精品 自在自线 I av免费观看网站 I 日本精品久久久久中文字幕5 I 91看视频 I 看全色黄大色黄女片18 I 精品不卡一区 I 亚洲最新精品 I 欧美 激情 在线 I 人妻少妇精品久久 I 国产99视频精品免费专区 I 欧美影院 I 欧美精品在欧美一区二区少妇 I av大片网站 I 国产精品黄色片 I 888久久 I 狠狠干最新 I 看看黄色一级片 I 黄色精品久久 I 三级av在线 I 69色综合 I 国产日韩欧美91 I 亚洲精品偷拍 I 激情小说亚洲图片 I 久久国产视频精品 I 国产综合精品一区二区三区 I 色婷婷国产 I 最新成人av在线 I 国产私拍精品 I 日韩成人影音 I 日日夜夜天天综合

python基礎(chǔ)5-字典

系統(tǒng) 2291 0

python基礎(chǔ)5-字典

python基礎(chǔ)5-字典_第1張圖片

數(shù)據(jù)類型

字典

字典定義、創(chuàng)建

字典是一種可變?nèi)萜黝愋停铱梢源鎯?chǔ)任意類型對(duì)象。字典和列表的最大的區(qū)別是字典強(qiáng)調(diào)的是“鍵值對(duì)”,key與value一一對(duì)應(yīng),字典中的存放順序并不重要,重要的是“鍵”和“值”的對(duì)應(yīng)關(guān)系。在字典中,要求key是唯一的,且不可變的。所以字典的特點(diǎn)如下:

  • 查找速度快
  • key-value序?qū)](méi)有順序
  • key鍵不可變且唯一

字典的創(chuàng)建,使用 {} ,每個(gè)鍵值對(duì)用 : 隔開(kāi),每對(duì)之間用 , 分割。還有使用dict和使用fromkeys的方法

            
              
                >>
              
              
                >
              
               d1 
              
                =
              
              
                {
              
              
                'key'
              
              
                :
              
              
                'value'
              
              
                }
              
              
                # 使用dict()初始化字典,其中鍵必須是字符串
              
              
                >>
              
              
                >
              
               d2 
              
                =
              
              
                dict
              
              
                (
              
              key
              
                =
              
              
                'value'
              
              
                )
              
              
                # 使用dict創(chuàng)建時(shí),下面的情況會(huì)出現(xiàn)bug
              
              
                >>
              
              
                >
              
               key 
              
                =
              
              
                'name'
              
              
                >>
              
              
                >
              
               d3 
              
                =
              
              
                dict
              
              
                (
              
              key
              
                =
              
              
                'value'
              
              
                )
              
              
                # 這個(gè)代碼,原本我們是想輸出{'name':'value'},可以結(jié)果并不一樣,所以使用dict初始化的時(shí)候需要注意
              
              
                >>
              
              
                >
              
              
                print
              
              
                (
              
              d3
              
                )
              
              
                {
              
              
                'key'
              
              
                :
              
              
                'value'
              
              
                }
              
              
                # 使用fromkeys方法初始化字典
              
              
                #初始化
              
              
                >>
              
              
                >
              
               d4 
              
                =
              
              
                {
              
              
                }
              
              
                .
              
              fromkeys
              
                (
              
              
                [
              
              
                'key1'
              
              
                ,
              
              
                'key2'
              
              
                ]
              
              
                )
              
              
                >>
              
              
                >
              
               d4

              
                {
              
              
                'key1'
              
              
                :
              
              
                None
              
              
                ,
              
              
                'key2'
              
              
                :
              
              
                None
              
              
                }
              
              
                >>
              
              
                >
              
               d5 
              
                =
              
              
                dict
              
              
                (
              
              
                )
              
              
                .
              
              fromkeys
              
                (
              
              
                [
              
              
                'key1'
              
              
                ,
              
              
                'key2'
              
              
                ]
              
              
                )
              
              
                >>
              
              
                >
              
               d5

              
                {
              
              
                'key1'
              
              
                :
              
              
                None
              
              
                ,
              
              
                'key2'
              
              
                :
              
              
                None
              
              
                }
              
              
                # 初始化并賦值
              
              
                >>
              
              
                >
              
               d6 
              
                =
              
              
                {
              
              
                }
              
              
                .
              
              fromkeys
              
                (
              
              
                [
              
              
                'key1'
              
              
                ,
              
              
                'key2'
              
              
                ]
              
              
                ,
              
              
                'value'
              
              
                )
              
              
                >>
              
              
                >
              
               d6

              
                {
              
              
                'key1'
              
              
                :
              
              
                'value'
              
              
                ,
              
              
                'key2'
              
              
                :
              
              
                'value'
              
              
                }
              
              
                # 也可以先初始化,然后動(dòng)態(tài)地添加
              
              
                >>
              
               d7 
              
                =
              
              
                {
              
              
                }
              
              
                >>
              
              
                >
              
               d7
              
                [
              
              
                'key1'
              
              
                ]
              
              
                =
              
              
                'value1'
              
              
                >>
              
              
                >
              
               d7
              
                [
              
              
                'key2'
              
              
                ]
              
              
                =
              
              
                'value2'
              
              
                >>
              
              
                >
              
               d7

              
                {
              
              
                'key1'
              
              
                :
              
              
                'value1'
              
              
                ,
              
              
                'key2'
              
              
                :
              
              
                'value2'
              
              
                }
              
              
                # 使用zip函數(shù)把鍵列表和值列表打包成鍵值對(duì)一一對(duì)應(yīng)的元組
              
              
                >>
              
              
                >
              
               d8 
              
                =
              
              
                dict
              
              
                (
              
              
                zip
              
              
                (
              
              
                [
              
              
                'key1'
              
              
                ,
              
              
                'key2'
              
              
                ]
              
              
                ,
              
              
                [
              
              
                'value1'
              
              
                ,
              
              
                'value2'
              
              
                ]
              
              
                )
              
              
                )
              
              
                >>
              
              
                >
              
               d8

              
                {
              
              
                'key1'
              
              
                :
              
              
                'value1'
              
              
                ,
              
              
                'key2'
              
              
                :
              
              
                'value2'
              
              
                }
              
              
                # 字典推導(dǎo)表達(dá)式
              
              
                >>
              
              
                >
              
               d9 
              
                =
              
              
                {
              
              x
              
                :
              
              x
              
                **
              
              
                2
              
              
                for
              
               x 
              
                in
              
              
                [
              
              
                1
              
              
                ,
              
              
                2
              
              
                ,
              
              
                3
              
              
                ]
              
              
                }
              
              
                >>
              
              
                >
              
               d9

              
                {
              
              
                1
              
              
                :
              
              
                1
              
              
                ,
              
              
                2
              
              
                :
              
              
                4
              
              
                ,
              
              
                3
              
              
                :
              
              
                9
              
              
                }
              
            
          

訪問(wèn)、修改字典

字典和列表一樣,是一種存儲(chǔ)數(shù)據(jù)的容器;在列表中,可以通過(guò)下標(biāo)索引來(lái)訪問(wèn)元素,在字典中通過(guò)鍵來(lái)訪問(wèn)它的對(duì)應(yīng)值,即key:value;可以修改,添加等操作。

            
              
                >>
              
              
                >
              
               d1 
              
                =
              
              
                {
              
              
                'type'
              
              
                :
              
              
                'dict'
              
              
                ,
              
              
                'code'
              
              
                :
              
              
                'python'
              
              
                }
              
              
                # 值訪問(wèn)
              
              
                >>
              
              
                >
              
               d1
              
                [
              
              
                'type'
              
              
                ]
              
              
                'dict'
              
              
                # 內(nèi)容添加
              
              
                >>
              
              
                >
              
               d1
              
                [
              
              
                1
              
              
                ]
              
              
                =
              
              
                2
              
              
                >>
              
              
                >
              
               d1

              
                {
              
              
                'type'
              
              
                :
              
              
                'dict'
              
              
                ,
              
              
                'code'
              
              
                :
              
              
                'python'
              
              
                ,
              
              
                1
              
              
                :
              
              
                2
              
              
                }
              
              
                # 內(nèi)容修改
              
              
                >>
              
              
                >
              
               d1
              
                [
              
              
                'code'
              
              
                ]
              
              
                =
              
              
                'java'
              
              
                >>
              
              
                >
              
               d1

              
                {
              
              
                'type'
              
              
                :
              
              
                'dict'
              
              
                ,
              
              
                'code'
              
              
                :
              
              
                'java'
              
              
                ,
              
              
                1
              
              
                :
              
              
                2
              
              
                }
              
              
                # 刪除元素,還可以是用del刪除某個(gè)字典的key,或者刪除整個(gè)字典;使用clear() 清空這個(gè)字典
              
              
                >>
              
              
                >
              
               d1 
              
                =
              
              
                {
              
              
                'type'
              
              
                :
              
              
                'dict'
              
              
                ,
              
              
                'code'
              
              
                :
              
              
                'python'
              
              
                ,
              
              
                1
              
              
                :
              
              
                2
              
              
                }
              
              
                >>
              
              
                >
              
               d1
              
                .
              
              pop
              
                (
              
              
                'code'
              
              
                )
              
              
                # d1的值為{'type': 'dict', 1: 2}
              
              
                >>
              
              
                >
              
              
                del
              
               d1
              
                [
              
              
                1
              
              
                ]
              
              
                # d1的值為{'type': 'dict'}
              
              
                >>
              
              
                >
              
               d1
              
                .
              
              clear
              
                (
              
              
                )
              
              
                # d1 = {}
              
              
                >>
              
              
                >
              
              
                del
              
               d1

              
                >>
              
              
                >
              
              
                print
              
              
                (
              
              d1
              
                )
              
              
                # NameError: name 'd1' is not defined
              
              
                # 如果有兩個(gè)字典,可以使用update函數(shù)來(lái)更新其中某一個(gè)字典
              
              
                # 從下面代碼的結(jié)果上可以看出,如果d1中沒(méi)有d2的元素,則添加進(jìn)來(lái);如果有,則修改為d2中的值
              
              
                >>
              
              
                >
              
               d2 
              
                =
              
              
                {
              
              
                1
              
              
                :
              
              
                3
              
              
                ,
              
              
                2
              
              
                :
              
              
                4
              
              
                ,
              
              
                5
              
              
                :
              
              
                6
              
              
                }
              
              
                >>
              
              
                >
              
               d1
              
                .
              
              update
              
                (
              
              d2
              
                )
              
              
                >>
              
              
                >
              
               d1

              
                {
              
              
                'type'
              
              
                :
              
              
                'dict'
              
              
                ,
              
              
                1
              
              
                :
              
              
                3
              
              
                ,
              
              
                2
              
              
                :
              
              
                4
              
              
                ,
              
              
                5
              
              
                :
              
              
                6
              
              
                }
              
            
          

字典的遍歷

            
              d 
              
                =
              
              
                {
              
              
                'a'
              
              
                :
              
              
                1
              
              
                ,
              
              
                'b'
              
              
                :
              
              
                2
              
              
                ,
              
              
                'c'
              
              
                :
              
              
                3
              
              
                }
              
              
                # 遍歷key值
              
              
                for
              
               key 
              
                in
              
               d
              
                :
              
              
                print
              
              
                (
              
              
                "{} : {}"
              
              
                .
              
              
                format
              
              
                (
              
              key
              
                ,
              
               d
              
                [
              
              key
              
                ]
              
              
                )
              
              
                )
              
              
                # 該方法和上面的方法是等價(jià)的
              
              
                for
              
               key 
              
                in
              
               d
              
                .
              
              keys
              
                (
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                "{} : {}"
              
              
                .
              
              
                format
              
              
                (
              
              key
              
                ,
              
               d
              
                [
              
              key
              
                ]
              
              
                )
              
              
                )
              
              
                # 遍歷value值
              
              
                for
              
               value 
              
                in
              
               d
              
                .
              
              values
              
                (
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              value
              
                )
              
              
                # 遍歷字典項(xiàng)
              
              
                for
              
               key_value 
              
                in
              
               d
              
                .
              
              items
              
                (
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              key_value
              
                )
              
              
                # 遍歷字典健值
              
              
                for
              
               key
              
                ,
              
              value 
              
                in
              
               d
              
                .
              
              items
              
                (
              
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              
                "{} : {}"
              
              
                .
              
              
                format
              
              
                (
              
              key
              
                ,
              
               value
              
                )
              
              
                )
              
            
          

字典的排序

字典的排序有兩種方法,第一種是 list()函數(shù)和字典的keys()方法相結(jié)合,對(duì)產(chǎn)生的list排序,然后輸出。第二種方法是使用內(nèi)置函數(shù)sorted()進(jìn)行排序,會(huì)返回排序好的鍵。

            
              
                # 使用list()函數(shù),和keys()相結(jié)合
              
              
d 
              
                =
              
              
                {
              
              
                1
              
              
                :
              
              
                2
              
              
                ,
              
              
                7
              
              
                :
              
              
                8
              
              
                ,
              
              
                3
              
              
                :
              
              
                4
              
              
                ,
              
              
                5
              
              
                :
              
              
                6
              
              
                }
              
              
d_key 
              
                =
              
              
                list
              
              
                (
              
              d
              
                .
              
              keys
              
                (
              
              
                )
              
              
                )
              
              
d_key
              
                .
              
              sort
              
                (
              
              
                )
              
              
                for
              
               key 
              
                in
              
               d_key
              
                :
              
              
                print
              
              
                (
              
              key
              
                ,
              
               d
              
                [
              
              key
              
                ]
              
              
                )
              
              
                # 使用sorted函數(shù)
              
              
                for
              
               key 
              
                in
              
              
                sorted
              
              
                (
              
              d
              
                )
              
              
                :
              
              
                print
              
              
                (
              
              key
              
                ,
              
               d
              
                [
              
              key
              
                ]
              
              
                )
              
            
          

判斷鍵值是否存在

在python2中判斷一個(gè)字典中某個(gè)key是否存在可以使用has_key和in兩種方法,但是在python3中只有in方法,

            
              
                >>
              
              
                >
              
               d 
              
                =
              
              
                {
              
              
                'type'
              
              
                :
              
              
                'dict'
              
              
                ,
              
              
                'code'
              
              
                :
              
              
                'java'
              
              
                ,
              
              
                1
              
              
                :
              
              
                2
              
              
                }
              
              
                >>
              
              
                >
              
              
                'code'
              
              
                in
              
               d

              
                True
              
              
                >>
              
              
                >
              
              
                3
              
              
                in
              
               d

              
                False
              
            
          

字典中g(shù)et()方法

有這樣一種情況,我們想獲取字典中的某一個(gè)值,但是有不確定它是否存在,那么如果直接寫 dict[key] 肯定是不妥當(dāng)?shù)模敲粗荒苁窍扰凶x,然后在輸出。這樣寫是可以的,但是在python中提供了一種方法 get(key, default=None) ,即若果存在直接輸出結(jié)果,如果不存在,則輸出為default的值。

            
              
                # 獲取字典中的值
              
              
d 
              
                =
              
              
                {
              
              
                'code'
              
              
                :
              
              
                'python'
              
              
                }
              
              
                if
              
              
                'name'
              
              
                in
              
               d
              
                :
              
              
                print
              
              
                (
              
              d
              
                [
              
              
                'name'
              
              
                ]
              
              
                )
              
              
                else
              
              
                :
              
              
                print
              
              
                (
              
              
                'default'
              
              
                )
              
              
                # get()替代 if ... else ...
              
              
                print
              
              
                (
              
              d
              
                .
              
              get
              
                (
              
              
                'name'
              
              
                ,
              
              
                'default'
              
              
                )
              
              
                )
              
            
          

字典和列表的不同

  • 從創(chuàng)建方式上,列表使用的是方括號(hào),字典使用的是花括號(hào)。
  • 字典里的對(duì)象是無(wú)序的,通過(guò)key-value來(lái)表示一種映射關(guān)系;列表中的元素是有序的,可以通過(guò)序號(hào)直接獲取元素,或者通過(guò)切片操作獲取多個(gè)元素。
  • 相對(duì)而言,字典更耗費(fèi)空間,因?yàn)樾枰S護(hù)key。
  • list隨著數(shù)量的正常增長(zhǎng)要想查找元素的時(shí)間復(fù)雜度為O(n), dict不隨數(shù)量而增長(zhǎng)而變化,時(shí)間負(fù)責(zé)都為O(1)

更多文章、技術(shù)交流、商務(wù)合作、聯(lián)系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號(hào)聯(lián)系: 360901061

您的支持是博主寫作最大的動(dòng)力,如果您喜歡我的文章,感覺(jué)我的文章對(duì)您有幫助,請(qǐng)用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點(diǎn)擊下面給點(diǎn)支持吧,站長(zhǎng)非常感激您!手機(jī)微信長(zhǎng)按不能支付解決辦法:請(qǐng)將微信支付二維碼保存到相冊(cè),切換到微信,然后點(diǎn)擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對(duì)您有幫助就好】

您的支持是博主寫作最大的動(dòng)力,如果您喜歡我的文章,感覺(jué)我的文章對(duì)您有幫助,請(qǐng)用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長(zhǎng)會(huì)非常 感謝您的哦!!!

發(fā)表我的評(píng)論
最新評(píng)論 總共0條評(píng)論