Python-Functions and Loops.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.7.3"
    },
    "colab": {
      "name": "Functions and Loops.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hfyHg4oR5ulY",
        "colab_type": "text"
      },
      "source": [
        "##  Defining Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9IHywU4A5ulZ",
        "colab_type": "text"
      },
      "source": [
        "**Define a function with no arguments and no return values:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I46yUqwH5ulc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def print_text():\n",
        "    print('this is text')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4fpv73IQ5ulh",
        "colab_type": "code",
        "outputId": "5c182955-a788-4e73-aa51-431348166223",
        "colab": {}
      },
      "source": [
        "# call the function\n",
        "print_text()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "this is text\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IVbCvwjn5ull",
        "colab_type": "text"
      },
      "source": [
        "**Define a function with one argument and no return values:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qkU7dMo55ull",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def print_this(x):\n",
        "    print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p-YiGua45ulo",
        "colab_type": "code",
        "outputId": "639ec64c-8415-462c-d7ba-fa0987c6bb42",
        "colab": {}
      },
      "source": [
        "# call the function\n",
        "print_this(3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T5-247FY5ulp",
        "colab_type": "code",
        "outputId": "c125a5f6-c88a-4c38-dd09-48a7c91c09e7",
        "colab": {}
      },
      "source": [
        "# prints 3, but doesn't assign 3 to n because the function has no return statement\n",
        "n = print_this(3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gQcMucz15ulw",
        "colab_type": "text"
      },
      "source": [
        "**Define a function with one argument and one return value:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "THEMBmXI5ulx",
        "colab_type": "code",
        "outputId": "1bf02d6f-57ef-4122-a7f1-da3285a7ce58",
        "colab": {}
      },
      "source": [
        "def square_this(x):\n",
        "    return x**2\n",
        "square_this(5)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "25"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ivPPcHU65ul0",
        "colab_type": "code",
        "outputId": "b0229f80-2327-48db-de09-514723c175b2",
        "colab": {}
      },
      "source": [
        "# include an optional docstring to describe the effect of a function\n",
        "def square_this(x):\n",
        "    \"\"\"Return the square of a number.\"\"\"\n",
        "    return x**2\n",
        "print(square_this.__doc__)    # .__doc__  returns the docstring"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Return the square of a number.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZzsACe1f5ul3",
        "colab_type": "code",
        "outputId": "a188567c-d85f-4631-848c-249b4f0196a1",
        "colab": {}
      },
      "source": [
        "# call the function\n",
        "square_this(3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n2EQGPp25ul5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# assigns 9 to var, but does not print 9\n",
        "var = square_this(3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "amy1PjGP5ul8",
        "colab_type": "text"
      },
      "source": [
        "**Define a function with two 'positional arguments' (no default values) and one 'keyword argument' (has a default value):**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ne0NdmCn5ul9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def calc(a, b, op='add'):\n",
        "    if op == 'add':\n",
        "        return a + b\n",
        "    elif op == 'sub':\n",
        "        return a - b\n",
        "    else:\n",
        "        print('valid operations are add and sub')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fn1vJPZs5umA",
        "colab_type": "code",
        "outputId": "c878f5ac-869c-4a9a-bf86-2ef0ac3ec4f8",
        "colab": {}
      },
      "source": [
        "# call the function\n",
        "calc(10, 4, op='add')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MVEKLpzd5umF",
        "colab_type": "code",
        "outputId": "9b8c79f4-af7e-4a86-e68d-2081bbee6b0d",
        "colab": {}
      },
      "source": [
        "# unnamed arguments are inferred by position\n",
        "calc(10, 4, 'add')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 83
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8UZEA5qg5umI",
        "colab_type": "code",
        "outputId": "38d47faa-d8f7-4f6f-9f00-c1f4b19b89ce",
        "colab": {}
      },
      "source": [
        "# default for 'op' is 'add'\n",
        "calc(10, 4)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XfEQ2sig5umM",
        "colab_type": "code",
        "outputId": "98d78cda-abc9-4be4-ba0e-377f2b0f6d85",
        "colab": {}
      },
      "source": [
        "calc(10, 4, 'sub')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4hVuTWf5umP",
        "colab_type": "code",
        "outputId": "4d486c89-cebd-49d1-e3a9-5e2441b48535",
        "colab": {}
      },
      "source": [
        "calc(10, 4, 'div')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "valid operations are add and sub\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ub2SyYB55umV",
        "colab_type": "text"
      },
      "source": [
        "**Use `pass` as a placeholder if you haven't written the function body:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O8qSATkY5umW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def stub():\n",
        "    pass"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Axi5vjsk5umb",
        "colab_type": "text"
      },
      "source": [
        "**Return two values from a single function:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "el-2-Lk_5umc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def min_max(nums):\n",
        "    return min(nums), max(nums)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WMoqOQs35ume",
        "colab_type": "code",
        "outputId": "c04e25a2-7aec-40fb-fc93-2097084cf32e",
        "colab": {}
      },
      "source": [
        "# return values can be assigned to a single variable as a tuple\n",
        "nums = [1, 2, 3]\n",
        "min_max_num = min_max(nums)\n",
        "min_max_num"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2tXlOKLF5umf",
        "colab_type": "code",
        "outputId": "1753239f-7829-409f-b7d1-26d6caac204a",
        "colab": {}
      },
      "source": [
        "# return values can be assigned into multiple variables using tuple unpacking\n",
        "min_num, max_num = min_max(nums)\n",
        "print(min_num)\n",
        "print(max_num)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3eUFi8Xx5umi",
        "colab_type": "text"
      },
      "source": [
        "## Anonymous (Lambda) Functions\n",
        "\n",
        "- Primarily used to temporarily define a function for use by another function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eWwdJ1Nb5umj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# define a function the \"usual\" way\n",
        "def squared(x):\n",
        "    return x**2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DmG4OPz05umk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# define an identical function using lambda\n",
        "squared = lambda x: x**2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uyba0p_P5umm",
        "colab_type": "text"
      },
      "source": [
        "**Sort a list of strings by the last letter:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VVD_0Zc25umo",
        "colab_type": "code",
        "outputId": "1cb1b04f-bb0d-456d-a5a1-75832e6b5b33",
        "colab": {}
      },
      "source": [
        "# without using lambda\n",
        "simpsons = ['homer', 'marge', 'bart']\n",
        "def last_letter(word):\n",
        "    return word[-1]\n",
        "sorted(simpsons, key=last_letter)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['marge', 'homer', 'bart']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 93
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g2o_Ysqy5umq",
        "colab_type": "code",
        "outputId": "d786c86d-25d6-4e94-fd30-d75e45b5dcec",
        "colab": {}
      },
      "source": [
        "# using lambda\n",
        "sorted(simpsons, key=lambda word: word[-1])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['marge', 'homer', 'bart']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XRfKTbC35ums",
        "colab_type": "code",
        "outputId": "f837208a-aadd-4e91-d970-c8dab3d5a201",
        "colab": {}
      },
      "source": [
        "##  For Loops and While Loops\n",
        "\n",
        "# includes the start value but excludes the stop value\n",
        "range(0, 3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(0, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h3jrrML55umt",
        "colab_type": "code",
        "outputId": "87812411-631c-47ab-bab9-3986825eee56",
        "colab": {}
      },
      "source": [
        "# default start value is 0\n",
        "range(3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(0, 3)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RhMhcKBl5umx",
        "colab_type": "code",
        "outputId": "94d631ff-73ee-4f89-f045-437e67d3a5db",
        "colab": {}
      },
      "source": [
        "# third argument is the step value\n",
        "range(0, 5, 2)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(0, 5, 2)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 97
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nCJKto4f5um0",
        "colab_type": "text"
      },
      "source": [
        "**`for` loops:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vfDmYNUe5um0",
        "colab_type": "code",
        "outputId": "71cc1f41-543d-4b77-f820-85cc1fd75623",
        "colab": {}
      },
      "source": [
        "# not the recommended style\n",
        "fruits = ['apple', 'banana', 'cherry']\n",
        "for i in range(len(fruits)):\n",
        "    print(fruits[i].upper())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "APPLE\n",
            "BANANA\n",
            "CHERRY\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_51Qj55y5um2",
        "colab_type": "code",
        "outputId": "58adfe87-8ec2-4bd1-8838-f893154d6119",
        "colab": {}
      },
      "source": [
        "# recommended style\n",
        "for fruit in fruits:\n",
        "    print(fruit.upper())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "APPLE\n",
            "BANANA\n",
            "CHERRY\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GMxO62QT5um3",
        "colab_type": "code",
        "outputId": "4a074f6f-5589-4cb4-9988-902c48140803",
        "colab": {}
      },
      "source": [
        "# iterate through two things at once (using tuple unpacking)\n",
        "family = {'dad':'homer', 'mom':'marge', 'size':6}\n",
        "for key, value in family.items():\n",
        "    print(key, value)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dad homer\n",
            "mom marge\n",
            "size 6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fiUIdnVy5um5",
        "colab_type": "code",
        "outputId": "44ceecd1-64ae-4fcd-9079-e4d0669143ab",
        "colab": {}
      },
      "source": [
        "# use enumerate if you need to access the index value within the loop\n",
        "for index, fruit in enumerate(fruits):\n",
        "    print(index, fruit)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 apple\n",
            "1 banana\n",
            "2 cherry\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oPon-Y5D5um7",
        "colab_type": "text"
      },
      "source": [
        "**`for`/`else` loop:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jRFhlQLm5um8",
        "colab_type": "code",
        "outputId": "0fe024a5-2f39-42b9-985d-16c1a349ff9d",
        "colab": {}
      },
      "source": [
        "for fruit in fruits:\n",
        "    if fruit == 'banana':\n",
        "        print('Found the banana!')\n",
        "        break    # exit the loop and skip the 'else' block\n",
        "else:\n",
        "    # this block executes ONLY if the for loop completes without hitting 'break'\n",
        "    print(\"Can't find the banana\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Found the banana!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-XmROgTD5um9",
        "colab_type": "text"
      },
      "source": [
        "**`while` loop:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "82kSn7al5um-",
        "colab_type": "code",
        "outputId": "0c3c2115-ea83-4232-95ff-9892c3a69d79",
        "colab": {}
      },
      "source": [
        "count = 0\n",
        "while count < 5:\n",
        "    print('This will print 5 times')\n",
        "    count += 1    # equivalent to 'count = count + 1'"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This will print 5 times\n",
            "This will print 5 times\n",
            "This will print 5 times\n",
            "This will print 5 times\n",
            "This will print 5 times\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b1NjwTFc5unB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "## Comprehensions"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qUCp3uDh5unD",
        "colab_type": "text"
      },
      "source": [
        "**List comprehension:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f_oMkLsL5unE",
        "colab_type": "code",
        "outputId": "e50b7456-2dbb-4e9d-ece0-6895914c2ad1",
        "colab": {}
      },
      "source": [
        "# for loop to create a list of cubes\n",
        "nums = [1, 2, 3, 4, 5]\n",
        "cubes = []\n",
        "for num in nums:\n",
        "    cubes.append(num**3)\n",
        "cubes"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 8, 27, 64, 125]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8lc7Qvtb5unJ",
        "colab_type": "code",
        "outputId": "80273542-be9b-4cad-fc54-f073b1a0df3f",
        "colab": {}
      },
      "source": [
        "# equivalent list comprehension\n",
        "cubes = [num**3 for num in nums]\n",
        "cubes"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 8, 27, 64, 125]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 106
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vO27uV8f5unN",
        "colab_type": "code",
        "outputId": "fd980860-2ac4-48af-896c-a586bb7e3e55",
        "colab": {}
      },
      "source": [
        "# for loop to create a list of cubes of even numbers\n",
        "cubes_of_even = []\n",
        "for num in nums:\n",
        "    if num % 2 == 0:\n",
        "        cubes_of_even.append(num**3)\n",
        "cubes_of_even"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[8, 64]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-xmln5Oi5unP",
        "colab_type": "code",
        "outputId": "bd136ec0-ca57-4fe0-d394-8af7e8ad3390",
        "colab": {}
      },
      "source": [
        "# equivalent list comprehension\n",
        "# syntax: [expression for variable in iterable if condition]\n",
        "cubes_of_even = [num**3 for num in nums if num % 2 == 0]\n",
        "cubes_of_even"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[8, 64]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hfh8smM65unS",
        "colab_type": "code",
        "outputId": "59536259-b45c-438a-8ae1-e03d70fde6e8",
        "colab": {}
      },
      "source": [
        "# for loop to cube even numbers and square odd numbers\n",
        "cubes_and_squares = []\n",
        "for num in nums:\n",
        "    if num % 2 == 0:\n",
        "        cubes_and_squares.append(num**3)\n",
        "    else:\n",
        "        cubes_and_squares.append(num**2)\n",
        "cubes_and_squares"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 8, 9, 64, 25]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SXBrPCtp5unU",
        "colab_type": "code",
        "outputId": "505c79d6-f3e0-41a3-e5de-475567017b40",
        "colab": {}
      },
      "source": [
        "# equivalent list comprehension (using a ternary expression)\n",
        "# syntax: [true_condition if condition else false_condition for variable in iterable]\n",
        "cubes_and_squares = [num**3 if num % 2 == 0 else num**2 for num in nums]\n",
        "cubes_and_squares"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 8, 9, 64, 25]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6crASnuX5una",
        "colab_type": "code",
        "outputId": "e1ebabcf-f457-4cfb-cb1a-7e9561eb75f4",
        "colab": {}
      },
      "source": [
        "# for loop to flatten a 2d-matrix\n",
        "matrix = [[1, 2], [3, 4]]\n",
        "items = []\n",
        "for row in matrix:\n",
        "    for item in row:\n",
        "        items.append(item)\n",
        "items"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 111
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TPUWv5YB5und",
        "colab_type": "code",
        "outputId": "72e70944-60be-4ad3-cae4-40a37e7746a3",
        "colab": {}
      },
      "source": [
        "# equivalent list comprehension\n",
        "items = [item for row in matrix\n",
        "              for item in row]\n",
        "items"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 112
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bkGO1Bsi5ung",
        "colab_type": "text"
      },
      "source": [
        "**Set comprehension:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JN3eDEad5unh",
        "colab_type": "code",
        "outputId": "5d9b8f45-eea9-4c3b-994b-4a73f5d17a61",
        "colab": {}
      },
      "source": [
        "fruits = ['apple', 'banana', 'cherry']\n",
        "unique_lengths = {len(fruit) for fruit in fruits}\n",
        "unique_lengths"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{5, 6}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 113
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GR0stiCV5unj",
        "colab_type": "text"
      },
      "source": [
        "**Dictionary comprehension:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j2otzvgF5unk",
        "colab_type": "code",
        "outputId": "5fe76fb9-5260-4c80-d0fb-00f0ab7bbd43",
        "colab": {}
      },
      "source": [
        "fruit_lengths = {fruit:len(fruit) for fruit in fruits}\n",
        "fruit_lengths\n",
        "\n",
        "fruit_indices = {fruit:index for index, fruit in enumerate(fruits)}\n",
        "fruit_indices"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'apple': 0, 'banana': 1, 'cherry': 2}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kXrIAjuo5unl",
        "colab_type": "text"
      },
      "source": [
        "##  Map, Filter and Reduce"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N8wDiRqv5unm",
        "colab_type": "text"
      },
      "source": [
        "**`map` applies a function to every element of a sequence and returns a list (Python 2) or iterator (Python 3):**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x5MD2wD85unn",
        "colab_type": "code",
        "outputId": "f9446eb6-2496-4df9-ca4f-9d10315f2ae9",
        "colab": {}
      },
      "source": [
        "simpsons = ['homer', 'marge', 'bart']\n",
        "mapper = map(len, simpsons)\n",
        "mapper"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<map at 0x1f9af3b6438>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5hXY5pQi5unq",
        "colab_type": "code",
        "outputId": "5a6c8fa3-f23b-422d-eb51-64089169e32f",
        "colab": {}
      },
      "source": [
        "for i in mapper:\n",
        "    print(i)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            "5\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W3Y6zpR95unv",
        "colab_type": "code",
        "outputId": "9bd3bc38-ffdc-48b4-81b2-09a6f88d910c",
        "colab": {}
      },
      "source": [
        "# equivalent list comprehension\n",
        "[len(word) for word in simpsons]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 5, 4]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9th1Kgma5uny",
        "colab_type": "code",
        "outputId": "234b2402-5ba3-4917-eb58-c4d12b1c054b",
        "colab": {}
      },
      "source": [
        "mapper = map(lambda word: word[-1], simpsons)\n",
        "for i in mapper:\n",
        "    print(i)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "r\n",
            "e\n",
            "t\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QFBn95JI5un0",
        "colab_type": "code",
        "outputId": "24714856-b4de-4109-c07c-98fef8e191d6",
        "colab": {}
      },
      "source": [
        "# equivalent list comprehension\n",
        "[word[-1] for word in simpsons]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['r', 'e', 't']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 117
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HJ6unc_N5un4",
        "colab_type": "text"
      },
      "source": [
        "**`filter` returns a list (Python 2) or iterator (Python 3) containing the elements from a sequence for which a condition is `True`:**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2bed5vJo5un5",
        "colab_type": "code",
        "outputId": "940ab69f-a1c6-4ef1-fb67-46c7843e07c8",
        "colab": {}
      },
      "source": [
        "nums = range(5)\n",
        "iterator = filter(lambda x: x % 2 == 0, nums) \n",
        "for element in iterator:\n",
        "    print(element)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "2\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NwNArNco5uoB",
        "colab_type": "code",
        "outputId": "990c8c40-6d6e-4505-ef37-3eedd496d8e4",
        "colab": {}
      },
      "source": [
        "# equivalent list comprehension\n",
        "[num for num in nums if num % 2 == 0]"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 2, 4]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 119
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cjzCLdjd5uoD",
        "colab_type": "text"
      },
      "source": [
        "**`Reduce` returns a single value after applying a function on an iterable**\n",
        "example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n",
        "((((1+2)+3)+4)+5). "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w1RwcrQz5uoD",
        "colab_type": "code",
        "outputId": "94ad67ff-4937-4907-cf23-25b41b93693d",
        "colab": {}
      },
      "source": [
        "from functools import reduce\n",
        "\n",
        "data = [1,2,3,4]\n",
        "reduce(lambda x,y: x * y, data)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NIwJOvm85uoE",
        "colab_type": "text"
      },
      "source": [
        "## Loops"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qoKdhipk5uoE",
        "colab_type": "text"
      },
      "source": [
        "**for-each loop**\n",
        "- In python, the for loop is called 'for each loop' ( that is the way we read it. \"for each element in iterable\")\n",
        "- We use it to iterate over a series, list, string etc any iterable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kDUNDYB35uoF",
        "colab_type": "code",
        "outputId": "b750313d-0ec0-4748-9cb3-0f0585a07b98",
        "colab": {}
      },
      "source": [
        "# print each elemt of a list using for loop\n",
        "a = [1,2,3,4,5,6]  \n",
        "\n",
        "for element in a:\n",
        "    print(element)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TRhDRL_a5uoG",
        "colab_type": "code",
        "outputId": "08b035bc-9291-48e8-c947-767e3569b176",
        "colab": {}
      },
      "source": [
        "# square each element of a list and append to a new list\n",
        "b = []  # empty list\n",
        "for element in a:\n",
        "    b.append(element*element)\n",
        "    \n",
        "print(b)    "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 4, 9, 16, 25, 36]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_6csInMk5uoH",
        "colab_type": "code",
        "outputId": "c70a8e79-c8e8-4e37-aac3-e4bea58e276c",
        "colab": {}
      },
      "source": [
        "# populate a dictionary using a for loop\n",
        "name = ['joe', 'jonas', 'Kit', 'Harrington', 'Liam', 'Neeson']\n",
        "weight = [15, 18, 17, 22, 25, 23]\n",
        "dictionary = {}\n",
        "\n",
        "for i in range(0,6):\n",
        "    dictionary[name[i]] = weight[i]\n",
        "\n",
        "dictionary"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'joe': 15, 'jonas': 18, 'Kit': 17, 'Harrington': 22, 'Liam': 25, 'Neeson': 23}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 127
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4jeVr355uoI",
        "colab_type": "code",
        "outputId": "a1b99062-21d8-4e64-fec6-6b42ee55e513",
        "colab": {}
      },
      "source": [
        "# Lets print some shapes to get comfortable with loops\n",
        "\n",
        "# pyramid\n",
        "for i in range(10):\n",
        "    print((10-i)*' ' + i*'* ')\n",
        "\n",
        "# half diamond\n",
        "for i in range(10):\n",
        "    if i < 6:\n",
        "        print(i*' *')\n",
        "    else:\n",
        "        print((10 - i)*' *')\n",
        "\n",
        "# full diamond\n",
        "for i in range(10):\n",
        "    if i < 6:\n",
        "        print((10-i)*' ' + i*'* ')\n",
        "    else:\n",
        "        print((i*' ' + (10 - i)*'* '))\n",
        "    "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "          \n",
            "         * \n",
            "        * * \n",
            "       * * * \n",
            "      * * * * \n",
            "     * * * * * \n",
            "    * * * * * * \n",
            "   * * * * * * * \n",
            "  * * * * * * * * \n",
            " * * * * * * * * * \n",
            "\n",
            " *\n",
            " * *\n",
            " * * *\n",
            " * * * *\n",
            " * * * * *\n",
            " * * * *\n",
            " * * *\n",
            " * *\n",
            " *\n",
            "          \n",
            "         * \n",
            "        * * \n",
            "       * * * \n",
            "      * * * * \n",
            "     * * * * * \n",
            "      * * * * \n",
            "       * * * \n",
            "        * * \n",
            "         * \n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}