python高级(1): 迭代器详解

发布时间:2024年01月21日

Python迭代器的作用是提供一种遍历数据集合的方式。它是一个可以被迭代的对象,可以使用迭代器的方法来逐个访问集合中的元素,而不需要事先知道集合的大小。

在深度学习的DatasetDataloader中,就是通过迭代器实现的,因此迭代器是一个非常重要的概念和工具

迭代器具有以下几个重要的特点:

  • 节省内存:迭代器一次只返回一个元素,不需要一次性将整个集合加载到内存中,这样可以节省内存空间,特别是在处理大型数据集合时非常有用。
  • 惰性计算:迭代器在需要时才会计算下一个元素,而不是一次性计算所有的元素。这种惰性计算的方式可以在处理大量数据时提高效率。
  • 可逆迭代:迭代器可以反向遍历集合,而不需要额外的复制和存储。
  • 支持并行处理:迭代器可以同时遍历多个集合,实现并行处理。

总之,迭代器提供了一种灵活、高效和节省内存的方式来遍历数据集合,是Python中非常重要的概念和工具。

1. 迭代器与可迭代对象(Iterable)

1.1 可迭代对象(Iterable)

表示该对象可迭代, 它的类中需要定义__iter__方法,只要是实现了__iter__方法的类就是可迭代对象

from collections.abc import Iterable, Iterator

class A(object):
   def __init__(self):
       self.a = [1, 2, 3]

   def __iter__(self):
       # 此处返回啥无所谓
       return self.a

cls_a = A()
#  True
print(isinstance(cls_a, Iterable))
  • 可迭代对象,必须具备__iter__这个特殊函数,并且返回一个可迭代对象。可以通过isinstance(cls_a, Iterable)可以判断是否是可迭代对象

  • 如果一个Iterable,仅仅定义了__iter__方法,是没有特别大的用途,因为依然无法迭代,实际上 Iterable 仅仅是提供了一种抽象规范接口

1.2 迭代器( Iterator)

  • 迭代器Iterator一定是可迭代对象Iterable,但反过来,可迭代对象不一定是迭代器,因为迭代器只是可迭代对象的一种表示形式。
  • 实现了__next____iter__方法的类才能称为迭代器 就可以被 for 循环遍历数据。

因此,通过自定义实现迭代器Iterator,必须具备__next____iter__ 两个方法,如下案例所示:

class A(object):
    def __init__(self):
        self.index = -1
        self.a = [1, 2, 3]

    # 必须要返回一个实现了 __next__ 方法的对象,否则后面无法 for 遍历
    # 因为本类自身实现了 __next__,所以通常都是返回 self 对象即可
    def __iter__(self):
        return self

    def __next__(self):
        self.index += 1
        if self.index < len(self.a):
            return self.a[self.index]
        else:
            # 抛异常,for 内部会自动捕获,表示迭代完成
            raise StopIteration("遍历完了")

cls_a = A()
print(isinstance(cls_a, Iterable)) # True 
print(isinstance(cls_a, Iterator)) # True  从这里可以看出来同时具有__iter__和__next__的类,是Iterator
print(isinstance(iter(cls_a), Iterator)) # True 这里加不加iter()都一样,因为这个类里面的iter也是直接返回自身(self)

#另外补充一点这个a和上面类里面的a是不一样的;这里的用i(任意字母都可以)也能
for a in cls_a:
    print(a)
# 打印 1 2 3

-可以看到,通过实现__iter__, 和__next__这两个特殊方法,实现了迭代器A。

2. 自定义一个可迭代器

2.1 实现迭代器

在Python中从头开始构建迭代器很容易。我们只需要实现这些方法__iter__()__next__()

  • __iter__()方法需要返回迭代器对象, 最简单直接返回self,也可以返回新的可迭代对象。如果需要,可以执行一些初始化
  • __next__()方法必须返回序列中的下一项。在到达终点时,以及在随后的调用中,它必须引发StopIteration

这里,我们展示了一个示例,通过定义一个迭代器,手动实现python的range方法:

class Range:
    
    def __init__(self,start,stop,step):
        self.start = start  
        self.stop = stop  
        self.step = step 
             
    
    def __iter__(self):
        self.value = self.start
        return self
    
    def __next__(self):
        # 1. 每执行一次next,需要返回一个值  
        # 2. 如果没有下一个值了,需要通过StopIteration 反馈异常
        if self.value < self.stop:
            old_value = self.value   
            self.value = self.value +self.step  
            return old_value
        else:
            raise StopIteration()

for i in Range(0,5,1):
    print(i)

输出结果
在这里插入图片描述

我们知道python 的range方法 有三个参数:start_value, stop_value和step,因此我们也定义这3个参数。

  • 首先定义类的__init__方法
  • 然后实现__iter__方法,并返回可迭代对象,这里返回了本身(slef)。其中在__iter__方法中,初始化了返回值self.value__iter__方法中,如果需要,可以执行一些初始化
  • 最后通过__next__方法,定义每一次迭代输出的值。当迭代完了,没有下一个值,通过raise StopIteration(), 反馈错误。

在for循环中,最后反馈的raise StopIteration() erro,会被for循环处理掉,因此我们看不到报错的提醒。

2.2 for 遍历迭代器的过程

在这里插入图片描述
通过单步调试,可以观察到如下执行顺序:

  • (1) 首先调用__init__方法,对成员变量进行初始化
  • (2) 紧接着,进入__iter__,获得一个迭代器对象self
  • (3) 最后进入__next__方法,执行循环迭代过程,每迭代一次返回相应的迭代结果。最后迭代会执行raise StopIteration()语句,此时程序结束(异常被for处理,所以没有显示出来)

可以看到所谓for循环,本质上是就是一次次的执行__next__方法的过程。for循环可等价如下代码:

r = Range(0,5,1)	  # __init__ 构造对象
iteration = iter(r)   # 执行__iter__,获得迭代器对象
#iteration =  r.__iter__()

next(iteration)      # 执行__next__
#iteration.__next__()
next(iteration)		 # 执行__next__
next(iteration)      # 执行__next__
next(iteration)      # 执行__next__
next(iteration)      # 执行__next__
try:
    next(iteration)
except StopIteration as e:
    pass
  • 最后一次会报StopIteration 异常,因此通过try except进行处理。
  • 注:`
    • iter(r) 就是 r.__iter__()实现的
    • next(iteration)就是通过iteration.__next__()实现的

3. yolov8 Dataset实现案例

class LoadImages:
   # YOLOv5 image/video dataloader, i.e. `python detect.py --source image.jpg/vid.mp4`
   def __init__(self, path, img_size=640, stride=32, auto=True, transforms=None, vid_stride=1):
       """Initialize instance variables and check for valid input."""
       if isinstance(path, str) and Path(path).suffix == '.txt':  # *.txt file with img/vid/dir on each line
           path = Path(path).read_text().rsplit()
       files = []
       for p in sorted(path) if isinstance(path, (list, tuple)) else [path]:
           p = str(Path(p).resolve())
           if '*' in p:
               files.extend(sorted(glob.glob(p, recursive=True)))  # glob
           elif os.path.isdir(p):
               files.extend(sorted(glob.glob(os.path.join(p, '*.*'))))  # dir
           elif os.path.isfile(p):
               files.append(p)  # files
           else:
               raise FileNotFoundError(f'{p} does not exist')

       images = [x for x in files if x.split('.')[-1].lower() in IMG_FORMATS]
       videos = [x for x in files if x.split('.')[-1].lower() in VID_FORMATS]
       ni, nv = len(images), len(videos)

       self.img_size = img_size
       self.stride = stride
       self.files = images + videos
       self.nf = ni + nv  # number of files
       self.video_flag = [False] * ni + [True] * nv
       self.mode = 'image'
       self.auto = auto
       self.transforms = transforms  # optional
       self.vid_stride = vid_stride  # video frame-rate stride
       if any(videos):
           self._new_video(videos[0])  # new video
       else:
           self.cap = None
       assert self.nf > 0, f'No images or videos found in {p}. ' \
                           f'Supported formats are:\nimages: {IMG_FORMATS}\nvideos: {VID_FORMATS}'

   def __iter__(self):
       """Returns an iterator object for iterating over images or videos found in a directory."""
       self.count = 0
       return self

   def __next__(self):
       """Iterator's next item, performs transformation on image and returns path, transformed image, original image, capture and size."""
       if self.count == self.nf:
           raise StopIteration
       path = self.files[self.count]

       if self.video_flag[self.count]:
           # Read video
           self.mode = 'video'
           for _ in range(self.vid_stride):
               self.cap.grab()
           ret_val, im0 = self.cap.retrieve()
           while not ret_val:
               self.count += 1
               self.cap.release()
               if self.count == self.nf:  # last video
                   raise StopIteration
               path = self.files[self.count]
               self._new_video(path)
               ret_val, im0 = self.cap.read()

           self.frame += 1
           # im0 = self._cv2_rotate(im0)  # for use if cv2 autorotation is False
           s = f'video {self.count + 1}/{self.nf} ({self.frame}/{self.frames}) {path}: '

       else:
           # Read image
           self.count += 1
           im0 = cv2.imread(path)  # BGR
           assert im0 is not None, f'Image Not Found {path}'
           s = f'image {self.count}/{self.nf} {path}: '

       if self.transforms:
           im = self.transforms(im0)  # transforms
       else:
           im = letterbox(im0, self.img_size, stride=self.stride, auto=self.auto)[0]  # padded resize
           im = im.transpose((2, 0, 1))[::-1]  # HWC to CHW, BGR to RGB
           im = np.ascontiguousarray(im)  # contiguous

       return path, im, im0, self.cap, s
  dataset = LoadImages(source, imgsz=imgsz, vid_stride=vid_stride)
   dataloader = build_dataloader(dataset, batch_size, workers, shuffle, rank)
  • 可以看到Dataset,也是通过一个迭代器实现,这样做的好处就是:需要时才会返回处理好的数据,而不需要一次性将整个集合加载到内存中,这样可以节省内存空间,也提高了数据处理的效率。
文章来源:https://blog.csdn.net/weixin_38346042/article/details/135729578
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。