Python基础教程：组合数据类型（序列、字符串、列表、元组）详解

本教程面向Python零基础学习者，详细讲解Python核心组合数据类型，重点覆盖序列、字符串、列表、元组的定义、特性、常用操作，结合具体示例一步步演示，全程手把手教学，确保新手能看懂、能跟着敲代码、能掌握核心用法。

先明确核心概念：Python中的组合数据类型，是指能同时存储多个数据的类型，其中序列是基础框架，字符串、列表、元组都属于序列类型，它们共享序列的核心特性，又有各自的独特用法。

一、核心基础：什么是序列？

序列是Python中最基础的组合数据类型，本质是“有序的、可通过索引访问的一组数据”，核心特性有3个，新手必须牢记：

• 有序性：序列中的每个元素都有固定的位置（索引），从0开始计数（和我们平时从1开始数不一样，重点注意）；

• 可索引：可以通过“序列名[索引值]”的方式，获取序列中指定位置的元素；

• 可切片：可以通过“序列名[起始索引:结束索引]”的方式，截取序列中的一部分元素（切片是序列最常用的操作之一）。

Python中，字符串、列表、元组 都属于序列类型，它们都具备以上3个特性，下面我们逐个详细讲解，结合示例落地操作。

二、序列延伸：变量名合法性判断（实战示例）

在学习组合数据类型之前，先补充一个基础实战场景：判断一个变量名是否符合Python命名规则。这是新手常踩的坑，结合序列的“字符判断”用法，我们写一段完整代码，一步一步讲解逻辑。

2.1 Python变量命名规则

一个合法的Python变量名，必须同时满足以下4个条件，缺一不可：

1. 变量名只能由 字母（a-z、A-Z）、数字（0-9）、下划线（_） 组成；

2. 变量名 不能以数字开头（比如123name是非法的，name123是合法的）；

3. 变量名 不能是Python关键字（比如if、for、while、print这些系统自带的关键字，不能当变量名）；

4. 变量名 区分大小写（比如Name和name是两个不同的变量）。

2.2 实战代码：判断变量名是否合法

我们写一段代码，实现“输入一个变量名，自动判断是否合法”，结合序列的字符判断、关键字判断，逐行讲解逻辑（新手可以跟着敲，每一行都有注释，看不懂的地方对照注释理解）：

# 1. 导入Python关键字模块（用于判断变量名是否是关键字）import keyword# 2. 定义一个函数，专门判断变量名是否合法def is_valid_variable(var_name):# 条件1：判断是否是Python关键字，若是则非法if keyword.iskeyword(var_name):return False, "变量名是Python关键字，非法！"# 条件2：判断变量名是否为空（空字符串不能作为变量名）if not var_name:return False, "变量名不能为空，非法！"# 条件3：判断第一个字符是否是字母或下划线（不能是数字）if not (var_name[0].isalpha() or var_name[0] == '_'):return False, "变量名必须以字母或下划线开头，非法！"# 条件4：判断后续所有字符（从第2个开始）是否是字母、数字或下划线for char in var_name[1:]:if not (char.isalnum() or char == '_'):return False, f"变量名包含非法字符'{char}'，非法！"# 所有条件都满足，返回合法return True, "变量名合法！"# 3. 测试示例（新手可以修改var_name的值，测试不同情况）var_name1 = "student_name"# 合法示例var_name2 = "123student"# 非法（以数字开头）var_name3 = "student@123"# 非法（包含@）var_name4 = "for"# 非法（是Python关键字）var_name5 = "_score"# 合法示例# 4. 调用函数，打印结果print(is_valid_variable(var_name1))  # 输出：(True, '变量名合法！')print(is_valid_variable(var_name2))  # 输出：(False, '变量名必须以字母或下划线开头，非法！')print(is_valid_variable(var_name3))  # 输出：(False, "变量名包含非法字符'@'，非法！")print(is_valid_variable(var_name4))  # 输出：(False, '变量名是Python关键字，非法！')print(is_valid_variable(var_name5))  # 输出：(True, '变量名合法！')

软件运行结果如下

2.3 代码核心讲解

• keyword.iskeyword(var_name)：判断变量名是否是Python关键字，比如for、if、else等，这些关键字是系统预留的，不能当变量名；

• var_name[0]：获取变量名的第一个字符（序列的索引特性，索引从0开始）；

• isalpha()：判断字符是否是字母（a-z、A-Z）；

• isalnum()：判断字符是否是字母或数字；

• var_name[1:]：切片操作，获取变量名从第2个字符开始到末尾的所有字符（序列的切片特性）。

新手可以多修改var_name的值，测试不同的非法情况，彻底掌握变量命名规则和序列的基础操作。

三、序列详解1：列表（List）—— 可变序列（重点）

列表是Python中最常用、最灵活的组合数据类型，属于可变序列（可以修改、添加、删除列表中的元素），常用于存储多个同类或不同类的数据，用方括号 [] 表示，元素之间用逗号分隔。

3.1 基础操作：创建列表（必学）

创建列表有两种常用方式，我们结合“100以内的自然数”这个需求，演示创建方法：

# 方式1：直接用[]创建（适合元素较少的情况）list1 = [1, 2, 3, 4, 5]  # 创建一个包含5个自然数的列表# 方式2：用range()函数创建（适合创建连续的数字列表，重点！）# range(1, 100)：生成1~99的连续自然数（左闭右开，不包含100）# list()：将range对象转换为列表list_natural = list(range(1, 100))  # 核心：创建100以内（1~99）的自然数列表# 打印列表，查看结果（新手可以运行代码，观察输出）print("100以内的自然数列表：", list_natural)print("列表的长度（元素个数）：", len(list_natural))  # len()：获取列表长度，输出99

重点讲解：range(1, 100) 生成的是1到99的连续整数（左闭右开，即包含1，不包含100），list() 函数可以将这个“连续数字序列”转换为列表，这是创建连续数字列表最简洁的方式，新手必须掌握。

3.2 实战操作1：删除列表中后50个元素

我们基于上面创建的 list_natural（1~99的自然数列表），删除后50个元素，核心用到列表的切片删除操作，分步讲解：

# 1. 先确认原始列表的长度和最后几个元素print("原始列表长度：", len(list_natural))  # 输出99print("原始列表最后5个元素：", list_natural[-5:])  # 切片获取最后5个元素，方便对比# 2. 删除列表中后50个元素（核心操作）# 思路：保留前 99 - 50 = 49 个元素，删除后面的50个# 切片语法：列表名[起始索引:结束索引]，只保留切片范围内的元素list_natural = list_natural[:49]  # 保留前49个元素（索引0~48），相当于删除后50个# 3. 验证删除结果print("删除后列表长度：", len(list_natural))  # 输出49（99-50=49，正确）print("删除后列表最后5个元素：", list_natural[-5:])  # 查看最后5个元素，确认删除成功

3.3 实战操作2：添加合并列表

删除后，我们再创建一个新列表，将其合并到 list_natural 中，常用两种合并方式，都演示一遍，新手可以根据需求选择：

# 1. 创建一个要合并的新列表（示例：100~105的整数）new_list = [100, 101, 102, 103, 104, 105]# 方式1：用extend()方法合并（推荐，不会产生新列表，直接在原列表末尾添加）list_natural.extend(new_list)print("extend()合并后：", list_natural)print("合并后长度：", len(list_natural))  # 49 + 6 = 55，正确# 方式2：用+号合并（会产生一个新列表，原列表不变）# 先还原list_natural（重新保留前49个元素）list_natural = list(range(1, 100))[:49]# 用+号合并merged_list = list_natural + new_listprint("+号合并后新列表：", merged_list)print("原列表（list_natural）：", list_natural)  # 原列表不变，还是49个元素

3.4 列表其他常用操作（基础必备）

除了上面的创建、删除、合并，列表还有几个基础操作，新手也要掌握，结合示例：

# 1. 向列表末尾添加单个元素（append()）list_natural.append(106)print("添加单个元素后：", list_natural[-3:])  # 查看最后3个元素，确认添加成功# 2. 向列表指定位置插入元素（insert(索引, 元素)）# 在索引1的位置插入元素0list_natural.insert(1, 0)print("插入元素后：", list_natural[:3])  # 查看前3个元素，确认插入成功# 3. 删除列表中指定元素（remove(元素值)）list_natural.remove(0)  # 删除元素0print("删除指定元素后：", list_natural[:3])  # 确认删除成功# 4. 清空列表（clear()）# list_natural.clear()  # 清空列表，注释掉，避免影响后续操作

四、序列详解2：元组（Tuple）—— 不可变序列（重点）

元组和列表类似，也是序列类型，用于存储多个数据，但它是不可变序列（一旦创建，就不能修改、添加、删除元素），用圆括号 () 表示，元素之间用逗号分隔。

核心区别：列表可变（能改），元组不可变（不能改）；元组的创建速度比列表快，适合存储不需要修改的数据（比如固定的配置、常量等）。

4.1 基础操作：创建元组（必学）

创建元组有3种常用方式，结合示例讲解，重点注意“单元素元组”的创建细节（新手常踩坑）：

# 方式1：直接用()创建（最常用）tuple1 = (10, 20, 30, 40, 50)  # 创建一个包含5个整数的元组print("元组1：", tuple1)print("元组1的长度：", len(tuple1))  # 输出5# 方式2：不写括号（省略括号，Python默认是元组）tuple2 = 100, 200, 300, 400print("元组2（省略括号）：", tuple2)print("元组2的类型：", type(tuple2))  # type()：查看类型，输出tuple（元组）# 方式3：创建单元素元组（重点！必须加逗号，否则不是元组）tuple3 = (60)  # 没有逗号，Python会认为是整数60，不是元组tuple4 = (60,) # 加了逗号，才是单元素元组print("tuple3的类型：", type(tuple3))  # 输出int（整数）print("tuple4的类型：", type(tuple4))  # 输出tuple（元组）print("单元素元组：", tuple4)

重点提醒：创建只有一个元素的元组时，必须在元素后面加逗号 ,，否则Python会将其识别为对应的基本数据类型（比如整数、字符串），而不是元组。

4.2 实战示例：元组的常用操作（结合序列特性）

元组不可变，所以不能修改、添加、删除元素，但可以使用序列的核心操作（索引、切片、遍历），结合示例演示：

# 1. 索引访问：获取元组中指定位置的元素（索引从0开始）tuple1 = (10, 20, 30, 40, 50)print("元组索引0的元素：", tuple1[0])  # 输出10print("元组索引3的元素：", tuple1[3])  # 输出40print("元组最后一个元素：", tuple1[-1])  # 负数索引，从末尾开始，输出50# 2. 切片操作：截取元组中的一部分元素print("元组前3个元素：", tuple1[:3])  # 截取索引0~2，输出(10, 20, 30)print("元组中间2个元素：", tuple1[1:3])  # 截取索引1~2，输出(20, 30)print("元组后2个元素：", tuple1[-2:])  # 截取最后2个元素，输出(40, 50)# 3. 遍历元组：逐个打印元组中的元素（常用for循环）print("遍历元组，逐个输出元素：")for num in tuple1:print(num, end=" ")  # 输出：10 20 30 40 50# 4. 元组拼接（用+号，会产生新元组，原元组不变）tuple2 = (60, 70, 80)new_tuple = tuple1 + tuple2print("\n拼接后的元组：", new_tuple)  # 输出(10,20,30,40,50,60,70,80)# 5. 元组重复（用*号，重复指定次数）tuple3 = (1, 2)repeat_tuple = tuple3 * 3print("重复3次后的元组：", repeat_tuple)  # 输出(1,2,1,2,1,2)

4.3 元组不可变的注意事项

元组的“不可变”是指“元组中的元素本身不能修改、不能添加、不能删除”，但有一个特殊情况：如果元组中的元素是可变类型（比如列表），那么这个可变元素内部是可以修改的，示例：

# 元组中包含列表（可变元素）tuple_with_list = (10, 20, [30, 40, 50], 60)print("原始元组：", tuple_with_list)# 错误：直接修改元组中的元素（不可变，报错）# tuple_with_list[0] = 100  # 运行会报错，注释掉# 正确：修改元组中的列表（可变元素）内部的值tuple_with_list[2][0] = 300# 修改列表的第一个元素（索引2是列表，索引0是列表中的元素）print("修改列表后的元组：", tuple_with_list)  # 输出(10, 20, [300, 40, 50], 60)

重点：元组的不可变，是“元素的引用不可变”，如果元素本身是可变类型，其内部内容可以修改，新手不用过度纠结，先记住“元组不能直接修改元素”即可。

五、序列延伸：字符串（String）—— 不可变序列

字符串也是序列类型，属于不可变序列（不能修改字符串中的单个字符），用于存储文本数据，用单引号 ''、双引号"" 或三引号 ''' ''' 表示，这里补充基础操作，和列表、元组的序列操作保持一致，方便新手关联记忆：

# 1. 创建字符串str1 = "Hello Python"# 双引号创建str2 = 'Python基础教程'# 单引号创建str3 = '''我是多行字符串可以换行适合长文本'''# 三引号创建，支持多行# 2. 索引访问print("str1索引0的字符：", str1[0])  # 输出Hprint("str1最后一个字符：", str1[-1])  # 输出n# 3. 切片操作print("str1前5个字符：", str1[:5])  # 输出Helloprint("str1从第6个字符开始：", str1[6:])  # 输出Python# 4. 遍历字符串print("遍历str2：", end=" ")for char in str2:print(char, end=" ")  # 输出：Python基础教程# 注意：字符串不可变，不能直接修改单个字符（报错）# str1[0] = 'h'  # 运行报错，注释掉

六、总结：组合数据类型核心对比

我们用表格总结字符串、列表、元组的核心区别，方便新手对比记忆，快速区分用法：

七、课后练习

结合本教程内容，完成以下练习，巩固知识点（答案在末尾，先自己尝试写代码）：

1. 判断以下变量名是否合法：123abc、abc_123、if_else、abc@123；

2. 创建一个包含1_{50的自然数列表，删除后20个元素，再合并一个包含51}60的列表；

3. 创建一个元组，包含你的姓名、年龄、性别，通过索引获取你的年龄；

4. 尝试修改元组中的元素，观察是否报错，理解元组的不可变性。

练习答案提示

# 1. 变量名判断import keywordvars = ["123abc", "abc_123", "if_else", "abc@123"]for var in vars:print(var, is_valid_variable(var))  # 调用之前写的判断函数# 2. 列表操作list1 = list(range(1, 51))list1 = list1[:30]  # 删除后20个元素list2 = list(range(51, 61))list1.extend(list2)print(list1)# 3. 元组操作my_tuple = ("张三", 20, "男")print("年龄：", my_tuple[1])# 4. 元组修改（报错）# my_tuple[1] = 21  # 运行报错，元组不可变

新手建议：先自己敲代码，遇到报错不要慌，对照教程排查问题，多练习几遍，就能彻底掌握组合数据类型的核心用法。后续我们会讲解字典、集合，进一步完善Python组合数据类型的知识体系。

The End・💛

点点在看，万事美满，随手点赞，岁岁平安～💛