使用 { } 创建字典

由于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号 : 分隔，相邻元素之间使用逗号 , 分隔，所有元素放在大括号 { } 中。

使用 { } 创建字典的语法格式如下：

dictname = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}

#使用字符串作为key
scores = {'数学': 95, '英语': 92, '语文': 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)
#创建空元组
dict2 = {}
print(dict2)

{'数学': 95, '英语': 92, '语文': 84}
{(20, 30): 'great', 30: [1, 2, 3]}
{}

2) 通过 fromkeys() 方法创建字典

Python 中，还可以使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典，具体格式为：

dictname = dict.fromkeys(list，value=None)

其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。

请看下面的例子：

knowledge = ['语文', '数学', '英语']字典

scores = dict.fromkeys(knowledge, 60)
print(scores)

dict5 = dict.fromkeys("abc", 'x')
print(dict5) 

# {'a': 'x', 'b': 'x', 'c': 'x'} 

_dict5 = dict.fromkeys({1, 2, 3}) 
print(_dict5) 

# {1: None, 2: None, 3: None}

运行结果为：

{'语文': 60, '英语': 60, '数学': 60}

可以看到，knowledge 列表中的元素全部作为了 scores 字典的键，而各个键对应的值都是 60。这种创建方式通常用于初始化字典，设置 value 的默认值。

3) 通过 dict() 映射函数创建字典

通过 dict() 函数创建字典的写法有多种，表 2 罗列出了常用的几种方式，它们创建的都是同一个字典 a。

3) 通过推导创建字典

dict6 = {i: 2 * i for i in range(3)}
print(dict6)  # {0: 0, 1: 2, 2: 4}

注意，无论采用以上哪种方式创建字典，字典中各元素的键都只能是字符串、元组或数字，不能是列表。列表是可变的，不能作为键。

4) 创建键值一对多的字典

一般写法: 使用Python3标准库,collections模块的类：defaultdict([default_factory[, …]])

from collections import defaultdict
dict2 = defaultdict(list)
dict2["one"].append(1)
dict2["one"].append(2)
dict2["one"].append(3)
print(dict2)  # defaultdict(<class 'list'>, {'one': [1, 2, 3]})
print(dict2["two"])  # key"two"不存在 根据参数是list返回空列表 []

6) 创建有序字典

创建有序Dict
推荐写法: 使用Python3的标准库，collections模块的类：OrderedDict([items])

7) 创建空字典

推荐写法: 使用{}直接创建

推荐写法: 使用Python3的标准库，dict类内置函数：dict()

empty_dict1 = {}
print(isinstance(empty_dict1, dict))  # True
print(empty_dict1)  # {}
empty_dict2 = dict()
print(isinstance(empty_dict2, dict))  # True
print(empty_dict2)  # {}

8) 创建有默认值的字典

推荐写法: 使用Python3的标准库，dict类内置函数：setdefault(key[, default])，key指定键，default是可选参数

dict1 = {"one": 1, "two": 2, "three": 3}
value = dict1.setdefault("one", 111)
print(value)  # key"one"存在 default不生效 1
print(dict1)  # {'one': 1, 'two': 2, 'three': 3}
none_value = dict1.setdefault("four")
print(none_value)  # key"four"不存在 None
print(dict1)  # 添加新元素 {'one': 1, 'two': 2, 'three': 3, 'four': None}
default_value = dict1.setdefault("five", 5)
print(default_value)  # key"five"不存在 返回default给定值 5
print(dict1)  # 添加新元素 {'one': 1, 'two': 2, 'three': 3, 'four': None, 'five': 5}

Python访问字典

列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。因为字典中的元素是无序的，每个元素的位置都不固定，所以字典也不能像列表和元组那样，采用切片的方式一次性访问多个元素。

Python 访问字典元素的具体格式为：dictname[key]

其中，dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常。

除了上面这种方式外，Python 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get() 方法不会抛出异常。

get() 方法的语法格式为：dictname.get(key[,default])

其中，dictname 表示字典变量的名字；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。

注意，当键不存在时，get() 返回空值 None，如果想明确地提示用户该键不存在，那么可以手动设置 get() 的第二个参数，例如：

a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('one') )
print( a.get('five', '该键不存在') )

Python删除字典

和删除列表、元组一样，手动删除字典也可以使用 del 关键字，例如：

a = dict(two=0.65, one=88, three=100, four=-59)
print(a)
del a
print(a)

Dict浅拷贝

Dict浅拷贝只会拷贝当前Dict的顶层元素，不会拷贝嵌套的子对象，即原Set和拷贝Set指向同一子对象
一般写法: 使用Python3的标准库，dict类内置函数：copy(other)，other指代另一个Dict

一般写法: 使用Python3的标准库，copy模块的函数：copy(other)，other指代另一个Dict

import copy
dict1 = {"one": 1, "two": {1: 1, 2: 2}}
copy1 = copy.copy(dict1)
print(dict1 == copy1)  # True
print(id(dict1) == id(copy1))  # False
copy1.get("two")[1] = 111
print(dict1)  # {'one': 1, 'two': {1: 111, 2: 2}}

一般写法: 使用Python3的标准库，dict类内置函数：dict(other)，other指代另一个Dict

dict1 = {"one": 1, "two": {1: 1, 2: 2}}
copy1 = dict(dict1)
print(dict1 == copy1)  # True
print(id(dict1) == id(copy1))  # False
copy1.get("two")[1] = 111
print(dict1)  # {'one': 1, 'two': {1: 111, 2: 2}}

一般写法: 使用运算符”=“

dict1 = {"one": 1, "two": {1: 1, 2: 2}}
copy1 = dict1
print(dict1 == copy1)  # True
print(id(dict1) == id(copy1))  # True
copy1.get("two")[1] = 111
print(dict1)  # {'one': 1, 'two': {1: 111, 2: 2}}

Dict深拷贝

Dict深拷贝不仅会拷贝当前Dict的顶层元素，也会拷贝嵌套的子对象，本质上是执行递归浅拷贝，原Dict和拷贝Dict完全独立，相互不影响
推荐写法: 使用Python3的标准库，copy模块的函数：deepcopy(other)，other指代另一个Dict

获取Dict长度

获取字典长度
推荐写法: 使用Python3的标准库，内置函数len(s)，参数可以是序列(如字符串、字节、元组、列表或范围等)或集合(如字典和集合)，这里是Dict实例

dict1 = {"one": 1, "two": 2, "three": 3}
length = len(dict1)
print(length)  # 3
empty_dict = {}
empty_length = len(empty_dict)
print(empty_length)  # 0

Dict添加

Dict添加键值对

添加一个键值对

Dict添加单个元素；键必须是不可变对象，比如数字、字符串或元组(纯元组，没有嵌套可变对象)，否则会抛出TypeError
推荐写法: 使用方括号dict1[key]=value直接赋值，指定键和值

dict1 = {"one": 1, "two": 2, "three": 3}
dict1["four"] = 4
print(dict1) # {'one': 1, 'two': 2, 'three': 3, 'four': 4}
dict1["one"] = 111
print(dict1) # {'one': 111, 'two': 2, 'three': 3, 'four': 4}

一般写法: 使用Python3的标准库，dict类内置函数：update([other])，other指代一个字典对象或一个键值对的迭代

dict1 = {"one": 1, "two": 2, "three": 3}
# 通过关键字形式的参数添加
dict1.update(four=4)
print(dict1)  # {'one': 1, 'two': 2, 'three': 3, 'four': 4}
# 通过元组列表参数添加
dict1.update([("five", 5)])
print(dict1)  # {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
# 通过字典实例参数添加
dict1.update({"six": 6})
print(dict1)  # {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}
# 可以使用以上任意方法修改已存在的键对应的值
dict1.update(one=111)
print(dict1)  # {'one': 111, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}

添加多个键值对

Dict添加多个元素；键必须是不可变对象，比如数字、字符串或元组(纯元组，没有嵌套可变对象)，否则会抛出TypeError
一般写法: 使用Python3的标准库，dict类内置函数：update([other])，other指代一个字典对象或一个键值对的迭代

Dict删除

Dict删除键值对

1) 根据指定的key删除一个键值对

dict1 = {"one": 1, "two": 2, "three": 3}
del dict1["one"]
print(dict1)  # {'two': 2, 'three': 3}
del dict1["1"]  # key"1"不存在 抛出KeyError: '1'

dict1 = {"one": 1, "two": 2, "three": 3}
del dict1
print(dict1)  # 抛出NameError: name 'dict1' is not defined

1) 更新指定key的value

dict1 = {"one": 1, "two": 2, "three": 3}
# 通过关键字形式的参数更新
dict1.update(one=111)
print(dict1)  # {'one': 111, 'two': 2, 'three': 3}
# 通过元组列表参数更新
dict1.update([("two", 222)])
print(dict1)  # {'one': 111, 'two': 222, 'three': 3}
# 通过字典参数更新
dict1.update({"three": 333})
print(dict1)  # {'one': 111, 'two': 222, 'three': 333}
# 可以使用以上任意方法添加一个键值对
dict1.update(four=4)
print(dict1)  # {'one': 111, 'two': 222, 'three': 333, 'four': 4}

dict1 = {"a": 123, "b": 321, "c": 200}
# 在一个字典上执行普通的数学运算，它们仅仅作用于键，而不是值
max_key = max(dict1)
print(max_key)  # 返回key的最大值 'c'
# 获取最大值对应的键
max_value_key = max(dict1, key=lambda k: dict1[k])
print(max_value_key)  # 'b'
# 根据键获取对应的值
max_value = dict1[max_key]
print(max_value)  # 321

dict1 = {"one": 1, "two": 2, "three": 3}
value = dict1["one"]
print(value)  # 1
none_value = dict1["four"]  # key"four"不存在 抛出KeyError: 'four'

1) 判断key是否在字典中

if key in dict1:
    """do something"""
if key not in dict1:
    """do something"""
dict1 = {"one": 1, "two": 2, "three": 3}
print("one" in dict1)  # True
print("one" not in dict1)  # False
print("One" in dict1)  # False

1) 根据key对字典排序

dict1 = {"a": 3, "c": 1, "b": 2}
# item指代(键，值)元组，item[0]是键, item[1]是值
dict_sorted = sorted(dict1.items(), key=lambda item: item[0])
print(dict_sorted)  # [('a', 3), ('b', 2), ('c', 1)]
dict_sorted_rev = sorted(dict1.items(), key=lambda item: item[0], reverse=True)
print(dict_sorted_rev)  # [('c', 1), ('b', 2), ('a', 3)]
# ------
# 注意：sorted(dict1)默认是对key排序，而不是对整个字典
sorted1 = sorted(dict1)
print(sorted1)  # ['a', 'b', 'c']

2) 根据key对value排序

dict1 = {"a": 3, "c": 1, "b": 2}
list1 = sorted(dict1.items(), key=lambda item: item[0])
print(list1)  # 根据key对字典排序 [('a', 3), ('b', 2), ('c', 1)]
list2 = [value for key, value in list1]
print(list2)  # [3, 2, 1]

dict1 = {"a": 3, "c": 1, "b": 2}
keys = sorted(dict1.keys())
list1 = [dict1[k] for k in keys]
print(list1)  # [3, 2, 1]

dict1 = {"a": 3, "c": 1, "b": 2}
keys = sorted(dict1.keys())
list1 = list(map(dict1.get, keys))
print(list1)  # [3, 2, 1]

3) 根据value对字典排序

dict1 = {"a": 3, "c": 1, "b": 2}
# item指代(键，值)元组，item[0]是键, item[1]是值
dict_sorted = sorted(dict1.items(), key=lambda item: item[1])
print(dict_sorted)  # [('c', 1), ('b', 2), ('a', 3)]
dict_sorted_rev = sorted(dict1.items(), key=lambda item: item[1], reverse=True)
print(dict_sorted_rev)  # [('a', 3), ('b', 2), ('c', 1)]

4) 根据某个key对应的value对字典列表排序

from operator import itemgetter
stu = [
    {"id": 3, "name": "Tom", "score": 82},
    {"id": 2, "name": "Jerry", "score": 67},
    {"id": 1, "name": "Pig", "score": 82},
    {"id": 4, "name": "Dog", "score": 98},
# 根据key"score"对应的value 对stu正序排序
[{'id': 2, 'name': 'Jerry', 'score': 67},
{'id': 3, 'name': 'Tom', 'score': 82},
{'id': 1, 'name': 'Pig', 'score': 82},
{'id': 4, 'name': 'Dog', 'score': 98}]
sorted_by_score = sorted(stu, key=itemgetter("score"))
print(sorted_by_score)
# 根据key"score"对应的value 对stu逆序排序
[{'id': 4, 'name': 'Dog', 'score': 98},
{'id': 3, 'name': 'Tom', 'score': 82},
{'id': 1, 'name': 'Pig', 'score': 82},
{'id': 2, 'name': 'Jerry', 'score': 67}]
sorted_by_score_rev = sorted(stu, key=itemgetter("score"), reverse=True)
print(sorted_by_score_rev)
# 根据key"score"和"id" 对stu正序排序(先根据"score"排序，"score"相同的情况下根据"id"排序)
[{'id': 2, 'name': 'Jerry', 'score': 67},
{'id': 1, 'name': 'Pig', 'score': 82},
{'id': 3, 'name': 'Tom', 'score': 82},
{'id': 4, 'name': 'Dog', 'score': 98}]
rows_by_score_id = sorted(stu, key=itemgetter("score", "id"))
print(rows_by_score_id)