python学习—列表和元组

系列文章目录

python学习—合并TXT文本文件
python学习—统计嵌套文件夹内的文件数量并建立索引表格
python学习—查找指定目录下的指定类型文件
python学习—年会不能停，游戏抽签抽奖
python学习—循环语句-控制流
python学习—合并多个Excel工作簿表格文件

---

---

功能说明

本文简单介绍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) 读取数据

列表中数据，叫 元素。

students = ['小明','小红','小刚'] 

print(students[0])       # 小明     索引为 0 的元素

for i in students:
    print(i+'在不在？')
    
# 小明在不在？
# 小红在不在？
# 小刚在不在？

(2) 包容性好

列表中的元素可以是不同类型的，如整数、字符串、甚至是其他列表。

list1 = ['小明',18,1.70,['小明','小红','小刚']]  

(3) 截取 切片

切片，一次从列表提取多个元素 ，切出来的 还是列表。
注意： 从 0 开始起排。

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]

students = ['小明','小红','小刚']
print(students[:2])                # ['小明', '小红']
print(students[2:])                #  ['小刚']
print(students[2])                 #  小刚  索引为2的元素 。

倒数的时刻，从 1 开始。

print(list2[-2])                   # 8   读取列表中倒数第二个元素
print(list2[8])                    # 报错 IndexError: list index out of range。 超出列表长度

总结规则：

• 左右空，取到头；
  冒号左边空，就要从偏移量为0的元素开始取； 右边空，就要取到列表的最后一个元素。

• 左右不空，左要取，右不取。
  冒号左边数字对应的元素要拿，右边的不动。

(4) 列表添加数据（append() ）

标准格式： 列表名.append(元素)
在列表末尾添加新的对象

list3 = [1,2]
list3.append(3)   
print(list3)    
 #[1, 2, 3]
 
list3.append([4,5])
print(list3) 
#[1, 2, 3, [4, 5]]

students = ['小明','小红','小刚']
students.append('小美')
print(students)    
#['小明', '小红', '小刚', '小美']

(5) 列表删除数据（del 列表[索引]）

标准格式： del 列表名[元素的索引]

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) 列表脚本操作符（ + * ）

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

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)

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）

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) 与列表相同的读取、截取 切片、迭代、+ * 、函数

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) 区别

当只有一个元素时，元组 需要在元素后面添加逗号

tuple1 = ('hello',)          # 当只有一个元素时，元组 需要在元素后面添加逗号
print(type(tuple1))          # <class 'tuple'>  数据类型为 元组
list001 = ['hello']
print(type(list001))         # <class 'list'>   数据类型为 列表 

元组 因为不能修改，所以 可用的 方法较少

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 浅拷贝 、传递 引用

浅拷贝 浅拷贝是指创建一个新的数据结构，并且递归地复制原数据结构中第一层的数据，用来 复制列表或字典这样的 可变值，而不是 简单的 引用。

• 但对于第一层中如果是可变类型的元素（如列表、字典等），则只是复制它们的引用，而不是这些元素内部的数据。
• 因此，原数据结构和浅拷贝后的数据结构中的第一层数据是完全独立的，
• 但如果有 可变类型元素，则这些元素仍然共享同一份内存，修改其中一个的内部数据会影响到另一个。

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编程中的一个重要方面。