Add Lesson 9 about iterators and generators

Author: sondosaabed

Lessons Code/Lesson 9 Advanced Topics.ipynb

@@ -0,0 +1,194 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Lesson 9 \n",
+    "Advanced Topics in Python\n",
+    "\n",
+    "Iterators and Generators\n",
+    "\n",
+    "Iterables are objects that can return one of their elements at a time, such as a list. Many of the built-in functions we’ve used so far, like 'enumerate,' return an iterator.\n",
+    "\n",
+    "An iterator is an object that represents a stream of data. This is different from a list, which is also an iterable, but is not an iterator because it is not a stream of data.\n",
+    "\n",
+    "Generators are a simple way to create iterators using functions. You can also define iterators using classes, which you can read more about here.\n",
+    "\n",
+    "Generators are a lazy way to build iterables. They are useful when the fully realized list would not fit in memory, or when the cost to calculate each list element is high and you want to do it as late as possible. But they can only be iterated over once.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Quiz 1: Implement `my_enumerate`\n",
+    "\n",
+    "Write your own generator function `my_enumerate` that works like the built-in function `enumerate`.\n",
+    "\n",
+    "Calling your function like this:\n",
+    "\n",
+    "```python\n",
+    "lessons = [\"Why Python Programming\", \"Data Types and Operators\", \"Control Flow\", \"Functions\", \"Scripting\"]\n",
+    "\n",
+    "for i, lesson in my_enumerate(lessons, 1):\n",
+    "    print(\"Lesson {}: {}\".format(i, lesson))\n",
+    "```\n",
+    "\n",
+    "should output:\n",
+    "\n",
+    "```txt\n",
+    "Lesson 1: Why Python Programming\n",
+    "Lesson 2: Data Types and Operators\n",
+    "Lesson 3: Control Flow\n",
+    "Lesson 4: Functions\n",
+    "Lesson 5: Scripting\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Lesson 1: Why Python Programming\n",
+      "Lesson 2: Data Types and Operators\n",
+      "Lesson 3: Control Flow\n",
+      "Lesson 4: Functions\n",
+      "Lesson 5: Scripting\n"
+     ]
+    }
+   ],
+   "source": [
+    "lessons = [\"Why Python Programming\", \"Data Types and Operators\", \"Control Flow\", \"Functions\", \"Scripting\"]\n",
+    "\n",
+    "# this is a function that works like built-in enumerate\n",
+    "def my_enumerate(iterable, start=0):\n",
+    "    \"\"\"\n",
+    "    Args:\n",
+    "        (object) iterable - the iterable object\n",
+    "        (int) start - the start index\n",
+    "    \"\"\"\n",
+    "    count = start\n",
+    "    for element in iterable: \n",
+    "        # Yeild is used like return but it returns generator \n",
+    "        yield count, element \n",
+    "        count = count + 1\n",
+    "    \n",
+    "#Code to test your my_enumerate function\n",
+    "for i, lesson in my_enumerate(lessons, 1):\n",
+    "    print(\"Lesson {}: {}\".format(i, lesson))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Quiz 2: Chunker\n",
+    "\n",
+    "If you have an iterable that is too large to fit in memory in full (e.g., when dealing with large files), being able to take and use chunks of it at a time can be very valuable.\n",
+    "\n",
+    "Implement a generator function, `chunker`, that takes in an iterable and yields a chunk of a specified size at a time.\n",
+    "\n",
+    "Calling the function like this:\n",
+    "\n",
+    "```python\n",
+    "for chunk in chunker(range(25), 4):\n",
+    "    print(list(chunk))\n",
+    "```\n",
+    "\n",
+    "should output:\n",
+    "\n",
+    "```txt\n",
+    "[0, 1, 2, 3]\n",
+    "[4, 5, 6, 7]\n",
+    "[8, 9, 10, 11]\n",
+    "[12, 13, 14, 15]\n",
+    "[16, 17, 18, 19]\n",
+    "[20, 21, 22, 23]\n",
+    "[24]\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0, 1, 2, 3]\n",
+      "[4, 5, 6, 7]\n",
+      "[8, 9, 10, 11]\n",
+      "[12, 13, 14, 15]\n",
+      "[16, 17, 18, 19]\n",
+      "[20, 21, 22, 23]\n",
+      "[24]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def chunker(iterable, size):\n",
+    "    \"\"\"\n",
+    "    Args:\n",
+    "        (object) iterable - the iterable object\n",
+    "        (int) size - the start index\n",
+    "    \"\"\"\n",
+    "    for i in range(0, len(iterable), size):\n",
+    "        yield iterable[i:i + size]\n",
+    "\n",
+    "# Code to test your chunker function\n",
+    "for chunk in chunker(range(25), 4):\n",
+    "    print(list(chunk))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Generator Expressions\n",
+    "\n",
+    "Here's a cool concept that combines generators and list comprehensions! You can actually create a generator in the same way you'd normally write a list comprehension, except with parentheses instead of square brackets. For example:\n",
+    "This can help you save time and create efficient code!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sq_list = [x**2 for x in range(10)]  # this produces a list of squares\n",
+    "sq_iterator = (x**2 for x in range(10))  # this produces an iterator of squares"
+   ]
+  }
+ ],
+ "metadata": {
+  "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.11.0"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}