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();