python_in_one_page.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "python-in-one-page.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "dJIZpYWK7Qkp"
      ],
      "authorship_tag": "ABX9TyO9mDLapZQvMhC6p3P/0XB3",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/andredarcie/python-in-one-page/blob/master/python_in_one_page.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ufmoz5FB7IBt",
        "colab_type": "text"
      },
      "source": [
        "# 📜 Python in one page"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dJIZpYWK7Qkp",
        "colab_type": "text"
      },
      "source": [
        "## What is Python?\n",
        "\n",
        "Python is a popular programming language. It was created by Guido van Rossum, and released in 1991.\n",
        "\n",
        "To focus on the language itself this guide not includes any built-in modules like math, random, datetime, json, re, random, etc"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Ry3S_PficPi",
        "colab_type": "text"
      },
      "source": [
        "## 🧘 The Zen of Python\n",
        "The Zen of Python is a collection of 19 **guiding principles** for writing computer programs that influence the design of the Python programming language."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cO-Y8VZKibg_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 374
        },
        "outputId": "2622fb4d-3675-4e76-edd9-6cab29bfb4c5"
      },
      "source": [
        "import this"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The Zen of Python, by Tim Peters\n",
            "\n",
            "Beautiful is better than ugly.\n",
            "Explicit is better than implicit.\n",
            "Simple is better than complex.\n",
            "Complex is better than complicated.\n",
            "Flat is better than nested.\n",
            "Sparse is better than dense.\n",
            "Readability counts.\n",
            "Special cases aren't special enough to break the rules.\n",
            "Although practicality beats purity.\n",
            "Errors should never pass silently.\n",
            "Unless explicitly silenced.\n",
            "In the face of ambiguity, refuse the temptation to guess.\n",
            "There should be one-- and preferably only one --obvious way to do it.\n",
            "Although that way may not be obvious at first unless you're Dutch.\n",
            "Now is better than never.\n",
            "Although never is often better than *right* now.\n",
            "If the implementation is hard to explain, it's a bad idea.\n",
            "If the implementation is easy to explain, it may be a good idea.\n",
            "Namespaces are one honking great idea -- let's do more of those!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Rwa7_m_7aXn",
        "colab_type": "text"
      },
      "source": [
        "Make a simple hello world"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mjkYYWFp7DSp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "70113632-3497-4e85-dac5-c0f968f5540e"
      },
      "source": [
        "print('Hello, World!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6752HQqs7AjA",
        "colab_type": "text"
      },
      "source": [
        "**Help**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z6z6XqsJ7DE2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 221
        },
        "outputId": "4c50cb84-beca-4478-8abf-7fb4b7cfd8f0"
      },
      "source": [
        "help(print)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on built-in function print in module builtins:\n",
            "\n",
            "print(...)\n",
            "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
            "    \n",
            "    Prints the values to a stream, or to sys.stdout by default.\n",
            "    Optional keyword arguments:\n",
            "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
            "    sep:   string inserted between values, default a space.\n",
            "    end:   string appended after the last value, default a newline.\n",
            "    flush: whether to forcibly flush the stream.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6rVqe_fh7MX1",
        "colab_type": "text"
      },
      "source": [
        "**Comments**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IGRidkbj7OjW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#This is a comment"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PZ-DoyxH7WSq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e6c7d410-9e00-4a4b-90c0-a0af56de77aa"
      },
      "source": [
        "#Variables\n",
        "name = 'John'\n",
        "age = 42\n",
        "\n",
        "x, y, z = 1, 2, 3\n",
        "\n",
        "print('Name: ' + name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Name: John\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C8CXc0xAReQy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "c6d0c9ae-ba27-445d-9997-f4706a033f21"
      },
      "source": [
        "# User input\n",
        "# favorite_comedy_series = input('Enter your favorite comedy series: \\n')\n",
        "# print(favorite_comedy_series)\n",
        "# output: Monty Python's Flying Circus"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter your favorite comedy series: \n",
            "legal\n",
            "legal\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G8TtGB3N7ZSE",
        "colab_type": "text"
      },
      "source": [
        "## 🔣 Data Types\n",
        "\n",
        "Python has the following data types built-in by **default**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wVZZdlFiLgDV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e694b38c-f499-4357-b913-6c99537eb967"
      },
      "source": [
        "my_number = 42\n",
        "print(type(my_number))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iotFWEk57agM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Text\n",
        "my_string = 'Hello World'\n",
        "\n",
        "# Numeric\n",
        "my_integer_number = 20\n",
        "my_float_number = 20.5\n",
        "my_complex_number = 1j\n",
        "\n",
        "# Sequence\n",
        "my_list = ['apple', 'banana', 'cherry']\n",
        "my_tuple = ('apple', 'banana', 'cherry') # immutable sequence \n",
        "my_other_tuple = tuple(('apple', 'banana', 'cherry')) # immutable sequence \n",
        "my_range = range(4) # range(0, 4)\n",
        "\n",
        "# Mapping\n",
        "my_dictionary = {'name' : 'John', 'age' : 36}\n",
        "my_other_dictionary = dict(name='John', age=36)\n",
        "\n",
        "# Set - No duplicate members\n",
        "my_set_value = {\"apple\", \"banana\", \"cherry\"}\n",
        "my_other_set_value = set({\"apple\", \"banana\", \"cherry\"})\n",
        "my_frozenset_value = frozenset({\"apple\", \"banana\", \"cherry\"})\n",
        "\n",
        "# Boolean\n",
        "my_boolean = True # Can be True of False\n",
        "bool(0) # Return a Boolean value\n",
        "\n",
        "# Binary\n",
        "my_bytes = b\"Hello\"\n",
        "my_bytearray = bytearray(5) # bytearray(b'\\x00\\x00\\x00\\x00\\x00')\n",
        "my_memoryview = memoryview(bytes(5)) # <memory at 0x01368FA0>"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M4kgxFxk8GaG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4d8fcdd6-25a7-473c-bd28-147c28ce9880"
      },
      "source": [
        "# Convert an integer number to a binary\n",
        "print(bin(2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0b10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UU1EIDks8KUT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f394e297-467a-4634-abee-f1ca4c032b5c"
      },
      "source": [
        "# Convert an integer number to an octal\n",
        "print(oct(8))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0o10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BeyAQirc8MQp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c197f7cd-521a-401a-fa17-45e0b4901753"
      },
      "source": [
        "print(type(string))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JlzDEc158Pdp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f2280c89-4662-466c-9a57-0af4f6d9a239"
      },
      "source": [
        "print(int('1'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XzMz1ZE892MK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ceaf2483-dd5d-4716-c6d0-191c08225b36"
      },
      "source": [
        "print(float(1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yy4X6975CIxW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "89017586-ad6d-4623-ce2d-1cc1772ad39c"
      },
      "source": [
        "# Convert an integer number to a lowercase hexadecimal string prefixed with '0x'\n",
        "print(hex(255))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0xff\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6yN8uJDo8ScS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "28ec9cfc-ac1a-4461-a9d7-c898b6382f84"
      },
      "source": [
        "# Represents a null value\n",
        "x = None\n",
        "print(x) # None"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "None\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ki_-evek8g9Y",
        "colab_type": "text"
      },
      "source": [
        "## 🧵 Strings\n",
        "A **string** is a sequence of Unicode **characters**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n0Gtmes68ihx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8e85a7da-4a92-41f7-f7b8-335a9bba89cf"
      },
      "source": [
        "hello = 'Hello, World! '\n",
        "print(hello[0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "H\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UxAvDzvC8mBR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0714ce62-2f50-4d53-8039-1a1891534814"
      },
      "source": [
        "print(hello[-2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O2i6hLn78tDw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "2c5268ff-cbbf-4db4-adb0-f01b47448a5b"
      },
      "source": [
        "print(hello[2:5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "llo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iOGWD9TT8wQM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "905edb4f-0ba9-4ccb-f8de-c4be9b3ac39f"
      },
      "source": [
        "print(len(hello)) # returns the size of hello"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "14\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DFt2XEB481u4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "cce9a887-a155-418e-a3a1-0df2762aae2a"
      },
      "source": [
        "print(hello.strip()) # removes whitespaces"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u-yfaZX386jR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6ff7c689-d28d-4f27-bf5f-57ec9cb51830"
      },
      "source": [
        "print(hello.lower())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello, world! \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b4M3ACDG87Xh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a41021d8-1b5b-416e-d808-38c61b64d20b"
      },
      "source": [
        "print(hello.upper())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "HELLO, WORLD! \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SbIe4Xwk89eS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ed3784d2-6dfc-44f2-d12d-ee70c05c7225"
      },
      "source": [
        "print(hello.replace(\"H\", \"A\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Aello, World! \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dFJqsnlz8_Ej",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "30cc890d-e08c-4e20-a3ab-a8037bef3885"
      },
      "source": [
        "print(hello.split(\",\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Hello', ' World! ']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PC3l_YeI9AkW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "0aa77f37-fc76-4fbf-863c-e8a51f6a0d82"
      },
      "source": [
        "# Membership Operators\n",
        "print(\"Hello\" in hello)\n",
        "print(\"Hello\" not in hello)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_SlannlY9GQh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7e232d2b-1d25-46ba-c7c3-d056d4ac5ecb"
      },
      "source": [
        "print('Hello, ' + 'World!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vRvrYJyJ9HEX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "65ea2a2b-3a44-4e24-d83d-08294bc4da4d"
      },
      "source": [
        "print('Hello, ' 'World!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kFhjB9yI9JqQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f5657204-8a7e-4fd1-dd9e-8f6196adbc5b"
      },
      "source": [
        "print(\"{0}, World!\".format('Hello'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s27Htl0f9Lap",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "4a216e89-e304-4563-8ba6-4cc1589c7301"
      },
      "source": [
        "print('Hello, \\n World!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, \n",
            " World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IDEaBAXT9NPR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ff8c75c6-a518-4b49-e280-e91f8cf31cab"
      },
      "source": [
        "print(chr(97)) # Return the string representing a character"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tN1jFCCH9Q7S",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "94d98778-a9ea-4827-93bd-b69f533967c4"
      },
      "source": [
        "print(ord('a')) # Return an integer representing the Unicode"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "97\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L_9D3fCTKT6h",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "91906547-6856-459b-e2ef-1c3c577abc01"
      },
      "source": [
        "# print('Number is: ' + 1)\n",
        "# TypeError: must be str, not int\n",
        "\n",
        "# 'str()' return a string version of object\n",
        "print('Number is: ' + str(1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number is: 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CamroSC1-3gL",
        "colab_type": "text"
      },
      "source": [
        "## 🧮 Arithmetic\n",
        "The arithmetic operators are used to perform **math operations**, such as addition, subtraction, multiplication, and division."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P3NDAINl-6H0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7183a5f5-25d6-4462-e296-87f99e631d84"
      },
      "source": [
        "x, y = 1, 2\n",
        "print(x + y) # Addition"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Nl9eBRa-9B6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fab442e4-a168-4f65-f5b2-af4fe211bf36"
      },
      "source": [
        "print(x - y) # Subtraction"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MOtE63mK_A4M",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8a71ec24-01af-4a01-c4f1-6a05ca316b19"
      },
      "source": [
        "print(x * y) # Multiplication"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-qBbKFgw_Cg_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9dbf84e7-37b7-4308-98b9-a93ed5dc3479"
      },
      "source": [
        "print(x / y) # Division"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qu1a-OQS_EKi",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "05bb4313-e7b7-4af3-a80e-1e11178168a1"
      },
      "source": [
        "print((50 - 5*6) / 4) # 5.0"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DPRxB4Pb_Fxy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "649caa12-8c7e-4c73-de7e-db265813bfda"
      },
      "source": [
        "print(x % y) # Modulus"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GBrC1v37_HU_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "eae03427-8cc8-4c09-bc8b-8fdfdfb754a5"
      },
      "source": [
        "print(x ** y) # Exponentiation"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5RtkWd0Q_JZ2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "020ae9a1-a22c-4606-ae01-5a2281a0b441"
      },
      "source": [
        "print(x // y) # Floor division"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i8iPP-ev_KvI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x += 3 # Same as x = x + 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ylkvUcA_NbG",
        "colab_type": "text"
      },
      "source": [
        "## 🎎 Comparison\n",
        "These operators **compare** the values on either sides of them and decide the **relation** among them"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "37gNaeb4_Psp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7d6f4281-4052-4fc8-9615-371b239b6fba"
      },
      "source": [
        "x, y = 1, 2\n",
        "print(x == y) # Equal"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OF-Kb2Hk_SHp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f6bd821b-0784-461b-f030-8d430319a20c"
      },
      "source": [
        "print(x != y) # Not equal"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5H3FO2xj_TfB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "43215215-1b24-43af-aeda-7a26ea9bab2f"
      },
      "source": [
        "print(x > y) # Greater than"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4GmGv1Bs_V3k",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5e4165b4-1c30-44fc-ebe5-c670305f57e9"
      },
      "source": [
        "print(x < y) # Less than"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "neN-lpCE_WjB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "42fef44d-c60a-4675-a315-fa082022b651"
      },
      "source": [
        "print(x >= y) # Greater than or equal to"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Id3-i3_H_YQf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ee406863-8a93-44ad-c32a-c4e275267c37"
      },
      "source": [
        "print(x <= y) # Less than or equal to"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d4IsbMVB_aBo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "81515b90-973b-490e-a944-1cc5f5fef656"
      },
      "source": [
        "if x > y:\n",
        "  print(\"x is greater than y\")\n",
        "else:\n",
        "  print(\"x is not greater than y\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x is not greater than y\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8yPvkkFR_ffj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Assert is used when debugging code\n",
        "assert x == 1 # AssertionError is not raised"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xv237JGs_rIR",
        "colab_type": "text"
      },
      "source": [
        "## 🤖 Logical"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-y7Eu03_umm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f858e155-1302-40c2-a9c7-953c194d5b7f"
      },
      "source": [
        "x = 2\n",
        "print(x == 2 and x > 42)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pgjElYHv_xp2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "70812e4a-d096-44c3-caaf-62801fa3eced"
      },
      "source": [
        "print(x == 2 or x > 42)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "17sfKffz_zbf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0b717f15-c7bf-4fc1-dd26-ff559363a4c2"
      },
      "source": [
        "print(not(True))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iohQxagh_1A-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "87ab2def-fa4d-4cae-821d-85266434b6d6"
      },
      "source": [
        "print(not(False))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jRhwXouzZvMD",
        "colab_type": "text"
      },
      "source": [
        "## 🖩 Math\n",
        "Python has a set of built-in math functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bI4Gc-a_Z9Pl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "0a061f45-a8b9-4883-dbdf-8c2aeea4e76e"
      },
      "source": [
        "min_value = min(5, 10, 25) # lowest value\n",
        "max_value = max(5, 10, 25) # highest  value\n",
        "\n",
        "print(min_value)\n",
        "print(max_value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            "25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EVT-lGa1areJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "90501f0b-3af4-4d44-85c2-13cce9fe695f"
      },
      "source": [
        "print(abs(-7.25)) # returns the absolute (positive) value\n",
        "print(pow(4, 3)) # returns the '4' to the power of '3'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7.25\n",
            "64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dkalkx_EzmMG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4156440b-ca5f-43d6-eeae-2a1d303ce174"
      },
      "source": [
        "# Takes two numbers and returns a pair of numbers (a tuple) \n",
        "# consisting of their quotient and remainder\n",
        "divmod(2, 2) # same as (2 // b, x % y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 0)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D1_T5q7jIVi5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "70b85ce1-30f0-4cb9-ccf5-22e69108209a"
      },
      "source": [
        "# Return number rounded to ndigits precision after the decimal point\n",
        "print(round(0.5))\n",
        "print(round(1.5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kJGDfVPs_3Y7",
        "colab_type": "text"
      },
      "source": [
        "## 🆔 Identity\n",
        "\n",
        "Identity operators are used to compare the objects"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QURkrB-m_4wA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "016df4d1-850c-413d-9c35-9e2b8bf43960"
      },
      "source": [
        "x = 'Hello'\n",
        "z = x\n",
        "\n",
        "print(x is z)\n",
        "print(x is not z)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zG-0JuVK_9YQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3030ccf1-6f19-4912-80aa-950badc0f583"
      },
      "source": [
        "y = 'World'\n",
        "print(x is y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zKiAbuDo_-4f",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "efbbea27-6328-4bad-bc39-95e6484c9ebd"
      },
      "source": [
        "print(x == y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GjMhGBAnRICt",
        "colab_type": "text"
      },
      "source": [
        "## 👪 Lists\n",
        "\n",
        "List is used to group together other values.\n",
        "\n",
        "Built-in methods for lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p0saMqzFRMi4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0a9f2a6e-80e0-4849-a4ea-cee23f5f62fa"
      },
      "source": [
        "mylist = ['hello', 'world']\n",
        "print(mylist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['hello', 'world']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "32kEXOv9RRoy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "950c3c2a-d3c6-41c8-f168-0c077fa53529"
      },
      "source": [
        "print(f'{mylist[0]} - {mylist[-1]} - {mylist[0:1]} - {mylist[:1]} - {mylist[0:]}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello - world - ['hello'] - ['hello'] - ['hello', 'world']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "USAzKvdGRUCU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "aaece8d5-62ba-403e-818c-f3bf12d8a78e"
      },
      "source": [
        "print(mylist[-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "world\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CpDL0pJTRVqp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7527083d-cf56-4037-cdd1-53ec6004858b"
      },
      "source": [
        "print(mylist[0:1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['hello']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ORc2asvjRW4b",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9b675ffa-2bf5-4f36-9871-63fc1ad871e5"
      },
      "source": [
        "print(mylist[:1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['hello']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f6DdDedgRYEy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4897b216-e470-40aa-a8fb-37ead636e1d3"
      },
      "source": [
        "print(mylist[0:])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['hello', 'world']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IcIQXAwoRZgU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f18a0a8d-d25f-48e2-efd3-565ffdcad5fd"
      },
      "source": [
        "mylist[1] = \"!\"\n",
        "print(mylist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['hello', '!']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LOZTSe4JRb8T",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "3a6324c6-4164-4899-cdc4-3640ba2126dd"
      },
      "source": [
        "for item in mylist:\n",
        "  print(item)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello\n",
            "!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GUi9wAjnRh2L",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ca3ccef9-ece4-4668-b008-d5ae7cb52552"
      },
      "source": [
        "if \"hello\" in mylist:\n",
        "  print(\"Yes, 'hello' is in the mylist\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Yes, 'hello' is in the mylist\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5f37hAzyRrd-",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "bbff115d-791f-49b6-eae1-fccfb587dc87"
      },
      "source": [
        "print(len(mylist))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iHRBvBC9RvnF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "46e37980-e925-474c-e8a9-596003a225c7"
      },
      "source": [
        "mylist.append(\"world\") # Add an item to the end of the list\n",
        "print(mylist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['world', 'world']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PFyWeBpZR8Ay",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d1ffb8ba-6574-4623-bf79-e5a07b073ca4"
      },
      "source": [
        "mylist.clear() # Removes all the elements\n",
        "print(mylist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xp5INxs4THqx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "mylist = ['hello', 'world']\n",
        "my_other_list = mylist.copy() # Returns a copy of the list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0cqFO19ETRbm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a448045b-eedb-426e-b78c-892734835d6a"
      },
      "source": [
        "my_other_list.count('hello') # Return the number of times the value \"hello\" appears"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 79
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_izGl5TKTnJw",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b31b663d-baf0-4aac-e78a-85ac4a903aa4"
      },
      "source": [
        "mylist.extend(['apple']) # Extend the list by appending all the items from the iterable\n",
        "print(mylist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['hello', 'world', 'apple', 'apple']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JRs90BllTsCj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a8342440-5218-48f7-dbb4-e69ad60ef289"
      },
      "source": [
        "mylist.index('world')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D0SCR4QeWo32",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3d97098a-209d-4eca-bf8c-b664b5fce6b6"
      },
      "source": [
        "mylist.insert(1, \"cucumber\") # Adds an element at the specified position\n",
        "print(mylist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['apple', 'cucumber', 'banana', 'cherry']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wBiRn19fW-3b",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "fbfb94ad-9410-42d6-e4a7-8cd9e41dddbc"
      },
      "source": [
        "mylist.pop() # Removes the last item from the list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'apple'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7B017CYHXL4u",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "38f2687b-0159-4ee8-a5f0-aa774fb75692"
      },
      "source": [
        "print(mylist)\n",
        "mylist.remove(\"cucumber\") # Remove the item at the given position in the list, and return it\n",
        "print(mylist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['apple', 'cucumber', 'banana', 'cherry']\n",
            "['apple', 'banana', 'cherry']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OPDPO0SqXTi1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "ccac7883-467a-4b74-ec86-bdd0feb100db"
      },
      "source": [
        "my_number_list = [ 1, 2, 3]\n",
        "my_number_list.reverse()\n",
        "print(my_number_list)\n",
        "print(reversed(my_number_list))\n",
        "my_number_list.sort()\n",
        "print(my_number_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 2, 1]\n",
            "<list_reverseiterator object at 0x7fa4e1b08cf8>\n",
            "[1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OMdsv501XjYZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e35fe6b2-fc1f-4664-b2c8-6e2ca4a546f6"
      },
      "source": [
        "del my_number_list[0]\n",
        "print(my_number_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YRato6ioXpjp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "39e327e7-fbd9-47b9-a38c-adb7a275e0e8"
      },
      "source": [
        "all(my_number_list) # Return True if all elements of the iterable are true"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 99
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "viC2FjK0XvVU",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "db1675ae-dc36-4072-8058-f34f6a28bab7"
      },
      "source": [
        "print(any(my_number_list)) # If the iterable is empty, return False\n",
        "my_number_list.clear()\n",
        "print(any(my_number_list))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yEQ2loNBYCmA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "43ea72f6-7633-4d35-d3ed-986020b7a780"
      },
      "source": [
        "letters = [ 'a', 'b', 'c' ]\n",
        "numbers = [ 1, 2, 3 ]\n",
        "print(letters + numbers)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['a', 'b', 'c', 1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_s2Zu5AyYPOG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "653fff26-8850-4fbc-ccb4-4b6d739fe1c7"
      },
      "source": [
        "mylist = list((\"apple\", \"banana\", \"cherry\"))\n",
        "print(mylist)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['apple', 'banana', 'cherry']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JJHCvd1W1gtV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "2bf9becc-8b74-42ee-9d7e-22dc428a0818"
      },
      "source": [
        "my_other_list = [ 'a', 'b', 'c', 'd', 'e' ]\n",
        "\n",
        "start = 0 # position to start the slicing\n",
        "end = 5 # position to end the slicing\n",
        "spet = 2 # step of the slicing\n",
        "slice_obj = slice(start, end, spet)\n",
        "\n",
        "my_other_list[slice_obj]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'c', 'e']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z7YlfTaTJmRz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7d59ff3d-7bb3-400d-d8e4-0d59cc9a7fa3"
      },
      "source": [
        "# Return a new sorted list from the items in iterable\n",
        "my_sorted_list = sorted([5, 4, 3, 2, 1])\n",
        "print(my_sorted_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BmNYzYCmLLpN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fb6c7224-39ee-4531-d6fe-0919876c045b"
      },
      "source": [
        "my_reversed_list = reversed(my_sorted_list)\n",
        "print(list(my_reversed_list))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[5, 4, 3, 2, 1]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t_1xQ9iBAjug",
        "colab_type": "text"
      },
      "source": [
        "### Built-in Higher Order Functions\n",
        "**map** and **filter** functions\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ShRfhx706it6",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4e819f24-9f92-4beb-ef6c-63727cad0e97"
      },
      "source": [
        "# The filter function tests every element in an iterable object \n",
        "# with a function that returns either True or False, only keeping \n",
        "# those which evaluates to True\n",
        "\n",
        "my_iterable = [ 1, 2, 3, 4, 5 ]\n",
        "\n",
        "def bigger_than_three(number):\n",
        "  return number > 3\n",
        "\n",
        "output_list = filter(bigger_than_three, my_iterable)\n",
        "print(list(output_list))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[4, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7KzRUtPrEdML",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b3f202c7-5998-43c7-c75a-94d0f54d7df5"
      },
      "source": [
        "# The map function allows us to apply a function to every element \n",
        "# in an iterable object\n",
        "\n",
        "my_iterable = [ 1, 2, 3, 4, 5 ]\n",
        "\n",
        "def add_one(number):\n",
        "  return number + 1\n",
        "\n",
        "output_list = map(add_one, my_iterable)\n",
        "print(list(output_list))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 3, 4, 5, 6]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IjUdD2ej2XPe",
        "colab_type": "text"
      },
      "source": [
        "### 💫 List Comprehensions\n",
        "List comprehensions are a way of making lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WWYSm8-j2jMa",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "472cadf1-2dba-4e35-c0a5-6e299289bcc5"
      },
      "source": [
        "numbers = [number for number in range(5)]\n",
        "print(numbers)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cpNAX7sZ3SpL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "03afff2a-be16-4e7b-d918-36b8e258af1c"
      },
      "source": [
        "squares = [number * number for number in range(5)]\n",
        "print(squares)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 4, 9, 16]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1BcuhbmP30jG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "293430ff-3aa5-4dd4-e6a1-74c66e2e9afd"
      },
      "source": [
        "def square(number):\n",
        "  return number * number\n",
        "\n",
        "squares = [square(number) for number in range(5)]\n",
        "print(squares)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 4, 9, 16]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nufofFhN4oC_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "e71f24cd-af43-4095-f56f-ab7b93290330"
      },
      "source": [
        "numbers = list(range(10))\n",
        "even_numbers = [number for number in numbers if number % 2 == 0]\n",
        "print(numbers)\n",
        "print(even_numbers)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "[0, 2, 4, 6, 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3xLBKzHLudHz",
        "colab_type": "text"
      },
      "source": [
        "## 🏷️ Sets\n",
        "Unordered collections of unique elements"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gU_S08k3ufH8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "cc114725-0dea-4b94-aae1-4a4c08cee60e"
      },
      "source": [
        "my_set = {'python', 'is', 'awesome'}\n",
        "print(my_set)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'python', 'is', 'awesome'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jxjvW5McwP9z",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "64889b68-6155-49bd-96c8-fe063a47e352"
      },
      "source": [
        "len(my_set) # Return the number of elements in set"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sDi8RoDVv_-_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "dbb63a9c-a948-4f09-e0df-ce9a908e37fb"
      },
      "source": [
        "for item in my_set:\n",
        "  print(item)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "python\n",
            "is\n",
            "awesome\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XgsjbB-gwFQp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "4806f5aa-2da8-4a95-e076-7661d57a1046"
      },
      "source": [
        "print('python' in my_set) # Check if 'python' is present in the set\n",
        "print('python' not in my_set) # Check if 'python' is not present in the set"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CoSkE7vZwYFs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "a2fa06eb-cb57-4231-fa24-a4c01be88ac5"
      },
      "source": [
        "my_set.add('🐍')\n",
        "print(my_set)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'python', '🐍', 'is', 'awesome'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bfJ9n4_Zw5-X",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3bcbb938-f5d4-4d92-d20c-e8712cc382a8"
      },
      "source": [
        "my_set.update(['and', 'very', 'nice'])\n",
        "print(my_set)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'python', 'awesome', '🐍', 'nice', 'very', 'and', 'is'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EEMyLrCaxEB9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "677f6f50-14df-4c16-c905-08e714e4e534"
      },
      "source": [
        "my_set.remove('🐍')\n",
        "# If the item to remove does not exists, discart will not raise an error\n",
        "my_set.discard('python') \n",
        "print(my_set)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'is', 'awesome'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2k4cDUE-xgsJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "675bd3d8-a8b0-425c-fb22-b02c66ba23ad"
      },
      "source": [
        "my_set.pop() # Remove and return an arbitrary element from the set"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'is'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AEOtQ_gFx1J5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_set.clear() # Remove all elements from the set"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cf7XH8kHCNOU",
        "colab_type": "text"
      },
      "source": [
        "## 📙 Dictionaries\n",
        "A dictionary is a collection which is unordered, changeable and indexed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z2Y0KsItCbyH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4de7de8e-d22f-41d4-c942-5c31d7ec6eb4"
      },
      "source": [
        "my_dict = {\n",
        "  'name': 'Python',\n",
        "  'designed_by': 'Guido van Rossum',\n",
        "  'first_released': 1991\n",
        "}\n",
        "print(my_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'name': 'Python', 'designed_by': 'Guido van Rossum', 'first_released': 1991}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XqKrhKpiEh42",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5c382204-386e-4fd7-a0ed-c0dfea18ebdd"
      },
      "source": [
        "print(my_dict['name'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Python\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZZ7HOuOhxJLr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "32a15440-1ab6-4b84-c89b-2de662ab9d6d"
      },
      "source": [
        "my_dict['first_released'] = 2077\n",
        "print(my_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'name': 'Python', 'designed_by': 'Guido van Rossum', 'first_released': 2077}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p3fYGu8p2D81",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "9beac222-1c9d-4c0f-8159-cffb15d59c61"
      },
      "source": [
        "for value in my_dict.values():\n",
        "  print(value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Python\n",
            "Guido van Rossum\n",
            "1991\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fqaHWfbc2U2o",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "a3b83da4-abaf-45b2-c642-067e3fcd332a"
      },
      "source": [
        "for key, value in my_dict.items():\n",
        "  print(key, value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "name Python\n",
            "designed_by Guido van Rossum\n",
            "first_released 1991\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JnnLxMUD2dhG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "dd968d1f-dfe9-4a38-b24e-9cb162eef606"
      },
      "source": [
        "if 'name' in my_dict:\n",
        "  print('The key \"name\" exists in my_dict')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The key \"name\" exists in my_dict\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TDA_xaoH32DR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ec6daefd-7665-4ae5-94c5-84dc648fac43"
      },
      "source": [
        "my_dict['website'] = 'www.python.org' # Add a new item\n",
        "print(my_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'name': 'Python', 'designed_by': 'Guido van Rossum', 'first_released': 1991, 'website': 'www.python.org'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2jcLDP104QW_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1266c856-0f72-404a-cc2b-f4432b46c027"
      },
      "source": [
        "my_dict.pop('website')\n",
        "print(my_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'name': 'Python', 'designed_by': 'Guido van Rossum', 'first_released': 1991}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-aAGX97O4ZZ7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "7cd7bdba-b696-4c7a-b85e-3c7088e62beb"
      },
      "source": [
        "my_dict.popitem()\n",
        "print(my_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'name': 'Python'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VM12scNS4gXi",
        "colab_type": "text"
      },
      "source": [
        "## ↪️ If ... Else"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ruc4mgev5LxO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0ce94d87-2e99-4d9a-b882-47e942f9420b"
      },
      "source": [
        "x, y = 1, 2\n",
        "if x > y:\n",
        "  print('x is greater than y')\n",
        "elif x == y:\n",
        "  print('x and y are equal')\n",
        "else:\n",
        "  print('x is greater than y')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "x is greater than y\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YmQy2CZX56a4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "36d956f6-e9a5-4c9a-a7de-2a20c7a33b3b"
      },
      "source": [
        "# Short Hand\n",
        "if x > y: print('x is greater than y')\n",
        "print('x') if x > y else print('y')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "y\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p4UGea5X6BKN",
        "colab_type": "text"
      },
      "source": [
        "## 🔁 Loops\n",
        "*'for' is used to iterate over the elements of a sequence (such as a string, tuple or list) or other iterable object*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jYhCft1F7f5n",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "bc6bbbb4-b148-424c-9a6e-27db1d7a2c9b"
      },
      "source": [
        "quote = ['Python', 'is', 'awesome']\n",
        "for word in quote:\n",
        "  print(word)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Python\n",
            "is\n",
            "awesome\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4gg9rsS38Ef0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "99b22ac0-a511-4257-a211-43ed7cf27103"
      },
      "source": [
        "for number in range(4):\n",
        "  print(number, end=' ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 2 3 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZMYtbO5vx8tv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "5becce08-e1f0-48c2-930a-9da87c09c63f"
      },
      "source": [
        "for index, value in enumerate(quote):\n",
        "  print(index, value)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 Python\n",
            "1 is\n",
            "2 awesome\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OpUWJpyp8yET",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "5b33c513-cef0-43ae-b7ea-dfceb707002d"
      },
      "source": [
        "# Function continues execution immediately \n",
        "# after the last yield run\n",
        "def number_generator(): \n",
        "    yield 1\n",
        "    yield 2\n",
        "  \n",
        "for number in number_generator():  \n",
        "    print(number)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bAgB3h8Z7RlW",
        "colab_type": "text"
      },
      "source": [
        "*'while' is used for repeated execution as long as an expression is true*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "btdERdbb6veG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "74eb1604-3435-4a3c-dd50-c9998489a281"
      },
      "source": [
        "counter = 0\n",
        "while counter < 4:\n",
        "  print(counter, end=' ')\n",
        "  counter += 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 2 3 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8c8HglBt90nl",
        "colab_type": "text"
      },
      "source": [
        "## ☄️ Functions\n",
        "A function is a block of code which only runs when it is called."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c5nWFpLK_hUT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0f48cfb6-a4e4-43f5-8b98-2dbf6bcbb2b5"
      },
      "source": [
        "def my_function():\n",
        "  print(\"Hello, World from a function\")\n",
        "\n",
        "my_function() # Call a function"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, World from a function\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DD7NT7KMHvOy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1a53d72b-5664-4c82-bb00-1169b7a601f1"
      },
      "source": [
        "# A function to add two numbers\n",
        "def sum(number):\n",
        "  return number + number\n",
        "\n",
        "print(sum(2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "06RJApfW_yxD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "35c19f69-38d6-4dec-87f5-8880d41f4dba"
      },
      "source": [
        "def my_function(programming_language): \n",
        "  print(programming_language + ' is awesome!')\n",
        "\n",
        "my_function('Python') # Pass parameters"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Python is awesome!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ayfYHgglASnD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "0482466a-f3f2-4016-f332-abc2370f16cb"
      },
      "source": [
        "def my_function(*parameters):\n",
        "  print(\"The third parameter is: \" + parameters[2])\n",
        "\n",
        "my_function('Python', 'is', 'easy', 'to', 'learn')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The third parameter is: easy\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fRYHRKwwDvhs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "eba8f8ad-c5b6-444c-d1fd-bbf2d454bd1a"
      },
      "source": [
        "def my_function(name, surname):\n",
        "  print(name, surname)\n",
        "\n",
        "my_function(surname='van Rossum', name='Guido')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Guido van Rossum\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wUyUNpuRGaZq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "5aa23efc-dba6-4d1f-e942-2542ffa923bd"
      },
      "source": [
        "def my_function(programming_language=\"Python\"): # Default parameter value\n",
        "  print(programming_language + ' is awesome!')\n",
        "\n",
        "my_function(\"Ruby\")\n",
        "my_function()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ruby is awesome!\n",
            "Python is awesome!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xSYSWZ49IQyW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f8897aa8-82d2-4f9b-8d68-b8f766e72e2a"
      },
      "source": [
        "# True if the object argument appears callable\n",
        "callable(my_function) # True"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KVplOS2ZK02W",
        "colab_type": "text"
      },
      "source": [
        "## 🛰️ Lambda Function\n",
        "Is a small anonymous function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xXgUxdhfN5IX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1609cb8d-67e3-4619-8b5e-024ffc727585"
      },
      "source": [
        "# lambda arguments : expression\n",
        "my_function = lambda x : x\n",
        "print(my_function(2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1rEzuWuwPNuf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# is equivalent to\n",
        "def my_function(x):\n",
        "  return x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cCNlhWjXOw6e",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "72cf6914-0efd-4106-98f7-8ace9812622a"
      },
      "source": [
        "sum = lambda x, y : x + y # Two parameters\n",
        "print(sum(2, 2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9wRfXl_kPWnu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "04d2cfa9-0d1e-471b-a827-10b140baa482"
      },
      "source": [
        "def call_any_function(func):\n",
        "  print(func(2, 2))\n",
        "\n",
        "call_any_function(sum) # Pass the 'sum' lambda function as parameter"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ehq9NjVcOEVl",
        "colab_type": "text"
      },
      "source": [
        "## 📦 Classes and Objects\n",
        "A **class** is a blueprint for an **object**, and an **object** is simply a collection of variables and functions that act on those variables."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xqUGjnCvOcLm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Person:\n",
        "  def __init__(self, name, age):\n",
        "    # Instance attribute’s\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "\n",
        "  def show_name(self):\n",
        "    print(\"My name is \" + self.name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PU8gQqqvPU8L",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "de159cca-88aa-4724-a3c9-724750ff3d99"
      },
      "source": [
        "king_arthur = Person('Arthur', 26)\n",
        "print(king_arthur)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<__main__.Person object at 0x7fb626e010f0>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pt4BpvxZ3krZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# King Arthur is a Person object at the memory address 0x7fb265f652b0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_s6HvmoYQQPr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "30597df3-41dd-4043-b6eb-bf90c3664e73"
      },
      "source": [
        "king_arthur.show_name()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "My name is Arthur\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yE2ayGcHQhAa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "king_arthur.age = 27 # Modify object properties"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KGo5JFQRQ49y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Use inheritance to create child classes from a parent class\n",
        "class Knight(Person):\n",
        "  def speak(self):\n",
        "    print('Ni!')\n",
        "  \n",
        "# Now the Knight class has the same properties \n",
        "# and methods as the Person class plus the 'speak()' method"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XhWEGexuRWTS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "2104c776-4b07-4ba6-c0ec-380531aea00c"
      },
      "source": [
        "lancelot = Knight('Lancelot', 25)\n",
        "lancelot.show_name()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "My name is Lancelot\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9VTsF3KBSU0q",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5b28b77e-ff7f-461f-c5d5-86e629e62895"
      },
      "source": [
        "lancelot.speak()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ni!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f76VJfWSSy94",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5cb41f4e-dcbe-4764-d7e8-116f904a877d"
      },
      "source": [
        "vars(lancelot)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'age': 25, 'name': 'Lancelot'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EVoRK_ArTBss",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "15cef0a3-aab3-4f0a-cdd4-306702f3e7fb"
      },
      "source": [
        "# Return the 'identity' of an object\n",
        "id(lancelot)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "140420313039592"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rvRmqFPK_N4c",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f143ebb2-51da-416f-931b-5b9e93da5c08"
      },
      "source": [
        "# Determine which class a given object belongs to\n",
        "type(lancelot)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "__main__.Knight"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LQmBJHbKTHa8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "db9f58c6-b62c-4ee7-c0e5-c0d4fef8dfe5"
      },
      "source": [
        "print(isinstance(lancelot, Knight))\n",
        "print(isinstance(king_arthur, Knight))\n",
        "print(issubclass(Knight, Person))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I0LJH541xLG2",
        "colab_type": "text"
      },
      "source": [
        "### Inheritance\n",
        "Inheritance allows us to define a class that inherits all the methods and properties from another class."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LVfun59I1CaO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Base class: Person\n",
        "# Derived class: Peasant\n",
        "class Peasant(Person):\n",
        "    # Class attributes are attributes that have the \n",
        "    # same value for all class instances.\n",
        "    political_position = \"We're an anarcho-syndicalist commune.\"\n",
        "    \n",
        "    # Friendlier output for print()\n",
        "    def __str__(self):\n",
        "      return f\"{self.name} is {self.age} years old\"\n",
        "\n",
        "    # You can access the parent class from \n",
        "    # inside a method of a child class by using super()\n",
        "    def show_name_using_super_method(self):\n",
        "      super().show_name()\n",
        "\n",
        "    # Static method it's not bound to instance or class and you \n",
        "    # can simply call that using class name\n",
        "    @staticmethod\n",
        "    def talk_about_politics():\n",
        "      print(Peasant.political_position)\n",
        "\n",
        "    # A class method receives the class as implicit first argument\n",
        "    @classmethod\n",
        "    def show_class(cls):\n",
        "      print(cls)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "siyQ-AJY8j-n",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "26e3c6b7-aba0-4703-a6c6-c80782bd25a3"
      },
      "source": [
        "dennis = Peasant('Dennis', 37)\n",
        "print(dennis)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dennis is 37 years old\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CbkgoPgH_sJp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5bd35c70-13be-4714-c22c-4020e3ae9030"
      },
      "source": [
        "dennis.show_name_using_super_method()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "My name is Dennis\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sN_i61SOB0ME",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8b1c514d-517a-4bcc-a8fd-ea454473a3a8"
      },
      "source": [
        "dennis.talk_about_politics() # Static method"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "We're an anarcho-syndicalist commune.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2YpWrqqSDwvt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6ab7b08a-0b29-47c4-d78b-10c5071e7cb7"
      },
      "source": [
        "Peasant.show_class() # class method"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class '__main__.Peasant'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DFM4y8Jc-VWB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "6825bf91-1e4f-48f4-945a-22bc4b5b064c"
      },
      "source": [
        "getattr(dennis, 'name')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Dennis'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4Q2BDaoQJGI5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "00a9dbec-99d5-487b-8156-624cc1568ada"
      },
      "source": [
        "print(dennis.name)\n",
        "# The function assigns the value to the attribute\n",
        "setattr(dennis, 'name', 'Other Name') # same as dennis.name = 'Other Name'\n",
        "print(dennis.name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dennis\n",
            "Other Name\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q31BrASmAPz3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "35316d34-39c8-4805-f42a-0c9cef728493"
      },
      "source": [
        "print(hasattr(dennis, 'name'))\n",
        "print(hasattr(dennis, 'email'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pjxcQsrTBKHn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "73203d4f-17f6-4165-93e8-f1720918c97a"
      },
      "source": [
        "# Return the hash value of the object (if it has one)\n",
        "print(hash(dennis))\n",
        "\n",
        "# They are used to quickly compare dictionary keys during a dictionary lookup\n",
        "print(hash(dennis) == hash(dennis))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "8771641773972\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jlnUIGrZN3wd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "eca065c2-762d-4d95-d1ba-96bbdc3be0d8"
      },
      "source": [
        "# Return a string containing a printable representation of an object\n",
        "print(repr(dennis))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<__main__.Peasant object at 0x7fa4e1adf630>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RqhqhpLQEgKi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# The function deletes the named attribute\n",
        "delattr(dennis, 'name')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bqE-HiZmL0nd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 'property()' Return a property attribute\n",
        "# class property(fget=None, fset=None, fdel=None, doc=None)\n",
        "# - doc creates a docstring for the attribute\n",
        "\n",
        "class C:\n",
        "  def __init__(self):\n",
        "      self._x = None\n",
        "\n",
        "  # function for getting an attribute value\n",
        "  def getx(self):\n",
        "      return self._x\n",
        "\n",
        "  # function for setting an attribute value\n",
        "  def setx(self, value):\n",
        "      self._x = value\n",
        "\n",
        "  # function for deleting an attribute value\n",
        "  def delx(self):\n",
        "      del self._x\n",
        "\n",
        "  x = property(getx, setx, delx, \"I'm the 'x' property.\")\n",
        "\n",
        "c = C()\n",
        "c.x # invoke the getter\n",
        "c.x = 2 # invoke the setter\n",
        "del c.x # invoke the deleter\n",
        "\n",
        "# This code is exactly equivalent to the first example\n",
        "class C:\n",
        "    def __init__(self):\n",
        "        self._x = None\n",
        "\n",
        "    @property\n",
        "    def x(self):\n",
        "        \"\"\"I'm the 'x' property.\"\"\"\n",
        "        return self._x\n",
        "\n",
        "    @x.setter\n",
        "    def x(self, value):\n",
        "        self._x = value\n",
        "\n",
        "    @x.deleter\n",
        "    def x(self):\n",
        "        del self._x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pThWhVeZ5O5B",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "c0e5289e-3029-4028-a6b5-789e4e449146"
      },
      "source": [
        "# The object() function returns a featureless\n",
        "# object which is a base for all classes\n",
        "my_object = object()\n",
        "\n",
        "# Get all the attributes\n",
        "print(dir(my_object))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UQ7KOR12aqeq",
        "colab_type": "text"
      },
      "source": [
        "# ➰ Iterators\n",
        "An iterator is an object that can be **iterated** upon, meaning that you can traverse through all the values."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rncFI-Gna0Vh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "bcb4f651-1bb5-4abf-83ef-bced5455e41f"
      },
      "source": [
        "# Lists, tuples, dictionaries, and sets are all iterable objects\n",
        "my_list = [ 1, 2, 3 ]\n",
        "\n",
        "# The 'for' takes the list iterator \n",
        "# and then moves through it using \n",
        "# the built-in 'next' iterator method\n",
        "for number in my_list:\n",
        "  print(number)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uhrmi3klmVLD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "d7801da1-c428-4a30-df30-f64065a97104"
      },
      "source": [
        "# Let's repeat what the 'for' does, but now manually\n",
        "my_list = [ 1, 2, 3 ] # The same list\n",
        "list_iterator = iter(my_list) # Returns the iterator\n",
        "\n",
        "print(next(list_iterator)) # Returns the next value of iterator\n",
        "print(next(list_iterator))\n",
        "print(next(list_iterator))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_erbjA76h-Qz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "764aea5b-fe8a-4a43-b19b-2f79b3bca6ee"
      },
      "source": [
        "# It is possible to do the same but with a 'while' loop\n",
        "my_list = [ 1, 2, 3 ]\n",
        "list_iterator = iter(my_list)\n",
        "\n",
        "while True:\n",
        "  try:\n",
        "    current_value = next(list_iterator) \n",
        "    print(current_value)\n",
        "  # The 'next' method returns an exception when the list ends\n",
        "  except StopIteration:\n",
        "    break # Stops the while loop"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z26Ey6L7nWaB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "24063068-e404-42af-f5fb-4f1be3ddb5eb"
      },
      "source": [
        "# It is possible to create an iterator,\n",
        "# is a class that has to have two methods, the 'iter' and the 'next'\n",
        "class MyNumbers:\n",
        "  # Return the iterator\n",
        "  def __iter__(self):\n",
        "    self.end = 3\n",
        "    self.value = 1 # Start value\n",
        "    return self # Return himself\n",
        "\n",
        "  # It says how to get the next value\n",
        "  def __next__(self):\n",
        "    if self.value > self.end:\n",
        "      # Stops the execution of the 'for' loop\n",
        "      raise StopIteration\n",
        "    \n",
        "    current = self.value\n",
        "    self.value += 1\n",
        "    return current\n",
        "\n",
        "my_numbers = MyNumbers()\n",
        "for number in my_numbers:\n",
        "  print(number)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1OY47wXd7EWG",
        "colab_type": "text"
      },
      "source": [
        "## 🔗 Scope\n",
        "Scope refers to the coding region from which particular object is **accessible**. \n",
        "\n",
        "LEGB rule (Local, Enclosing, Global, and Built-in):\n",
        "- Built-in Python scope (Predefined names: **open**, **range**, **len**, **etc**)\n",
        "- Global or module scope (Names assigned at top-level of a module or declared **global** in function)\n",
        "- Enclosing or nonlocal scope (Only exists for nested functions)\n",
        "- Local or function scope (Names assigned inside a function **def**)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kS6yT-lZGoE9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "len('len() is a built-in function') # built-in scope\n",
        "number = 0 # global scope\n",
        "\n",
        "def my_function_one():\n",
        "  number = 1 # enclosed scope\n",
        "  def my_function_two():\n",
        "    number = 2 # local scope"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H3ufOdn27ZXY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def my_function():\n",
        "  number = 2\n",
        "\n",
        "my_function()\n",
        "\n",
        "# print(number) NameError: name 'number' is not defined\n",
        "# The variable number cannot be accessed from outside the function"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zR0plQ388DmS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "301c4bc7-fce1-4eb3-879f-d53b1923c953"
      },
      "source": [
        "def myfunction():\n",
        "  global number # global variable\n",
        "  number = 2\n",
        "\n",
        "myfunction()\n",
        "\n",
        "print(number) # can be accessed outside the function"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3-N60Fb1891B",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f73edde7-6926-4ebb-c1df-f89df4c0acd5"
      },
      "source": [
        "number = 2 # can be used inside the function\n",
        "\n",
        "def my_function():\n",
        "  print(number)\n",
        "\n",
        "print(number)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XOsWNdla9VV4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "cd2e0564-fc9b-47a1-963e-54f4647142e9"
      },
      "source": [
        "def my_function_one():\n",
        "  name = \"King Arthur\"\n",
        "  def my_function_two():\n",
        "    # Update and return a dictionary representing the current local symbol table\n",
        "    print(f'Local: {locals()}')\n",
        "\n",
        "    nonlocal name # non local variable\n",
        "    # sets the value of 'name' variable of the 'my_function_one()'\n",
        "    name = \"Black Knight\" \n",
        "  my_function_two()\n",
        "  return name\n",
        "\n",
        "print(my_function_one())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Local: {'name': 'King Arthur'}\n",
            "Black Knight\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SpAdGIu3JYcF",
        "colab_type": "text"
      },
      "source": [
        "## 🧱 Modules\n",
        "Simply, a module is a file consisting of Python code. A module can define **functions**, **classes** and **variables**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TEToniA5J5n0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Save this code in a file named 'my_module.py'\n",
        "def greeting(name):\n",
        "  print('Hello, ' + name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kxJ8b47UKCyM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# This code is commented out because it doesn't run on the jupyter notebook\n",
        "# import my_module\n",
        "# my_module.greeting('Rabbit of Caerbannog')\n",
        "# output: Hello, Rabbit of Caerbannog"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nhssiQqoLB3T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Create an alias for my_module called my\n",
        "# import my_module as my\n",
        "# my.greeting('Rabbit of Caerbannog')\n",
        "# output: Hello, Rabbit of Caerbannog"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qboXVt4z_ZjI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "4715b656-fcf4-4f9f-a99f-f2586117b049"
      },
      "source": [
        "# Return a dictionary representing the current global symbol table\n",
        "print(len(globals()))\n",
        "globals()['my_iterable']"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "60\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tZ4X5puebsL2",
        "colab_type": "text"
      },
      "source": [
        "## ❌ Try Except"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A83gFZEkb0N1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "95e590bc-2b90-4a97-d5ec-6f5bc156f6ac"
      },
      "source": [
        "try:\n",
        "  raise Exception(\"Sorry, no numbers below zero\")\n",
        "except:\n",
        "  print(\"Something went wrong\")\n",
        "finally:\n",
        "  print(\"The 'try except' is finished\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Something went wrong\n",
            "The 'try except' is finished\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B2-qjeZAcKAQ",
        "colab_type": "text"
      },
      "source": [
        "## 📁 File Handling"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GxTK3GigcL-Q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# This code is commented out because it doesn't run on the jupyter notebook\n",
        "# file = open(\"hello.txt\", \"r\")\n",
        "# r - Read\n",
        "# a - Append\n",
        "# w - Write\n",
        "# x - Create\n",
        "\n",
        "# print(file.read())\n",
        "# print(file.readline())\n",
        "# file.close()\n",
        "\n",
        "# Using with statement \n",
        "# with open('hello.txt', 'w') as file: \n",
        "#    file.write('hello world !')\n",
        "\n",
        "# no need to call file.close() when using with"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FsJlTI7Bcdtj",
        "colab_type": "text"
      },
      "source": [
        "## Other built-in Functions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_EVdZUs0cfHA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "c30190b7-ae75-49ca-b19e-a29e03db9640"
      },
      "source": [
        "# Returns a readable version of any object \n",
        "# (Strings, Tuples, Lists, etc)\n",
        "ascii([ 1, 2, 3 ]) #  1, 2, 3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, World!\n",
            "Hello, World!\n",
            "(4+2j)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JzJ4iZ-OdN7i",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "b767060b-7d62-411e-b4bd-27fa2b837967"
      },
      "source": [
        "# Compile the source into a code or AST object\n",
        "ast = compile('print(\"Hello, World!\")', \n",
        "              'test', 'eval')\n",
        "\n",
        "# Code objects can be executed by:\n",
        "exec(ast) # Hello, World!\n",
        "eval(ast) # Hello, World!"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, World!\n",
            "Hello, World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "71w235lLdSRq",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e8751be5-78c1-44c2-b2dd-6d6b83b1905b"
      },
      "source": [
        "# Convert the number 4 and imaginary \n",
        "# number 2 into a complex number\n",
        "print(complex(4, 2)) # (4+2j)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(4+2j)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MNahWISbdrMv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "43c1cce9-70e2-4cec-9607-52ea99c8f893"
      },
      "source": [
        "# The 'zip()' function takes in iterables as arguments and returns an iterator. \n",
        "numbers = [1, 2, 3]\n",
        "letters = ['a', 'b', 'c']\n",
        "zipped = zip(numbers, letters)\n",
        "print(type(zipped))\n",
        "print(list(zipped))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'zip'>\n",
            "[(1, 'a'), (2, 'b'), (3, 'c')]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pq31R97lHkNr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        },
        "outputId": "41629680-53a6-481d-fa17-ac05a0b20e31"
      },
      "source": [
        "for number, letter in zip(numbers, letters):\n",
        "  print(number, letter)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 a\n",
            "2 b\n",
            "3 c\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VtShPlLje2tQ",
        "colab_type": "text"
      },
      "source": [
        "## Other things"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CGPBRuE9e43_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "60691dd7-ca6c-4b3f-f56d-4f19930f14ac"
      },
      "source": [
        "# In interactive mode, the last printed expression \n",
        "# is assigned to the variable _\n",
        "2 + 2\n",
        "print(_)\n",
        "\n",
        "# This function drops you into the debugger at the call site\n",
        "breakpoint()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[(1, 'a'), (2, 'b'), (3, 'c')]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i9klY2O7ObwO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "84f888c9-10b6-42a5-bb91-afd62478f540"
      },
      "source": [
        "# '__main__' is the name of the scope in which top-level code executes\n",
        "# A module’s __name__ is set equal to '__main__' when read from standard \n",
        "# input, a script, or from an interactive prompt\n",
        "print(__name__)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "__main__\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BPI9drryT-8C",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4ffb7128-c2b7-4bca-f7bb-8494ee1c086b"
      },
      "source": [
        "if __name__ == \"__main__\":\n",
        "    # execute only if run as a script\n",
        "    print('Your Module Is the Main Program')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Your Module Is the Main Program\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tKxvCVpCfCzs",
        "colab_type": "text"
      },
      "source": [
        "## All keywords"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jnjYWkwIfD73",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "61edab76-362f-4513-ed1d-9bcbb59a9d3c"
      },
      "source": [
        "import keyword\n",
        "print(keyword.kwlist, sep='')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}