标签：通过   解构   存储   封装   不能   划线   个数   返回   body   

字典dict

• 与列表的区别：列表可以存储大量的数据类型，但是只能按照顺序存储，数据与数据之间关联性不强
• 字典(dict)是python中唯?的?个映射类型.他是以{ }括起来的键值对组成.
• 字典中的键值对的保存排列是无序的（不可切片，只能通过key来找value），但每一个键和值（key:value）是对应的，所以在查找值时速度很快，根据键通过哈希算法得出对应值的内存地址
• key必须是不可变的. value没有要求.可以保存任意类型的数据
• 已知的可哈希(不可变)的数据类型: int, str, tuple, bool 不可哈希(可变)的数据类型: list, dict, set

命令格式：

字典名:{‘键1‘:值1，‘键2‘:值2，....}

# 合法的键
dic = {123: 456, True: 666, "id": 1, "name": ‘杨梅‘, "age": 19, "stu": [‘狼‘, ‘羊‘], (1, 2, 3): ‘开开心心‘}
print(dic[123])
print(dic[True])
print(dic[‘id‘])                         #key通常用int或str来表示，当然tuple、bool也可以
print(dic[‘stu‘])
print(dic[(1, 2, 3)])

# 不合法的键
dic = {[1, 2, 3]: ‘罗志祥‘}               # 列表list是可变的. 不能作为key
dic = {{1: 2}: "多人"}                    # 字典dict是可变的. 不能作为key
dic = {{1, 2, 3}: ‘运动‘}                 # 集合set 是可变的, 不能作为key

一、字典的增删改查

1.增加?

1.1定义键值对的同时增加

dic={}
dic[‘name‘]=‘杨梅’
dic[‘age‘]=12
print(dic)
结果：
{‘name‘: ‘杨梅‘, ‘age‘: 12}

1.2通过setdefault设置默认值

当setdefault中第一个参数存在这个字典中就就不进行添加操作,否则就添加

dic={}
a=dic.setdefault(‘many‘,‘3000‘)
print(a)
print(dic)
结果：
3000
{‘many‘:‘3000‘}

2.删除?

2.1删除指定键值对pop

dic={‘many‘:‘3000‘}
dic.pop(‘many‘)                              # pop删除有返回值,返回的是被删的值
print(dic)
结果：
dic={}

2.2删除随机键值对popitem

dic={‘many‘:‘3000‘}
dic.popitem()                                 #随机删除，python3.6中默认删除最后一个
print(dic)
结果：
dic={}

2.3清空字典

dic={‘many‘:‘3000‘}
dic.clear()                                    #清空字典

3.改?

• 注意：对应的键有的话就改值，没有就增加键值对到字典中

3.1单个键值对修改

dic={‘many‘:‘3000‘}
dic[‘many‘]=‘4000‘
print(dic)
结果：
{‘many‘:‘4000‘}

3.2多个键值对修改update

dic={‘many‘:‘3000‘}
dic.update({‘many‘:‘4000‘,‘book‘:‘5000‘})
print(dic)
结果：
{‘many‘: ‘4000‘, ‘book‘: ‘5000‘}

4.查?

4.1通过键来查找值

dic={‘many‘:‘3000‘}
a=dic[‘many‘]
print(a)
结果：
3000

4.2通过get来查找值

dic={‘many‘:‘3000‘}
a=dic.get(‘many‘)
print(a)
结果：
3000

4.3get查找值时可以自定义返回的结果

dic={‘many‘:‘3000‘}
a=dic.get(‘many‘,‘找不到就太棒了‘)
print(a)
结果：
3000

dic={‘many‘:‘3000‘}
a=dic.get(‘any‘,‘找不到就太棒了‘)
print(a)
结果：
找不到就太棒了

二、字典的其他操作

1.获取字典中所有的键(keys)

dic={‘many‘: ‘4000‘, ‘book‘: ‘5000‘}
key_list = dic.keys()    
print(key_list)

结果:
dict_keys([‘many‘, ‘book‘])
# 一个高仿列表,存放的都是字典中的key

2.获取字典中所有的值(values)

dic={‘many‘: ‘4000‘, ‘book‘: ‘5000‘}
value_list = dic.values()
print(value_list)

结果:
dict_values([‘4000‘, ‘5000‘])
#一个高仿列表,存放都是字典中的value

3.获取字典中所有的键值对(items)

dic={‘many‘: ‘4000‘, ‘book‘: ‘5000‘}
key_value_list = dic.items()
print(key_value_list)
结果:
dict_items([(‘many‘, ‘4000‘), (‘book‘, ‘5000‘)])

# 一个高仿列表,存放是多个元祖,元祖中第一个是字典中的键,第二个是字典中的值

三、字典遍历

1.循环打印字典中的键

dic={‘many‘:‘4000‘,‘book‘:‘5000‘}
for i in dic.keys()
print(i)

2.循环打印字典中的值

dic={‘many‘:‘4000‘,‘book‘:‘5000‘}
for i in dic.values()
print(i)

3.循环打印字典中的键值对（元组形式）

dic={‘many‘:‘4000‘,‘book‘:‘5000‘}
for i in dic.items()
print(i)

4.循环打印字典中的键和值（解构式）

dic={‘many‘:‘4000‘,‘book‘:‘5000‘}
for k,v in dic.items():
    print(‘这是键‘,k)
    print(‘这是值‘,v)

四、解构和封装

• 解构可以将内容分别赋值到变量当中,我们使用解构就能够快速的将值使用
• 把线性结构的元素解开，并顺序的赋给其他变量
• 左边接纳的变量数要和右边解开的元素个数一致

例-解构：
a = 4 
b = 5 
temp = a 
a = b 
b = temp 
#等价于
a,b = b,a #右边使用了封装，左边使用了解构


例-封装：
t1 = (1,2) #定义元组
t2 = 1,2  #将1和2封装成元组
type(t1)
type(t2)

1.其他解构举例

例：
lst = [3, 5]
first, second = lst 
print(first, second)

例：
a,b = 1,2   #正常的封装解构
a,b = (1,2) #元组的封装解构
a,b = [1,2] #列表的封装解构
a,b = {10,20} #set的封装解构
a,b = {‘a‘:10,‘b‘:20} # 非线性结构也可以解构

2.解构时*号的妙用

• 使用*变量名接收，但不能单独使用
• 被*变量名 收集后组成一个列表

lst = list(range(1, 21, 2)) #把1-21之间的数写入列表lst中
head, *mid, tail = lst      #执行结果1 [3, 5, 7, 9, 11, 13, 15, 17] 19
*lst2 = lst                 #不能单独使用 
*body, tail = lst           #执行结果 [1, 3, 5, 7, 9, 11, 13, 15, 17] 19
head, *tail = lst           #执行结果 1 [3, 5, 7, 9, 11, 13, 15, 17, 19]
head, *m1, *m2, tail = lst  #只能有一个*变量名
head, *mid, tail = "abcdefghijklmn"    #执行结果 a [‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘, ‘h‘, ‘i‘, ‘j‘, ‘k‘, ‘l‘, ‘m‘] n
type(mid)                   #mid 类型是列表 list

3.‘’丢弃变量‘’（_下划线的使用）

• 这是一个惯例，是一个不成文的规定，不是标准

• 如果不关心一个变量，就可以定义变量的名字为_

• _是一个合法的标识符，也可以作为一个有效的变量使用，但是定义成下划线就是希望不要被使用，除非你明确的知道这个数据需要使用

• _这个变量本身无任何语义，没有任何可读性，所以不是用来给人用的

• Python中很多库，都使用这个变量，使用十分广泛，请不要在不明确变量作用域的情况下使用_导致和库中的冲突

lst = [9,8,7,20]
first, *second = lst
head, *_, tail = lst
print(head)
print(tail)    #_是合法的标识符，看到下划线就知道这个变量就是不想被使用
print(_)
结果：
9
20
[8,7]

五、字典嵌套

• 根据键来获取值，若值中包含字典还根据键来获取，若值中包含列表则用索引来获取元素

dic = {
    ‘name‘:‘杨梅‘,
    ‘age‘:18,
    ‘wife‘:[{‘name‘:‘林志玲‘,‘age‘:17}],
    ‘children‘:[‘熊大‘,‘熊二‘]
}

dic1=dic[‘name‘]                        #获取杨梅的名字
dic2=dic[‘wife‘][0][‘name‘]             #获取杨梅老婆的名字
dic3=dic[‘wife‘][0][‘age‘]              #获取杨梅老婆的年龄
dic4=dic[‘children‘][0]                 #获取杨梅的大孩子

8.字典dict和解构-封装

标签：通过   解构   存储   封装   不能   划线   个数   返回   body   

原文地址：https://www.cnblogs.com/yangte/p/13394601.html