美文网首页Python全栈
9.Python基础数据类型之字典

9.Python基础数据类型之字典

作者: 免跪姓黄 | 来源:发表于2020-02-06 22:50 被阅读0次

    Python基础数据类型之字典

    1. 字典(dict)

      • 虽然列表可以存储大量数据,但由于列表的数据关联性不强,且列表的查询速度比较慢,因此产生了字典;

      • 字典是另一种可变容器模型,且可存储任意类型对象。

      • 字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号{ }中 ,格式如下所示:

        d = {key1 : value1, key2 : value2 }
        
        # 字典实例
        d = {"张三":{"年龄":18, "性别":"男"},"李四":{"年龄":20, "性别":"女"}}
        

        其中键必须是唯一的,但值则不必。值可以取任何数据类型,但键必须是不可变的数据类型,如字符串、数字、布尔值或元组。

      • 数据类型的分类(按照可变与不可变进行分类):

        • 可变(不可哈希)的数据类型:列表(list)、字典(dict)、集合(set)
        • 不可变(可哈希)的数据类型:字符串(str)、数值(int)、布尔值(bool)、元组(tuple)
    2. 字典特点

      • 字典在Python 3.5版本及之前版本是无序的。而在Python 3.6版本以后,字典会按照初次建立的顺序排列,但学术上仍然认为Python字典不是有序的。在Python 3.7及以后版本中,字典都是有序的了。
      • 字典的优点:字典查询速度非常快,比列表的查询速度要快的多。可以存储关联性数据。
      • 字典的缺点:空间换时间。字典查询速度快的代价就是浪费空间。
    3. 字典的创建方式

      • 创建一个空字典

        d = dict()
        
      • 方式一(元组的拆包)

        d = dict((("one",1), ("two",2), ("three",3)))
        print(d)
        # 输出结果:{'one': 1, 'two': 2, 'three': 3}
        
      • 方式二(键值对形式)

        d = dict(one=1, two=2, three=3)
        print(d)
        # 输出结果:{'one': 1, 'two': 2, 'three': 3}
        
      • 方式三(官方推荐)

        d = dict({"one":1, "two":2, "three":3})
        print(d)
        # 输出结果:{'one': 1, 'two': 2, 'three': 3}
        
      • 方式四(直接花括号)

        d = {'one': 1, 'two': 2, 'three': 3}
        
      • 方式五(dict.formkeys():字典的键时来自一个可迭代的对象,把可迭代的对象每一个值当作一个键,所有的键共用一个值,正因为所有键都公用一个值,因此,当键值为可变数据类型时,一个键的值更改,其他键的值也会随着更改)

        d = dict.fromkeys([1,2,3],"字典")
        print(d)
        # 输出结果:{1: '字典', 2: '字典', 3: '字典'}
        
        d = dict.fromkeys([1,2,3],[6])
        print(d)
        d[1].append(666)
        print(d)
        '''
        输出结果:
        {1: [6], 2: [6], 3: [6]}
        {1: [6, 666], 2: [6, 666], 3: [6, 666]}
        '''
        
      • 方式六

    4. 字典的增、删、改、查

        • 方式一(直接增加)

          d = {'one': 1, 'two': 2, 'three': 3}
          d['four'] = 4
          print(d)
          # 输出结果:{'one': 1, 'two': 2, 'three': 3, 'four': 4}
          
          # 如果增加的键值对的键与字典中的键重复,则新键值对会覆盖掉原有键值对,也叫“有则改之,无则增加”
          d = {'one': 1, 'two': 2, 'three': 3}
          d['one'] = 4
          print(d)
          # 输出结果:{'one': 4, 'two': 2, 'three': 3}
          
        • 方式二(通过内置函数setdefault增加)

          d = {'one': 1, 'two': 2, 'three': 3}
          d.setdefault('four',4)
          print(d)
          # 输出结果:{'one': 1, 'two': 2, 'three': 3, 'four': 4}
          # 如果增加的键值对的键与字典中的键重复,则新键值对不会覆盖掉原有键值对,也叫“有则不改,无则增加”
          
        • 方式三(通过update方法增加)

          d = {'one': 1, 'two': 2, 'three': 3}
          d.update(four=4,five=5)
          print(d)
          # 输出结果:{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
          
        • 方式四(通过update方法和元组的拆包增加)

          d = {'one': 1, 'two': 2, 'three': 3}
          d.update([('four',4),('five',5)])
          print(d)
          # 输出结果:{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
          
        • 方式五(通过update将一个列表更新到另一个列表)

          dict_1 = {'one': 1, 'two': 2, 'three': 3}
          dict_2 = {'one': 0, 'four': 4}
          dict_1.update(dict_2)
          print(dict_1)
          # 输出结果:{'one': 0, 'two': 2, 'three': 3, 'four': 4}
          # update()方法特点:有则改之,无则增加
          
        • 方式一(通过内置函数pop进行删除)(推荐使用此方式)

          d = {'one': 1, 'two': 2, 'three': 3}
          d.pop('three')
          print(d)
          # 输出结果:{'one': 1, 'two': 2}
          # 所有删除方法,只有pop有返回值,返回的值是删除的值
          
          # 当不确定删除的键值在不在字典中,为了防止报错,可以在删除的简直后面增加一个空键值,如果没有要删除的键值,不会报错
          d = {'one': 1, 'two': 2, 'three': 3}
          d.pop('four',"")
          print(d)
          # 输出结果:{'one': 1, 'two': 2, 'three': 3}
          
        • 方式二(通过del方式删除)

          d = {'one': 1, 'two': 2, 'three': 3}
          del d['two']
          print(d)
          # 输出结果:{'one': 1, 'three': 3}
          # 如果删除的键字典中没有会报错,因此不推荐此方法
          
        • 方式三(通过内置函数clear清空字典,并非删除字典)

          d = {'one': 1, 'two': 2, 'three': 3}
          d.clear()
          print(d)
          # 输出结果:{}
          
        • 方式一(直接改)

          d = {'one': 1, 'two': 2, 'three': 3}
          d['one'] = 4
          print(d)
          # 输出结果:{'one': 4, 'two': 2, 'three': 3}
          
        • 方式二(通过update方法改)

          d = {'one': 1, 'two': 2, 'three': 3}
          d.update(one=4)
          print(d)
          # 输出结果:{'one': 4, 'two': 2, 'three': 3}
          
        • 方式一(直接查,不推荐)

          d = {'one': 1, 'two': 2, 'three': 3}
          print(d['three'])
          # 输出结果:3
          # 如果查询的键字典中没有会报错,因此不推荐此方法
          
        • 方式二(通过内置函数get查询)

          d = {'one': 1, 'two': 2, 'three': 3}
          d1 = d.get('two')
          print(d1)
          # 输出结果:2
          # # 如果查询的键字典中没有也不会报错,默认返回值是None,返回值可以设置,因此推荐此方法
          
          d = {'one': 1, 'two': 2, 'three': 3}
          d1 = d.get('four', '没有此键')
          print(d1)
          # 输出结果:没有此键
          
        • 通过内置方法 keys() 查询字典内所有的键

          d = {'one': 1, 'two': 2, 'three': 3}
          print(d.keys())
          # 输出结果:dict_keys(['one', 'two', 'three'])
          
          # 此方式可将键名称转换成列表
          print(list(d.keys()))
          # 输出结果:['one', 'two', 'three']
          
          # 也可以通过for循环列出所有的键
          d = {'one': 1, 'two': 2, 'three': 3}
          for key in d:
              print(i)
          '''
          输出结果:
          one
          two
          three
          '''
          
        • 通过内置方法 values() 查询字典内所有的值

          d = {'one': 1, 'two': 2, 'three': 3}
          print(d.values())
          # 输出结果:dict_values([1, 2, 3])
          
          # 同理,也可以转换成列表及使用for循环列出所有的值
          
        • 通过内置方法 item() 查询所有的键值对

          d = {'one': 1, 'two': 2, 'three': 3}
          print(d.items())
          # 输出结果:dict_items([('one', 1), ('two', 2), ('three', 3)])
          
          # 将键值对转换成列表
          d = {'one': 1, 'two': 2, 'three': 3}
          print(list(d.items()))
          # 输出结果:[('one', 1), ('two', 2), ('three', 3)]
          
          # 使用for循环列出所有的键值对(使用到了元组的拆包)
          d = {'one': 1, 'two': 2, 'three': 3}
          for key,value in d.items():
              print(key,value)
          '''
          输出结果:
          one 1
          two 2
          three 3
          '''
          
    5. 字典的嵌套

      d = {
          '姓名': '张三',
          '性别': '男',
          '配偶':{'姓名': '李四', '性别': '女'},
          '联系方式':[{'手机':12345678, '电话':123456},]
          }
      
      • 获取张三的名字

        print(d.get('姓名'))
        
      • 获取联系方式中的字典

        print(d.get('联系方式')[0])
        
      • 获取手机号

        print(d.get('联系方式')[0].get('手机'))
        
      • 获取配偶的姓名

        print(d.get('配偶').get('姓名'))
        
    6. 字典的for循环

      • 循环一个字典时,如果改变字典的大小(增加或删除元素),就会报错。

        # 将下面字典中所有含t的键值对删掉如何处理呢?
        # 首先我们会想到,循环字典,判断字典的键是否含有"t",可循环字典时改变字典大小就会报错。
        # 那么,我们换种思路,不循环字典时删除键值就好了,只要找到满足有两种方法。
        
        # 方法一:先for循环字典,将满足条件的键放入到一个列表中,然后循环列表,删除满足条件的键值
        d = {'one': 1, 'two': 2, 'three': 3, 'four': 4}
        l = []
        for key in d:
            if 't' in key:
                l.append(key)
        for i in l:
            d.pop(i)
        print(d)
        # 输出结果:{'one': 1, 'four': 4}
        
        # 方法二:通过内置方法keys()生成字典中所有键的列表,然后通过循环键的列表删除满足条件的键值
        d = {'one': 1, 'two': 2, 'three': 3, 'four': 4}
        l = list(d.keys()) # 由于d.keys()生成的列表仍与字典d有关系,直接循环删键值对仍然会报错,因此创建一个新的列表
        for key in l:
            if 't' in key:
                d.pop(key)
        print(d)
        
    7. 字典推导式

      # 将两个列表通过一行代码生成一个字典
      keys = ['a', 'b', 'c']
      values = [1, 2, 3]
      
      dic = {keys[i]:values[i] for i in range(len(keys))}
      
      print(dic)    # {'a': 1, 'b': 2, 'c': 3}
      

    相关文章

      网友评论

        本文标题:9.Python基础数据类型之字典

        本文链接:https://www.haomeiwen.com/subject/urjpxhtx.html