字典
一、 可变类型与不可变类型
- 序列是以连续的整数为索引，与此不同的是，字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值。
- 字典是 Python 唯一的一个 <u>映射类型</u>，字符串、元组、列表属于<u>序列类型</u>。
那么如何快速判断一个数据类型 X 是不是可变类型的呢？两种方法：
- 麻烦方法：用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id，如果不一样，则 X 不可变，如果一样，则 X 可变。
- 便捷方法：用 hash(X)，只要不报错，证明 X 可被哈希，即不可变，反过来不可被哈希，即可变。
【例子】
i = 1
print(id(i)) # 140732167000896
i = i + 2
print(id(i)) # 140732167000960
l = [1, 2]
print(id(l)) # 4300825160
l.append('Python')
print(id(l)) # 4300825160
这段代码演示了变量和列表对象的内存地址的变化。
首先，我们定义了一个整数变量 i，并给它赋值为 1。然后，我们使用 print(id(i)) 打印了变量 i 的内存地址，得到的结果是 140732167000896。这是 i 对象在内存中的唯一标识。
接下来，我们执行 i = i + 2，将 i 的值增加 2。这实际上是创建了一个新的整数对象，并将其赋值给 i。因为整数是不可变类型，所以当我们修改 i 的值时，实际上是创建了一个新的对象，而原来的对象被丢弃。所以，打印 id(i) 的结果变为 140732167000960，与之前的内存地址不同。
然后，我们定义了一个列表 l，包含了数字 1 和 2。我们使用 print(id(l)) 打印了列表 l 的内存地址，得到的结果是 4300825160。这也是 l 对象在内存中的唯一标识。
最后，我们执行 l.append('Python')，将字符串 'Python' 添加到列表 l 中。由于列表是可变类型，所以在此操作中，只是在现有的列表对象中添加了一个新元素，并没有创建新的对象。因此，打印 id(l) 的结果仍然是 4300825160，与之前的内存地址相同。
- 整数
i在加 1 之后的id和之前不一样，因此加完之后的这个i(虽然名字没变)，但不是加之前的那个i了，因此整数是不可变类型。 - 列表
l在附加'Python'之后的id和之前一样，因此列表是可变类型。
【例子】
print(hash('Name')) # 7047218704141848153
print(hash((1, 2, 'Python'))) # 1704535747474881831
print(hash([1, 2, 'Python']))
# TypeError: unhashable type: 'list'
>>> print(hash([1, 2, 'Python']))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>>
这段代码演示了使用 hash() 函数计算不同对象的哈希值。
首先，我们使用 hash('Name') 计算字符串 'Name' 的哈希值。哈希值是根据对象的内容计算出来的唯一标识。在这个例子中，计算得到的结果是 7047218704141848153。
接下来，我们使用 hash((1, 2, 'Python')) 计算元组 (1, 2, 'Python') 的哈希值。元组是不可变类型，因此可以被作为字典的键或者集合的元素，并且可以被哈希。在这个例子中，计算得到的结果是 1704535747474881831。
然而，当我们尝试使用 hash([1, 2, 'Python']) 计算列表 [1, 2, 'Python'] 的哈希值时，发生了 TypeError 错误。列表是可变类型，它的内容可以随时修改，因此不具备哈希的特性。所以，尝试对列表进行哈希操作会抛出错误，提示类型不可哈希（unhashable type）。要注意的是，由于列表是可变的，它们本身不适合用作字典的键或者集合的元素。
print(hash({1, 2, 3}))
# TypeError: unhashable type: 'set'
在你的代码中，当你尝试计算集合 {1, 2, 3} 的哈希值时，抛出了 TypeError 错误。
集合是一种可变类型，它的元素可以随时添加、删除或修改，因此不具备哈希的特性。在Python中，只有不可变类型的对象才能作为可哈希的对象，例如整数、字符串和元组等。所以，当你尝试对集合进行哈希操作时，会抛出 TypeError 错误，提示该类型不可哈希（unhashable type）。
如果你需要对集合进行哈希操作，一种方法是将集合转换为元组，然后再计算哈希值，例如 hash(tuple({1, 2, 3}))。这样会创建一个元组对象，其中包含集合的所有元素，并且元组是不可变的，可以被哈希。但是需要注意的是，由于集合是无序的，不同顺序的元素会得到不同的哈希值。
- 数值、字符和元组 都能被哈希，因此它们是不可变类型。
- 列表、集合、字典不能被哈希，因此它是可变类型。
二、 字典的定义
字典 是无序的 键:值（key:value）对集合，键必须是互不相同的（在同一个字典之内）。
- dict 内部存放的顺序和 key 放入的顺序是没有关系的。
- dict 查找和插入的速度极快，不会随着 key 的增加而增加，但是需要占用大量的内存。
字典 定义语法为 {元素1, 元素2, ..., 元素n}
- 其中每一个元素是一个「键值对」-- 键:值 (
key:value) - 关键点是「大括号 {}」,「逗号 ,」和「冒号 :」
- 大括号 -- 把所有元素绑在一起
- 逗号 -- 将每个键值对分开
- 冒号 -- 将键和值分开
三、 创建和访问字典
【例子】
brand = ['李宁', '耐克', '阿迪达斯']
slogan = ['一切皆有可能', 'Just do it', 'Impossible is nothing']
print('耐克的口号是:', slogan[brand.index('耐克')])
# 耐克的口号是: Just do it
dic = {'李宁': '一切皆有可能', '耐克': 'Just do it', '阿迪达斯': 'Impossible is nothing'}
print('耐克的口号是:', dic['耐克'])
# 耐克的口号是: Just do it
你的代码展示了两种不同的方式获取品牌口号。
首先，你定义了一个品牌列表 brand，其中包含了几个品牌名称。另外，你定义了一个口号列表 slogan，其中存储了对应品牌的口号。通过使用 brand.index('耐克')，你获取到品牌名 '耐克' 在列表中的索引，然后使用该索引来获取对应口号 slogan[brand.index('耐克')]。最终输出结果为 '耐克的口号是: Just do it'。这种方法适用于已知品牌在列表中的情况。
接下来，你创建了一个字典 dic，其中键为品牌名称，值为对应的口号。通过直接使用品牌名作为键来获取对应口号，例如 dic['耐克']，可以得到结果 '耐克的口号是: Just do it'。这种方法适用于通过品牌名直接获取口号的情况，并且具有更好的性能，因为字典的查找操作时间复杂度为 O(1)。
两种方式都能达到相同的目的，具体使用哪种方式取决于代码的需求和数据结构的选择。
通过字符串或数值作为key来创建字典。
【例子】
dic1 = {1: 'one', 2: 'two', 3: 'three'}
print(dic1) # {1: 'one', 2: 'two', 3: 'three'}
print(dic1[1]) # one
print(dic1[4]) # KeyError: 4
你的代码演示了对字典进行操作的一些情况。
首先，你创建了一个字典 dic1，其中包含了几个键值对。通过 print(dic1)，你输出了整个字典的内容 {1: 'one', 2: 'two', 3: 'three'}。
接下来，你使用 dic1[1] 来获取键为 1 的值，即字典中键 1 对应的值 'one'。通过该操作，输出结果为 'one'。
然而，当你尝试通过 dic1[4] 获取键为 4 的值时，发生了 KeyError 错误。这是因为字典中并不存在键为 4 的键值对，所以无法返回对应的值。当我们使用一个不存在的键来访问字典时，Python会抛出 KeyError 错误。
要避免 KeyError 错误，可以使用 dic1.get(4) 方法来获取键为 4 的值。如果该键不存在，将返回 None 或者可选的默认值。例如，你可以使用 dic1.get(4, 'Not Found') 来获取键为 4 的值，如果该键不存在，则返回 'Not Found'。
print(dic1.get(4)) # None
print(dic1.get(4, 'Not Found')) # Not Found
这样可以确保在字典中不存在指定键时不会引发错误。
dic2 = {'rice': 35, 'wheat': 101, 'corn': 67}
print(dic2) # {'wheat': 101, 'corn': 67, 'rice': 35}
print(dic2['rice']) # 35
你的代码展示了对字典 dic2 进行操作的一些情况。
首先，你创建了一个字典 dic2，其中包含了三个键值对。通过 print(dic2)，你输出了整个字典的内容，注意字典是无序的，所以输出结果可能会有所不同，例如 { 'wheat': 101, 'corn': 67, 'rice': 35 }。
接下来，你使用 dic2['rice'] 来获取键为 'rice' 的值，即字典中键 'rice' 对应的值 35。通过该操作，输出结果为 35。
字典是 Python 中常用的数据结构，它是一个键值对的集合，可以通过键来查找对应的值。字典中的键是唯一的，可以是字符串、整数、元组等不可变类型，但不能是列表、字典等可变类型。
需要注意的是，当使用不存在的键来访问字典时，将会引发 KeyError 错误。如果希望避免该错误，可以使用 dic2.get(key) 方法，它会返回键 key 对应的值，如果键不存在则返回 None。
print(dic2.get('nonexistent')) # None
另外，字典还提供了其他方法来操作和获取字典中的键值对，如 keys()、values() 和 items() 方法。这些方法可以分别返回字典中的键、值和键值对的视图，可以使用 list() 函数将其转换为列表。
keys = list(dic2.keys()) # 返回所有的键
values = list(dic2.values()) # 返回所有的值
items = list(dic2.items()) # 返回所有的键值对
print(keys) # ['wheat', 'corn', 'rice']
print(values) # [101, 67, 35]
print(items) # [('wheat', 101), ('corn', 67), ('rice', 35)]
注意：如果我们取的键在字典中不存在，会直接报错KeyError。
通过元组作为key来创建字典，但一般不这样使用。
【例子】
dic = {(1, 2, 3): "Tom", "Age": 12, 3: [3, 5, 7]}
print(dic) # {(1, 2, 3): 'Tom', 'Age': 12, 3: [3, 5, 7]}
print(type(dic)) # <class 'dict'>
你的代码展示了一个字典 dic 的创建和使用。
首先，你创建了一个字典 dic，其中包含了三个键值对。通过 print(dic)，你输出了整个字典的内容 {(1, 2, 3): 'Tom', 'Age': 12, 3: [3, 5, 7]}。该字典中包含了不同类型的键和值，例如元组 (1, 2, 3) 对应值 'Tom'，字符串 'Age' 对应值 12，整数 3 对应值 [3, 5, 7]。
接下来，你使用 type(dic) 来获取字典 dic 的类型，即判断它是哪种数据类型。通过该操作，输出结果为 <class 'dict'>，表示 dic 是一个字典类型的对象。
字典是 Python 中常用的数据结构，它是一个无序的键值对集合，可以根据键来查找对应的值。字典中的键是唯一的，并且必须是不可变类型（如字符串、数字或元组）。字典中的值可以是任意类型，包括字符串、数字、列表、字典等。
需要注意的是，字典是可变的，这意味着可以添加、修改或删除字典中的键值对。
通过构造函数dict来创建字典。
- dict() 创建一个空的字典。
【例子】通过key直接把数据放入字典中，但一个key只能对应一个value，多次对一个key放入 value，后面的值会把前面的值冲掉。
dic = dict()
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3
print(dic)
# {'a': 1, 'b': 2, 'c': 3}
dic['a'] = 11
print(dic)
# {'a': 11, 'b': 2, 'c': 3}
dic['d'] = 4
print(dic)
# {'a': 11, 'b': 2, 'c': 3, 'd': 4}
-
dict(mapping)new dictionary initialized from a mapping object's (key, value) pairs
- dict(mapping) 从映射对象的（键，值）对初始化的新字典
【例子】
dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
print(dic1) # {'cherry': 4098, 'apple': 4139, 'peach': 4127}
dic2 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2) # {'peach': 4127, 'cherry': 4098, 'apple': 4139}
以上代码展示了两种创建字典的方法，它们都使用了键值对的形式来初始化字典。
首先，使用了 dict() 函数和一个由元组组成的列表来创建了一个字典 dic1。通过 print(dic1)，你输出了字典的内容 { 'apple': 4139, 'peach': 4127, 'cherry': 4098 }。注意字典是无序的，所以输出结果的顺序可能会有所不同。
其次，使用了 dict() 函数和一个由元组组成的元组来创建了另一个字典 dic2。通过 print(dic2)，你输出了字典的内容 { 'peach': 4127, 'cherry': 4098, 'apple': 4139 }。同样地，字典是无序的，所以输出结果的顺序可能会有所不同。
这两种方法都是常见的创建字典的方式。第一种方法使用列表中的元组作为参数，每个元组包含一个键和一个值。第二种方法使用元组中的元组作为参数，每个元组也包含一个键和一个值。
需要注意的是，由于字典是无序的，所以输出结果的键值对的顺序可能不同于你在代码中初始化字典时的顺序。
-
dict(**kwargs)-> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)
- dict(**kwargs) -> 使用关键字参数列表中的name=value对初始化的新字典。例如：dict（one=1，two=2）
【例子】这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上就会直接报语法错误。
dic = dict(name='Tom', age=10)
print(dic) # {'name': 'Tom', 'age': 10}
print(type(dic)) # <class 'dict'>
代码展示了另一种创建字典的方式。
使用了 dict() 函数和关键字参数来创建了一个字典 dic。通过 print(dic)，你输出了字典的内容 { 'name': 'Tom', 'age': 10 }。该字典中包含了两个键值对，键分别是 'name' 和 'age'，对应的值分别是 'Tom' 和 10。
通过 print(type(dic))，你输出了字典 dic 的类型，即判断它是哪种数据类型。输出结果为 <class 'dict'>，表示 dic 是一个字典类型的对象。
这种创建字典的方式利用关键字参数简洁地定义了键和对应的值。在创建字典时，你可以直接指定键和值的名称，并使用等号将它们关联起来。
需要注意的是，字典是无序的，所以输出结果的顺序可能会有所不同。
四、 字典的内置方法
- dict.fromkeys(seq[, value]) 用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
【例子】
seq = ('name', 'age', 'sex')
dic1 = dict.fromkeys(seq)
print(dic1)
# {'name': None, 'age': None, 'sex': None}
dic2 = dict.fromkeys(seq, 10)
print(dic2)
# {'name': 10, 'age': 10, 'sex': 10}
dic3 = dict.fromkeys(seq, ('小马', '8', '男'))
print(dic3)
# {'name': ('小马', '8', '男'), 'age': ('小马', '8', '男'), 'sex': ('小马', '8', '男')}
代码展示了使用 dict.fromkeys() 方法创建字典的过程。
首先，你定义了一个元组 seq，包含了三个元素 'name'、'age' 和 'sex'。
接下来，通过调用 dict.fromkeys(seq) 方法，你创建了一个新的字典 dic1。该方法会使用 seq 中的元素作为字典的键，而对应的值都被设置为 None。通过 print(dic1)，你输出了字典 dic1 的内容：{'name': None, 'age': None, 'sex': None}。
然后，你通过调用 dict.fromkeys(seq, 10) 方法，创建了另一个新的字典 dic2。该方法会使用 seq 中的元素作为字典的键，而对应的值都被设置为指定的值 10。通过 print(dic2)，你输出了字典 dic2 的内容：{'name': 10, 'age': 10, 'sex': 10}。
最后，你通过调用 dict.fromkeys(seq, ('小马', '8', '男')) 方法，创建了第三个字典 dic3。该方法会使用 seq 中的元素作为字典的键，而对应的值都被设置为指定的元组 ('小马', '8', '男')。通过 print(dic3)，你输出了字典 dic3 的内容：{'name': ('小马', '8', '男'), 'age': ('小马', '8', '男'), 'sex': ('小马', '8', '男')}。
这种使用 dict.fromkeys() 方法创建字典的方式可以快速地生成具有相同默认值的字典。
- dict.keys()返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键。
【例子】
dic = {'Name': 'lsgogroup', 'Age': 7}
print(dic.keys()) # dict_keys(['Name', 'Age'])
lst = list(dic.keys()) # 转换为列表
print(lst) # ['Name', 'Age']
代码展示了如何获取字典中所有的键，并将其转换为列表格式。
首先，你定义了一个字典 dic，其中包含两个键值对：'Name': 'lsgogroup' 和 'Age': 7。
通过调用 dic.keys() 方法，你可以获取字典中所有的键。使用 print(dic.keys()) 输出结果为 dict_keys(['Name', 'Age'])，这是一个字典视图对象，表示字典中所有的键。
接下来，你想将字典中的键转换为列表格式。使用 list() 函数，你将字典视图对象转换为列表。具体而言，你调用 list(dic.keys()) 将字典的键转换为列表，并将结果赋值给变量 lst。
最后，通过 print(lst)，你输出了列表 lst 的内容。输出结果为 ['Name', 'Age']，表示转换后的列表包含了字典中的所有键。
这种方式可以方便地将字典中的键转换为列表，便于进一步处理或操作。
- dict.values()返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
【例子】
dic = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print(dic.values())
# dict_values(['female', 7, 'Zara'])
print(list(dic.values()))
# [7, 'female', 'Zara']
代码展示了如何获取字典中所有的值，并将其转换为列表格式。
首先，你定义了一个字典 dic，其中包含三个键值对：'Sex': 'female'、'Age': 7 和 'Name': 'Zara'。
通过调用 dic.values() 方法，你可以获取字典中所有的值。使用 print(dic.values()) 输出结果为 dict_values(['female', 7, 'Zara'])，这是一个字典视图对象，表示字典中所有的值。
接下来，你想将字典中的值转换为列表格式。使用 list() 函数，你将字典视图对象转换为列表。具体而言，你调用 list(dic.values()) 将字典的值转换为列表，并将结果赋值给变量 lst。
最后，通过 print(lst)，你输出了列表 lst 的内容。输出结果为 [7, 'female', 'Zara']，表示转换后的列表包含了字典中的所有值。
这种方式可以方便地将字典中的值转换为列表，便于进一步处理或操作。
- dict.items()以列表返回可遍历的 (键, 值) 元组数组。
【例子】
dic = {'Name': 'Lsgogroup', 'Age': 7}
print(dic.items())
# dict_items([('Name', 'Lsgogroup'), ('Age', 7)])
print(tuple(dic.items()))
# (('Name', 'Lsgogroup'), ('Age', 7))
print(list(dic.items()))
# [('Name', 'Lsgogroup'), ('Age', 7)]
代码展示了如何获取字典中所有的键值对，并将其转换为不同格式。
首先，你定义了一个字典 dic，其中包含两个键值对：'Name': 'Lsgogroup' 和 'Age': 7。
通过调用 dic.items() 方法，你可以获取字典中所有的键值对。使用 print(dic.items()) 输出结果为 dict_items([('Name', 'Lsgogroup'), ('Age', 7)])，这是一个字典视图对象，表示字典中所有的键值对。
接下来，你想将字典中的键值对转换为元组格式。使用 tuple() 函数，你将字典视图对象转换为元组。具体而言，你调用 tuple(dic.items()) 将字典的键值对转换为元组，并将结果输出。
然后，你又想将字典中的键值对转换为列表格式。使用 list() 函数，你将字典视图对象转换为列表。具体而言，你调用 list(dic.items()) 将字典的键值对转换为列表，并将结果输出。
通过以上操作，你得到了三种不同格式的表示字典键值对的结果：
- 使用
dic.items()输出的字典视图对象。 - 使用
tuple(dic.items())输出的元组，即(('Name', 'Lsgogroup'), ('Age', 7))。 - 使用
list(dic.items())输出的列表，即[('Name', 'Lsgogroup'), ('Age', 7)]。
这些转换的方式可以根据需要选择不同的数据结构来表示字典的键值对。
- dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回默认值。
【例子】
dic = {'Name': 'Lsgogroup', 'Age': 27}
print("Age 值为 : %s" % dic.get('Age')) # Age 值为 : 27
print("Sex 值为 : %s" % dic.get('Sex', "NA")) # Sex 值为 : NA
print(dic) # {'Name': 'Lsgogroup', 'Age': 27}
代码展示了如何使用字典的 get() 方法获取指定键的值，并在键不存在时提供默认值。
首先，你定义了一个字典 dic，其中包含两个键值对：'Name': 'Lsgogroup' 和 'Age': 27。
通过使用 dic.get('Age')，你可以获取键 'Age' 对应的值。这里使用了格式化字符串 %s 来输出结果。使用 print("Age 值为 : %s" % dic.get('Age')) 输出结果为 Age 值为 : 27，表示字典中 'Age' 对应的值是 27。
接下来，你想获取键 'Sex' 对应的值，但是该键在字典中不存在。为了避免出现键不存在时的错误，你在 get() 方法中提供了一个默认值 'NA'。使用 print("Sex 值为 : %s" % dic.get('Sex', "NA")) 输出结果为 Sex 值为 : NA，表示字典中不存在键 'Sex'，所以返回了默认值 'NA'。
最后，你通过 print(dic) 输出了完整的字典内容。输出结果为 {'Name': 'Lsgogroup', 'Age': 27}，即包含了原始的键值对。
使用 get() 方法可以安全地获取字典中的值，并且在键不存在时提供默认值，避免了 KeyError 异常的发生。
- dict.setdefault(key, default=None)和get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
【例子】
dic = {'Name': 'Lsgogroup', 'Age': 7}
print("Age 键的值为 : %s" % dic.setdefault('Age', None)) # Age 键的值为 : 7
print("Sex 键的值为 : %s" % dic.setdefault('Sex', None)) # Sex 键的值为 : None
print(dic)
# {'Age': 7, 'Name': 'Lsgogroup', 'Sex': None}
代码展示了如何使用字典的 setdefault() 方法获取指定键的值，并在键不存在时设置默认值。
首先，你定义了一个字典 dic，其中包含两个键值对：'Name': 'Lsgogroup' 和 'Age': 7。
通过使用 dic.setdefault('Age', None)，你可以获取键 'Age' 对应的值。在这种情况下，由于字典中已经存在键 'Age'，所以返回了该键对应的值 7。使用格式化字符串 %s 来输出结果，即 print("Age 键的值为 : %s" % dic.setdefault('Age', None))，输出结果为 Age 键的值为 : 7。
接下来，你想获取键 'Sex' 对应的值，但是该键在字典中不存在。为了避免出现键不存在时的错误，你使用 setdefault('Sex', None) 方法来设置默认值为 None 并获取该键对应的值。由于键 'Sex' 在字典中不存在，所以返回了默认值 None。使用格式化字符串 %s 来输出结果，即 print("Sex 键的值为 : %s" % dic.setdefault('Sex', None))，输出结果为 Sex 键的值为 : None。
最后，你通过 print(dic) 输出了完整的字典内容。输出结果为 {'Age': 7, 'Name': 'Lsgogroup', 'Sex': None}，可以看到字典中包含了原始的键值对，并且新添加了键 'Sex'，其值为 None。
使用 setdefault() 方法可以方便地获取字典中指定键的值，并在键不存在时设置默认值。如果键已经存在，则返回对应的值；如果键不存在，则将键和默认值添加到字典中。
- key in dict in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回true，否则返回false。而not in操作符刚好相反，如果键在字典 dict 里返回false，否则返回true。
【例子】
dic = {'Name': 'Lsgogroup', 'Age': 7}
# in 检测键 Age 是否存在
if 'Age' in dic:
print("键 Age 存在")
else:
print("键 Age 不存在")
# 检测键 Sex 是否存在
if 'Sex' in dic:
print("键 Sex 存在")
else:
print("键 Sex 不存在")
# not in 检测键 Age 是否存在
if 'Age' not in dic:
print("键 Age 不存在")
else:
print("键 Age 存在")
# 键 Age 存在
# 键 Sex 不存在
# 键 Age 存在
代码展示了如何使用 in 和 not in 操作符检测字典中是否存在指定键。
首先，你定义了一个字典 dic，其中包含两个键值对：'Name': 'Lsgogroup' 和 'Age': 7。
通过使用 if 'Age' in dic:，你检测字典中是否存在键 'Age'。由于该键存在于字典中，所以输出结果为 "键 Age 存在"。
接下来，你使用 if 'Sex' in dic: 检测字典中是否存在键 'Sex'。由于该键不存在于字典中，所以输出结果为 "键 Sex 不存在"。
然后，你使用 if 'Age' not in dic: 检测字典中是否不存在键 'Age'。由于该键存在于字典中，所以输出结果为 "键 Age 存在"。
最后，根据检测的结果输出相应的信息。
使用 in 操作符可以方便地检测字典中是否存在指定键。如果键存在，则返回 True；如果键不存在，则返回 False。而 not in 操作符则是其反义操作。
- dict.pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出。若key不存在，则返回 default 值。
- del dict[key] 删除字典给定键 key 所对应的值。
【例子】
dic1 = {1: "a", 2: [1, 2]}
print(dic1.pop(1), dic1) # a {2: [1, 2]}
# 设置默认值，必须添加，否则报错
print(dic1.pop(3, "nokey"), dic1) # nokey {2: [1, 2]}
del dic1[2]
print(dic1) # {}
代码展示了如何使用 pop() 方法删除字典中的键值对，并在键不存在时设置默认值。
首先，你定义了一个字典 dic1，其中包含两个键值对：1: "a" 和 2: [1, 2]。
通过使用 dic1.pop(1)，你删除了字典中键为 1 的键值对，并返回了该键对应的值 "a"。同时，你打印出了删除后的字典内容，即 {2: [1, 2]}。
接下来，你使用 dic1.pop(3, "nokey") 来删除键为 3 的键值对，并设置默认值为 "nokey"。由于键 3 在字典中不存在，所以返回了默认值 "nokey"。同时，你打印出了删除后的字典内容，即 {2: [1, 2]}。
然后，你使用 del dic1[2] 删除了字典中键为 2 的键值对。最后，你打印出了删除后的字典内容，即 {}，表示字典已经为空。
使用 pop() 方法可以删除字典中指定键的键值对，并返回该键对应的值。如果键不存在于字典中，则可以通过设置默认值来避免报错。
- dict.popitem()随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常。
【例子】
dic1 = {1: "a", 2: [1, 2]}
print(dic1.popitem()) # {2: [1, 2]}
print(dic1) # (1, 'a')
代码展示了如何使用 popitem() 方法删除并返回字典中的一个键值对。
首先，你定义了一个字典 dic1，其中包含两个键值对：1: "a" 和 2: [1, 2]。
通过使用 dic1.popitem()，你从字典中删除并返回一个键值对。由于字典是无序的，具体删除的是哪个键值对是不确定的。在这个例子中，输出结果为 {2: [1, 2]}，表示删除并返回了键为 2，值为 [1, 2] 的这个键值对。
然后，你打印出了删除后的字典内容，即 (1, 'a')，表示字典中剩下了键为 1，值为 'a' 的这个键值对。
使用 popitem() 方法可以随机删除并返回字典中的一个键值对。由于字典是无序的，所以具体删除的键值对是不确定的。
- dict.clear()用于删除字典内所有元素。
【例子】
dic = {'Name': 'Zara', 'Age': 7}
print("字典长度 : %d" % len(dic)) # 字典长度 : 2
dic.clear()
print("字典删除后长度 : %d" % len(dic))
# 字典删除后长度 : 0
代码展示了如何使用 len() 函数获取字典的长度，并使用 clear() 方法清空字典。
首先，你定义了一个字典 dic，其中包含两个键值对：'Name': 'Zara' 和 'Age': 7。
通过使用 len(dic)，你获取了字典的长度，并使用 %d 格式化字符串将长度值插入到输出语句中。输出结果为 "字典长度 : 2"，表示字典中有两个键值对。
接下来，你使用 dic.clear() 清空了字典，即删除了字典中的所有键值对。
然后，你再次使用 len(dic) 获取字典的长度，并使用 %d 格式化字符串将长度值插入到输出语句中。由于字典已经被清空，所以输出结果为 "字典删除后长度 : 0"，表示字典的长度为0。
使用 len() 函数可以获取字典中键值对的个数，即字典的长度。而 clear() 方法可以清空字典，删除其中的所有键值对。
- dict.copy()返回一个字典的浅复制。
【例子】
dic1 = {'Name': 'Lsgogroup', 'Age': 7, 'Class': 'First'}
dic2 = dic1.copy()
print("dic2")
# {'Age': 7, 'Name': 'Lsgogroup', 'Class': 'First'}
代码展示了如何使用 copy() 方法复制一个字典。
首先，你定义了一个字典 dic1，其中包含三个键值对：'Name': 'Lsgogroup'、'Age': 7 和 'Class': 'First'。
通过使用 dic1.copy()，你创建了字典 dic2，它是 dic1 的一个副本。copy() 方法会复制字典中的所有键值对，并返回一个新的字典。将 dic2 打印出来，输出结果为 {'Age': 7, 'Name': 'Lsgogroup', 'Class': 'First'}，表示成功复制了字典。
注意，dic2 中键值对的顺序与 dic1 中的不一定相同，因为字典是无序的。
使用 copy() 方法可以复制一个字典，以便在需要的场景下进行备份或修改操作，而不影响原始字典。
直接赋值和 copy 的区别
【例子】
dic1 = {'user': 'lsgogroup', 'num': [1, 2, 3]}
# 引用对象
dic2 = dic1
# 浅拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
dic3 = dic1.copy()
print(id(dic1)) # 148635574728
print(id(dic2)) # 148635574728
print(id(dic3)) # 148635574344
# 修改 data 数据
dic1['user'] = 'root'
dic1['num'].remove(1)
# 输出结果
print(dic1) # {'user': 'root', 'num': [2, 3]}
print(dic2) # {'user': 'root', 'num': [2, 3]}
print(dic3) # {'user': 'runoob', 'num': [2, 3]}
代码展示了字典的引用和浅拷贝的概念。
首先，你定义了一个字典 dic1，其中包含两个键值对：'user': 'lsgogroup' 和 'num': [1, 2, 3]。
然后，你创建了 dic2 = dic1，这是一个引用对象的操作。也就是说，dic2 和 dic1 引用同一个字典对象。
接着，你使用浅拷贝的方式创建了 dic3 = dic1.copy()。这意味着 dic3 是 dic1 的一个副本，但是副本中的子对象还是引用，不进行拷贝。
通过打印 id(dic1)、id(dic2) 和 id(dic3)，你可以看到它们的内存地址。由于 dic2 是 dic1 的引用，所以它们的内存地址是相同的（148635574728）。而 dic3 是 dic1 的浅拷贝，所以它的内存地址与 dic1 不同（148635574344）。
接下来，你修改了 dic1 中的数据，将 'user' 的值改为 'root'，并从 'num' 列表中移除了元素 1。
最后，你分别打印了 dic1、dic2 和 dic3 的内容。输出结果为：
{'user': 'root', 'num': [2, 3]}
{'user': 'root', 'num': [2, 3]}
{'user': 'lsgogroup', 'num': [2, 3]}
可以发现，dic1 和 dic2 的内容都发生了变化，这是因为它们引用同一个字典对象。而 dic3 的内容没有发生变化，因为它是 dic1 的副本，对 dic1 的修改不影响 dic3。
需要注意的是，由于浅拷贝仅复制了一级目录，子对象仍然是引用，所以对子对象的修改会在所有复制中体现出来。
- dict.update(dict2)把字典参数 dict2 的 key:value对 更新到字典 dict 里。
【例子】
dic = {'Name': 'Lsgogroup', 'Age': 7}
dic2 = {'Sex': 'female', 'Age': 8}
dic.update(dic2)
print(dic)
# {'Sex': 'female', 'Age': 8, 'Name': 'Lsgogroup'}
代码展示了如何使用 update() 方法将一个字典添加到另一个字典中。
首先，你定义了两个字典 dic 和 dic2。dic 包含两个键值对：'Name': 'Lsgogroup' 和 'Age': 7，dic2 包含两个键值对：'Sex': 'female' 和 'Age': 8。
通过使用 dic.update(dic2)，你将 dic2 的内容添加到了 dic 中。update() 方法会将传入的字典的键值对添加到调用方法的字典中。如果有相同的键，那么新的值将覆盖原有的值。
最后，你打印了 dic 的内容，输出结果为 {'Sex': 'female', 'Age': 8, 'Name': 'Lsgogroup'}，表示成功将 dic2 添加到了 dic 中。
注意，在执行 update() 方法后，dic 发生了改变，所以 dic2 的内容不受影响。
