一、散列类型
用来表示无序集合
1 集合
无序不重复元素的集合。
三大特性：
- 确定性：对于任意一个元素，要么它属于某个指定集合，要么它不属于该集合，二者必居其一。
- 互异性：同一个集合中的元素是互不相同的。
- 无序性：任意改变集合中元素的排列次序，它们仍然表示同一个集合。
1.1 python中集合的定义
一对大括号进行定义，元素之间使用逗号隔开。集合中的元素必须是不可变类型 python中集合用set表示
a = {1,2,3,4,5,6}
b = {1,'a',1.5,(1,2)}
print('a的类型是:', type(a))
print('b的类型是:', type(b))
{[1,2,3],1} # 会报错，因为第一个元素是列表，列表是可变数据类型，不能作为集合的元素
以下几个空数据类型（序列）都可以利用内置函数表示
empty_set = set() # 空集合
empty_tuple = tuple()
empty_list = list()
empty_str = str()
empty_dict = dict() # 空字典
1.2 集合的常用操作
1.2.1 添加元素
.add(obj),向集合中添加元素obj，不存在则添加，元素obj必须是不可变数据类型
s = {1,2}
s.add(3)
print(s) # 输出{1, 2, 3}
s.add([1,2]) # 报错TypeError: unhashable type: 'list'
print(s)
.update(iterable),向集合添加多个元素，如果集合中不存在则添加
s = {1, 2}
s.update([3, 4, (5, 'a')]) # 输出{(5, 'a'), 1, 2, 3, 4}
print(s)
s.update([3, 4, [5, 'a']])
1.2.2 删除元素
.pop()随机删除并返回集合中的一个元素，如果集合为空抛出异常
s = {1,2,3,4,5,6}
s.pop()
.remove(ele),从集合里删除元素ele，如果不存在则报错
s = {1,2,3,4,5,6}
s.remove(3) # 输出{1, 2, 4, 5, 6}
.discard(ele)，从集合中删除ele元素，如果不存在不做任何操作
s = {1,2,3,4,5,6}
s.discard(3) # 输出{1, 2, 4, 5, 6}
.clear(),清空集合
s = {1,2,3,4,5,6}
s.clear() # 输出set()
print(s)
1.2.3 集合的运算（了解即可）
| 数学符号 | python运算符 | 含义 | 定义 |
|---|---|---|---|
| ∩ | & | 交集 | 一般地,由所有属于A且属于B的元素所组成的集合叫做AB的交集. |
| ∪ | | | 并集 | 一般地,由所有属于集合A或属于集合B的元素所组成的集合,叫做AB的并集 |
| -或\ | - | 相对补集/差集 | A-B，取在A集合但不在B集合的项 |
| ^ | 对称差集/反交集 | A^B，取只在A集合和只在B集合的项，去掉两者交集项 |
差集/相对补集
A-B，取在A集合但不在B集合的项
s1 = {1,2,3}
s2 = {2,3,4}
s = s1-s2
print(s) # 输出{1}
反交集/对称差集
取不在集合 AB 交集里的元素组成的集合称为对称差集，也叫反交集
s1 = {1,2,3}
s2 = {2,3,4}
s = s1^s2
print(s) # 输出{1, 4}
1.3 集合去重
ls = [1, 1, 2, 3, 2, 4, 5, 4]
res = set(ls)
print(res) # 输出{1, 2, 3, 4, 5}
2 字典
使用集合中的元素作为key，和值形成键值对，通过key找到值
键值对的集合
2.1 字典的定义
使用一对大括号进行定义，键值对之间使用逗号隔开，键和值使用冒号分割。
字典的键必须是不可变数据类型，且不重复，值可以是任意的数据类型。
实际上，字典是Hash表，所以key必须是不可变数据类型
python使用dict表示字典
zd = {'name': '张学友', 'age': '50', 'height': 170, 'hobby': ['演戏', '唱歌']}
2.2 字典的索引
通过键作为索引来获取对应的值，字典中的键是无序的
zd = {'name': '张学友', 'age': '50', 'height': 170, 'hobby': ['演戏', '唱歌']}
ne = zd['name']
hy = zd['hobby'][1]
print(ne , hy)
2.3 字典的常用操作
2.3.1 增加元素
直接通过key 赋值的方式进行添加元素，如果key存在则修改
zd = {'name': '张学友', 'age': 50, 'height': 170, 'hobby': ['演戏', '唱歌']}
zd['name'] = '刘德华'
zd['weigh'] = 60
print(zd)
.update(new_dict),将new_dict 合并到字典中，如果有重复的元素，重复的不会添加
zd = {'name': '张学友', 'age': '50', 'height': 170, 'hobby': ['演戏', '唱歌']}
dc = {'sex': '男'}
zd.update(dc)
print(zd)
2.3.2 删除元素
pop(key,[,d]),删除指定的key和对应的值，并返回key对应的值，如果key不存在，则返回d，如果没有给定d，则抛出异常
dc = {'sex': '男', 'sd': 123, 'height': 170}
res = dc.pop('sex')
print(res)
print(dc)
输出：
男
{'sd': 123, 'height': 170} 'sex': '男被删除
dc = {'sex': '男', 'sd': 123, 'height': 170}
res = dc.pop('sex1', '默认值')
print(res)
print(dc)
输出：
默认值
{'sex': '男', 'sd': 123, 'height': 170}”
.popitem() 随机删除字典中的一个键值对，并且以二元元组(key,value)的方式返回
dc = {'sex': '男', 'sd': 123, 'height': 170}
res = dc.popitem()
print(res)
print(dc)
2.3.3 查询元素
通过key查询，如果key不存在即会报错
dc = {'sex': '男', 'sd': 123, 'height': 170}
res = dc['sex']
print(dc)
.get(key,default=None),获取key对应的value，如果不存在则返回default
dc = {'sex': '男', 'sd': 123, 'height': 170}
res = dc.get('sex')
res1 = dc.get('sex1')
res2 = dc.get('sex2', '自定义默认值')
print(res, res1, res2) #输出 男 None 自定义默认值
二、其他数据类型
1. 布尔型
bool，True和False 表示 真和假
条件表达式，比较表达式的运算结果返回布尔型
1.1 比较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于-比较对象是否相等 | print(a==b) # False |
| is | 等于-比较对象的内存地址是否相同 | print(a is b) |
| != | 不等于 | print(a!=b) # True |
| > | 大于 | print(a>b) # False |
| < | 小于 | print(a<b) # True |
| >= | 大于等于 | print(a>=b) # False |
| <= | 小于等于 | print(a<=b) # True |
True表示1，False表示0
3.1.1 ==与is的分别（面试常考）
== 比较的是值是否相等
is比较的是内存地址是否相等
a = 26309
b = 26309
print(a == b) # 比较值得大小
print(a is b) # 比较的是id
1.1.1 内存优化机制
c = 10
d = 10
print(c is d) # 输出ture
上面代码中为什么输出True，之前说过不可变数据类型赋值时，会新建一个内存空间，上面代码中的内存地址应该是不一致才对，输出应该是False，为什么会输出True呢？
因为为了优化内存，对常用的数据进行了缓存，python解释器启动的时候，会预先创建-5到256这些数字，所以将10赋值给a和b，ab都指向同一个对象，所以是ture。
但是发现赋值257时，按照上面说的原理，下面代码中c is d应该是输出False才对，为什么会输出True呢
c和d分成两行赋值
c = 257
d = 257
print(c is d) # 输出ture
c和d同一行赋值，此时
c, d = 257, 257
print(c is d)
猜测：代码是从上往下执行的，分行赋值保留了缓存，所以d还是指向了c赋值时创建的对象，所以输出了True，同行赋值c，d是同时赋值执行的，所以会创建两个对象
1.2 成员运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回True，否则False | L = [1, 2, 3, 4, 5] a = 3 print(a in L) # True |
| not in | 如果在指定的序列中没有找到值返回True，否则False | print(a not in L) # False |
ls = [1,2,3,4]
a = 2
print(a in ls)
# 字典是看key
dt = {'name': '刘德华'}
print('name' in dt)
1.3 布尔型运算
布尔型数据可以和数值数据进行数学计算，True 其实是 整数1 False是整数0
print(True + 1)
print(False + 1)
print(True + False)
分别输出2 1 1
1.4 布尔型转换
任意的数据都可以通过bool转换成布尔型
在python中，0,0.0,0.0+0.0j，空字符串，空列表，空元组，空字典，空集合，None的布尔值是False，其他的都是True
print(bool('name')) #输出True
print(bool('')) #输出False
1.5 逻辑运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| and | 与，如果x为False,x and y返回x的值，否则返回y的值 | print(a and b) # True |
| or | 或，如果x为True,x and y返回x的值，否则返回y的值 | print(a or b) # True |
| not | 非，如果x为True，返回False，反之，返回True | print(not a) # False |
print(True and True)
print(False and True)
print(True and True)
print(True or True)
print(not True)
print(not False)
and，or逻辑运算表达式返回值遵循短路的原则
a = 1
b = 2
print(a and b) # a and b表达式当 a为真时，返回b的值,输出2
print(b and a) # b and a表达式当 b为真时，返回b的值,输出1
a = 0
b = 1
print(a or b) # a or b 表达式，当 a为假的时候，返回b的值
a = 2
b = 1
print(a or b) # a or b 表达式，当 a为真的时候，返回a的值2，称之为短路
print(b or a) # b or a 表达式，当 b为真的时候，返回b的值1，称之为短路
2. None
特殊的数据类型，它的值就是它本身 None，表示空，表示不存在
ls = [1, 2]
res = ls.remove(1)
print(res) # 输出None
