『无为则无心』Python序列 — 21、Python字典及其常用操作

『无为则无心』Python序列 — 21、Python字典及其常用操作

1、字典的应用场景

思考1: 如果有多个数据,例如:’Tom’, ‘男’, 20,如何快速存储?

答:列表

list1 = ['Tom', '男', 20]

思考2:如何查找到数据’Tom’?

答:查找到下标为0的数据即可。

list1[0]

思考3:如果将来数据顺序发生变化,如下所示,还能用list1[0]访问到数据’Tom’吗?。

list1 = ['男', 20, 'Tom']

答:不能,数据’Tom’此时下标为2。

思考4:数据顺序发生变化,每个数据的下标也会随之变化,如何保证数据顺序变化前后能使用同一的标准查找数据呢?

答:字典,字典里面的数据是以键值对形式出现,字典数据和数据顺序没有关系,即字典不支持下标,后期无论数据如何变化,只需要按照对应的键的名字查找数据即可。

2、字典的概念

  • 字典属于一种新的数据结构,称为映射(mapping)。
    字典不再是序列,无法通过为止索引完成元素值的获取,只能通过键索引实现。
    字典也是Python中唯一内建的映射类型。
  • 字典的作用和列表类似,都是用来存储对象的容器。
  • 列表存储数据的性能很好,但是查询数据的不是很方便(要么知道下标,要么就要一个一个遍历)。
  • 在字典中每一个元素都有一个唯一的名字,通过这个唯一的名字可以快速的查找到指定的元素。
  • 在查询元素时,字典的效率是非常快的。
  • 在字典中可以保存多个对象,每个对象都会有一个唯一的名字。
    • 这个唯一的名字,我们称其为键(key),
      通过key可以快速的查询value
      字典的键可以是任意的不可变对象(intstrbooltuple …),但是一般我们都会使用str
      字典的键是不能重复的,如果出现重复的后边的会替换到前边的。
    • 这个对象,我们称其为值(value),字典的值可以是任意对象。
    • 所以字典,我们也称为叫做键值对(key-value)结构。
    • 每个字典中都可以有多个键值对,而每一个键值对我们称其为一项(item)。

3、创建字典的语法

字典特点

  • 符号为大括号。
  • 数据为键值对形式出现。
  • 各个键值对之间用逗号隔开。
# 1.创建有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(type(dict1))  # <class 'dict'>

# 2.创建空字典
# 方式1
dict2 = {}
print(type(dict2))  # <class 'dict'>
# 方式2,通过dict()函数
dict3 = dict()
print(type(dict3))  # <class 'dict'>

# 3.使用dict()函数来创建有元素的字典
# 每一个参数都是一个键值对,参数名就是键,参数名就是值
# (这种方式创建的字典,key都是字符串)
d = dict(name='孙悟空', age=18, gender='男')
print(d) # {'name': '孙悟空', 'age': 18, 'gender': '男'}
print(type(d)) # <class 'dict'>

注意:一般称冒号前面的为键(key),简称k;冒号后面的为值(value),简称v

4、字典常见操作

(1)字典的增加操作

写法:字典序列[key] = 值

注意:如果key存在则修改这个key对应的值;如果key不存在则新增此键值对。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# 1.修改字典中name的值。
dict1['name'] = 'Rose'
# 结果:{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)

# 2.新增id属性
dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)

注意:字典为可变类型。

(2)字典的删除操作

@1、del()方法 或 del函数

del()方法 或 del函数:删除字典或删除字典中指定键值对。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

# 1.删除字典中指定的键值对
# 结果:{'name': 'Tom', 'age': 20}
del dict1['gender']
print(dict1)

# 2.通过del删除整个字典
# 结果:NameError: name 'dict1' is not defined
del(dict1)
print(dict1)

# 3.所删除的key不包含在字典中,会抛异常
# 结果:KeyError: 'genders'
del dict1['genders']
print(dict1)

@2、clear()方法

clear()方法:清空字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1)  # {}

@3、popitem()方法

popitem()方法随机删除字典中的一个键/值对,一般都会删除最后一个键值对。

删除之后,它会将删除的key-value作为返回值返回,

返回的是一个元组,元组中有两个元素,第一个元素是删除的key,第二个是删除的value

"""
1.在字典中删除一个键值对。
输出结果:
result =  ('c', 3)
{'a': 1, 'b': 2}
"""
d = {'a': 1, 'b': 2, 'c': 3}
result = d.popitem()
print("result = ", result)
print(d)

# 2.当使用popitem()删除一个空字典时,会抛出异常。
# 结果:KeyError: 'popitem(): dictionary is empty'
d = {}
d.popitem()

@4、pop(key[, default])方法

"""
1.pop(key[, default])方法,
根据key删除字典中的key-value,
会将被删除的value返回!

输出结果:
result =  1
{'b': 2, 'c': 3}
"""
d = {'a': 1, 'b': 2, 'c': 3}
result = d.pop('a')
print("result = ", result)
print(d)


"""
2.如果删除的key,在字典中不存在,会抛出异常。

"""
# 结果:KeyError: 'f'
d = {'a': 1, 'b': 2, 'c': 3}
result = d.pop('f') # 异常

"""
3.如果指定了默认值,再删除不存在的key时,不会报错,
而是直接返回默认值。
输出结果:
result =  这是默认值
{'a': 1, 'b': 2, 'c': 3}
"""
d = {'a': 1, 'b': 2, 'c': 3}
result = d.pop('z','这是默认值')
print("result = ", result)
print(d)

(3)字典的修改操作

@1、通过key修改字典

写法:字典序列[key] = 值

注意:如果key存在则修改这个key对应的值 ,如果key不存在则新增此键值对。

dict1 = {'name': 'TOM', 'age': 20, 'gender': '男'}

# 修改
# 结果:{'name': 'Lily', 'age': 20, 'gender': '男'}
dict1['name'] = 'Lily'
print(dict1)

# 增加
# 结果:{'name': 'Lily', 'age': 20, 'gender': '男', 'id': 110}
dict1['id'] = 110
print(dict1)

@2、setdefault(key[, default])方法

"""
setdefault(key[, default]) 可以用来向字典中添加key-value,
如果key已经存在于字典中,则返回key的值,不会对字典做任何操作,
如果key不存在,则向字典中添加这个key,并设置value,返回默认值。
"""
# 1.存在key,不会对字典做任何操作,返回key的值
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
result = dict1.setdefault('name','猪八戒')
print('result =',result) # result = Tom
print(dict1) # {'name': 'Tom', 'age': 20, 'gender': '男'}

# 2.不存在key,添加值,返回key的默认值
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
result = dict1.setdefault('id','猪八戒')
print('result =',result) # result = 猪八戒
print(dict1) # {'name': 'Tom', 'age': 20, 'gender': '男', 'id': '猪八戒'}

@3、update([other])方法

"""
将其他的字典中的key-value添加到当前字典中
如果有重复的key,则后边的会替换到当前的
"""
# 结果:{'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
d = {'a': 1, 'b': 2, 'c': 3}
d2 = {'d': 4, 'e': 5, 'f': 6, 'a': 7}
d.update(d2)
print(d)

(4)字典的查找操作

@1、key值查找

key必须加引号,否则按变量识别。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 1.key存在返回对应的值
print(dict1['name'])  # Tom

# 2.字典中没有对应的key
# 结果KeyError: 'id'
print(dict1['id'])  # 报错

如果当前查找的key存在,则返回对应的值;否则则报错。

@2、get()方法

该方法用来根据键来获取字典中的值。

语法:

字典序列.get(key, 默认值)

注意:如果当前查找的key不存在则返回第二个参数(默认值),如果省略第二个参数,则返回None。

快速体验:

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 1.如果key存在,返回对应的值
print(dict1.get('name'))  # Tom

# 2.如果key不存在,返回默认值。
print(dict1.get('id', 110))  # 110

# 3.如果key不存在,也没有设置默认值,则返回None。
print(dict1.get('id'))  # None

@3、keys()方法

示例:

# 查找字典中所有的key,返回一个序列,包含字典中所有的key。
# 是一个可迭代的序列。(就是支持for遍历)
# 结果:dict_keys(['name', 'age', 'gender'])
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys())

遍历字典的key:

"""
# dict1.keys()得到可遍历的对象
输出结果: 
name
age
gender
"""
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
    print(key)

@4、values()方法

示例:

# 查找字典中所有的value值,返回一个序列,包含字典中所有的value值。
# 是一个可迭代的序列。
# 结果:dict_values(['Tom', 20, '男'])
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values())  

遍历字典的value:

"""
# dict1.values()得到可遍历的对象
输出结果: 
Tom
20
男
"""
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
    print(value)

@5、items()方法

示例:

# 查找字典中所有的键值对,返回一个序列,包含字典中所有的键值对(项)。
# 是一个可迭代的序列。
# 可迭代对象里面的数据是元组(有的也叫双值子序列),
# 元组中数据1是字典的key,元组中数据2是字典key对应的值。

# 结果:dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items()) 

遍历字典的元素:

"""
# dict1.items()得到可遍历的对象,其中的元素是一个元组。
输出结果: 
('name', 'Tom')
('age', 20)
('gender', '男')
"""
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
    print(item)

遍历字典的键值对:

也就是将得到的数据进行一个拆包动作。

"""
xx.items(): 返回可迭代对象,内部的元素是元组,
而元组有2个数据,将元组中的第一个数据赋值给第一个变量,第二个数据赋值给第二个变量。
也就是元组数据1是字典的key,元组数据2是字典的value,
这就是所谓的拆包动作。(可以看元祖中将的序列的拆包)

输出结果: 
name = Tom
age = 20
gender = 男
"""

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
    print(f'{key} = {value}')

(5)copy()复制

和列表中的用法一样,这里补充说明:

copy()方法用于对字典进行浅复制,复制以后的对象,和原对象是独立,修改一个不会影响另一个。

但注意,浅复制会简单复制对象内部的值,如果内部值也是一个可变对象,这个可变对象不会被复制。

#基本用法和列表一样。(可以看列表)

"""
# 字典的value可以存储的还是字典,
这个value值的字典用copy()方法的时候,是不进行复制的,
在内存中还是一份的,所以修改其中一个字典的value,
另一个也会改变。

输出结果:
d =  {'a': {'name': '猪八戒', 'age': 18}, 'b': 2, 'c': 3}
d2 =  {'a': {'name': '猪八戒', 'age': 18}, 'b': 2, 'c': 3}
"""
d = {'a': {'name': '孙悟空', 'age': 18}, 'b': 2, 'c': 3}
d2 = d.copy()
d2['a']['name'] = '猪八戒'
print("d = ", d)
print("d2 = ", d2)

分享到 :
相关推荐