系列文章目录
python学习---合并TXT文本文件
python学习---统计嵌套文件夹内的文件数量并建立索引表格
python学习---查找指定目录下的指定类型文件
python学习---年会不能停，游戏抽签抽奖
python学习---循环语句-控制流
python学习---合并多个Excel工作簿表格文件
文章目录
- 系列文章目录
- 功能说明
- [1 列表（List）](#1 列表（List）)
-
-
- [(1) 读取数据](#(1) 读取数据)
- [(2) 包容性好](#(2) 包容性好)
- [(3) 截取 切片](#(3) 截取 切片)
- [(4) 列表添加数据（append() ）](#(4) 列表添加数据（append() ）)
- [(5) 列表删除数据（del 列表[索引]）](#(5) 列表删除数据（del 列表[索引]）)
- [(6) 列表脚本操作符（ + * ）](#(6) 列表脚本操作符（ + * ）)
- [(7) 列表函数（len 、 max、 min)](#(7) 列表函数（len 、 max、 min))
- [(8) 列表方法（extend、count、index、insert、pop、remove、reverse、sort、copy、clear）](#(8) 列表方法（extend、count、index、insert、pop、remove、reverse、sort、copy、clear）)
-
- [2 元组（Tuple）](#2 元组（Tuple）)
-
-
- [(1) 与列表相同的读取、截取 切片、迭代、+ * 、函数](#(1) 与列表相同的读取、截取 切片、迭代、+ * 、函数)
- [(2) ==区别==](#(2) ==区别==)
-
- [3 浅拷贝 、传递 引用](#3 浅拷贝 、传递 引用)
- [4 后记](#4 后记)
功能说明
本文简单介绍python中的列表（List）和元组（Tuple），它们是python语言的两种基本的数据结构，用于存储有序的元素集合。尽管它们在某些方面相似，但在功能和用途上存在关键区别。
python版本为 python3。
-
列表（List） ： 列表是可变的（mutable）序列类型，这意味着你可以修改列表中的元素，添加或删除元素。
语法：用方括号 [] 包围，元素之间用逗号 , 分隔。例如：my_list = [1, 2, 3]
特性：索引：每个元素都分配一个数字作为它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
动态大小：列表的长度可以在程序运行时改变；
支持多种数据类型：列表中的元素可以是不同类型的，如整数、字符串、甚至是其他列表；
可变操作：支持增加、删除、修改元素等操作，如 append(), extend(), pop(), remove() 等方法。
应用场景：当需要一个可以频繁修改的集合时，比如存储购物车商品列表、动态生成的结果集等。 -
元组（Tuple） ：元组是不可变的（immutable）序列类型，一旦创建，就不能更改其中的元素。
语法：元组用圆括号 () 包围，同样用逗号 , 分隔元素。单个元素的元组需要在元素后加一个逗号，如 (1,)。空元组直接写作 ()。
特性：静态大小：元组创建后，其长度和内容都是固定的，不能增删改元素；
支持多种数据类型：与列表一样，元组中的元素也可以是不同类型的；
效率高：由于不可变性，元组在某些情况下比列表更节省内存，访问速度也更快。
应用场景：当需要一个固定不变的数据集合时，比如表示坐标(x, y)、存储数据库查询结果的列名等
1 列表（List）
(1) 读取数据
列表中数据，叫 元素。
python
students = ['小明','小红','小刚']
print(students[0]) # 小明 索引为 0 的元素
for i in students:
print(i+'在不在？')
# 小明在不在？
# 小红在不在？
# 小刚在不在？(2) 包容性好
列表中的元素可以是不同类型的，如整数、字符串、甚至是其他列表。
python
list1 = ['小明',18,1.70,['小明','小红','小刚']] (3) 截取 切片
切片，一次从列表提取多个元素 ，切出来的 还是列表 。
注意： 从 0 开始起排。
python
list2 = [5,6,7,8,9]
print(list2[:]) # [5,6,7,8,9]
print(list2[2:]) # [7,8,9]
print(list2[:2]) # [5,6]
print(list2[1:3]) # [6,7]
print(list2[2:4]) # [7,8]
python
students = ['小明','小红','小刚']
print(students[:2]) # ['小明', '小红']
print(students[2:]) # ['小刚']
print(students[2]) # 小刚 索引为2的元素 。倒数的时刻，从 1 开始。
python
print(list2[-2]) # 8 读取列表中倒数第二个元素
print(list2[8]) # 报错 IndexError: list index out of range。 超出列表长度总结规则：
-
左右空，取到头 ；
冒号左边空，就要从偏移量为0的元素开始取； 右边空，就要取到列表的最后一个元素。
-
左右不空，左要取，右不取 。
冒号左边数字对应的元素要拿，右边的不动。
(4) 列表添加数据（append() ）
标准格式： 列表名.append(元素)
在列表末尾添加新的对象
python
list3 = [1,2]
list3.append(3)
print(list3)
#[1, 2, 3]
list3.append([4,5])
print(list3)
#[1, 2, 3, [4, 5]]
python
students = ['小明','小红','小刚']
students.append('小美')
print(students)
#['小明', '小红', '小刚', '小美'](5) 列表删除数据（del 列表[索引]）
标准格式： del 列表名[元素的索引]
python
students = ['小明', '小红', '小刚', '小美']
del students[1] #删除 索引为 1 的元素
print(students) # ['小明', '小刚', '小美']
del students[1:] #删除切片 0到1
print(students) # ['小明']
del students #删除 整个 列表
print(students) # 报错，列表不存在。NameError: name 'students' is not defined。(6) 列表脚本操作符（ + * ）
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
python
print([1, 2, 3] + [4, 5, 6] ) #[1, 2, 3, 4, 5, 6]
print(['Hello!'] * 4) #['Hello!', 'Hello!', 'Hello!', 'Hello!']
print(3 in [1, 2, 3]) # True(7) 列表函数（len 、 max、 min)
python
list4 = [4, 5, 6, 7, 8, 9]
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(len(list4)) # 列表长度， 6
print(max(list4)) # 列表最大值 9
print(min(list4)) # 列表最小值 4
list5 = list(tuple1) # 元组 转换为 列表
print(list5) # [1, 2, 3, 4, 5, 6, 7, 8, 9](8) 列表方法（extend、count、index、insert、pop、remove、reverse、sort、copy、clear）
python
list3 = [1, 2, 3]
list4 = [4, 5, 6, 7, 8, 9]
list3.extend(list4) # extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
print(list3) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list4.count(4)) # 1 统计某个元素 4 在列表中出现的次数.
print(list3.index(3)) # 2 从列表中找出某个值3 第一个匹配项的索引位置
list3.insert(10, 118) # 将指定对象101 插入列表的指定位置 第10位置 。
print(list3) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 118]
print(list.pop(list3)) # 118 移除列表中最后一个元素，并且返回该元素的值
print(list3) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list.pop(list3)) # 9 移除列表中最后一个元素，并且返回该元素的值
print(list3) # [1, 2, 3, 4, 5, 6, 7, 8]
list3.remove(3) # 移除列表中某个值 3 的第一个匹配项
print(list3) # [1, 2, 4, 5, 6, 7, 8]
list3.reverse() # 列表 反转 从最后一个元素开始，依次向前排列
print(list3) # [8, 7, 6, 5, 4, 2, 1]
list3.append(119) # 列表 末位 添加元素 119
print(list3) # [8, 7, 6, 5, 4, 2, 1, 119]
list3.sort() # 列表 从小到大 升序排序
//如果列表中的元素为字符串，则按照字母顺序排序；如果列表中的元素为数字，则按照大小顺序排序。
print(list3) # [1, 2, 4, 5, 6, 7, 8, 119]2 元组（Tuple）
元组 不同之处在于元组的元素不能修改。索引从0开始，可以进行截取，组合、读取、迭代、函数（len 、 max、 min) 都跟 列表相同。
(1) 与列表相同的读取、截取 切片、迭代、+ * 、函数
python
eggs = ('hello ', 42, 0.5)
print(eggs[0]) # hello
print(eggs[1:2]) # (42,) 一个元素 后面加 逗号
print(eggs[1:3]) # (42,0.5) 索引值可以超出范围
print(eggs[::1]) # ('hello ', 42, 0.5) ，每间隔1个元素，即 步长为1
print(eggs[::2]) # ('hello ', 0.5) 每间隔2个元素，即 步长为2 ，选择索引为偶数的元素
print(len(eggs)) # 3
for i in eggs:
print(i)
# hello
# 42
# 0.5
vegetables = ('carrot', 'cabbage', 'broccoli')
abc = eggs + vegetables # 合并
print(abc) # ('hello ', 42, 0.5, 'carrot', 'cabbage', 'broccoli')
efg = ('fish',)
hij = efg * 3
print(hij) # ('fish', 'fish', 'fish') (2) 区别
当只有一个元素时，元组 需要在元素后面添加逗号
python
tuple1 = ('hello',) # 当只有一个元素时，元组 需要在元素后面添加逗号
print(type(tuple1)) # <class 'tuple'> 数据类型为 元组
list001 = ['hello']
print(type(list001)) # <class 'list'> 数据类型为 列表 元组 因为不能修改，所以 可用的 方法较少
python
eggs = ('hello ', 42, 0.5)
print(len(eggs)) # 3 统计 元组 内 元素数量。
print(eggs.count('hello ')) # 1 统计 元素 出现次数
print(eggs.index(0.5)) # 2 获取 元素的 索引值
del eggs # 只能删除整个元组
print(eggs) # NameError: name 'eggs' is not defined, 元组 不存在
list002 = [1, 2, 3, 4, 5]
tuple002 = tuple(list002) # 强制 转换 ，将列表转换为 元组
print(tuple002) # (1, 2, 3, 4, 5)3 浅拷贝 、传递 引用
浅拷贝 浅拷贝是指创建一个新的数据结构，并且递归地复制原数据结构中第一层的数据，用来 复制列表或字典这样的 可变值，而不是 简单的 引用。
- 但对于第一层中如果是可变类型的元素（如列表、字典等），则只是复制它们的引用，而不是这些元素内部的数据。
- 因此，原数据结构和浅拷贝后的数据结构中的第一层数据是完全独立的，
- 但如果有 可变类型元素，则这些元素仍然共享同一份内存，修改其中一个的内部数据会影响到另一个。
python
list9 = list3.copy() # 创建并返回一个当前列表list3 的浅拷贝，
浅拷贝意味着list9中的元素与list3中的元素指向相同的内存地址。
print(list9) # [1, 2, 4, 5, 6, 7, 8, 119]
list3.clear() # 清空列表list3 中的所有元素，使其变为一个空列表，但不影响list9中的元素 内存地址。
print(list3) # []
print(list9) # [1, 2, 4, 5, 6, 7, 8, 119]
list10 = list9 # 将变量list9 赋值给新变量 list10， 指向list9的引用，意味着list9和list10指向同一个列表对象
print(list10) # [1, 2, 4, 5, 6, 7, 8, 119]
list9.clear() # 清空列表list9 中的所有元素，使其变为一个空列表。list10指向同一个列表对象，也被清空
print(list9) # []
print(list10) # [] 因为list9和list10指向同一个列表对象，list9被清空后，list10也相应地变为空列表如果 复制的列表里又包含了列表， 就使用 copy.deepcopy()函数来代替。
4 后记
列表与元组的主要区别：
可变性 ：列表是可变的，而元组是不可变的，这是两者最根本的区别。
性能 ：由于元组的不可变性，它在某些场景下比列表更高效。
应用场景：列表适用于需要频繁修改的数据集合，而元组适用于不需要修改的数据集合，如常量集合或作为字典的键。
如果 需要一个永远不会改变值的序列，就使用元组。
因为不变，所有 python 可实现一些优化，让 使用元组比 列表 运行速度快。
如果需要元组值的一个可变版本，可以将元组转换为 列表。
理解列表和元组的不同，并根据具体需求选择合适的数据结构，是Python编程中的一个重要方面。