python 中集合(set)类型与数学中的集合类型一致，用来表示无序 不重复元素的集合。
1.1 集合定义
集合使用一对大括号 {} 进行定义，元素直接使用逗号隔开。集合中的元素必须是不可变类型。
a = {1, 2, 3, 4, 5}
b = {1, 2 ,'a', ('a',), 1.5} #集合中的元素必须是不可变类型
print('a的类型为：', type(a))
print('b的类型为：', type(b))
a的类型为：b的类型为：
c = {[1, 2, 3], (1, 2, 3)} #元素为可变的话，报错
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) ~AppDataLocalTemp/ipykernel_8120/3592833078.py in----> 1 c = {[1, 2, 3], (1, 2, 3)} TypeError: unhashable type: 'list'
空集合的定义方式
a = set() print(a, 'a的类型为：', type(a))
set() a的类型为：
1.2集合的常用操作
1.2.1 添加元素
集合添加元素常用函数有两个：add 和 update
set.add(obj), 向集合中添加obj, 如果集合不存在则添加
s = {1, 2}
s.add(1) #添加元素已存在，则不发生变化
print(s)
{1, 2}
s.add(3) #添加元素不存在，则添加 print(s)
{1, 2, 3}
s.add([1,2]) # 添加可变类型的元素，则报错
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) ~AppDataLocalTemp/ipykernel_8120/3876906618.py in----> 1 s.add([1,2]) TypeError: unhashable type: 'list'
set.update(iterable) 向集合中添加多个元素，如果集合中不存在则添加
s = {1, 2}
s.update({2, 3})
print(s)
{1, 2, 3}
s.update((4,5)) #使用update可以添加列表，会将列表中的元素提出来，一个一个加入集合中 print(s)
{1, 2, 3, 4, 5}
s.update(6, (7, 8)) #如果列表中还镶嵌有列表就会报错 print(s)
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) ~AppDataLocalTemp/ipykernel_8120/3159936450.py in----> 1 s.update(6, (7, 8)) 2 print(s) TypeError: 'int' object is not iterable
1.2.2 删除元素
set.pop() 随机删除并返回集合中的一个元素，如何集合中元素为空则抛出异常。
s = {1, 2, 3}
s.pop()
1
s = set() #集合为空时，报错 s.pop()
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) ~AppDataLocalTemp/ipykernel_8120/2117061617.py in1 s = set() ----> 2 s.pop() KeyError: 'pop from an empty set'
set.remove(ele) 从集合中删除元素 ele，如果不存在则抛出异常。
s = {'a', 'b', 'c'}
s.remove('a')
print(s)
{'c', 'b'}
s.remove('d') #元素不存在报错
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) ~AppDataLocalTemp/ipykernel_8120/1773474314.py in----> 1 s.remove('d') KeyError: 'd'
set.discard(ele) 从集合中删除元素 ele，如果不存在不做任何操作
s = {'a', 'b', 'c'}
s.discard('d')
print(s)
{'c', 'a', 'b'}
set.clear() 清空集合
s.clear() print(s)
set()
1.2.3 集合运算
| 数学符号 | python 运算符含义 | 含义 | 定义 |
|---|---|---|---|
| ∩ | & | 交集 | 一般地，由所有属于 A 且属于 B 的元素所组成的集合叫做 AB 的交集。 |
| ∪ | | | 并集 | 一般地，由所有属于集合 A 或属于集合 B 的元素所组成的集合，叫做 AB 的并集 |
| -或 | - | 相对补集/差集 | A-B，取在 A 集合但不在 B 集合的项 |
| ^ | 对称差集/反交集 | A^B，取只在 A 集合和只在 B 集合的项，去掉两者交集项 |
交集
取既属于集合 A 和又属于集合 B 的项组成的集合叫做 AB 的交集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(s1 & s2)
{2, 3}
s3 = {5, 6} # 交集无元素返回空集合
print(s1 & s3)
set()
并集
集合 A 和集合 B 的所有元素组成的集合称为集合 A 与集合 B 的并集
print(s1 | s2)
{1, 2, 3, 4}
补集
取在集合 A 中不在集合 B 中的项组成的集合称为 A 相对 B 的补集
print(s1 - s2)
{1}
对称差集
取不在集合 AB 交集里的元素组成的集合称为对称差集，也叫反交集
print(s1 ^ s2)
{1, 4}
1.3 集合去重
集合具有天生去重的性质，因此可以利用它来去除序列中的重复元素
ls = [1,1,2,3,4,4,3,2,5] ls = list(set(ls)) print(ls)
[1, 2, 3, 4, 5]
set('aabbcc')
{'a', 'b', 'c'}
2. 字典
因为集合无序，因此不能很便捷的获取特定元素。利用集合元素不重复的特性，使集合中的元素映射值组成键值对，再通过键来获取对应的值。
2.1 字典的定义
python 中的字典(dict)数据类型就是键值对的集合，使用一对大括号进行定义，键值对之间使用逗号隔开，键和值使用冒号分割。
字典中的键必须是不可变数据类型，且不会重复，值可以使任意数据类型。
a = {} # 空字典
b = {
1: 2, # key:数字；value：数字
2: 'hello', # key:数字；value：字符串
('k1',): 'v1', # key:元祖；value：字符串
'k2': [1, 2, 3], # key:字符串；value：列表
'k3': ('a', 'b', 'c'), # key:字符串；value：元祖
'k4': { # key:字符串；value：字典
'name': 'feifei',
'age': '18'
}
}
print('a的类型为：', type(a))
print('b的类型为：', type(b))
a的类型为：b的类型为：
2.2 字典的索引
字典通过键值对中的键作为索引来获取对应的值。字典中的键是无序的
d = {1:2, 'key': 'value'}
print(d[1])
2
print(d['key'])
value
2.3 字典的常用操作
2.3.1 增加元素
字典可以直接利用 key 索引赋值的方式进行添加元素，如果 key 存在则修改字典
d = {'name': 'test'}
d['age'] = 18
print(d)
{'name': 'test', 'age': 18}
dict.update(new_dict) 将 new_dict 合并进 dict 中
d = {'name': 'test'}
n_d = {'age':18, 'sex':'男'}
d.update(n_d)
print(d)
{'name': 'test', 'age': 18, 'sex': '男'}
d.update({'sex': '女','height': 170}) # 当有重复key的时候会覆盖原值
print(d)
{'name': 'xinlan', 'age': 18, 'sex': '女', 'height': 170}
2.3.2 修改元素
直接通过 key 索引赋值的方式可以对字典进行修改，如果 key 不存在则添加
d = {'name': 'test'}
d['name'] = 'Test'
print(d)
{'name': 'Test'}
2.3.3 删除元素
dict.pop(key[,d]) 删除指定的 key 对应的值并返回该值，如果 key 不存在则返回 d，如果没有给定 d，则抛出异常
d = {'name': 'test','age': 18}
d.pop('age')
18
print(d)
{'name': 'test'}
d.pop('sex') #删除字典里没有的key，不给定d值，报错
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) ~AppDataLocalTemp/ipykernel_8120/2296253875.py in----> 1 d.pop('sex') #删除字典里没有的key，不给定d值，报错 KeyError: 'sex'
d.pop('sex', -1) #删除字典里没有的key，给定d值，返回d值
-1
dict.popitem() 任意删除字典 dict 中的一个键值对，并以二元元组 (key,value) 的方式返回
d = {'name': 'Felix','age': 18}
d.popitem()
('age', 18)
2.3.4 查询元素
通过 key 索引可以直接获取 key 对应的值，如果 key 不存在则抛出异常
d = {1:2, 'key': 'value'}
print(d[1])
2
d['name'] #key不存在报错
--------------------------------------------------------------------------- KeyError Traceback (most recent call last) ~AppDataLocalTemp/ipykernel_8120/3276799042.py in----> 1 d['name'] KeyError: 'name'
dict.get(key,default=None) 获取 key 对应的 value 如果不存在返回 default
d = {1:2, 'key': 'value'}
d.get(1)
2
d.get('name',0)
0
五、其他类型 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 |
| >= | 大于等于 | print(a>=b) # False |
| <= | 小于等于 | print(a<=b) # True |
a = 1 b = 2 a == b
False
a = 300 b = 300 a is b # is 是判断id，虽然值一样，但是不相等
False
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,5] 1 in ls
True
s = ['abcdefg'] 'a' in s
False
d = {'name': 'Felix','age':18} # 字典判断的是key
'name' in d
True
1.3 布尔值运算
布尔型数据可以和数值类型数据进行数学计算，这时 True 表示整数·1, False 表示整数 0
True + 1
2
False + 1
1
1.4 布尔类型转换
任意数据都可以通过函数 bool 转换成布尔型。
在 python 中，None, 0（整数），0.0（浮点数），0.0+0.0j（复数），""(空字符串)，空列表，空元组，空字典，空集合的布尔值都为 False，其他数值为 True
print(bool(0))
print(bool(0.0))
print(bool(0.0+0.0j))
print(bool(''))
print(bool([]))
print(bool(()))
print(bool({}))
print(bool(set()))
print(bool(None))
False False False False False False False False 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 |
True and True
True
True and False
False
0 and 1 # 短路，当and左边的元素为False之后，不会计算and右边的元素
0
1 and 2 # 当and左边的元素为True时，值由右边的元素确定
2
True or False
True
False or False
False
1 or 0 # 短路，当or左边的元素为True时，不会计算右边的元素
1
0 or '' # 短路，当or左边的元素为False时，值由右边的元素觉得
2.None''
None 是 python 中的特殊数据类型，它的值就是它本身 None，表示空，表示不存在。
print(None)
None
