python字典：增删改查复制
0 字典基础：
字典(Dictionary)是Python提供的一种常用的数据结构，由键（key）和值（value）成对组成，键和值中间以冒号：隔开，项之间用逗号隔开，整个字典由大括号{}括起来。
格式如下：
dic = {key1 : value1, key2 : value2 }
空字典的定义：
{}
dict()
字典也被称作关联数组或哈希表。下面是几种常见的字典创建方式：
# 方法1
dic1 = { 'Author' : 'Python当打之年' , 'age' : 99 , 'sex' : '男' }
# 方法2
lst = [('Author', 'Python当打之年'), ('age', 99), ('sex', '男')]
dic2 = dict(lst)
# 方法3
dic3 = dict( Author = 'Python当打之年', age = 99, sex = '男')
# 方法4
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', 99, '男']
dic4 = dict(zip(list1, list2))
字典由 dict 类代表，可以使用**dir(dict)**来查看该类包含哪些方法，输入命令，可以看到如下输出结果：
methods = dir(dict)
print('methods = ',methods)
methods = ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
字典的方法和属性有很多种，这里我们重点介绍以下11种方法：
['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
1 字典基础用法：增删改查复制
增
- 字典[新的key] = 值
- 如果key在原字典中已经存在则为修改原key对应的值
# 增 使用新的键 = 值的形式增加键值对
dict1 = {'name':'xiaoming', 'age': 18}
# 使用新的键= 值
# 格式:字典变量[key] = 值 如果为新增,则key在原字典中不存在
dict1['gender'] = '男'
print(dict1) # {'name': 'xiaoming', 'age': 18, 'gender': '男'}
# 如果原字典中存在该key 则为修改原key所对应的值
dict1['name'] = 'xiaowang'
print(dict1) # {'name': 'xiaowang', 'age': 18, 'gender': '男'}
删
- del 查找到字典的键所对应的值进行删除
- clear（）清空字典所在数据空间中的多有键值对
- pop：删除指定键所对应的键值对，会将删除的键值对所对应的值进行返回
- popitem： 删除随机一个键值对，尝试后发现总是删除最后一个，会将删除的键值对以元组的形式进行返回
del dict[key]
使用del删除键值对,先要找到dict所对应的键,进行删除
注意,在字典中键值对是成对出现的,删除键值也就消失了,不能出现单独的键或者单独的值
dict1 = {'name': 'xiaoming', 'age': 18}
del dict1['age']
print(dict1) # {'name': 'xiaoming'}
dict.clear()
clear() 用于清空字典中所有元素（键-值对），对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', 99, '男']
dic1 = dict(zip(list1, list2))
# dic1 = {'Author': 'Python当打之年', 'age': 99, 'sex': '男'}
dic1.clear()
# dic1 = {}
dict.pop()
pop() 返回指定键对应的值，并在原字典中删除这个键-值对。
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
sex = dic1.pop('sex')
print('sex = ', sex)
print('dic1 = ',dic1)
# sex = 男
# dic1 = {'Author': 'Python当打之年', 'age': [18, 99]}
dict.popitem()
popitem() 删除字典中的最后一对键和值。
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
dic1.popitem()
print('dic1 = ',dic1)
# dic1 = {'Author': 'Python当打之年', 'age': [18, 99]}
改
- 字典[key] = 值
- 字典中key必须存在
- update：
- update（键 = 值）
- update（{键：值}）
- 对应的键一定存在
dict[key] = value1
# 通过索引修改字典中的键值对
dict1 = {'name':'小明', 'age':18}
dict1['name'] = '小红'
print(dict1)
dict.update(dict1)
update() 字典更新，将字典dict1的键-值对更新到dict里，如果被更新的字典中己包含对应的键-值对，那么原键-值对会被覆盖，如果被更新的字典中不包含对应的键-值对，则添加该键-值对。
相当于集合的合并一样，合并相同的；
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
print('dic1 = ',dic1)
# dic1 = {'Author': 'Python当打之年', 'age': [18, 99], 'sex': '男'}
list3 = ['Author', 'phone' ]
list4 = ['当打之年', 12345678]
dic2 = dict(zip(list3, list4))
print('dic2 = ',dic2)
# dic2 = {'Author': '当打之年', 'phone': 12345678}
dic1.update(dic2)
print('dic1 = ',dic1)
# dic1 = {'Author': '当打之年', 'age': [18, 99], 'sex': '男', 'phone': 12345678}
dict.setdefault()
setdefault() 和 get() 类似, 但如果键不存在于字典中，将会添加键并将值设为default。
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
dic1.setdefault('Author', '当打之年')
print('dic1 = ',dic1)
# dic1 = {'Author': 'Python当打之年', 'age': [18, 99], 'sex': '男'}
dic1.setdefault('name', '当打之年')
print('dic1 = ',dic1)
# dic1 = {'Author': 'Python当打之年', 'age': [18, 99], 'sex': '男', 'name': '当打之年'}
dict.fromkeys()：有种广播机制的感觉
fromkeys() 使用给定的多个键创建一个新字典，值默认都是 None，也可以传入一个参数作为默认的值。
list1 = ['Author', 'age', 'sex']
dic1 = dict.fromkeys(list1)
dic2 = dict.fromkeys(list1, 'Python当打之年')
# dic1 = {'Author': None, 'age': None, 'sex': None}
# dic2 = {'Author': 'Python当打之年', 'age': 'Python当打之年', 'sex': 'Python当打之年'}
查
- 使用键查询值：字典[key]
- 查询的键不存在时则报错
- get：字典.get(key)
- 查询的键不存在时，不报错，可以默认返回None，或者手动设置返回内容
- keys：获取所有的键
- values：获取所有的值
- items：获取所有的键值对组成的元组·
dict[key]:
# 直接使用key进行查询
dict1 ={'name':'小明','age':18,'gender':'男','id':'001'}
# 查询学员的名称?print(dict1['name'])
dict.get()
get() 用于返回指定键的值，也就是根据键来获取值，在键不存在的情况下，返回 None，也可以指定返回值。
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
Author = dic1.get('Author')
# Author = Python当打之年
phone = dic1.get('phone')
# phone = None
phone = dic1.get('phone','12345678')
# phone = 12345678
dict.items()
items() 获取字典中的所有键-值对，一般情况下可以将结果转化为列表再进行后续处理。
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
items = dic1.items()
print('items = ', items)
print(type(items))
print('items = ', list(items))
# items = dict_items([('Author', 'Python当打之年'), ('age', [18, 99]), ('sex', '男')])
# <class 'dict_items'>
# items = [('Author', 'Python当打之年'), ('age', [18, 99]), ('sex', '男')]
dict.keys()
keys() 返回一个字典所有的键。
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
keys = dic1.keys()
print('keys = ', keys)
print(type(keys))
print('keys = ', list(keys))
# keys = dict_keys(['Author', 'age', 'sex'])
# <class 'dict_keys'>
# keys = ['Author', 'age', 'sex']
dict.values()
values() 返回一个字典所有的值。
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
values = dic1.values()
print('values = ', values)
print(type(values))
print('values = ', list(values))
# values = dict_values(['Python当打之年', [18, 99], '男'])
# <class 'dict_values'>
# values = ['Python当打之年', [18, 99], '男']
复制
dict.copy()
copy() 用于返回一个字典的浅拷贝。
只要注意地址问题就好：
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', 99, '男']
dic1 = dict(zip(list1, list2))
dic2 = dic1 # 浅拷贝: 引用对象
dic3 = dic1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
dic1['age'] = 18
# dic1 = {'Author': 'Python当打之年', 'age': 18, 'sex': '男'}
# dic2 = {'Author': 'Python当打之年', 'age': 18, 'sex': '男'}
# dic3 = {'Author': 'Python当打之年', 'age': 99, 'sex': '男'}
拓展深拷贝：copy.deepcopy()
import copy
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
dic2 = dic1
dic3 = dic1.copy()
dic4 = copy.deepcopy(dic1)
dic1['age'].remove(18)
dic1['age'] = 20
# dic1 = {'Author': 'Python当打之年', 'age': 20, 'sex': '男'}
# dic2 = {'Author': 'Python当打之年', 'age': 20, 'sex': '男'}
# dic3 = {'Author': 'Python当打之年', 'age': [99], 'sex': '男'}
# dic4 = {'Author': 'Python当打之年', 'age': [18, 99], 'sex': '男'}
dic2 是 dic1 的引用，所以输出结果是一致的；dic3 父对象进行了深拷贝，不会随dic1 修改而修改，子对象是浅拷贝所以随 dic1 的修改而修改；dic4 进行了深拷贝，递归拷贝所有数据，相当于完全在另外内存中新建原字典，所以修改dic1不会影响dic4的数据。
2 字典的进阶用法：
Python collections模块之Counter()详解
collections模块 ==> Python标准库，数据结构常用的模块；collections包含了一些特殊的容器，针对Python内置的容器，例如list、dict、set和tuple，提供了另一种选择。
计数器（Counter）
dict的子类，计算可hash的对象
Counter()
主要功能：可以支持方便、快速的计数，将元素数量统计，然后计数并返回一个字典，键为元素，值为元素个数。
from collections import Counter
list1 = ["a", "a", "a", "b", "c", "c", "f", "g", "g", "g", "f"]
dic = Counter(list1)
print(dic)
#结果:次数是从高到低的
#Counter({'a': 3, 'g': 3, 'c': 2, 'f': 2, 'b': 1})
print(dict(dic))
#结果:按字母顺序排序的
#{'a': 3, 'b': 1, 'c': 2, 'f': 2, 'g': 3}
from collections import Counter
str1 = "aabbfkrigbgsejaae"
print(Counter(str1))
print(dict(Counter(str1)))
#结果:
#Counter({'a': 4, 'b': 3, 'g': 2, 'e': 2, 'f': 1, 'k': 1, 'r': 1, 'i': 1, 's': 1, 'j': 1})
#{'a': 4, 'b': 3, 'f': 1, 'k': 1, 'r': 1, 'i': 1, 'g': 2, 's': 1, 'e': 2, 'j': 1}
Python collections模块之defaultdict()详解
默认字典（defaultdict）
dict的子类，可以调用提供默认值的函数
Python中通过Key访问字典，当Key不存在时，会引发‘KeyError’异常。为了避免这种情况的发生，可以使用collections类中的defaultdict()方法来为字典提供默认值
defaultdict是内置数据类型dict的一个子类，基本功能与dict一样，只是重写了一个方法missing(key)和增加了一个可写的对象变量default_factory
语法格式：
collections.defaultdict([default_factory[, …]])
- 如果default_factory属性为None，就报出以key作为遍历的KeyError异常；
- 如果default_factory不为None，就会向给定的key提供一个默认值，这个值插入到词典中，并返回；
- 如果调用default_factory报出异常，这个异常在传播时不会改变；
- 这个方法是当要求的key不存在时，dict类中的getitem()方法所调用，无论它返回或者报出什么，最终返回或报出给getitem()；
- 只有getitem()才能调用missing()，这意味着，如果get()起作用，如普通的词典，将会返回None作为默认值，而不是使用default_factory；
default_factory， 这个属性用于missing()方法，使用构造器中的第一个参数初始化；
使用list作为default_factory，很容易将一个key-value的序列转换为list字典；
列表字典 d = defaultdict(list)
from collections import defaultdict
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d = defaultdict(list)
for k, v in s:
d[k].append(v)
a = d.items()
print(a)
b = sorted(d.items())
print(b)
"""
结果：
dict_items([('yellow', [1, 3]), ('blue', [2, 4]), ('red', [1])])
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
当字典中没有的键第一次出现时，default_factory自动为其返回一个空列表，list.append()会将值添加进新列表；再次遇到相同的键时，list.append()将其它值再添加进该列表。
这种方法比使用dict.setdefault()更为便捷，dict.setdefault()也可以实现相同的功能。
计数
设置default_factory为int，使得defaultdict可以用于计数
from collections import defaultdict
s = "chlzdjlongdong"
d = defaultdict(int)
for k in s:
d[k] += 1
a = d.items()
print(a)
b = sorted(d.items())
print(b)
"""
结果：
dict_items([('c', 1), ('h', 1), ('l', 2), ('z', 1), ('d', 2), ('j', 1), ('o', 2), ('n', 2), ('g', 2)])
[('c', 1), ('d', 2), ('g', 2), ('h', 1), ('j', 1), ('l', 2), ('n', 2), ('o', 2), ('z', 1)]
"""
字符串中的字母第一次出现时，字典中没有该字母，default_factory函数调用int()为其提供一个默认值0,加法操作将计算出每个字母出现的次数。
集合字典：
将default_factory设置为set，使得defaultdict可以建立一个集合字典
from collections import defaultdict
s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
d = defaultdict(set)
for k, v in s:
d[k].add(v)
a = d.items()
print(a)
b = sorted(d.items())
print(b)
"""
结果：
dict_items([('red', {1, 3}), ('blue', {2, 4})])
[('blue', {2, 4}), ('red', {1, 3})]
"""
参考：
https://blog.youkuaiyun.com/ljh18885466426/article/details/119357723
https://blog.youkuaiyun.com/chl183/article/details/107446836
https://blog.youkuaiyun.com/chl183/article/details/106956807
940
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
