Python中dict的功能介绍

Dict的功能介绍

1. 字典的两种函数（方法）

1. 字典的内置函数

1. 包含关系

   格式：x.__contains__(key)等同于key in x
   例如：dic = {'ab':23,'cd':34,}
        print(dic.__contains__('ab'))
    >>> True
   返回值：bool
   #只能判断字典的键
   

2. 删除字典指定键的键值对

   格式：x.__delitem__(key)等同于del x[key]
   例如：dic = {'ab':23,'cd':34,}
        dic.__delitem__('ab'))
        print(dic)
    >>> {'cd':34}
   返回值：None
   #直接修改原字典
   

3. 判断两个字典是否相等

   格式：x.__eq__(y)等同于x==y
   例如：dic = {'ab':23,'cd':34,}
        print(dic.__eq__({}))
    >>> False
   返回值：bool
   #上述的y只能是字典
   

4. 判断是否大于等于

   格式：x.__ge__(y)等同于x>=y
   返回值：bool
   #字典没有该方法
   

5. 访问属性

   格式：x.__getattribut__(self,name)
   返回值：tuple
   

6. 获取指定键的值

   格式：x.__getitem__(key)等同于x[key]
   例如：dic = {'ab':23,'cd':34,}
        print(dic.__getitem__('ab'))
    >>> 23
   返回值：object
   

7. 判断是否大于

   格式：x.__gt__(y)等同于：x>y
   返回值：bool
   #字典没有该方法
   

8. 构造方法

   格式：x.__init__(dict())
   例如：dic = {1:3,2:4,}
        dic.__init__(dict())
        print(dic)
    >>> {1: 3, 2: 4}
   返回值：None
   

9. 迭代器

   格式：x.__iter__()等同于iter(x)
   返回值：迭代器
   

10. 判断是否小于等

    格式：x.__le__(y)等同于x<=y
    返回值：bool
    #字典没有该方法
    

11. 长度

    格式：x.__len__()等同于len(x)
    返回值：int
    

12. 判断是否小于

    格式：x.__lt__(y)等同于x<y
    返回值：bool
    #字典没有该方法
    

13. 判断是否不等于

    格式：x.__ne__(y)等同于x!=y
    返回值：bool
    

14. 创建新字典

    格式：x.__new__(dict)
    例如：dic = {'a':3,'b':4,}
         print(dic.__new__(dict))
     >>> {}
    返回值：dict
    

15. 内置转换方法

    格式：x.__repr__(self)
    返回值：dict
    

16. 新增一对键值对或修改指定key的值

    格式：x.__setitem__(key,value)等同于x[key]=value
    例如：dic = {'a':3,'b':4,}
         dic.__setitem__('c',5)
         dic.__setitem__('c',9)
         print(dic)
     >>> {'b': 4, 'c': 9, 'a': 3}
    返回值：None
    

17. 字典在内存中大小，转换为字节进行计算

    格式：x.__sizeof__()
    例如：dic1 = {'a':3,'b':4,}
         dic2 = {2:4}
         print(dic1.__sizeof__())
     >>> 264
         print(dic2.__sizeof__())
     >>> 264
    返回值：int
    #字典长度和内容的不同，不影响字典在内存中的大小。
    

2. 字典的常用函数

1. 清空字典

   格式：x.clear()
   例如：dic = {'a':3,'b':4,}
        dic.clear()
        print(dic)
    >>> {}
   返回值：None
   

2. 复制

   格式：x.copy()
   例如：dic = {'a':3,'b':4,}
        print(dic.copy())
    >>> {'a':3,'b':4}
   返回值：dict
   

3. 新建字典并指定字典值

   格式：x.fromkeys(iterable,value=None)
   例如：dic = {'a':3,'b':4,}
        print(dic.fromkeys('cde'))
    >>> {'c':None,'d':None,'e':None}
        print(dic.fromkeys('de',12))
    >>> {'d':12,'e':12}
   返回值：dict
   

4. 获取指定键的值

   格式：x.get(key)
   例如：dic = {'a':3,'b':4,}
        print(dic.get('a'))
    >>> 3
   返回值：object
   

5. 获取字典所有的键值对

   格式：x.items()
   例如：dic = {'a':3,'b':4,}
        print(dic.items())
    >>> dict_items([('b', 4), ('a', 3)])
   返回值：list
   #把字典所有的键值对以列表的元祖的形式表示
   

6. 获取字典所有的键

   格式：x.keys()
   例如：dic = {'a':3,'b':4,}
        print(dic.keys())
    >>> dict_keys(['b', 'a'])
   返回值：list
   #把字典所有的键以列表元素的形式表示
   

7. 移除指定键的值

   格式：x.pop(key)
   例如：dic = {'a':3,'b':4,}
        print(dic.pop('a'))
    >>> 3
   返回值：object
   #删除原字典中指定键的值，并返回删除的值
   

8. 随机删除键值对

   格式：x.popitem()
   例如：dic = {'a':3,'b':4,}
        print(dic.popitem())
    >>> {'a':3}
   返回值：tuple
   #随机删除一个键值对，并以元祖的形式返回删除的键值对
   

9. 设置字典默认值

   格式：x.setdefault(key,value=None)
   例如：dic = {'a':3,'b':4,}
        print(dic.setdefault('c'))
    >>> None
   #没有设置值的默认值，则新增的键'c'默认值为None
        print(dic.setdefault('d',9))
    >>> 9
   #当设置默认值时，新增的键'd'的值则为设置的9，返回值则为设置的值9
   返回值：object
   

10. 更新字典

    格式：x.update(y)
    例如：dic = {'a':3,'b':4,}
         dic.update({'c':1})
         print(dic)
     >>> {'a':3,'b':4,'c':1}
    返回值：None
    #在原字典的基础上再合并一个字典
    

11. 获取字典所有的值

    格式：x.values()
    例如：dic = {'a':3,'b':4,}
         print(dic.values())
     >>> dict_values([4, 3])
    返回值：list
    #把字典所有的值以列表元素的形式表示
    

2. 字典的操作

1. 字典的基本操作

1. 访问

   格式：dict[key]
   返回值：object
   

2. 修改

   格式：dict[key] = value
   返回值：None
   

3. 删除

   格式：del dict[key]
   返回值：None
   

4. 添加

   格式：dict[key] = value
   返回值：None
   #添加和修改格式都一样，只是添加使用的是新的键，修改使用的是存在的键
   

2. 字典的遍历操作

使用for...in 遍历字典

   1. 不使用字典函数的遍历

        格式：for variable in dict:
                 使用variable
        例如：dic = {'a':3,'b':5,}
             for i in dic:
                 print(i)
         >>> a
         >>> b
        返回值：字典的key
  2. 使用函数key()遍历字典的键

        格式：for variable in dict.keys():
                 使用variable
        例如：dic = {'a':3,'b':5,}
             for i in dic.keys():
                 print(i)
         >>> a
         >>> b
        返回值：字典的key
        #效果与省略函数keys()的效果一样
  3. 使用函数values()遍历字典的值

        格式：for variable in dict.values():
                 使用variable
        例如：dic = {'a':3,'b':5,}
             for i in dic.values():
                 print(i)
         >>> 3
         >>> 5
        返回值：字典的values
  4. 使用函数items()遍历字典的键值对

        格式：for variable1,variable2 in dict.items():
                 使用variable1,variable2
        例如：dic = {'a':3,'b':5,}
             for i,j in dic.items():
                 print(i,j)
         >>> a 3
         >>> b 5
        返回值：字典的键值对，两个变量分别对应字典的键和值

3. 字典的推导式

1. 返回值为集合的推导式

   1.格式：{variable for variable in dict}
     例如：dic = {'a':3,'b':5,}
          print({i for i in dic})
      >>> {'a','b'}
     返回值：set
     #把字典所有的key，组建成一个集合
   2.格式：{variable for variable in dict.keys()}
     例如：dic = {'a':3,'b':5,}
          print({i for i in dic.keys()})
      >>> {'a','b'}
     返回值：set
     #把字典所有的key，组建成一个集合
   3.格式：{variable for variable in dict.values()}
     例如：dic = {'a':3,'b':5,}
          print({i for i in dic.values()})
      >>> {3,5}
     返回值：set
     #把字典所有的value，组建成一个集合
   

   注：字典推导式也可以有带判断和多字典的导式，这里不再一一举例。

2. 返回值为字典的推导式

   格式：{variable2:variable1 for variable1,variable2 in dict.items()}
   例如：dic = {'a':3,'b':5,}
        print({v:k for k,v in dic.items()})
    >>> {3: 'a', 5: 'b'}
   返回值：dict
   #字典推导式把键和值互换
   

3. 稍作修改的字典推导式

   格式：{variable2:(variable1+'*') for variable1,variable2 in dict.items()}
   例如：dic = {'a':3,'b':5,}
        print({v:(k+'*') for k,v in dic.items()})
    >>> {3: 'a*', 5: 'b*'}
   返回值：dict
   #字典推导式把键和值互换，并进行修改
   

4. 多个字典推导式

   格式：{(k1+k2):(v1+v2) for k1,v1 in dict1.items() for k2,v2 in dict2.items()}
   例如：dict1 = {'a':3,'b':5,}
        dict2 = {'c':10,'d':20,}
        print({(k1+k2):(v1+v2) for k1,v1 in dict1.items() for k2,v2 in dict.items()})
    >>> {'ad': 23, 'bd': 25, 'ac': 13, 'bc': 15}
   返回值：dict
   

5. 带判断条件的多字典推导式

   格式：{(k1*v2):(k2*v1) for k1,v1 in dict1.items() for k2,v2 in dict2.items() if 条件表达式}
   例如：dict1 = {'a':3,'b':5,}
        dict2 = {'c':10,'d':20,}
        print({(k1*v2):(k2*v1) for k1,v1 in dict1.items() for k2,v2 in dict.items() v1 <15 and v2 < 15})
    >>> {'bbbbbbbbbb': 'ccccc', 'aaaaaaaaaa': 'ccc'}
   返回值：dict