003字典基本操作

字典的基本用法

在 Python 中，字典是一种可以将相关的两个信息关联起来的操作，并且字典可存储的信息量几乎不受限制
字典是 Python 提供的一种常用的数据结构，它用于存放具有映射关系的数据。为了保存具有映射关系的数据， Python 提供了字典，字典相当于保存了两组数据，其中一组数据是关键数据，被称为 key；另一组数据可通过 key 来 访问，被称为 value。

创建字典

字典是以 key、value 的形式创建的
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中, 格式如下所示：
d = {key1 : value1, key2 : value2 }
一般情况下，字典的创建可以有以下几种方式：

#创建一个空的字典
my_dict1 = {}

#创建key值为整数的字典
my_dict2 = {1:'apple',2:'ball'}

#创建key值为string的字典
my_dict3 = {'name1':'apple','name2':'ball'}

#用dict()函数创建字典
my_dict5 = dict({1:'apple',2:'ball'})

#以元组的形式组成序列创建字典
my_dict6 = dict([(1,'apple'),(2,'ball')])

#创建空白字典
my_dict7 = dict()

获取字典中的元素

通过key获取value

my_dict8 = {'name':'John','age':25,1:[2,4,3]}

print(my_dict8['name'])
print(my_dict8.get('name'))


#结果
John
John

通过value来获取key

通过 value 来获取 key 值，在 Python 中并没有提供直接的方法，我们可以通过自定义函数来实现，如下：

def get_keys(d,value): #d为字典
    return [k for k,v in d.items() if v==value]

#调用函数
get_keys(my_dict8,'John')


#结果
['name']

在字典中修改或者添加元素

在字典中，可以修改已有 key 对应的 value 值，或者添加新的 key-value 键值对数据，如下：

#修改已有key对应的value的值
my_dict8['age']=98
print(my_dict8)

#结果
{'name': 'John', 'age': 98, 1: [2, 4, 3]}

#添加新的key-value数据组
my_dict8['gender']='man'
print(my_dict8)

#结果
{'name': 'John', 'age': 98, 1: [2, 4, 3], 'gender': 'man'}

从字典中删除元素

pop()方法

移除字典数据 pop() 方法的作用是：删除指定给定键所对应的值，返回这个值并从字典中把它移除。

#使用pop()方法删除
my_dict8.pop('age')
print(my_dict8)

#结果
{'name': 'John', 1: [2, 4, 3], 'gender': 'man'}

del方法

#使用del方法来删除
del my_dict8['name']

print(my_dict8)

#结果
{1: [2, 4, 3], 'gender': 'man'}

popitem()方法

在 Python 3.5 版本以及之前的时候，使用 popitem() 可能是随机删除的， 从 Python 3.7 版本开始，使用 popitem() 方法是删除最后一项，因为字典默认是记住了顺序的

#使用popitem()方法来删除
my_dict8.popitem()
print(my_dict8)

#结果
{1: [2, 4, 3]}

clear()方法

clear() 方法是用来清除字典中的所有数据，因为是原地操作，所以返回 None（也可以理解为没有返回值）

my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'}

my_dict8.clear()
print(my_dict8)

#结果
{}

字典内置函数与方法

my_dict6 = dict([(1,'apple'),(2,'ball')])
my_dict8 = {'name':'John','age':25,1:[2,4,3],'gender':'man'}

print(len(my_dict8))  # 4
print(str(my_dict6))  # {1: 'apple', 2: 'ball'}
print(type(my_dict8))  # <class 'dict'>

my_dict8 = {'name':'John','age':25,1:[2,4,3],'gender':'man'}

print('copy:',my_dict8.copy())
#结果  copy: {'name': 'John', 'age': 25, 1: [2, 4, 3], 'gender': 'man'}

print("keys:",my_dict8.keys())
#结果  keys: dict_keys(['name', 'age', 1, 'gender'])

print("values:",my_dict8.values())
#结果  values: dict_values(['John', 25, [2, 4, 3], 'man'])

print("items:",my_dict8.items())
#结果  items: dict_items([('name', 'John'), ('age', 25), (1, [2, 4, 3]), ('gender', 'man')])

update方法

通过 update 方法，可以更新字典的数据内容：

my_dict6 = {'name':'Lemon','age':25,1:[2,4,3],'gender':'man'}
my_dict8 = {'name':'John','age':25,1:[2,4,3],'gender':'man'}

my_dict8.update(my_dict6)

print(my_dict8)
#结果  {'name': 'Lemon', 'age': 25, 1: [2, 4, 3], 'gender': 'man'}

fromkeys方法

seq = ['name','age','city']
value = ['Lemon',18,'cs']

my_dict9 = dict.fromkeys(seq,value)

print(my_dict9)
#结果  
{'name': ['Lemon', 18, 'cs'],
 'age': ['Lemon', 18, 'cs'],
 'city': ['Lemon', 18, 'cs']}

zip()方法

my_dict10 = dict(zip(seq,value))

print(my_dict10)
#结果  {'name': 'Lemon', 'age': 18, 'city': 'cs'}

setdefault方法

dict.setdefault(key, default=None)
该方法接收两个参数，第一个参数是健的名称，第二个参数是默认值。
假如字典中不存在给定的键，则把默认值赋值给对应的 value，并返回默认值
反之，不修改 value，只返回 value。

my_dict8 = {'name': 'John', 'age': 25 , 1: [2, 4, 3], 'gender': 'man'}

print("字典中存在的key，返回对应value:",my_dict8.setdefault('age',0))
print("字典中不存在的key,返回默认值：",my_dict8.setdefault('age1',0))

#结果
字典中存在的key，返回对应value: 25
字典中不存在的key,返回默认值： 0

#用setdefault()方法统计一个列表里单词出现的次数
strings = ("Lemon","kitten","Lemon","Lemon","Lemon_zs","Lemon","Lemon","Lemon_zs")

counts = {}
for kw in strings:
    counts[kw] = counts.setdefault(kw,0)+1
    
print(counts)
#结果
{'Lemon': 5, 'kitten': 1, 'Lemon_zs': 2}

字典推导式

一般式：
{key: value for (key, value)in iterable}

my_dict01 ={x: x*x for x in range(6)}

print(my_dict01)
#结果  {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

#通过两个list创建字典
keys = ['name','age','city']
values = ['Lemon',18,'cs']

my_dict02 = {k:v for (k,v) in zip(keys,values)}

print(my_dict02)
#结果
{'name': 'Lemon', 'age': 18, 'city': 'cs'}

字典合并

x={'a':1,'b':2}
y={'b':4,'c':5}

z1 = {**x, **y)
print(z1)
#结果
{'a': 1, 'b': 4, 'c': 5}

多个字典合并

def merge_dicts(*dict_args):
    result = {}
    for item in dict_args:
        result.update(item)
    return result

x1 = {'a':1,'b':2}
y1 = {'b':4,'c':5}
x2 = {'d':8,'e':10}

z3 = merge_dicts(x1,y1,x2)
print(z3)
#结果
{'a': 1, 'b': 4, 'c': 5, 'd': 8, 'e': 10}

嵌套型字典

字典是以 key、value 的形式创建的，而嵌套型的字典有一个特征，就是 key 对应的 value 值也可以是一个字典。 最简洁的嵌套型字典如下：

d = {key1:{key3:value3},key2:{key4:value4}}

创建嵌套型字典

nested_dict01 = {1:{'name':'Lemon','age':'18','city':'cs'},
                2:{'name':'Lemon_zs','age':'18','city':'changchun'}}
                
print(nested_dict01)
#结果
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
 2: {'name': 'Lemon_zs', 'age': '18', 'city': 'changchun'}}

从嵌套型字典中获取元素

print(nested_dict01[1]['name'])
print(nested_dict01[2]['city'])

#结果
Lemon
changchun

修改嵌套型字典的元素

#增加一个空的字典
nested_dict01[3] = {}
print(nested_dict01)
#结果
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
 2: {'name': 'Lemon_zs', 'age': '18', 'city': 'changchun'},
 3: {}}

#修改增加新的元素
nested_dict01[2]['age'] = '26'
print(nested_dict01)
#结果
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
 2: {'name': 'Lemon_zs', 'age': '26', 'city': 'changchun'},
 3: {}}

#增加新的元素
nested_dict01[3]['name'] = 'xsk'
print(nested_dict01)
#结果
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
 2: {'name': 'Lemon_zs', 'age': '26', 'city': 'changchun'},
 3: {'name': 'xsk'}}

#在嵌套型字典中直接添加一个字典
nested_dict01[5] = {'name':'rx','age':'3','city':'ly'}
print(nested_dict01)
#结果
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
 2: {'name': 'Lemon_zs', 'age': '26', 'city': 'changchun'},
 3: {'name': 'xsk'},
 5: {'name': 'rx', 'age': '3', 'city': 'ly'}}

#删除某个具体的元素内容
del nested_dict01[5]['city']
print(nested_dict01)
#结果
{1: {'name': 'Lemon', 'age': '18', 'city': 'cs'},
 2: {'name': 'Lemon_zs', 'age': '26', 'city': 'changchun'},
 3: {'name': 'xsk'},
 5: {'name': 'rx', 'age': '3'}}

通过for循环来获取嵌套字典内的元素

for main_id, main_info in nested_dict01.items():
    print('\nmain id:',main_id)
    
    for key in main_info:
        print(key+':',main_info[key])

#结果
main id: 1
name: Lemon
age: 18
city: cs

main id: 2
name: Lemon_zs
age: 26
city: changchun

main id: 3
name: xsk

main id: 5
name: rx
age: 3