python 字典

{'1':1, (1,2):2, 1:3, True:4}
{'1': 1, (1, 2): 2, 1: 4}

字典是一种映射类型的数据结构，它可以将可哈希对象映射到任意对象。在字典中，可哈希对象被用作键，而对应的值则是键所映射的条目。因此，字典的键必须是可哈希对象，比如字符串和元组（但元组中不能包含不可哈希对象）。如果两个对象的哈希值相等，它们会被视为相同的键。

type({})
dict

{'a':1, 'b':2}
{'a': 1, 'b': 2}
dict(a=1,b=2)
{'a': 1, 'b': 2}
dict(zip(['a','b'],(1,2)))
{'a': 1, 'b': 2}

# 获取
d = {'a':1}
d['a']
1
# 更新
d['a'] = [1,2]
d
{'a': [1, 2]}
# 键不存在则添加项
d['b'] = {1,2}
d
{'a': [1, 2], 'b': {1, 2}}
d['c']
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in 
----> 1 d['c']
KeyError: 'c'

字典是目前唯一的标准映射类型，其类型为dict。我们可以用一对花括号表示一个空字典。创建字典时，可以使用花括号和逗号分隔的键值对，也可以使用内置函数dict()。字典是可变对象，可以通过键来获取对应的值，也可以更新或添加新的键值对。如果获取项时，键不存在于字典中，会引发KeyError异常。

d = {}
d[3] = 3
d[1] = 1
d[2] = 2
d
{3: 3, 1: 1, 2: 2}
d[1] = 10
d
{3: 3, 1: 10, 2: 2}
d.popitem(),d.popitem(),d.popitem()
((2, 2), (1, 10), (3, 3))

help(dict.keys)
Help on method_descriptor:
keys(...)
    D.keys() -> a set-like object providing a view on D's keys

字典的元素（键值对）是按照哈希值存储的，没有像序列类型那样的双向索引操作。但是，字典会保留元素插入时的顺序，更新操作不会改变插入顺序。此外，使用popitem()方法删除元素时，会按照后进先出的原则进行删除。

dict.keys()方法返回一个由字典的键组成的动态视图。字典的视图支持成员检测，并且可以进行迭代。

d = {'a':1, 'b':2}
d.keys()
dict_keys(['a', 'b'])
'a' in d.keys()
True
list(d.keys())
['a', 'b']
d = {'a':1, 'b':2}
d_view = d.keys()
print(d_view)
d['c'] = 3 # 添加元素，视图也动态变化
print(d_view)
dict_keys(['a', 'b'])
dict_keys(['a', 'b', 'c'])

help(dict.values)
Help on method_descriptor:
values(...)
    D.values() -> an object providing a view on D's values

d = {'a':1, 'b':2}
d_view = d.values()
print(d_view)
d['c'] = 3 # 添加元素，视图也动态变化
print(d_view)
dict_values([1, 2])
dict_values([1, 2, 3])
1 in d_view
True
[i for i in d_view]
[1, 2, 3]

dict.values()方法返回一个由字典的值组成的动态视图。字典的视图支持成员检测，并且可以进行迭代。

help(dict.items)
Help on method_descriptor:
items(...)
    D.items() -> a set-like object providing a view on D's items

d = {'a':1, 'b':2}
d_view = d.items()
print(d_view)
d['c'] = 3 # 添加元素，视图也动态变化
print(d_view)
dict_items([('a', 1), ('b', 2)])
dict_items([('a', 1), ('b', 2), ('c', 3)])
('a', 1) in d_view
True
[k*j for k, j in d_view]
['a', 'bb', 'ccc']

help(dict.get)
Help on method_descriptor:
get(self, key, default=None, /)
    Return the value for key if key is in the dictionary, else default.

dict.items()方法返回一个由字典的键值对组成的动态视图。字典的视图支持成员检测，并且可以进行迭代。

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

help(dict.copy)
Help on method_descriptor:
copy(...)
    D.copy() -> a shallow copy of D

dict.get()方法用于获取字典中指定键的值。如果键存在于字典中，则返回对应的值；如果键不存在，则返回指定的默认值（默认为None）。

d = {'a':[1,2], 'b':3}
print(id(d), d)
d1 = d.copy()
print(id(d1), d1)
2276967660712 {'a': [1, 2], 'b': 3}
2276967660784 {'a': [1, 2], 'b': 3}
# 同一个对象的多次引用
id(d['a']), id(d1['a'])
(2276966678024, 2276966678024)
# 改变一个都会改变
d['a'].extend('34')
print(d)
print(d1)
{'a': [1, 2, '3', '4'], 'b': 3}
{'a': [1, 2, '3', '4'], 'b': 3}

help(dict.pop)
Help on method_descriptor:
pop(...)
    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

dict.copy()方法返回字典的一个浅拷贝。浅拷贝会创建一个新的字典，但如果字典中的某个键值对的值是可变对象，则该值会被多次引用。

d = {'a':1, 'b':2}
d.pop('a')
1
d = {'a':1, 'b':2}
d.pop('c', 3)
3
d = {'a':1, 'b':2}
d.pop('c')
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in 
      1 d = {'a':1, 'b':2}
----> 2 d.pop('c')
KeyError: 'c'

help(dict.popitem)
Help on method_descriptor:
popitem(self, /)
    Remove and return a (key, value) pair as a 2-tuple.
    
    Pairs are returned in LIFO (last-in, first-out) order.
    Raises KeyError if the dict is empty.

dict.pop()方法用于删除字典中指定键的键值对，并返回对应的值。如果键存在于字典中，则删除并返回值；如果键不存在，并且指定了可选参数d，则返回d；如果键不存在且未指定d，则引发KeyError异常。

d = {2:2,1:1}
d.popitem()
(1, 1)
d = {}
d[1] = 1
d[3] = 3
d[2] = 2
d[3] = 30 # 更新并不改变元素插入顺序
d.popitem(),d.popitem(),d.popitem()
((2, 2), (3, 30), (1, 1))
d = {}
d.popitem()
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in 
      1 d = {}
----> 2 d.popitem()
KeyError: 'popitem(): dictionary is empty'

help(dict.fromkeys)
Help on built-in function fromkeys:
fromkeys(iterable, value=None, /) method of builtins.type instance
    Create a new dictionary with keys from iterable and values set to value.

dict.popitem()方法按照后进先出的原则删除字典中的键值对，并以(key, value)元组的形式返回。如果字典为空，则引发KeyError异常。

dict.fromkeys('123')
{'1': None, '2': None, '3': None}
dict.fromkeys([1,2,3], 0)
{1: 0, 2: 0, 3: 0}

dict.fromkeys([[1],2,3], 0)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in 
----> 1 dict.fromkeys([[1],2,3], 0)
TypeError: unhashable type: 'list'

help(dict.clear)
Help on method_descriptor:
clear(...)
    D.clear() -> None.  Remove all items from D.

使用dict.fromkeys()方法可以使用可迭代对象iterable中的元素作为字典的键，并指定值（默认为None）来创建字典。需要注意的是，可迭代对象中不能包含不可哈希对象。

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

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

help(dict.setdefault)
Help on method_descriptor:
setdefault(self, key, default=None, /)
    Insert key with a value of default if key is not in the dictionary.
    
    Return the value for key if key is in the dictionary, else default.

d = {'a':1, 'b':2}
d.setdefault('a')
1
d.setdefault('c', 3)
3
d
{'a': 1, 'b': 2, 'c': 3}
d.setdefault('c', 4) # 如果存在，并不会再次设置
3
d
{'a': 1, 'b': 2, 'c': 3}

dict.clear()方法用于清空字典中的所有元素。该方法是一个原地操作，返回值为None。

help(dict.update)
Help on method_descriptor:
update(...)
    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] = v
    In either case, this is followed by: for k in F:  D[k] = F[k]

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

d = {'a':1, 'b':2}
d.update([('a',10),['c',3]])
d
{'a': 10, 'b': 2, 'c': 3}

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

d = {'a':1, 'c':3, 'b':2}
for k in d:
    print(k)
a
c
b
list(d)
['a', 'c', 'b']
sorted(d)
['a', 'b', 'c']
max(d)
'c'

dict.update()方法用于更新字典。如果键已存在于字典中，则会覆盖原有的值；如果键不存在，则会添加新的键值对元素。该方法有几种使用方式。

d = {'a':1, 'c':3, 'b':2}
for k in d.keys(): # 可以不用视图
    print(k)
a
c
b
d = {'a':1, 'c':3, 'b':2}
for k in d.values(): 
    print(k)
1
3
2
d = {'a':1, 'c':3, 'b':2}
for k,v in d.items(): 
    print(k,v)
a 1
c 3
b 2
# 按值排序后再遍历
d = {'a':1, 'c':3, 'b':2}
for k,v in sorted(d.items(),key=lambda x:x[1]): 
    print(k,v)
a 1
b 2
c 3

{1:1} < {2:2}
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in 
----> 1 {1:1} < {2:2}
TypeError: '<' not supported between instances of 'dict' and 'dict'

{1:1.0, 2:2} == {2:2, True:1}
True
{1:'1', 2:2} == {2:2, 1:1}
False

字典是可迭代对象，可以遍历字典的元素。由于字典的元素是键值对，因此遍历字典比较特殊。如果未指定遍历对象，默认会遍历字典的键。在很多函数中，字典被视为可迭代对象时也是如此处理的。

{'a':1, 'b':2, **{'a':10}}
{'a': 10, 'b': 2}
d = {'a':1, 'b':2}
'a={a},b={b}'.format(**d)
'a=1,b=2'

字典可以使用**操作符进行拆包，拆包后可以将其置于新字典中，用于更新字典，或者作为关键字参数传递给函数。此外，在Python 3.9的新版本中，还引入了两个操作符|和|=，用于合并两个字典的键和值，其中优先使用第二个字典的值。

以上是关于字典的概述和常用操作的介绍。通过了解字典的特性和使用方法，您可以更好地利用字典来处理和组织数据。