pythonav资源分享

书接上文，本篇继续来进行讲解Python常见数据类型。

![](/media/uploads/2020/03/25/QQ20200325-021922%402x.png)

## 6. 字典(dict)

此处的字典和我们小时候用的`新华字典`大不同。

字典也可以当做是个容器，在内部可以存放数据。相比较于元组和列表，字典的元素必须是 `键值对`。

注意：在Python3.6+字典就是有序了，之前的字典都是无需。

### 6.1 字典定义
```python
info = {"age":12, "status":True, "name":"wupeiqi","hobby":['篮球','足球']}

# 例如： "age":12 称为一个键值对。
```
```python
department_dict = {
	"IT部门":["武沛齐","Alex"],
	"销售部":["张三","刘能","张扬"],
	"财务部":["歪歪"]
}
```
```python
department_dict = {
	"武沛齐":{"id":1,"gender":"男","email":"xx@live.com"},
	"Alex":{"id":1,"gender":"男","email":"xx@live.com"},
	"郭达":{"id":1,"gender":"男","email":"xx@live.com"},
	"刘能":{"id":1,"gender":"男","email":"xx@live.com"},
	"赵四":{"id":1,"gender":"男","email":"xx@live.com"},
	"广坤":{"id":1,"gender":"男","email":"xx@live.com"},
	...
}
```

注意：字典的键有特殊要求，即：`必须可哈希` 。 目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/dict

```python
# 合法
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅
哥', '美⼥'], (1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
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
```

### 6.2 常见方法

1. 所有的键
```python
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.keys() # 获取字典的所有的键，返回一个`高仿的`列表，存放的都是字典中的key。
print(data) # 输出：dict_keys(['age', 'status', 'name', 'email'])
```
```python
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for ele in info.keys():
	print(ele)
```
注意：在Python2中 字典.keys()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。

2. 所有的值
```python
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.values()
print(data) # 输出：dict_values([12, True, 'wupeiqi', 'xx@live.com'])
```
```python
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
for val in info.values():
	print(val) # 输出：dict_values([12, True, 'wupeiqi', 'xx@live.com'])
```
注意：在Python2中 字典.values()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示。

3. 所有的键值
```python
info = {"age":12, "status":True, "name":"wupeiqi","email":"xx@live.com"}
data = info.items()
print(data) # 输出 dict_items([('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com')])
```
```python
for item in info.items():
	print(item) # item是一个元组 (键，值)
```
```python
for key,value in info.items():
	print(key,value) # key代表键，value代表值，将兼职从元组中直接拆分出来了。
```
4. 更新字典键值对
```python
info = {"age":12, "status":True}
info.update({"age":14,"name":"武沛齐"}) # info中没有的键直接添加；有的键则更新值
print(info) # 输出：{"age":14, "status":True,"name":"武沛齐"}
```
5. 移除字典的简直对
```python
info = {"age":12, "status":True,"name":"武沛齐"}
data = info.pop("age")
print(info) # {"age":12,"name":"武沛齐"}
print(data) # 12
```
6. 根据键获取值
```python
info = {"age":12, "status":True,"name":"武沛齐"}
data = info.get("name",None) # 根据name为键去info字典中获取对应的值，如果不存在则返回None，存在则返回值。
print(data) # 输出：武沛齐
```

### 6.3 转换

由于字典的每一个元素是键值对，所以想要转换为字典的必须要有个特定的格式才能转换成功
```python
v = dict([("k1","v1"),("k2","v2")])
print(v) # 输出：{'k2': 'v2', 'k1': 'v1'}
```
```python
v = dict([ ["k1","v1"], ["k2","v2"] ])
print(v) # 输出：{'k2': 'v2', 'k1': 'v1'}
```
子元素必须包含两个元素，从而将值对应给字典的键、值。

### 6.4 其他
1. 取长度
```python
info = {"age":12, "status":True,"name":"武沛齐"}
data = len(info)
print(data) # 输出：3
```
2. 索引（键）
字典不同于元组和列表，字典的索引是`键`，而列表和元组则是 `0、1、2等数值` 。
```python
info = {"age":12, "status":True,"name":"武沛齐"}
print(info["age"])  	# 输出：12
print(info["name"])		# 输出：武沛齐
print(info["status"])	# 输出：True
print(info["xxxx"])   	# 报错，通过键为索引去获取之后时，键不存在会报错（以后项目开发时建议使用get方法根据键去获取值）
```
提示：字典根据键的查找速度非常快，远远大于列表或元组通过索引查找的速度，因为字典内部是基于hash存储。

3. 根据键 修改值 和 添加值 和 删除键值对
上述示例通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作
```python
info = {"age":12, "status":True,"name":"武沛齐"}
info["gender"] = "男" # gender键在字典中不存在，则自动在字典中新添加一个键值对
print(info) # 输出： {"age":12, "status":True,"name":"武沛齐","gender":"男"}
```
```python
info = {"age":12, "status":True,"name":"武沛齐"}
info["age"] = "18" # age键在info字典中已存在，则更新键对应的值
print(info) # 输出： {"age":18, "status":True,"name":"武沛齐"}
```
```python
info = {"age":12, "status":True,"name":"武沛齐"}
del info["age"] # 删除info字典中键为age的那个键值对（键不存在则报错）
print(info) # 输出： {"status":True,"name":"武沛齐"}
```
4. for循环
由于字典也属于是容器，内部可以包含多个键值对，可以通过循环对其中的：键、值、键值进行循环；
	```python
	info = {"age":12, "status":True,"name":"武沛齐"}
	for item in info.key():
		print(item)
	```
	```python
	info = {"age":12, "status":True,"name":"武沛齐"}
	for item in info.values():
		print(item)
	```
	```python
	info = {"age":12, "status":True,"name":"武沛齐"}
	for key,value in info.items():
		print(key,value)
	```
5. 字典嵌套
截止目前位置我们已学了：int/str/list/tuple/dict 五种常见数据类型，而其中list/tuple/dict类型中可以包含子元素，所以他们的内容就可以进行数据的嵌套。但在嵌套和对内部数据操作时要注意：`元组子元素不能变`、`不可哈希的list、dict不能做字典的键`。
	```python
	dic = {
		'name':'汪峰',
		'age':48,
		'wife':[{'name':'国际章','age':38}],
		'children':['第一个熊孩子','第二个熊孩子']
	}
	"""
	1. 获取汪峰的妻子名字
		d1 = dic['wife'][0]['name']
		print(d1)
	2. 获取汪峰的孩子们
		d2 = dic['children']
		print(d2)
	3. 获取汪峰的第一个孩子
		d3 = dic['children'][0]
		print(d3)
	4. 汪峰的媳妇姓名变更为 章子怡
		dic['wife'][0]['name] = "章子怡"
		print(dic)
	5. 汪峰再娶一任妻子
		dic['wife'].append({"name":"铁锤","age":19})
		print(dic)
	6. 给汪峰添加一个爱好：吹牛逼
		dic['hobby'] = "吹牛逼"
		print(dic)
	7. 删除汪峰的年龄
		del dic['age']
		或
		dic.pop('age')_
		print(dic)
	"""
	```

### 练习题
1. 根据需求写代码
	```
	dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
	请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
	请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
	请在k3对应的值中追加一个元素 44，输出修改后的字典
	请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
	```
2. 根据需求写代码
	```python
	dic1 = {
	 'name':['alex',2,3,5],
	 'job':'teacher',
	 'oldboy':{'alex':['python1','python2',100]}
	 }
	1，将name对应的列表追加⼀个元素’wusir’。
	2，将name对应的列表中的alex⾸字⺟⼤写。
	3，oldboy对应的字典加⼀个键值对’⽼男孩’,’linux’。
	4，将oldboy对应的字典中的alex对应的列表中的python2删除
	```

3. 循环提示用户输入，并将输入内容添加到字典中（如果输入N或n则停止循环）
	```python
	例如：用户输入 x1|wupeiqi ,则需要再字典中添加键值对 {'x1':"wupeiqi"}
	```

4. 写代码实现
    ```python
    v1 = {'alex','武sir','肖大'}
    v2 = []
    # 循环提示用户输入，如果输入值在v1中存在，则追加到v2中，如果v1中不存在，则添加到v1中。（如果输入N或n则停止循环）
    ```
5. 判断以下值那个能做字典的key ？那个能做集合的元素？
    - 1
    - -1
    - ""
    - None
    - [1,2]
    - (1,)
    - {11,22,33,4}
    - {'name':'wupeiq','age':18}

6. 将字典的键和值分别追加到 key_list 和 value_list 两个列表中，如：

```python
   key_list = []
   value_list = []
   info = {'k1':'v1','k2':'v2','k3':'v3'}
   ```

7. 字典dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}

```python
   a. 请循环输出所有的key
   b. 请循环输出所有的value
   c. 请循环输出所有的key和value
   d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
   e. 请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
   f. 请在k3对应的值中追加一个元素 44，输出修改后的字典
   g. 请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
   ```

8. 请循环打印k2对应的值中的每个元素。

```python
   info = {
       'k1':'v1',
       'k2':[('alex'),('wupeiqi'),('oldboy')],
   }
   ```

9. 有字符串"k: 1|k1:2|k2:3  |k3 :4" 处理成字典 {'k':1,'k1':2....}

10. 写代码
   ```python 
   """
   有如下值 li= [11,22,33,44,55,66,77,88,99,90] ,将所有大于 66 的值保存至字典的第一个key对应的列表中，将小于 66 的值保存至第二个key对应的列表中。
   
   result = {'k1':[],'k2':[]}
   """
   ```

11. 输出商品列表，用户输入序号，显示用户选中的商品

```python
    """
    商品列表：
      goods = [
    		{"name": "电脑", "price": 1999},
    		{"name": "鼠标", "price": 10},
    		{"name": "游艇", "price": 20},
    		{"name": "美女", "price": 998}
    	]
    要求:
    1：页面显示 序号 + 商品名称 + 商品价格，如：
          1 电脑 1999 
          2 鼠标 10
    	  ...
    2：用户输入选择的商品序号，然后打印商品名称及商品价格
    3：如果用户输入的商品序号有误，则提示输入有误，并重新输入。
    4：用户输入Q或者q，退出程序。
    """
    ```

## 7. 集合(set)

集合与元组和列表相似都用于做容器，在内部可以放一些子元素，但集合有三特殊特点： `子元素不重复` 、 `子元素必须可哈希`、`无序`.

提示：目前可哈希的数据类型 int/str/tuple;不可哈希的类型tuple/list/set 。

### 7.1 集合的定义
```
v1 = {1,2,99,18}
v2 = {"武沛齐","Alex","老妖","Egon"}
v3 = {1,True,"world",(11,22,33)}
```
集合与字典虽然都是用`{}`括号，但字典内部是键值对，而集合内部直接是值。

### 7.2 常用方法

1. 添加元素
	```python
	data = {"刘嘉玲", '关之琳', "王祖贤"}
	data.add("郑裕玲")
	print(data)
	```
	```python
	data = set()
	data.add("周杰伦")
	data.add("林俊杰")
	print(data)
	```
2. 删除元素
	```
	data = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
	data.discard("关之琳") 
	print(data)
	```
3. 交集
	```python
	s1 = {"刘能", "赵四", "⽪⻓⼭"}
	s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
	s3 = s1 & s2   			  # 方式一：取两个集合的交集
	s4 = s1.intersection(s2)) # 方式二：取两个集合的交集
	print(s3,s4)
	```
4. 并集
	```python
	s1 = {"刘能", "赵四", "⽪⻓⼭"}
	s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
	s3 = s1 | s2   			# 方式一：取两个集合的并集
	s4 = s1.union(s2)) 		# 方式二：取两个集合的并集
	print(s3,s4)
	```
5. 差集
	```python
	s1 = {"刘能", "赵四", "⽪⻓⼭"}
	s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
	s3 = s1 - s2   					# 方式一：差集，s1中有且s2中没有的值
	s4 = s1.difference(s2) 		# 方式二：差集，s1中有且s2中没有的值
	print(s3,s4)
	
	s5 = s2 - s1   					# 方式一：差集，s2中有且s1中没有的值
	s6 = s2.difference(s1)   		# 方式一：差集，s2中有且s1中没有的值
	print(s5,s6)
	```

### 7.3 转换

其他类型如果想要转换为集合类型，可以通过set进行转换，并且如果数据有重复自动剔除。

提示：int/list/tuple/dict都可以转换为集合。

```python
v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}
```
```python
v1 = "武沛齐"
v2 = set(v1)
print(v2) # {"武","沛","齐"}
```
```python
v1 = (11,22,3,11)
v2 = set(v1)
print(v2) # {11,22,3}
```
```python
v1 = {"age":12, "status":True,"name":"武沛齐"}
print( set(v1.keys()) ) 	# 输出：{'status', 'name', 'age'}
print( set(v1.values()) )	# 输出：{'status', 'name', 'age'}
print( set(v1.items()) )	# 输出：{('age', 12), ('status', True), ('name', '武沛齐')}
```

### 7.4 其他

1. 索引/切片/步长
	集合中没有提供 索引/切片/步长 这些功能，因为他无需，所以无法使用索引操作。
2. 获取集合长度
```python
v = {"刘能", "赵四", "尼古拉斯")
data = len(v)
print(data)
```
3. for循环
	```python
	v = {"刘能", "赵四", "尼古拉斯")
	for item in v:
		print(item)
	```

用户评论

登录或注册后才能发表评论