Python 可迭代对象

1. 什么是可迭代对象

在 Python 中，可迭代对象是指实现了特殊方法 __iter__() 或 __getitem__() 的对象，可以用于迭代操作。简单来说，可迭代对象就是可以使用 for 循环遍历的对象。

Python 中常见的可迭代对象有列表、元组、字符串、字典和集合等。此外，还可以自定义类实现可迭代功能。

1.1 列表（List）

列表是 Python 中最常用的数据类型之一，它是一种有序的集合，可以包含任意类型的元素。我们可以使用 for 循环遍历列表中的元素。

示例代码：

nums = [1, 2, 3, 4, 5]

for num in nums:
    print(num)

# 输出：
# 1
# 2
# 3
# 4
# 5

1.2 元组（Tuple）

元组是与列表类似的有序集合，不同之处在于元组的元素不能修改。我们也可以使用 for 循环遍历元组中的元素。

示例代码：

fruits = ('apple', 'banana', 'orange')

for fruit in fruits:
    print(fruit)

# 输出：
# apple
# banana
# orange

1.3 字符串（String）

字符串是由字符组成的，也可以看作是字符的一个有序集合。我们同样可以使用 for 循环遍历字符串中的字符。

示例代码：

s = "Hello, World!"

for char in s:
    print(char)

# 输出：
# H
# e
# l
# l
# o
# ,
#  
# W
# o
# r
# l
# d
# !

1.4 字典（Dictionary）

字典是 Python 中的一种数据结构，存储键值对（key-value）的映射关系。虽然字典无序，但我们可以使用 for 循环遍历字典中的键或值。

示例代码：

student = {
    'name': 'Alice',
    'age': 18,
    'gender': 'female'
}

# 遍历字典的键
for key in student:
    print(key)

# 输出：
# name
# age
# gender

# 遍历字典的值
for value in student.values():
    print(value)

# 输出：
# Alice
# 18
# female

1.5 集合（Set）

集合是一种不重复元素的无序集合。我们同样可以使用 for 循环遍历集合中的元素。

示例代码：

nums = {1, 2, 3, 3, 4, 5}

for num in nums:
    print(num)

# 输出：
# 1
# 2
# 3
# 4
# 5

2. 自定义可迭代对象

除了使用内置的可迭代对象，我们还可以自定义类实现可迭代功能。为了能够迭代访问对象的元素，我们需要在类中定义 __iter__() 方法。

2.1 案例：自定义迭代器类

下面我们来看一个简单的例子，自定义一个迭代器类 Countdown，用于倒计数。

示例代码：

class Countdown:
    def __init__(self, start):
        self.start = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.start < 0:
            raise StopIteration
        else:
            current = self.start
            self.start -= 1
            return current

countdown = Countdown(5)

for num in countdown:
    print(num)

# 输出：
# 5
# 4
# 3
# 2
# 1
# 0

在上面的代码中，我们定义了一个迭代器类 Countdown，它保存了开始倒计数的初始值，并实现了 __iter__() 和 __next__() 方法。

__iter__() 方法返回一个迭代器对象自身，使得该对象可以被迭代。
__next__() 方法返回下一个迭代元素，直到抛出 StopIteration 异常终止迭代。

3. 可迭代对象的常见操作

3.1 使用 `enumerate()` 函数获取索引和值

有时候我们需要同时获取可迭代对象的索引和值，这时可以使用 enumerate() 函数。

示例代码：

fruits = ['apple', 'banana', 'orange']

for index, fruit in enumerate(fruits):
    print(index, fruit)

# 输出：
# 0 apple
# 1 banana
# 2 orange

在上面的代码中，enumerate(fruits) 返回一个可迭代对象，每次迭代返回一个包含索引和值的元组 (index, fruit)。

3.2 使用 `zip()` 函数同时迭代多个可迭代对象

有时候我们需要同时遍历多个可迭代对象，这时可以使用 zip() 函数。

示例代码：

fruits = ['apple', 'banana', 'orange']
prices = [2.5, 3.2, 4.1]

for fruit, price in zip(fruits, prices):
    print(fruit, price)

# 输出：
# apple 2.5
# banana 3.2
# orange 4.1

在上面的代码中，zip(fruits, prices) 返回一个可迭代对象，每次迭代返回一个包含对应索引位置的值的元组 (fruit, price)。

3.3 使用 `reversed()` 函数倒序迭代

有时候我们需要倒序遍历一个可迭代对象，这时可以使用 reversed() 函数。

示例代码：

nums = [1, 2, 3, 4, 5]

for num in reversed(nums):
    print(num)

# 输出：
# 5
# 4
# 3
# 2
# 1

在上面的代码中，reversed(nums) 返回一个可迭代对象，每次迭代返回原可迭代对象中的元素，但按倒序的方式。

4. 总结

本文详细介绍了 Python 中的可迭代对象，包括列表、元组、字符串、字典和集合等内置的可迭代对象，以及通过自定义类实现可迭代功能。另外，还介绍了可迭代对象的常见操作，如使用 enumerate() 函数获取索引和值，使用 zip() 函数同时迭代多个可迭代对象，以及使用 reversed() 函数倒序迭代。