一、散列类型

用来表示无序集合

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集合的项

image.png

s1 = {1,2,3}
s2 = {2,3,4}
s = s1-s2
print(s) # 输出{1}

反交集/对称差集

取不在集合 AB 交集里的元素组成的集合称为对称差集，也叫反交集

image.png

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