Python 字典（详解）

字典是由大括号构成的{}：

字典的特点:

由键值对组成:键(key),值(value),键与值之间用":"分割,对于对之间用","分割,键:相当于元组,不可改变,不可以重复,值可以改变,也可以重复,部分可以切片

字典的内置函数:

clear(), copy(), fromkeys(), get(), items(), keys(), pop(), popitem(), setdefault(), update(), values()

字典的创建：

#创建字典
list = { "a":1,"b":"123","c":3.14}
print(list["a"])
list = dict(key1='value1', key2='value2')
my_dict = dict([('key1', 'value1'), ('key2', 'value2')])
print(my_dict)
red = my_dict.keys()
print(red)

字典：外部由大括号构成，字典名={}，大括号里面由键值对构成：{key:value}={'name'='小牛'，'age'=18}，key：键名，value：值，！注，在同一个字典中，key必须是唯一的（元组）元组的特性就是不能被改变，value可以改变，两个键值对之间用，隔开。

创建字典有两个方式：第一种是直接创建

字典里面的键key，必须用引号引起来

# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}

第二种就是用dict（）来创建

my_dict = dict([('key1', 'value1'), ('key2', 'value2')])
print(my_dict)

字典的一些便利：

接下来就到了字典的一些用法了，在这之前，我觉得需要先将字典的一些比较方便的特点分享一下

第一：方便存储数据：它可以用于表示各种复杂的关联数据。比如在一个游戏角色属性管理的程序中，用字典来存储游戏角色的各种属性。

character_attributes = 
{  
   '角色1': 
       {'力量': 100, '敏捷': 80, '智力': 90}, 
   '角色2': 
       {'力量': 90, '敏捷': 95, '智力': 85}
}

这里的字典结构能够很好地体现不同角色与其属性之间的对应关系，方便对游戏角色属性进行修改、查询等操作。

第二：快速查找：字典中的键是唯一的，通过键来查找值的速度非常快。eg：有一个存储城市名称和对应的城市代码的字典

city_codes = {'北京': '010', '上海': '021', '广州': '020'}，

当需要查找某个城市的代码时，像city_codes['北京']这样的操作就能快速返回对应的代码，这比在列表等其他数据结构中进行查找要高效得多。

第三：灵活访问数据：可以根据具体的需求访问字典中的部分数据。例如，在一个包含产品信息（产品 ID、名称、价格、库存）的字典

product_info = {'id': 'P001', 'name': '手机', 'price': 3000, 'stock': 100}

中，如果只关心产品价格，可以直接通过product_info['price']获取价格信息，而不需要处理其他无关的数据。

字典的增删改查:

增加：

字典名{新键}=新值

my_data = {'name':'小牛'}
print(my_data)
# 增加新元素
my_data['age']=18
print(my_data)

updata（）方法实例：

my_dict = {'a': 1, 'b': 2, 'c': 3}  #创建一个字典
my_data = {'d':4}

print(my_dict)

my_dict.update(my_data)

print(my_dict)

输出结果：

删除:

del方法 , pop () , popitem(),clear()

del方法实例：

del是 Python 中的一个语句，用于删除对象。它的操作对象可以是变量、列表中的元素、字典中的键值对等多种数据结构中的元素。它的主要作用是从内存中删除指定的对象引用，从而释放资源或改变数据结构的内容。

基本语法：del 字典名[想删除的键名]，注意当''想删除的键名''不小心输出错误时，会报错哟

my_data={'name':'小牛','age':18}
print(my_data)     
del my_data['age'] #删除age
print(my_data)

有一个特殊的用法 _del_ 方法：

class MyClass:
    def __init__(self, name):
        self.name = name
        print(f"对象 {self.name} 被创建")

    def say_hello(self):
        print(f"Hello, I'm {self.name}")

    def __del__(self):
        print(f"对象 {self.name} 被销毁")


# 创建对象并调用方法
obj = MyClass("Instance 1")
obj.say_hello()
# 手动删除对象引用，促使垃圾回收（但不保证立刻执行析构）
del obj

注意哟！有一个叫做class的它是用来创建类的

提醒一下：class关键字在 Python 中开启了面向对象编程的大门，让开发者能够以更符合现实世界逻辑和更利于代码管理、复用的方式来编写程序。

输出结果为：

注意哟！__del__方法会被调用，从而关闭文件。不过需要注意的是，__del__方法的使用要谨慎，因为它的执行时间可能会受到 Python 垃圾回收机制的不确定性的影响。

pop()方法实例：

my_data={'name':'小牛','age':18}  #创建字典
print('字典：',my_data)           #打印字典，便于观察
print(my_data.pop('aga','空'))    # 引用pop函数将my_data中的'age'删除，如果没找到则返回'空'
                                  #并且打印输出
                                  #输出结果为空

print(my_data.pop('age','空'))    #打印输出结果为删除'age'=(key)，对应的值18=(value)

print(my_data)                    #最后打印输出字典，与刚开始做对比

基本功能：

  字典的pop方法用于移除指定键对应的键值对，并返回该键对应的值。例如，对于字典my_dict = {'a': 1, 'b': 2, 'c': 3}，执行my_dict.pop('b')会移除键为b的键值对，返回 2，此时my_dict变为{'a': 1, 'c': 3}。

默认行为与不存在键的处理：

  字典的pop方法可以接受第二个可选参数，这个参数是当要移除的键不存在时返回的值。例如，my_dict.pop('d', None)，如果键d不存在，就返回None，而不会引发错误。如果不提供这个默认值参数，当键不存在时会引发KeyError。

建议一般用pop()时要带上第二个可选参数，不然pop（）没有删除成功的话他是不会报错的，他只会将第二个可选参数输出，del是话如果没有删除成功是会报错的

输出结果：

看不懂输出结果的可以看一下：第一个打印的是原本的字典内的数据，第二个打印的是（因为pop（）函数在my_data中没找到要删除的键值对所有返回的’空‘（注意空是我自己定义的，可以看上方代码））第三个打印的是pop()函数删除成功并且返回该键对应的值，第四个打印的是删除后字典内的数据，便于我们观察！

pop（）应用的场景：

在字典中，pop方法可以用于清理不需要的数据或者根据某些条件更新字典。例如，在一个存储用户购物车信息的字典中，如果某个商品被用户移除，就可以使用pop方法将该商品对应的键值对从购物车字典中移除。同时，返回被移除商品的信息可以用于记录或者其他相关操作，比如统计商品被移除的数量等。

popitem()方法实例：

my_dict = {'a': 1, 'b': 2, 'c': 3}  #创建一个字典

last_item = my_dict.popitem()       #使用popitem方法将字典的最后一个键值对删除

print(last_item)                    #输出结果：('c', 3)，代表这是popitem（）删除的最后一个元素

print(my_dict)                      #输出结果：{'a': 1, 'b': 2}，删除成功！

popitem（）基本语法：字典名.popitem()

基本功能：

对于字典，popitem函数用于移除并返回字典中的一个键值对。它的操作方式是移除字典中的最后一个键值对。例如，有字典my_dict = {'a': 1, 'b': 2, 'c': 3}，执行my_dict.popitem()会返回('c', 3)，并且my_dict变为{'a': 1, 'b': 2}。

popitem()应用场景：

遍历并清理字典：在需要逐个移除并处理字典中的所有元素时很有用。例如，当要清空一个字典，同时对每个被移除的键值对进行一些操作（如记录到日志或进行数据清理），可以使用popitem。假设要清空一个存储用户临时数据的字典user_temp_data，并且将移除的数据保存到另一个字典removed_data中。

popitem（）与pop（）不同：

和pop函数不同的是，popitem是专门针对字典的键值对整体操作。例如，在一个简单的配置字典中，新添加的配置项可能会覆盖旧的配置项，但如果需要按照添加的逆序（即最后添加的先处理）来逐个移除并处理配置项，就可以使用popitem。

操作对象不同：

pop函数主要用于移除指定键对应的键值对，需要指定要移除的键作为参数；而popitem函数不需要指定键，它直接移除字典中的最后一个键值对（在有序字典中是最后插入的键值对）。

返回值不同：

pop函数返回指定键对应的单个值；而popitem函数返回一个包含键和值的元组。例如，对于字典my_dict = {'x': 10, 'y': 20}，my_dict.pop('x')返回 10，而my_dict.popitem()返回('y', 20)。

错误情况不同：

pop函数如果指定的键不存在，会根据是否提供默认值参数来决定是否引发KeyError；而popitem函数只有在字典为空时才会引发KeyError，因为它总是尝试移除字典中的最后一个键值对，当没有键值对可移除时就会出错。

对了有一个小总结：popitem（）是与pop（）不同的哟！不要混淆了，而且列表，元组，集合里面都没有popitem（）这个函数，所以popitem是字典特有的函数，它的设计是为了方便地处理字典这种键值对数据结构，以特定的方式（移除并返回最后一个键值对）来操作字典，在其他常见的 Python 基本数据结构中没有完全相同的函数。

输出结果为：

clear()方法实例：

my_data={'name':'小牛','age':18}  #创建字典

print(my_data)                    #打印字典，便于观察

my_data.clear()                   #clear()将my_data字典里面的元素全部删除

print(my_data)                    #打印，观察是否是空字典

clear（）的基本语法：字典名.clear（）

基本功能：清除字典中的所有键值对，使字典变为空字典。例如，对于字典my_dict = {'a': 1, 'b': 2, 'c': 3}，执行my_dict.clear()后，my_dict就变成{}。同样，这是对原字典对象的修改，而不是返回一个新的空字典。

应用场景：在需要重置字典内容的场景中很有用。比如，在一个用户登录系统中，用于存储用户登录信息的字典在用户登出时可以使用clear函数来清空，为下一次用户登录做准备。

需要注意的是！！！

与重新赋值空列表的区别：从功能结果上看，my_data = {}和my_data.clear()类似，都是让my_data变为空字典。但是，从内存和对象引用的角度有细微差别。my_data = {}实际上是重新创建了一个新的空字典对象，并让my_data这个变量指向这个新对象；而my_data.clear()是直接在原来的字典对象上进行操作，清除其中的元素，字典对象本身的内存地址没有改变。

输出结果：

修改：

增加的变相：因为当你的key（键）与原字典有同样的key（键）时，你的value（值）会将原来字典中的value（值）覆盖

字典名称[key] = value

my_dict = {'a': 1, 'b': 2, 'c': 3}  #创建一个字典

print(my_dict)                      #打印字典，便于观察

my_dict['a']=100                    #修改a的值为100

print(my_dict)                      #打印字典，查看是否修改成功

my_dict = {'a': 1, 'b': 2, 'c': 3}  #创建第一个字典
my_data = {'a':100}                 #创建第二个字典

print(my_dict)                      #打印字典

my_dict.update(my_data)             #将第二个字典赋值给第一个字典将其更新

print(my_dict)                      #打印字典，看是否重新赋值成功

查找：

直接通过键直接查找：

my_data = {'name':'小牛','age':18}     #创建一个字典

print(my_data['name'],my_data['age'])  #直接通过键查找，调用

输出结果：

基本原理：在字典中，可以直接使用键来查找对应的值。例如，对于字典my_dict = {'a': 1, 'b': 2, 'c': 3}，如果要查找键b对应的值，直接使用my_dict['b']，就可以得到 2。这种查找方式非常直接和高效，在平均情况下，时间复杂度接近 O (1)。

注意事项：如果查找的键不存在于字典中，会引发KeyError。例如，在上述字典中查找my_dict['d']会出错。为了避免这种情况，可以先使用in关键字检查键是否存在，如if 'd' in my_dict: print(my_dict['d'])，或者使用get方法。

通过get方法：

my_data = {'name':'小牛','age':18}    #创建一个字典

print(my_data.get('aaaa'))            #没找到，会默认输出第二个参数

print(my_data.get('aaaa','没找到'))    #没找到，会输入我们定义的第二个参数

print(my_data.get('name','没找到'))    #找到了，直接输出键对应的值

基本原理：get方法用于从字典中获取指定键的值。如果键存在，就返回对应的值；如果键不存在，返回None（可以通过第二个参数指定默认返回值）。例如，对于字典my_dict = {'a': 1, 'b': 2, 'c': 3}，my_dict.get('b')会返回 2，my_dict.get('d')会返回None。如果使用my_dict.get('d', '不存在')，则当键d不存在时，会返回不存在。

注意这个也可以与pop（）一起记哟，一个是删除，一个是查找，但是千万别搞混，而且还是有一些不同的地方的！

应用场景：在不确定键是否存在的情况下，get方法比直接使用键查找更安全。例如，在一个用户信息字典user_info = {'name': '张三', 'age': 20}中，当需要获取用户的联系方式，但不确定是否已经存储了联系方式这个键值对时，可以使用user_info.get('phone', '未记录')来避免出现KeyError，并得到合适的返回值。

输出结果：

keys.values和items方法（间接查找）

keys基本原理： 

keys方法用于返回一个可迭代对象，这个对象包含了字典中的所有键。这个可迭代对象的类型是dict_keys，它类似于一个集合，但可以用于迭代。例如，对于字典my_dict = {'a': 1, 'b': 2, 'c': 3}，当执行my_dict.keys()时，会返回一个类似dict_keys(['a', 'b', 'c'])的对象。

my_dict = {'a': 1, 'b': 2, 'c': 3}  #创建一个字典
keys_iter = my_dict.keys()          #将my_dict里的key放入keys_iter里面
if 'b' in keys_iter:                #判断keys_iter里面是否有b
    print("键 'b' 存在于字典中")     #有的话则输出，没有的话则不会输出

（小衍生）注意！有人想说如果我这样呢！

my_dict = {'a': 1, 'b': 2, 'c': 3}  #创建一个字典
keys_iter = my_dict.keys()          #将my_dict里的key放入keys_iter里面
print(keys_iter)

输出结果为：

为什么是这个样子呀？这样看的话有点像元组里面套了一个列表，还有为什么前面是dict_keys，我上面的代码明明没有定义这个呀！

解释！：

当在字典my_dict上调用keys方法时，它返回的是一个dict_keys类型的可迭代对象。这种返回值类型是 Python 字典专门用于表示键集合的一种视图。

与普通的列表不同，dict_keys是一种动态视图，它会实时反映字典中键的变化。例如，如果在获取keys视图后，向字典中添加或删除一个键，这个视图也会相应地更新。不过，它主要用于迭代和成员检查（如in操作符），而不是像列表那样支持索引访问等所有操作。

Python 选择以dict_keys(['a', 'b', 'c'])这种格式输出是为了清晰地表明返回值的类型（dict_keys）以及其中包含的内容（键的列表）。这样可以让开发者很容易区分它和其他数据类型，如普通的列表或元组。

同时，这种格式也暗示了它的一些特性，比如它是一个类似集合的可迭代对象（通过['a', 'b', 'c']部分展示了其中的元素），但又有其特殊的用途（由dict_keys类型标识），主要用于与字典的键相关的操作，如检查某个键是否存在于字典中、遍历字典的所有键等。

当然办法总比困难多，如果你觉的这个样子有点难绷，不要忘记有一个小办法哟！那就是list()

my_dict = {'a': 1, 'b': 2, 'c': 3}  #创建一个字典
keys_iter = my_dict.keys()          #将my_dict里的key放入keys_iter里面
new_keys_iter = list(my_dict.keys())#将他强行转化成list列表形式
print(new_keys_iter)                #打印观察

输出结果为：

接下来就是遍历了：用key()遍历的话，遍历出来的就是key咯，请看vcr！

my_dict = {'a': 1, 'b': 2, 'c': 3}  #创建一个字典
for key in my_dict.keys():          #将my_dict.keys()用for循环遍历
    print('键为：',key)             #打印

输出结果为：

接下来就到values()了

values()的基本原理：

values方法返回一个包含字典中所有值的可迭代对象，这个对象的类型是dict_values。例如，对于字典my_dict = {'a': 1, 'b': 2, 'c': 3}，my_dict.values()返回一个类似dict_values([1, 2, 3])的对象。

my_dict = {'a': 1, 'b': 2, 'c': 3}
values_iter = my_dict.values()
if 2 in values_iter:
    print("值2存在于字典中")

输出结果为：值2存在于字典中

当然与上文相同，我们直接输出my_dict.values试试看！

my_dict = {'a': 1, 'b': 2, 'c': 3}
values_iter = my_dict.values()
print(values_iter)

输出结果为：，果然！与keys（）相同！当然也是同样的解释！

values的遍历：

my_dict = {'a': 1, 'b': 2, 'c': 3}  #创建一个字典
for values in my_dict.values():     #将my_dict.values()用for循环遍历
    print('值为：',values)           #打印

输出结果为：

最后是items():

items()的基本原理：

items方法返回一个包含字典中所有键值对的可迭代对象，其中每个元素是一个元组（键，值）。这个对象的类型是dict_items。例如，对于字典my_dict = {'a': 1, 'b': 2, 'c': 3}，my_dict.items()返回一个类似dict_items([('a', 1), ('b', 2), ('c', 3)])的对象。

items()的遍历与查找：

my_dict = {'a': 1, 'b': 2, 'c': 3}
items_iter = my_dict.items()
for key, value in items_iter:
    print(f"键为 {key}，值为 {value}")
#输出结果为：
#键为 a，值为 1
#键为 b，值为 2
#键为 c，值为 3

user_info = {'user1': 20, 'user2': 25, 'user3': 30}
for key, value in user_info.items():
    if value > 25:
        print(f"{key}的年龄大于25")
# 输出结果为：
# user3的年龄大于25

最后写一个综合案例：通讯录管理系统 ：需求：开个⼀个通讯录的管理系统，主要⽤于实现存储班级中同学的信息（姓名、年龄、电话） 要求：正常情况下，通讯录管理系统应该有4个功能：增删改查

# 1、定义⼀个列表，将来⽤于存储所有学员的通讯信息
students = []
while True:
    # 2、打印功能菜单
    print('-' * 40)
    print('欢迎使⽤通讯录管理系统V1.0')
    print('[1] 增加学员信息')
    print('[2] 删除学员信息')
    print('[3] 退出系统')
    print('-' * 40)

    # 3、提示⽤户进⾏相关操作
    user_num = int(input('请输⼊您要进⾏的操作编号：'))
    if user_num == 1:
        # 4、提示⽤户输⼊学员的信息
        student = {}
        student['name'] = input('请输⼊学员的姓名：')
        student['age'] = int(input('请输⼊学员的年龄：'))
        student['mobile'] = input('请输⼊学员的电话：')
        # 5、把学员信息保存在列表中
        students.append(student)
        print(students)
    elif user_num == 2:
        name = input('请输⼊要删除的学员信息：')
        # 6、遍历所有学员信息
        for i in students:
            if i['name'] == name:
                # 从列表中删除整个学员（字典）
                students.remove(i)
                print('删除成功')
                print(students)
                break
        else:
            print('您要删除的学员信息不存在')
    elif user_num == 3:
        print('感谢您使⽤通讯录管理系统V1.0')
        break
    else:
        print('输⼊错误，请重新输⼊要操作的编号')