跳至主要內容

Python高级特性详解：让代码更加Pythonic

Li JiaXinPython编程高级特性Python高级特性切片迭代器生成器大约 9 分钟

Python高级特性详解：让代码更加Pythonic

Python之所以被称为优雅的编程语言，很大程度上得益于其丰富的高级特性。在我五年的开发经验中，熟练掌握这些特性不仅能让代码更加简洁高效，更能体现出Python的独特魅力。

今天，我将深入介绍Python的核心高级特性，包括切片、迭代器、生成器等，帮助大家写出更加Pythonic的代码。

切片

1.1 切片操作符 切片操作符是序列通用的一种操作方式，它可以将序列进行截取。切片操作符的语法如下：

序列[起始:结束:步长]

其中，起始表示切片的起始位置，结束表示切片的结束位置，步长表示切片的步长。切片操作符会返回从起始位置到结束位置（不包括结束位置）的序列，步长表示每次截取的间隔。

1.2 切片操作符的用法 切片操作符可以用于字符串、列表、元组等序列类型。下面是一些切片操作符的示例：

# 字符串切片
s = "Hello, World!"
print(s[0:5])  # 输出 "Hello"
print(s[7:12])  # 输出 "World"

# 列表切片
lst = [1, 2, 3, 4, 5]
print(lst[1:4])  # 输出 [2, 3, 4]

# 元组切片
tup = (1, 2, 3, 4, 5)
print(tup[2:])  # 输出 (3, 4, 5)

1.3 切片操作符的注意事项 切片操作符的起始位置和结束位置都是可选的，如果不指定起始位置，则默认为0；如果不指定结束位置，则默认为序列的长度。 切片操作符的步长也是可选的，如果不指定步长，则默认为1。 切片操作符返回的是一个新的序列，不会修改原序列。 切片操作符可以用于字符串、列表、元组等序列类型。

迭代

可迭代对象：可以直接作用于for循环的对象统称为可迭代对象( Iterable )

判断对象是否可迭代

from collections.abc import Iterable

print(isinstance('abc', Iterable)) # str是否可迭代
print(isinstance([1,2,3], Iterable)) # list是否可迭代
print(isinstance(123, Iterable)) # 整数是否可迭代

输出：

True
True
False

可迭代对象：字符串，列表，元组，字典，集合

生成式

列表生成式

2.1 列表生成式的语法 列表生成式是一种简洁的列表创建方式，它可以在一行代码中生成一个列表。列表生成式的语法如下：

[表达式 for 变量 in 序列]

其中，表达式表示列表中的元素，变量表示序列中的每个元素，序列表示要遍历的序列。

2.2 列表生成式的用法 列表生成式可以用于生成列表、列表推导、列表筛选等操作。下面是一些列表生成式的示例：

# 生成列表
lst = [x for x in range(10)]
print(lst)  # 输出 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 列表推导
lst = [x**2 for x in range(10)]
print(lst)  # 输出 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 列表筛选
lst = [x for x in range(10) if x % 2 == 0]  
print(lst)  # 输出 [0, 2, 4, 6, 8]

2.3 列表生成式的注意事项

列表生成式可以用于生成列表、列表推导、列表筛选等操作。

列表生成式的表达式可以是任意的表达式，包括函数调用、条件表达式等。

列表生成式的变量可以是任意的变量名，但是不能与其他变量名冲突。

列表生成式的序列可以是任意的序列类型，包括字符串、列表、元组等。

列表生成式返回的是一个新的列表，不会修改原列表。

集合生成式

3.1 集合生成式的语法 集合生成式是一种简洁的集合创建方式，它可以在一行代码中生成一个集合。集合生成式的语法如下：

{表达式 for 变量 in 序列}

其中，表达式表示集合中的元素，变量表示序列中的每个元素，序列表示要遍历的序列。

3.2 集合生成式的用法 集合生成式可以用于生成集合、集合推导、集合筛选等操作。

下面是一些集合生成式的示例：

# 生成集合
s = {x for x in range(10)}
print(s)  # 输出 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
# 集合推导
s = {x**2 for x in range(10)}
print(s)  # 输出 {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}
# 集合筛选
s = {x for x in range(10) if x % 2 == 0}
print(s)  # 输出 {0, 2, 4, 6, 8}

3.3 集合生成式的注意事项

集合生成式可以用于生成集合、集合推导、集合筛选等操作。

集合生成式的表达式可以是任意的表达式，包括函数调用、条件表达式等。

集合生成式的变量可以是任意的变量名，但是不能与其他变量名冲突。

集合生成式的序列可以是任意的序列类型，包括字符串、列表、元组等。

集合生成式返回的是一个新的集合，不会修改原集合。

字典生成式

4.1 字典生成式的语法 字典生成式是一种简洁的字典创建方式，它可以在一行代码中生成一个字典。字典生成式的语法如下：

{键:值 for 变量 in 序列}

其中，键表示字典中的键，值表示字典中的值，变量表示序列中的每个元素，序列表示要遍历的序列。 4.2 字典生成式的用法 字典生成式可以用于生成字典、字典推导、字典筛选等操作。下面是一些字典生成式的示例：

# 生成字典
d = {x: x**2 for x in range(10)}
print(d)  # 输出 {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
# 字典推导
d = {x: x**2 for x in range(10) if x % 2 == 0}
print(d)  # 输出 {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}
# 字典筛选
d = {x: x**2 for x in range(10) if x % 2 == 0}
print(d)  # 输出 {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

4.3 字典生成式的注意事项

字典生成式可以用于生成字典、字典推导、字典筛选等操作。

字典生成式的键和值可以是任意的表达式，包括函数调用、条件表达式等。

字典生成式的变量可以是任意的变量名，但是不能与其他变量名冲突。

字典生成式的序列可以是任意的序列类型，包括字符串、列表、元组等。

字典生成式返回的是一个新的字典，不会修改原字典。

生成器

生成器：为了节省内存空间，提高程序速度，这种一边循环一边计算的机制，称为生成器 ( Generator )。 next() 取值

g = (x for x in range(10))
print(next(g))  # 输出 0
print(next(g))  # 输出 1
print(next(g))  # 输出 2

for 循环取值

g = (x for x in range(10))
for i in g:
    print(i)

生成器的特点： 生成器是一种特殊的迭代器，它可以在循环的过程中不断地推算出后续的元素，而不是一次性地将所有元素都计算出来，从而节省了内存空间。 生成器函数：

在函数中使用 yield 关键字，该函数就变成了一个生成器函数，调用该函数会返回一个生成器对象。

def fibonacci(n):
    a, b = 0, 1
    for i in range(n):
        yield b
        a, b = b, a + b
g = fibonacci(10)
for i in g:
    print(i)

生成器表达式：类似于列表生成式，但是使用圆括号而不是方括号。

g = (x for x in range(10))
for i in g:
    print(i)

生成器的优点： 节省内存空间：生成器可以在循环的过程中不断地推算出后续的元素，而不是一次性地将所有元素都计算出来，从而节省了内存空间。

迭代器

迭代器：可以被 next() 函数调用并不断返回下一个值的对象称为迭代器( Iterator )

实用 iter(可迭代对象) 可以把可迭代对象转化为迭代器

lst = [1, 2, 3, 4, 5]
lst_iter = iter(lst)
print(next(lst_iter))  # 输出 1
print(next(lst_iter))  # 输出 2

注意：

  1. 凡是可作用于for循环的对象都是Iterable类型

  2. 凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列

  3. 集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一 个Iterator对象

  4. Python的for循环本质上就是通过不断调用next()函数实现的

迭代器和生成器的对比

迭代器（Iterator）和生成器（Generator）确实有很多相似之处，但它们并不是完全相同的概念。以下是一些关键点，帮助你理解它们之间的关系与区别：

相似之处 都用于迭代：两者都可以用于遍历集合中的元素。 实现迭代器协议：两者都实现了迭代器协议，包含 iter() 和 next() 方法。 区别 定义方式：

迭代器：通常需要定义一个类，并手动实现 iter() 和 next() 方法。需要管理状态。 生成器：使用函数和 yield 语句定义，Python 自动处理状态管理。 状态管理：

迭代器：状态由用户手动管理，每次调用 next() 时需要自行跟踪当前状态。 生成器：状态由 Python 自动管理，yield 会保存当前执行状态并在下一次调用时恢复。 内存效率：

迭代器：如果迭代的数据量大，可能会占用更多内存。 生成器：采用惰性求值，只在需要时生成数据，通常更节省内存。

迭代器示例：

class MyIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.limit:
            self.current += 1
            return self.current - 1
        raise StopIteration

生成器示例：

def my_generator(limit):
    current = 0
    while current < limit:
        yield current
        current += 1
```
总结
迭代器 是一种更通用的实现，适合复杂的状态和逻辑。
生成器 是一种更简单、直接的实现方式，特别适合快速生成序列和处理大数据。