字典创建和对象方法
文章目录
前言
- 字典的每个键值对用冒号 : 隔开写成 key: value 的格式，每个键值对 之间用逗号 , 隔开，包括在花括号 {} 中
- Dict 是可变的，它不是序列
- 键和键包含的内容都必须为不可变类型（如数字，字符串或元组） 如果键重复，那么重复键对应的值后面会把前面的值覆盖掉，但是位置还是原来的位置
- 值的数据类型没有严格的限制，并且可以重复
创建字典的六种方式
- 直接在空字典{}里面写键值对
a = {'name': 'Tom', 'age': 28}
print(a) # {'name': 'Tom', 'age': 28}
- 定义一个空字典，再往里面添加键值对
a = {} # a = dict()等价于type(某个字典对象)()
a['name'] = 'Tom'
a['age'] = 28
print(a)
- 把键作为关键字传入
a = dict(name="Tom", age=28) # dict(**kwarg)和dict(mapping)创造方式不一样，注意了：dict({'name': "Tom", "age": 28})
print(a)
- 可迭代对象方式来构造字典
a = dict([("name", "Tom"), ("age", 28)]) # 这里用元组/列表/集合都是可以的
print(a) # {'name': 'Tom', 'age': 28}
a = dict((("name", "Tom"), ("age", 28))) # 这里用元组/列表/集合都是可以的
print(a) # {'name': 'Tom', 'age': 28}
a = dict({("name", "Tom"), ("age", 28)}) # 这里用元组/列表/集合都是可以的
print(a) # {'name': 'Tom', 'age': 28}
- 通过zip()把对应元素打包成元组，类似于上一种方法
a = dict(zip(["name", "age"], ["Tom", 28]))
print(a) # {'name': 'Tom', 'age': 28}
*zip(iterables)
- 返回一个元组的迭代器，其中的第 i 个元组包含来自每个可迭代对象的第 i 个元素，当可迭代对象长度不匹配时，按照最短的长度来匹配。
- 当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代
- 不带参数时，它将返回一个空迭代器
- 当只有一个可迭代对象参数时，它将返回一个单元组的迭代器
result1 = zip("abcd", "efgh")
print(result1) # 返回一个可迭代对象
print(list(result1)) # [('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', 'h')]
result2 = zip("abcd", "efg")
print(result2) # 返回一个可迭代对象
print(list(result2)) # [('a', 'e'), ('b', 'f'), ('c', 'g')]
result3 = zip()
print(result3) # 返回一个可迭代对象
print(list(result3)) # []
result4 = zip("abcd")
print(result4) # 返回一个可迭代对象
print(list(result4)) # [('a',), ('b',), ('c',), ('d',)]
- 利用类方法 fromkeys() 创建
dic1 = dict.fromkeys(("name", "age", "gender"))
print(dic1) # {'name': None, 'age': None, 'gender': None}
dic2 = dict.fromkeys(("name", "age", "gender"), "I don'tknow!")
print(dic2) # {'name': "I don'tknow!", 'age': "I don'tknow!", 'gender': "I don'tknow!"}
classmethod.fromkeys(iterable[, value])
- 创建一个新字典，以 iterable 的元素作为键，value 作为值，value 默 认为 None
dic1 = dict.fromkeys(("name", "age", "gender"))
print(dic1) # {'name': None, 'age': None, 'gender': None}
dic2 = dict.fromkeys(("name", "age", "gender"), "I don'tknow!")
print(dic2) # {'name': "I don'tknow!", 'age': "I don'tknow!", 'gender': "I don'tknow!"}
dict(**kwarg) / dict(mapping) / dict(iterable)
- 用于创建一个字典并返回
print(dict(one=1, two=2, three=3)) # 传入关键字来构造字典
print(dict(zip(["one", "two", "three"], [1, 2, 3]))) #映射函数方式来构造字典
print(dict([("one", 1), ("two", 2), ("three", 3)])) # 可迭代对象方式来构造字典
dict 语法：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
参数说明：
- **kwargs – 关键字。
- mapping – 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
- iterable – 可迭代对象。
只使用关键字创造字典
numbers = dict(x=5, y=0)
print('numbers =', numbers)
print(type(numbers))
empty = dict()
print('empty =', empty)
print(type(empty))
# 以上实例输出的结果为：
numbers = {'y': 0, 'x': 5}
<class 'dict'>
empty = {}
<class 'dict'>
使用可迭代对象创建字典
# 没有设置关键字参数
numbers1 = dict([('x', 5), ('y', -5)])
print('numbers1 =',numbers1)
# 设置关键字参数
numbers2 = dict([('x', 5), ('y', -5)], z=8)
print('numbers2 =',numbers2)
# zip() 创建可迭代对象
numbers3 = dict(dict(zip(['x', 'y', 'z'], [1, 2, 3])))
print('numbers3 =',numbers3)
# 以上实例输出的结果为:
numbers1 = {'y': -5, 'x': 5}
numbers2 = {'z': 8, 'y': -5, 'x': 5}
numbers3 = {'z': 3, 'y': 2, 'x': 1}
使用映射来创建字典
映射类型（Mapping Types）是一种关联式的容器类型，它存储了对象与对象之间的映射关系。
numbers1 = dict({'x': 4, 'y': 5})
print('numbers1 =',numbers1)
# 以下代码不需要使用 dict()
numbers2 = {'x': 4, 'y': 5}
print('numbers2 =',numbers2)
# 关键字参数会被传递
numbers3 = dict({'x': 4, 'y': 5}, z=8)
print('numbers3 =',numbers3)
# 以上实例输出结果为：
numbers1 = {'x': 4, 'y': 5}
numbers2 = {'x': 4, 'y': 5}
numbers3 = {'x': 4, 'z': 8, 'y': 5}
访问和修改字典
访问字典里的值
diction = {'Name': 'Tom', 'Age': 7, 'Class': 'First'}
print(diction['Name'])
print(diction['Age'])
# print(diction['age']) # 没有找到键, 则报错 KeyError
修改字典
# 指定键值对, 如果键已经存在, 则修改值；如果键不存在, 则在最后增加键值对
d1 = {"height": 175, "weight": 65}
d1["height"] = "1米75"
d1["name"] = "Tom"
print(d1)
字典的对象方法
dict.keys()
- 返回由字典键组成的一个新视图
- 返回的对象是视图对象，这意味着当字典改变时，视图也会相应改变
d1 = {'身高': 175, '体重': 65, '肤色': '黑色', '名字': '张三'}
a = d1.keys()
print(a) # dict_keys(['身高', '体重', '肤色', '名字'])
print(list(a)) # ['身高', '体重', '肤色', '名字']
b = list(a)
print(b) # ['身高', '体重', '肤色', '名字']
d1["性别"] = "女"
print(a) # dict_keys(['身高', '体重', '肤色', '名字', '性别'])
print(list(a)) # ['身高', '体重', '肤色', '名字', '性别']
print(b) # ['身高', '体重', '肤色', '名字']
dict.values()
- 返回由字典值组成的一个新视图
- 返回的对象是视图对象，这意味着当字典改变时，视图也会相应改变
d1 = {'身高': 175, '体重': 65, '肤色': '黑色', '名字': '张三'}
a = d1.values()
print(a) # dict_values([175, 65, '黑色', '张三'])
print(list(a)) # [175, 65, '黑色', '张三']
b = list(a)
print(b) # [175, 65, '黑色', '张三']
d1["肤色"] = "黄色"
print(a) # dict_values([175, 65, '黄色', '张三'])
print(list(a)) # [175, 65, '黄色', '张三']
print(b) # [175, 65, '黑色', '张三']
dict.items()
- 返回由字典项 ((键, 值) 对) 组成的一个新视图
- 返回的对象是视图对象，这意味着当字典改变时，视图也会相应改变
d1 = {'身高': 175, '体重': 65, '肤色': '黑色', '名字': '张三'}
a = d1.items()
print(a) # dict_items([('身高', 175), ('体重', 65), ('肤色', '黑色'), ('名字', '张三')])
print(list(a)) # [('身高', 175), ('体重', 65), ('肤色', '黑色'), ('名字', '张三')]
b = list(a)
print(b) # [('身高', 175), ('体重', 65), ('肤色', '黑色'), ('名字', '张三')]
d1["体重"] = 77
d1["性别"] = "女"
print(a) # dict_items([('身高', 175), ('体重', 77), ('肤色', '黑色'), ('名字', '张三'), ('性别', '女')])
print(list(a)) # [('身高', 175), ('体重', 77), ('肤色', '黑色'), ('名字', '张三'), ('性别', '女')]
print(b) # [('身高', 175), ('体重', 65), ('肤色', '黑色'), ('名字', '张三')]
dict.get(key, default=None)
- key：指定的键
- default：如果指定的键不存在时，返回该值，默认为 None
- 返回指定的键 key 对应的值, 如果 key 不在字典中，则返回 default
dic = {"身高": 175, "体重": 65}
value = dic.get("体重")
print(value) # 65
value = dic["体重"]
print(value) # 65
value = dic.get("体", "KeyError")
print(value) # 返回一个字符串："KeyError"
value = dic["体"]
print(value) # 报错：KeyError
dict.update([other])
- 使用来自 other 的键 / 值对更新字典，如果键相同，则覆盖原有的键
- other：可以是另一个字典对象；一个包含键/值对的可迭代对象；关键字参数
d1 = {'身高': 175, '名字': '张三'}
d2 = {'肤色': '巨黑'}
d3 = {'身高': '1米75'}
# other 为另一个字典对象
d1.update(d2)
print(d1) # {'身高': 175, '名字': '张三', '肤色': '巨黑'}
d1.update(d3)
print(d1) # {'身高': '1米75', '名字': '张三', '肤色': '巨黑'}
# other 为一个包含键/值对的可迭代对象
d1.update([("地址", "不详"), ("性别", "男")])
print(d1) # {'身高': '1米75', '名字': '张三', '肤色': '巨黑', '地址': '不详', '性别': '男'}
# other 为关键字参数
d1.update(体重=105, 肤色='小白')
print(d1) # {'身高': '1米75', '名字': '张三', '肤色': '小白', '地址': '不详', '性别': '男', '体重': 105}
dict.pop(key[,default])
- key：指定的键
- default：指定当键不存在时应该返回的值
- 移除指定的键 key , 并返回对应的值, 如果 key 不在字典中，则返回 default
- 如果 default 未给出且 key 不存在于字典中，则会引发 KeyError
d1 = {'身高': 175, '名字': '张三', '年龄': 18}
value1 = d1.pop('年龄')
print(d1) # {'身高': 175, '名字': '张三'}
print(value1) # 18
# value2 = d1.pop('年')
dict.popitem()
- 从字典中移除最后一个键值对，并返回它们构成的元组(键, 值)
dic = {'name': '小明', '年龄': 18, '学历': '本科'}
item = dic.popitem()
print(item) # ('学历', '本科')
print(dic) # {'name': '小明', '年龄': 18}
dict.setdefault(key, default=None)
- 如果字典存在键 key，返回它的值
- 如果不存在，加入值为 default 的键 key，并返回 default，default 默 认为 None
dic = {'name': '小明', '年龄': 18, '学历': '本科'}
item = dic.setdefault('年龄')
print(item) # 18
item = dic.setdefault("性别")
print(item) # None
print(dic) # {'name': '小明', '年龄': 18, '学历': '本科', '性别': None}
item = dic.setdefault("地址", "不详")
print(item) # 不详
print(dic) # {'name': '小明', '年龄': 18, '学历': '本科', '性别': None, '地址': '不详'}
dict.copy()
- 返回原字典的浅拷贝
dic = {'name': '小明', '年龄': 18, '学历': '本科'}
new_dic = dic.copy()
print(new_dic) # {'name': '小明', '年龄': 18, '学历': '本科'}
dict.clear()
- 移除字典中的所有元素，无返回值
dic = {'name': '小明', '年龄': 18, '学历': '本科'}
dic.clear()
print(dic) # {}
6576
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
