Python 字典

• 字典是Python的一种内置数据类型，
• 每个元素都以键：值对的形式存在，用“{ }”将所有元素括起来，各个元素之间用 “ ， ” 分隔。

字典与字符串、列表和元组主要的不同是：

• 字典是无序的，
• 其元素的访问是通过“键”来实现的，而不是通过元素的位置（下标），并且字典中的“键”不能重复。

字典是Python中最强的的数据类型之一

1、字典的创建与访问

在Python中，创建实例对象时，通过赋值号 “=” 将一个实例赋值给一个变量即可。

dict = {}
adct = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(adct)
# 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

lag = {'Python': 1, 'c': 2, 'JAVA': 3}
print(lag)
# 输出：{'Python': 1, 'c': 2, 'JAVA': 3}


print(adct['a'])  # 通过键访问元素的值
# 输出：1

print(lag['JAVA'])
# 输出：3

xuesheng = {'xm': ['dong', 'wang', 'li'], 'xb': ['f', 'f', 'm'], 'fs': [67, 78, 87]}
print(xuesheng)
# {'xm': ['dong', 'wang', 'li'], 'xb': ['f', 'f', 'm'], 'fs': [67, 78, 87]}

可得知：

• 字典的键可以是字符串、数值、逻辑值，
• 字典的值可以是单个的值，也可以是列表、元组等。

2、字典元素的修改

1、修改值

lag = {'Python': 1, 'c': 2, 'JAVA': 3}
print(lag)
# 输出：{'Python': 1, 'c': 2, 'JAVA': 3}
lag['JAVA'] = 5
print(lag)
# 输出：{'Python': 1, 'c': 2, 'JAVA': 5}

2、增添元素

lag2 = {'Python': 1, 'c': 2, 'JAVA': 3}
print(lag2)
# 输出：{'Python': 1, 'c': 2, 'JAVA': 3}
lag2["C#"] = 4  # 直接将值赋给一个新的键，就添加了一个元素
print(lag2)
# 输出：{'Python': 1, 'c': 2, 'JAVA': 3, 'C#': 4}

3、元素的删除

del 命令可以删除元素，也可以删除整个字典。

lag3 = {'Python': 1, 'c': 2, 'JAVA': 3}
print(lag3)
# 输出：{'Python': 1, 'c': 2, 'JAVA': 3}
del lag3['JAVA']  # 删除‘JAVA'元素
print(lag3)
# 输出：{'Python': 1, 'c': 2}
del lag3
print(lag3)
# （删除整个字典后，再查询该字典就会）抛出异常

3、字典操作方法

方法	功能
dict.clear()	清空字典

way = {1: 'a', 2: 'python', 'name': 'xu'}
print(way)
# 输出：{1: 'a', 2: 'python', 'name': 'xu'}
way.clear()  # 清空字典
print(way)
# 输出：{}

方法	功能
dict.copy()	复制字典

此部分代码来源于：python：dict.copy()

dict1 = {'Name': 'Zara', 'Age': [0,0,0]}
"""
    dict.copy()
    对于一级目录是深拷贝，二级目录浅拷贝，浅拷贝就是引用
    浅拷贝的话，改变子对象，父对象也改变
"""
dict2 = dict1.copy()
print('dict2',dict2)
 
#一级目录相互独立
dict2['Name']='lose'
print('dict2',dict2)
print('dict1',dict1)
 
#改变子对象的二级目录，父目录改变
dict2['Age'][0]=1024
print('dict2',dict2)
print('dict1',dict1)
 
#改变父对象的二级目录，子对象改变
dict1['Age'][1]=9
print('dict2',dict2)
print('dict1',dict1)
 
"""
dict2 {'Name': 'Zara', 'Age': [0, 0, 0]}
dict2 {'Name': 'lose', 'Age': [0, 0, 0]}
dict1 {'Name': 'Zara', 'Age': [0, 0, 0]}
dict2 {'Name': 'lose', 'Age': [1024, 0, 0]}
dict1 {'Name': 'Zara', 'Age': [1024, 0, 0]}
dict2 {'Name': 'lose', 'Age': [1024, 9, 0]}
dict1 {'Name': 'Zara', 'Age': [1024, 9, 0]}
"""

方法	功能
dict.items()	获得由键和值组成的元组，作为元素的列表

way1 = {'name': "xiaoping", 'age': 18, 'score': [100, 90, 99]}
way2 = way1.items() #  获得由键和值组成的元组，作为元素的列表
print(way2)


"""
dict_items([('name', 'xiaoping'), ('age', 18), ('score', [100, 90, 99])])
"""

方法	功能
dict.key()	获得 键 的迭代器
dict.values()	获得 值 的迭代器

way = {1: 'a', 2: 'python', 'name': 'xu'}
way2 = way.keys()  # 获取字典way的所有“键”
print(way2)
way2 = way.values()  # 获取字典way的所有“值”
print(way2)


"""
dict_keys([1, 2, 'name'])
dict_values(['a', 'python', 'xu'])
"""

方法	功能
dict.pop(keyname, defaultvalue)	删除k(键)对象的 键:值 对

参数说明

参数	描述
keyname	必需的参数， 要删除的元素的key
defaultvalue	可选的。如果指定的key不存在，则返回的值。如果未指定此参数，且未找到具有指定key的项，则会引发错误。

从字典中删除key为"model"的元素：

car = {"brand": "Ford", "model": "Mustang", "year": 1964}
car.pop("model")
print(car)

"""
{'brand': 'Ford', 'year': 1964}
"""

删除元素的值是pop()方法的返回值：

car = {"brand": "Ford", "model": "Mustang", "year": 1964}
x = car.pop("model")
print(x)

"""
Mustang
"""

方法	功能
dict.update()	从另一个字典更新字典元素的值，如果不存在，则添加此元素

• update()方法将指定的键值对更新插入字典。
• 指定的键值对可以是字典，也可以是键值对的可迭代对象。

car = {"brand": "Ford", "model": "Mustang", "year": 1964}
car.update({"color": "White"})
print(car)

"""
{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'White'}
"""

方法	功能
dict.fromkeys(keys,value)	以列表或元组中给定的键建立字典，默认值为value

• fromkeys()方法用于创建一个新字典，以序列 keys 中元素做字典的key，value 为字典所有key对应的初始值。

参数说明

参数	描述
keys	必需的参数，指定新字典key的迭代器
value	可选的。所有key对应的value。默认值为None

x = ('key1', 'key2', 'key3')
y = 0
thisdict = dict.fromkeys(x, y)
print(thisdict)
"""
{'key1': 0, 'key2': 0, 'key3': 0}
"""

x = ('key1', 'key2', 'key3')
thisdict = dict.fromkeys(x)
print(thisdict)

"""
{'key1': None, 'key2': None, 'key3': None}
"""

方法	功能
dict.get(k,[default])	获得K（键）对应的值，不存在则返回default
dict.popitem()	从字典这删除任一 k:v 元素，并返回它
dict.setdefault(k[,default]）	若字典中存在键为 k 的元素，则返回其对应的值，否则的字典中建立一个 k:default 的元素。

xuesheng = {'name': 'ding', 'age': 18, 'score': [112, 145, 80]}
print(xuesheng)

print(xuesheng.get('add', 'jiangsu'))  # "addr"键不存在，返回默认值“jiangsu"

print(xuesheng.popitem())  # 随机删除一个元素（键：值对），并返回该元素

xuesheng.setdefault('add', 'shanghai')
print(xuesheng)  # 删除了'score':[112,145,80],增添了'addr':'shanghai'的元素

for key in xuesheng.items():  # 活得键:值对的列表
    print(key)
    
    
"""
{'name': 'ding', 'age': 18, 'score': [112, 145, 80]}
jiangsu
('score', [112, 145, 80])
{'name': 'ding', 'age': 18, 'add': 'shanghai'}

('name', 'ding')
('age', 18)
('add', 'shanghai')
"""

可以简单理解为，字典可存储一个二维表