Python数据类型之字典

Python 中有六个标准的数据类型：

在 Python 中，变量就是变量，它没有类型.
我们所说的"类型"是变量所指的内存中对象的类型。

Python3 的六个标准数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

不可变数据（3 个）：
Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：
List（列表）、Dictionary（字典）、Set（集合）。
理解：

 可变数据和不可变数据是相对于引用地址来说的，不可变数据类型不允许变量的值
 发生变化，如果改变了的变量的值，相当于新建了一个对象，而对于相同的值的对象，
 内部会有一个引用计数来记录有多少个变量引用了这个对象。可变数据类型允许变量
 的值发生变化。对变量进行修改操作只会改变变量的值，不会新建对象，变量引用的
 地址也不会发生变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，
 即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在
 引用计数，是实实在在的对象。

简单地讲，可变数据和不可变数据的变是相对于引用地址来说的，
不是不能改变其数据，而是改变数据的时候会不会改变变量的引用地址。

---

字典

字典更适合保存不同数据 或者 需要定位数据，比如一个商品的不同信息、一个人的不同信息。
采用字典：既能存储多个数据，还能在访问元素的很方便的定位到需要的元素。

# 一个字典保存5个学生的成绩，
score_dict = {"小明":66,"小花":100,"jack":70,"tom":70,"bob":99}

1、定义字典

语法：{键1:值1, 键2:值2, 键3:值3, …, 键n:值n}
说明：

• 字典和列表类似，都可以用来存储多个数据
• 在列表中查找某个元素时，是根据索引进行的；字典中找某个元素时，是根据键查找的（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
• 字典中的每个元素都由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值
• 键可以使用数字、布尔值、元组，字符串等不可变数据类型，但是一般习惯使用字符串，切记不能使用列表等可变数据类型,但是，值的数据类型没有限制
• 每个字典里的key都是唯一的，如果出现了多个相同的key,后面的value会覆盖之前的value

【面试题】定义字典的方式有几种，举例说明

# 1.  {key1:value1,key2:value2....}       
dict1 = {'name':'张三','age':18,'hobby':'唱歌'}  

# 2. 字典[key]=value          
dict2 = {}
dict2['aaa'] = 10

# 3.dict(key1=value1,key2=value2....)
dict3 = dict(name='坤坤',hobby='篮球')
dict31 = {10:'a',20:'b'}
print(dict3)  # {'name': '坤坤', 'hobby': '篮球'}

# 4.dict([(key1,value1),(key2,value2)....])
dict41 = dict([('name','坤坤'),('hobby','篮球')])

# 5.dict(zip([key1,key2......],[value1,value2.......]))
# zip:映射  
dict51 = dict(zip(['a','b','c'],[34,6,78]))
print(dict51)
dict51 = dict(zip(('a','b','c'),(34,6,78)))
print(dict51)
dict51 = dict(zip(['a','b','c'],[34,6,78,45,7,8,9,9]))
print(dict51)
dict51 = dict(zip(['a','b','c','d','e'],[34,6,78]))
print(dict51)

2、字典的使用

字典 ： d1 = { ‘a’ :10 , ‘b’ : 20 }
集合： d2 = { 34 , 354 , 7 , 89 }
注意：{}为空的情况下，默认表示字典
d3 = {} # 空字典

键是唯一的

每个字典中的key是唯一的，如果出现了多个相同的key，后面的value会覆盖之前的value

dict1 = {'name':'小明','age':10,'name':'张三'}
print(dict1)  # {'name': '张三', 'age': 10}

---

###值可以重复

dict2 = {'张三':88,'王五':88,'小明':100}
print(dict2)  # {'张三': 88, '王五': 88, '小明': 100}

---

键值的数据类型

• 键只能是不可变的数据类型

  d1 = {10:24,34.56:20,'abc':54,True:35,(4,5,5):'gaga'}
  print(d1)
  
  # 错误写法
  # d2 = {[34,56,7]:'abc'}
  # print(d2)
  

• 值可以是任意类型

---

字典是无序的

有序的数：【索引】：列表 字符串 元组
无序的数据：字典 集合
字典的本质是无序的
在Python3.7之前，打印字典输出结果是无序的
在Python3.7之后，打印字典输出结果看起来是有序的

---

3、字典中键值的访问

a.字典中的键相当于列表中的索引，列表中通过索引访问元素，字典中通过键访问对应的值

# 1.通过键访问值
dict1 = {'name':'张三','age':18,'hobby':'唱歌'}
print(dict1)

# a.字典[key]:只能获取存在的key对应的value
print(dict1['age'])
# print(dict1['weight'])  # KeyError: 'weight'

# b.字典.get(key)：如果key不存在，返回None         ******
print(dict1.get('age'))
print(dict1.get('weight'))  # None

​b.字典是可变的数据类型，可以通过键将原值获取出来，然后进行修改

# 语法：字典[key] = 新值
dict1 = {'name':'张三','age':18,'hobby':'唱歌'}
print(dict1)


# a.key存在，则  字典[key] = 新值  表示修改字典中指定键对应的值
dict1['name'] = 'jack'
print(dict1)  # {'name': 'jack', 'age': 18, 'hobby': '唱歌'}

# b.key不存在，则  字典[key] = 新值 表示向字典中添加一对键值对   ******
dict1['weight'] = 173
print(dict1)  # {'name': 'jack', 'age': 18, 'hobby': '唱歌', 'weight': 173}

---

4、遍历字典

dict1 = {'name':'张三','age':18,'hobby':'唱歌'}

# 方式一               *******
for key in dict1:
 print(key,dict1[key])

# 方式二
# print(dict1.keys())
for key in dict1.keys():
 print(key,dict1[key])

# 方式三
# print(dict1.values())
for value in dict1.values():
 print(value)

# 方式四           ******
# print(dict1.items())
for key,value in dict1.items():     # 拆包
 print(key,value)

5、字典系统功能【重点掌握】

一、增

d1 = {'a':10,'b':20}
d1['c'] = 30
print(d1)
# 2.update():更新，合并        
# d1.update(d2):将d2中的键值对合并到d1中
d1 = {'a':10,'b':20}
d2 = {'abc':35,'xyz':19,'b':66}
d1.update(d2)
print(d1)

d2.update(d1)
print(d2)

---

二、删

# 1.pop(key):通过指定的key删除key-value对           *******
d1 = {'a': 10, 'b': 66, 'abc': 35, 'xyz': 19}
d1.pop('abc')
print(d1)
# d1.pop('d')  # KeyError: 'd'

# 2.clear():清空字典
d1.clear()
print(d1)

# 3.del 字典[key]
d1 = {'a': 10, 'b': 66, 'abc': 35, 'xyz': 19}
del d1['b']
print(d1)

---

三、查

print(len(d1))
print(d1.keys())
print(d1.values())
print(d1.items())

四、其他：copy()

注意：
 但凡是可变的数据类型，都有copy()的功能
 不可变的数据类型，没有copy()
 字典和列表相似，同样可以使用
 copy()	,	copy.copy()	,	copy.deepcopy()
 字典和列表一样遵循深浅拷贝的使用规则

【面试题】

d1 = {'a':34,'b':13}
d2 = d1.copy()
d1['a'] = 88
print(d2)  # {'a': 34, 'b': 13}

import copy
d3 = {'aga':26,'hgh':132,'m':[1,2,3]}
d4 = copy.deepcopy(d3)
d3['m'][-1] = 88
print(d3)  # {'aga': 26, 'hgh': 132, 'm': [1, 2, 88]}
print(d4)  # {'aga': 26, 'hgh': 132, 'm': [1, 2, 3]}

d3 = {'aga':26,'hgh':132,'m':[1,2,3]}
d4 = copy.copy(d3)  # d3.copy()
d3['m'][-1] = 88
print(d3)  # {'aga': 26, 'hgh': 132, 'm': [1, 2, 88]}
print(d4)  # {'aga': 26, 'hgh': 132, 'm': [1, 2, 88]}

---

6、字典推导式【重点掌握】

列表推导式：[元素的规律 for循环 if语句]
字典推导式：{key:value for循环 if语句}

1.【面试题】已知一个字典dict1 = {'a':10,'b':20},
书写一个程序，实现key和value的交换，生成一个新的字典

dict1 = {'a':10,'b':20}
# 方式一
dict11 = {}
for key,value in dict1.items():
 dict11[value] = key
print(dict11)

# 方式二       ******
dict12 = dict(zip(dict1.values(),dict1.keys()))
print(dict12)

# 方式三：      *******
dict13 = {value:key for key,value in dict1.items()}
print(dict13)

# 2.使用字典推导式生成一个字典{0:0,2:4,4:16,6:36,8:64}
# 方式一
dict2 = {num:num ** 2 for num in range(0,9,2)}
print(dict2)

# 方式二
dict21 = {num:num ** 2 for num in range(10) if num % 2 == 0}
print(dict21)

---

和列表推导式相同，都可以使用多个for或多个if，执行仍然是从左往右嵌套的关系

list3 = [m + n for m in 'xyz' for n in '123']
print(list3)   # 9  ,['x1', 'x2', 'x3', 'y1', 'y2', 'y3', 'z1', 'z2', 'z3']
dict3 = {m:n for m in 'xyz' for n in '123'}
print(dict3)   # 3  ,{'x': '3', 'y': '3', 'z': '3'}

---

注意：

• [xx for if ]是列表推导式,
• (xx for if )并不是元组推导式，而是生成器

list3 = [m + n for m in 'xyz' for n in '123']
print(type(list3))   # <class 'list'>
tuple3 = (m + n for m in 'xyz' for n in '123')
print(type(tuple3))  # <class 'generator'>生成器：函数中讲解

---