Lecture 1. Basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lec1_DataSci.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNbWn0rJ5Um2WSDe/9B/13i"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kX5IPduTut2A"
      },
      "source": [
        "**Lecture 1: Basics**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IobwMIT7FXrL"
      },
      "source": [
        "Other languages: e.g. **Julia** solving main problems of Python. It's fast in scripting like python and the same powerful"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UUgkgx9nHNOl"
      },
      "source": [
        "x = 1 #assigment of the name to the integer"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ZxKjTicIMCt"
      },
      "source": [
        "#One instruction = one line\n",
        "#long instructions can be broken over multiple lines by:\n",
        "    #using the \\ character\n",
        "#x = 3 * 2 \\\n",
        "#(5 + 4)\n",
        "    #just going to the next line if the text is included in between parenthesis\n",
        "x = 3 * (2 + \n",
        "         6)\n",
        "\n",
        "#But it is possible to write more instructions on a line, if separated by ;\n",
        "x = 0; y = 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8OSymFZpKPt7"
      },
      "source": [
        "##Python names \n",
        "\n",
        "- The first character cannot be a number\n",
        "- Names that start with underscore have special meanings\n",
        "- Do not use spaces inside names\n",
        "- Names are case sensitive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lyV4dCDtJBZr",
        "outputId": "ad70c033-3e3a-4ebe-9acc-68c039f37bac"
      },
      "source": [
        "#What we can name?\n",
        "#Integer numbers (no limits in length)\n",
        "x = 0xA72 #example of binary number\n",
        "print(x)\n",
        "    #It's possible to use bases different from 10 with \n",
        "    # the prefixes: 0b, 0B (binary); 0o, 0O (octal); 0x, 0X (hexadecimal)\n",
        "\n",
        "#floating number\n",
        "    #e.g. 0.01 | .01 | 1e-2 | 1E-2\n",
        "y = 1.2\n",
        "print(y)\n",
        "  #lowest absolute value: 5e-324\n",
        "  #highest absolute value: 1e-325\n",
        "\n",
        "#complex number\n",
        "    #e.g. 2.1+3.4j | complex(2.3, 3.4)\n",
        "z = complex(2,3)\n",
        "print(z)\n",
        "\n",
        "#bool\n",
        "    #e.g. True | False\n",
        "c = True\n",
        "print(c)\n",
        "\n",
        "#strings of characters\n",
        "  #Both single or double apexes can be used \n",
        "  #Use 3 apexes for strings spanning over more lines\n",
        "u = 'first string'\n",
        "u1 = \"second string\"\n",
        "u2 = '''the\n",
        "third\n",
        "string'''\n",
        "print(u,u1,u2)\n",
        "\n",
        "#NoneType\n",
        "o = None #useful in functions and some codes"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2674\n",
            "1.2\n",
            "(2+3j)\n",
            "True\n",
            "first string second string the\n",
            "third\n",
            "string\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2HeCmUMEKUSc"
      },
      "source": [
        "## **Funcitions**\n",
        "- They can receive inputs\n",
        "- The number of inputs can be arbitrary\n",
        "- They can return an output\n",
        "- Some input parameters might have default values (keyword parameters)\n",
        "- **`help(print)`** for help\n",
        "```\n",
        "x = 1\n",
        "help(x)\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8GkatY7NLOir",
        "outputId": "695fb399-1110-4232-a0f1-0b322b05549f"
      },
      "source": [
        "#Basic functions\n",
        "  #type(object)\n",
        "type(True) #bool\n",
        "type(1) #int\n",
        "type(1.0) #float\n",
        "\n",
        "  #isinstance(object,type) - return True is object is of that type\n",
        "isinstance(False, bool) #True\n",
        "isinstance(1.0, int) #False\n",
        "\n",
        "  #print()\n",
        "  #At default, the input parameters are separated by a space,\n",
        "    #but it's possible to change this behaviour with the argument sep\n",
        "  #At default, the last printed character is the newline, \n",
        "    #but it's possible to change it with the argument end   \n",
        "print('ciao', 'hello', 'privet', sep = '-', end = 'END')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ciao-hello-privetEND"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ew6d74YrsuCV",
        "outputId": "bc9b85e5-16c2-4386-ab9b-386b6b7af384"
      },
      "source": [
        "  #input() - Then it waits for input from the standard input up to a newline character\n",
        "x = input('Insert a integer value:')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Insert a integer value:27\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "96whhNJcLaK6",
        "outputId": "a70fbcbe-d872-4bd1-9fb7-2e1a06ef2f56"
      },
      "source": [
        "#Examples\n",
        "print(x) #продолжение предыдущей команды\n",
        "print(type(x))\n",
        "isinstance(x, str)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "27\n",
            "<class 'str'>\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1aZ5IJGxLv-J"
      },
      "source": [
        "#Converttions input to an object of the corresponding type\n",
        "  #e.g. bool(), int(), float(), complex(), str()\n",
        "y = int(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ubdDSq4zL96g"
      },
      "source": [
        "## **Methods**\n",
        "\n",
        "- Similar to functions but acting on a specific object\n",
        "- They can receive inputs\n",
        "- They can change the object itself\n",
        "- They can return an output\n",
        "- Some input parameter might have default values (keyword parameters)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UNjf_WOj_45s",
        "outputId": "1e035846-90e2-4568-8174-dcc871f62600"
      },
      "source": [
        "s = 'a usEleSs sTRIng'\n",
        "  #lower letters\n",
        "s1 = s.lower() #a useless string\n",
        "  #upper letters\n",
        "s2 = s.upper() #A USELESS STRING\n",
        "  #to replace a character\n",
        "s3 = s.replace('STRING', 'EXAMPLE') # A USELESS EXAMPLE\n",
        "print(s1,s2,s3,sep = ' - ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a useless string - A USELESS STRING - a usEleSs sTRIng\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bu18-AYVMSA5",
        "outputId": "1b1c82e7-0eaf-473e-e76d-d12d92d423dc"
      },
      "source": [
        "#Another example\n",
        "m = 'natalia.kuzminykh'\n",
        "m1 = m.upper()\n",
        "m2 = m.lower()\n",
        "m3 = m.replace('.', '-')\n",
        "print(m1,m2,m3,sep = ' - ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NATALIA.KUZMINYKH - natalia.kuzminykh - natalia-kuzminykh\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UbZWg96lB9gn",
        "outputId": "8d059b3d-c26e-4da4-ff8a-ce34637d44bb"
      },
      "source": [
        "#MORE METHODS\n",
        "  #Search for substring into m. It returns the position of the first occurence \n",
        "  #If substring is not included in s, it return -1\n",
        "m4 = m.find('ia')\n",
        "\n",
        "  #Remove all the characters at the begin/end of m. \n",
        "  #At default it removes blank spaces and new lines\n",
        "m5 = m.strip('kuzminykh')\n",
        "\n",
        "  #Create a string by merging the elements in seq using s as a separator\n",
        "m6 = m.join('17')\n",
        "\n",
        "  #Create a string by merging the elements in seq using s as a separator\n",
        "m7 = m.split('AA')\n",
        "print(m4,m5,m6,m7,sep = ' - ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5 - atalia. - 1natalia.kuzminykh7 - ['natalia.kuzminykh']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tVZHFbZQF_1Z"
      },
      "source": [
        "#Special characters\n",
        "r = '\\n' #new line\n",
        "r = '\\t' #tab\n",
        "r = '\\u03B1' #UTF8 code\n",
        "print(r)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "psNiJZQxNKGg"
      },
      "source": [
        "## **Operators**\n",
        "\n",
        "- **E.g.:** *and, or, not* \n",
        "- Operators can be bool, int, float, complex\n",
        "- In numeric expressions, `True` is treated as $1$, `False` as $0$\n",
        "- The results always belongs to the wider set (`bool < int < float < complex`)\n",
        "\n",
        "---\n",
        "```\n",
        "`+ Sum \n",
        "- Subtraction\n",
        "* Product \n",
        "/ Division \n",
        "// Quotient \n",
        "% Module \n",
        "** Power`\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nibJjM_9NN4_",
        "outputId": "d12f9459-0046-4758-d72d-5b0f5590eac5"
      },
      "source": [
        "#EXAMPLES:\n",
        "x = 5 // 3 #Division\n",
        "y = 5 % 3 #Quotient \n",
        "\n",
        "  #for power\n",
        "z = 5**3 #power OR\n",
        "w = pow(5, 3) #function\n",
        "print(x, y, z, w)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 2 125 125\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 129
        },
        "id": "Ss3sVyIOOEDf",
        "outputId": "8c7dd84c-59ac-4845-9ddc-590e70a22f09"
      },
      "source": [
        "#Combining binding with operator\n",
        "  #All the arithmetic operators can be combined with the binding operator into a single expression\n",
        "\n",
        "t = 1\n",
        "t = += 1 #t = t + 1\n",
        "t = -= 2 #t = t - 2\n",
        "t = *= 3 #t = t * 3\n",
        "t = /= 4 #t = t / 4\n",
        "    #etc. "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-39-97d6bdaf1273>\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m    t = += 1 #t = t + 1\u001b[0m\n\u001b[0m         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NQxgbOp_ORQG",
        "outputId": "f5c46678-2736-4d6d-dad9-4e39ba7f5a00"
      },
      "source": [
        "#Operators with strings\n",
        "q1 = 'natalia'\n",
        "q2 = 'kuzminykh'\n",
        "q = q1 + q2\n",
        "print(q)\n",
        "\n",
        "c = 'ATC'\n",
        "c2 = 10*c\n",
        "print(c2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nataliakuzminykh\n",
            "ATCATCATCATCATCATCATCATCATCATC\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eTX6A9aSOqo2",
        "outputId": "3726b0ab-5755-4719-ce22-92d85f2716cf"
      },
      "source": [
        "#Operators\n",
        "  #in: object1 in object2\n",
        "  #True if object1 is included in object2\n",
        "  #It can be used any time object2 is iterable\n",
        "'ALL' in \"ALLTHINGSMATTER\" #True\n",
        "'ALL' in \"ORMAYBENOT\" #False\n",
        "\n",
        "  #not in operator:the opposite values\n",
        "'ALL' not \"ALLTHINGSMATTER\" #False\n",
        "'ALL' not \"ORMAYBENOT\" #True\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7LVMeMqzO_uF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1a97fe8c-5509-4fe2-8fd6-2e3b2557c18a"
      },
      "source": [
        "#Python logical operator\n",
        "  #and, or, not - boolean operators\n",
        "True or False\n",
        "False and True\n",
        "False and False\n",
        "1 and ''\n",
        "'1' and 1\n",
        "'' and 0\n",
        "0 or 1 \n",
        "\n",
        "#Relational operators\n",
        "1 == 2 #Equal\n",
        "1 != 0 # Different \n",
        "1 <= \n",
        "  #etc.\n",
        "\n",
        "#Bitwise operators\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MAkpltpYQMbs",
        "outputId": "7dce1bc9-5848-4f77-cd3d-93af9ff6554c"
      },
      "source": [
        "x = 2 & 6 #and\n",
        "# ^ - exclusive OR vs. | - Or\n",
        "# << - left shift\n",
        "# >> - right shift\n",
        "# ~ - not\n",
        "# 10\n",
        "# 110\n",
        "# 010\n",
        "# ---> 2\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ccT6_taDRJ-r"
      },
      "source": [
        "# **Problems**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AkBYVAzsXip8"
      },
      "source": [
        "## **PROBLEM 1**\n",
        "Write a program that read from the keyboard:\n",
        "\n",
        "- your name\n",
        "- your surname\n",
        "- your year of birth\n",
        "\n",
        "And it save them into separate variables. Compute your age in years and print a string with the following format:\n",
        "\n",
        "*The age of NAME SURNAME is AGE years*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HCQ11y-pXn4c",
        "outputId": "24d1bd28-80e7-402b-d494-c57e8d5b2c2f"
      },
      "source": [
        "name = input('Name: ')\n",
        "surname = input('Surname: ')\n",
        "year_of_birth = int(input('Birth year: '))\n",
        "age = 2021 - year_of_birth\n",
        "#print('The age of',name,surname,'is',age,'years') #OR\n",
        "\n",
        "#print('The age of {0:s} {1:s} is {2:d} years'.format(name, surname, age)) \n",
        "#s - string \n",
        "#d - integer\n",
        "#f - float\n",
        "\n",
        "#with the floar number for age\n",
        "print('The age of {0:s} {1:s} is {2:f} years'.format(name, surname, float(age))) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name: n\n",
            "Surname: k\n",
            "Birth year: 94\n",
            "The age of n k is 1927.000000 years\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_vm7yUZvYgTT"
      },
      "source": [
        "## **PROBLEM 2**\n",
        "\n",
        "Write a program that reads three strings from the keyboard and that it substitute any occurrence of the second string in the first one with the third one in a case-insensitive way\n",
        "\n",
        "```\n",
        "#Example:\n",
        "- string1 = 'DOG cat fish dOg'\n",
        "- string2 = 'dog'\n",
        "- string3 = 'horse'\n",
        "- results = 'horse cat fish horse'\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IB3J7sDXYnJb",
        "outputId": "cce70520-bfa3-4236-9d70-a521d6d2642c"
      },
      "source": [
        "s1 = input('First string: ')\n",
        "s2 = input('Second string: ')\n",
        "s3 = input('Third string: ')\n",
        "s4 = s1.lower().replace(s2.lower(),s3.lower())\n",
        "print(s4)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First string: DOG cat fish dOg\n",
            "Second string: dog\n",
            "Third string: horse\n",
            "horse cat fish horse\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TZZmeFL2cI6H"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h-48cBuScLE_"
      },
      "source": [
        "## **PROBLEM 3**\n",
        "Repeat *PROBLEM1* but:\n",
        "\n",
        "- Reading the input data (name, surname, and year of birth) as field of a single string separated by commas (e.g. 'Simone, Furini, 1979')\n",
        "Saving the data into a list\n",
        "- Using the format method for printing the output using 20 characters left-justified for the name, 20 characterst left-justified for the surname, and 3 digits for the age"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_cs312vtNRnJ"
      },
      "source": [
        "### **List**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eLeXKhMvNz-2"
      },
      "source": [
        "l = [23, 1.0, True, 'hello', 12, 43, 1, [9,8]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZJYPOKejN9QU",
        "outputId": "a88a78d5-9dfe-4e6f-9aa5-16bdcaecd7cf"
      },
      "source": [
        "print(len(l)) #Return the number of elements in L\n",
        "print(l[0]) #to call for the specific element \n",
        "print(l[:]) #all the elements in the list\n",
        "print(l[-3]) #indexing\n",
        "print(l[:3]) #from the first element to the one before the j-th element\n",
        "print(l[5:]) ##from the i-th element to the last one\n",
        "print(l[1:4]) #selecting\n",
        "print(l[1::-4]) #reversing\n",
        "\n",
        "#to change the element in the list\n",
        "l[1] = 'HURRAY' \n",
        "l1 = list('fhjf')\n",
        "print(l) \n",
        "\n",
        "#Remove i-th element from the list. It changes the list itself\n",
        "del l[0]\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "8\n",
            "23\n",
            "[23, 1.0, True, 'hello', 12, 43, 1, [9, 8]]\n",
            "43\n",
            "[23, 1.0, True]\n",
            "[43, 1, [9, 8]]\n",
            "[1.0, True, 'hello']\n",
            "[1.0]\n",
            "[23, 'HURRAY', True, 'hello', 12, 43, 1, [9, 8]]\n",
            "['HURRAY', True, 'hello', 12, 43, 1, [9, 8]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7D6QcNR2QxrH"
      },
      "source": [
        "### **Methods of lists**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NFKEbujYRRO0",
        "outputId": "ea0f6925-9289-4875-f9a7-d0e55030156b"
      },
      "source": [
        "l.append('COMMON') #add values to the end of the list\n",
        "l.extend([19, 94]) #add all the elements in M (iterable) at the end of l\n",
        "l.insert(88,7) #Add the element x to L at position i\n",
        "l.remove(1) #Remove the first occurrence of x from x, Error if l does not include x\n",
        "#l.pop([3]) #Remove and return the i-th element of the list (last element by default)\n",
        "l.index(12) #Return the index of the first occurrence of x in l, Error if L does not include x\n",
        "l.count(9) #Count the occurrences of x in l\n",
        "l.reverse() #Reverse the order of the elements in l\n",
        "#l.sort([reverse = False]) #Sort the elements in the list in ascending order (descending if reverse is True)\n",
        "\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[7, 94, 19, 'COMMON', [9, 8], 1, 43, 12, 'hello', 'HURRAY']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YDRyJvDYcN_X",
        "outputId": "23f59ea2-825c-40ff-d465-f730f22b9894"
      },
      "source": [
        "s= list('natalia')\n",
        "s[0] = 'N'\n",
        "print(s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['N', 'a', 't', 'a', 'l', 'i', 'a']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XCySUjQmTKDr"
      },
      "source": [
        "### **Solution**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QaT8E85hcxQw",
        "outputId": "8f558817-5194-449a-be5b-ce39235c73d4"
      },
      "source": [
        "#NOT LIKE HOW YOU NEED TO SOLVE IT\n",
        "n = input('Name: ')\n",
        "s = input('Surname: ')\n",
        "y = int(input('Birth year: '))\n",
        "age = 2021 - y\n",
        " \n",
        "n1 = list(n)\n",
        "s1 = list(s)\n",
        "#print('The age of {0:s} {1:s} is {2:f} years'.format(n1, s1, age))\n",
        "print('The age of',n1, s1,'is',age,'years') #OR"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name: d\n",
            "Surname: s\n",
            "Birth year: 1994\n",
            "The age of ['d'] ['s'] is 27 years\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VVyMPOhrigXp",
        "outputId": "c35df6cd-e21d-434d-b0f3-45a73e36074c"
      },
      "source": [
        "#THE RIGHT SOLUTION\n",
        "s = input('Write NAME, SURNAME, YEAR_OF_BIRTH: ').split(',')\n",
        "s[2] = 2021 - int(s[2])\n",
        "print('{0:<20s}{1:<20s}{2:3d}'.format(s[0],s[1],s[2]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write NAME, SURNAME, YEAR_OF_BIRTH: Natalia, Kuzminykh, 1994\n",
            "Natalia              Kuzminykh           27\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kCUMD_nSvBic"
      },
      "source": [
        "### **Missing part:**\n",
        "\n",
        "- Aliasing\n",
        "- is operator\n",
        "- copy methods\n",
        "- list Vs strings / tuples\n",
        "- set & dictionary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x6ygLWXYvScr",
        "outputId": "5689a381-2465-4351-9214-91c8c9022e17"
      },
      "source": [
        "#Aliasing\n",
        "animals_1 = ['dog', 'cat' , 'mouse']\n",
        "animals_2 = animals_1 #It creates a new label for the animals_1\n",
        "animals_2[1] = 'fish' #Thus, any change to animals_2 also affects animals_1\n",
        "print(animals_1,animals_2)\n",
        "\n",
        "#is operator\n",
        "  #It checks if two names point to the same object (not if they are equal)\n",
        "a1 = [1,2,3]\n",
        "a2 = a1\n",
        "a1 is a2 #True\n",
        "\n",
        "b1 = [1,2,3]\n",
        "b2 = [1,2,3]\n",
        "b1 is b2 #False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['dog', 'fish', 'mouse'] ['dog', 'fish', 'mouse']\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8Aq_-wB3w-j5",
        "outputId": "310850f5-4bb5-4d38-a9c4-f78482987bbb"
      },
      "source": [
        "#Example\n",
        "l1 = [23, 0, True]\n",
        "l2 = l1\n",
        "l1[0] = 24\n",
        "print(l1)\n",
        "print(l2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[24, 0, True]\n",
            "[24, 0, True]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GIHh97DRw7bS",
        "outputId": "f9106748-66e0-48c5-f33a-0b3dac52a9ee"
      },
      "source": [
        "#copy method\n",
        "  #It creates a copy of the list\n",
        "  #But it does not copy the elements of the list\n",
        "z1 = [1,2,3]\n",
        "z2 = z1.copy()\n",
        "z1 is z2 #False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qYamSCbSjnrP",
        "outputId": "d2c4f216-0b61-4993-e23d-451ede7036df"
      },
      "source": [
        "from copy import deepcopy\n",
        "l1 = [1,2,3] #w1 = [23, [0,1], True]\n",
        "l2 = [4,5,6]\n",
        "l3 = [l1, l2]\n",
        "l4 = deepcopy(l3)\n",
        "l4 is l3 #False\n",
        "l4[0] is l3[0] #False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PbT1JnukyQGs"
      },
      "source": [
        "#Aliasing and binding operator\n",
        "  #The l1 defined in the last line points to a new \n",
        "  #object, so l2 still points to [1,2,3]\n",
        "l1 = [1,2,3]\n",
        "l2 = l1\n",
        "l1 = l1 + [4,5,6]\n",
        "\n",
        "  #Here, the l1 defined in the last line points to the\n",
        "  #same object defined in the first line, so in this\n",
        "  #case also l2 points to [1,2,3,4,5,6]\n",
        "l1 = [1,2,3]\n",
        "l2 = l1\n",
        "l1 += [4,5,6]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BBir2Tw40uyj"
      },
      "source": [
        "**List Vs strings**\n",
        "\n",
        "strings are similar to lists, but with two important differences:\n",
        "-  all the items are characters\n",
        "- strings are immutable\n",
        "```\n",
        "s = 'dog'\n",
        "s[0] = 'f' #ERROR\n",
        "#VS\n",
        "l = list('dog')\n",
        "l[0] = 'f' #now it works\n",
        "```\n",
        "\n",
        "**Lists Vs tuples**\n",
        "- Similar to list but immutable\n",
        "\n",
        "```\n",
        "t1 = (1,2,3)\n",
        "t2 = 4,5,6\n",
        "t1[0] = 2 #ERROR\n",
        "#VS\n",
        "t1 = () # empty tuple\n",
        "t2 = 2, # one element tuple\n",
        "l1 = [1,2,3]\n",
        "t1 = tuple(l1) # it works with any iterable\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J9XNTBQT2Oyk"
      },
      "source": [
        "**Set**\n",
        "\n",
        "- Unordered collection of elements\n",
        "- Elements can be of different types\n",
        "- Being unordered, indexing is not possible (and each object is\n",
        "included only once)\n",
        "- Elements need to be hashable objects (immutable objects are\n",
        "hashable)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6Inqk6FJlWDG",
        "outputId": "da0dd0bc-1bb5-47eb-e05d-f13185917d33"
      },
      "source": [
        "#Example of set\n",
        "s = {1,2,3,1}\n",
        "print(s) #it will skip the repitions\n",
        "\n",
        "#Set operations\n",
        "  #2 sets can be intersected with:\n",
        "    #& and union - as operators e.g. s1 | s2 and s1 & s2\n",
        "    #OR with methods s1.union(s2,...) and s1.intersection(s2,...)\n",
        "  #Difference: - as an operator e.g. s1 – s2 and s1.difference(s2,...) as method\n",
        "  #Symmetric: ^ as an operator e.g. s1 ^ s2 and s1.symmetric(s2,...)  as method\n",
        "\n",
        "s1 = {1,2,3}\n",
        "s2 = {1,4,5}\n",
        "s3 = s1 | s2 # {1,2,3,4,5}\n",
        "print(s3)\n",
        "\n",
        "#Adding/removing elements\n",
        "s3.add(6)\n",
        "s3.remove(1) #Error if item is missing\n",
        "#s3.discard(1) #As before, but without error if item is missing\n",
        "s3.update([7,8,9]) #Add all the elements in IT to SET1, where IT is an iterable\n",
        "print(s3)\n",
        "\n",
        "#Set comparisons\n",
        "s3.isdisjoint(s2) #True if there’s no element in common\n",
        "s3.issubset(s2) #True if SET3 is bigger than SET1, and all the elements in SET1 are also in SET2\n",
        "\n",
        "#FROZENSET - as sets but hashable/immutable"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3}\n",
            "{1, 2, 3, 4, 5}\n",
            "{2, 3, 4, 5, 6, 7, 8, 9}\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SO_gCsdV9oXF"
      },
      "source": [
        "**Dictionary**\n",
        "\n",
        "- set of key:value pairs\n",
        "- key needs to be hashable\n",
        "- values can be anything"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9tcWVQQm4V_V",
        "outputId": "e646f2b2-23a0-45dd-806c-424673916a82"
      },
      "source": [
        "#Example\n",
        "d = {'dog':'sobaka','cat': 'kot'}\n",
        "d['fish'] = 'ryba' #Add the k:v pair (or redefine it, if already there)\n",
        "del d['cat'] #Remove the element with key k \n",
        "print(d)\n",
        "\n",
        "print(d['dog']) #Get the value corresponding to the key k\n",
        "print(d.keys()) #Return an iterator to the keys\n",
        "print(d.values()) #Return an iterator to the values\n",
        "print(d.items()) #Return an iterator to key, value pairs"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'dog': 'sobaka', 'fish': 'ryba'}\n",
            "sobaka\n",
            "dict_keys(['dog', 'fish'])\n",
            "dict_values(['sobaka', 'ryba'])\n",
            "dict_items([('dog', 'sobaka'), ('fish', 'ryba')])\n"
          ]
        }
      ]
    }
  ]
}