python_字典

字典

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

字符类型：dict
符号：{}
存储方式：键值对

创建字典

1. 使用{}创建空字典：emptydict={}
2. 使用内建函数dict()创建字典：emptydict=dict()

字典的函数

1. 添加键值对 | 修改字典：dict[key]=value

dict1={'name':'zz'}
dict1['age']=10
print(dict1) # {'name': 'zz', 'age': 10}
dict1['name']='zxl'
print(dict1) # {'name': 'zxl', 'age': 10}

2. 访问字典里的值：dict[key]
3. 查询所有键【返回一个视图对象】：dict.keys()
4. 查询所有值【返回一个视图对象】：dict.values()
5. 查询所有键值对【返回一个视图对象】：dict.items()

• 视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。
• 不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。
• 视图对象是动态的，受字典变化的影响，删除了字典的 key，视图对象转为列表后也跟着变化

obj={'aa':2,'bb':4,'cc':0}
keys=obj.keys()
print(keys) # dict_keys(['aa', 'bb', 'cc'])
print(type(keys)) # <class 'dict_keys'>
keylst=list(keys)
print(keylst) # ['aa', 'bb', 'cc']
print(keylst[0]) # aa
values=obj.values()
print(values) # dict_values([2, 4, 0])
print(type(values)) # <class 'dict_values'>
items=obj.items()
print(items) # dict_items([('aa', 2), ('bb', 4), ('cc', 0)])
print(type(items)) # <class 'dict_items'>

5. 添加默认值【键不存在于字典中】：dict.setdefault(key, default=None)

dict2={'aa':0,'bb':9}
dict2.setdefault('bb',None)
dict2.setdefault('cc',None)
print(dict2) # {'aa': 0, 'bb': 9, 'cc': None}

• 添加内容的优先级：直接添加>本身元素>默认添加元素

6. 删除字典元素

• 能删单一的元素也能清空字典，清空只需一项操作。

7. 删除字典内所有元素：dict.clear()

tinydict={'name':'aa','age':'99','sex':0}
# 删除键
del tinydict['age']
print(tinydict) # {'name': 'aa', 'sex': 0}
# 清空字典
tinydict.clear()
print(tinydict) # {}
# 删除字典
del tinydict
print(tinydict) # 报错

8. 删除字典key所对应的值，返回被删除的值：dict.pop(key[,default])
9. 返回并删除字典中的最后一对键和值： dict.popitem()

dict3={'name':'aa','age':'99','sex':0}
print(dict3.pop('age')) # 99
print(dict3) # {'name': 'aa', 'sex': 0}
print(dict3.popitem()) # ('sex', 0)
print(dict3) # {'name': 'aa'}

10. 返回指定键的值，如果键不在字典中返回 default 设置的默认值：dict.get(key, default=None)

dict3={'name':'aa','age':'99','sex':0}
print(dict3.get('age')) # 99
print(dict3.get('bb')) # None

11. 把字典dict2的键/值对更新到dict里：dict.update(dict2)

dict1={'aa':'a','bb':'b'}
dict2={11:1,22:2}
dict1.update(dict2)
print(dict1) # {'aa': 'a', 'bb': 'b', 11: 1, 22: 2}

12. 复制字典：dict.copy()

test1={'user':'admin','pwd':[1,2,3,4]}
test2=test1         # 浅拷贝: 引用对象
test3=test1.copy()  # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，子对象是引用
# 修改数据
test1['user']='root'
test1['pwd'].remove(3)

print(test1)    # {'user': 'root', 'pwd': [1, 2, 4]}
print(test2)    # {'user': 'root', 'pwd': [1, 2, 4]}
print(test3)    #{'user': 'admin', 'pwd': [1, 2, 4]}
# 实例中 test2 其实是 test1 的引用（别名），所以输出结果都是一致的，test3 父对象进行了深拷贝，不会随test1 修改而修改，子对象是浅拷贝所以随 test1 的修改而修改。

13. 创建一个新字典：dict.fromkeys(seq[, value])

• seq -- 字典键值列表。
• value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。

seq1=('name','age','sex')
seq2=['name','age','sex']
tempdict=dict.fromkeys(seq1) # 不指定值
print(tempdict) # {'name': None, 'age': None, 'sex': None}
tempdict2=dict.fromkeys(seq2,10)
print(tempdict2) # {'name': 10, 'age': 10, 'sex': 10}

14. 判断键是否在字典dict中：key in dict

tempdict={'name': 10, 'age': 10, 'sex': 10}
print('name' in tempdict) # True

15. 计算字典元素个数[即键的总数]：len(dict)
16. 输出字典，可以打印的字符串表示：str(dict)
17. 判断变量类型：type(dict)

字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

1. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

dict4={'name':'ao','age':7,'name':'aoao'}
print(dict4) # {'name': 'aoao', 'age': 7}

2. 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行