06. Functions and Modules Part 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HyperLearning AI - Introduction to Python\n",
    "An introductory course to the Python 3 programming language, with a curriculum aligned to the Certified Associate in Python Programming (PCAP) examination syllabus (PCAP-31-02).<br/>\n",
    "https://knowledgebase.hyperlearning.ai/courses/introduction-to-python\n",
    "\n",
    "\n",
    "## 06. Functions and Modules Part 1\n",
    "https://knowledgebase.hyperlearning.ai/courses/introduction-to-python/modules/6/functions-and-modules-part-1\n",
    "\n",
    "In this module we will formally introduce functions, generator functions and lambda functions in Python, starting with formal definitions before exploring their structures and core components, including:\n",
    "\n",
    "* **Functions** - bespoke functions, parameters, arguments, default parameters, name scope, and important keywords such as return, None and global\n",
    "* **Generator Functions** - bespoke generators, lazy evaluation and lazy iterators, generator termination and generator expressions\n",
    "* **Lambda Functions** - functional programming, anonymous functions, and lambda functions within filter, map, reduce, sorted and reversed functions "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A simple example of a user-defined function\n",
    "def product(number_1, number_2):\n",
    "    return number_1 * number_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "240\n"
     ]
    }
   ],
   "source": [
    "# Call the user-defined function\n",
    "a = 12\n",
    "b = 20\n",
    "c = product(a, b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.1. Defining Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to test whether a given number is a prime number or not\n",
    "def is_prime(num):\n",
    "    \"\"\" Test whether a given number is a prime number or not.\n",
    "    \n",
    "    Tests whether a given number is a prime number or not,\n",
    "    by first testing whether it is 0, 1, negative or not a\n",
    "    whole number. If neither of these conditions are met, \n",
    "    then the function proceeds to test whether the given\n",
    "    number can be divided by the numbers from 2 to the\n",
    "    floor division of the given number by 2 without a\n",
    "    remainder. If not, then the given number is indeed a \n",
    "    prime number.\n",
    "    \n",
    "    Args:\n",
    "        num (int): The number to test\n",
    "        \n",
    "    Returns:\n",
    "        True if the number is a prime number,\n",
    "        False otherwise.\n",
    "    \"\"\"\n",
    "    \n",
    "    if num <= 1 or num % 1 > 0:\n",
    "        return False\n",
    "    \n",
    "    for i in range(2, num//2):\n",
    "        if num % i == 0:\n",
    "            return False\n",
    "        \n",
    "    return True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2. Calling Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is the number 8 a prime number? False\n",
      "Is the number 13 a prime number? True\n",
      "Is the number 277 a prime number? True\n",
      "Is the number -23 a prime number? False\n",
      "Is the number 7.181 a prime number? False\n",
      "Is the number 0 a prime number? False\n"
     ]
    }
   ],
   "source": [
    "# Call the is_prime() function on a given integer\n",
    "a = 8\n",
    "print(f'Is the number {a} a prime number? {is_prime(a)}')\n",
    "b = 13\n",
    "print(f'Is the number {b} a prime number? {is_prime(b)}')\n",
    "c = 277\n",
    "print(f'Is the number {c} a prime number? {is_prime(c)}')\n",
    "d = -23\n",
    "print(f'Is the number {d} a prime number? {is_prime(d)}')\n",
    "e = 7.181\n",
    "print(f'Is the number {e} a prime number? {is_prime(e)}')\n",
    "f = 0\n",
    "print(f'Is the number {f} a prime number? {is_prime(f)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "is_prime() missing 1 required positional argument: 'num'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-38e10062a072>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Call a function with an incorrect number of positional arguments\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mis_prime\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: is_prime() missing 1 required positional argument: 'num'"
     ]
    }
   ],
   "source": [
    "# Call a function with an incorrect number of positional arguments\n",
    "print(is_prime())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3. Arbitrary Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to expect an arbitrary number of arguments\n",
    "def product(*nums):\n",
    "    x = 1\n",
    "    for num in nums:\n",
    "        x *= num\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "\n",
      "The product of the numbers (9, 11, 2) is 198\n"
     ]
    }
   ],
   "source": [
    "# Call this function with a tuple of arguments\n",
    "print(product(2, 10, 5))\n",
    "\n",
    "my_numbers = (9, 11, 2)\n",
    "print(f'\\nThe product of the numbers {my_numbers} is {product(*my_numbers)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.4. Unpacking Argument Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function expecting separate positional arguments\n",
    "def findPrimesBetween(start_num, end_num):\n",
    "    return [num for num in range(start_num, end_num) if is_prime(num)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
     ]
    }
   ],
   "source": [
    "# Call this function using argument unpacking\n",
    "args = [1, 100]\n",
    "print(findPrimesBetween(*args))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.5. Keyword Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199]\n"
     ]
    }
   ],
   "source": [
    "# Call a function using keyword arguments\n",
    "print(findPrimesBetween(start_num = 100, end_num = 200))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.6. Arbitrary Keyword Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to expect an arbitrary number of keyword arguments\n",
    "def concatenate_words(**words):\n",
    "    return ' '.join(words.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wonderful World of Python\n"
     ]
    }
   ],
   "source": [
    "# Call this function with a dictionary of arguments\n",
    "print(concatenate_words(word_1=\"Wonderful\", word_2=\"World\", word_3=\"of\", word_4=\"Python\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.7. Default Parameter Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function with default parameter values\n",
    "def findPrimesBetween(start_num = 2, end_num = 100):\n",
    "    return [num for num in range(start_num, end_num) if is_prime(num)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n",
      "[2, 3, 4, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n",
      "[29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n",
      "[1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249]\n",
      "[101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199]\n"
     ]
    }
   ],
   "source": [
    "# Call this function without sending selected arguments\n",
    "print(findPrimesBetween())\n",
    "print(findPrimesBetween(end_num = 50))\n",
    "print(findPrimesBetween(start_num = 25))\n",
    "print(findPrimesBetween(start_num = 1000, end_num = 1250))\n",
    "print(findPrimesBetween(100, 200))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.8. Passing Mixed Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function with parameters of mixed types\n",
    "def calculate_bmi(fname, lname, /, dob, *, weight_kg, height_m):\n",
    "    bmi = round((weight_kg / (height_m * height_m)), 2)\n",
    "    print(f'{fname} {lname} (DOB: {dob}) has a BMI of: {bmi}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Barack Obama (DOB: 04/08/1961) has a BMI of: 23.84\n"
     ]
    }
   ],
   "source": [
    "# Call this function with mixed arguments\n",
    "calculate_bmi(\"Barack\", \"Obama\", height_m = 1.85, weight_kg = 81.6, dob = '04/08/1961')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.9. Pass Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "unexpected EOF while parsing (<ipython-input-34-5b3e28f1020f>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-34-5b3e28f1020f>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    \u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unexpected EOF while parsing\n"
     ]
    }
   ],
   "source": [
    "# Try to define a function without a body\n",
    "def my_empty_function():\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define an empty function using the pass keyword\n",
    "def my_empty_function():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.10. None Keyword and Returning None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Log Record 1\n",
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "# Define a function that does not return a value\n",
    "def my_logging_function(message):\n",
    "    print(message)\n",
    "    \n",
    "# Call this function and examine the type that it returns\n",
    "log = my_logging_function(\"01/09/2020 00:01 - Audit Log 1\")\n",
    "print(type(log))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.11. Function Recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the Nth element in Fibonacci sequence using function recursion\n",
    "def fibonacci_sequence(n):\n",
    "    if n <= 1:\n",
    "        return n\n",
    "    else:\n",
    "        return(fibonacci_sequence(n-1) + fibonacci_sequence(n-2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "0 1 1 2 3 5 8 13 21 34 "
     ]
    }
   ],
   "source": [
    "# Calculate the Nth element in the Fibonacci sequence\n",
    "print(fibonacci_sequence(10))\n",
    "\n",
    "# Print the first N elements in the Fibonacci sequence\n",
    "for num in range(0, 10):\n",
    "    print(fibonacci_sequence(num), end = ' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.12. Name Scope and Global Keyword"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function that contains variables with local scope\n",
    "def calculate_bmi(weight_kg, height_m):\n",
    "    weight_lb = weight_kg * 2.205\n",
    "    height_inches = height_m * 39.37\n",
    "    bmi = round((weight_lb / (height_inches * height_inches)) * 703, 2)\n",
    "    return bmi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'weight_lb' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-64-36404fd71278>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Try to access those variables with local scope\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mweight_lb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'weight_lb' is not defined"
     ]
    }
   ],
   "source": [
    "# Try to access a variable with local scope\n",
    "print(weight_lb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.84\n"
     ]
    }
   ],
   "source": [
    "# Define the kg to lb ratio\n",
    "kg_lb = 2.205\n",
    "\n",
    "# Define the metres to inches ratio\n",
    "m_inches = 39.37\n",
    "\n",
    "# Define a function that uses variables created outside of the function\n",
    "def calculate_bmi(weight_kg, height_m):\n",
    "    weight_lb = weight_kg * kg_lb\n",
    "    height_inches = height_m * m_inches\n",
    "    bmi = round((weight_lb / (height_inches * height_inches)) * 703, 2)\n",
    "    return bmi\n",
    "\n",
    "# Call this function\n",
    "print(calculate_bmi(weight_kg = 81.6, height_m = 1.85))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Define variables with global scope\n",
    "x = 1\n",
    "y = 2\n",
    "\n",
    "# Define a simple function\n",
    "def sum():\n",
    "    x = 10\n",
    "    y = 20\n",
    "    return x + y\n",
    "\n",
    "# Print the value of x\n",
    "print(sum())\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Define variables with global scope\n",
    "x = 1\n",
    "y = 2\n",
    "\n",
    "# Define a simple function\n",
    "def sum():\n",
    "    global x\n",
    "    x = 10\n",
    "    y = 20\n",
    "    return x + y\n",
    "\n",
    "# Print the value of x\n",
    "print(sum())\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1000000000\n",
      "1000\n",
      "1000000\n"
     ]
    }
   ],
   "source": [
    "# Define a function that creates new variables with global scope\n",
    "def product():\n",
    "    global alpha, beta\n",
    "    alpha = 1000\n",
    "    beta = 1_000_000\n",
    "    return alpha * beta\n",
    "\n",
    "# Print the value of alpha and beta\n",
    "print(product())\n",
    "print(alpha)\n",
    "print(beta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Generator Functions\n",
    "#### 2.1. Defining Generator Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a generator function to generate an infinite sequence\n",
    "def infinite_sequence_generator():\n",
    "    counter = 0\n",
    "    while True:\n",
    "        yield counter\n",
    "        counter += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Call this generator function and lazily evaluate the next element in the iterable object\n",
    "infinite_generator = infinite_sequence_generator()\n",
    "print(next(infinite_generator))\n",
    "print(next(infinite_generator))\n",
    "print(next(infinite_generator))\n",
    "print(next(infinite_generator))\n",
    "print(next(infinite_generator))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.2. Generator Termination"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a generator function to lazily return an ordered sequence of letters given a starting letter and an ending letter\n",
    "def letter_sequence_generator(start, stop, step=1):\n",
    "    for ord_unicode_int in range(ord(start.lower()), ord(stop.lower()), step):\n",
    "        yield chr(ord_unicode_int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n"
     ]
    }
   ],
   "source": [
    "# Call this generator function until there are no further elements in the sequence to be evaluated\n",
    "alphabet = letter_sequence_generator(\"a\", \"e\")\n",
    "print(next(alphabet))\n",
    "print(next(alphabet))\n",
    "print(next(alphabet))\n",
    "print(next(alphabet))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-a775c4f3c4ea>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Attempt to call the next() function again on the terminated generator function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0malphabet\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Attempt to call the next() function again on the terminated generator function\n",
    "print(next(alphabet))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.3. Generators and For Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n",
      "g\n",
      "h\n",
      "i\n",
      "j\n",
      "k\n",
      "l\n",
      "m\n",
      "n\n",
      "o\n",
      "p\n",
      "q\n",
      "r\n",
      "s\n",
      "t\n",
      "u\n",
      "v\n",
      "w\n",
      "x\n",
      "y\n"
     ]
    }
   ],
   "source": [
    "# Use a for loop to iterate over the iterable object returned by our letter sequence generator function\n",
    "alphabet = letter_sequence_generator(\"a\", \"z\")\n",
    "for letter in alphabet:\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4. Generator Expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Use a generator expression to create a lazily evaluated iterable object\n",
    "first_million_numbers = (num for num in range(1, 1_000_000))\n",
    "print(next(first_million_numbers))\n",
    "print(next(first_million_numbers))\n",
    "print(next(first_million_numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.5. Generator Objects as Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y']\n"
     ]
    }
   ],
   "source": [
    "# Create a lazily evaluated generator object\n",
    "alphabet = letter_sequence_generator(\"a\", \"z\")\n",
    "\n",
    "# Convert the generator object into a list\n",
    "alphabet_list = list(alphabet)\n",
    "print(alphabet_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Lambda Functions\n",
    "#### 3.1. Defining Lambda Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n"
     ]
    }
   ],
   "source": [
    "# Create a simple lambda function to square a given number\n",
    "square = lambda n: n * n\n",
    "\n",
    "# Call this lambda function\n",
    "print(square(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150\n"
     ]
    }
   ],
   "source": [
    "# Create a simple lambda function with three arguments\n",
    "product = lambda x, y, z: x * y * z\n",
    "\n",
    "# Call this lambda function\n",
    "print(product(3, 10, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2. Using Lambda Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of numbers\n",
    "my_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "# Use the imperative paradigm to filter the list of integers, keeping only the even numbers\n",
    "def filter_evens_imperative(number_list):\n",
    "    even_number_list = []\n",
    "    for number in number_list:\n",
    "        if number % 2 == 0:\n",
    "            even_number_list.append(number)\n",
    "    return even_number_list\n",
    "\n",
    "# Filter the list of numbers, keeping only the even numbers\n",
    "even_numbers = filter_evens_imperative(my_numbers)\n",
    "print(even_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Use a functional approach to filter the same list of integers\n",
    "even_numbers = list(filter(lambda num: num % 2 == 0, my_numbers))\n",
    "print(even_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.1. User Defined Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "400\n"
     ]
    }
   ],
   "source": [
    "# Create a Python function containing a lambda anonymous function\n",
    "def multiply(multiplier):\n",
    "    return lambda x: x * multiplier\n",
    "\n",
    "# Instantiate a function that always doubles a given number\n",
    "doubler = multiply(2)\n",
    "\n",
    "# Call this function with the value 10\n",
    "print(doubler(10))\n",
    "\n",
    "# Instantiate a function that always quadruples a given number\n",
    "quadrupler = multiply(4)\n",
    "\n",
    "# Call this function with the value 100\n",
    "print(quadrupler(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.2. Filter Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of numbers\n",
    "my_numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "# Create a function that will test whether a given number is even or not\n",
    "def test_even(num):\n",
    "    if num % 2 == 0:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "# Apply this function to the list of numbers using the filter() function\n",
    "my_even_numbers = list(filter(test_even, my_numbers))\n",
    "print(my_even_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# Use a lambda function within filter() to perform the same task\n",
    "my_even_numbers = list(filter(lambda num: num % 2 == 0, my_numbers))\n",
    "print(my_even_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.3. Map Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 9, 4, 25, 6, 49, 8, 81, 10]\n"
     ]
    }
   ],
   "source": [
    "# Create a function that will square a given number but only if that number is odd\n",
    "def square_odd_number(num):\n",
    "    if num % 2 == 0:\n",
    "        return num\n",
    "    return num * num\n",
    "\n",
    "# Apply this function to the list of numbers using the map() function\n",
    "my_squared_odd_numbers = list(map(square_odd_number, my_numbers))\n",
    "print(my_squared_odd_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 9, 4, 25, 6, 49, 8, 81, 10]\n"
     ]
    }
   ],
   "source": [
    "# Use a lambda function within map() to perform the same task\n",
    "my_squared_odd_numbers = list(map(lambda num: num if num % 2 == 0 else num * num, my_numbers))\n",
    "print(my_squared_odd_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.4. Reduce Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3628800\n",
      "7257600\n",
      "36288000\n"
     ]
    }
   ],
   "source": [
    "from functools import reduce \n",
    "\n",
    "# Create a function that will calculate the product of two given numbers\n",
    "def product(a, b):\n",
    "    return a * b\n",
    "\n",
    "# Apply this function to the list of numbers using the reduce() function\n",
    "my_product_of_numbers = reduce(product, my_numbers)\n",
    "print(my_product_of_numbers)\n",
    "\n",
    "# Apply this function to the list of numbers using the reduce() function and an initializer value of 2\n",
    "my_product_of_numbers = reduce(product, my_numbers, 2)\n",
    "print(my_product_of_numbers)\n",
    "\n",
    "# Apply this function to the list of numbers using the reduce() function and an initializer value of 10\n",
    "my_product_of_numbers = reduce(product, my_numbers, 10)\n",
    "print(my_product_of_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3628800\n"
     ]
    }
   ],
   "source": [
    "# Use a lambda function within reduce() to perform the same task\n",
    "my_product_of_numbers = reduce(lambda a, b: a * b, my_numbers)\n",
    "print(my_product_of_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.5. Sorted Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 7, 8, 13, 38, 48, 88, 99, 100]\n",
      "[100, 99, 88, 48, 38, 13, 8, 7, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of unordered numbers\n",
    "my_unordered_numbers = [2, 100, 99, 3, 7, 8, 13, 48, 88, 38]\n",
    "\n",
    "# Sort the list of numbers\n",
    "sorted_numbers = sorted(my_unordered_numbers)\n",
    "print(sorted_numbers)\n",
    "\n",
    "# Sort the list of numbers in descending order\n",
    "sorted_numbers_desc = sorted(my_unordered_numbers, reverse=True)\n",
    "print(sorted_numbers_desc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Arsenal', 90, 73, 26), ('Chelsea', 79, 67, 30), ('Manchester United', 75, 64, 35), ('Liverpool', 60, 55, 37), ('Newcastle United', 56, 52, 40), ('Aston Villa', 56, 48, 44)]\n"
     ]
    }
   ],
   "source": [
    "# Create a list of tuples modelling a football league (team name, total points, total goals scored, total goals conceded)\n",
    "completed_football_league = [\n",
    "    ('Manchester United', 75, 64, 35), \n",
    "    ('Aston Villa', 56, 48, 44), \n",
    "    ('Arsenal', 90, 73, 26), \n",
    "    ('Newcastle United', 56, 52, 40), \n",
    "    ('Liverpool', 60, 55, 37), \n",
    "    ('Chelsea', 79, 67, 30)\n",
    "]\n",
    "\n",
    "# Create a function to create a compound sorting key\n",
    "def sorting_key(item):\n",
    "    total_points = item[1]\n",
    "    goal_difference = item[2] - item[3]\n",
    "    return (total_points, goal_difference)\n",
    "\n",
    "# Use this sorting function with the sorted() function to sort the football league by multiple keys i.e. total points and goal difference\n",
    "sorted_football_league = sorted(completed_football_league, key=sorting_key, reverse=True)\n",
    "print(sorted_football_league)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Arsenal', 90, 73, 26), ('Chelsea', 79, 67, 30), ('Manchester United', 75, 64, 35), ('Liverpool', 60, 55, 37), ('Newcastle United', 56, 52, 40), ('Aston Villa', 56, 48, 44)]\n"
     ]
    }
   ],
   "source": [
    "# Use a lambda function within sorted() as the key function to perform the same task\n",
    "sorted_football_league = sorted(completed_football_league, key=lambda item: (item[1], item[2] - item[3]), reverse=True)\n",
    "print(sorted_football_league)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.6. Reversed Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
      "[20, 19, 18, 17, 16, 15, 14, 13, 12, 11]\n",
      "['a', 'r', 'b', 'a', 'd', 'a', 'c', 'a', 'r', 'b', 'a']\n"
     ]
    }
   ],
   "source": [
    "# Use the reversed() function to return a reversed iterable object\n",
    "my_reversed_numbers = list(reversed(my_numbers))\n",
    "print(my_reversed_numbers)\n",
    "\n",
    "# Reverse a range of numbers\n",
    "my_range = range(11, 21)\n",
    "my_reversed_range = list(reversed(my_range))\n",
    "print(my_reversed_range)\n",
    "\n",
    "# Reverse the characters in a string\n",
    "my_string = 'abracadabra'\n",
    "my_reversed_string = list(reversed(my_string))\n",
    "print(my_reversed_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.7. Sort Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Arsenal', 90, 73, 26), ('Chelsea', 79, 67, 30), ('Manchester United', 75, 64, 35), ('Liverpool', 60, 55, 37), ('Newcastle United', 56, 52, 40), ('Aston Villa', 56, 48, 44)]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "# Create a deepcopy of the previous list of tuples representing a football league\n",
    "completed_football_league_deep_copy_1 = copy.deepcopy(completed_football_league)\n",
    "\n",
    "# Sort the previous list of tuples representing a football league using the list sort() method\n",
    "completed_football_league_deep_copy_1.sort(reverse=True, key=sorting_key)\n",
    "print(completed_football_league_deep_copy_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Arsenal', 90, 73, 26), ('Chelsea', 79, 67, 30), ('Manchester United', 75, 64, 35), ('Liverpool', 60, 55, 37), ('Newcastle United', 56, 52, 40), ('Aston Villa', 56, 48, 44)]\n"
     ]
    }
   ],
   "source": [
    "# Use a lambda function within the list sort() method as the key function to perform the same task\n",
    "completed_football_league_deep_copy_2 = copy.deepcopy(completed_football_league)\n",
    "completed_football_league_deep_copy_2.sort(reverse=True, key=lambda item: (item[1], item[2] - item[3]))\n",
    "print(completed_football_league_deep_copy_2)"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}