关于何时使用Dataset或者iterableDataset(生成器/迭代器/可迭代对象)

参考：

• 【你在 Python 中常看到的 yield 到底是什么鬼？-哔哩哔哩】 https://b23.tv/3PZYqjt
• 【15分钟彻底搞懂迭代器、可迭代对象、生成器【python迭代器】-哔哩哔哩】 https://b23.tv/a0tqrZ6

---

Dataset 或者 IterableDataset?

关于何时使用Dataset或者iterableDataset，先说结论: 当你数据量很大，如一百万张图片左右（经验值）的时候，推荐使用IterDataset；即当你在__init__()方法中生成data_path时间 大于 调用batch_size个 __getitem__()方法时候，可以考虑使用iterDataset。

生成器

timer.py 用于停表计时。

import time

class Timer: #@save
    """记录多次运⾏时间"""
    def __init__(self):
        self.times = []
        self.start()
    def start(self):
        """启动计时器"""
        self.tik = time.time()
    def stop(self):
        """停⽌计时器并将时间记录在列表中"""
        self.times.append(time.time() - self.tik)
        return self.times[-1]
    def avg(self):
        """返回平均时间"""
        return sum(self.times) / len(self.times)
    def sum(self):
        """返回时间总和"""
        return sum(self.times)

generator.py 用于理解生成器。

import sys, os
sys.path.append(os.path.dirname(__file__))
from timer import Timer

# list 会 一次性将数据全部存储进内存; 而 generator 不会一股脑将数据存进内存，而是根据算法一次一次生成。
timer2 = Timer()
diy_list = [i for i in range(7200)]         # list
timer2_1 = timer2.stop()

timer2.start()
diy_generator = (i for i in range(7200))    # generator
timer2_2 = timer2.stop()
print(timer2.times)         # 当数据量为7200000个时，[3.2351293563842773, 9.5367431640625e-06] 可以看出列表生成器更快   | 类似于生成len=7200000的list
print(type(diy_generator))  # <class 'generator'>

# 比价时间
timer = Timer()
for i in diy_list:
    # print(i)
    pass
time1 = timer.stop()

timer.start()
for i in diy_generator:
    # print(i)
    pass
time2 = timer.stop()
print(time1, time2, timer.times)    # 当数据量为7200000个时，使用 for in 迭代输出，输出时间为 [2.6780059337615967, 7.6640541553497314] 可以看到列表输出更快 | 类似于batch_size = 7200000 

# 总结，当你数据量很大，如一百万张图片左右（经验值）的时候，推荐使用IterDataset。
# 当你在__init__()方法中生成data_path时间 大于 调用batch_size个 __getitem__()方法时候，可以考虑使用iterDataset


# 如果一个函数里面被定义了 yield，那么这个函数就是一个生成器
def foo():
    print("1")
    yield
    print("2")
    yield
    print("3")
    yield

f = foo()   # f 是生成器对象（内部是根据生成器类generator创建的对象，生成器类也声明了：__iter__(), __next__()方法。生成器属于一种特殊的迭代器）。
print(type(f))
next(f)
next(f)
# next(f)
next(f)
# yield在函数中用于将函数变成迭代器。你可以使用python的built-in function(next)来调用重写的magic method(__next__())
# 当被next()调用的时候，yield的作用类似于return，只不过他会从上一次yield结束的地方开始运行，直到下一次yield的地方。当你越界后，会报错StopIteration。


# 常见yield函数使用yield返回值，如下：
def foo2():
    for i in range(10):
        yield i * 2
for i in foo2():    # 当对可迭代对象（如生成器就是可迭代对象）for循环时候，本质上是先调用可迭代对象的__iter__()方法得到迭代器对象，在内部执行迭代器对象的__next__()方法。
    print(i)

输出：

[0.0004489421844482422, 2.86102294921875e-06]
<class 'generator'>
0.0003223419189453125 0.0008766651153564453 [0.0003223419189453125, 0.0008766651153564453]
<class 'generator'>
1
2
3
0
2
4
6
8
10
12
14
16
18

迭代器

iterator.py

'''
迭代器类型的定义：
    1. 类中定义__iter__和__next__方法
    2. __iter__方法返回对象本身, 即: self
    3. __next__方法, 返回下一个数据, 如果没有数据则StopIteration
'''

# 创建一个迭代器对象
class EvenNumbers:
    def __init__(self, max_number):
        self.max_number = max_number
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.max_number:
            raise StopIteration
        result = self.current
        self.current += 2
        return result

even_numbers = EvenNumbers(10)
print(type(even_numbers))   # <class '__main__.EvenNumbers'>

print(next(even_numbers))
print(next(even_numbers))

for _, number in enumerate(even_numbers):
    print("in", number)
# # the same as below:
# for number in even_numbers:
#     print(number) 

输出

<class '__main__.EvenNumbers'>
0
2
in 4
in 6
in 8

可迭代对象

iterable_object.py

# 迭代器定义: 如果一个类中有__iter__()方法且返回一个迭代器对象(生成器是特殊的迭代器), 则我们称这个类创建的对象叫可迭代对象。

# 例子如下：
class Foo(object): 

    def __iter__(self):
        return "迭代器对象(生成器对象)"
    
obj = Foo()
for item in obj:    # item若能调用其__iter__返回迭代器对象，则item就是可迭代对象
    pass