# 字典的基本特征
# 1. 键值对结构：{key: value}
# 2. 键必须是不可变类型（字符串、数字、元组）
# 3. 值可以是任意类型
# 4. Python 3.7+ 中字典保持插入顺序
# -----------------------------------------------
# 定义字典的方法# 方法1：使用花括号
alien_0 ={'color':'green','points':5}
person = {'name': '张三', 'age': 25, 'city': '北京'}
print(f"使用花括号创建字典：{person}")# 方法2：使用dict（）构造函数
person = dict(name='张三', age=25, city='北京')
print(f"使用dict()构造函数创建字典：{person}")# 方法3：通过键值对列表创建
person = dict([('name','张三'),('age',25),('city','北京')])
print(f"键值对列表创建字典：{person}")
# 使用字典推导式创建字典
squares = {x: x **2 for x in range(1,6)}
print(f"使用字典推导式创建字典：{squares}")# 空字典的定义
# -------------------------------------------------
# 使用花括号
empty_dict1 = {}
print(f"使用花括号构造空字典：{empty_dict1}")
# 使用dict()构造函数
empty_dict2 = dict()
print(f"使用构造函数构造空字典:{empty_dict2}")# 获取字典中的值
# -------------------------------------------------
# 方法1：直接通过键访问
print(alien_0['color'])
print(alien_0['points'])
print(person['name'])# 方法2： 使用get（）方法获取
point_value = alien_0.get('color')
person_name = person.get('name')
print(f"使用get（）方法获取值：{point_value}")
print(f"使用get()方法获取值：{person_name}")# 方法3：获取不存在的键
person_name = person.get('point','No point value assigned.')
print(f"获取不存在的键值：{person_name}")#
# ----------------------------------------------------------# 将获取到键对应的值赋给一个变量
new_point = alien_0['points']
print(f"You just earned {new_point} points!")# 为字典中添加键值对
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)# 获取字典中所有的键、值及键值对
# ----------------------------------------------------------
student ={'name':'mayer','age':20,'major':'communication','city':'北京'}
# 获取所有键，使用keys()方法获取dict_keys对象
keys = student.keys()
print(f"获取字典中所有的键：{keys}")
print(f"获取字典中所有的键，以列表的形式：{list(keys)}")# 获取字典中所有键对应的值,使用values()方法
values = student.values()
print(f"获取字典中所有键对应的值：{values}")
print(f"获取字典中所有键对应的值，以列表形式展示：{list(values)}")# 获取字典中所有的键值对，使用items()方法
items = student.items()
print(f"获取字典中所有的键值对：{items}")
print(f"获取字典中所有的键值对，以列表的形式展示{list(items)}")# 遍历字典
# ----------------------------------------------------------
student_2 ={'name':'zhongmin','age':45,'major':'cs','city':'上海'}# 方法1.遍历键（显像）
for key in student_2.keys():print(f"遍历键：{key},键所对应的值为：{student_2[key]}")print(f"遍历键；{key},键所对应的值，通过get()方法获取：{student_2.get(key)}")# 方法2：遍历键
for okey in student_2:print(f"遍历键：{okey}")# 方法3：遍历值
for ovlue in student_2.values():print(f"遍历字典中键对应 的值：{ovlue}")# 方法4：遍历键值对
for okey,ovlue in student_2.items():print(f"遍历字典中的键值对：{okey}----对应的值为：{ovlue}")# 添加修改字典元素
# --------------------------------------------------------------
# --------------------------------------------------------------
# 添加新元素
animal = {}
# 方法1：直接赋值添加
animal['class'] = 'cat'
animal['age'] = 5
animal['color'] ='black'
animal['favorite_food'] = 'gouliang'
print(f"直接赋值添加字典元素：{animal}")# 方法2：使用update()方法添加多个元素
animal.update({'city':'北京','zhuren':'zhongmin'})
print(f"使用update()方法添加后字典的值为：{animal}")# 方法3：使用setdefault()方法添加
# 如果键在字典中不存在，则添加
animal.setdefault('salary',10000)
print(f"使用setdefault()方法添加:{animal}")
# 如果键在字典中已存在，则不会修改字典的值
animal.setdefault('age',15)
print(f"测试通过setdefault()方法是否能修改字典中已存在键的值：{animal['age']}")# 修改字典中的元素
# ----------------------------------------------------------------------
#方法1： 直接赋值修改
student_2['age'] = 15
print(f"通过直接赋值修改字典中的值：{student_2}")# 方法2： 使用update()修改多个值
student_2.update({'name':'Mayer','major':'communication','age':35})
print(f"使用update()修改name 和age ,修改后student_2字典：{student_2}")#合并字典
# -----------------------------------------------------------------------
student_1 ={'name':'zhongmin','age':45,'major':'cs','city':'上海'}
student_3= {'base':'河南省','country':'中国','college':'East China Normal University'}
# 方法1：使用update（），该方法会修改原字典
student_3.update(student_1)
print(f"student_3修改合并_1后的字典:{student_3},\n合并前student_1字典为：{student_1}")# 方法2：使用**运算符
merged_student = {**student_1,**student_3}
print(f"使用**运算符合并字典后：{merged_student}")# 方法3：使用 | 运算符
merged_student_1 =student_1 | student_3
print(f"使用 | 运算符合并后的字典：{merged_student_1}")# 删除字典元素
# ------------------------------------------------------------------------
# 删除单个字典元素
# 方法1：使用del语句
del merged_student_1['country']
print(f"使用del删除字典中的某个字段之后：{merged_student_1}")# 方法2：使用pop()方法 （返回被删除的值）
college_pop = merged_student.pop('college')
print(f"使用pop()方法删除字典某个元素返回的值：{college_pop}")
print(f"使用pop()方法删除字典某个元素之后，字典变为：{merged_student}")# 方法3：使用pop()方法并设置默认值,避免出现字典中无该键出现keyerror错误
score_pop = merged_student.pop('score',0)
print(f"使用pop()方法删除字典中某个元素后的返回值：{score_pop}")# 方法4：使用popitem()删除最后插入的键值对
last_item = merged_student.popitem()
print(f"使用popitem()删除最后插入的键值对,返回的键值对：{last_item},删除后字典为：{merged_student}")# 清空字典
# ---------------------------------------------------------------------------
# 清空字典中所有的元素
merged_student.clear()
print(f"清空merged_student 字典后，字典变为：{merged_student}")# 注意;clear()和重新赋值的区别
merged_student_1 = merged_student
print(f"赋值与清空的区别:{merged_student_1}-------------{merged_student}")# 使用get（）方法访问值
# ------------------------------------------------------------------------------
# 1.get()方法的基本用法
alien_0 = {'color':'green','speed':'slow'}
# 1）访问字典中某一个键关联的值
print(alien_0['color'])#2）使用get（）方法访问
print(f"使用get()方法访问字典中某个键关联的值：{alien_0.get('color')}")# 3) 访问字典中不存在的键
# print(alien_0['point'])
point_value = alien_0.get('point','No point value assigned.')
print(point_value)# 使用get()方法与直接访问对比
# ----------------------------------------------------------------------------------
# 直接访问，键不存在必然报错，需要try 处理
try:score = alien_0['point']print(f"直接访问字典中不存在的键：{score}")
except KeyError as e:print(f"错误：键不存在{e}")# 使用get()访问安全，不会出错
score_get = alien_0.get('point')
if score_get is None:print(f"point键不存在")# 链式操作
config ={'database':{'host':'localhost','port':3306}
}
# 安全的链式访问
print(config.get('database',{}).get('port',3306))# 更复杂的场景
max_connections = config.get('database',{}).get('pool',{}).get('max_connections',10)
print(max_connections)# get()方法的应用实践
# 场景1：统计词频时，安全的增加计数
text = "apple banana apple orange banana apple li lizhi"
words = text.split()
words_count = {}
for word in words:# words_count[word] += 1words_count[word] =words_count.get(word,0) + 1
print(f"计算词频：{words_count}")# 场景2：配置文件读取
config ={'host':'localhost','port':3306
}
# 安全读取配置项
# 使用默认值30s
timeout = config.get('timeout',30)
# 使用默认值False
debug = config.get('debug',False)
print(f"超时时间：{timeout}秒，调试时间：{debug},配置文件内容：{config}")# 字典常用方法
# --------------------------------------------------------------------------------------------
# 1.检查键是否存在
graduate = {'name': '李四', 'age': 20, 'major': '计算机科学','graduate_year':'2025','degree':'Master'}
# True
print('name' in graduate)
# True
print('major' in graduate)
# False
print('score' in graduate)# 方法2 ：使用keys()方法
print('name' in graduate.keys())# 方法3：检查值是否存在
print('李四' in graduate.values())# 方法4：检查键值对是否存在
print(('name','李四') in graduate.items())#字典长度、字典复制
# ----------------------------------------------------------------------------------------
# 获取字典长度（键值对数量）
print(len(graduate))# 浅拷贝字典
graduate_copy = graduate.copy()
print(f"浅拷贝字典后，查看拷贝字典的情况：{graduate_copy}")# 深拷贝（需要拷贝模块）
import copy
graduate_deepcopy = copy.deepcopy(graduate)
print(f"深拷贝字典后，查看拷贝后字典的情况：{graduate_deepcopy}")# 字典视图对象
# -------------------------------------------------------------------------------------
# keys(), values(), items() 返回的是视图对象
# 视图主要特点：
# 动态性：当字典改变时，视图会自动更新。
# 可迭代：可以用于循环遍历。
# 支持成员测试：可以使用 in 运算符。
# 不支持索引：不能通过下标直接访问，但可以转换为列表。
graduate_keys_view = graduate.keys()
print(f"查看keys()方法返回的类型，{type(graduate_keys_view)}")
graduate_values_view = graduate.values()
print(f"查看values()方法返回的类型，{type(graduate_values_view)}")
graduate_items_view = graduate.items()
print(f"查看items()方法返回的类型，{type(graduate_items_view)}")
# 视图对象是动态变化的，会反映字典的变化
graduate['major'] = '通信工程'
print(f"查看视图对象的变化：{list(graduate_items_view)}")# 嵌套字典操作
# -----------------------------------------------------------------------------------
# 定义嵌套字典
company ={'employee_1':{'name':'maying','age':45,'department':'技术部','skill':['python','java','c++'],'city':'北京'},'employee_2': {'name': 'zhongmin','age': 55,'department': '项目部','skill': ['sql', 'java', 'english'],'city': '上海'},'employee_3': {'name': 'jiehao','age': 47,'department': '产品部','skill': ['产品讲解', '表达', 'ppt'],'city': '上海'}
}# 访问嵌套字典的值
# 方法1：get()
print(company.get('employee_1',{}).get('skill',0)[0])
# 方法2：
print(company['employee_1']['name'])
print(company['employee_1']['skill'][1])# 修改嵌套的值
company['employee_1']['name'] ='Mayer'
company['employee_1']['skill'][1] = 'javaweb'
#遍历嵌套字典
for employee_id,employee_info in company.items():print(f"\n员工ID：{employee_id},员工信息类型:{type(employee_info)}")for okey,ovalue in employee_info.items():print(f"{okey}-----------------------{ovalue}")# 使用get()方法安全访问嵌套字典
salary = company.get('employee_2',{}).get('salary',10000)
print(f"默认工资：{salary}")# 字典推导式高级用法
# ----------------------------------------------------------------------
# 基本字典推导式
squares = {x:x**2 for x in range(1,10)}
print(f"使用基本推导式：{squares}")
# 带条件的字典推导式
even_squares = {x:x**2 for x in range(1,10) if x % 2 == 0}
print(f"带条件的字典推导式：{even_squares}")
# 反转字典（键值互换）
reversed_graduate = {ovalue:okey for okey,ovalue in graduate.items()}
print(f"反转字典后：{reversed_graduate}")
# 合并两个列表为字典
list_1 =['name','age','city','country','major']
list_2 =['Mayer','30','上海','中国','通信工程']
ditionary_combine = {okey:ovalue for okey,ovalue in zip(list_1,list_2)}
print(f"列表合并后的字典为：{ditionary_combine}")# 处理字符串，统计字符频率
text =" hello world i love you , you are the real world"
char_count = {char:text.count(char) for char in set(text) if char != ' '}
print(char_count)# 字典经典方法总结
# -----------------------------------------------------------------------------------------------------------------------------------------
# 方法 描述 示例
# clear() 移除所有元素 d.clear()
# copy() 返回字典的浅拷贝 d.copy()
# fromkeys(iterable[, value]) 从可迭代对象创建新字典 dict.fromkeys(['a','b'], 0)
# get(key[, default]) 安全获取值 d.get('key', 'default')
# items() 返回键值对视图 for k,v in d.items():
# keys() 返回键视图 for k in d.keys():
# pop(key[, default]) 移除并返回值 value = d.pop('key')
# popitem() 移除并返回最后插入的键值对 k,v = d.popitem()
# setdefault(key[, default]) 获取值，键不存在时设置默认值 d.setdefault('key', 0)
# update([other]) 用另一个字典更新当前字典 d.update({'x': 1})
# values() 返回值视图 for v in d.values():#
# -----------------------------------------------------------------------------------------------------------------------------------------
