Chính xác thì lặp, lặp và lặp là gì?

Định nghĩa cơ bản nhất của "iterable", "iterator" và "iteration" trong Python là gì?

Tôi đã đọc nhiều định nghĩa nhưng tôi không thể xác định ý nghĩa chính xác vì nó vẫn không chìm trong.

Ai đó có thể vui lòng giúp tôi với 3 định nghĩa trong điều khoản cư sĩ không?

Lặp lại là một thuật ngữ chung để lấy từng mục của một cái gì đó, cái khác. Bất cứ khi nào bạn sử dụng một vòng lặp, rõ ràng hoặc ẩn, để đi qua một nhóm các mục, đó là lặp lại.

Trong Python, iterable và iterator có ý nghĩa cụ thể.

Một iterable là một đối tượng có một __iter__phương thức trả về một iterator hoặc định nghĩa một __getitem__phương thức có thể lấy các chỉ mục tuần tự bắt đầu từ 0 (và tăng lên IndexErrorkhi các chỉ mục không còn hợp lệ). Vì vậy, một iterable là một đối tượng mà bạn có thể nhận được một iterator từ đó.

Một iterator là một đối tượng với phương thức next(Python 2) hoặc __next__(Python 3).

Bất cứ khi nào bạn sử dụng một forvòng lặp, hoặc map, hoặc hiểu danh sách, v.v. trong Python, nextphương thức được gọi tự động để lấy từng mục từ trình vòng lặp , do đó sẽ trải qua quá trình lặp .

Một nơi tốt để bắt đầu học sẽ là phần iterators của hướng dẫn và phần iterator của trang loại chuẩn . Sau khi bạn hiểu những điều cơ bản, hãy thử phần lặp trong phần Lập trình chức năng HOWTO .

Đây là lời giải thích tôi sử dụng trong việc dạy các lớp Python:

Một ITERABLE là:

• bất cứ điều gì có thể được lặp lại (tức là bạn có thể lặp qua một chuỗi hoặc tệp) hoặc
• bất cứ thứ gì có thể xuất hiện ở phía bên phải của vòng lặp for: for x in iterable: ...hoặc
• bất cứ điều gì bạn có thể gọi với iter()điều đó sẽ trả lại một ITERATOR: iter(obj)hoặc
• một đối tượng xác định __iter__trả về một ITERATOR mới hoặc nó có thể có một __getitem__phương thức phù hợp để tra cứu được lập chỉ mục.

Một ITERATOR là một đối tượng:

• với trạng thái nhớ nó ở đâu trong khi lặp lại,
• với một __next__phương pháp:
  • trả về giá trị tiếp theo trong lần lặp
  • cập nhật trạng thái để trỏ đến giá trị tiếp theo
  • tín hiệu khi nó được thực hiện bằng cách tăng StopIteration
• và đó là tự lặp lại (có nghĩa là nó có một __iter__phương thức trả về self).

Ghi chú:

• Các __next__phương pháp trong Python 3 được viết nextbằng Python 2, và
• Hàm dựng sẵn next()gọi phương thức đó trên đối tượng được truyền cho nó.

Ví dụ:

>>> s = 'cat'      # s is an ITERABLE
                   # s is a str object that is immutable
                   # s has no state
                   # s has a __getitem__() method 

>>> t = iter(s)    # t is an ITERATOR
                   # t has state (it starts by pointing at the "c"
                   # t has a next() method and an __iter__() method

>>> next(t)        # the next() function returns the next value and advances the state
'c'
>>> next(t)        # the next() function returns the next value and advances
'a'
>>> next(t)        # the next() function returns the next value and advances
't'
>>> next(t)        # next() raises StopIteration to signal that iteration is complete
Traceback (most recent call last):
...
StopIteration

>>> iter(t) is t   # the iterator is self-iterable

Các câu trả lời trên rất hay, nhưng như hầu hết những gì tôi đã thấy, đừng nhấn mạnh sự khác biệt đủ cho những người như tôi.

Ngoài ra, mọi người có xu hướng nhận được "quá Pythonic" bằng cách đặt các định nghĩa như "X là một đối tượng có __foo__()phương thức" trước đó. Các định nghĩa như vậy là chính xác - chúng dựa trên triết lý gõ vịt, nhưng trọng tâm của các phương pháp có xu hướng giữa khi cố gắng hiểu khái niệm này trong sự đơn giản của nó.

Vì vậy, tôi thêm phiên bản của tôi.

Trong ngôn ngữ tự nhiên,

• lặp là quá trình lấy một phần tử tại một thời điểm trong một hàng các phần tử.

Trong Python

• iterable là một đối tượng, tốt, lặp đi lặp lại, đơn giản chỉ có nghĩa là nó có thể được sử dụng trong phép lặp, ví dụ như với một forvòng lặp. Làm sao? Bằng cách sử dụng iterator . Tôi sẽ giải thích bên dưới.

• ... trong khi iterator là một đối tượng xác định cách thực sự lặp lại - cụ thể là phần tử tiếp theo là gì . Đó là lý do tại sao nó phải có next()phương pháp.

Các trình lặp cũng tự lặp lại, với sự khác biệt là __iter__()phương thức của chúng trả về cùng một đối tượng ( self), bất kể các mục của nó có được sử dụng bởi các lệnh gọi trước hay không next().

Vậy trình thông dịch Python nghĩ gì khi thấy for x in obj:câu lệnh?

Hãy nhìn xem, một forvòng lặp. Trông giống như một công việc cho một trình vòng lặp ... Hãy lấy một cái. ... Có objanh chàng này , vì vậy hãy hỏi anh ta.

"Ông obj, bạn có lặp lại không?" (... các cuộc gọi iter(obj), cuộc gọi này obj.__iter__(), vui vẻ đưa ra một trình vòng lặp mới sáng bóng _i.)

OK, thật dễ dàng ... Hãy bắt đầu lặp đi lặp lại. ( x = _i.next()... x = _i.next()...)

Vì Mr. objđã thành công trong bài kiểm tra này (bằng cách có một phương thức nhất định trả về một trình vòng lặp hợp lệ), chúng tôi thưởng cho anh ấy bằng tính từ: bây giờ bạn có thể gọi anh ấy là "ông lặp đi lặp lại obj".

Tuy nhiên, trong các trường hợp đơn giản, thông thường bạn không được hưởng lợi từ việc có trình vòng lặp và vòng lặp riêng biệt. Vì vậy, bạn chỉ xác định một đối tượng, đó cũng là trình lặp riêng của nó. (Python không thực sự quan tâm đến việc được _iđưa ra bởi objkhông phải là tất cả sáng bóng, mà chỉ là objchính nó.)

Đây là lý do tại sao trong hầu hết các ví dụ tôi đã thấy (và những gì đã làm tôi bối rối nhiều lần), bạn có thể thấy:

class IterableExample(object):

    def __iter__(self):
        return self

    def next(self):
        pass

thay vì

class Iterator(object):
    def next(self):
        pass

class Iterable(object):
    def __iter__(self):
        return Iterator()

Tuy nhiên, có những trường hợp khi bạn có thể hưởng lợi từ việc iterator tách khỏi iterable, chẳng hạn như khi bạn muốn có một hàng vật phẩm, nhưng nhiều "con trỏ" hơn. Ví dụ: khi bạn muốn làm việc với các phần tử "hiện tại" và "sắp tới", bạn có thể có các trình vòng lặp riêng cho cả hai. Hoặc nhiều luồng kéo từ một danh sách lớn: mỗi luồng có thể có trình vòng lặp riêng để duyệt qua tất cả các mục. Xem câu trả lời của @ Raymond và @ glglgl ở trên.

Hãy tưởng tượng những gì bạn có thể làm:

class SmartIterableExample(object):

    def create_iterator(self):
        # An amazingly powerful yet simple way to create arbitrary
        # iterator, utilizing object state (or not, if you are fan
        # of functional), magic and nuclear waste--no kittens hurt.
        pass    # don't forget to add the next() method

    def __iter__(self):
        return self.create_iterator()

Ghi chú:

• Tôi sẽ nhắc lại lần nữa: iterator không lặp lại được . Iterator không thể được sử dụng như một "nguồn" trong forvòng lặp. Những gì forvòng lặp chủ yếu cần là __iter__() (mà trả lại một cái gì đó với next()).

• Tất nhiên, forkhông phải là vòng lặp duy nhất, vì vậy, ở trên cũng áp dụng cho một số cấu trúc khác ( while...).

• Iterator next()có thể ném StopIteration để dừng lặp. Mặc dù vậy, nó không phải lặp đi lặp lại hoặc sử dụng các phương tiện khác.

• Trong "quá trình suy nghĩ" ở trên, _ikhông thực sự tồn tại. Tôi đã tạo nên cái tên đó.

• next()Bây giờ phải có một thay đổi nhỏ trong phương thức Python 3.x: (không phải là tích hợp sẵn) __next__(). Vâng, nó đáng lẽ phải như thế suốt.

• Bạn cũng có thể nghĩ về nó như thế này: iterable có dữ liệu, iterator kéo mục tiếp theo

Tuyên bố miễn trừ trách nhiệm: Tôi không phải là nhà phát triển của bất kỳ trình thông dịch Python nào, vì vậy tôi không thực sự biết trình thông dịch "nghĩ gì". Những suy ngẫm ở trên chỉ là minh chứng cho cách tôi hiểu chủ đề từ những giải thích, thí nghiệm và trải nghiệm thực tế khác của một người mới chơi Python.

Một iterable là một đối tượng có một __iter__()phương thức. Nó có thể lặp đi lặp lại nhiều lần, chẳng hạn như list()s và tuple()s.

Một iterator là đối tượng lặp đi lặp lại. Nó được trả về bởi một __iter__()phương thức, trả về chính nó thông qua __iter__()phương thức riêng của nó và có một next()phương thức ( __next__()trong 3.x).

Lặp đi lặp lại là quá trình gọi sự tôn trọng này next(). __next__()cho đến khi nó tăng StopIteration.

Thí dụ:

>>> a = [1, 2, 3] # iterable
>>> b1 = iter(a) # iterator 1
>>> b2 = iter(a) # iterator 2, independent of b1
>>> next(b1)
1
>>> next(b1)
2
>>> next(b2) # start over, as it is the first call to b2
1
>>> next(b1)
3
>>> next(b1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> b1 = iter(a) # new one, start over
>>> next(b1)
1

Đây là bảng cheat của tôi:

 sequence
  +
  |
  v
   def __getitem__(self, index: int):
  +    ...
  |    raise IndexError
  |
  |
  |              def __iter__(self):
  |             +     ...
  |             |     return <iterator>
  |             |
  |             |
  +--> or <-----+        def __next__(self):
       +        |       +    ...
       |        |       |    raise StopIteration
       v        |       |
    iterable    |       |
           +    |       |
           |    |       v
           |    +----> and +-------> iterator
           |                               ^
           v                               |
   iter(<iterable>) +----------------------+
                                           |
   def generator():                        |
  +    yield 1                             |
  |                 generator_expression +-+
  |                                        |
  +-> generator() +-> generator_iterator +-+

Trắc nghiệm: Bạn có thấy ...

1. mỗi lần lặp là một lần lặp?
2. một đối tượng container __iter__()Phương thức có thể được thực hiện như một trình tạo không?
3. một iterable có một __next__phương thức không nhất thiết phải là một iterator?

Đáp án:

1. Mỗi iterator phải có một __iter__phương thức. Đang có__iter__ đủ để là một lặp đi lặp lại. Do đó, mỗi iterator là một iterable.

2. Khi __iter__được gọi, nó sẽ trả về một iterator ( return <iterator>trong sơ đồ trên). Gọi một trình tạo trả về một trình vòng lặp trình tạo là một kiểu trình vòng lặp.

   class Iterable1:
       def __iter__(self):
           # a method (which is a function defined inside a class body)
           # calling iter() converts iterable (tuple) to iterator
           return iter((1,2,3))
   
   class Iterable2:
       def __iter__(self):
           # a generator
           for i in (1, 2, 3):
               yield i
   
   class Iterable3:
       def __iter__(self):
           # with PEP 380 syntax
           yield from (1, 2, 3)
   
   # passes
   assert list(Iterable1()) == list(Iterable2()) == list(Iterable3()) == [1, 2, 3]

3. Đây là một ví dụ:

   class MyIterable:
   
       def __init__(self):
           self.n = 0
   
       def __getitem__(self, index: int):
           return (1, 2, 3)[index]
   
       def __next__(self):
           n = self.n = self.n + 1
           if n > 3:
               raise StopIteration
           return n
   
   # if you can iter it without raising a TypeError, then it's an iterable.
   iter(MyIterable())
   
   # but obviously `MyIterable()` is not an iterator since it does not have
   # an `__iter__` method.
   from collections.abc import Iterator
   assert isinstance(MyIterable(), Iterator)  # AssertionError

Tôi không biết nó có giúp được ai không nhưng tôi luôn thích hình dung các khái niệm trong đầu để hiểu rõ hơn về chúng. Vì vậy, khi tôi có một đứa con trai nhỏ, tôi hình dung khái niệm iterable / iterator bằng gạch và giấy trắng.

Giả sử chúng tôi ở trong phòng tối và trên sàn nhà chúng tôi có gạch cho con trai tôi. Gạch có kích thước, màu sắc khác nhau, không quan trọng bây giờ. Giả sử chúng ta có 5 viên gạch như thế. 5 viên gạch đó có thể được mô tả như một đối tượng - giả sử bộ gạch . Chúng ta có thể làm nhiều thứ với bộ gạch này - có thể lấy một cái rồi lấy thứ hai rồi thứ ba, có thể thay đổi vị trí của viên gạch, đặt viên gạch đầu tiên lên trên cái thứ hai. Chúng ta có thể làm nhiều thứ với những thứ đó. Do đó, bộ công cụ gạch này là một đối tượng hoặc trình tự lặp lại khi chúng ta có thể đi qua từng viên gạch và làm một cái gì đó với nó. Chúng tôi chỉ có thể làm điều đó như con trai nhỏ của tôi - chúng tôi có thể chơi với một viên gạch cùng một lúc . Vì vậy, một lần nữa tôi tưởng tượng mình bộ gạch này là mộtiterable .

Bây giờ hãy nhớ rằng chúng ta đang ở trong phòng tối. Hoặc gần như tối. Vấn đề là chúng ta không nhìn rõ những viên gạch đó, màu gì, hình dạng gì, v.v. Vì vậy, ngay cả khi chúng ta muốn làm gì đó với chúng - hay lặp đi lặp lại qua chúng - chúng ta không thực sự biết nó là gì và vì nó là như thế nào quá tối.

Những gì chúng ta có thể làm là ở gần viên gạch đầu tiên - như là một yếu tố của bộ gạch - chúng ta có thể đặt một mảnh giấy huỳnh quang trắng để chúng ta thấy vị trí của phần tử gạch đầu tiên. Và mỗi lần chúng tôi lấy một viên gạch từ một bộ dụng cụ, chúng tôi thay thế mảnh giấy trắng thành một viên gạch tiếp theo để có thể nhìn thấy nó trong căn phòng tối. Mảnh giấy trắng này không gì khác hơn là một vòng lặp . Nó là một đối tượng là tốt . Nhưng một đối tượng với những gì chúng ta có thể làm việc và chơi với các yếu tố của đối tượng lặp lại của chúng ta - bộ gạch.

Nhân tiện, điều đó giải thích cho sai lầm ban đầu của tôi khi tôi đã thử những điều sau trong IDLE và nhận được TypeError:

 >>> X = [1,2,3,4,5]
 >>> next(X)
 Traceback (most recent call last):
    File "<pyshell#19>", line 1, in <module>
      next(X)
 TypeError: 'list' object is not an iterator

Danh sách X ở đây là bộ gạch của chúng tôi nhưng KHÔNG phải là một mảnh giấy trắng. Tôi cần tìm một iterator trước:

>>> X = [1,2,3,4,5]
>>> bricks_kit = [1,2,3,4,5]
>>> white_piece_of_paper = iter(bricks_kit)
>>> next(white_piece_of_paper)
1
>>> next(white_piece_of_paper)
2
>>>

Không biết nếu nó giúp, nhưng nó đã giúp tôi. Nếu ai đó có thể xác nhận / hình dung chính xác khái niệm, tôi sẽ biết ơn. Nó sẽ giúp tôi tìm hiểu thêm.

Lặp lại : - một cái gì đó có thể lặp lại được lặp đi lặp lại; như các chuỗi như danh sách, chuỗi, vv Ngoài ra, nó có __getitem__phương thức hoặc __iter__phương thức. Bây giờ nếu chúng ta sử dụng iter()hàm trên đối tượng đó, chúng ta sẽ có một trình vòng lặp.

Iterator : - Khi chúng ta lấy đối tượng iterator từ iter()hàm; chúng ta gọi __next__()phương thức (trong python3) hoặc đơn giản next()(trong python2) để lấy các phần tử từng cái một. Lớp này hoặc thể hiện của lớp này được gọi là iterator.

Từ tài liệu: -

Việc sử dụng các trình lặp lặp lại và thống nhất Python. Đằng sau hậu trường, câu lệnh for gọi  iter() đối tượng container. Hàm trả về một đối tượng iterator xác định phương thức  __next__() truy cập các phần tử trong vùng chứa một lần. Khi không còn phần tử nào nữa,  __next__() sẽ xuất hiện ngoại lệ StopIteration để cho vòng lặp for chấm dứt. Bạn có thể gọi  __next__() phương thức bằng hàm  next() dựng sẵn; ví dụ này cho thấy tất cả hoạt động như thế nào:

>>> s = 'abc'
>>> it = iter(s)
>>> it
<iterator object at 0x00A1DB50>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    next(it)
StopIteration

Ví dụ của một lớp: -

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    def __iter__(self):
        return self
    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]


>>> rev = Reverse('spam')
>>> iter(rev)
<__main__.Reverse object at 0x00A1DB50>
>>> for char in rev:
...     print(char)
...
m
a
p
s

Tôi không nghĩ rằng bạn có thể làm cho nó đơn giản hơn nhiều so với tài liệu , tuy nhiên tôi sẽ thử:

• Lặp đi lặp lại là một cái gì đó có thể được lặp đi lặp lại . Trong thực tế, nó thường có nghĩa là một chuỗi, ví dụ như một cái gì đó có một khởi đầu và kết thúc và một số cách để đi qua tất cả các mục trong đó.

• Bạn có thể nghĩ Iterator như một phương thức giả trợ giúp (hoặc thuộc tính giả) cung cấp (hoặc giữ) mục tiếp theo (hoặc đầu tiên) trong lần lặp . (Trong thực tế, nó chỉ là một đối tượng xác định phương thức next())

• Lặp lại có lẽ được giải thích tốt nhất theo định nghĩa của Merriam-Webster của từ :

b: sự lặp lại của một chuỗi các hướng dẫn máy tính một số lần xác định hoặc cho đến khi một điều kiện được đáp ứng - so sánh đệ quy

iterable = [1, 2] 

iterator = iter(iterable)

print(iterator.__next__())   

print(iterator.__next__())   

vì thế,

1. iterablelà một đối tượng có thể được lặp qua . ví dụ: danh sách, chuỗi, tuple, v.v.

2. sử dụng iterhàm trên iterableđối tượng của chúng ta sẽ trả về một đối tượng iterator.

3. bây giờ đối tượng iterator này có phương thức được đặt tên __next__(trong Python 3, hoặc chỉ nexttrong Python 2) mà bạn có thể truy cập từng phần tử của iterable.

vì vậy, ĐẦU RA CỦA MÃ TRÊN SILL ĐƯỢC:

1

2

Lặp lại có một __iter__phương thức khởi tạo một trình vòng lặp mới mỗi lần.

Các trình vòng lặp thực hiện một __next__phương thức trả về các mục riêng lẻ và một __iter__phương thức trả về self.

Do đó, các trình vòng lặp cũng có thể lặp lại, nhưng các trình vòng lặp không phải là các trình vòng lặp.

Luciano Ramalho, Python thông thạo.

Trước khi làm việc với iterables và iterator, yếu tố chính quyết định iterable và iterator là chuỗi

Trình tự: Trình tự là tập hợp dữ liệu

Iterable: Iterable là đối tượng kiểu trình tự hỗ trợ __iter__phương thức.

Phương thức lặp: Phương thức Iter lấy chuỗi làm đầu vào và tạo một đối tượng được gọi là iterator

Iterator: Iterator là đối tượng gọi phương thức tiếp theo và chuyển qua chuỗi. Khi gọi phương thức tiếp theo, nó trả về đối tượng mà nó hiện đang đi qua.

thí dụ:

x=[1,2,3,4]

x là một chuỗi bao gồm tập hợp dữ liệu

y=iter(x)

Khi gọi iter(x)nó chỉ trả về một iterator khi đối tượng x có phương thức iter nếu không nó sẽ đưa ra một ngoại lệ. Nếu nó trả về iterator thì y được gán như thế này:

y=[1,2,3,4]

Vì y là một iterator do đó nó hỗ trợ next()phương thức

Khi gọi phương thức tiếp theo, nó trả về từng phần tử của danh sách một.

Sau khi trả về phần tử cuối cùng của chuỗi nếu chúng ta gọi lại phương thức tiếp theo, nó sẽ xuất hiện lỗi StopIteration

thí dụ:

>>> y.next()
1
>>> y.next()
2
>>> y.next()
3
>>> y.next()
4
>>> y.next()
StopIteration

Trong Python mọi thứ đều là một đối tượng. Khi một đối tượng được cho là có thể lặp lại, điều đó có nghĩa là bạn có thể bước qua (tức là lặp lại) đối tượng như một bộ sưu tập.

Mảng ví dụ là lặp đi lặp lại. Bạn có thể bước qua chúng bằng một vòng lặp for và đi từ chỉ số 0 đến chỉ số n, n là độ dài của đối tượng mảng trừ đi 1.

Từ điển (cặp khóa / giá trị, còn được gọi là mảng kết hợp) cũng có thể lặp lại. Bạn có thể bước qua các phím của họ.

Rõ ràng các đối tượng không phải là bộ sưu tập không thể lặp lại. Ví dụ, một đối tượng bool chỉ có một giá trị, Đúng hoặc Sai. Nó không thể lặp lại được (sẽ không có nghĩa là nó là một đối tượng có thể lặp lại).

Đọc thêm. http://www.lepus.org.uk/ref/compmate/Iterator.xml