list列表
列表基础
是数据容器中的一类，是一次性可以存储多个不同数据（元素）的。和JS中的数组类似。
python
# 基础语法
列表名称 = [数据1,数据2,数据3,数据4,数据5...]
# 1 列表操作
# 1.1 定义列表(list) - my_list
my_list=[10,20,'hello',True]
# 1.2 打印列表
print(my_list)
# 2 访问列表元素
# 2.1 获取(索引)
print(f'1索引处的元素：{my_list[1]}') #使用正向索引
print(f'-1索引处的元素：{my_list[-1]}') #使用反向索引
# print(f'5索引处的元素：{my_list[5]}') #索引超出范围就会报错：IndexError: list index out of range
# 2.2 修改/设置(索引)
my_list[1]=666 #等价于my_list[-3]=666
print(f'1索引处的元素：{my_list[1]}')
# 2.3 删除
del my_list[1]
print(my_list)
# 2.4 遍历
for e in my_list: #变量e表示表示每个元素
print(e)
# 2.5 遍历(获取索引)，enumerate(容器)：在遍历可迭代对象时, 同时获取元素的索引和值 (索引从0开始)
for i, e in enumerate(my_list): #i表示索引，e表示元素
print(f'索引是：{i},元素是：{my_list[i]}')**序列类型：**容器中的元素按特定顺存储的、可通过索引访问并支持顺序遍历的容器类型称之为序列。
那由于list列表中的元素是有序，顺序是固定的，我们在访问list列表中的元素的时候，就可以通过元素的下标（索引）来进行访问。从前向后（正向索引），下标从0开始；从后向前（反向索引），下标从-1开始。
正常遍历列表中的元素，直接使用for循环即可，比如
for e in my_list如果在遍历列表中的元素时，还需要获取到元素的索引，可以使用enumerate语句，比如：
for i, e in enumerate(my_list)--->i表示索引，e表示遍历出来的元素和JS不同的是，在Python中，索引越界是会报错的！！！
切片
切片是指对操作的数据截取其中一部分的操作。列表、字符串、元组都支持切片操作。
- 语法：
序列数据[``开始索引``:``结束索引``:``步长``]- 不包含结束索引位置对应的元素(开始索引未指定默认为0；结束索引未指定默认为列表长度(直到列表末尾)；步长未指定默认为1)
- **切片技巧：**索引和步长都可正可负，步长为正向右找，步长为负向左找，索引方向与步长方向相反则无数据
- **说明：**如果不写步长，步长前面的冒号可以省略，但是开始索引和结束索引之间的冒号不能省略。
- 样例：
s[0:5:1]切片后的结果为["A", "C", "E", "B", "D"]s[0:5:2]切片后的结果为["A", "E", "D"]
python
# ---------------------------- 列表 list 切片 ----------------------------
"""
列表: a b c d e f g h
正向索引: 0 1 2 3 4 5 6 7
逆向索引: -8 -7 -6 -5 -4 -3 -2 -1
切片技巧：索引和步长都可正可负，步长为正向右找，步长为负向左找，索引方向 与 步长方向相反则无数据。
说明：如果不写步长，步长前面的冒号可以省略，但是开始索引和结束索引之间的冒号不能省略。
"""
# 1. 定义列表
s = ["a", "b", "c", "d", "e", "f", "g", "h"]
# 2. 演示字符串的切片.
print(s[1:3]) # bc 不写步长, 默认是: 1
print(s[:5]) # abcde 不写起始索引, 默认是: 0
print(s[3:]) # defgh 不写结束索引, 默认到: 字符串最后
print(s[1:5:2]) # bd 起始索引是1, 结束索引是5, 步长是2, 包左不包右.
print('---------------')
print(s[-6:-2]) # cdef, 不写步长, 默认是: 1
print(s[-6:-2:1]) # 效果同上.
print(s[:-3]) # abcde
print(s[-5:]) # defgh
print(s[-1:-5:-1]) # hgfe
print(s[-6:-2:-1]) # 不报错, 但是啥都没有. 因为查找的顺序是 -6到-2 从前往后(->), 而步长是-1, 顺序是 从后往前(<-) 查找和步长方法相反, 无数据.
print('---------------')
print(s[2:-3]) # cde
print(s[-2:1]) # 不报错, 但是啥都没有. 查找方向 和 方向顺序不一致.
print(s[-2:1:-1]) # gfedc
# 刁钻的面试题
print(s[:]) # abcdefgh, 即: 字符串本身.
print(s[::-1]) # hgfedcba, 即: 反转字符串
print(s[::-3]) # heb方法
| 方法 | 作用 | 样例 |
|---|---|---|
| append() | 在列表的尾部追加元素 | s.append(10086) |
| insert() | 在指定索引之前，插入该元素 | s.insert(0, 92) |
| remove() | 移除列表中第一个匹配到的值 | s.remove(75) |
| pop() | 删除列表中指定索引位置的元素（如果未指定索引，默认删最后一个） | s.pop(2) / s.pop() |
| sort() | 对列表进行排序（列表元素的数据类型一致，才可以进行排序） | s.sort() |
| reverse() | 反转列表元素 | s.reverse() |
代码示例：
python
# ----------------------------- 列表 list 常用方法 -----------------------------
# 定义列表
my_list = [56, 90, 88, 65, 90, 100, 209, 72, 145]
# append(): 在列表尾部追加元素
my_list.append(666)
print(my_list)
# insert(): 在指定索引之前, 插入元素
my_list.insert(1,88)
print(my_list)
# remove(): 移除列表中第一个匹配到的元素
my_list.remove(88) #z只移除第一个出现的88
print(my_list)
# pop(): 删除列表中指定索引位置的元素并返回(如果未指定, 默认删除最后一个)
my_list.pop()
print(my_list)
my_list.pop(1)
print(my_list)
# sort(): 排序
my_list.sort() #升序
# my_list.sort(reverse=True) #升序后再反转(也就是降序)，reverse表示反转，默认值为false
print(my_list)
# reverse(): 反转列表元素
my_list.reverse() #只是将列表反转，不排序
print(my_list)列表推导式
python
# 格式:
# 列表名称 = [表达式 for 变量 in 可迭代对象]
# 列表名称 = [表达式 for 变量 in 可迭代对象 if 条件表达式]
# 案例如下：
# 需求1: 生成1-20的平方列表。 --> range(1,21)
new_list1 = [num ** 2 for num in range(1, 21)]
print(new_list1)
# 需求2: 从一个数字列表中提取所有偶数，并计算其平方，组成一个新的列表
num_list = [9, 20, 15, 6, 8, 21, 10, 23, 12, 3, 26, 55, 22]
# 这行代码的执行思路：循环num_list，然后根据if条件成立的情况下，执行前面表达式内容，然后返回一个新的列表
new_list2 = [num ** 2 for num in num_list if num % 2 == 0]
print(new_list2)列表的合并
原始列表：
python
a = [1,2,3]
b = [4,5,6]+ 加号运算符（生成新列表，最常用）
python
c = a + b
print(c) # [1,2,3,4,5,6]- ✅ 返回全新列表，不修改原 a、b
- ❌ 会产生新内存；不适合超大列表频繁合并
- 支持多个：
a + b + [7,8]
extend() 原地扩展（修改原列表，无返回值）
python
a.extend(b)
print(a) # [1,2,3,4,5,6]- ✅ 原地修改 a，不生成新对象，内存效率高
- ❌ a 本身被改变；
c = a.extend(b)→ c 得到None（坑） - extend 可以接收任意可迭代对象：列表、元组、字符串、range
python
a.extend((7,8))
a.extend(range(2))解包 * 合并（Python3.5+，灵活，生成新列表）
python
c = [*a, *b]
print(c) # [1,2,3,4,5,6]- ✅ 非常灵活，可以穿插其他元素
python
c = [*a, 99, *b, 100]- ✅ 支持多个列表一起解包合并
python
a,b,c = [1],[2],[3]
res = [*a,*b,*c]字符串
字符串基础
字符串是字符的容器，一个字符串中可以存放任意数量的字符 。如："Python" 'Python' """Python"""。特点：不可变（无法修改）、有序性、可重复、有索引 。
- 字符串中的每一个字符元素都有其对应的下标（索引），通过元素对应的索引，就可以获取到对应的元素 。
- **注意：**从前向后（正向索引），下标从0开始；从后向前（反向索引），下标从-1开始。
- 切片：
序列对象[``开始索引``:``结束索引``:``步长``]- 不包含结束索引位置对应的元素(开始索引未指定默认为0；结束索引未指定默认为列表长度(直到列表末尾)；步长未指定默认为1)
- **切片技巧：**索引和步长都可正可负，步长为正向右找，步长为负向左找，索引方向与步长方向相反则无数据
- **说明：**如果不写步长，步长前面的冒号可以省略，但是开始索引和结束索引之间的冒号不能省略。
- 样例：
s[0:5:1]切片后的结果为"Pytho"s[0:5:2]切片后的结果为"Pto"
python
# 字符串 基本操作 ---> 不可变（无法修改）、有序性、可重复、有索引
s = "Hello-Python"
#1 不可变（无法修改）
# s[1]='E' # TypeError: 'str' object does not support item assignment 不支持赋值
# print(s)
#2 有索引
print(s[1]) #e
print(s[-1]) #n
#3 遍历
print('--------------')
for e in s:
print(e)
#4 切片
print('--------------')
#4.1 切出"hello"
print(s[:5])
print(s[:-7])
#4.1 切出"Python"
print(s[6:])
print(s[-6:])
#4.1 字符串反转
print(s[::-1])总结：字符串的切片和列表的切片是完全一致的，没有区别。
字符串的方法
| 方法 | 作用 | 样例 |
|---|---|---|
| find() | 在字符串中查找子串，返回第一次出现的索引位置，找不到返回-1 | s.find('Python') |
| count() | 统计子串在字符串中出现的次数 | s.count('H') |
| upper() | 将字符串中的所有字母转换为大写 | s.upper() |
| lower() | 将字符串中的所有字母转换为小写 | s.lower() |
| split() | 将字符串按指定分隔符分割成列表 | s.split(' ') |
| strip() | 去除字符串两端的空白字符或指定字符 | s.strip() / s.strip('*') |
| replace() | 将字符串中的指定子串替换为新的子串 | s.replace('H','C', count)，count不写的话就全部匹配的都替换，否则只替换指定个数的 |
| startswith() | 检查字符串是否以指定子串开头，返回布尔值 | s.startwith('P') |
由于字符串是不可变的，当我们对字符串进行转大写、转小写、切割、替换等操作时，并不会对原有字符串进行修改，而是返回了一个新的字符串。
代码示例：
python
# -------------------------------------------- 字符串常用方法 --------------------------------------
s = " Hello-Python-Hello-World "
# find() 查找指定字符串第一次出现的索引位置
index = s.find("-")
print(index)
# count() 统计子字符串在指定字符串中出现的次数
c = s.count("o")
print(c)
# upper() 转为大写
su = s.upper()
print(su)
# lower() 转为小写
sl = s.lower()
print(sl)
# split() 将字符串按照指定字符串切割 - 列表
slist = s.split("-")
print(slist)
# strip() 去除字符串两端的空格
ss = s.strip()
print(ss)
# replace() 将字符串中的指定子串替换为新的内容
sr = s.replace("-", "_")
print(sr)
# startswith() / endswith() 判断字符串是否是以指定的字符串开头 / 结尾, 返回布尔值
print(s.startswith("Hello"))
print(s.endswith("Python"))
print("-------------------------------------------")
print(s)关于将字符串列表拼接为字符串
语法：
new_str = " ".join(str2_list)，注意：join里面的列表元素必须全是字符串，不能是数字；
python
str1 = 'Hello,Python,hello,python,good'
str1_list = str1.split(',')
# 使用列表推导式过滤掉长度小于5的单词
str2_list = [word for word in str1_list if len(word) >= 5]
print(str2_list) # ['Hello', 'Python', 'hello', 'python']
# 重新按照空格拼接回去，这点跟js的区别如下：
# 空格中的内容类似js中的array.join('分隔符')
new_str = " ".join(str2_list)
print(new_str) # Hello Python hello pythontuple 元组
元组的基本知识点
元组是不可变的序列，类似于列表，但创建后不能修改。元组和列表最大的不同点在于：元组一旦定义完成，不可修改。元组的特点：可以存储不同类型的元素；不可变、有序、可重复、有索引(支持索引访问、切片)。
重点记忆：元组识别靠逗号，不是靠小括号。如果元组中有一个或多个元素的话，不加小括号也是可以的，但是一般建议加上。
python
# 定义元组
元组名称 = (元素1，元素2，...) # 注意:如果只有一个元素，需要一个保留,
# 定义空元组
元组名称 = ()
元组名称 = tuple()
# 定义元组
t1 = (5, 7, 9, 1, 2, 3, 10, 6, 4, 8 ,12, 7, 5)
# 定义空元组
t2 = ()
t3 = tuple()
# 只有一个元素的元组，需要保留后面的逗号
t4 = (100,) # t4 = 100, # 这种写法也是可以的- 常用方法：
count()：统计某元素在元组中出现的次数index()：查找某个元素在元组中的索引位置(第一次出现的位置)
python
# 定义元组，元组名称 = (元素1，元素2，...) 注意:如果只有一个元素，需要一个保留,
t1 = (10,20,30,20,40)
# t2=() #空元组
# t3=tuple() #空元组
t4=(100)
print(t4,type(t4)) # 100 <class 'int'>
t5=(100,) #注意:如果只有一个元素，需要一个保留,
print(t5,type(t5)) # (100,) <class 'tuple'>
# 特点：不可变、有序、可重复、有索引(支持索引访问、切片)
# t1[1]=666 # TypeError: 'tuple' object does not support item assignment 不支持赋值
# 切片
print(t1[1:3]) # 20,30
# count() 统计元素的个数
print(t1.count(20)) # 2
# index() 获取元素的索引(第一个元素的位置)
print(t1.index(20)) # 1
# print(t1.index(60)) # 如果不存在就报错注意：
t3 = (100)中的()是数学中的小括号（圆括号），用于改变运算优先级，而不是元组的语法。- 定义单元素元组时，需要在结尾加上逗号，比如
('A',) - 记住这句口诀：逗号才是元组的灵魂，括号只是礼貌的装饰。
- 定义元组也可以写为：
t3 = 100, ;t3 = 100,200(这里其实是元组组包的写法)
- 定义元组也可以写为：
元组的切片
和字符串以及列表的切片功能完全一致。
元组、字符串、列表的index方法
在这三个数据容器的方法中，index方法如果找不到这样的元素是会报错的。和JS中找不到返回-1是不一样的！！！
组包和解包
- 组包（Packing）：将多个值合并到一个容器（元组、列表）中。
- 解包（Unpacking）：将容器(元组、列表)解开成独立的元素，分别赋值给多个变量。
*叫解包运算符（unpack），主要用于列表、元组、集合；字典用**。 注意：*不是乘法，作用：把容器里面的元素拆开、打散。
python
# 定义元组, 组包
t1 = (5, 7, 9, 1)
# 定义元组, 组包
t2 = 5, 7, 9, 1
# 基础解包
a, b, c, d = t1
# (*)扩展解包
x, *y, z = t2 # x为5，y为[7, 9]，z为1
s, *o = t2 # s为5，o为[7, 9, 1]
*o, e = t2 # o为[5, 7, 9]，e为1
t1 = (5, 7, 9, 1)
u, *v = t1
print(u, type(u)) # <class 'int'>
print(v, type(v))5 # [7, 9, 1] <class 'list'>，
# 多个值的情况下，使用*解出来的是list数据类型，哪怕list中解包出来只有一个元素**说明：*在元组解包时， 表示收集剩余的所有元素，允许我们处理不确定数量的元素（生成列表，以便于可以进行进一步的处理）。
元组转列表
python
# 定义元组, 组包
t1 = (5, 7, 9, 1, 8, 6)
# 元组转列表的方法1
list1 = list(t1)
print(list1, type(list1)) # [5, 7, 9, 1, 8, 6] <class 'list'>
# 元组转列表的方法2：
list2 = [*t1] # 解出t1的全部元素
print(list2, type(list2)) # [5, 7, 9, 1, 8, 6] <class 'list'>dict 字典
字典：使用键值对（key：value）来存储数据，每一个键都对应一个值，通过键（key）可以快速找到对应的值（value）。特点：键值对（key:value）存储、可变、有序、不重复(键)、无索引。
python
# 定义字典
字典名称 = {key: value, key:value, key:value …}
# 定义空字典
字典名称 = {}
字典名称 = dict()
# 根据key获取value
值 = 字典名称[key]
# 定义字典
dict1 = {"王林": 675, "李慕婉": 608, "许立国": 478, …}
# 定义空字典
dict2 = {}
dict3 = dict()
# 根据key获取value
score = dict1["李思"]
# 字典的增加和获取
dict1 = {'王超': 100, '陈刚': 200}
print(dict1['陈刚'])
# 如果是新增不存在的属性，没有问题
dict1['张三'] = 400
print(dict1)
# 如果是访问不存在属性，则抛出错误，推荐使用字典的get方法
print(dict1['测试'])**提示：**字典（dict）中的value可以是任何类型的数据，而key不能为可变类型（如：不能为 列表list、集合set、字典dict）。
代码示例：
python
# 字典 -- key不能重复(如果重复, 后面的值, 会覆盖前面的值)
# 1 定义字典-->"王林":670, "李慕婉":608, "徐立国":580, "李慕婉":688
dict1={"王林":670, "李慕婉":608, "徐立国":580, "李慕婉":688}
print(dict1,type(dict1)) # {'王林': 670, '李慕婉': 688, '徐立国': 580} <class 'dict'>
# 创建空字典
dict2={}
print(dict2,type(dict2))
dict3=dict()
print(dict2,type(dict2))
# 2 key必须得是不可变类型（str,int,float,bool,tuple）, 不能是 list、set、dict
dict4={"王林":670,1:100,1.2:120,True:22,("a","b"):666}
# 3 访问
# 3.1 根据key获取value
print(dict1["王林"])
# 3.2 根据key设置value
dict1["王林"]=666
print(dict1["王林"])总结：
字典的存储形式及特点?
- 字典(dict)存储的是键值对(key:value)形式的数据
- 特点：键值对、key是唯一的、可修改
字典定义的语法?
- 定义：
dict1 = {"王林": 675, "李慕婉": 608, "许立国": 478, …} - 获取：
v = dict1["王林"]
- 定义：
字典的注意事项
- value可以是任意类型，而key必须是不可变类型（不能为list、set、dict）
- 字典内的key不允许重复，如果重复定义，后面的覆盖前面的
- 字典是没有索引下标的，不能根据索引获取值，只可以根据key获取value
字典常见的方法
dict1 = {"小智": 675, "李思": 608, "李琪": 478, "小黑": 545, "温韬": 429}
字典的增删改查操作如下：
| 操作 | 含义 | 样例 |
|---|---|---|
| 字典名称[key] = value | 往指定字典中添加key-value键值对 | dict1["莫厉海"] = 688 |
| 字典名称.pop(key) | 删除字典中指定的key, 并返回该key对应的value | score = dict1.pop("莫厉海") |
| del 字典名称[key] | 删除字典中指定的键值对 | del dict1["莫厉海"] |
| 字典名称[key] = value | 修改字典中指定的key对应的值 | dict1["小智"] = 658 |
| 字典名称[key] | 根据key获取value | dict1["莫厉海"] |
| 字典名称.get(key) | 根据key获取value | dict1.get("莫厉海") |
| 字典名称.keys() | 获取所有的key | dict1.keys() |
| 字典名称.values() | 获取所有的value | dict1.values() |
| 字典名称.items() | 获取所有的key-value键值对 | dict1.items() |
代码示例：
python
# -------------------------------- 字典 常见操作 ---------------------------
my_dict = {"王林": 670, "李慕婉": 608, "许立国": 580, "韩立": 688}
# 1 添加 - 字典名称[key] = value -->key不存在就是添加
my_dict["张益达"] = 666
print(my_dict) # {'王林': 670, '李慕婉': 608, '许立国': 580, '韩立': 688, '张益达': 666}
# 2 修改 - 字典名称[key] = value -->key存在就是修改
my_dict["王林"] = 650
print(my_dict) # {'王林': 650, '李慕婉': 608, '许立国': 580, '韩立': 688, '张益达': 666}
# 3 查询
# 3.1 字典名称[key]：根据key获取value
print(my_dict["王林"]) # 650
# 3.2 字典名称.get(key)：根据key获取value
print(my_dict.get("王林")) # 650
# 3.3 字典名称.keys()：获取所有的key
print(my_dict.keys()) # dict_keys(['王林', '李慕婉', '许立国', '韩立', '张益达'])
# 3.4 字典名称.values()：获取所有的value
print(my_dict.values()) # dict_values([650, 608, 580, 688, 666])
# 3.5 字典名称.items()：获取所有的key-value键值对
print(my_dict.items()) # dict_items([('王林', 650), ('李慕婉', 608), ('许立国', 580), ('韩立', 688), ('张益达', 666)])
# 4 删除
# 4.1 字典名称.pop(key)：删除字典中指定的key, 并返回该key对应的value
score = my_dict.pop("王林")
print(score, my_dict) # 650 {'李慕婉': 608, '许立国': 580, '韩立': 688, '张益达': 666}
# 4.2 del 字典名称[key]：删除字典中指定的键值对
del my_dict["张益达"]
print(my_dict) # {'李慕婉': 608, '许立国': 580, '韩立': 688}
# 5 遍历(默认是遍历出所有的键)
# 获取所有的key并遍历，再根据key获取值
for key in my_dict.keys():
print(f"{key} = {my_dict[key]}")
print("-----------------")
# 等价于
for key in my_dict:
print(f"{key} = {my_dict[key]}")
print("-----------------")
# 获取所有的键值对并遍历
for item in my_dict.items(): #item是一个元组
print(f"{item[0]} = {item[1]}")
print("-----------------")
# 等价于
for key,value in my_dict.items(): #使用了解包
print(f"{key} = {value}")字典的get方法
get(key) 方法在 key（键）不在字典中时，可以返回默认值 None 或者设置的默认值。
dict[key] 在 key（键）不在字典中时，会触发 KeyError 异常。
python
>>> runoob = {}
>>> print('URL: ', runoob.get('url')) # 返回 None
URL: None
>>> print(runoob['url']) # 触发 KeyError
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'url'
>>>嵌套字典使用：
get() 方法对嵌套字典的使用方法如下：
python
tinydict = {'RUNOOB' : {'url' : 'www.runoob.com'}}
res = tinydict.get('RUNOOB', {}).get('url')
# 输出结果
print("RUNOOB url 为 : ", str(res))字典推导式
python
# 基本语法：
{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件}
# 案例1：从列表生成字
words = ['apple', 'banana', 'pear']
lengths = {word: len(word) for word in words}
# 输出: {'apple': 5, 'banana': 6, 'pear': 4}
# 案例2： 对现有字典做变换
stocks = {'AAPL': 121, 'MSFT': 219}
new_stocks = {symbol: price * 1.02 for symbol, price in stocks.items()}
# 输出: {'AAPL': 123.42, 'MSFT': 223.38}
# 案例3：带条件过滤
ages = {'张三': 35, '李四': 12, '王五': 31}
adults = {name: age for name, age in ages.items() if age >= 18}
# 输出: {'张三': 35, '王五': 31}
# 案例4：反转键值
original = {'a': 1, 'b': 2}
swapped = {v: k for k, v in original.items()}
# 输出: {1: 'a', 2: 'b'}
# 字典键必须唯，如果生成过程中出现重复键，后面的值会覆盖前面的值。
# 反转键值时要确保原字典的值是可哈希的（比如数字、字符串），不然会报错。关于字典的解包
*作用在字典上，只会解包字典的 key（键），不会拿到 value！
python
d1 = {"x": 10, "y": 20}
d2 = {"y": 50, "z": 30}
res1 = {*d1, *d2}
res2 = {**d1, **d2}
print(res1) # {'y', 'x', 'z'}
print(res2) # {'x': 10, 'y': 50, 'z': 30}
d = {"a": 1, "b": 2, "c": 3}
print({*d}) # 对于字典来说只能解出字典的key，是一个集合
print({**d}) # 对于字典这样解出的是字典语法对比：
| 语法 | 作用 | 适用对象 |
|---|---|---|
*obj | 序列解包，取出元素 | 列表、元组、字符串、字典 (仅 key) |
**obj | 字典解包，拆成 key=value | 只能是字典 |
集合
集合(set)是一种可变、无序的、不重复、无索引(不支持切片) 的数据容器。
**提示：**空集合的定义不可以使用{}，{}表示的是空字典；由于集合是无序的，因此是不支持索引访问的。
# 定义集合
s1 = {"C", "D", "X", "T", "O", "U"}
# 定义空集合
s2 = set()集合常见的方法
| 方法 | 作用 | 样例 |
|---|---|---|
| add(..) | 添加元素到集合中 | s1.add(``'t'``) |
| remove(..) | 移除集合中的指定元素（指定元素不存在将报错） | s1.remove(``'t'``) |
| pop() | 随机删除集合中的元素并返回 | e = s1.pop() |
| clear() | 清空集合 | s1.clear() |
| difference() | 求取两个集合的差集（包含在第一个集合但不包含在第二个集合的元素） | s1.difference(s2) |
| union() | 求取两个集合的并集 | s1.union(s2) |
| intersection() | 求取两个集合的交集 | s1.intersection(s2) |
代码示例：
python
# 集合 set ---> 可变、无序的、不重复、无索引(不支持切片)
# 定义集合
s1 = {'a', 'b', 'c', 'd', 'e', 'a'}
print(s1, type(s1))
# 定义空集合
# s1 = set()
# print(s1, type(s1))
# s1 = {} # {} <class 'dict'>,直接写{}是定义字典不是集合
# print(s1, type(s1))
# 无索引(不支持切片)
# print(s1[0]) #TypeError: 'set' object is not subscriptable 报错：set不是一个序列
# 常见方法 :
# add() : 添加元素到集合
s1.add('f')
print(s1)
# remove() : 移除集合中的指定元素(指定元素不存在将报错)
s1.remove('f')
print(s1)
# pop() : 随机删除集合中的元素并返回
e = s1.pop()
print(f'被随机删除的元素：{e}, 剩余元素：{s1}')
# clear() : 清空集合
s1.clear()
print(s1)
s2 = {'a', 'b', "c", "d", "e"}
s3 = {"c", "d", "e", "f", 'g'}
# difference() : 求两个集合的差集 (存在于第一个集合, 但不存在于第二个集合)，或者使用-符号
print(f's2和s3的差集：{s2.difference(s3)}') # s2和s3的差集：{'b', 'a'}
print(f's2和s3的差集：{s2 - s3}') # s2和s3的差集：{'b', 'a'}
# union() : 求两个集合的并集 (两个集合中的内容合并到一起，会去除重复数据)，或者使用|符号
print(f's2和s3的并集：{s2.union(s3)}') # s2和s3的并集：{'d', 'c', 'b', 'a', 'e', 'g', 'f'}
print(f's2和s3的并集：{s2 | s3}') # s2和s3的并集：{'d', 'c', 'b', 'a', 'e', 'g', 'f'}
# intersection() : 求两个集合的交集 (两个集合都有的数据)，或者使用&符号
print(f's2和s3的交集：{s2.intersection(s3)}') # s2和s3的交集：{'d', 'c', 'e'}
print(f's2和s3的交集：{s2 & s3}') # s2和s3的交集：{'d', 'c', 'e'}
# 需求: 合并两个列表中的元素，并对合并的结果进行去重处理(去除列表中的重复元素)
num_list1 = [19, 23, 54, 64, 875, 20, 109, 232, 123, 54]
num_list2 = [55, 80, 72, 35, 60, 123, 54, 29, 91]
# 利用解包+集合，将解包后的内容存到集合中
s5 = {*num_list1, *num_list2} # 目的：去重
new_list = list(s5)
print(new_list) # [64, 35, 232, 72, 91, 875, 109, 80, 19, 20, 55, 54, 23, 123, 60, 29]集合推导式
和列表推导式基本上一致，只是列表是[]，集合这里是{}
变量名称={i表达式 for i in 可迭代对象}
变量名称={i表达式 for i in 可迭代对象 if 条件}数据容器的对比
| 特性 | 字符串（str） | 列表（list） | 元组（tuple） | 集合（set） | 字典（dict） |
|---|---|---|---|---|---|
| 有序性 | 有序 | 有序 | 有序 | 无序 | 有序(3.7+) |
| 重复元素 | 允许 | 允许 | 允许 | 不允许 | key不允许 |
| 可变性 | 不可变 | 可变 | 不可变 | 可变 | 可变 |
| 索引访问 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 切片操作 | 支持 | 支持 | 支持 | 不支持 | 不支持 |
| 使用场景 | 文本处理 | 有序可重复数据集合 | 固定数据记录 | 去重数据集合 | 键值对 |
总结：最常用的是字符串和列表，如果要去重就选集合，如果存固定值就使用元组，存键值对用字典。
Python中的filter方法
filter(function, iterable)
- 作用：根据函数返回的布尔值，过滤可迭代对象，保留返回 True 的元素
- 参数
function：判断函数，接收 1 个参数，返回 True / False；也可以传Noneiterable：可迭代对象（列表、元组、集合、字符串等容器）
- 返回值：filter 对象（迭代器），需要用
list()/tuple()转成容器才能看到结果
python
# 需求：返回偶数列表
nums = [1, 2, 3, 4, 5, 6]
# lambda表达式相当于js中的匿名函数
get_even = lambda value: value % 2 == 0
# **filter 对象（迭代器）**，需要用 `list()` / `tuple()` 转成容器才能看到结果
new_nums = filter(get_even, nums)
new_nums_list = list(new_nums)
print(new_nums_list) # [2, 4, 6]