# 第四章 散列类型的方法
## 一、Dictionary（字典）
### 1、字典定义
字典定义:字典是Python中唯一的映射类型(哈希表)
- 字典对象是可变的，但是字典的键必须使用不可变对象，程序需要通过 key 来访问 value，因此字典中的 key 不允许重复，并且一个字典中可以使用不同类型的键值。
- key()或者values()返回键列表或者值列表。
- items()返回包含键值对的元组。
### 2、创建字典
- 1、直接使用{}花括号创建字典
##### 在使用花括号语法创建字典时，花括号中应包含多个 key-value 对，key 与 value 之间用英文冒号隔开,多个 key-value 对之间用英文逗号隔开。
```python
>>> d1={'name':'Tom','age':18,'gender':'male'}
>>> d1['name'] //通过指定键输出对应值
'Tom'
>>> a=1
>>> d2={a:111,'b':'two'} //字典中的键，可以使用字符串，数字，元组，还可以使用变量
>>> d2
{1: 111, 'b': 'two'}
```
- 2、使用构造函数创建字典 - dict
##### 使用 dict() 函数创建字典时，可以传入多个列表或元组参数作为 key-value 对，每个列表或元组将被当成一个 key-value 对，因此这些列表或元组都只能包含两个元素。
```python
>>> a=dict()
>>> a = dict(name='tom',age=15) #使用关键字参数来创建字典,其key不需要加双引号
>>> a['name']
'tom'
>>> fruit=[('apple', 10), ('banana',8), ('pear',3)] # 创建包含3组key-value对的字典
>>> dict1=dict(fruit)
>>> print(dict1)
{'apple': 10, 'banana': 8, 'pear': 3}
```
## 二、 Set（集合）
### 1、集合定义
集合定义:set是一个无序且不重复的元素集合。set和dict一样，只是没有value，相当于dict的key集合，由于dict的key是不重复的，且key是不可变对象因此set也有如下特性：不重复和元素为不可变对象。
- 集合是一个可变容器
- 集合内的数据对象都是唯一的(不能重复)
- 集合是无序的存储结构,集合内的数据没有先后关系
- 集合是可迭代对象
- 集合相当于是只有键没有值得字典(键就是集合中的数据)
- 集合内的元素是不可变的
### 2、创建集合
创建集合:
- 1.使用直接量创建集合,注意:使用直接量不能创建空集合
```python
>>> se={1,2,3} #se={value},value类型：string、tuple、数字等不可变类型
>>> type(se)
<class 'set'>
>>> s={'hello',1.23,True,(12)}
>>> type(s)
<class 'set'>
```
- 2.使用构造函数创建集合 - set
```python
>>> s = set() #创建空集合
>>> s = set("ABC")
>>> s
{'A','B','C'}
>>> se = set([1,0,3.14,"hello"]) # s = {1,0,3.14,'hello'}
>>> se
{0, 1, 3.14, 'hello'}
```
- 3、利用dict创建，将会使用dict中的key值作为set的值
```python
>>> d=set({'d1':'v1','d2':'v2'})
>>> print(d)
{'d1', 'd2'}
```
## 三、散列类型的方法
### 1、字典方法
1)增
- a=di.copy() 字典的浅复制
- a.setdefault('a') 有则查，无则增,增的值为;none
- a=fromkeys 给定的多个 key 创建字典，这些 key 对应的 value 默认都是 None；也可以额外传入一个参数作为默认的 value。
```python
>>> car={'dress':88,'skirt':58,'shirt':68}
>>> cars=car.copy() #复制新的对象cars
>>> print(cars)
{'dress': 88, 'skirt': 58, 'shirt': 68}
>>> print(car.setdefault('coat',128)) #新增一个键值对
128
>>> print(car)
{'dress': 88, 'skirt': 58, 'shirt': 68, 'coat': 128}
>>> print(car.setdefault('dress',58)) #如果key在dict中存在，不会修改dict内容
88
>>> print(car)
{'dress': 88, 'skirt': 58, 'shirt': 68, 'coat': 128}
```
2)删
- clear()，用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。
- pop()， 获取指定 key 对应的 value，并删除这个 key-value 对。
- popitem()， 由于字典存储 key-value 对的顺序是不可知的，因此开发者感觉字典的 popitem() 方法是“随机”弹出的，但实际上字典的 popitem() 方法总是弹出底层存储的最后一个 key-value对。
- del 字典对象， 删除字典对象， 如：del car
```python
#clear方法
>>> car={'dress':88,'skirt':58,'shirt':68}
>>> car.clear()
>>> print(car)
{}
#pop方法
>>> car={'dress':88,'skirt':58,'shirt':68}
>>> print(car.pop('dress'))
88
>>> print(car)
{'skirt': 58, 'shirt': 68}
#popitems方法
>>> car={'dress':88,'skirt':58,'shirt':68}
>>> print(car.popitem())
('shirt', 68)
>>> print(car)
{'dress': 88, 'skirt': 58}
```
3)改
- update 更新字典 ，如果被更新的字典中己包含对应的 key-value 对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去。
```python
>>> car={'dress':88,'skirt':58,'shirt':68}
>>> car.update({'dress':98,'coat':168})
>>> print(car)
{'dress': 98, 'skirt': 58, 'shirt': 68, 'coat': 168}
```
4)查
- get 根据 key 来获取 value，它相当于方括号语法的增强版，当使用方括号语法访问并不存在的 key 时，字典会引发 KeyError 错误；但如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，不会导致错误。
- keys 查看所有的键
- values 查看所有的值
- items 查看所有的键值
```python
# get方法
>>> car={'dress':88,'skirt':58,'shirt':68}
>>> print(car.get('skirt')) #get('键')，如果键存在，返回对应的值
58
>>> print(car.get('coat')) #如果键不存在，返回None
None
>>> print(car[coat]) #如果键不存在，不使用get方法，则报错。
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'coat' is not defined
# items方法
>>> car={'dress':88,'skirt':58,'shirt':68}
>>> it=car.items()
>>> print(type(it)) #返回dict_items对象
<class 'dict_items'>
>>> print(list(it)) #将dict_items转换成列表
[('dress', 88), ('skirt', 58), ('shirt', 68)]
>>> print(list(it)[1]) #访问第2个key-value对
('skirt', 58)
# keys方法
>>> ke=car.keys()
>>> print(type(ke)) #返回dict_keys对象
<class 'dict_keys'>
>>> print(list(ke)) #将dict_keys转换成列表
['dress', 'skirt', 'shirt']
>>> print(list(ke)[1]) #访问第2个key
skirt
#values方法
>>> val=car.values()
>>> print(type(val)) #返回dict_values对象
<class 'dict_values'>
>>> print(list(val)[1]) #访问第2个value
58
```
程序调用字典的 items()、keys()、values() 方法之后，都需要调用 list() 函数将它们转换为列表，这样即可把这三个方法的返回值转换为列表。
5)字典格式化字符串
在格式化字符串时，如果要格式化的字符串模板中包含多个变量，后面就需要按顺序给出多个变量，这种方式对于字符串模板中包含少量变量的情形是合适的，但如果字符串模板中包含大量变量，这种按顺序提供变量的方式则有些不合适。可改为在字符串模板中按 key 指定变量，然后通过字典为字符串模板中的 key 设置值。
```python
# 字符串模板中使用key
>>> temp = '教程是:%(name)s, 价格是:%(price)010.2f, 出版社是:%(publish)s'
>>> book = {'name':'Python基础教程', 'price': 99, 'publish': 'C语言中文网'}
# 使用字典为字符串模板中的key传入值
>>> print(temp % book)
教程是:Python基础教程, 价格是:0000099.00, 出版社是:C语言中文网
>>> book = {'name':'C语言小白变怪兽', 'price':159, 'publish': 'C语言中文网'}
# 使用字典为字符串模板中的key传入值
>>> print(temp % book)
教程是:C语言小白变怪兽, 价格是:0000159.00, 出版社是:C语言中文网
```
### 2、集合方法
1)增
- add()
```python
>>> se={'apple','banana','pear'}
>>> se.add('cherry')
>>> print(se) #集合无序性，随机插入某个位置
{'apple', 'cherry', 'banana', 'pear'}
```
2)删
- pop() 删除为无序删除，而不是有序从后面删除的
- discard() 移除不存在的元素不会报错
- remove() 移除不存在的元素会报错
- clear() 删除全部内容
```python
>>> se = {11, 22, 33}
>>> se.discard(11)
>>> se.discard(44) # 移除不存的元素不会报错
>>> print(se)
{33, 22}
#其他方法可以动手操作，去理解这些方法
```
3)改
- update()
```python
>>> se = {11, 22, 33}
>>> be = {22,44,55}
>>> se.update(be) # 把se和be合并，得出的值覆盖se
>>> print(se)
{33, 22, 55, 11, 44}
>>> se.update([66, 77]) # 可增加迭代项
>>> print(se)
{33, 66, 22, 55, 11, 44, 77}
```
4)查
无法通过下标索引
5)集合操作
集合的运算：交集，并集和差集
- 交集 成两个集合的交集(两个集合的共同部分)
- 并集 生成两个集合的并集
- 差集 生成属于se，但不属于st的所有元素的集合
- '>' 判断一个集合是另一个集合的超集
- '-' 判断一个集合是另一个集合的子集
- == 判断集合相同
- ！= 判断集合不同
```python
>>> se={11,22,33,44}
>>> st={22,44,66,88}
>>> se&st
{44, 22}
>>> se|st
{33, 66, 11, 44, 22, 88}
>>> se-st
{33, 11}
>>> s1 = {1,2,3}
>>> s2 = {2,3}
>>> s1 > 2s # s1为s2的超集
True
>>> s2 < s1 # s2为s1的子集
True
>>> s1 = {1,2,3}
>>> s2 = {2,3,1}
>>> s1 == s2 # 相同为True
True
>>> s1 != s1 #两个对象不相同为True,相同为False
False
```
## 四、课堂练习
- 1、有字典 dic = {"k1": "v1", "k2": "v2", "k3": "v3"}，实现以下功能：
1、输出字典 dic 中所有的key
2、输出字典 dic 中所有的value
3、添加一个键值对"k4","v4",输出添加后的字典 dic
4、删除字典 dic 中的键值对"k1","v1",并输出删除后的字典 dic
5、删除字典 dic 中 'k5' 对应的值，若不存在，使其不报错，并返回None
- 2、经理有：曹操，刘备，孙权， 技术员有：曹操，孙权，张飞， 关羽。
用集合求：
1. 即是经理也是技术员的有谁？
2. 是经理，但不是技术人员的都有谁？
3. 是技术人员，但不是经理的人都有谁？
4. 张飞是经理吗？
5. 身兼一职的人都有谁？
6. 经理和技术人员共有几个人？
## 五、上一节课堂练习答案
- 1、创建一个变量，并赋给它一个列表(含数值，文本)，进行切片取值，并进行增删改查的操作。
```python
>>> li=[12,34,'tom','Jon','Merry','Lili','是我好盆友']
>>> li[2:6] #取出里面四位好盆友
['tom', 'Jon', 'Merry', 'Lili']
>>> li[-2:-6:-1]
['Lili', 'Merry', 'Jon', 'tom']
>>> li[2:6:2]
['tom', 'Merry']
>>> li.append('!') #在列表最后增加一个元素
>>> print(li)
[12, 34, 'tom', 'Jon', 'Merry', '是我好盆友', '!']
>>> li.remove('Merry') #删除一位小盆友
>>> print(li)
[12, 34, 'tom', 'Jon', 'Jerry', '是我好盆友', '!']
>>> li[4]='Ella' #指定索引位置插入一个小盆友
>>> print(li)
[12, 34, 'tom', 'Jon', 'Ella', '是我好盆友', '!']
>>> li.index('tom') #查看'tom'在哪个索引位置下
2
```
- 2、创建三个字符串对象，值分别是'Hello'、'My name'和'is tom',用学过的拼接方法去完成拼接结果为'Hello,My name is tom'
```python
>>> st1='Hello'
>>> st2='My name'
>>> st3='is tom'
>>> str=st1+'!'+' '+st2+' '+st3+'!' #需要加上空格和叹号，合并为一条规范的英语句子
>>> print(str)
Hello! My name is tom!
>>> str='%s! %s %s!'%(st1,st2,st3) #通过%s和%拼接
>>> print(str)
Hello! My name is tom!
>>> '{}! {} {}!'.format(st1,st2,st3) #通过.format和{}
'Hello! My name is tom!'
```
`