简介：本资源为Python基础入门系列教程的第2章配套课件，面向零基础或刚接触编程、希望系统掌握Python数据结构的自学者与在校学生。课件围绕Python序列展开，从列表、元组、字符串到字典、集合与range，逐一讲解其定义、双向索引机制及常用方法，并重点剖析列表的创建、增删改查、排序、浅拷贝等操作，辅以range()与xrange()的效率对比，帮助读者建立对序列类型的整体认知。资源包内含1个PPT文件，压缩后约583KB，以图文与代码示例结合的形式呈现，共68页，内容由浅入深、条理清晰，便于课堂讲解或自学翻阅。目前已有206人学习下载，适合作为Python入门阶段夯实数据结构基础的参考课件。

1. 从一份 68 页的 PPT 说起：Python 序列到底该按什么顺序啃

很多人学 Python 卡在序列这一章，不是因为概念难，而是因为资料把列表、元组、字符串、字典、集合、range 全堆在一起讲，学完脑子里只剩一堆方法名。我手上这份《Python基础入门教程 第2章 Python序列》共 68 页，属于一套九章的基础课件，从第 1 章基础知识一路铺到第 9 章 GUI 编程，序列这章正好卡在语法入门和函数设计之间，位置很关键。它把列表作为主线，先讲创建与删除，再讲元素增加，最后落到内存模型和性能对比，这个编排顺序其实比很多教材都合理。如果你正在带新人、准备面试八股，或者想给团队做一次内部基础培训，这份 PPT 的骨架可以直接拿来用。它适合两类人：一类是刚学完变量和运算符、需要把序列一次性理清的新手；另一类是有其他语言基础、想快速摸清 Python 序列底层行为的熟手。下面我按自己拆课件的习惯，把这份 68 页的内容重新排一遍，重点讲清楚每个操作背后的代价，以及哪些地方最容易翻车。

2. 列表创建与删除：list()、range()和del的真实边界

2.1 直接赋值与list()转换的适用场景

列表创建看起来简单，但选错方式会在后续代码里埋下类型不一致的隐患。PPT 里给了两种路径：直接用中括号赋值，以及用list()把其他可迭代对象转成列表。我一般会按数据来源来选——如果元素是写死的配置项，直接赋值；如果数据来自元组、range 或字符串，用list()转换更干净。

# 直接赋值：适合固定配置、初始化已知元素 a_list = ['a', 'b', 'mpilgrim', 'z', 'example'] empty_list = [] # 空列表，后续 append 填充 # list() 转换：适合把其他可迭代对象统一成列表 from_tuple = list((3, 5, 7, 9, 11)) # 元组转列表 from_range = list(range(1, 10, 2)) # range 转列表，得到 [1,3,5,7,9] from_str = list('hello world') # 字符串转列表，每个字符一个元素 x = list() # 显式创建空列表，等价于 []

逻辑说明：list()接收任意可迭代对象，内部会遍历并逐个取出元素放入新列表。参数方面，list()不传参返回空列表，传参时只接受一个可迭代对象，传多个会直接报TypeError。这里有个细节：list('hello world')会把空格也当成一个字符元素，如果你想要按单词切分，应该用split()而不是list()。

2.2range()的三参数与 Python 2/3 的返回值差异

range()是序列这章出现频率最高的内置函数，PPT 专门用了一页讲它的语法和版本差异。它的完整签名是range([start,] stop[, step])，起始值默认 0，终止值不包含在结果里，步长默认 1。这个“左闭右开”的设定在写循环和切片时反复出现，必须形成肌肉记忆。

# range 三种典型用法 list(range(5)) # [0, 1, 2, 3, 4]，只给终止值 list(range(2, 8)) # [2, 3, 4, 5, 6, 7]，给起始和终止 list(range(1, 10, 2)) # [1, 3, 5, 7, 9]，给起始、终止和步长 # 步长为负：反向生成 list(range(10, 0, -2)) # [10, 8, 6, 4, 2]

参数说明：start和step都可以省略，但stop必须给。步长不能为 0，否则抛ValueError。PPT 里特别强调，Python 3.x 的range()返回的是 range 可迭代对象，不是列表，所以直接打印看到的是range(0, 5)而不是[0,1,2,3,4]；Python 2.x 的range()直接返回列表，数据量大时会一次性吃掉大量内存。这也是为什么 PPT 建议在 Python 2.x 里处理大范围循环时改用xrange()，它惰性求值，内存占用恒定。如果你现在维护的是 Python 3 代码，这条建议可以忽略，但面试里经常被问到，知道来龙去脉没坏处。

2.3del删除列表对象后到底发生了什么

PPT 用一段报错演示了del的效果：删除a_list之后再访问，解释器抛NameError。这里要区分两个层面——del删除的是变量名到对象的引用，不是直接擦除内存数据。如果同一个列表对象还有其他变量指向它，那个变量仍然能正常访问。

a_list = [1, 2, 3] b_list = a_list # b_list 和 a_list 指向同一个列表对象 del a_list # 只删除 a_list 这个引用 print(b_list) # [1, 2, 3]，对象还在，因为 b_list 还指着它 # print(a_list) # 这行会抛 NameError

逻辑说明：Python 的内存管理基于引用计数，del让引用计数减一，减到零时对象才被回收。所以删除列表后如果发现内存没降，先检查是不是还有别的变量在引用它。这个点在调试内存泄漏时很实用，PPT 虽然没有展开讲引用计数，但通过id()的对比已经暗示了这层机制。

3. 元素增加的五种方式：从+到append的性能分水岭

3.1+运算符与append()的本质区别

PPT 里用一段 10000 次循环的计时对比，把+和append()的速度差距摆了出来——append()比+快约 70 倍。这个数字不是玄学，根源在于+每次都会创建一个新列表，把原列表和新元素全部复制过去；而append()是原地操作，只在列表尾部追加一个元素，不涉及整体复制。

import time # 方式一：用 + 拼接，每次生成新列表 result = [] start = time.time() for i in range(10000): result = result + [i] print(len(result), time.time() - start) # 方式二：用 append，原地追加 result = [] start = time.time() for i in range(10000): result.append(i) print(len(result), time.time() - start)

逻辑说明：+运算符两侧必须是列表，它返回一个全新列表对象，原列表不变。append(x)把x当作一个整体追加到尾部，如果x本身是列表，它会作为一个嵌套元素存在，而不是展开。参数方面，append()只接受一个参数，多传会报TypeError。我一般会在循环里优先用append()，只有在需要保留原列表不变、且数据量很小时才用+。

3.2extend()与insert()的原地操作和位置代价

extend()和insert()都是原地修改列表，不改变列表对象的内存首地址。PPT 用id()的前后对比证明了这一点。extend()接收一个可迭代对象，把其中所有元素逐个追加到尾部；insert(index, x)在指定位置插入元素，但插入点之后的所有元素都要向后移动一位。

a = [1, 2, 3] print(id(a)) # 记录初始内存地址 a.extend([4, 5]) # 追加多个元素 print(a, id(a)) # [1, 2, 3, 4, 5]，地址不变 a.extend((6, 7)) # 也可以接收元组 print(a, id(a)) # [1, 2, 3, 4, 5, 6, 7]，地址不变 a.insert(0, 0) # 在头部插入，后续元素全部后移 print(a, id(a)) # [0, 1, 2, 3, 4, 5, 6, 7]，地址不变

参数说明：extend()只接受一个可迭代对象，传整数会报TypeError；insert()接受两个参数，第一个是索引，第二个是元素，索引超出范围时不会报错，而是追加到头部或尾部。PPT 明确建议尽量从尾部增删元素，因为insert()在头部插入时，后面所有元素都要移动，数据量越大越慢。我见过有人在循环里反复insert(0, x)来构建列表，数据量上万后直接卡死，换成append()再reverse()就能解决。

3.3 乘法扩展列表的引用陷阱

用*运算符可以把列表重复若干次生成新列表，但 PPT 用一段嵌套列表的代码揭示了一个经典陷阱：当列表中包含可变对象时，乘法复制的是引用，不是独立副本。

# 陷阱演示：嵌套列表的乘法 x = [[None] * 2] * 3 print(x) # [[None, None], [None, None], [None, None]] x[0][0] = 5 print(x) # [[5, None], [5, None], [5, None]]，三个子列表全变了 # 正确做法：用列表推导式创建独立子列表 y = [[None] * 2 for _ in range(3)] y[0][0] = 5 print(y) # [[5, None], [None, None], [None, None]]

逻辑说明：[[None] * 2] * 3先创建一个子列表[None, None]，然后把这个子列表的引用复制三份。三个位置指向的是同一个对象，改一个自然全变。列表推导式每次循环都新建一个子列表，所以互不影响。这个坑在初始化二维数组、矩阵、游戏棋盘时特别常见，PPT 把它放在元素增加这一节，说明编者确实踩过。

4. 内存模型与性能排查：id()对比和常见翻车现场

4.1 可变序列的引用语义与id()验证方法

PPT 用多组id()对比展示了列表的引用语义：变量本身不直接存储元素值，而是存储元素的引用。修改元素值时，列表对象的内存首地址不变，变的是被修改元素的地址。这个机制解释了为什么a = [1,2,3]和b = [1,2,3]的id(a) != id(b)，但id(a[0]) == id(b[0])——小整数在 Python 里有缓存机制，两个列表的第一个元素指向同一个整数对象。

a = [1, 2, 4] b = [1, 2, 3] print(a == b) # False，值不同 print(id(a) == id(b)) # False，不同对象 print(id(a[0]) == id(b[0])) # True，小整数缓存 a = [1, 2, 3] print(id(a)) # 记录地址 a.append(4) print(id(a)) # 地址不变 a.remove(3) print(id(a)) # 地址不变 a[0] = 5 print(id(a)) # 地址不变

逻辑说明：id()返回对象在内存中的唯一标识，可以理解为地址。判断两个变量是否指向同一个对象，用is比==更准确。PPT 里反复用id()做对比，目的是让读者建立“变量是引用，不是容器”的认知。这个认知在函数传参时尤其重要——把列表传给函数，函数内部修改会影响外部，因为传的是引用。

4.2 头部插入与尾部追加的耗时对比

PPT 给了一段insert(0, i)和append(i)各执行 10000 次的计时对比，结果insert耗时约 0.578 秒，append约 0.031 秒，差距接近 19 倍。这个差距随着数据量增大会进一步拉大，因为insert(0, x)每次都要把现有元素全部后移一位。

import time def insert_head(): a = [] for i in range(10000): a.insert(0, i) # 每次头部插入，全员后移 def append_tail(): a = [] for i in range(10000): a.append(i) # 尾部追加，无移动 start = time.time() insert_head() print('insert head:', time.time() - start) start = time.time() append_tail() print('append tail:', time.time() - start)

逻辑说明：列表底层是动态数组，尾部追加均摊复杂度是 O(1)，头部插入是 O(n)。如果业务上确实需要频繁在头部操作，常见做法是改用collections.deque，它支持两端 O(1) 插入删除。PPT 没有提 deque，但这是实际工程里最直接的替代方案。我一般会在代码审查时特别留意循环里的insert(0, ...)和pop(0)，这两个是性能问题的常客。

4.3 避坑与排查：序列操作里最容易翻车的五件事

现象一：循环里用+拼接列表，数据量上万后程序卡住。原因：+每次创建新列表并复制全部元素，时间复杂度 O(n²)。解决：改用append()或先收集到列表再用extend()合并。

现象二：用[[0] * 3] * 3初始化二维数组，改一个元素其他行跟着变。原因：乘法复制的是子列表引用，三行指向同一个对象。解决：用[[0] * 3 for _ in range(3)]列表推导式创建独立子列表。

现象三：del删除列表后内存没释放。原因：还有其他变量引用同一个列表对象，引用计数未归零。解决：用id()或sys.getrefcount()检查引用来源，把所有引用都删掉。

现象四：append()传入列表后得到嵌套结构，不是想要的多元素追加。原因：append()把参数当整体追加，不展开。解决：需要展开时用extend()，或者用a += [x, y]。

现象五：insert()索引越界没有报错，元素跑到了奇怪的位置。原因：insert()对越界索引做了容错处理，负数索引和超大索引会被截断到头部或尾部。解决：插入前先用len()检查索引范围，或者明确使用append()表达尾部追加意图。

5. 把序列知识落到实战：三个验证技巧和我的固定习惯

学完列表的增删改查和内存模型，下一步是怎么验证自己真的掌握了。我一般会用三个小练习来检验：第一，写一个函数，接收任意可迭代对象，返回去重后的列表，要求保持原顺序；第二，用time模块对比+和append在 10 万次循环下的耗时差距；第三，故意用[[None] * 2] * 3制造引用陷阱，再用列表推导式修复，观察id()的变化。

# 练习一：保序去重 def dedup(iterable): seen = set() result = [] for item in iterable: if item not in seen: seen.add(item) result.append(item) return result print(dedup([3, 1, 2, 3, 1, 4])) # [3, 1, 2, 4] # 练习二：性能对比 import time def concat_way(n): result = [] for i in range(n): result = result + [i] return result def append_way(n): result = [] for i in range(n): result.append(i) return result for n in [1000, 5000, 10000]: t1 = time.time(); concat_way(n); d1 = time.time() - t1 t2 = time.time(); append_way(n); d2 = time.time() - t2 print(f'n={n}, +: {d1:.4f}s, append: {d2:.4f}s, ratio: {d1/d2:.1f}x')

参数说明：dedup用set做存在性判断，把查找复杂度从 O(n) 降到 O(1)，整体保持 O(n)。concat_way和append_way的对比可以直观看到差距随 n 增大而拉大。跑完这三个练习，基本就能把 PPT 里列表部分的核心知识点串起来。

这份 68 页的 PPT 在序列这章还有一个值得注意的地方：它把列表放在最前面，用最大篇幅讲透，然后才带出元组、字符串、字典、集合和 range。这个顺序符合认知规律——列表是可变序列的代表，理解了列表的引用语义和原地操作，再去看元组的不可变性、字符串的不可变性，就很容易理解为什么元组没有append、字符串没有insert。如果你手上有这套九章课件，建议按第 1 章基础知识、第 2 章序列、第 3 章选择与循环的顺序推进，序列这章至少留出两个晚上，把每个方法的参数和边界都亲手敲一遍。从那以后我每次初始化二维结构，都会条件反射地检查是不是用了列表推导式，而不是乘法——这个习惯帮我省掉了至少三次深夜排查的麻烦。希望帮到你。

本文还有配套的精品资源，点击获取