字典

一、字典的创建
    创建一个空字典 {} or dict()
    dict() 方法创建字典:
        1. key = value 2. 嵌套元组的列表 3. 嵌套列表的元组 4. **字典解包 5. dict(zip())
        6. dict.fromkeys(iterable, def_value) 
二、字典的取值
1.dict[key]取值 ： key不存在报错

2.get(key):key不存在返回None值
三、增
dict[key] = value key不存在增加，key存在就是修改
update() :2个字典合并
setdefault():新增key,存在不新增，不存在插入默认value
三、删
del dict[key] : 单个删除
pop(key):指定删除字典元素
popitem() 随机删除
del 整个字典
dict.lear() 字典清空，字典称为 {}字典
五、改 
dict[key]=value 修改和添加差不多 主要看key存不存在
六、copy() 浅拷贝，跟列表差不多
七、 迭代器(keys()、values()、items())
八、字典推导式：
字典推导式：{key:value for variable in iterable [if expression]}
九、字典解包

一、字典的创建

创建一个空字典

{} or dict()

image.png

dict() 方法创建字典

六种：key = value,嵌套元组的列表，嵌套列表的元组，zip(),**多个字典解包，dict.fromkeys(seq)

# dict()方法创建
# 1. key = value
dict1 = dict(firstname='ma', lastname='yun')
# 2. 嵌套元组的列表
dict1 = dict([('firstname', 'ma'), ('lastname', 'yun')])
# 3. 嵌套列表的元组
dict1 = dict((['firstname', 'ma'], ['lastname', 'yun']))
# 4. **字典解包
one = {'1': "a", '2': "b"}
two = {'4': "a", '3': "b"}
dict1 = dict(**one, **two)
# 5. dict(zip())
dict1 = dict(zip(['firstname', 'lastname'], ['ma', 'yun']))
# 6. dict.fromkeys(iterable, def_value) 创建一个默认值为None的字典，def_value默认为None
dict1 = dict.fromkeys(["name","age", "sex"], 2)
print(dict1)   # {'name': 2, 'age': 2, 'sex': 2}

二、字典的取值

1.dict[key]取值 ： key不存在报错

2.get(key):key不存在返回None值

# 通过dict[key]取值，key不存在会报错
print(adeng['name']) # 阿登
# print(adeng['name1']) # key不存在keyError错误 KeyError: 'name1'
# 通过dict.get(key):key存在返回value,key不存在返回，返回默认值None
print(adeng.get("age")) # 18
print(adeng.get("age1")) # None 不会报错，如果这里用key去取就报错了

三、增

dict[key] = value key不存在增加，key存在就是修改

adeng = {'name': '阿登', 'gender': '男', 'age': 18, 'love_into': 'eat apple', 'hobby':'数学'}
adeng[1] = 100
print(adeng)  # {'name': '向佳', 'gender': '男', 'age': 18, 'love_into': 'eat apple', 'hobby': '数学', 1: 100

update() :2个字典合并

adeng = {'name': '阿登', 'gender': '男', 'age': 18, 'love_into': 'eat apple', 'hobby':'数学'}
dict_new = dict((["a", True],["b", False]))

adeng.update(dict_new)
print(adeng) #{'name': '向佳', 'gender': '男', 'age': 18, 'love_into': 'eat apple', 'hobby': '数学', 1: 100, 'a': True, 'b': False}

​

setdefault():新增key,存在不新增，不存在插入默认value

# setdefault插入一个key，默认为None
print(adeng.setdefault("b")) # 因为key存在所以返回key的值 False
print(adeng.setdefault("c")) # 因为key不存在所以返回默认值 None
"""
 setdeafult(key,default) 原字典key存在就不新增，不存在就新增。跟dict[key]区别是：
 dict[key] 如果不知道key存不存在的话，这种方法可以修改原来存在key的值。而用setdefault()就不会。
 所以可以作为条件判定：
"""
one = {1:100,2:200}
if one.setdefault(3,300) == one.get(1):
    print("你要添加的key已经存在")
else:
    one.setdefault(3, 300)
    print(one)

四、删

del dict[key] : 单个删除

pop(key):指定删除字典元素

popitem() 随机删除

del 整个字典

dict.lear() 字典清空，字典称为 {}字典

adeng = {'name': '阿登', 'gender': '男', 'age': 18, 'love_into': 'eat apple', 'hobby': '数学'}

# 删除 单个key
del adeng["age"]
print(adeng)  # {'name': '阿登', 'gender': '男', 'love_into': 'eat apple', 'hobby': '数学'}
# 指定删除pop(key)
adeng.pop("name")
print(adeng) # {'gender': '男', 'love_into': 'eat apple', 'hobby': '数学'}
# 随机删除
adeng.popitem()
print(adeng) # {'gender': '男', 'love_into': 'eat apple'}
# 整个字典删除 del 字典名
del adeng
print(adeng) # NameError: name 'adeng' is not defined

五、改

dict[key]=value 修改和添加差不多 主要看key存不存在

adeng = {'name': '阿登', 'gender': '男', 'age': 18, 'love_into': 'eat apple', 'hobby': '数学'}
adeng["name"] = "向佳"
print(adeng["name"]) # 向佳

六、copy() 浅拷贝，跟列表差不多

one = {'name': '阿登', 'gender': '男', 'love_into': 'eat apple', 'hobby': ['数学', '岛国片']}
two = one
there = one.copy()

one["name"] = "向佳"
print('----'.center(150,'-'))
print(one)
print(two)
print(there)
'''
{'name': '向佳', 'gender': '男', 'love_into': 'eat apple', 'hobby': ['数学', '岛国片']}
{'name': '向佳', 'gender': '男', 'love_into': 'eat apple', 'hobby': ['数学', '岛国片']}
{'name': '阿登', 'gender': '男', 'love_into': 'eat apple', 'hobby': ['数学', '岛国片']}
可以看出修改了one two也变了。there没变
'''

one["hobby"][1] = "语文"
print(one)
print(two)
print(there)
'''
{'name': '向佳', 'gender': '男', 'love_into': 'eat apple', 'hobby': ['数学', '语文']}
{'name': '向佳', 'gender': '男', 'love_into': 'eat apple', 'hobby': ['数学', '语文']}
{'name': '阿登', 'gender': '男', 'love_into': 'eat apple', 'hobby': ['数学', '语文']}
'''
# 修改了可变列表作为value的值时，三者都变了。浅拷贝只拷贝父，子有可变类型一旦删除修改也会更改。

七、 迭代器(keys()、values()、items())

dict.keys() 所有key为列表
dict.values() 所有值为列表
字典.items() 所有 (key,value) 元组列表 拓展可以转化为列表 然后用+ 拼接起来 然后可以转化为字典
for m,n in dict.items()

'''
迭代
    dict.keys() 所有key为列表
    dict.values() 所有值为列表
    字典.items() 所有 (key,value) 元组列表
        拓展 可以转化为列表 然后用+ 拼接起来 然后可以转化为字典
    for m,n in dict.items()
'''
one = {'name': '阿登', 'gender': '男', 'love_into': 'eat apple', 'hobby': '数学'}

a = []
for i in one.keys():
    a.append(i)
print(a) # ['name', 'gender', 'love_into', 'hobby']

b = []
for i in one.values():
    b.append(i)

print(b) # ['阿登', '男', 'eat apple', '数学']

c = []
for m, n in one.items():
    c.append((m,n))

print(c) # [('name', '阿登'), ('gender', '男'), ('love_into', 'eat apple'), ('hobby', '数学')]

# a,b列表还原成原来的字典
dict1 = dict(zip(a,b))
print(dict1) # {'name': '阿登', 'gender': '男', 'love_into': 'eat apple', 'hobby': '数学'}
# c 是一个嵌套元组的列表，元组还是key=value的形式类似想dict.items()
dict2 = dict(c)
print(dict2) #  {'name': '阿登', 'gender': '男', 'love_into': 'eat apple', 'hobby': '数学'}

八、字典推导式：

字典推导式：{key:value for variable in iterable [if expression]}

1、for 循环：遍历可迭代对象，将其值赋给变量。
2、if 语句：筛选满足 if 条件的结果。
3、存储结构：以键值对的方式存储在字典中

"""
字典推导式：{key:value for variable in iterable [if expression]}
1、for 循环：遍历可迭代对象，将其值赋给变量。
2、if 语句：筛选满足 if 条件的结果。
3、存储结构：以键值对的方式存储在字典中。
"""
a = [('name', '阿登'), ('gender', '男'), ('love_into', 'eat apple'), ('hobby', '数学')]
dict_a = {m:n for m,n in a }
print(dict_a) # {'name': '阿登', 'gender': '男', 'love_into': 'eat apple', 'hobby': '数学'}

九、字典解包

字典解包： * kyes ** values

a, b, c = {'name': '阿登', 'gender': '男', 'age': 18}
print(a,b,c,type(a),type(b),type(c))

# 可以看出a b c接收了 字典的key
name gender age <class 'str'> <class 'str'> <class 'str'>

           
a, *b, c = adeng = {'name': '阿登', 'gender': '男', 'age': 18, 'love_into': 'eat apple', 'hobby':'数学'}
print(a,b,c,type(a),type(b),type(c))

可以看出 a c接收的字典守尾的key b作为列表接收了剩余的key
name ['gender', 'age', 'love_into'] hobby <class 'str'> <class 'list'> <class 'str'>

def fo(name,salary):
    print("{:□^10}的工资是{}".format(name,salary))

dict_info = {"name": "阿登",'salary':16000}
# ** 两个星号解包是字典独有的，实际就是以key=value的形式传给函数
fo = fo(**dict_info) # □□□□阿登□□□□的工资是16000