Python数据序列

数据序列	是否有序	是否可变	元素是否允许重复
字符串(String)	是	否	是
列表(List)	是	是	是
元组(Tuple)	是	否	是
集合(Set)	否	是	否
字典(Dict)	是(3.7后保留了插入顺序)	是	Key:值唯一 Value:值可重复

二、列表

2.1 列表的定义

列表是Python中最常用的内置数据结构 之一，它是一个有序的、可变的 序列，用方括号 [] 表示，元素之间用逗号分隔。列表可以存储任意类型 的数据（数字、字符串、甚至其他列表），并且可以通过索引访问每个元素。

基本语法：

定义列表：

**定义不为空的列表：**列表名称 = [data1,data2,data3,...] 或列表名称 = list((data1,data2,data3,...))

**定义空列表：**列表名 = [ ] 或列表名 = list()

python 复制代码

# 创建不同元素类型的列表
names = ['张三','李四','王五']
nums = [1,2,3,4]
demos = [1,2,3,'哈哈','小明']
print(type(demos))
# 结果： <class 'list'>

# 创建空列表
names1 = []
nums1 = list()
print(names1)    # []
print(nums1)    # []

# 使用list()创建列表
nums2 = list((1,2,3,4))
print(nums2)    # [1,2,3,4]

2.2为什么需要列表

1. 批量管理数据

当需要处理多个相关的数据时，列表让他们"团结"在一起，而不是散落在各个变量中。意思就是说：使用列表存储多个相关的数据，只需要声明一个变量存储列表即可；如果分散存储，则需要的变量数量和数据个数相同。使用列表可以更好的管理多个数据，方便后续使用和运算。

2. 顺序性

列表会记住元素添加的顺序，可以通过位置（索引）快速找到每个元素。

3. 可变性

列表创建后可以随时增、删、改元素，非常灵活。

4. 可迭代

可以使用循环遍历列表中的每一个元素，批量处理数据。

以下示例带你直观地了解是否使用列表地区别：

从代码量来看使用列表更加简洁、方便，在数据量大的情况下，对遍历和运算非常友好。

python 复制代码

''' 
    进行数学运算------计算学生的平均分
'''
# 不使用列表，使用变量分散存储单个数据
score1 = 85
score2 = 92
score3 = 78
score4 = 88
average = (score1 + score2 + score3 + score4) / 4
print(f"平均分: {average}")
# ... 如果有50个学生，就要写50个变量
# 计算平均分:要写 sum = score1 + score2 + ... + score50 太麻烦


# 使用列表
scores = [85, 92, 78, 88]
# 平均分只需一行
average = sum(scores) / len(scores)
print(f"平均分: {average}")




'''
    进行数据的编历和批量处理------在上述的基础上，为每个同学增加5分
'''
# 不使用列表
score1 += 5
score2 += 5
score3 += 5
score4 += 5
# ...


# 使用列表
for i in range(len(scores)):
    scores[i] += 5

核心思想：

独立变量就像是散落在地面上的物品（数据），找起来麻烦，数量多了更加混乱。

列表就相当于一个抽屉，外面零散的物品（数据），按顺序放到抽屉（列表）中，想拿第几个就拿第几个，想增加抽屉就加，想批量扔掉直接使用他们的位置（索引）进行批量处理（即直接删除从第几个到第几个）。方便管理的同时，使得代码界面更加简洁、清晰。

2.3 列表的常用操作

列表的作用是一次性存储多个数据，我们可以进行的操作有：增、删、改、查（遍历）。

2.3.1查询

列表的底层存储形式和字符串是一样的，都是通过索引下标来对其进行引用的。

python 复制代码

names = ['张三','李四','王五']
print(names[0]) # 张三
print(names[1]) # 李四
print(names[2]) # 王五

index()

查询列表中的元素。如果存在，返回首个匹配元素对应的索引下标 （位置）；如果不存在，会和字符串中的index()方法一样抛出异常。

语法结构：列表名.index(查找的元素,开始下标,结束下标) 【开始下标和结束下标的使用方法和字符串中的相同，后续不再过多赘述】

python 复制代码

nums = [1,2,8,4,10,12,11,4,22]
print(nums.index(4))    # 3
print(nums.index(5))    # 该元素不在该列表中，控制台抛出异常
print(nums.index(4,5))  # 7    表示从列表中第6个开始首个匹配的元素的下标索引

count()

统计列表中指定数据的出现次数，也可以说是列表中有多少个该元素。

语法结构：列表名.count(数据)

python 复制代码

nums = [1,2,8,4,10,12,11,4,22,4]
print(nums.count(4))
# 3    列表中"4"出现了3次

in / not in

in：判断指定数据在列表序列中，如果在返回True；如果不在返回False

not in：判断指定数据不在列表序列中，如果不在返回True；如果在返回False

python 复制代码

nums = [11,22,33,44,55]
print(11 in nums)    # True
print(11 not in nums)    # Flase
print(23 in nums)    # False
print(23 not in nums)    # True

综合示例

python 复制代码

# 小卖铺一周内的顾客名单
customer_names = ['张三','李四','王五','赵六','张三','王五','王五']
name = input('请输入要查询的顾客姓名：')
if name in customer_names:
    # 统计该顾客来过多少次该店铺
    count = customer_names.count(name)
    print(f'该顾客来过{count}次该店铺！')
else:
    print('该顾客不曾来过该店铺！')

2.3.2 增加

方法	功能描述	核心特点
list.append(data)	在列表末尾添加一个元素	将data作为一个整体添加
list.extend(iterable)	在列表末尾批量添加多个元素	遍历可迭代对象，将元素逐个添加
list.insert(i,data)	在指定索引i处添加元素	原位置及之后的元素会向后移动
+ 或 +=	列表拼接	"+"创建新列表；"+='原地修改相当于extend()

示例

python 复制代码

# 初始化列表
my_list = [1, 2, 3]

# 1. list.append(x)：末尾添加单个元素
my_list.append(4)          # 添加数字4
my_list.append([5, 6])     # 添加列表[5,6]（视为整体）
print(my_list)  # 输出: [1, 2, 3, 4, [5, 6]]

# 2. list.extend(iterable)：末尾批量添加元素
my_list.extend([7, 8])     # 遍历[7,8]，逐个添加
my_list.extend("ab")       # 遍历字符串，逐个添加字符
print(my_list)  # 输出: [1, 2, 3, 4, [5, 6], 7, 8, 'a', 'b']

# 3. list.insert(i, x)：指定索引插入元素
my_list.insert(0, 0)       # 在索引0处插入0，原元素后移
my_list.insert(-1, 99)     # 在倒数第1个位置前插入99
print(my_list)  # 输出: [0, 1, 2, 3, 4, [5, 6], 7, 8, 99, 'a', 'b']

# 4. + 或 +=：列表拼接
new_list = my_list + [10, 11]  # + 创建新列表
my_list += [12, 13]            # += 原地修改（类似extend）
print(new_list)  # 输出: [0, 1, 2, 3, 4, [5, 6], 7, 8, 99, 'a', 'b', 10, 11]
print(my_list)   # 输出: [0, 1, 2, 3, 4, [5, 6], 7, 8, 99, 'a', 'b', 12, 13]

2.3.3删除

方法	功能描述	参数类型	核心特点
list.remove(data)	按值删除	元素的值	删除列表中第一个匹配的元素
list.pop(i)	按索引删除	元素的索引	删除并返回索引为 i 的元素，不写()中的 i 默认删除最后一个
del list[i]	按索引删除	元素的索引	删除索引为 i 的元素不返回值
list.clear()	清空列表	无	删除列表中的所有元素，使其变为空 [ ]

示例

【使用下面代码练习，建议练习一个注释一个，使结果更加直观】

python 复制代码

# 使用remove() 方法
fruits = ['apple', 'banana', 'cherry', 'banana']
# 我要扔掉一个 'banana'
fruits.remove('banana') 
print(fruits) 
# 输出: ['apple', 'cherry', 'banana']
# 只剩下一个 'banana' 了，说明它只删了第一个找到的


# 使用pop(i) 方法
fruits = ['apple', 'banana', 'cherry', 'banana']
# 我要扔掉一个 'banana'
fruit = fruits.pop(1) 
print(f'删除的元素为{fruit},剩余元素为{fruits}')
# 输出：删除的元素为banana,剩余元素为['apple', 'cherry', 'banana']


# 使用pop() 方法，不写参数
fruits = ['apple', 'banana', 'cherry', 'banana']
fruit = fruits.pop()    # 默认删除列表最后一个元素
print(f'删除的元素为{fruit},剩余元素为{fruits}')
# 输出：删除的元素为banana,剩余元素为['apple', 'banana', 'cherry']


# 使用del 删除列表元素
fruits = ['apple', 'banana', 'cherry', 'banana']
del fruits[1]    # 删除列表索引为1的元素
print(fruits)
# 输出：['apple', 'cherry', 'banana']


# 使用del和切片规则删除列表中一段连续的元素
fruits = ['apple', 'banana', 'cherry', 'banana','wartermelon']
del fruits[1:3]     # 删除列表索引为1到3的元素，但不包括3
print(fruits)
# 输出：['apple', 'banana', 'wartermelon']


# 使用del和切片规则删除列表中间隔相同的连续的元素
fruits = ['apple', 'banana', 'cherry', 'banana','wartermelon']
del fruits[1::2]    # 删除列表索引为1到3的元素
print(fruits)
# 输出：['apple', 'cherry', 'wartermelon']


# 使用clear() 方法
fruits = ['apple', 'banana', 'cherry', 'banana']
fruits.clear()    # 清空列表
print(fruits)
# 输出：[]

2.3.4修改

操作/方法	功能描述	核心特点
索引赋值 `list[i] = x`	修改指定索引处的元素	最直接、最常用的修改方式。
切片赋值 `list[a:b] = iterable`	批量修改或替换指定范围的元素	可以替换、删除或插入多个元素。
`list.sort()`	对列表进行原地排序	直接修改原列表，无返回值。
`sorted(list)`	返回排序后的新列表	不修改原列表，返回新列表。
list.copy()	返回一个浅拷贝的新列表	实现对象分离。修改新列表，通常不影响原列表

示例

python 复制代码

# 使用索引赋值
nums = [1,2,3,4,5,6,7,8,9,10]
nums[0] = 0
nums[4] = 11
print(nums)
# 输出：[0, 2, 3, 4, 11, 6, 7, 8, 9, 10]


# 使用切片赋值
nums = [1,2,3,4,5,6,7,8,9,10]
nums[0:4] = [0,0,0,0]
print(nums)
# 输出：[0, 0, 0, 0, 5, 6, 7, 8, 9, 10]


# 对列表进行原地排序
nums = [1,2,22,4,33,6,44,8,55,10]
nums.sort()
print(nums)
# 输出：[1, 2, 4, 6, 8, 10, 22, 33, 44, 55]


# 使用sorted()对列表排序并返回新列表
nums = [1,2,22,4,33,6,44,8,55,10]
nums1 = sorted(nums)
print(nums1)
# 输出：[1, 2, 4, 6, 8, 10, 22, 33, 44, 55]

# 对列表进行原地逆序
nums = [1,2,3,4,5,6,7,8,9,10]
nums.reverse()
print(nums)
# 输出：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]


# 使用copy()对列表进行浅复制
nums = [1,2,3,4,5,6,7,8,9,10]
nums1 = nums.copy()
print(nums1)
# 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 对nums1进行修改
nums1.append(11)
print(nums1)
print(nums)
# 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


# 不使用copy()复制，会发现对nums1进行修改，nums也会被修改
nums = [1,2,3,4,5,6,7,8,9,10]
nums1 = nums
nums1.append(11)
print(nums1)
print(nums)
# 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

2.3.5列表的循环遍历

while循环遍历

python 复制代码

# 定义列表
names = ['张三', '李四', '王五', '赵六', '孙七']
# 初始化循环变量
i = 0
# 设置循环条件
while i < len(names):
    # 打印列表元素
    print(names[i])
    # 循环变量自增，确保循环不会无限执行
    i += 1

for循环遍历

python 复制代码

# 定义列表
names = ['张三', '李四', '王五', '赵六', '孙七']
# 使用for驯悍遍历列表【因为列表为可迭代对象，所以可以使用for循环遍历列表】
for name in names:
    # 打印列表中的元素
    print(name)

2.3.6列表嵌套

列表嵌套：就是列表中的每元素还是一个列表。【是一个矩阵（或者说是表格）】

访问方式：双重索引。语法：list[row][col] / list[行索引][列索引]

常用场景：表格数据、矩阵运算、多维坐标等

三、元组

3.1元组的定义

定义：元组（Tuple）是Python中的一种有序、不可变的序列类型。

核心特点：它与列表（List）非常相似，唯一的区别在于：元组一旦创建其内容就不能被修改（不能添加、删除或更改元素）

创建方式：

元组使用圆括号 () 来定义，元素之间用逗号" , "分隔或者使用tuple((data1,data2,data3,...))。例如：

python 复制代码

# 使用定义形式创建元组
my_tuple = (1, 2, 3, 4)
print(my_tuple)    # (1, 2, 3, 4)
# 使用tuple()创建元组
my_tuple1 = tuple((1, 2, 3, 4))
print(my_tuple1)    # (1, 2, 3, 4)

也可以不加括号，直接用" , "分隔元素：

python 复制代码

my_tuple = 1, 2, 3, 4

但推荐使用带有圆括号的定义方式更为稳妥。

也可以使用()或者tuple()创建空元组

python 复制代码

# my_tuple = ()
my_tuple = tuple()
print(my_tuple)    # ()

3.2为什么需要使用元组

1. 数据安全性（不可变性）

元组的不可变性是其最大的特点。一旦创建，元组的内容就不能被修改。应用场景：保护数据不被意外修改、作为字典的键...

2. 性能优势

由于元组是不可变的，Python在内部对元组的处理比列表更高效。表现为：

· 更小的内存占用：元组的存储空间比列表更紧凑

· 更快的访问速度：由于元组的不可变性，Python可以对其进行优化，访问元组元素的速度通常比列表更快。

3. 用于返回多个值

在函数中，元组常用于返回多个值。【这个在学习了函数后，比较常用，建议着重了解一下】

python 复制代码

def get_user_info():
    name = "Alice"
    age = 25
    city = "Beijing"
    return name, age, city  # 返回一个元组

user_info = get_user_info()
print(user_info)
# 输出: ('Alice', 25, 'Beijing')

4. 用于数据交换

元组的解包特性使得数据交换变得非常简单，不需要再使用引入中间量来存储两个变量转换过程中的值。例如：

python 复制代码

a = 1
b = 2

# 交换 a 和 b 的值
a, b = b, a

print(a, b)  # 输出: 2 1

3.3 元组常用操作

3.3.1 常用操作

函数	作用
元组名[索引]	根据索引下标查找元素
元组名.index()	查找某个元素，如果元素存在返回对应的下标，否则报错。
元组名.count()	统计某个元素在当前元组中出现的次数
len(元组名)	统计元组中的元素个数

python 复制代码

# 定义元组
tuple1 = ('aa', 'bb', 'cc', 'bb')
# 遍历第一个元素
print(tuple1[0])  # aa
# 查找元素'aa'
print(tuple1.index('aa'))  # 0
# 统计'bb'出现的次数/统计'bb'在当前元组中的个数
print(tuple1.count('bb'))  # 2
# 统计元组中元素的个数
print(len(tuple1))  # 4

3.3.2 元组无法增删改⭐⭐⭐

元组因为其特性（元组内部元素不可变）所以无法进行增删改，只能通过新建元组的方式实现对原始元组的增删改操作。

但是，并不是说在元组内部的元素也不可变。这句话如何理解呢？

当一个元组中的元素为可变类型的数据序列，就可以对元组内的元素(可变的数据序列)进行增删改操作。

例如：元组中的元素都是列表，元组中元素(列表)不能增加或删除一个元素(列表)，但是可以对列表中的元素进行修改、增加或删除，这从另一个角度讲实现了对元组的增删改。具体实现如下所示：

python 复制代码

# 定义一个元组，内部的元素为列表
my_tuple = ([1,2,3],[4,5],[6,7,8],[9])
# 尝试修改元组的元素，也就是说尝试修改某个列表替换为另一个列表元素
# my_tuple[0] = [10,11,12]
# print(my_tuple)    # TypeError: 'tuple' object does not support item assignment


# 但是先提取出元组中某个列表，在进行列表中的元素增删改
# 修改元组中第一个列表的第一个元素
my_tuple[0][0] = 10
print(my_tuple)     #([10, 2, 3], [4, 5], [6, 7, 8], [9])
# 增加元组中第一个列表的元素
my_tuple[0].append(11)
print(my_tuple)     #([10, 2, 3, 11], [4, 5], [6, 7, 8], [9])
# 删除元组中第一个列表的最后一个元素
my_tuple[0].pop()
print(my_tuple)     #([10, 2, 3], [4, 5], [6, 7, 8], [9])

# 如果想实现元组删除，直接删除列表中的元素即可，这样就以另一种方式实现了元组的增删改
# 清空元组 == 清空每个列表元素
for i in my_tuple:
    i.clear()
print(my_tuple)     #([], [], [], [])

列表循环遍历同样适用于元组

四、字典

4.1 字典的定义

字典：一种**键值对(Key-Value Pair)**的集合，用于存储具有映射关系的数据。

表示方式：使用花括号"{} "包裹，键值对之间以冒号":"连接。

核心特点：字典中键值对的键(Key)是唯一且不可变的 ；值(Value)可以是可重复的、任意类型的数据。

有序性：Python 3.7+ 版本后，字典会保留插入顺序。

什么是键值对？

想想一下查字典：

你查字的时候，是先找拼音（键/Key） ，然后才能看到对应的汉字解释（值/Value）。
在 Python 中，我们不再像列表那样通过"第几个位置（索引）"来找数据，而是通过**"名字（键）"**来找数据。

语法结构

一般"Key"在"："前，"Value"在"："后面，这就是一个键值对的形式。

字典名 = {"Key1":Value1,"Key2":Value2,...}

或者使用 {} / dict() 创建空字典

【注意：这里的{}，在不写任何内容的情况下表示创建空字典，但是如果里面有数据（但不是键值对的形式）则创建的是集合。所以这里容易和集合的创建混淆，请多多留意】

示例：

python 复制代码

# 使用字典的定义形式创建字典
user_dict = {"name": "James", "age": 20, "country": "Canada"}
print(user_dict)    # {'name': 'James', 'age': 20, 'country': 'Canada'}
# 使用dict()创建字典
user_dict1 = dict({"name": "James", "age": 20, "country": "Canada"})
print(user_dict1)    # {'name': 'James', 'age': 20, 'country': 'Canada'}

python 复制代码

# 创建空字典
# user_dict = {}
user_dict = dict()
print(user_dict)    # {}

4.2 为什么需要字典

字典有两大优势：

语义清晰：student["name"]比student[0]更加直观和通俗易懂。并且如果使用列表存储，后续列表中元素的顺序发生变化：

student = ["Tom",23,"man"] ==> student = ["man",23,"Tom"]

student[0]和原来student[0]的不同了,但student["name"]不同。

查找速度快 ：列表查找数据需要从头遍历到尾（慢），字典通过"哈希算法"直接定位，哪怕有一百万条数据，也能瞬间找到。

4.3 字典的常用操作

4.3.1 增加

基本语法：字典名[key] = value

如果key在当前字典中已存在，则会修改"key"对应的值；如果不存在，则会增加一个键值对（key:value）。

python 复制代码

user_dict = {"name": "James", "age": 20, "country": "Canada"}
# 执行字典的增加操作
user_dict["sex"] = "male"
print(user_dict)    # {'name': 'James', 'age': 20, 'country': 'Canada', 'sex': 'male'}

4.3.2 修改

基本语法：字典名[key] = value

和增加操作语法相同，解释同上（黄色背景）

python 复制代码

user_dict = {"name": "James", "age": 20, "country": "Canada"}
# 执行字典的修改操作（将年龄修改为23）
user_dict["age"] = 23
print(user_dict)    # {'name': 'James', 'age': 23, 'country': 'Canada'}

4.3.3 删除

del() / del ：删除字典或删除字典中指定的键值对

python 复制代码

user_dict = {"name": "James", "age": 20, "country": "Canada"}
# 执行字典的删除操作：del() / del
# 删除字典中指定的键值对
# del(user_dict["name"])
del user_dict["name"]
print(user_dict)    # {'age': 20, 'country': 'Canada'}
# 删除字典
# del user_dict
# del(user_dict)
# print(user_dict)    # 和清空字典不同，删除字典后"user_dict"变量就会丢失，所以会报错

clear():清空字典

python 复制代码

user_dict = {"name": "James", "age": 20, "country": "Canada"}
# 清空字典
user_dict.clear()
print(user_dict)    # {}

4.3.4 查找

最简单的一种方式就是：通过Key值查找------字典名["Key"]

python 复制代码

user_dict = {"name": "James", "age": 20, "country": "Canada"}
# 通过key值查找指定的元素
print(user_dict["country"])    # Canada

常用查找函数

函数	作用
get(key,默认值)	根据字典中的key获取对应的value。如果字典中不存在指定的key，则返回默认值；如果不写第二个参数，则返回None
keys()	以列表的形式返回字典中的所有key值
values()	以列表的形式返回字典中的所有value值
items()	以列表的形式返回可遍历的(键，值)的元组

python 复制代码

user_dict = {"name": "James", "age": 20, "country": "Canada"}
# 字典的查找操作

# 字典名[key]
# print(user_dict["name"])  # James

# 字典名.get(key,默认值)
# print(user_dict.get("name", "Unknown"))     # James
# print(user_dict.get("name_name", "Unknown"))       # Unknown
# print(user_dict.get("name_name"))       # None

# keys()和values()的使用
# print(user_dict.keys())     # dict_keys(['name', 'age', 'country'])
# print(user_dict.values())   # dict_values(['James', 18, 'China'])

# items()的使用
print(user_dict.items())    # dict_items([('name', 'James'), ('age', 18), ('country', 'China')])

4.3.5 字典循环遍历

遍历字典的key

python 复制代码

user_dict = {"name": "James", "age": 20, "country": "Canada"}
# 遍历key值的两种方式
for key in user_dict.keys():
    print(key)

# for key in user_dict:
#    print(key)

遍历字典的value

python 复制代码

user_dict = {"name": "James", "age": 20, "country": "Canada"}
# 遍历字典的value
for value in user_dict.values():
    print(value)

遍历字典的item（键值对）

python 复制代码

user_dict = {"name": "James", "age": 20, "country": "Canada"}
# 字典以键值对的形式输出
for item in user_dict.items():
    print(item)

# ('name', 'James')
# ('age', 20)
# ('country', 'Canada')

遍历字典中键值对的元素

python 复制代码

user_dict = {"name": "James", "age": 20, "country": "Canada"}
# 遍历字典中键值对的元素
for key,value in user_dict.items():
    print(f'{key} : {value}')

# name : James
# age : 20
# country : Canada

五、集合

5.1 集合的定义

定义：一个无序的，不重复的数据序列。（集合中的元素是不能重复的并且是无序的）

核心特点：集合中的元素不能重复，意味着集合可以用来对数据去重；集合中的元素是无序的，意味着集合无法使用索引的形式访问集合中的每个元素。

语法结构：集合名 = {1,2,3,4,12}

创建集合的方式：

使用带有数据的"{}"创建有数据的集合

set()创建空集合

python 复制代码

# 使用"{}"创建集合
set1 = {"apple", "banana", "cherry"}
print(set1)     # 输出：{'apple', 'banana', 'cherry'}
# 使用"set()"创建空集合
set2 = set()
print(set2)     # 输出：set()
# 使用"set()"创建有数据的集合
set3 = set(("apple", "banana", "cherry"))
print(set3)     # 输出：{'apple', 'banana', 'cherry'}

5.2 为什么需要使用集合

1. 极速的数据去重

由于集合的特点（集合中的元素不能重复），可以实现对数据的去重操作。比如原本有大量数据的列表想要实现去重，只需要将其转换为集合，最后打印集合就是去重后的数据。

2. 高效的成员测试

在列表中使用" if x in list_name "查找一个元素是否在列表中，如果有一万条数据，最坏的结果是遍历一万次。但在集合中无论数据量多大，查找几乎是瞬间完成的。

5.3 集合的常用操作

因为集合不支持通过索引来访问元素或修改元素，但支持添加和删除。

5.3.1 增加

5.3.1.1 添加

add() : 增加单一元素

【注意】因为集合有去重功能，所以，当向集合内追加的数据是当前集合已存在的数据，则不进行任何操作。

python 复制代码

my_set = {1,2,3,4}
# add()增加一个元素
my_set.add(5)
print(my_set)   # {1, 2, 3, 4, 5}
# 当添加的元素在集合中已经存在时，不执行任何操作
my_set1 = {1,2,3,4}
my_set1.add(2)
print(my_set1)  # {1, 2, 3, 4}

5.3.1.2 批量添加

update() : 将数据序列（列表、元组、字符串等）中的多个元素加入集合

需要注意，列表、元组、集合是将里面的元素逐个加入集合，而字符串是每个字符逐个加入集合。

python 复制代码

my_set = {1,2,3,4}
# 使用update()方法添加字符串
my_set.update("hello")
print(my_set)     # 输出：{1, 2, 3, 4, 'h', 'e', 'l', 'o'}
# 使用update()方法添加列表
my_set1 = {1,2,3,4}
my_set1.update([5,6,7])
print(my_set1)    # 输出：{1, 2, 3, 4, 5, 6, 7}

5.3.2 删除

remove()

删除集合中指定数据，若数据不存在则报错。

python 复制代码

my_set = {1,2,3,4}
# 使用remove()删除集合中的"2"
my_set.remove(2)
print(my_set)   # 输出：{1, 3, 4}

discard()

删除集合中指定数据，如果数据不存在也不会报错。

python 复制代码

my_set = {1,2,3,4}
# 使用discard()删除集合中的"2"
my_set.discard(2)
print(my_set)   # 输出：{1, 3, 4}

pop()

随机删除集合中的某个数据，并返回删除的数据。

【困惑】

在很多情况下，你会发现 pop() 总是删除最小的那个数字（例如 1）。
原因：这是因为在底层的哈希表中，较小的整数往往被放置在更靠前的"槽位"里，所以 pop() 遍历时第一个遇到的就是它。

python 复制代码

my_set = {1,2,3,4}
# 使用pop()删除
num = my_set.pop()
print(f'删除：{num},剩余集合元素：{my_set}')   # 删除：1,剩余集合元素：{2, 3, 4}

5.3.3 查询

in/not in ：判断数据是否在集合序列中。

python 复制代码

my_set = {1,2,3,4,5,6,7,8,9,10}
# 使用in/not in判断数据是否在集合中
print(5 in my_set)  # True
print(55 in my_set) # False
print(5 not in my_set)  # False
print(55 not in my_set) # True

六、数据序列的公共方法

运算符	描述	支持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、集合、字典
not in	元素是否不存在	字符串、列表、元组、集合、字典

python 复制代码

# "+" 合并操作
# 字符串
str1 = "hello"
str2 = "world"
print("字符串：",str1 + str2)
# 列表
list1 = [1,2,3,4,5]
list2 = [6,7,8,9,10]
print("列表：",list1 + list2)
# 元组
tuple1 = (1,2,3,4,5)
tuple2 = (6,7,8,9,10)
print("元组：",tuple1 + tuple2)
# 结果：
# 字符串： helloworld
# 列表： [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 元组： (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)


# "*" 重复操作
# 字符串
str1 = "hello"
print("字符串：",str1 * 3)
# 列表
list1 = [1,2,3,4,5]
print("列表：",list1 * 3)
# 元组
tuple1 = (1,2,3,4,5)
print("元组：",tuple1 * 3)
# 输出结果：
# 字符串： hellohellohello
# 列表： [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
# 元组： (1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5)

# "in" 运算符
# 列表
list1 = [1,2,3,4,5]
print(1 in list1)   # True
print(6 in list1)   # False
# 元组
tuple1 = (1,2,3,4,5)
print(1 in tuple1)  # True
print(6 in tuple1)  # False
# 字符串
str1 = "hello"
print("h" in str1)  # True
print("a" in str1)  # False

# not in 运算符和上述in 运算符相反

函数	描述
len()	统计序列中的元素个数
del / del()	删除序列中的某个元素或者删除数据序列
max() / min()	返回序列中的最大/最小值
range(start,end,step)	生成从 [start，end) 的数字，步长为step，供for循环使用
enumerate()	枚举，函数将数据序列中的每个元素分别组合在一个带索引的元组中

下面只展示使用enumerate()方法，枚举数据序列中每个元素：

python 复制代码

# 定义一个列表
list1 = ['apple', 'banana', 'orange','pear','watermelon']
# 使用enumerate()函数和for循环遍历列表，先查看枚举的结果
for element in enumerate(list1):
    print(element)
# 输出结果：
# (0, 'apple')
# (1, 'banana')
# (2, 'orange')
# (3, 'pear')
# (4, 'watermelon')

# 使用enumerate()函数和for循环遍历列表，同时获取索引和值
for index, value in enumerate(list1):
    print("索引为：", index, "值为：", value)
# 输出结果：
# 未指定索引时，默认从0开始
# 索引为： 0 值为： apple
# 索引为： 1 值为： banana
# 索引为： 2 值为： orange
# 索引为： 3 值为： pear
# 索引为： 4 值为： watermelon


# 指定索引从1开始
for index, value in enumerate(list1, 1):
    print("索引为：", index, "值为：", value)
# 输出结果：
# 索引为： 1 值为： apple
# 索引为： 2 值为： banana
# 索引为： 3 值为： orange
# 索引为： 4 值为： pear
# 索引为： 5 值为： watermelon

七、推导式

7.1 什么是推导式？

推导式 ：又称解析式 ，是Python独有的一种特性。它允许你使用一行代码 ，从一个现有的数据序列 （列表、元组等）通过特定的规则（循环、过滤、计算），快速生成一个新的数据序列 。共有三种推导式：列表推导式、集合推导式、字典推导式。

7.2 为什么需要推导式？

代码更简洁：3-4行代码压缩为一行代码。
执行效率更高：在Python内部，推导式的执行速度通常比普通的for循环快。
可读性强：习惯了这种语法后，你会一眼就能看出代码是在"做什么"（生成数据），而不是"怎么做"（循环append）。也就是说只关心生成什么样的数据，不关心使用什么方法将数据添加进去。

下属代码，带你直观感受分别使用列表推导式和for循环生成（添加）列表数据：

python 复制代码

# 先定义一个空列表
my_list = []
# 使用for循环往列表中添加元素
for i in range(10):
    my_list.append(i)
print(my_list)

# 使用列表推导式
my_list = [i for i in range(10)]
print(my_list)

# 上述两个方式的输出结果：
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 两种方式结果一致，但是从代码量上看：使用列表推导式比使用for循环要简洁，效率更高。

7.3 三种推导式

7.3.1 列表推导式

可迭代对象：请参考前面《Python循环结构》中的迭代对象

基本的推导式：

变量名 = [表达式 for 循环变量 in 可迭代对象]

python 复制代码

# 先定义一个空列表
my_list = []

# 使用列表推导式
my_list = [i for i in range(10)]
print(my_list)

# 输出结果：
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

带有if条件的推导式：

变量名 = [表达式 for 循环变量 in 可迭代对象 if 条件]

python 复制代码

# 先定义一个空列表
my_list = []

# 使用列表推导式创建1-10的偶数列表
my_list = [i for i in range(10) if i % 2 == 0]
print(my_list)

# 输出结果：
# [0, 2, 4, 6, 8]

多个for循环实现的推导式：

变量名 = [表达式 for 循环变量 in 可迭代对象 for 循环变量1 in 可迭代对象1]

python 复制代码

# 先定义一个空列表
my_list = []

# 使用列表推导式创建0,1,2三个数中取两个数的不同组合
my_list = [(i,j) for i in range(3) for j in range(3)]
print(my_list)

# 上述两个方式的输出结果：
# [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

7.3.2 字典推导式

字典推导式是列表推导式思想的延续，语法类似，只不过产生的是字典而已。

字典推导式的作用：快速合并列表为字典或提取字典中目标数据。

下述示例：

将两个列表按对应位置合并为字典

python 复制代码

# 定义两个位置元素相对应且长度相同的列表
user_names = ['admin', 'tom', 'jerry', 'lucy']
user_passwords = ['123456', '654321', 'abcdef', 'qwerty']
# 使用推导式将上述两个列表转换为字典
user_dict = {user_names[i]: user_passwords[i] for i in range(len(user_names))}
print(user_dict)
# 输出结果：{'admin': '123456', 'tom': '654321', 'jerry': 'abcdef', 'lucy': 'qwerty'}

提取字典中的目标数据为两个列表

python 复制代码

# 定义一个字典
user_dict = {'admin': '123456', 'tom': '654321', 'jerry': 'abcdef', 'lucy': 'qwerty'}
# 使用推导式提取字典中的所有用户名
user_names = [name for name in user_dict.keys()]
print(user_names)
# 输出结果：['admin', 'tom', 'jerry', 'lucy']

7.3.3 集合推导式

集合推导式和列表基本一致，唯一的区别是使用"{}"替换了"[]"。

但是集合具有去重功能。

python 复制代码

# 定义一个列表
list1 = [1, 1, 3, 2, 5]
# 现在我像获得列表中每个元素平方后的不同结果（要求不重复显示相同结果）
# 此时就考虑去重------集合
set1 = {i**2 for i in list1}
print(set1)
# 输出结果：{1, 4, 9, 25}

八、总结

第一部分（一）：介绍了什么是数据序列、数据序列的分类（列表、字符串、字典、集合、元组）以及各自的特点。

第二部分（二~五）：介绍了四种数据序列的概念、为什么使用这些数据序列以及这些数据序列的常用操作（增删改查）。

第三部分（六）：介绍了这几种数据序列的公共方法。

最后一部分（七）：简单介绍了什么是推导式、为什么使用推导式并演示了三种推导式的使用。

总的来说，这些只是Python数据序列的常用基本操作 ，并不是所有 。其中还有各种数据类型之间的转换，本章节未进行讲解，其实很简单大家可以去搜索一下就是（str()、set()、list()、dict()、tuple()）方法的使用，需要注意其中的字符串和字典。推导式这里只是简单介绍，后期会有生成器相关概念，本章的主要目的是：让大家理解不同数据序列之家的关系和区别。

如果文章有何问题，欢迎各位朋友积极指正！！！

Python数据序列

一、数据序列

1.1 序列的概念

1.2 序列的分类

二、列表

2.1 列表的定义

2.2为什么需要列表

2.3 列表的常用操作

2.3.1查询

index()

count()

in / not in

综合示例

2.3.2 增加

2.3.3删除

2.3.4修改

2.3.5列表的循环遍历

2.3.6列表嵌套

三、元组

3.1元组的定义

3.2为什么需要使用元组

1. 数据安全性（不可变性）

2. 性能优势

3. 用于返回多个值

4. 用于数据交换

3.3 元组常用操作

3.3.1 常用操作

3.3.2 元组无法增删改⭐⭐⭐

列表循环遍历同样适用于元组

四、 字典

4.1 字典的定义

什么是键值对？

语法结构

4.2 为什么需要字典

4.3 字典的常用操作

4.3.1 增加

4.3.2 修改

4.3.3 删除

4.3.4 查找

常用查找函数

4.3.5 字典循环遍历

五、集合

5.1 集合的定义

5.2 为什么需要使用集合

1. 极速的数据去重

2. 高效的成员测试

5.3 集合的常用操作

5.3.1 增加

5.3.1.1 添加

5.3.1.2 批量添加

5.3.2 删除

remove()

discard()

pop()

5.3.3 查询

六、数据序列的公共方法

七、推导式

7.1 什么是推导式？

7.2 为什么需要推导式？

7.3 三种推导式

7.3.1 列表推导式

7.3.2 字典推导式

7.3.3 集合推导式

八、总结

四、字典