detecting that an object is repeatedly iterable

These requirements mean that iterators are never repeatable, and that you can always confirm that an iterable is an iterator (and therefore unrepeatable by definition) by confirming that iter(obj) is obj is True:

def is_unrepeatable(obj):
   return iter(obj) is obj

This behaviour would be strange (and annoying), but is not prohibited. Here's an example of a non-repeatable iterable class which is not an iterator:

class Unrepeatable:

   def __init__(self, iterable):
   self.iterable = iterable
self.exhausted = False

def __iter__(self):
   if self.exhausted:
   return
else:
   self.exhausted = True
yield from self.iterable

>>> x = Unrepeatable([1, 2, 3]) >>>
   list(x)[1, 2, 3] >>>
   list(x)[] >>>
   iter(x) is x
False
   >>>

Suggestion : 2

This function is lazy; that is, it is guaranteed to return in $Θ(1)$ time and use $Θ(1)$ additional space, and flt will not be called by an invocation of filter. Calls to flt will be made when iterating over the returned iterable object. These calls are not cached and repeated calls will be made when reiterating.,Given a predicate function flt and an iterable object itr, return an iterable object which upon iteration yields the elements x of itr that satisfy flt(x). The order of the original iterator is preserved.,Return an iterator over the product of several iterators. Each generated element is a tuple whose ith element comes from the ith argument iterator. The first iterator changes the fastest.,zip orders the calls to its subiterators in such a way that stateful iterators will not advance when another iterator finishes in the current iteration.

1._

Stateful(itr)

Examples

julia > a = Iterators.Stateful("abcdef");

julia > isempty(a)
false

julia > popfirst!(a)
'a': ASCII / Unicode U + 0061(category Ll: Letter, lowercase)

julia > collect(Iterators.take(a, 3))
3 - element Vector {
      Char
   }:
   'b': ASCII / Unicode U + 0062(category Ll: Letter, lowercase)
'c': ASCII / Unicode U + 0063(category Ll: Letter, lowercase)
'd': ASCII / Unicode U + 0064(category Ll: Letter, lowercase)

julia > collect(a)
2 - element Vector {
      Char
   }:
   'e': ASCII / Unicode U + 0065(category Ll: Letter, lowercase)
'f': ASCII / Unicode U + 0066(category Ll: Letter, lowercase)

julia > Iterators.reset!(a);
popfirst!(a)
'a': ASCII / Unicode U + 0061(category Ll: Letter, lowercase)

julia > Iterators.reset!(a, "hello");
popfirst!(a)
'h': ASCII / Unicode U + 0068(category Ll: Letter, lowercase)

julia > a = Iterators.Stateful([1, 1, 1, 2, 3, 4]);

julia >
   for x in a;
x == 1 ||
   break;
end

julia > peek(a)
3

julia > sum(a) # Sum the remaining elements
7

1._

zip(iters...)

Examples

julia > a = 1: 5
1: 5

julia > b = ["e", "d", "b", "c", "a"]
5 - element Vector {
      String
   }:
   "e"
"d"
"b"
"c"
"a"

julia > c = zip(a, b)
zip(1: 5, ["e", "d", "b", "c", "a"])

julia > length(c)
5

julia > first(c)
   (1, "e")

1._

enumerate(iter)

Examples

julia > a = ["a", "b", "c"];

julia >
   for (index, value) in enumerate(a)
println("$index $value")
end
1 a
2 b
3 c

1._

rest(iter, state)

Examples

julia > collect(Iterators.rest([1, 2, 3, 4], 2))
3 - element Vector {
      Int64
   }:
   2
3
4

1._

countfrom(start = 1, step = 1)

Examples

julia >
   for v in Iterators.countfrom(5, 2)
v > 10 &&
   break
println(v)
end
5
7
9

1._

take(iter, n)

Examples

julia > a = 1: 2: 11
1: 2: 11

julia > collect(a)
6 - element Vector {
      Int64
   }:
   1
3
5
7
9
11

julia > collect(Iterators.take(a, 3))
3 - element Vector {
      Int64
   }:
   1
3
5

Suggestion : 3

August 1, 2021

				# list iterable
				   >>>
				   for num in [1, 2, 3]:
				   ...print(num)
				1
				2
				3

				# String iterable
				   >>>
				   for num in "Python":
				   ...print(num)
				P
				y
				t
				h
				o
				n

				iter_object = iter(iterable)
				OR
				iter_object = iterable.__iter__()

				>>> next(my_iter)
				1

				>>> next(my_iter)
				2

				>>> next(my_iter)
				3

				>>> next(my_iter)
				Traceback (most recent call last):
				File "<stdin>", line 1, in <module>
				      StopIteration

				my_list = [1, 2, 3]

				for num in my_list:
				   print(num)

				>>> map_obj = map(lambda x: x**2, [1,2,3])

				>>> map_obj
				<map object at 0x00000203D8C142B0>

				   >>> dir(map_obj)
				   ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__',
				   '__ge__', '__getattribute__', '__gt__', '__hash__','__init__','__init_subclass__',
				   '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__',
				   '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

				   >>> list(map_obj)
				   [1, 4, 9]

				>>>
				iter_obj = map(lambda x: x ** 2, [1, 2, 3]) >>>
				   min(iter_obj)
				1

				   >>>
				   iter_obj = map(lambda x: x ** 2, [1, 2, 3]) >>>
				   max(iter_obj)
				9

				   >>>
				   iter_obj = map(lambda x: x ** 2, [1, 2, 3]) >>>
				   sum(iter_obj)
				14

Suggestion : 4

This is far more general than just working over ArrayLists — any class that implements Iterable can be used with a for-each loop. This is yet another example of the power of good abstractions: by recognizing the common elements of iteration and being iterable, we can create a reusable notion that works wherever we choose to implement it.,In fact, ArrayList is not special, and does not get its own syntax. Instead, it is simply one particular example of a far more general notion, one that we can take advantage of for our own classes, too.,We are using our Deque as a queue, where items are added at the end of the queue and removed from the front. (Think of a queue as standing in line at the supermarket: people queue up at the end of the line, and exit from the front of the line.),According to our naming conventions, it really ought to be called IIterator, but that’s a clumsy name. At least it does start with a capital I!

X-- -- -- -- --X-- -- -- -- --X-- -- -- -- --X-- -- -- -- --X-- -- -- -- --X-- -- -- -- --X

Suggestion : 5

In Python, any type which can be iterated over with a for loop is an iterable. Lists, tuples, strings and dicts are all commonly used iterable types. Iterating over a list or a tuple simply means processing each value in turn.,You can use all these iterables almost interchangeably because they all use the same interface for iterating over values: every iterable object has a method which can be used to return an iterator over that object. The iterable and the iterator together form a consistent interface which can be used to loop over a sequence of values – whether those values are all stored in memory or calculated as they are needed:,The first part (2 * number or number or animal.title()) defines what is going to be inserted into the new list at each step of the loop. This is usually some function of each item in the original iterable as it is processed.,The middle part (for number in numbers or for animal in animals) corresponds to the first line of a for loop, and defines what iterable is being iterated over and what variable name each item is given inside the loop.

total = 0
i = 1

while i <= 10:
   total += i
i += 1

x = 0
while x < 3:
   y += 1 # wrong variable updated

product = 1
count = 1

while count <= 10:
   product *= count
# forgot to update count

x = 0
while x < 5:
   print(x)
x += 1 # update statement is indented one level too little, so it 's outside the loop body

x = 0
while x != 5:
   print(x)
x += 2 # x will never equal 5, because we are counting in even numbers!

# numbers is a list of numbers--we don 't know what the numbers are!

total = 0
i = 0

while i < len(numbers) and total < 100:
   total += numbers[i]
i += 1

for (int count = 1; count <= 8; count++) {
   System.out.println(count);
}

for i in range(1, 9):
   print(i)

pets = ["cat", "dog", "budgie"]

for pet in pets:
   print(pet)