rust python对比_Python Rust 迭代器对比

迭代是数据处理的基石，而 Python 中所有集合都可以迭代，这是 Python 让使用者感到非常方便的特征之一。

下面是一些在 Python 中经常使用的迭代模式

# 列表

for i in [1, 2, 3, 4]:

print(i)

# 字典

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

# 迭代键

for k in di.keys():

print(k)

# 迭代键值

for k, v in di.items():

print('{}: {}'.format(k, v))

除了基本数据类型，Python 也支持为自定义的数据类型实现迭代器协议。Python 解释器在需要迭代对象 x 时会自动调用 iter(x)。

内置的 iter 函数有如下作用。

检查对象是否实现了 __iter__ 方法，如果实现了就调用它，__iter__ 方法返回一个迭代器

如果没有实现 __iter__ 方法，但是实现了 __getitem__ 方法，Python 会创建一个迭代器，尝试按顺序(从索引0)获取元素。

如果上述两个尝试失败，Python 会抛出 TypeError 异常，提示该元素不可迭代。

所以如果我们要让某个对象是可迭代对象，只需要实现 __iter__，这个方法要求返回一个迭代器，那什么是迭代器呢？ Python 中标准的迭代器接口有两个方法。

__next__

返回下一个可用的元素，如果元素，抛出 StopIteration 异常。

__iter__

返回迭代器自身，即 self，以便在应该使用可迭代对象的地方使用迭代器，如 for 循环中。

这里需要说明的一点是，可迭代对象与迭代器是不同的，《流畅的 Python》这样定义可迭代对象

> 使用 iter 内置函数可以获取迭代器的对象。如果对象实现了能返回迭代器的 iter 方法，那么对象就是可迭代的。序列都可以迭代；实现了 getitem 方法，而且其参数是从零开始的索引，这种对象也可以迭代

而迭代器则定义为

> 迭代器是这样的对象：实现了无参数的 next 方法，返回序列中的下一个元素；如果没有元素了，那么抛出 StopIteration 异常。Python 中的迭代器还实现了 iter 方法，因此迭代器也可以迭代。

也就是说每次对可迭代对象调用 iter(x) 都将返回一个新的迭代器。

那如果为一个可迭代对象实现 __next__ 方法，即把这个可迭代对象变成自身的可迭代对象会怎样呢？没人阻止你这样做，但当你真正为这个对象实现这两个方法时，你会发现麻烦不断。举个例子

class MyData:

def __init__(self, values):

# 假设 value 为列表

self.values = values

def __iter__(self):

return self

def __next__(self):

# ???

raise NotImplementedError()

按照协议 __next__ 应该返回下一个元素或者抛出 StopIteration，显然我们需要一个属性存储当前迭代位置，所以应该似乎应该这样写

class MyData:

def __init__(self, values):

self.values = values

# 记录当前迭代位置

self.current = 0

def __iter__(self):

# 每次调用重头开始迭代

self.current = 0

return self

def __next__(self):

if self.current < len(self.values):

value = self.values[self.current]

self.current += 1

return value

else:

raise StopIteration

但考虑这样一种情况，我们调用2次 iter，交替迭代获得的2个迭代器，预期行为应该是2个迭代器不会干涉，但如果按上述代码实现 MyData 对象行为并不符合预期。

data = MyData([1, 2, 3, 4, 5])

data_iter1 = iter(data)

print(next(data_iter1)) # 结果为1

print(next(data_iter1)) # 结果为2

data_iter2 = iter(data)

print(next(data_iter2)) # 结果为1

print(next(data_iter1)) # 预期为3，但得到2

如果把 current 属性变为列表，每次调用 iter 增加一个元素表示新的迭代器当前位置呢？但又会导致 __next__ 变得非常复杂，因为它必须找到不同迭代器对应当前位置，这样才能保证正确的迭代行为。为什么我们的迭代实现如此复杂呢？根本原因在于 __iter__ 总是返回自身，换言之，调用 iter 的迭代器都是一样，这其实破坏了每次调用 iter 返回新的迭代器这一设计。

解决难题办法很简单，遵循设计，把可迭代对象和迭代器拆开。

class MyData:

def __init__(self, values):

self.values = values

def __iter__(self):

return DataIterator(list(self.values))

class DataIterator:

def __init__(self, values):

self.values = values

self.current = 0

def __iter__(self):

return self

def __next__(self):

if self.current < len(self.values):

value = self.values[self.current]

self.current += 1

return value

else:

raise StopIteration

现在 __iter__ 将会返回新的迭代器，每个迭代器都保存着自身状态，这让我们不必费心费力第维护迭代器状态。

所以，把可迭代对象变成其自身的迭代器是条歧路，反设计的。

在 Rust 中，迭代也遵循着相似的设计，Rust 中实现了 Iterator 特性的结构体就被认为是可迭代的。

我们可以像 Python 那样使用 for 循环迭代

let v1 = vec![1, 2, 3, 4, 5];

for item in v1 {

println!("{}", item);

}

std::iter::Iterator 只要求实现 next 方法即可，下面是一个官方文档中的例子

// 首先定义一个结构体，作为“迭代器”

struct Counter {

count: usize,

}

// 实现静态方法 new，相当于构造函数

// 这个方法不是必须的，但可以让我更加方便

// 地使用 Counter

impl Counter {

fn new() -> Counter {

Counter { count: 0 }

}

// 实现 Iterator 特性

impl Iterator for Counter {

// 确定迭代器的返回值类型

type Item = usize;

// 只有 next() 是必须实现的方法

// Option 也可以写成 Option<:item>

fn next(&mut self) -> Option {

// 增加计数

self.count += 1;

// 到 5 就返回 :)

if self.count < 6 {

Some(self.count)

} else {

None

}

let mut counter = Counter::new();