python_basics/python_intro_part2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/jngadiub/ML_course_Pavia_23/blob/main/python_basics/python_intro_part2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Introduction to Python (Part II)\n",
        "\n",
        "Based on [W3Schools tutorial](https://www.w3schools.com/python/python_intro.asp).\n",
        "\n",
        "Additional useful links:\n",
        "\n",
        "* [python built-in functions](https://www.w3schools.com/python/python_ref_functions.asp)\n",
        "* [python file handling functions](https://www.w3schools.com/python/python_ref_file.asp)\n",
        "* [python keywords](https://www.w3schools.com/python/python_ref_keywords.asp)\n",
        "* [python exceptions](https://www.w3schools.com/python/python_ref_exceptions.asp)"
      ],
      "metadata": {
        "id": "NzwZq8_7xCOH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Functions\n",
        "\n",
        "A function is a block of code which only runs when it is called. You can pass data, known as parameters, into a function. A function can return data as a result.\n",
        "\n",
        "In Python a function is defined using the `def` keyword:"
      ],
      "metadata": {
        "id": "s9RVLsJcyKIA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function():\n",
        "  print(\"Hello from a function\")"
      ],
      "metadata": {
        "id": "iWMOQ1k4yv0o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To call a function, use the function name followed by parenthesis:"
      ],
      "metadata": {
        "id": "mKqH5JCby9yE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_function()"
      ],
      "metadata": {
        "id": "AFBvLC1jyz-q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Information can be passed into functions as arguments. Arguments are specified after the function name, inside the parentheses. You can add as many arguments as you want, just separate them with a comma.\n",
        "\n",
        "The following example has a function with one argument (`fname`). When the function is called, we pass along a first name, which is used inside the function to print the full name: "
      ],
      "metadata": {
        "id": "CO6g_I56zDLw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(fname):\n",
        "  print(fname + \" Refsnes\")\n",
        "\n",
        "my_function(\"Emil\")\n",
        "my_function(\"Tobias\")\n",
        "my_function(\"Linus\")"
      ],
      "metadata": {
        "id": "E2xXyxDZzI-h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "By default, a function must be called with the correct number of arguments. Meaning that if your function expects 2 arguments, you have to call the function with 2 arguments, not more, and not less."
      ],
      "metadata": {
        "id": "JxqQpdhYzc6O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(fname, lname):\n",
        "  print(fname + \" \" + lname)\n",
        "\n",
        "my_function(\"Emil\", \"Refsnes\")"
      ],
      "metadata": {
        "id": "qqPkMVp_zeMG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you try to call the function with 1 or 3 arguments, you will get an error: "
      ],
      "metadata": {
        "id": "u51sVsZTziZL"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rDR7jCZCuFmG"
      },
      "outputs": [],
      "source": [
        "def my_function(fname, lname):\n",
        "  print(fname + \" \" + lname)\n",
        "\n",
        "my_function(\"Emil\") "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you do not know how many arguments that will be passed into your function, add a `*` before the parameter name in the function definition. This way the function will receive a set of arguments, and can access the items accordingly:"
      ],
      "metadata": {
        "id": "q5fzZ3hnzpyc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(*args):\n",
        "  print(\"The youngest child is \" + args[-1])\n",
        "  print(\"The number of children is {NC}\".format(NC=len(args)))\n",
        "\n",
        "my_function(\"Emil\", \"Tobias\", \"Linus\")"
      ],
      "metadata": {
        "id": "CFsboPR5z0Fe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can also send arguments with the *key = value* syntax. This way the order of the arguments does not matter."
      ],
      "metadata": {
        "id": "R6xKohPv0sa2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(child3, child2, child1):\n",
        "  print(\"The youngest child is \" + child3)\n",
        "\n",
        "my_function(child1 = \"Emil\", child2 = \"Tobias\", child3 = \"Linus\")"
      ],
      "metadata": {
        "id": "xBJS728w0wE5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you do not know how many keyword arguments that will be passed into your function, add two asterisk: `**` before the parameter name in the function definition."
      ],
      "metadata": {
        "id": "iFzXhT7P0_Q-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(**kwargs):\n",
        "  print(\"His last name is \" + kwargs[\"lname\"])\n",
        "\n",
        "my_function(fname = \"Tobias\", lname = \"Refsnes\")"
      ],
      "metadata": {
        "id": "vZdg3SGq1BpH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following example shows how to use a default parameter value. If we call the function without argument, it uses the default value:"
      ],
      "metadata": {
        "id": "Nr63UZR_1dAN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(country = \"Norway\"):\n",
        "  print(\"I am from \" + country)\n",
        "\n",
        "my_function(\"Sweden\")\n",
        "my_function(\"India\")\n",
        "my_function()\n",
        "my_function(\"Brazil\") "
      ],
      "metadata": {
        "id": "L-FHig5x1e5c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Exercise: write a function that takes an array as input and print its values. Then evaluate the function on an array of your choice.*"
      ],
      "metadata": {
        "id": "d8Ck2bUI1mn0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To let a function return a value, use the `return` statement:"
      ],
      "metadata": {
        "id": "-ew0HVhR1y3P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def my_function(x):\n",
        "  return 5 * x\n",
        "\n",
        "print(my_function(3))\n",
        "print(my_function(5))\n",
        "print(my_function(9)) "
      ],
      "metadata": {
        "id": "NV9zHtrl10N5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Lambda function\n",
        "\n",
        "A lambda function is a small anonymous function. A lambda function can take any number of arguments, but can only have one expression. The syntax is:\n",
        "\n",
        "```\n",
        "lambda arguments : expression\n",
        "```\n",
        "\n",
        "The *expression* is executed taking as input the *arguments* and the result is returned:"
      ],
      "metadata": {
        "id": "eZQehl-j2CTA"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = lambda a : a + 10\n",
        "print(x(5))\n",
        "print(x(21))"
      ],
      "metadata": {
        "id": "r3aQhF9G2WUZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Lambda functions can take any number of arguments:"
      ],
      "metadata": {
        "id": "Qw0Uu9Bn2kaf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = lambda a, b : a * b\n",
        "print(x(5, 6))\n",
        "print(x(2, 3))"
      ],
      "metadata": {
        "id": "_UN8wFxz2k_7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Exercise: write a lambda function that sum three numbers.*"
      ],
      "metadata": {
        "id": "QhKREzHF2vGx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The power of lambda is better shown when you use them as an anonymous function inside another function.\n",
        "\n",
        "Say you have a function definition that takes one argument, and that argument will be multiplied with an unknown number:"
      ],
      "metadata": {
        "id": "Ftmec_qa20Kn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def myfunc(n):\n",
        "  return lambda a : a * n "
      ],
      "metadata": {
        "id": "z1VKN3iD3S5V"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*Exercise: use the above function definition to make a function that always doubles the number you send in.*"
      ],
      "metadata": {
        "id": "iKyP0wna3VxE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Classes/Objects\n",
        "\n",
        "Python is an object oriented programming language. Almost everything in Python is an object, with its properties and methods. A `Class` is like an object constructor, or a \"blueprint\" for creating custom objects.\n",
        "\n",
        "To create a class, use the keyword `class`:"
      ],
      "metadata": {
        "id": "55Aj3k4U3oie"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class MyClass:\n",
        "  x = 5"
      ],
      "metadata": {
        "id": "kPym04-S33lq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we can use the class named `MyClass` to create objects:"
      ],
      "metadata": {
        "id": "A-6oUIMR37_E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "p1 = MyClass()\n",
        "print(p1.x)"
      ],
      "metadata": {
        "id": "coKOvUfI3-f-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The examples above are classes and objects in their simplest form, and are not really useful in real life applications.\n",
        "\n",
        "To understand the meaning of classes we have to understand the built-in `__init__()` function. All classes have a function called `__init__()`, which is always executed when the class is being initiated.\n",
        "\n",
        "Use the `__init__()` function to assign values to object properties, or other operations that are necessary to do when the object is being created:"
      ],
      "metadata": {
        "id": "9QWSBNRj4B43"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "\n",
        "p1 = Person(\"John\", 36)\n",
        "\n",
        "print(p1.name)\n",
        "print(p1.age)"
      ],
      "metadata": {
        "id": "VP4OHLQm4OFV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note:** The `self` parameter is a reference to the current instance of the class, and is used to access variables that belong to the class."
      ],
      "metadata": {
        "id": "01xHOKsJ5Oih"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `__str__()` function controls what should be returned when the class object is represented as a string. If the `__str__()` function is not set, the string representation of the object is returned:\n",
        "\n",
        "**Example 1**"
      ],
      "metadata": {
        "id": "b7Dl0YjK4g6J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "\n",
        "p1 = Person(\"John\", 36)\n",
        "\n",
        "print(p1)"
      ],
      "metadata": {
        "id": "5tTtgVPH4kCp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Example 2**"
      ],
      "metadata": {
        "id": "XsVF5zDA4rmc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "\n",
        "  def __str__(self):\n",
        "    return f\"{self.name}({self.age})\"\n",
        "\n",
        "p1 = Person(\"John\", 36)\n",
        "\n",
        "print(p1) "
      ],
      "metadata": {
        "id": "AGbcNXTtzk9K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Objects can also contain methods. Methods in objects are functions that belong to the object.\n",
        "\n",
        "Let us create a method in the Person class:"
      ],
      "metadata": {
        "id": "iUC9Vo1B47Wa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(self, name, age):\n",
        "    self.name = name\n",
        "    self.age = age\n",
        "\n",
        "  def myfunc(self):\n",
        "    print(\"Hello my name is \" + self.name)\n",
        "\n",
        "p1 = Person(\"John\", 36)\n",
        "p1.myfunc()"
      ],
      "metadata": {
        "id": "DsANR7TM5EeU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Inheritance\n",
        "\n",
        "Inheritance allows us to define a class that inherits all the methods and properties from another class.\n",
        "\n",
        "**Parent class** is the class being inherited from, also called base class.\n",
        "\n",
        "**Child class** is the class that inherits from another class, also called derived class.\n",
        "\n",
        "Any class can be a parent class, so the syntax is the same as creating any other class:"
      ],
      "metadata": {
        "id": "AiNU7hi35kfH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(self, fname, lname):\n",
        "    self.firstname = fname\n",
        "    self.lastname = lname\n",
        "\n",
        "  def printname(self):\n",
        "    print(self.firstname, self.lastname)\n",
        "\n",
        "#Use the Person class to create an object, and then execute the printname method:\n",
        "\n",
        "x = Person(\"John\", \"Doe\")\n",
        "x.printname() "
      ],
      "metadata": {
        "id": "QWAnfTTP500w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To create a class that inherits the functionality from another class, send the parent class as a parameter when creating the child class:"
      ],
      "metadata": {
        "id": "NFkIMc3C56WS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " class Student(Person):\n",
        "  pass "
      ],
      "metadata": {
        "id": "g4TaHZJ45-jG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note**: Use the `pass` keyword when you do not want to add any other properties or methods to the class."
      ],
      "metadata": {
        "id": "Km70BSvi6BYP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now the `Student` class has the same properties and methods as the `Person` class. You can use the `Student` class to create an object, and then execute the `printname` method:"
      ],
      "metadata": {
        "id": "KhWA_eGF6OQo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = Student(\"Mike\", \"Olsen\")\n",
        "x.printname() "
      ],
      "metadata": {
        "id": "aa2feUhW6VQv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Above we have created a child class that inherits the properties and methods from its parent. We want now to add the `__init__()` function to the child class (instead of the `pass` keyword)."
      ],
      "metadata": {
        "id": "UWwFb-jM6cE7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student(Person):\n",
        "  def __init__(self, fname, lname):\n",
        "    #add something -- this is going to crash but do not worry!"
      ],
      "metadata": {
        "id": "iUlFtO3v6i7W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "When you add the `__init__()` function, the child class will no longer inherit the parent's `__init__()` function. In other words, the child's `__init__()` function overrides the inheritance of the parent's `__init__()` function.\n",
        "\n",
        "To keep the inheritance of the parent's `__init__()` function, add a call to the parent's `__init__()` function:"
      ],
      "metadata": {
        "id": "nbeTcEA76ijr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student(Person):\n",
        "  def __init__(self, fname, lname):\n",
        "    Person.__init__(self, fname, lname) "
      ],
      "metadata": {
        "id": "AF9wHnt16ysP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we have successfully added the `__init__()` function, and kept the inheritance of the parent class, and we are ready to add functionality in the `__init__()` function.\n",
        "\n",
        "Python also has a `super()` function that will make the child class inherit all the methods and properties from its parent:"
      ],
      "metadata": {
        "id": "L2SqzhcI6gaQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Student(Person):\n",
        "  def __init__(self, fname, lname):\n",
        "    super().__init__(fname, lname) "
      ],
      "metadata": {
        "id": "fWGHDHrV6_yH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "By using the `super()` function, you do not have to use the name of the parent element, it will automatically inherit the methods and properties from its parent.\n",
        "\n",
        "*Exercise: add new properties and methods to the Student child object and test that they work together with the Person parent object.*"
      ],
      "metadata": {
        "id": "0iRlgfQV7BfG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Modules\n",
        "\n",
        "Consider a module to be the same as a code library. A file containing a set of functions you want to include in your application.\n",
        "\n",
        "To create a module just save the code you want in a file with the file extension `.py`. I have created one for you which you can inspect at [this link](https://github.com/jngadiub/ML_course_Padova_23/blob/main/mymodule.py). The module can contain functions, but also variables of all types (arrays, dictionaries, objects etc).\n",
        "\n",
        "Now fetch from git the `mymodule.py` file with the module definition locally here on colab in order to use it:"
      ],
      "metadata": {
        "id": "fujD4Zd89zrc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Fetch module definition file from github\n",
        "!curl https://raw.githubusercontent.com/jngadiub/ML_course_Pavia_23/main/python_basics/mymodule.py -o mymodule.py"
      ],
      "metadata": {
        "id": "Iix_2U3M-bm2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we can use the module we just created, by using the `import` statement:"
      ],
      "metadata": {
        "id": "k9X8zF14-rGN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import mymodule\n",
        "\n",
        "mymodule.greeting(\"Jonathan\")\n",
        "\n",
        "a = mymodule.person1[\"age\"]\n",
        "print(a) "
      ],
      "metadata": {
        "id": "W1b-vmFJ-s87"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can name the module file whatever you like, but it must have the file extension `.py`.\n",
        "\n",
        "You can create an alias when you import a module, by using the `as` keyword:"
      ],
      "metadata": {
        "id": "KMoX1tRs_0di"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import mymodule as mx\n",
        "\n",
        "a = mx.person1[\"age\"]\n",
        "print(a) "
      ],
      "metadata": {
        "id": "zGtWP3DS_7P8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "There are several [built-in modules in Python](https://docs.python.org/3/py-modindex.html), which you can import whenever you like. Each python built-in module has the `dir()` built-in function to list all the function names (or variable names) in a module.\n",
        "\n",
        "*Exercise: import the `math` python built-in module and create a function that return the square root of its argument.*"
      ],
      "metadata": {
        "id": "h7-fU7oCA24s"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can also choose to import only parts from a module, by using the `from` keyword:"
      ],
      "metadata": {
        "id": "j8DJu6r1BkgI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from random import randint\n",
        "\n",
        "for i in range(5): print(randint(0,100))"
      ],
      "metadata": {
        "id": "1tkVQPr-BpVJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### JSON data format\n",
        "\n",
        "JSON is a popular text-based data format following JavaScript object syntax.\n",
        "\n",
        "Python has a built-in package called `json`, which can be used to work with JSON data. The package converts them into a python object (a dictionary, for example):\n",
        "\n"
      ],
      "metadata": {
        "id": "3maYMOaoCKwS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "\n",
        "# some JSON:\n",
        "x =  '{ \"name\":\"John\", \"age\":30, \"city\":\"New York\"}'\n",
        "\n",
        "# parse x:\n",
        "y = json.loads(x)\n",
        "\n",
        "# the result is a Python dictionary:\n",
        "print(y[\"age\"])"
      ],
      "metadata": {
        "id": "hqZheiX4CU1o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "At the same time you can convert Python objects (a dictionary, for example) into JSON format by using the `json.dumps()` method:"
      ],
      "metadata": {
        "id": "uB4p8-meC7Dr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "\n",
        "# a Python object (dict):\n",
        "x = {\n",
        "  \"name\": \"John\",\n",
        "  \"age\": 30,\n",
        "  \"city\": \"New York\"\n",
        "}\n",
        "\n",
        "# convert into JSON:\n",
        "y = json.dumps(x)\n",
        "\n",
        "# the result is a JSON string:\n",
        "print(y)"
      ],
      "metadata": {
        "id": "1EziWh5yC_9B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can convert Python objects of the following types, into JSON strings:\n",
        "\n",
        "* dict\n",
        "* list\n",
        "* tuple\n",
        "* string\n",
        "* int\n",
        "* float\n",
        "* True\n",
        "* False\n",
        "* None\n",
        "\n",
        "**Examples**"
      ],
      "metadata": {
        "id": "6XjhtIUYDU7Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import json\n",
        "\n",
        "print(json.dumps({\"name\": \"John\", \"age\": 30}))\n",
        "print(json.dumps([\"apple\", \"bananas\"]))\n",
        "print(json.dumps((\"apple\", \"bananas\")))\n",
        "print(json.dumps(\"hello\"))\n",
        "print(json.dumps(42))\n",
        "print(json.dumps(31.76))\n",
        "print(json.dumps(True))\n",
        "print(json.dumps(False))\n",
        "print(json.dumps(None)) "
      ],
      "metadata": {
        "id": "YPrs9qAODbu7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Convert a Python object containing all the legal data types:\n",
        "import json\n",
        "\n",
        "x = {\n",
        "  \"name\": \"John\",\n",
        "  \"age\": 30,\n",
        "  \"married\": True,\n",
        "  \"divorced\": False,\n",
        "  \"children\": (\"Ann\",\"Billy\"),\n",
        "  \"pets\": None,\n",
        "  \"cars\": [\n",
        "    {\"model\": \"BMW 230\", \"mpg\": 27.5},\n",
        "    {\"model\": \"Ford Edge\", \"mpg\": 24.1}\n",
        "  ]\n",
        "}\n",
        "\n",
        "print(json.dumps(x))"
      ],
      "metadata": {
        "id": "_jgbgqPCEXjZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The example above prints a JSON text, but it is not very easy to read, with no indentations and line breaks.\n",
        "\n",
        "The `json.dumps()` method has parameters to make it easier to read the result:"
      ],
      "metadata": {
        "id": "KpnhmFP-EfRT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "json.dumps(x, indent=4)"
      ],
      "metadata": {
        "id": "Tmgq_Ew3EjTX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can also define the `separators`, default value is (`\",\"` , `\", \"` , `\": \"`), which means using a comma and a space to separate each object, and a colon and a space to separate keys from values:"
      ],
      "metadata": {
        "id": "LpwsdQK7EnkE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "json.dumps(x, indent=4, separators=(\". \", \" = \"))"
      ],
      "metadata": {
        "id": "GgcCjgHvEtcK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `json.dumps()` method has parameters to order the keys in the result:"
      ],
      "metadata": {
        "id": "7a7V0uLNFlxt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "json.dumps(x, indent=4, sort_keys=True)"
      ],
      "metadata": {
        "id": "y2U8YkMDFnap"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Exception Handling\n",
        "\n",
        "The `try` block lets you test a block of code for errors.\n",
        "\n",
        "The `except` block lets you handle the error.\n",
        "\n",
        "The `else` block lets you execute code when there is no error.\n",
        "\n",
        "The `finally` block lets you execute code, regardless of the result of the try- and except blocks.\n"
      ],
      "metadata": {
        "id": "xTxO0MmZGAje"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "When an error occurs, or exception as we call it, Python will normally stop and generate an error message.\n",
        "\n",
        "These exceptions can be handled using the `try` statement.\n",
        "\n",
        "**Example: the `try` block will generate an exception, because `y` is not defined:**"
      ],
      "metadata": {
        "id": "VBL-zHT1GOWn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  print(y)\n",
        "except:\n",
        "  print(\"An exception occurred\") "
      ],
      "metadata": {
        "id": "CgeTUJ-6GZVG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Since the `try` block raises an error, the `except` block will be executed.\n",
        "\n",
        "Without the `try` block, the program will crash and raise an error:"
      ],
      "metadata": {
        "id": "nDH3yUAYGw0A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(y)"
      ],
      "metadata": {
        "id": "iewtv35kGz1z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can define as many exception blocks as you want, e.g. if you want to execute a special block of code for a special kind of error:"
      ],
      "metadata": {
        "id": "cgRBNquGG6Kl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  print(y)\n",
        "except NameError:\n",
        "  print(\"Variable y is not defined\")\n",
        "except:\n",
        "  print(\"Something else went wrong\") "
      ],
      "metadata": {
        "id": "vupqH918G7O9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can use the `else` keyword to define a block of code to be executed if no errors were raised:"
      ],
      "metadata": {
        "id": "HoCyyoH3HBJw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  print(\"Hello\")\n",
        "except:\n",
        "  print(\"Something went wrong\")\n",
        "else:\n",
        "  print(\"Nothing went wrong\") "
      ],
      "metadata": {
        "id": "o2elIFttHC5_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `finally` block, if specified, will be executed regardless if the try block raises an error or not:"
      ],
      "metadata": {
        "id": "B-baAaGmHHQ7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  print(y)\n",
        "except:\n",
        "  print(\"Something went wrong\")\n",
        "finally:\n",
        "  print(\"The 'try except' is finished\") "
      ],
      "metadata": {
        "id": "FQjtmHJkHJWf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "As a Python developer you can choose to throw an exception if a condition occurs:"
      ],
      "metadata": {
        "id": "9alDOJucHSlO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = -1\n",
        "if x < 0:\n",
        "  raise Exception(\"Sorry, no numbers below zero\") "
      ],
      "metadata": {
        "id": "6j4H6t_nHThe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `raise` keyword is used to raise an exception.\n",
        "\n",
        "You can define what kind of error to raise, and the text to print to the user:"
      ],
      "metadata": {
        "id": "fNzDjoyBHZrH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = \"hello\"\n",
        "if not type(x) is int:\n",
        "  raise TypeError(\"Only integers are allowed\") "
      ],
      "metadata": {
        "id": "FltGDHioHeFt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### File Handling\n",
        "\n",
        "Python has several functions for creating, reading, updating, and deleting files.\n",
        "\n",
        "The key function for working with files in Python is the `open()` function. It takes two parameters; *filename*, and *mode*.\n",
        "\n",
        "There are four different modes for opening a file:\n",
        "\n",
        "* `\"r\"` - Read - Default value. Opens a file for reading, error if the file does not exist\n",
        "\n",
        "* `\"a\"` - Append - Opens a file for appending, creates the file if it does not exist\n",
        "\n",
        "* `\"w\"` - Write - Opens a file for writing, creates the file if it does not exist\n",
        "\n",
        "* `\"x\"` - Create - Creates the specified file, returns an error if the file exists\n",
        "\n",
        "In addition you can specify if the file should be handled as binary or text mode:\n",
        "\n",
        "* `\"t\"` - Text - Default value. Text mode\n",
        "\n",
        "* `\"b\"` - Binary - Binary mode\n",
        "\n",
        "To open a file for reading it is enough to specify the name of the file:"
      ],
      "metadata": {
        "id": "8kXvd0kZHnrn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Fetch demofile.txt from github\n",
        "!curl https://raw.githubusercontent.com/jngadiub/ML_course_Pavia_23/main/python_basics/demofile.txt -o demofile.txt\n",
        "\n",
        "#Open the file\n",
        "f = open(\"demofile.txt\")"
      ],
      "metadata": {
        "id": "mCT_EMiTIH69"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `open()` function returns a file object, which has a `read()` method for reading the content of the file:"
      ],
      "metadata": {
        "id": "VNttarbwIk6S"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"demofile.txt\")\n",
        "print(f.read())"
      ],
      "metadata": {
        "id": "QfLXq6PHImtI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "By default the `read()` method returns the whole text, but you can also specify how many characters you want to return:"
      ],
      "metadata": {
        "id": "sll45_BWIvjm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"demofile.txt\")\n",
        "print(f.read(5))"
      ],
      "metadata": {
        "id": "XCF1vtVDIxCI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "You can return one line by using the `readline()` method:"
      ],
      "metadata": {
        "id": "B4zK_6tpI400"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"demofile.txt\", \"r\")\n",
        "print(f.readline()) "
      ],
      "metadata": {
        "id": "8TOOtqV7I6UP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "By calling `readline()` two times, you can read the two first lines:"
      ],
      "metadata": {
        "id": "M3bFXEmDI9vB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"demofile.txt\", \"r\")\n",
        "print(f.readline())\n",
        "print(f.readline())"
      ],
      "metadata": {
        "id": "2TRHAcE4I_P3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "By looping through the lines of the file, you can read the whole file, line by line:"
      ],
      "metadata": {
        "id": "JcjvUnswJDuW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"demofile.txt\", \"r\")\n",
        "for x in f: print(x) "
      ],
      "metadata": {
        "id": "PHCUArmIJEhL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "It is a good practice to always close the file when you are done with it:"
      ],
      "metadata": {
        "id": "LDrZ3pGzJLjw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"demofile.txt\", \"r\")\n",
        "print(f.readline())\n",
        "f.close()"
      ],
      "metadata": {
        "id": "s7kctEXjJMc6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To write to an existing file, you must add a parameter to the `open()` function:\n",
        "\n",
        "* `\"a\"` - Append - will append to the end of the file\n",
        "\n",
        "* `\"w\"` - Write - will overwrite any existing content"
      ],
      "metadata": {
        "id": "J4HK5_J7JWN1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"demofile.txt\", \"a\")\n",
        "f.write(\"Now the file has more content!\")\n",
        "f.close()\n",
        "\n",
        "#open and read the file after the appending:\n",
        "f = open(\"demofile.txt\", \"r\")\n",
        "print(f.read()) "
      ],
      "metadata": {
        "id": "gyB-R1JEJpl_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now let's overwrite the `demofile.txt` content:"
      ],
      "metadata": {
        "id": "fV5wIOmvJxN4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"demofile.txt\", \"w\")\n",
        "f.write(\"Woops! I have deleted the content!\")\n",
        "f.close()\n",
        "\n",
        "#open and read the file after the appending:\n",
        "f = open(\"demofile.txt\", \"r\")\n",
        "print(f.read())"
      ],
      "metadata": {
        "id": "0Cgb-72wJ0R7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To create a new file in Python, use the `open()` method, with one of the following parameters:\n",
        "\n",
        "* `\"x\"` - Create - will create a file, returns an error if the file exist\n",
        "\n",
        "* `\"a\"` - Append - will create a file if the specified file does not exist\n",
        "\n",
        "* `\"w\"` - Write - will create a file if the specified file does not exist"
      ],
      "metadata": {
        "id": "0yV85SuHKgkH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"myfile.txt\", \"x\")\n",
        "\n",
        "#check your local folder content\n",
        "!ls"
      ],
      "metadata": {
        "id": "5-Rh8GApKubd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you do not want to raise errors use the `w` parameter:"
      ],
      "metadata": {
        "id": "UDsgIIN5LNT3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"myfile.txt\", \"w\")"
      ],
      "metadata": {
        "id": "9FRyDVPmLPdm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To delete a file, you must import the OS module, and run its `os.remove()` function:"
      ],
      "metadata": {
        "id": "pwI20atbLojK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "os.remove(\"demofile.txt\")\n",
        "\n",
        "#check your local folder content\n",
        "!ls"
      ],
      "metadata": {
        "id": "5SRZwglSLrOP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To avoid getting an error, you might want to check if the file exists before you try to delete it:"
      ],
      "metadata": {
        "id": "Ra2uWXL7L1Ma"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "if os.path.exists(\"demofile.txt\"):\n",
        "  os.remove(\"demofile.txt\")\n",
        "else:\n",
        "  print(\"The file does not exist\") "
      ],
      "metadata": {
        "id": "R_sNzNs7L2cb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To delete an entire folder, use the `os.rmdir()` method:"
      ],
      "metadata": {
        "id": "jkpyKfTYL640"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#create a folder called myfolder\n",
        "!mkdir myfolder\n",
        "\n",
        "#check your local folder content\n",
        "!ls\n",
        "\n",
        "#now remove the folder you just created\n",
        "import os\n",
        "os.rmdir(\"myfolder\")\n",
        "\n",
        "#check your local folder content\n",
        "!ls"
      ],
      "metadata": {
        "id": "HKM0V2e3L8Zk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note:** the `os` module has many methods that allow you to interact with the system. Check the module documentation at [this link](https://docs.python.org/3/library/os.html).\n",
        "\n",
        "*Exercise: write a function that loop over the local files and folders and delete a specific one.*\n"
      ],
      "metadata": {
        "id": "SObdZyPlMRog"
      }
    }
  ]
}