11-Advanced_concepts/02_iterators_and_generators.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "edd970d0",
   "metadata": {},
   "source": [
    "# Module 11: Advanced concepts\n",
    "\n",
    "## Part 2: Iterators and generators\n",
    "\n",
    "In Python, iterators and generators are essential concepts that provide a convenient and memory-efficient way to work with sequences of data. They allow you to iterate over a collection or generate values on the fly without loading all the data into memory at once. In this section, we will explore iterators and generators and understand their usage and benefits.\n",
    "\n",
    "### 2.1. Iterators\n",
    "\n",
    "An iterator is an object that implements the iterator protocol. It allows you to iterate over a collection of elements or values one at a time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42bff452",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "iterator = iter(numbers)\n",
    "\n",
    "print(next(iterator))  # Output: 1\n",
    "print(next(iterator))  # Output: 2\n",
    "print(next(iterator))  # Output: 3"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8fc36c1b",
   "metadata": {},
   "source": [
    "In this code snippet, we create a list of numbers. We use the iter() function to obtain an iterator object from the list. The next() function is then used to retrieve the next value from the iterator in sequence. Each subsequent call to next() returns the next value until all items in the iterator are exhausted.\n",
    "\n",
    "The iteration protocol consists of two methods: __iter__() and __next__(). By implementing these methods, you can make an object\n",
    "iterable and define how it behaves during iteration.\n",
    "\n",
    "- The __iter__() method is responsible for returning an iterator object. It is called when you start iterating over an object. This method initializes any necessary state and returns an iterator object.\n",
    "- The __next__() method is called on the iterator object and is responsible for returning the next value in the iteration. It should raise the StopIteration exception when there are no more values to be returned.\n",
    "\n",
    "By implementing the iteration protocol, you can create custom iterable objects and define their iteration behavior. \n",
    "This allows you to control how the objects are iterated over and what values are returned during each iteration.\n",
    "\n",
    "Understanding the iteration protocols is essential for building advanced iterable objects and working with custom iterators and generators in Python.\n",
    "\n",
    "Here's an example of creating a custom iterator for a list of numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59de46ec",
   "metadata": {},
   "outputs": [],
   "source": [
    "class NumberIterator:\n",
    "    def __init__(self, numbers):\n",
    "        self.numbers = numbers\n",
    "        self.index = 0\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        if self.index >= len(self.numbers):\n",
    "            raise StopIteration\n",
    "        value = self.numbers[self.index]\n",
    "        self.index += 1\n",
    "        return value\n",
    "\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "iterator = NumberIterator(numbers)\n",
    "\n",
    "for number in iterator:\n",
    "    print(number)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6d08b10b",
   "metadata": {},
   "source": [
    "In this example, we define a NumberIterator class that takes a list of numbers as input. It implements the __iter__() method,\n",
    "which returns the iterator object itself, and the __next__() method, which retrieves the next value from the list. When there \n",
    "are no more values to iterate over, we raise a StopIteration exception. We can then use the NumberIterator object in a for loop to iterate over each number in the list.\n",
    "\n",
    "### 2.2. Generators\n",
    "\n",
    "Generators are a special type of iterator that can be created using generator functions or generator expressions. Generator functions are defined like regular functions but use the yield keyword to return values one at a time, maintaining their state between successive yields. Generator expressions are similar to list comprehensions but use parentheses instead of square brackets, producing a generator object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e47f6aec",
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "squares = (x ** 2 for x in numbers)\n",
    "\n",
    "for square in squares:\n",
    "    print(square, end=\" \")  # Output: 1 4 9 16 25"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d9fd8626",
   "metadata": {},
   "source": [
    "In this code snippet, we create a list of numbers. We use a generator expression (x ** 2 for x in numbers) to generate the square of each number. The generator expression produces a generator object that yields the squared values when iterated over. The for loop retrieves and prints each squared value in sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46bd9d37",
   "metadata": {},
   "outputs": [],
   "source": [
    "def countdown(n):\n",
    "    while n > 0:\n",
    "        yield n\n",
    "        n -= 1\n",
    "\n",
    "for num in countdown(5):\n",
    "    print(num, end=\" \")  # Output: 5 4 3 2 1\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "95fdec94",
   "metadata": {},
   "source": [
    "In this example, we define a generator function called countdown that takes a number n as input. Inside the function, we use a while loop to generate values in descending order from n to 1 using the yield statement. When the generator function is called in a for loop, it yields the next value in the sequence until the loop completes.\n",
    "\n",
    "Here's another example of a generator function that generates a sequence of Fibonacci numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6f4699c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci_generator():\n",
    "    a, b = 0, 1\n",
    "    while True:\n",
    "        yield a\n",
    "        a, b = b, a + b\n",
    "\n",
    "fibonacci = fibonacci_generator()\n",
    "\n",
    "for _ in range(10):\n",
    "    print(next(fibonacci))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "16c210fa",
   "metadata": {},
   "source": [
    "In this example, we define a fibonacci_generator function using the yield keyword. It initializes two variables a and b to\n",
    "the starting Fibonacci numbers. The function enters an infinite loop and yields the current Fibonacci number. It then updates \n",
    "the variables to the next Fibonacci numbers. We can use the generator in a for loop by calling the next() function on it, which\n",
    "retrieves the next value from the generator.\n",
    "\n",
    "Generators are memory-efficient because they generate values on-the-fly, only producing the next value when requested. This makes\n",
    "them particularly useful for working with large datasets or infinite sequences.\n",
    "\n",
    "### 2.3. Summary\n",
    "\n",
    "Iterators and generators are powerful constructs in Python that allow for efficient iteration over sequences of data. Iterators provide a way to sequentially access elements from a collection, while generators enable the dynamic generation of values on demand. They are particularly useful when working with large or infinite data sets where loading all the data into memory at once is impractical. By understanding iterators and generators, you can leverage their benefits to write more efficient and memory-friendly code in your Python programs."
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}