【Python基础】| 高级特性

目录

• 高级特性
  • 切片
    • 知识点
    • 常见误区
    • 练习
  • 迭代
    • 知识点
    • 练习
  • 列表生成式
    • 知识点
    • if 的两种位置
    • 练习
    • 小结
  • 生成器
    • 知识点
    • 生成器函数
    • yield 的执行过程
    • 获取生成器的返回值
    • 生成器的几个重要特点
    • 练习
  • 迭代器
    • 知识点
    • for 循环的本质
    • Iterable 和 Iterator 的区别
    • 小结
  • 本章综合小结
  • 练习题
    • 基础题
    • 列表生成式练习
    • 生成器和迭代器练习
    • 综合题
  • 小项目练手
    • 项目：文本日志分析器
    • 基础要求
    • 推荐代码骨架
    • 进阶要求
    • 项目复盘

高级特性

本章的核心是：用更简洁的语法处理序列、集合和数据流。

主要内容：

• 切片：快速截取序列的一部分
• 迭代：统一遍历各种可迭代对象
• 列表生成式：用一行代码生成新列表
• 生成器：按需计算，节省内存
• 迭代器：理解 for 循环背后的机制

切片

知识点

切片用于从序列中取出一部分元素，常见对象包括 list、tuple 和 str。

基本语法：

sequence[start:stop:step]

含义：

• start：起始下标，包含该位置
• stop：结束下标，不包含该位置
• step：步长，默认是 1

例如先准备一个列表：

L = list(range(100))

取出前 10 个数：

L[:10]
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

取出后 10 个数：

L[-10:]
# [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

取出第 11 到第 20 个数。注意下标从 0 开始，所以第 11 个数的下标是 10：

L[10:20]
# [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

前 10 个数中，每 2 个取 1 个：

L[:10:2]
# [0, 2, 4, 6, 8]

所有数中，每 5 个取 1 个：

L[::5]
# [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

什么都不写可以复制一个列表：

copy_L = L[:]

注意：L[:] 是浅拷贝。如果列表里还有列表、字典等可变对象，内部对象不会被深拷贝。

a = [[1], [2]]
b = a[:]

b[0].append(99)
print(a)  # [[1, 99], [2]]

切片也支持负步长，常用于反转序列：

nums = [1, 2, 3, 4, 5]
print(nums[::-1])  # [5, 4, 3, 2, 1]

text = 'Python'
print(text[::-1])  # nohtyP

字符串也可以切片：

'ABCDEFG'[:3]
# 'ABC'

'ABCDEFG'[::2]
# 'ACEG'

tuple 也支持切片，切片结果仍然是 tuple：

t = (1, 2, 3, 4, 5)
print(t[1:4])  # (2, 3, 4)

常见误区

• L[0:3] 取的是下标 0、1、2，不包含下标 3
• 下标越界不会报错，Python 会自动取到能取到的位置
• L[:] 只是浅拷贝，不是深拷贝
• step 不能是 0，否则会报 ValueError

L = [1, 2, 3]

print(L[:100])   # [1, 2, 3]
print(L[100:])   # []
print(L[::-1])   # [3, 2, 1]

练习

利用切片操作，实现一个 trim() 函数，去除字符串首尾的空格，注意不要调用 str.strip() 方法。

def trim(s):
    start = 0
    end = len(s)

    while start < end and s[start] == ' ':
        start = start + 1

    while end > start and s[end - 1] == ' ':
        end = end - 1

    return s[start:end]


# 测试
if trim('hello  ') != 'hello':
    print('测试失败!')
elif trim('  hello') != 'hello':
    print('测试失败!')
elif trim('  hello  ') != 'hello':
    print('测试失败!')
elif trim('  hello  world  ') != 'hello  world':
    print('测试失败!')
elif trim('') != '':
    print('测试失败!')
elif trim('    ') != '':
    print('测试失败!')
else:
    print('测试成功!')

说明：这里把 end 设计成“结束下标后一位”，正好符合切片 s[start:end] 的习惯。

迭代

知识点

如果一个对象可以被 for 循环遍历，就称它是可迭代对象，即 Iterable。

常见可迭代对象：

• list
• tuple
• dict
• set
• str
• generator

遍历列表：

names = ['Michael', 'Bob', 'Tracy']

for name in names:
    print(name)

遍历字符串：

for ch in 'ABC':
    print(ch)

遍历字典时，默认遍历的是 key：

d = {'a': 1, 'b': 2, 'c': 3}

for key in d:
    print(key)

遍历 value：

for value in d.values():
    print(value)

同时遍历 key 和 value：

for key, value in d.items():
    print(key, value)

从 Python 3.7 开始，普通 dict 的遍历顺序保证为插入顺序。不过，学习阶段更应该关注“遍历 key、value、item 的方式”，不要把字典当成靠下标访问的列表。

判断一个对象是否可迭代：

from collections.abc import Iterable

print(isinstance('abc', Iterable))  # True
print(isinstance([1, 2, 3], Iterable))  # True
print(isinstance(123, Iterable))  # False

如果想在遍历列表时同时拿到下标和值，可以使用 enumerate()：

for index, value in enumerate(['A', 'B', 'C']):
    print(index, value)

输出：

0 A
1 B
2 C

for 循环中还可以同时解包多个变量：

points = [(1, 2), (3, 4), (5, 6)]

for x, y in points:
    print(x, y)

练习

请使用迭代查找一个 list 中的最小值和最大值，并返回一个 tuple：

def findMinAndMax(L):
    if not L:
        return (None, None)

    min_value = L[0]
    max_value = L[0]

    for value in L:
        if value < min_value:
            min_value = value
        if value > max_value:
            max_value = value

    return (min_value, max_value)


# 测试
if findMinAndMax([]) != (None, None):
    print('测试失败!')
elif findMinAndMax([7]) != (7, 7):
    print('测试失败!')
elif findMinAndMax([7, 1]) != (1, 7):
    print('测试失败!')
elif findMinAndMax([7, 1, 3, 9, 5]) != (1, 9):
    print('测试失败!')
else:
    print('测试成功!')

说明：不要把变量命名为 min 或 max，因为它们会覆盖 Python 内置函数 min() 和 max()。

列表生成式

知识点

列表生成式用于快速创建列表。

普通写法：

L = []
for x in range(1, 11):
    L.append(x * x)

print(L)

列表生成式写法：

print([x * x for x in range(1, 11)])

生成结果：

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

基本形式：

[表达式 for 变量 in 可迭代对象]

可以在后面添加过滤条件：

[x * x for x in range(1, 11) if x % 2 == 0]
# [4, 16, 36, 64, 100]

可以使用两层循环：

[m + n for m in 'ABC' for n in 'XYZ']
# ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

可以同时使用两个变量：

d = {'x': 'A', 'y': 'B', 'z': 'C'}

result = [key + '=' + value for key, value in d.items()]
print(result)

把列表中的字符串统一转成小写：

names = ['Hello', 'World', 'IBM', 'Apple']
print([name.lower() for name in names])

if 的两种位置

列表生成式里的 if 有两种常见位置，含义不同。

放在 for 后面的 if 是过滤条件，不能写 else：

[x for x in range(10) if x % 2 == 0]
# [0, 2, 4, 6, 8]

放在 for 前面的 if ... else ... 是表达式，必须有 else：

[x if x % 2 == 0 else -x for x in range(10)]
# [0, -1, 2, -3, 4, -5, 6, -7, 8, -9]

可以这样理解：

• [表达式 for x in ... if 条件]：先筛选，再生成
• [A if 条件 else B for x in ...]：每个元素都生成，只是按条件决定生成 A 还是 B

练习

如果列表中既包含字符串，又包含整数、None 等非字符串对象，直接调用 .lower() 会报错：

L = ['Hello', 'World', 18, 'Apple', None]

# 错误写法
# [s.lower() for s in L]

请通过添加 if 过滤条件，让列表生成式只处理字符串。

L1 = ['Hello', 'World', 18, 'Apple', None]
L2 = [s.lower() for s in L1 if isinstance(s, str)]


# 测试
print(L2)
if L2 == ['hello', 'world', 'apple']:
    print('测试通过!')
else:
    print('测试失败!')

小结

• 列表生成式适合从一个可迭代对象快速生成新列表
• 表达式写在最前面，for 写在后面
• for 后面的 if 用于过滤元素
• 表达式里的 if ... else ... 用于决定每个元素生成什么值
• 列表生成式不要写得过长，过复杂时普通 for 循环更清楚

生成器

知识点

列表会一次性把所有元素创建出来。如果元素很多，可能会占用大量内存。

生成器 generator 的特点是：一边循环，一边计算。它不会一次性保存所有结果，而是在需要下一个值时才计算。

把列表生成式的 [] 改成 ()，就可以创建一个生成器：

L = [x * x for x in range(10)]
g = (x * x for x in range(10))

print(L)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(g)  # <generator object ...>

可以使用 next() 取得生成器的下一个值：

g = (x * x for x in range(3))

print(next(g))  # 0
print(next(g))  # 1
print(next(g))  # 4

当没有更多元素时，继续调用 next() 会抛出 StopIteration：

print(next(g))  # StopIteration

实际开发中，更常用 for 循环遍历生成器：

g = (x * x for x in range(10))

for n in g:
    print(n)

生成器函数

如果一个函数中包含 yield，它就不再是普通函数，而是生成器函数。

普通斐波那契函数：

def fib(max_count):
    n, a, b = 0, 0, 1
    while n < max_count:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

改成生成器函数：

def fib(max_count):
    n, a, b = 0, 0, 1
    while n < max_count:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

调用生成器函数时，返回的是生成器对象：

f = fib(6)
print(f)  # <generator object fib at ...>

用 for 循环遍历：

for n in fib(6):
    print(n)

输出：

1
1
2
3
5
8

yield 的执行过程

普通函数从上到下执行，遇到 return 就结束。

生成器函数每次执行到 yield 时会暂停，并返回 yield 后面的值。下一次调用 next() 时，会从上次暂停的位置继续执行。

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield 3
    print('step 3')
    yield 5


g = odd()
print(next(g))
print(next(g))
print(next(g))

输出：

step 1
1
step 2
3
step 3
5

注意：每次调用生成器函数都会创建一个新的生成器对象。

next(odd())  # 每次都是新的生成器，所以都从 step 1 开始
next(odd())
next(odd())

正确写法是先保存生成器对象：

g = odd()
next(g)
next(g)
next(g)

获取生成器的返回值

用 for 循环遍历生成器时，拿不到生成器函数中 return 的值。

如果一定要获取 return 的值，需要捕获 StopIteration：

g = fib(6)

while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration as e:
        print('Generator return value:', e.value)
        break

生成器的几个重要特点

• 惰性计算：需要时才计算下一个值
• 节省内存：不一次性保存所有元素
• 只能向前遍历：不能像列表一样随便按下标访问
• 会被消耗：遍历过一次后，再次遍历不会重新开始

g = (x for x in range(3))

print(list(g))  # [0, 1, 2]
print(list(g))  # []

练习

杨辉三角定义如下：

          1
         / \
        1   1
       / \ / \
      1   2   1
     / \ / \ / \
    1   3   3   1
   / \ / \ / \ / \
  1   4   6   4   1

把每一行看作一个 list，请写一个生成器，不断输出下一行：

def triangles():
    row = [1]
    while True:
        yield row
        row = [1] + [row[i] + row[i + 1] for i in range(len(row) - 1)] + [1]

测试：

n = 0
results = []

for row in triangles():
    results.append(row)
    n = n + 1
    if n == 10:
        break

for row in results:
    print(row)

if results == [
    [1],
    [1, 1],
    [1, 2, 1],
    [1, 3, 3, 1],
    [1, 4, 6, 4, 1],
    [1, 5, 10, 10, 5, 1],
    [1, 6, 15, 20, 15, 6, 1],
    [1, 7, 21, 35, 35, 21, 7, 1],
    [1, 8, 28, 56, 70, 56, 28, 8, 1],
    [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
]:
    print('测试通过!')
else:
    print('测试失败!')

迭代器

知识点

可以直接作用于 for 循环的对象叫 Iterable，即可迭代对象。

可以被 next() 函数调用，并不断返回下一个值的对象叫 Iterator，即迭代器。

判断是否是 Iterable：

from collections.abc import Iterable

print(isinstance([], Iterable))  # True
print(isinstance({}, Iterable))  # True
print(isinstance('abc', Iterable))  # True
print(isinstance((x for x in range(10)), Iterable))  # True
print(isinstance(100, Iterable))  # False

判断是否是 Iterator：

from collections.abc import Iterator

print(isinstance((x for x in range(10)), Iterator))  # True
print(isinstance([], Iterator))  # False
print(isinstance({}, Iterator))  # False
print(isinstance('abc', Iterator))  # False

生成器一定是迭代器：

g = (x for x in range(3))
print(isinstance(g, Iterator))  # True

list、dict、str 是可迭代对象，但不是迭代器。可以使用 iter() 把它们转换成迭代器：

it = iter([1, 2, 3])

print(next(it))  # 1
print(next(it))  # 2
print(next(it))  # 3

继续调用：

print(next(it))  # StopIteration

for 循环的本质

下面的 for 循环：

for x in [1, 2, 3, 4, 5]:
    print(x)

本质上类似于：

it = iter([1, 2, 3, 4, 5])

while True:
    try:
        x = next(it)
        print(x)
    except StopIteration:
        break

Iterable 和 Iterator 的区别

类型	能否 for 循环	能否 next()	是否惰性计算
list	可以	不可以	否
dict	可以	不可以	否
str	可以	不可以	否
generator	可以	可以	是
iter(list)	可以	可以	是

迭代器表示的是一个数据流。它不一定知道总长度，只能不断向后取下一个值。

这也是为什么迭代器可以表示无限序列，而列表不适合：

def natural_numbers():
    n = 1
    while True:
        yield n
        n = n + 1

使用无限生成器时一定要设置停止条件：

for n in natural_numbers():
    if n > 10:
        break
    print(n)

小结

• 凡是可以用于 for 循环的对象，都是 Iterable
• 凡是可以用于 next() 的对象，都是 Iterator
• generator 既是 Iterable，也是 Iterator
• list、dict、str 是 Iterable，但不是 Iterator
• iter() 可以把可迭代对象转换为迭代器
• Python 的 for 循环本质上是不断调用 next()，直到遇到 StopIteration

本章综合小结

• 切片适合截取序列，语法是 sequence[start:stop:step]
• 字符串、列表、元组都支持切片
• 迭代让我们可以用统一方式遍历不同对象
• enumerate() 适合在遍历时同时获取下标和值
• 列表生成式适合快速生成新列表
• 生成器适合处理大量数据或无限序列
• yield 会让函数变成生成器函数
• Iterable 强调“能不能被遍历”
• Iterator 强调“能不能被 next() 取下一个值”

练习题

下面练习按难度从低到高排列，建议先独立完成，再对照自己的代码思考有没有更简洁的写法。

基础题

1. 给定列表 L = list(range(1, 101))，使用切片取出：
   • 前 10 个数
   • 后 10 个数
   • 第 20 到第 30 个数
   • 所有 5 的倍数
2. 使用切片判断一个字符串是否是回文字符串，例如 'level'、'上海自来水来自海上'。
3. 编写函数 first_and_last(items)，返回序列的第一个元素和最后一个元素。如果序列为空，返回 (None, None)。
4. 遍历字典 scores = {'Bob': 75, 'Alice': 92, 'Tom': 66}，打印每个学生的姓名和成绩。
5. 使用 enumerate() 遍历列表 ['Python', 'Java', 'Go']，输出从 1 开始的编号。

列表生成式练习

6. 使用列表生成式生成 [1, 4, 9, ..., 100]。
7. 使用列表生成式生成 ['1x1=1', '2x2=4', ..., '9x9=81']。
8. 给定 L = ['Hello', '', 'World', None, 'Python']，生成一个新列表，只保留非空字符串并全部转成小写。
9. 给定 nums = [3, -1, 0, 8, -5]，生成新列表：正数保持不变，负数变成 0。
10. 使用两层循环生成所有扑克牌点数和花色组合，例如 ['A♠', 'A♥', ...]。

生成器和迭代器练习

11. 编写生成器 even_numbers(limit)，依次生成不超过 limit 的所有偶数。
12. 编写生成器 take(iterable, n)，从任意可迭代对象中最多取出前 n 个元素。
13. 编写生成器 countdown(n)，从 n 倒数到 1。
14. 编写函数 is_iterator(obj)，判断一个对象是否是迭代器。
15. 用 iter() 和 next() 手动模拟遍历列表 ['a', 'b', 'c']。

综合题

16. 编写函数 normalize_names(names)：

• 去掉每个名字首尾空格
• 过滤掉空字符串
• 每个名字首字母大写，其余小写
• 返回新列表

17. 编写生成器 window(seq, size)，按固定窗口切片序列：

list(window([1, 2, 3, 4, 5], 3))
# [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

18. 编写函数 flatten(matrix)，使用列表生成式把二维列表拉平成一维列表：

flatten([[1, 2], [3, 4], [5]])
# [1, 2, 3, 4, 5]

19. 编写生成器 unique(iterable)，按出现顺序生成不重复的元素。
20. 编写函数 top_students(scores, n)，参数 scores 是形如 {'Bob': 75, 'Alice': 92} 的字典，返回分数最高的前 n 个学生姓名。

小项目练手

项目：文本日志分析器

目标：写一个简单的日志分析工具，练习本章的切片、迭代、列表生成式、生成器和迭代器。

假设有一批日志，每行格式如下：

2026-05-14 10:01:03 INFO user=alice action=login cost=35ms
2026-05-14 10:02:18 WARN user=bob action=upload cost=210ms
2026-05-14 10:03:22 ERROR user=alice action=download cost=530ms

基础要求

1. 编写生成器 read_logs(lines)，接收一个字符串列表，逐行生成非空日志。
2. 编写函数 parse_log(line)，把一行日志解析成字典：

{
    'date': '2026-05-14',
    'time': '10:01:03',
    'level': 'INFO',
    'user': 'alice',
    'action': 'login',
    'cost': 35
}

3. 使用切片取得：
   • 日期部分
   • 时间部分
   • 最近 5 条日志
4. 使用迭代统计不同日志级别的数量，例如：

{'INFO': 10, 'WARN': 3, 'ERROR': 2}

5. 使用列表生成式筛选出所有 ERROR 日志。
6. 编写生成器 slow_logs(logs, limit)，只生成耗时大于 limit 毫秒的日志。

推荐代码骨架

def read_logs(lines):
    for line in lines:
        line = line.strip()
        if line:
            yield line


def parse_log(line):
    parts = line.split()
    detail = {}

    for item in parts[3:]:
        key, value = item.split('=')
        detail[key] = value

    return {
        'date': parts[0],
        'time': parts[1],
        'level': parts[2],
        'user': detail['user'],
        'action': detail['action'],
        'cost': int(detail['cost'][:-2])
    }


def count_by_level(logs):
    result = {}
    for log in logs:
        level = log['level']
        result[level] = result.get(level, 0) + 1
    return result


def slow_logs(logs, limit):
    for log in logs:
        if log['cost'] > limit:
            yield log


def main():
    lines = [
        '2026-05-14 10:01:03 INFO user=alice action=login cost=35ms',
        '2026-05-14 10:02:18 WARN user=bob action=upload cost=210ms',
        '2026-05-14 10:03:22 ERROR user=alice action=download cost=530ms',
        '2026-05-14 10:04:01 INFO user=tom action=logout cost=18ms',
        '2026-05-14 10:05:44 ERROR user=bob action=delete cost=680ms'
    ]

    parsed_logs = [parse_log(line) for line in read_logs(lines)]

    print('最近 5 条日志:')
    for log in parsed_logs[-5:]:
        print(log)

    print('级别统计:', count_by_level(parsed_logs))
    print('错误日志:', [log for log in parsed_logs if log['level'] == 'ERROR'])
    print('慢日志:', list(slow_logs(parsed_logs, 200)))


if __name__ == '__main__':
    main()

进阶要求

• 支持按用户名筛选日志
• 支持按日期筛选日志
• 找出平均耗时最高的用户
• 找出出现次数最多的操作 action
• 把 read_logs() 改成从文件逐行读取，体会生成器节省内存的优势
• 对 parse_log() 增加容错：格式错误的行不要让程序直接崩溃

项目复盘

完成后重点回顾：

• 哪些地方用了切片？
• 哪些地方用了普通迭代？
• 哪些地方适合列表生成式？
• 哪些地方适合生成器？
• 如果日志有 100 万行，哪些写法会一次性占用大量内存？