04Python学习字典详解

一 字典dict特性

字典dict是一种key - value 与Java的中Map有点类似

• dict是无序的

• key必须是唯一的 且必须是可hash 不可变类型 如int str tuple frozenset

  • >>> hash(1)
    1
    >>> hash('a')
    6134580092184725428
    >>> tu = (1,2,)
    >>> hash(tu)
    3713081631934410656
    >>> hash(frozenset(st))
    -1826646154956904602
    
    >>> li = [1,2,3]
    >>> dic = {'a':1}
    >>> st = {1,2}
    >>> hash(li)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'list'
    >>> hash(dic)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'dict'
    >>> hash(st)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'set'
    

• 查询速度快，比列表快多了

• 比list占用内存多

• 字典是可修改的

二 定义一个字典

字典中的key值, 必须是可hash类型. 即类型为不可变类型. 如: str/number/元祖/字典/frozenset

d1 = {}  # 构造一个空字典
d2 = {'spam': 2, 'eggs': 3}  # 构造2个key-value的元素的字典
d3 = {'food': {'eggs': 3, 'bread': 4}}  # 构造一个嵌套的字典
d4 = dict.fromkeys(['a', 'b'])  # 其他构造方法,只构造key => {'a': None, 'b': None}
d5 = dict(zip(['a', 'b'], [1, 2]))  # 通过拉链来构造,key value => {'a': 1, 'b': 2}
d6 = dict(a=1, b=2)  # 字典构造 => {'b': 2, 'a': 1}

三 遍历字典

for x in dic:  #默认用的是 keys
    print(x,"=",dic.get(x))
    

四 字典的常用方法

4.1 clear() ⭐️

清空字典所有数据 D.clear() -> None. Remove all items from D.

>>> d = {'a':1,'b':2}
>>> d.clear()
>>> d
{}

4.2 copy() ⭐️

浅拷贝字典里面的内容 D.copy() -> a shallow copy of D

>>> d = {'a':1,'b':2}
>>> c = {}
>>> c = d.copy()
>>> c
{'a': 1, 'b': 2}

4.3 fromkeys(*args, **kwargs)

staticmethod 静态方法

Returns a new dict with keys from iterable and values equal to value.

>>> dict.fromkeys(['a','b','c'])
{'a': None, 'b': None, 'c': None}


>>> dict.fromkeys(['a','b','c'],"A")
{'a': 'A', 'b': 'A', 'c': 'A'}

4.4 get(k, d=None) ⭐️

D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.

通过字典的Key来,获取字典中的value. 如果key不存在,则返回None不会报错. 或者给一个初始值来返回

>>> d = {'a':1,'b':2}
>>> d.get('a')
1
>>> d.get('c')
>>> d.get('c',3)
3

4.5 items() ⭐️

D.items() -> a set-like object providing a view on D’s items

通过字典中的key value组成一个个元祖,并将所有的小元祖来组成一个列表

>>> d
{'a': 1, 'b': 2}
>>> for x in d.items():
...     print(x)
...
('a', 1)
('b', 2)

4.6 keys() ⭐️

获取字典中所有的key值

D.keys() -> a set-like object providing a view on D’s keys

>>> d
{'a': 1, 'b': 2}
>>> d.keys()
dict_keys(['a', 'b'])
>>> for x in d.keys():
...     print(x)
...
a
b

4.7 values() ⭐️

获取所有的value值

D.values() -> an object providing a view on D’s values

>>> d
{'a': 1, 'b': 2}
>>> for x in d.values():
...     print(x)
...
1
2

4.8 pop(self, k, d=None) ⭐️

D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised

删除字典中对应的key 并返回该key值中的value 如果删除的key不存在 且未指定默认的返回值 则会报错

>>> d
{'a': 1, 'b': 2}
>>> d.pop('a')
1
>>> d
{'b': 2}
>>> x = d.pop('b')
>>> x
2
>>> d
{}
>>> y = d.pop('c')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'c'
>>> y = d.pop('c',3)
>>> y
3

4.9 popitem()

D.popitem() -> (k, v), remove and return some (key, value) pair as a**2-tuple; but raise KeyError if D is empty.

删除最后一个字典的key 及 value 并返回其组成的元祖. 如果字典为空时,抛异常

>>> d = {'a':1,'b':2}
>>> d.popitem()
('b', 2)
>>> d
{'a': 1}
>>> d.popitem()
('a', 1)
>>> d
{}
>>> d.popitem()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'

4.10 setdefault(k,d=None)

D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D

给一个key值,如果字典中存在该key值,则不修改对应的value 如果key不存在,则使用对应的默认value值

>>> d
{'a': None, 'b': 1}
>>> d.setdefault('a',2)
>>> d
{'a': None, 'b': 1}
>>> d.setdefault('c',3)
3
>>> d
{'a': None, 'b': 1, 'c': 3}

4.11 update(E=None, **F)

*D.update([E, ]**F) -> None. Update D from dict/iterable E and F.*If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = vIn either case, this is followed by: for k in F: D[k] = F[k]

字典1 and 字典2 字典1调用update(字典2) 通过字典2中key值来进行覆盖字典1

>>> dic1 = {'a':1,'b':2}
>>> dic2 = {'a':'A'}
>>> dic1.update(dic2)
>>> dic1
{'a': 'A', 'b': 2}
>>> dic1.update({'b':'B','c':3})
>>> dic1
{'a': 'A', 'b': 'B', 'c': 3}