Python序列大揭秘：字符串、列表、元组的奇妙世界

欢迎来到Python序列的奇幻之旅！如果你曾觉得编程枯燥，那么今天我要告诉你：Python序列就像是一盒五彩斑斓的乐高积木，让你用简单的模块构建出无限可能。无论是处理文本、管理数据，还是玩转算法，序列都是你的得力助手。准备好笑一笑，学一学了吗？让我们开始吧！

一、序列家族三兄弟：字符串、列表、元组

在Python中，序列是一种可迭代的、元素有序的容器。主要有三位成员：

字符串（str）：不可变的字符序列，比如 "hello"。它像石刻的文字，一旦创建就不能修改，但可以复制或拼接。
列表（list）：可变的元素序列，比如 [1, 2, 3]。它像白板上的便签，随时可以擦写、添加或删除。
元组（tuple）：不可变的元素序列，比如 (1, 2, 3)。它像已签订的合同，内容固定，但可读性强。

它们都支持索引、切片和迭代，但可变性不同：列表是“善变”的，而字符串和元组是“专一”的。下面我们来探索它们的魔法操作！

二、可变和不可变序列的基本运算

1. 增量赋值：`*=`, `+=` 等

增量赋值是序列的“健身计划”：可变序列原地锻炼，不可变序列换身新衣服。

# 可变序列：列表，id()不变，就像同一个人增重了
lst = [1, 2, 3]
print(id(lst))  # 输出类似 140245678
lst *= 2
print(lst)      # [1, 2, 3, 1, 2, 3]
print(id(lst))  # 与之前相同，id不变

# 不可变序列：字符串，id()变化，就像换了个人
s = "hello"
print(id(s))    # 输出类似 140245790
s *= 2
print(s)        # "hellohello"
print(id(s))    # 新的id，因为字符串不可变，创建了新对象

幽默一下：列表像贪吃蛇，吃多了还是那条蛇；字符串像复制粘贴，每次都生成新文档。

2. `is` 和 `not is`：判断是否是同一个对象

is 检查身份，就像问“你是不是你？”；而 == 检查值是否相等，就像问“你们长得像吗？”

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # True，值相等
print(a is b)  # False，不是同一个对象（id不同）

c = a
print(a is c)  # True，c是a的别名，同一个对象

3. `in` 和 `not in`：判断包含关系

检查元素是否在序列中，就像在派对里找朋友。

lst = [1, 2, 3, 5]
print(2 in lst)      # True
print(4 not in lst)  # True

s = "python"
print('p' in s)      # True
print('z' not in s)  # True

4. `del`：删除操作

del 是序列的“橡皮擦”，可以擦除整个对象或部分元素。

x = [1, 2, 3, 5]
del x[2]          # 删除索引2的元素，x变成[1, 2, 5]
del x[1:3]        # 删除切片，x变成[1]（如果x足够长）
del x[::2]        # 删除步长为2的元素，谨慎使用，可能打乱序列

# 清空列表
x.clear()         # 等价于 del x[:]，x变成[]
# 删除整个对象
del x             # x不复存在，再访问会报NameError

提示：clear() 是列表的方法，而 del 是通用语句，更灵活。

三、序列相关函数：你的瑞士军刀

Python提供了一系列内置函数，让序列操作变得轻松有趣。

1. 转换函数：`list()`, `tuple()`, `str()`

这些函数像“变形金刚”，让序列之间互相转换。

s = "123"
lst = list(s)      # ['1', '2', '3']
tup = tuple(lst)   # ('1', '2', '3')
back_to_str = str(lst)  # "['1', '2', '3']"，注意这是字符串表示

2. `min()` 和 `max()`：找最小和最大

可以传递可迭代对象或直接参数，还能设置默认值避免空序列报错。

x = [1, 2, 3]
print(max(x))                  # 3
print(min(x))                  # 1
print(max(1, 2, 3))           # 3，直接传参数
print(max([], default="无事发生"))  # "无事发生"，空序列时返回默认值

3. `len()`：获取长度

返回序列中元素的数量，但注意长度受内存限制（理论上最大是 sys.maxsize）。

s = "hello"
print(len(s))  # 5
lst = [1, 2, 3, 4, 5]
print(len(lst))  # 5

4. `sum()`：求和

对可迭代对象求和，可指定起始值。

numbers = [1, 2, 3]
print(sum(numbers))        # 6
print(sum(numbers, 10))    # 16，相当于 10 + 1 + 2 + 3

5. `sorted()` 和 `reversed()`：排序和反转

sorted() 返回全新的排序列表，原序列不变。它像给序列“美颜排序”。
reversed() 返回一个反向迭代器，节省内存。

lst = [5, 2, 8, 1]
sorted_lst = sorted(lst)          # [1, 2, 5, 8]，默认升序
print(lst)                        # [5, 2, 8, 1]，原序列不变

# 使用key参数按长度排序
words = ["apple", "pie", "banana"]
print(sorted(words, key=len))     # ['pie', 'apple', 'banana']

# reversed() 示例
rev_iter = reversed([1, 2, 5, 8, 0])
print(list(rev_iter))             # [0, 8, 5, 2, 1]

6. `all()` 和 `any()`：逻辑判断

all() 检查是否所有元素为真（非零、非空、非False）。
any() 检查是否存在真元素。

print(all([1, 2, 3]))      # True
print(all([1, 0, 3]))      # False
print(any([0, False, 5]))  # True
print(any([]))             # False，空序列为False

7. `zip()`：并行迭代

将多个可迭代对象“拉链”在一起，生成元组对。如果长度不同，以最短的为准。

x = [1, 2]
y = [2, 3]
z = "good"
print(list(zip(x, y)))        # [(1, 2), (2, 3)]
print(list(zip(x, y, z)))     # [(1, 2, 'g'), (2, 3, 'o')]，只取前两个字符

8. `map()`：映射函数

对可迭代对象的每个元素应用函数，返回映射结果。它像“流水线加工”。

# 计算幂次：pow(x, y) 返回 x^y
print(list(map(pow, [1, 2], [10, 10])))  # [1, 1024]，即 1^10 和 2^10

9. `filter()`：过滤元素

根据函数条件过滤可迭代对象，返回真值元素。它像“筛子”。

# 筛选大写字母
print(list(filter(str.isupper, "Python")))  # ['P']

四、迭代器和可迭代对象：一次性与可重复之旅

在Python中，可迭代对象（如列表、字符串）可以被迭代，而迭代器是实际执行迭代的工具。

可迭代对象：实现了 __iter__() 方法，可以反复迭代（如多次使用 for 循环）。
迭代器：实现了 __iter__() 和 __next__() 方法，是“一次性用品”，迭代完后耗尽。

关键点：迭代器一定是可迭代对象，但可迭代对象不一定是迭代器。

# 可迭代对象：列表
lst = [1, 2, 3]
for item in lst:
    print(item)  # 可以反复迭代

# 获取迭代器
iter_obj = iter(lst)  # 或 lst.__iter__()
print(next(iter_obj))  # 1
print(next(iter_obj))  # 2
print(next(iter_obj))  # 3
# print(next(iter_obj))  # 抛出 StopIteration 异常，迭代器耗尽

# 对比：可迭代对象 vs 迭代器
s = "hello"
iter_s = iter(s)
print(list(iter_s))  # ['h', 'e', 'l', 'l', 'o']
print(list(iter_s))  # []，迭代器已耗尽，而 s 本身仍可迭代