Python_review.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.6"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/raminass/Software-Project/blob/main/Python_review.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qVrTo-LhL9eS"
      },
      "source": [
        "#Introduction\n",
        "**Author**: Rami Nasser (raminass@gmail.com)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9t1gKp9PL9eV"
      },
      "source": [
        "## Why Python\n",
        "\n",
        "\n",
        "\n",
        "*   General purpose programming language (script, OOP, interactive)\n",
        "*   Interpreted (no need of binary, runs until failure)\n",
        "*   Powerful environment for scientific computing\n",
        "*   Free - https://www.python.org/downloads/\n",
        "*   Simple\n",
        "*   Massive community support\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WXZo-cyiJzrr"
      },
      "source": [
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U1PvreR9L9eW"
      },
      "source": [
        "## Agenda\n",
        "\n",
        "* Basic Python\n",
        "* Basic data types (Containers, Lists, Dictionaries, Sets, Tuples)\n",
        "* Functions\n",
        "* Classes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gnrwpb3LPQB6"
      },
      "source": [
        "## Running modes\n",
        "1.   Interactivly\n",
        "  - Starting the Interpreter\n",
        "  - Executing Python Code (Enter)\n",
        "  - Exiting the Interpreter(exit())\n",
        "2.   Running a Python Script from the Command Line\n",
        "3.   Interacting with Python through an IDE\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nxvEkGXPM3Xh"
      },
      "source": [
        "## Python Versions\n",
        "\n",
        "We'll be using Python 3 for this iteration of the course. You can check your Python version at the command line by running `python --version`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1L4Am0QATgOc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39d602c6-a1fb-4a21-96ca-ec356c507084"
      },
      "source": [
        "!python3 --version"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python 3.9.16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JAFKYgrpL9eY"
      },
      "source": [
        "# Basics of Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RbFS6tdgL9ea"
      },
      "source": [
        "*   Python is a high-level, dynamically typed multiparadigm programming language.\n",
        "*   Python code is often said to be almost like pseudocode, since it allows you to express very powerful ideas in very few lines of code while being very readable.\n",
        "*   Whitespaces are important. Python uses indentation, no braces are needed.\n",
        "\n",
        "\n",
        "As an example, here is an implementation of the classic quicksort algorithm in Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cYb0pjh1L9eb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "010653b3-1ee5-447e-b705-c58c13fc9fc0"
      },
      "source": [
        "def quicksort(arr):\n",
        "    if len(arr) <= 1:\n",
        "        return arr\n",
        "    pivot = arr[len(arr) // 2]\n",
        "    left = [x for x in arr if x < pivot]\n",
        "    middle = [x for x in arr if x == pivot]\n",
        "    right = [x for x in arr if x > pivot]\n",
        "    return quicksort(left) + middle + quicksort(right)\n",
        "\n",
        "print(quicksort([3,6,8,10,1,2,1]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 1, 2, 3, 6, 8, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NwS_hu4xL9eo"
      },
      "source": [
        "## Basic data types\n",
        "\n",
        "The followings are Built-In data types, next lectures we will see external data structers such Numpy and Pandas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DL5sMSZ9L9eq"
      },
      "source": [
        "### Numbers\n",
        "Every thing is an object in Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MGS0XEWoL9er"
      },
      "source": [
        "Integers and floats work as you would expect from other languages:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KheDr_zDL9es",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e6cfc07d-c2fd-4109-ef1a-71a6b9ca3e32"
      },
      "source": [
        "#32-bit\n",
        "x = 20\n",
        "print(x, type(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20 <class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x.to_bytes(4,'big')"
      ],
      "metadata": {
        "id": "ZT1uUjTIb6FB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4c797ef5-f537-4074-9770-dc4448ca07a5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "b'\\x00\\x00\\x00\\x14'"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x.bit_length()"
      ],
      "metadata": {
        "id": "-zephrEFb7Xk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kp3_RW92gbAb"
      },
      "source": [
        "Explicit int creation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ofeE6JIny5TH"
      },
      "source": [
        "x_explicit = int(3) #not common"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sk_8DFcuL9ey"
      },
      "source": [
        "print(x + 1)   # Addition\n",
        "print(x - 1)   # Subtraction\n",
        "print(x * 2)   # Multiplication\n",
        "print(x ** 2)  # Exponentiation"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2zZJJpV7gnr7"
      },
      "source": [
        "int object methods"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vadbFcpLiyzW"
      },
      "source": [
        "dir(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U4Jl8K0tL9e4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "44c79544-3906-4d42-dc28-f7e96d08ca87"
      },
      "source": [
        "x += 1\n",
        "print(x)\n",
        "x *= 2\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "21\n",
            "42\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w-nZ0Sg_L9e9"
      },
      "source": [
        "# 64-bit\n",
        "y = 2.5\n",
        "print(type(y))\n",
        "print(y, y + 1, y * 2, y ** 2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r2A9ApyaL9fB"
      },
      "source": [
        "\n",
        "Python also has built-in types for long integers and complex numbers; you can find all of the details in the [documentation](https://docs.python.org/3.7/library/stdtypes.html#numeric-types-int-float-long-complex)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EqRS7qhBL9fC"
      },
      "source": [
        "### Booleans"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nv_LIVOJL9fD"
      },
      "source": [
        "Python implements all of the usual operators for Boolean logic, but uses English words rather than symbols (`&&`, `||`, etc.):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RvoImwgGL9fE"
      },
      "source": [
        "t, f = True, False\n",
        "print(type(t))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YQgmQfOgL9fI"
      },
      "source": [
        "Now we let's look at the operations:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6zYm7WzCL9fK"
      },
      "source": [
        "print(t and f) # Logical AND;\n",
        "print(t or f)  # Logical OR;\n",
        "print(not t)   # Logical NOT;\n",
        "print(t != f)  # Logical XOR;"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UQnQWFEyL9fP"
      },
      "source": [
        "### Strings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ntD79HXlgGo"
      },
      "source": [
        "<img src=\"https://files.realpython.com/media/t.f398a9e25af0.png\" width=\"200\" height=\"70\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9RRex1W7lsgm"
      },
      "source": [
        "s = 'foobar'\n",
        "s[3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AijEDtPFL9fP"
      },
      "source": [
        "hello = 'good'   # String literals can use single quotes\n",
        "world = \"morning\"   # or double quotes; it does not matter\n",
        "print(hello, len(hello))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "saDeaA7hL9fT"
      },
      "source": [
        "hw = hello + ' ' + world  # String concatenation\n",
        "print(hw)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nji1_UjYL9fY"
      },
      "source": [
        "hw12 = '{}-{}-{}'.format(hello, world, 12)  # string formatting\n",
        "print(hw12)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "84-lRtb7bdk7"
      },
      "source": [
        "hw22 = f'{hello}-{world}-{22}' # latest way is f-strings\n",
        "print(hw22)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bUpl35bIL9fc"
      },
      "source": [
        "String objects have a bunch of useful methods; for example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VOxGatlsL9fd"
      },
      "source": [
        "s = \"hello\"\n",
        "print(s.capitalize())  # Capitalize a string\n",
        "print(s.upper())       # Convert a string to uppercase; prints \"HELLO\"\n",
        "print(s.rjust(7))      # Right-justify a string, padding with spaces\n",
        "print(s.center(7))     # Center a string, padding with spaces\n",
        "print(s.replace('l', '(ell)'))  # Replace all instances of one substring with another\n",
        "print('  world '.strip())  # Strip leading and trailing whitespace, useful in text processing"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "06cayXLtL9fi"
      },
      "source": [
        "You can find a list of all string methods in the [documentation](https://docs.python.org/3.7/library/stdtypes.html#string-methods)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vT_ch1VQMel4"
      },
      "source": [
        "### Other bases"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tRmOx9jmMaN7"
      },
      "source": [
        "print(0o10) # Octal\n",
        "print(0x10) # Hexa\n",
        "print(0b101) # Binary"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zxMimFJYzS1D"
      },
      "source": [
        "### Magic Methods\n",
        "Magic methods in Python are the special methods that start and end with the double underscores. They are also called dunder methods. Magic methods are not meant to be invoked directly by you, but the invocation happens internally from the class on a certain action."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sxAI9Pdz0bri"
      },
      "source": [
        "dir(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IlnYoPHwi9RA"
      },
      "source": [
        "x.__pow__(2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yI51J46jh4rE"
      },
      "source": [
        "x **2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p-6hClFjL9fk"
      },
      "source": [
        "## Containers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FD9H18eQL9fk"
      },
      "source": [
        "*   **Python** includes several built-in **container** types: lists, dictionaries, sets, and tuples.  \n",
        "*   The **Collection** in **Java** is a framework that provides an architecture to store and manipulate the group of objects.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UsIWOe0LL9fn"
      },
      "source": [
        "### Lists"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wzxX7rgWL9fn"
      },
      "source": [
        "A list is the Python equivalent of an array, but is resizeable and can contain elements of different types:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hk3A8pPcL9fp"
      },
      "source": [
        "xs = [3, 1, 2]   # Create a list\n",
        "print(xs, xs[2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q5MB4QUhpCyH"
      },
      "source": [
        "is mutatble ?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YCjCy_0_L9ft"
      },
      "source": [
        "xs[2] = 'foo'    # Lists can contain elements of different types\n",
        "print(xs)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vJ0x5cF-L9fx"
      },
      "source": [
        "xs.append('bar') # Add a new element to the end of the list\n",
        "print(xs)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cxVCNRTNL9f1"
      },
      "source": [
        "x = xs.pop()     # Remove and return the last element of the list\n",
        "print(x, xs)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PpjlYGWxoe7s"
      },
      "source": [
        "Lists can be nested.\n",
        "\n",
        "<img src=\"https://robocrop.realpython.net/?url=https%3A//files.realpython.com/media/t.08554d94a1e5.png&w=1150&sig=dd460296ea6940e0ea6e809b7d98b1272708da03\" width=\"400\" height=\"210\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pvdzW9y3eBfl"
      },
      "source": [
        "x = ['a', ['bb', ['ccc', 'ddd'], 'ee', 'ff'], 'g', ['hh', 'ii'], 'j'] # different object types in same list\n",
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mAeEpew7oDDJ"
      },
      "source": [
        "neagitive index"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "26RTPUMlnue-"
      },
      "source": [
        "<img src=\"https://files.realpython.com/media/t.c11ea56e8ca2.png\" width=\"300\" height=\"110\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0ClVR1dGoAo9"
      },
      "source": [
        "a = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge']\n",
        "a[-2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ilyoyO34L9f4"
      },
      "source": [
        "As usual, you can find all the details about lists in the [documentation](https://docs.python.org/3.7/tutorial/datastructures.html#more-on-lists)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ovahhxd_L9f5"
      },
      "source": [
        "### Slicing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YeSYKhv9L9f6"
      },
      "source": [
        "In addition to accessing list elements one at a time, Python provides concise syntax to access sublists; this is known as slicing:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ninq666bL9f6"
      },
      "source": [
        "nums = list(range(5))    # range is a built-in function that creates a list of integers\n",
        "print(nums)         # Prints \"[0, 1, 2, 3, 4]\"\n",
        "print(nums[2:4])    # Get a slice from index 2 to 4 (exclusive); prints \"[2, 3]\"\n",
        "print(nums[2:])     # Get a slice from index 2 to the end; prints \"[2, 3, 4]\"\n",
        "print(nums[:2])     # Get a slice from the start to index 2 (exclusive); prints \"[0, 1]\"\n",
        "print(nums[:])      # Get a slice of the whole list; prints [\"0, 1, 2, 3, 4]\"\n",
        "print(nums[:-1])    # Slice indices can be negative; prints [\"0, 1, 2, 3]\"\n",
        "nums[2:4] = [8, 9] # Assign a new sublist to a slice\n",
        "print(nums)         # Prints \"[0, 1, 8, 9, 4]\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OM2IX4RgiCkK"
      },
      "source": [
        "ynwa = [\"you\", \"will\", \"never\", \"walk\", \"alone\"]\n",
        "ynwa.index(\"walk\") # finding element"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UONpMhF4L9f_"
      },
      "source": [
        "### Loops"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_DYz1j6QL9f_"
      },
      "source": [
        "You can loop over the elements of a list like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4cCOysfWL9gA"
      },
      "source": [
        "animals = ['cat', 'dog', 'monkey']\n",
        "for animal in animals:\n",
        "    print(animal)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KxIaQs7pL9gE"
      },
      "source": [
        "If you want access to the index of each element within the body of a loop, use the built-in `enumerate` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JjGnDluWL9gF"
      },
      "source": [
        "animals = ['cat', 'dog', 'monkey']\n",
        "for idx, animal in enumerate(animals):\n",
        "    print(f'#{idx+1}: {animal}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "arrLCcMyL9gK"
      },
      "source": [
        "### List comprehensions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Qn2jU_pL9gL"
      },
      "source": [
        "When programming, frequently we want to transform one type of data into another. As a simple example, consider the following code that computes square numbers:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IVNEwoMXL9gL"
      },
      "source": [
        "nums = [0, 1, 2, 3, 4]\n",
        "squares = []\n",
        "for x in nums:\n",
        "    squares.append(x ** 2)\n",
        "print(squares)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7DmKVUFaL9gQ"
      },
      "source": [
        "You can make this code simpler using a list comprehension:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kZxsUfV6L9gR"
      },
      "source": [
        "nums = [0, 1, 2, 3, 4]\n",
        "squares = [x ** 2 for x in nums]\n",
        "print(squares)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-D8ARK7tL9gV"
      },
      "source": [
        "List comprehensions can also contain conditions, filter and transform the values in one line:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yUtgOyyYL9gV"
      },
      "source": [
        "nums = [0, 1, 2, 3, 4]\n",
        "even_squares = [x ** 2 for x in nums if x % 2 == 0]\n",
        "print(even_squares)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H8xsUEFpL9gZ"
      },
      "source": [
        "### Dictionaries"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kkjAGMAJL9ga"
      },
      "source": [
        "A dictionary stores (key, value) pairs, similar to a `Map` in Java or an object in Javascript. You can use it like this:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FZ_xDTAA8wEv"
      },
      "source": [
        "<img src=\"https://files.realpython.com/media/t.b3e3d8f2d100.png\" width=\"300\" height=\"270\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_V-T2jbi8jLs"
      },
      "source": [
        "# Create a new dictionary with some data\n",
        "MLB_team = {\n",
        "     'Colorado' : 'Rockies',\n",
        "     'Boston'   : 'Red Sox',\n",
        "     'Minnesota': 'Twins',\n",
        "     'Milwaukee': 'Brewers',\n",
        "     'Seattle'  : 'Mariners'\n",
        " }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XBYI1MrYL9gb"
      },
      "source": [
        "print(MLB_team['Boston'])       # Get an entry from a dictionary\n",
        "print('Seattle' in MLB_team)     # Check if a dictionary has a given key"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YtextAX9MNA5"
      },
      "source": [
        "is at mutable ?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pS7e-G-HL9gf"
      },
      "source": [
        "MLB_team['New York'] = 'Mets'    # Set an entry in a dictionary\n",
        "print(MLB_team['New York'] )"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tFY065ItL9gi"
      },
      "source": [
        "print(MLB_team['Los Angeles'])  # KeyError"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kiD-XHYqlbN2"
      },
      "source": [
        "better solution"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8TjbEWqML9gl"
      },
      "source": [
        "print(MLB_team.get('Atlanta', 'N/A'))  # Get an element with a default\n",
        "print(MLB_team.get('Seattle', 'N/A'))  # Get an element with a default"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0EItdNBJL9go"
      },
      "source": [
        "del MLB_team['Seattle']        # Remove an element from a dictionary\n",
        "print(MLB_team.get('Seattle', 'N/A')) # \"fish\" is no longer a key"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wqm4dRZNL9gr"
      },
      "source": [
        "You can find all you need to know about dictionaries in the [documentation](https://docs.python.org/2/library/stdtypes.html#dict)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IxwEqHlGL9gr"
      },
      "source": [
        "It is easy to iterate over the keys in a dictionary:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rYfz7ZKNL9gs"
      },
      "source": [
        "d = {'person': 2, 'cat': 4, 'spider': 8}\n",
        "for k, v in d.items():\n",
        "    print(f'A {k} has {v} legs')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "17sxiOpzL9gz"
      },
      "source": [
        "Dictionary comprehensions: These are similar to list comprehensions, but allow you to easily construct dictionaries. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8PB07imLL9gz"
      },
      "source": [
        "nums = [0, 1, 2, 3, 4]\n",
        "even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}\n",
        "print(even_num_to_square)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZvWzo0G6Mi6W"
      },
      "source": [
        "Nested Dictionary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XiP5xzGEMmGE"
      },
      "source": [
        "# keys are IDs\n",
        "students = {\n",
        "              1: {'name': 'John', 'age': '27', 'sex': 'Male',\n",
        "                  'address': {'country':'England', 'city':'London'}},\n",
        "              2: {'name': 'Marie', 'age': '22', 'sex': 'Female',\n",
        "                  'address': {'country':'France','city':'Lyon'}}\n",
        "            }"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ukwtz0AuFQSk"
      },
      "source": [
        "students[2]['address']['city']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V9MHfUdvL9g2"
      },
      "source": [
        "### Sets\n",
        "\n",
        "Python’s built-in set type has the following characteristics:\n",
        "\n",
        "\n",
        "*   Sets are unordered\n",
        "*   Set elements are unique. Duplicate elements are not allowed.\n",
        "*   A set itself may be modified, but the elements contained in the set must be of an immutable type.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rpm4UtNpL9g2"
      },
      "source": [
        "A set is an unordered collection of distinct elements. As a simple example, consider the following:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jh4yB2fEeIDC"
      },
      "source": [
        "x = set(['foo', 'bar', 'baz', 'foo', 'qux', 2, 2, 7])\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MmyaniLsL9g2"
      },
      "source": [
        "animals = {'cat', 'dog'}\n",
        "print('cat' in animals)   # Check if an element is in a set\n",
        "print('fish' in animals)  # prints ?\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dyFIFqkfe6i6"
      },
      "source": [
        "animals[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ElJEyK86L9g6"
      },
      "source": [
        "animals.add('fish')      # Add an element to a set\n",
        "print('fish' in animals)\n",
        "print(len(animals))       # Number of elements in a set;"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5uGmrxdPL9g9"
      },
      "source": [
        "animals.add('cat')       # Adding an element that is already in the set does nothing\n",
        "print(len(animals))\n",
        "animals.remove('cat')    # Remove an element from a set\n",
        "print(len(animals))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zk2DbvLKL9g_"
      },
      "source": [
        "_Loops_: Iterating over a set has the same syntax as iterating over a list; however since sets are unordered, you cannot make assumptions about the order in which you visit the elements of the set:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K47KYNGyL9hA"
      },
      "source": [
        "animals = {'cat', 'dog', 'fish'}\n",
        "for idx, animal in enumerate(animals):\n",
        "    print('#{}: {}'.format(idx + 1, animal))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "puq4S8buL9hC"
      },
      "source": [
        "Set comprehensions: Like lists and dictionaries, we can easily construct sets using set comprehensions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iw7k90k3L9hC"
      },
      "source": [
        "from math import sqrt\n",
        "print({int(sqrt(x)) for x in range(30)})"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ixn3jLUxPrM_"
      },
      "source": [
        "What will be printed ?\n",
        "Why ?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D1GplpSJPJIv"
      },
      "source": [
        "from math import sqrt\n",
        "print([int(sqrt(x)) for x in range(30)])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X77romJ2OUjb"
      },
      "source": [
        "Mathimatical view.\n",
        "\n",
        "<img src=\"https://files.realpython.com/media/t.ca57b915cec6.png\" width=\"400\" height=\"200\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-oaCb_cmOh_j"
      },
      "source": [
        "x1 = {'foo', 'bar', 'baz'}\n",
        "x2 = {'baz', 'qux', 'quux'}\n",
        "x1.union(x2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qPsHSKB1L9hF"
      },
      "source": [
        "### Tuples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kucc0LKVL9hG"
      },
      "source": [
        "A tuple is an (immutable) ordered list of values."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X2RMPHivnR7o"
      },
      "source": [
        "tup1 = ('a', 'b', 22, 33)\n",
        "tup1[2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YekLXTwcnpoM"
      },
      "source": [
        "try to change it"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qWgkaZWvndBc"
      },
      "source": [
        "tup1[2] = 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FXQQ5fMxnRA8"
      },
      "source": [
        "A tuple is in many ways similar to a list; one of the most important differences is that tuples can be used as keys in dictionaries and as elements of sets, while lists cannot. Here is a trivial example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9wHUyTKxL9hH"
      },
      "source": [
        "d = {(x, x + 1): x for x in range(10)}  # Create a dictionary with tuple keys\n",
        "t = (5, 6)      # Create a tuple\n",
        "print(d)\n",
        "print(type(t))\n",
        "print(d[t])\n",
        "print(d[(1, 2)])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GKl8DSvGPMTK"
      },
      "source": [
        "## Conditional"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2_Di3-QYPilC"
      },
      "source": [
        "<img src=\"https://files.realpython.com/media/t.78f3bacaa261.png\" width=\"400\" height=\"200\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bHfX_DGDPflo"
      },
      "source": [
        "if 'foo' in ['bar', 'baz', 'qux', 'foo']:\n",
        "    print('Expression was true')\n",
        "    print('Executing statement in suite')\n",
        "    print('...')\n",
        "    print('Done.')\n",
        "print('After conditional')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6XP4B_3bQXdO"
      },
      "source": [
        "### The elif Statement"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JrO-gpt4QU4Z"
      },
      "source": [
        "var = 100\n",
        "if var == 200:\n",
        "   print(\"1 - Got a true expression value\")\n",
        "   print(var)\n",
        "elif var == 150:\n",
        "   print(\"2 - Got a true expression value\")\n",
        "   print(var)\n",
        "elif var == 100:\n",
        "   print(\"3 - Got a true expression value\")\n",
        "   print(var)\n",
        "else:\n",
        "   print(\"4 - Got a false expression value\")\n",
        "   print(var)\n",
        "\n",
        "print(\"Good bye!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l3kJ9vyI8oc-"
      },
      "source": [
        "## Python Exceptions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mCWuJq0Z8uMu"
      },
      "source": [
        "A Python program terminates as soon as it encounters an error. In Python, an error can be a **syntax error** or an **exception**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GFBWThXF807r"
      },
      "source": [
        "Syntax errors occur when the parser detects an incorrect statement. Observe the following example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c_Dl5MC1857C"
      },
      "source": [
        "print('hello'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ryrLcB_O-YJx"
      },
      "source": [
        "We can use raise to throw an exception if a condition occurs. The statement can be complemented with a custom exception."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r-sX2nmo-nzj"
      },
      "source": [
        "x = 10\n",
        "if x > 5:\n",
        "    raise Exception(f'x should not exceed 5. The value of x was: {x}')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qO_uVSPD-zLO"
      },
      "source": [
        "Some functions raises exception, in order to handle these exceptions and avoid terminating the program, we can use try/except. demonstrated at class."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AXA4jrEOL9hM"
      },
      "source": [
        "## Functions\n",
        "\n",
        "As every language it comes with Built-In functions, we have encoutered (print(), pow()... )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WaRms-QfL9hN"
      },
      "source": [
        "Python functions are defined using the `def` keyword. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kiMDUr58L9hN"
      },
      "source": [
        "def sign(x):\n",
        "    if x > 0:\n",
        "        return 'positive'\n",
        "    elif x < 0:\n",
        "        return 'negative'\n",
        "    else:\n",
        "        return 'zero'\n",
        "\n",
        "for x in [-1, 0, 1]:\n",
        "    print(sign(x))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sign"
      ],
      "metadata": {
        "id": "K3ls3uEDzT-k"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6pcwzoCCbOZ2"
      },
      "source": [
        "New PEP 484 function annotations: [read more](https://www.python.org/dev/peps/pep-0484/)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lahL8x4-amlD"
      },
      "source": [
        "def sign(x: float) -> str:\n",
        "    if x > 0:\n",
        "        return 'positive'\n",
        "    elif x < 0:\n",
        "        return 'negative'\n",
        "    else:\n",
        "        return 'zero'\n",
        "\n",
        "for x in [-1, 0, 1]:\n",
        "    print(sign(x))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sign"
      ],
      "metadata": {
        "id": "eIS2FLZ6zdkY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U-QJFt8TL9hR"
      },
      "source": [
        "We will often define functions to take optional keyword arguments, like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PfsZ3DazL9hR"
      },
      "source": [
        "def hello(name, loud=False, age):\n",
        "    if loud:\n",
        "        print('HELLO, {}'.format(name.upper()))\n",
        "    else:\n",
        "        print('Hello, {}!'.format(name))\n",
        "\n",
        "hello('Bob',age=20)\n",
        "hello('Fred', loud=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fFCLGNtXJpYs"
      },
      "source": [
        "# Some Concepts"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QcGJT-OKKqZz"
      },
      "source": [
        "## Indentation\n",
        "This is how the code is structured.\n",
        "\n",
        "Noramally, the standard is four spaces (from the guidelines):\n",
        "\n",
        "\"Python 3 disallows mixing the use of tabs and spaces for indentation.\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OcUNxBJeKxVM"
      },
      "source": [
        "a = 0\n",
        "b = 5\n",
        "if a < b:\n",
        "    print(\"Indentation\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k2AmqzF2K2aj"
      },
      "source": [
        "# IndentationError\n",
        "if a < b:\n",
        "print(\"Indentation\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aH5KcB3yJsjo"
      },
      "source": [
        "## Object References\n",
        "\n",
        "\n",
        "*   Every variable is a reference to an object\n",
        "*   Upon assignment (=) you are creating a reference for the right-hand side.\n",
        "*   Object references doesn’t have a single type associated with *them*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fjgwUwAwQcSP"
      },
      "source": [
        "<img src=\"https://files.realpython.com/media/t.2d7bcb9afaaf.png\" width=\"300\" height=\"100\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JjKvCnU3PMrP"
      },
      "source": [
        "n = 300\n",
        "m = n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FlMBZaUVQojr"
      },
      "source": [
        "<img src=\"https://files.realpython.com/media/t.d368386b8423.png\" width=\"500\" height=\"100\" />"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NsDSbeh3poxe"
      },
      "source": [
        "print(id(n))\n",
        "print(id(m))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ryje9i9KQxLs"
      },
      "source": [
        "m = 400"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mPFioTq3Qxw0"
      },
      "source": [
        "<img src=\"https://files.realpython.com/media/t.d476d91592cd.png\" width=\"500\" height=\"200\" />"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1uv-i31BRmgp"
      },
      "source": [
        "In Python, every object that is created is given a number that uniquely identifies it. It is guaranteed that no two objects will have the same identifier during any period in which their lifetimes overlap. Once an object’s reference count drops to zero and it is garbage collected,"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rmac2HZfRUJq"
      },
      "source": [
        "print(id(n))\n",
        "print(id(m))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HRkfg-GFqNGS"
      },
      "source": [
        "m = 'Im string'\n",
        "print(m)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YukuOR56KPfI"
      },
      "source": [
        "spam = [1,2,3]\n",
        "eggs = spam\n",
        "eggs.append(99)\n",
        "spam"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DntHim8ULJrD"
      },
      "source": [
        "# also function get args by ref\n",
        "def popit(lst):\n",
        "    if lst:  # Check if empty\n",
        "        lst.pop(-1)\n",
        "popit(spam)\n",
        "eggs"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "buxNt60sRDq1"
      },
      "source": [
        "How to assign by value ?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xRv_wlR4LPo0"
      },
      "source": [
        "list1 = ['dont', 'change', 'me']\n",
        "list2 = list1.copy()\n",
        "list2.append('why?')\n",
        "print(list2)\n",
        "print(list1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dI3LHioUSCWh"
      },
      "source": [
        "## Variable Names\n",
        "Officially, variable names in Python can be any length and can consist of uppercase and lowercase letters (A-Z, a-z), digits (0-9), and the underscore character (_). An additional restriction is that, although a variable name can contain digits, the first character of a variable name cannot be a digit."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "990KSeIiSeBi"
      },
      "source": [
        "## Reserved Words\n",
        "There is one more restriction on identifier names. The Python language reserves a small set of keywords that designate special language functionality. No object can have the same name as a reserved word."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QhsFMMZOSaIo"
      },
      "source": [
        "help(\"keywords\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gUUX-nOzMAHg"
      },
      "source": [
        "### Importing modules\n",
        "Calling a .py file from where it can be accessed using the \"import\" keyword makse it a module"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile my_module.py\n",
        "\n",
        "print('Imported my_module...')\n",
        "\n",
        "test = 'Test String'\n",
        "\n",
        "\n",
        "def find_index(to_search, target):\n",
        "    '''Find the index of a value in a sequence'''\n",
        "    for i, value in enumerate(to_search):\n",
        "        if value == target:\n",
        "            return i\n",
        "\n",
        "    return -1\n",
        "print(__name__)\n",
        "if __name__ == \"__main__\":\n",
        "    print(2+3)"
      ],
      "metadata": {
        "id": "W2oMJbamocp6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LWfaXzxX_Abl"
      },
      "source": [
        "import my_module as my\n",
        "courses = ['History', 'Math', 'Physics', 'CompSci']\n",
        "my.find_index(courses, 'Math')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ObA9PRtQL9hT"
      },
      "source": [
        "# Classes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hAzL_lTkL9hU"
      },
      "source": [
        "The syntax for defining classes in Python is straightforward:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "agStB4eGRZQH"
      },
      "source": [
        "class Employee:\n",
        "\n",
        "    raise_amt = 1.04\n",
        "\n",
        "    def __init__(self, first, last, pay):\n",
        "        self.first = first\n",
        "        self.last = last\n",
        "        self.email = first + '.' + last + '@email.com'\n",
        "        self.pay = pay\n",
        "\n",
        "    def fullname(self):\n",
        "        return f'{self.first} {self.last}'\n",
        "\n",
        "    def apply_raise(self):\n",
        "        self.pay = int(self.pay * self.raise_amt)\n",
        "\n",
        "\n",
        "\n",
        "emp_1 = Employee('Lady', 'Gaga', 50000)\n",
        "emp_2 = Employee('Test', 'Employee', 60000)\n",
        "\n",
        "print(emp_2.fullname())\n",
        "print(emp_2.pay)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5rCfgVV2prob"
      },
      "source": [
        "print(Employee.raise_amt)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kn710kXHpilP"
      },
      "source": [
        "Employee.raise_amt = 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-34-QDXSSbYR"
      },
      "source": [
        "# intsance method\n",
        "emp_2.apply_raise()\n",
        "print(emp_2.pay)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RGVki2SVRdvE"
      },
      "source": [
        "## Inheritance"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rroMem8LRltl"
      },
      "source": [
        "class Developer(Employee):\n",
        "    raise_amt = 1.10\n",
        "\n",
        "    def __init__(self, first, last, pay, prog_lang):\n",
        "        super().__init__(first, last, pay)\n",
        "        self.prog_lang = prog_lang\n",
        "\n",
        "\n",
        "class Manager(Employee):\n",
        "\n",
        "    def __init__(self, first, last, pay, employees=None):\n",
        "        super().__init__(first, last, pay)\n",
        "        if employees is None:\n",
        "            self.employees = []\n",
        "        else:\n",
        "            self.employees = employees\n",
        "\n",
        "    def add_emp(self, emp):\n",
        "        if emp not in self.employees:\n",
        "            self.employees.append(emp)\n",
        "\n",
        "    def remove_emp(self, emp):\n",
        "        if emp in self.employees:\n",
        "            self.employees.remove(emp)\n",
        "\n",
        "    def print_emps(self):\n",
        "        for emp in self.employees:\n",
        "            print('-->', emp.fullname())\n",
        "\n",
        "\n",
        "dev_1 = Developer('Corey', 'Schafer', 50000, 'Python')\n",
        "dev_2 = Developer('Test', 'Employee', 60000, 'Java')\n",
        "\n",
        "mgr_1 = Manager('Sue', 'Smith', 90000, [dev_1])\n",
        "\n",
        "print(mgr_1.email)\n",
        "\n",
        "mgr_1.add_emp(dev_2)\n",
        "mgr_1.remove_emp(dev_2)\n",
        "\n",
        "mgr_1.print_emps()"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}