Python_Basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.6.9"
    },
    "colab": {
      "name": "Python Basics.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QxZGL2Y5u_6B",
        "colab_type": "text"
      },
      "source": [
        "### Basic Data Types\n",
        "\n",
        "In programming terminology, they are also commonly known as literals. Literals can be of different types for e.g 1, 11  are of type int, 3.14 is a float and \"hello\" is a string. Remember that in Python everything is object even basic data types like int, float, string, we will elaborate more on this in later chapters.\n",
        "\n",
        "In Python, you don't need to declare types of variables ahead of time. The interpreter automatically detects the type of the variable by the data it contains. To assign value to a variable equal sign (=) is used. The = sign is also known as the assignment operator."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9Bn6Xikvu_6C",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# The following are some examples of variable declaration:\n",
        "\n",
        "x = 100                       # x is integer\n",
        "pi = 3.14                     # pi is float\n",
        "empname = \"python is great\"   # empname is string\n",
        "is_true = True               # is_true is bool\n",
        "\n",
        "a = b = c = 100               # this statement assign 100 to c, b and a."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cNIsmcULu_6G",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# python assignments\n",
        "\n",
        "c, d = 3, 4        # unpacking\n",
        "x = y = z = 0      # multiple assignment\n",
        "e = 3.5; f = 5.6   # semicolon seperates the simple statement on the same line\n",
        "e, f = f, e        # value exchange\n",
        "a, *b = [1, 2, 3, 4, 5] # extended unpacking\n",
        "\n",
        "print(a, b, sep='\\n')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QWsQKLAVu_6J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# str() method returns a string version of object\n",
        "str(12345)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0i1niuWUu_6L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# check data type\n",
        "a = 1\n",
        "type(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j7x6mju_u_6O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Augmented assignment operators\n",
        "# +=, -=. *=, /=, //=, &=. **=. >>=, <<=, &=, ^=, |=\n",
        "a += 2\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h2FcBsKUu_6Q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# format method\n",
        "# format(value, format_spec)\n",
        "\n",
        "print(format(3.141592, '10.3f'))  # input spec argument as string format"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WBqe0IwMu_6T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# fancier usage of format\n",
        "\n",
        "'Name : {0}, Student_ID : {1}'.format('your name', 1234)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "Wr572XzFu_6W",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# want to know bool?\n",
        "# try to print the following\n",
        "\n",
        "bool(3)  # True\n",
        "bool(0)  # False\n",
        "bool([]) # False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EGuKkt79u_6Y",
        "colab_type": "text"
      },
      "source": [
        "### String\n",
        "\n",
        "   1. There are six sequence types in python: strings, Unicode strings, lists, tuples, buffers, and xrange objects.\n",
        "   1. Some common operations for the sequence type object can work on both mutable and immutable sequences."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JcJs6NKcu_6Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# string basics & operations\n",
        "\n",
        "s = 'Machine Learning'\n",
        "len(s)  # length of the string"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M59zOsLCu_6b",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'Machine' in s  # check whether the substring is in s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ieSQ3Lzcu_6d",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Return a copy of the string with all the cased characters converted to uppercase\n",
        "s.upper()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3p5gkI2zu_6g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# convert to lowercase\n",
        "s.lower()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fqXdZ_hpu_6i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Return a list of the words in the string, using sep as the delimiter string\n",
        "s.split(sep='e')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_G6Ab5-zu_6n",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# If sep is not specified or is None, runs of consecutive whitespace are regarded as a single separator\n",
        "s.split()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hTRHxVQau_6p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Return the lowest index in the string where substring is found within the slice s[start:end]\n",
        "s.find('ear')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a1Mh5yiku_6r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# concatenate two sequences a and b\n",
        "a = 'Machine'\n",
        "b = 'Learning'\n",
        "a + b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qAoLv4RHu_6t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# add sequence a with itself n times\n",
        "a * 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XAAz0ZMGu_6w",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# indexing; i'th item of the sequence\n",
        "s[9]  # seq[i]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aNiIBPdyu_6y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# slicing; slice sequence from index i to j with step k\n",
        "s[2:10:2]  # seq[i:j:k]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l-TGPrvju_60",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# string is immutable data type\n",
        "s[0] = 'm'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zuxAqRaWu_62",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# change the string? -> use slicing, create new object of string and reassign\n",
        "s = 'm' + s[1:]\n",
        "s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tk-BKTGWu_65",
        "colab_type": "text"
      },
      "source": [
        "### Python Numbers\n",
        "\n",
        "This data type supports only numerical values like 1, 31.4, -1000, 0.000023, 88888888\n",
        "\n",
        "Python supports 3 different numerical types.\n",
        "\n",
        "    1. int - for integer values like 1, 100, 2255, -999999, 0, 12345678\n",
        "    2. float - for floating-point values like 2.3, 3.14, 2.71, -11.0\n",
        "    3. complex - for complex numbers like 3+2j, -2+2.3j, 10j, 4.5+3.14j"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pl-gt3x6u_65",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# int type\n",
        "\n",
        "a = 1234\n",
        "type(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0hFYOsmlu_67",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "isinstance(a, int) # check data type"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SbzsDvFVu_6-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# int() method :  conver to int data type\n",
        "int(3.2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JQYKgjMJu_7A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "int(-3.9)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "909fUgQDu_7D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "int('1234')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n9ae5fgpu_7G",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# try to convert string type of float to int type\n",
        "int(float('123.45'))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iZcWx5aDu_7I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# convert int type to other data type\n",
        "a = 1234\n",
        "float(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0F3uqzbnu_7K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "str(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3TGwYg_Ku_7M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "complex(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PCXHWz6Ku_7P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# float type\n",
        "\n",
        "a = 3.14\n",
        "isinstance(a, float)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PwZ32vk0u_7R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# we can express infinity as follows\n",
        "float('inf'), float('-inf')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e3iJS_QHu_7T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a.is_integer()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pgYNsEzSu_7U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = 3.0  # float\n",
        "a.is_integer()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tXgJieheu_7X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# complex type\n",
        "\n",
        "a = 3 + 4j\n",
        "b = 2 - 3j\n",
        "a * b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WqJt0CtBu_7Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# call attribute of real part\n",
        "a.real"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UXnEsIL4u_7a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# call attribute of imaginary part\n",
        "a.imag"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vceMWJvQu_7c",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# convert to conjugate \n",
        "a.conjugate()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3yJAl98ju_7e",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# arithmetic operator\n",
        "\n",
        "a = 10; b = 20\n",
        "\n",
        "print(a + b) # addition\n",
        "print(a - b) # subtraction\n",
        "print(a * b) # multiplication\n",
        "print(b / a) # division\n",
        "print(b & a) # modulus\n",
        "print(a ** b) # sxponent\n",
        "print(b // a) # floor division"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-ZDr22jqu_7g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# comparison operators\n",
        "\n",
        "print(a == b) # check whether the two operands are equal\n",
        "print(a != b) # check whether the two operands are not equal\n",
        "print(a > b) # check whether the left operand is greater than the right operand\n",
        "print(a < b) # check whether the left operand is less than the right operand\n",
        "print(a >= b) # check whether the left operand is greater than or equal to the right operand\n",
        "print(a <= b) # check whether the left operand is less than or equal to the right operand"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qJFJUeKyu_7i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# logical operators\n",
        "# not necessarily return bool type\n",
        "\n",
        "print(a and b)  # If both the operands are true then condition becomes true\n",
        "print(a or b)   # If any of the two operands are non-zero then condition becomes true\n",
        "print(not (a or b))  # Used to reverse the logical state of its operand."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fbcmr6Y7u_7m",
        "colab_type": "text"
      },
      "source": [
        "### Categorization of Data Types\n",
        "\n",
        "\n",
        "**1. Direct type** : supported type of python number\n",
        "            ex) int, float, complex\n",
        "\n",
        "**2. Sequence type** : any ordered collection of objects whose contents can be accessed via “indexing\" \n",
        "            ex) list, str, tuple, bytes, bytearray, range\n",
        "\n",
        "**3. Mapping type** : object that maps values of one type (the key type) to arbitrary objects, \n",
        "            ex) dict\n",
        "\n",
        "**4. Set type** : unordered collections of unique elements\n",
        "            ex) set, frozenset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iwuh6Xfbu_7m",
        "colab_type": "text"
      },
      "source": [
        "### Mutable & Immutable\n",
        "\n",
        "**1. Mutable** : Objects whose value can change\n",
        "            ex) list, dict, set\n",
        "\n",
        "**2. Immutable** : objects whose value is unchangeable once they are created\n",
        "            ex) int, float, complex, str, tuple, frozenset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LBxLr2Rzu_7n",
        "colab_type": "text"
      },
      "source": [
        "### Scalar(Literal) & Container\n",
        "\n",
        "**1. Literal/Scalar type** : a object has a specific and concrete value \n",
        "            ex) str, bytes, bytearray, int, float, complex\n",
        "            \n",
        "**1. Container type** : any object that holds an arbitrary number of other objects \n",
        "            ex) list, tuple, dict, set, frozenset"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZBaA0YNNu_7n",
        "colab_type": "text"
      },
      "source": [
        "### List\n",
        "\n",
        "1. As opposed to data types such as int, bool, float, str, a list is a compound data type where you can group values together\n",
        "1. You can create a list with square brackets\n",
        "1. It is also possible for a list to contain different types within it as well"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3YMm8MKxu_7o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# create empty list\n",
        "\n",
        "a = []\n",
        "a = list()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r4keMyaju_7p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# change the elements in list via indexing\n",
        "\n",
        "a = ['this', 'is', 'a', 'list']\n",
        "a[2] = 10\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oRyos-Wau_7r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# delete element\n",
        "\n",
        "a[:2] = []\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u8vqB9dNu_7t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# add element\n",
        "\n",
        "a[1:1] = [100, 1234]\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_lwQuXftu_7w",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# slicing from i to j with step k\n",
        "\n",
        "a[::2]  # slicing from start to end with step 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DSXayCSpu_7y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# extended slice\n",
        "\n",
        "a[::2] = list(range(2))\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FTxuoKBqu_70",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# delete elements via del keyword\n",
        "\n",
        "del a[0]\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JD4Hf9Cxu_71",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "del a[:2]\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IzM-ASO2u_74",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# nested list\n",
        "a = ['this', 'is', 'a', 'list']\n",
        "b = [1, a, 3]\n",
        "b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H5-mtr1Nu_76",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# indexing\n",
        "b[1][1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xnm0AyaSu_7-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# change element in nested list\n",
        "a[1] = 100\n",
        "b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nhUollp4u_7_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# list method (inplace operation)\n",
        "\n",
        "a.append(123) # Add x at the end of the sequence\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MnYK3Dbvu_8C",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a.insert(3, 1234) # Insert x at the position i, usage: seq.insert(i, x)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aKmdPHTeu_8E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a.index(1234) # Index of the first occurrence of 1234"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gLulTyd4u_8F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a.count(1234) # Count total number of elements in the sequence"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DIjil1d6u_8J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a.reverse() # Reverse the list, In-place operation\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DBK-QiTTu_8K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a.remove('this') #Remove first occurrence of item \n",
        "a.remove('a')\n",
        "a.remove('list')\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q3iBd8DAu_8M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Sort the list, In-place operation\n",
        "# If you want to sort Out-of-place, use sorted()\n",
        "\n",
        "print(sorted(a))\n",
        "print(a)\n",
        "\n",
        "a.sort()\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UsrUaQsCu_8O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a.pop() # return the item of last element and also remove from the list\n",
        "a.pop(0) # return the item of i'th item and remove\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DUqaO6N_u_8Q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a.extend([12345, 123456]) # extend list\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kz2gyFbyu_8R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# usage with for statement\n",
        "for i in a:\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KkGFFjiDu_8T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# If reverse is True, iterable would be sorted in reverse(descending) order\n",
        "sorted(a, reverse=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4wgAJHmcu_8U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# key argument is a function that serves as a key or a basis of sort comparison\n",
        "\n",
        "def func(a):\n",
        "    return a % 3\n",
        "\n",
        "sorted(a, key=func)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SXTGiTXdu_8W",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "L = 'Machine learning is my Life'.split()\n",
        "L"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ymZ7SYLuu_8X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sorted(L) # sorted as alphabetical order"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FlrLn-7zu_8Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sorted(L, key=str.lower) # the strings pass to str.lower() method and sorted based on str.lower(word)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3xOzJ377u_8c",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# using lambda function\n",
        "# lambda input: func(input)\n",
        "\n",
        "sorted(L, key=lambda x: len(x)) # sorted based on thier length"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MN6e7Ooju_8d",
        "colab_type": "text"
      },
      "source": [
        "### Tuple & Set\n",
        "\n",
        "1. Similar to Python lists, tuples are another standard data type that allows you to store values in a sequence    \n",
        "1. Similar to python list, **python tuple** is **ordered** data structure\n",
        "1. How tuple differs from a python list?\n",
        "    - **tuple** is **immutable** data type -> cannot change the element inplace\n",
        "\n",
        "\n",
        "1. **Python set** is **mutable** but **unordered** collection of **unique** element"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4zBb98Wwu_8d",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# create empty tuple\n",
        "t = ()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yhy3cBDOu_8g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# construct tuple\n",
        "\n",
        "t = (1,) # creating tuple with one element, need a comma\n",
        "t = 1,  # you can create without using parentheses\n",
        "t = (1, 2, 3)\n",
        "t = 1, 2, 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H6wxkfqyu_8i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# tuple is immutable -> changing the value is not supported (similar to string)\n",
        "t[0] = 10"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Sf9dRi8Bu_8j",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# tuple support membership, count, index, slicing.. method\n",
        "# nested tuple is also possible\n",
        "\n",
        "# Packing\n",
        "t = 1, 2, 'python'\n",
        "t"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DsF_CNCfu_8l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Unpacking\n",
        "a, b, c = t\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "anEE0ABHu_8m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# list also support unpacking\n",
        "l = [1, 2, 'python']\n",
        "a, b, c = l\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oXmKIBAKu_8n",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# extended unpacking\n",
        "t = 1, 2, 3, 4, 5  # create tuple\n",
        "a, *b, c = t\n",
        "print(a)\n",
        "print(b)  # b is list\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OWWMj-8uu_8o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# convert to list\n",
        "list(t)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kCs9tUVPu_8q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# tuple as arguments\n",
        "def add_sub(a, b):\n",
        "    return a + b, a - b  # return as tuple type\n",
        "\n",
        "x, y = add_sub(3, 4) # unpacking output\n",
        "print(x, y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PQ6eAbi2u_8r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "args = (3, 4)\n",
        "x, y = add_sub(*args) # equivalent to add_sub(3, 4)\n",
        "print(x, y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4ORDf5jAu_8t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = set() # create empty set (warning!: '{}' is empty dictionary)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Su4De-3Uu_8u",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "b = {1, 2, 4} # create set object\n",
        "b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "imTzocb_u_8v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# set can be created by iterable object\n",
        "set([1, 2, 3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fuPUWGjcu_8x",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "set('string') # string object is also iterable"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FvJVfxeIu_80",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# set is collection of 'unique' elements\n",
        "set([1, 2, 3, 1, 2, 3, 1, 2, 3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AfIznZnTu_81",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Only hashable type (equivalent to immutable type) can be a element of set\n",
        "a = [1, 2, 3] # list is unhashable (mutable)\n",
        "b = [3, 4, 5]\n",
        "set([a, b])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "awLBo3rDu_82",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# count the number of elements\n",
        "a = set((1, 2, 3))\n",
        "len(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RoeNdwTTu_84",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a.add(4) # add element 4  (In-place operation)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qLNZuMaEu_85",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a.update([4, 5, 6]) # a U {4, 5, 6}\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OwC8nIAmu_86",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "b = {6, 7, 8}\n",
        "c = {8, 9, 10}\n",
        "a.update(b, c) # get more than two arguments\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x1YzIBPRu_88",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# remove the elements -> remove(), discard() method\n",
        "# what's different?\n",
        "a.remove(3)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0uki38J3u_89",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Out-of-place set operation\n",
        "print(a.union(b)) # a U b\n",
        "print(a.intersection(b)) # a & b\n",
        "print(a.difference(b))  # a - b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xDYwoJj0u_8_",
        "colab_type": "text"
      },
      "source": [
        "### Dictionary\n",
        "\n",
        "1. A piece of data or values that can be accessed by a key(word) you have at hand\n",
        "1. You can store the data with key-value pair\n",
        "1. The data structure is like below:\n",
        "\n",
        "```python\n",
        "{key1: value1, key2: value2, ...}\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IV3qSUx6u_8_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = {} # create empty dictionary\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TZ6eR-3eu_9A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# create dict in various ways\n",
        "# the followings are equivalent\n",
        "\n",
        "a = {'apple': 1, 'banana': 2, 'orange': 3}\n",
        "a = dict(apple=1, banana=2, orange=3)\n",
        "a = dict([('apple',1), ('banana',2), ('orange',3)])\n",
        "\n",
        "keys = ['apple', 'banana', 'orange']\n",
        "values = (1, 2, 3)\n",
        "a = dict(zip(keys, values))  # zip return a sequence object of (key, value) pair\n",
        "\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "msh9KC4Ku_9B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a['banana'] # search using key"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZxKuuidBu_9C",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a['grape'] = 4   # set new key-value\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "csP3lvbmu_9D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a['grape'] = 0 # change the value\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h9HUqxaMu_9F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# length of dict\n",
        "len(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IiL9M2FCu_9I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "del a['banana'] # delete key\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QShe8DVRu_9J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# key must be hashable (== immutable) type (list, dict, .. can not be a key)\n",
        "# value can be every data type\n",
        "d = {}\n",
        "d['string'] = 'abc'\n",
        "d[1] = 2\n",
        "d[(1, 2, 3)] = 'tuple'\n",
        "d"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p0zRR93Bu_9L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d[[1, 2, 3]] = 'list'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "43UnJ3Weu_9M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# even function can be a key or value\n",
        "\n",
        "def add(a, b):\n",
        "    return a + b\n",
        "\n",
        "def sub(a, b):\n",
        "    return a - b\n",
        "\n",
        "d = {'add':add, 'sub':sub}\n",
        "d['add'](4, 5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lSu1apDVu_9N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# return keys \n",
        "a.keys()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "paCY05H5u_9P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# return values\n",
        "a.values()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cfpZ20_Vu_9Q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# return items\n",
        "a.items()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zu8O288Eu_9R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# dict can be used as iterable object\n",
        "for key in a:\n",
        "    print(key)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AboCHPh8u_9S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for (key, value) in a.items():\n",
        "    print(key, value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iTZ3em3lu_9T",
        "colab_type": "text"
      },
      "source": [
        "### File Read & Write\n",
        "\n",
        "Three basic things: how to open, read and write data into flat files"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rh_iRV6Ju_9T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "s = 'Welcome to tutorial on reading and writing files in python!\\n'\n",
        "f = open('text1.txt', 'w') # open file as write only mode"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LiX2N0tvu_9U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f.write(s) # write text in txt file and return number of characters"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e9v4dskOu_9W",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f.write('Writing new line\\n') # write new line in it\n",
        "f.close()\n",
        "f = open('text1.txt') # open file as read mode\n",
        "print(f.read())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jUn7BUfXu_9Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# write lines with 'with' statement\n",
        "with open('text1.txt', 'w') as f:\n",
        "    f.write('Welcome to tutorial on reading and writing files in python!\\n')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fDQaJKMFu_9Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# file read\n",
        "f = open('text1.txt') # default as read only mode\n",
        "print(f.read())\n",
        "f.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L00RHEmMu_9a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# write multiple lines using writelines method\n",
        "# usage: file.writelines(list)\n",
        "\n",
        "lines = ['Welcome to tutorial', 'on reading and writing', 'files in python!']\n",
        "f = open('text2.txt', 'w')\n",
        "f.writelines('\\n'.join(lines))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J-xH3oBgu_9b",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# read file\n",
        "# readline(), readlines() methods\n",
        "\n",
        "with open('text2.txt') as f:\n",
        "    for line in f:\n",
        "        print(line, end=' ')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zlRN-k80u_9e",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# readline()\n",
        "\n",
        "f = open('text2.txt')\n",
        "line = f.readline()\n",
        "while line:\n",
        "    print(line, end=' ')\n",
        "    line = f.readline()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4yRrgF_Ju_9f",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# readlines()\n",
        "\n",
        "f = open('text2.txt')\n",
        "f.readlines()  # return as a list"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0cysXG5Ou_9g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# open a file for appending new lines\n",
        "f = open('text2.txt', 'a')\n",
        "f.write('\\nWriting new lines!')\n",
        "\n",
        "f = open('text2.txt', 'r')\n",
        "f.readlines()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wBd13URYu_9h",
        "colab_type": "text"
      },
      "source": [
        "### Python Control Flow\n",
        "\n",
        "```if-elif-else``` are conditional statements that provide you with the decision making that is required when you want to execute code based on a particular condition. It is very common for programs to execute statements based on some conditions. The syntax of ```if-elif-else``` statement is the following:\n",
        "```python\n",
        "if boolean statement1:\n",
        "    statement1\n",
        "elif boolean statement2:\n",
        "    statement2\n",
        "else:\n",
        "    statement3\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3-aJwnmOu_9h",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# define variable\n",
        "a = 'first condition'\n",
        "b = 20\n",
        "\n",
        "# if-slif-else construct\n",
        "if a == 'first condition':\n",
        "    print('first statement')\n",
        "elif a == 'second condition':\n",
        "    print('second statement')\n",
        "elif a == 'third condition':\n",
        "    print('third statement')\n",
        "else:\n",
        "    print('no conditions match')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "9hsghAQsu_9i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# if-else construct\n",
        "if b > 10:\n",
        "    print('b is higher than 10')\n",
        "else:\n",
        "    print('b is not higher than 10')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rDbMzn4Mu_9j",
        "colab_type": "text"
      },
      "source": [
        "### Loops\n",
        "\n",
        "If you want to write the same line of code multiple times, loops help you to excute a block of code repeatedly.\n",
        "\n",
        "Python supports two kinds of loops:\n",
        "1. for loop\n",
        "1. while loop\n",
        "\n",
        "The syntax of for loop:\n",
        "```python\n",
        "for i in iterable object:\n",
        "    statement\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LnQRpsrwu_9k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# example of for loop\n",
        "# range(a, b, k) returns a sequence from a to b-1 with k step\n",
        "\n",
        "for i in range(1, 11, 2):\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f06X7Hmdu_9l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# list comprehension\n",
        "# list comprehension can utilize conditional statement to modify exisiting list\n",
        "a = [x for x in range(20) if x % 2 == 0]\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NCrw_QKlu_9m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# nested if statement with list comprehension\n",
        "a = [y for y in range(100) if y % 2 == 0 if y % 5 == 0]\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OzkTeN2Ku_9o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# if else statement with list comprehension\n",
        "a = ['even' if i % 2 == 0 else 'odd' for i in range(10)]\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ee3rcXA9u_9p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Dictionary Comprehension\n",
        "\n",
        "s = 'abcde'\n",
        "d1 = {k: v for k, v in zip(s, range(1, 6))}\n",
        "d1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x-MfEdWZu_9q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "double_d1 = {k: v * 2 for k, v in d1.items()}\n",
        "double_d1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X5WujzjUu_9q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "double_d2 = {k * 2: v for k, v in double_d1.items()}\n",
        "double_d2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B9Q6-TF2u_9r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# dict comprehension with if else conditions\n",
        "dict_cond = {k: ('even' if v % 2 == 0 else 'odd') for k, v in double_d2.items()}\n",
        "dict_cond"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOkpUAu2u_9w",
        "colab_type": "text"
      },
      "source": [
        "***Quick Question:*** Count how many times each letter appears"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RYxA2pM2u_9w",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def histogram(string):\n",
        "    histo = {}\n",
        "    ### START CODE HERE ###\n",
        "    \n",
        "    ### END CODE HERE ###\n",
        "    return histo\n",
        "\n",
        "histogram(\"extraordinary\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bx0oALMtu_9x",
        "colab_type": "text"
      },
      "source": [
        "The syntax of while loop:\n",
        "```python\n",
        "while condition:\n",
        "    statement\n",
        "```\n",
        "\n",
        "The while loop keeps executing the statements until condition becomes False. If condition becomes False, execution is out of the loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BtYJMeuqu_9x",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# example of while loop\n",
        "count = 0\n",
        "while count < 5:\n",
        "    print(count, end=' ')\n",
        "    count += 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DXdft7oAu_9y",
        "colab_type": "text"
      },
      "source": [
        "**break & continue statement**\n",
        "\n",
        "```break``` statement allows to break out of the loop.\n",
        "\n",
        "When ```continue``` statement encountered, program control goes to the end of the loop."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U4AOlzMmu_9y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# example of break statement\n",
        "count = 0\n",
        "while count < 5:\n",
        "    print(count, end=' ')\n",
        "    count += 1\n",
        "    if count == 3:  # if count becomes 3, break keyword breaks out of the loop\n",
        "        break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qn6FJiaru_9z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# example of continue statement\n",
        "count = 0\n",
        "while count < 5:\n",
        "    count += 1\n",
        "    if count > 3:\n",
        "        continue\n",
        "    print(count, end=' ')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hwcNp23zu_90",
        "colab_type": "text"
      },
      "source": [
        "**Quick Question:** Transpose the following 2D matrix by using for loop or list comprehension"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d2DnI4FPu_91",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# transpose using for loop\n",
        "matrix = [[1, 2, 3, 4], [5, 6, 7, 8]]\n",
        "matrix_transpose = [[0,0], [0,0], [0,0], [0,0]]\n",
        "\n",
        "### START CODE HERE ###\n",
        "\n",
        "### END CODE HERE ###\n",
        "        \n",
        "matrix_transpose"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zOlfmUGou_94",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# nested loops in list comprehension\n",
        "matrix = [[1, 2, 3, 4], [5, 6, 7, 8]]\n",
        "\n",
        "### START CODE HERE ###\n",
        "\n",
        "### END CODE HERE ###\n",
        "\n",
        "matrix"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PkLkwN4du_95",
        "colab_type": "text"
      },
      "source": [
        "### Python Functions\n",
        "\n",
        "You can use functions to bundle a set of instructions that you want to use repeatedly.\n",
        "\n",
        "There are three types of functions in python:\n",
        "- **Built-in functions**: predefined functions (keywords) such as ```print()```, ```str.lower()```, and so on.\n",
        "- **User-defined functions**\n",
        "- **Anonymous functions** (lambda function)\n",
        "\n",
        "The syntax for defining user-defined function :\n",
        "```python\n",
        "def func_name(arguments [-> not mandatory]):\n",
        "    statements\n",
        "    return ... [-> not mandatory]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ma_lvYKcu_96",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def hello():\n",
        "    print('Hello World')\n",
        "    return  # return None object\n",
        "\n",
        "hello()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_98sTc92u_97",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# you can call the function in another function\n",
        "\n",
        "def add_exponent(a, b):  # Required arguments! -> need to be passed during function call\n",
        "    c = add(a, b)  # we must define add() function!\n",
        "    return c ** 2\n",
        "\n",
        "def add(a, b):\n",
        "    return a + b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3PFQdRI_u_98",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "add_exponent(3, 4)  # (3 + 4)^2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8diepu2Ru_99",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Default Arguments\n",
        "\n",
        "def add(a, b=3): # assign default value to b as 3\n",
        "    return a + b\n",
        "\n",
        "add(5)  # 5 + 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pSXVsyxLu_9-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "add(5, 6) # 5 + 6 (call with positional arguments)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-yGHBKlbu_-A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# keyword arguments -> make sure all the parameters in the right order\n",
        "\n",
        "def sub(a, b):\n",
        "    return a - b\n",
        "\n",
        "sub(5, 10) # call with parameters"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lOaOh7Zfu_-B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sub(b=5, a=10) # call with keyword arguments"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XZ9DCi1tu_-C",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Having a positional argument after keyword arguments will result in errors\n",
        "sub(a=10, 5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2IoPy2Scu_-D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# usage of unpacking: *args, **kwargs\n",
        "# asterisk is placed before the tuple object\n",
        "\n",
        "args = (10, 5)\n",
        "sub(*args)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WhrT2qFju_-E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# variable number of arguments\n",
        "\n",
        "def vargs(a, *args):\n",
        "    return a, args"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3tOckoLvu_-G",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "vargs(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qdrjYw0lu_-I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "vargs(10, 11, 12)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vn880uaKu_-J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "vargs(10, 11, 12, 13, 14, 15)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WGmYi-p3u_-K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# user defined make list function\n",
        "\n",
        "def make_list(*args):\n",
        "    return list(args)\n",
        "\n",
        "make_list(1, 2, 3, 4, 5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_24Njgl9u_-M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# double asterisk(**) is placed before the dict object\n",
        "\n",
        "kwargs = dict(a=5, b=10)\n",
        "sub(**kwargs) # function call with keyword arguments"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1-52UfJuu_-M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# passing undefined keyword arguments\n",
        "\n",
        "def f(a, b, *args, **kwargs):\n",
        "    print(a, b)\n",
        "    print(args)\n",
        "    print(kwargs)\n",
        "    \n",
        "f(1, 2, 3, 4, c=5, d=6)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o0W9pR32u_-O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "args = (3, 4)\n",
        "kwargs = {'c':5, 'd':6}\n",
        "\n",
        "f(1, 2, *args, **kwargs)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hlJe3etVu_-P",
        "colab_type": "text"
      },
      "source": [
        "**Global & Local variable**\n",
        "\n",
        "**Global variable**: A variable declared outside of the function or in global scope. This means that a global variable can be accessed inside or outside of the function.\n",
        "\n",
        "**Local variable**: A variable declared inside the function's body or in the local scope."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zFN328Byu_-P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# define global variable\n",
        "x = 10\n",
        "y = 20"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pQraSP63u_-S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Local variable would be referenced(accessed) if it is assigned in local scope. Otherwise, access global variable\n",
        "\n",
        "def func1():\n",
        "    x = 11 # local variable of func1\n",
        "    def func2():\n",
        "        z = 30 # local variable of func2\n",
        "        print(x, y, z) # reference x, z for local variable and y for global variable\n",
        "    func2()\n",
        "    x = 12 # change the value of x via local variable assignment (do not affect global variable)\n",
        "    func2()\n",
        "    \n",
        "func1()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KLoRMuDau_-S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# global variable x is not affected by local variable assignment\n",
        "x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qd5DNsZRu_-T",
        "colab_type": "text"
      },
      "source": [
        "**global & nonlocal statement**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bvsJJOPIu_-T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "g = 10\n",
        "def func():\n",
        "    x = g   # g is not local -> reference global variable\n",
        "    return x\n",
        "\n",
        "func()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rirFEpTHu_-U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# you must assign before reference (no execption to local variable)\n",
        "g = 10\n",
        "def func():\n",
        "    x = g   #  2. but not assigned before reference\n",
        "    g = 10  # 1. g is considered as local variable,\n",
        "    return x\n",
        "\n",
        "func()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NsmH7SFRu_-V",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# global statement connects local to global variable\n",
        "\n",
        "g = 10\n",
        "def func():\n",
        "    global g  # connect local to global g\n",
        "    x = g\n",
        "    g = 20  # change the global variable g\n",
        "    return x\n",
        "\n",
        "func(), g"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qfl8AmVDu_-W",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# nonlocal statement connect local to variable in closest namescope\n",
        "\n",
        "def func1():\n",
        "    x = 1\n",
        "    def func2():\n",
        "        nonlocal x  # connect local x of func2 to variable x of func1\n",
        "        x = 10  # change the variable x of func1\n",
        "        print(x)\n",
        "    func2()\n",
        "    print(x)\n",
        "\n",
        "func1()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "25nJ0I8Xu_-X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# function as a argument\n",
        "\n",
        "def f(a, b):\n",
        "    return a + b\n",
        "\n",
        "def g(func, a, b):\n",
        "    return func(a, b) # function as a argument\n",
        "\n",
        "g(f, 4, 5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-39HI1tDu_-Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# lambda function\n",
        "f = lambda : 1  # no parameter, just return 1\n",
        "f()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-aQf7Pi5u_-Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f = lambda x, y: x + y\n",
        "f(4, 5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wlw31Idfu_-a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f = lambda x, y=10: x + y  # keyword argument support\n",
        "f(20)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1S1rx6V1u_-b",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "keywords = lambda x, *args, **kwargs: kwargs\n",
        "keywords(1, 2, 3, a=4, b=5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8G2Fviaxu_-c",
        "colab_type": "text"
      },
      "source": [
        "**Quick Question:** Define function that check whether a given Number is a prime number."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BfltnUm_u_-c",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def check_prime(number):\n",
        "    ### START CODE HERE ###\n",
        "    \n",
        "    ### END CODE HERE ###\n",
        "\n",
        "check_prime(2)\n",
        "check_prime(10)\n",
        "check_prime(17)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ULW7uYJu_-d",
        "colab_type": "text"
      },
      "source": [
        "**Quick Question:** Compute i'th element of Fibonacci sequence"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "njScLlRTu_-d",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def fibo(n):\n",
        "    ### START CODE HERE ###\n",
        "    \n",
        "    ### END CODE HERE ###\n",
        "\n",
        "print(fibo(10))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BJqNciU2u_-d",
        "colab_type": "text"
      },
      "source": [
        "### Class & Class Inheritance\n",
        "\n",
        "Class name in python is preceded with class keyword followed by a colon ```:```. \n",
        "\n",
        "Classes commonly contains data field to store the data and methods for defining behaviors. \n",
        "\n",
        "Its definitions play some neat tricks with namespaces"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WrfGRDjqu_-e",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class S1:\n",
        "    a = 10\n",
        "    \n",
        "S1.a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GmZQ--5Yu_-f",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "S1.b = 20 # create a new member in class namespace\n",
        "S1.b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O1jn1pgbu_-g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "inst1 = S1() # create instance object from class\n",
        "print(inst1.a)  # instance namespace is different from class namespace\n",
        "\n",
        "inst2 = S1() # create another instance object from class\n",
        "inst2.a = 100 # inst2 instance object namespace is not shared with inst1 instance object\n",
        "print(inst2.a, inst1.a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gPCIxxEru_-g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# define method in class\n",
        "# 'self' method parameter means instance object created from class itself\n",
        "\n",
        "class Person:\n",
        "    # constructor or initializer\n",
        "    def __init__(self, name): \n",
        "        self.name = name # name is data field also commonly known as instance variables\n",
        "\n",
        "    # method which returns a string\n",
        "    def whoami(self):\n",
        "        return \"You are \" + self.name"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2u4bRhMDu_-h",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "person1 = Person(name='your name')  # create instance, automatically call __init__() method first\n",
        "Person.whoami(person1) # unbound method call"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "85bZfU2Ru_-j",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# bound method call\n",
        "person1.whoami()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0rwAaCSWu_-k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# method call inside the class\n",
        "\n",
        "class Myclass:\n",
        "    def __init__(self, v):\n",
        "        self.value = v\n",
        "    def get(self):\n",
        "        return self.value\n",
        "    def count(self):\n",
        "        self.value = self.value + 1  # reference and assign to instance member\n",
        "        return self.get()  # method call"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zb1f6k7-u_-l",
        "colab_type": "text"
      },
      "source": [
        "### Class member & Instance member\n",
        "\n",
        "1. class member is defined outside of the methods\n",
        "1. instance member is defined inside method via 'self' as self.inst_member\n",
        "1. class member is created in class namespace\n",
        "1. instance member is created in instance namespace\n",
        "1. class member can be shared in all created instances\n",
        "1. instance member can be referenced from each instance object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EpBRiPS7u_-l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Var:\n",
        "    c_mem = 100 # class member\n",
        "    def f(self):\n",
        "        self.i_mem = 200 # instance member\n",
        "    def g(self):\n",
        "        return self.i_mem, self.c_mem"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GPDui0B9u_-m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "Var.c_mem  # call class member"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XjpV0Vw0u_-n",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "v1 = Var()  # create instance\n",
        "v1.c_mem    # call class member via instance object"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mGA9VchGu_-o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "v1.f()  # create instance member i_mem\n",
        "v1.i_mem  # call instance member i_mem"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4_H-x1THu_-r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Class Inheritance\n",
        "\n",
        "class parent:\n",
        "    def __init__(self):\n",
        "        self.parent_attr = 'I am a parent'\n",
        "        \n",
        "    def parent_method(self):\n",
        "        print('call parent method..')\n",
        "        \n",
        "# create child class that inherits from parent class\n",
        "class child(parent):\n",
        "    def __init__(self):\n",
        "        parent.__init__(self)\n",
        "        self.child_attr = 'I am a child'\n",
        "        "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ntr5bMelu_-t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# create instance of child\n",
        "child1 = child()\n",
        "\n",
        "# print attributes and call method\n",
        "print(child1.parent_attr)\n",
        "print(child1.child_attr)\n",
        "child1.parent_method()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MS7Fd0Tpu_-v",
        "colab_type": "text"
      },
      "source": [
        "In the simplest case, the ```super``` function can be used to replace the explicit call to \n",
        "\n",
        "```python \n",
        "Parent.__init__(self) \n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QvAh-ftWu_-v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# the above child class is identical to:\n",
        "class child(parent):\n",
        "    def __init__(self):\n",
        "        super().__init__()  # do not depend on the name of parent class and we don't need to pass 'self' to call this method!\n",
        "        self.child_attr = 'I am a child'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jxYx1Toiu_-x",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# When a method in a subclass( == child class) has the same name with the method in parent class, \n",
        "# subclass finds and references the method in its namespace.\n",
        "# see the example below\n",
        "\n",
        "class Base(object):  # equivalent to Base:\n",
        "    def f(self):\n",
        "        self.g()   # call g method\n",
        "    def g(self):\n",
        "        print('call Base class method')\n",
        "\n",
        "# create subclass Derived inherits from Base\n",
        "class Derived(Base):\n",
        "    def g(self):  # same name with parent class method\n",
        "        print('call Derived class method')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IHU7UIqdu_-x",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "b = Base()\n",
        "b.f()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r3aXGYa6u_-0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = Derived()\n",
        "a.f()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9QdJ2eoCu_-1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Multiple Inheritance without super\n",
        "\n",
        "class B:\n",
        "    def b(self):\n",
        "        print('class B')\n",
        "\n",
        "\n",
        "class C:\n",
        "    def c(self):\n",
        "        print('class C')\n",
        "\n",
        "\n",
        "class D(B, C):\n",
        "    def d(self):\n",
        "        print('class D')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wKdi3t_Cu_-2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d = D()\n",
        "d.b(); d.c(); d.d()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kFdCIhh6u_-3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# What's happening when excuting code with multiple & multilevel inheritance without super method ?\n",
        "# see the examples below\n",
        "class A:\n",
        "    def save(self):\n",
        "        print('A save called')\n",
        "        \n",
        "class B(A):\n",
        "    def save(self):\n",
        "        print('B save called')\n",
        "        A.save(self)\n",
        "        \n",
        "class C(A):\n",
        "    def save(self):\n",
        "        print('C save called')\n",
        "        A.save(self)\n",
        "        \n",
        "class D(B, C):\n",
        "    def save(self):\n",
        "        print('D save called')\n",
        "        B.save(self)\n",
        "        C.save(self)\n",
        "        \n",
        "d = D()\n",
        "d.save()  # induce redundant save!"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HJ7UXUt9u_-8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# with super method:\n",
        "class A:\n",
        "    def save(self):\n",
        "        print('A save called')\n",
        "        \n",
        "class B(A):\n",
        "    def save(self):\n",
        "        print('B save called')\n",
        "        super().save()  # prevent unwanted call\n",
        "        \n",
        "class C(A):\n",
        "    def save(self):\n",
        "        print('C save called')\n",
        "        super().save()  # prevent unwanted call\n",
        "        \n",
        "class D(B, C):\n",
        "    def save(self):\n",
        "        print('D save called')\n",
        "        super().save()\n",
        "        \n",
        "d = D()\n",
        "d.save()  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h0Dpss9su_--",
        "colab_type": "text"
      },
      "source": [
        "**References** \n",
        "\n",
        "https://thepythonguru.com/\n",
        "\n",
        "https://www.datacamp.com/community/tutorials/\n",
        "\n",
        "https://docs.python.org/3/\n",
        "\n",
        "https://www.programiz.com/python-programming\n",
        "\n",
        "https://www.programiz.com/python-programming/examples \n",
        "\n",
        "https://python.swaroopch.com/oop.html\n",
        "\n",
        "파이썬3 바이블 - 이강성 저, 프리렉(이한디지털리)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sGAg7iqDu_--",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}