Part_01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Why Python \n",
    "\n",
    "- Easy to learn\n",
    "- High-level data structures\n",
    "- Compact syntax\n",
    "- Lots of useful packages for machine learning and data science"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some references:\n",
    "\n",
    "1. Tutorial: https://docs.python.org/3/tutorial/index.html\n",
    "2. Library reference: https://docs.python.org/3/library/index.html\n",
    "3. Language reference: https://docs.python.org/3/reference/index.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Language essentials\n",
    "\n",
    "- **Interpreted:** the interpeter runs a Python program by executing a line (actually, a statement) at a time\n",
    "- **Object-oriented:** numbers, strings, data structures, functions, modules, ... they are all objects\n",
    "\n",
    "## What is an object?\n",
    "- Objects are Python’s abstraction for data.\n",
    "- Every object has a **type** (e.g., integer, string, function, ...)\n",
    "- Objects have also **methods** and a **value**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Basic data types\n",
    "\n",
    "## Integers and floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "50 - 5*3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Python **expression** is a fragment of code that has a *type* and a *value*.\n",
    "\n",
    "Expressions are built using *literals* like `50`, *operators* like `*`, and *variables* like `x`.\n",
    "\n",
    "The Python interpreter **evaluates** an expression returning its value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "type(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`type()` is a *built-in function* that returns the type of an object.\n",
    "\n",
    "Objects of type `int` can store arbitrarily large numbers (up to machine capacity)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "25/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(_) # Underscore in Python stores the value of the last expression evaluated"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Objects of type `float` are stored in **64 bits**\n",
    "\n",
    "- The division operator `/` always returns a float\n",
    "- To do *floor division* and get an integer result (discarding any fractional result) you can use the `//` operator\n",
    "- To calculate the remainder you can use `%`.\n",
    "\n",
    "`#` is used for comments in the code: the interpreter ignores the rest of the line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(17 / 3) # classic division returning a float\n",
    "print(17 // 3) # floor division discarding the fractional part\n",
    "17 % 3 # operator returning the remainder of the division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`print()` is a **built-in function** used to print objects. If we don't use it to display the intermediate results, only the result of the last operation is shown as output of the cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "17 / 3\n",
    "17 // 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integers and floats can be transformed into each other using **type casting**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(3.5) # fractional part discarded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "float(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`int()` and `float()` are *constructors* for their type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "? float"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`?` opens contextual help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "In Python, we can refer to objects using **variables**. A variable corresponds to a memory area. The name of a variable is known as *identifier*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the Python interpreter encounters an **assignment instruction** like `a = 5` the expression on the right-hand side is evaluated, and the resulting object is assigned to the variable (that is, stored in the corresponding memory area). The variable is then said to *refer to that object*.\n",
    "\n",
    "A variable is not created with a type, and can be directly assigned to an object without being declared first. If we query the type of a variable, we see the type of the object it refers to."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 6\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3.14\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a **dynamically typed language**. This means that the Python interpreter does type checking only at runtime, and that the type of a variable is allowed to change over its lifetime. \n",
    "\n",
    "A statement containing just the name of a variable prints its content (or an error message if the variable is not defined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can run cells in any arbitrary order. **The actual value of a variable depends on the order of cell execution.**\n",
    "\n",
    "Below, a list of the arithmetic operators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "print(x + 3)   # addition\n",
    "print(x - x)   # subtraction\n",
    "print(x * 2)   # multiplication\n",
    "print(x ** 3)  # exponentiation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some shorthands for the assignment operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3\n",
    "print(x)\n",
    "x = x + 1 # Increment the value of x\n",
    "print(x)\n",
    "x += 1 # A shortcut for the above\n",
    "print(x)\n",
    "x *= 2 # Same as x = x * 2\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python supports **multiple assignments** of objects to variables,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = 2, 3.0, 3.5\n",
    "print(a, b, c, sep=', ') # Prints values of multiple variables with a separator string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This makes it easy to do certain operations, like **swapping two variables**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 3, 5\n",
    "print(a,b)\n",
    "a, b = b, a\n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that Python is **strongly typed**: objects with different types cannot usually be combined through operators. We see this after introducing a new type, `str` for strings of characters.\n",
    "\n",
    "String literals are expressed using single quotes `'...'` or double quotes `\"...\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'foo'\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'5' + 5 # Operator overloading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Through type casting we can select the semantics of the operator `+` (string concatenation or integer sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'5' + str(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int('5') + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implicit type conversions occur only in specific obvious circumstances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example: int is converted to float when the other operand is float\n",
    "a, b = 4.0, 2\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to understand how variables reference objects, we introduce the first **compound data type**: `list`\n",
    "\n",
    "Lists contain objects of **possibly different types**. Lists can be modified by adding or removing objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "some_list = ['one', 2, 3.0]\n",
    "type(some_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = [1, 4, 9, 16]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a description of the memory after the assignment\n",
    "\n",
    "<img src=\"Img/ref.png\" width=\"50%\" />\n",
    "\n",
    "Recall that an object has a value (`[1, 4, 9, 16]` in this case) and a list of methods. Methods are determined by the objec type and correspond to code that operates on the object.\n",
    "\n",
    "We now assign the list referenced by `squares` to another variable, `other`.\n",
    "\n",
    "Then, we use `other` to invoke the method `append` on the object referenced by `other`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "other = squares\n",
    "other.append(32) # Invocation of method append\n",
    "other"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows that the statement `other = squares` makes the two variables reference the same `list` object.\n",
    "\n",
    "<img src=\"Img/objref.png\" width=\"100%\" />\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pressing the TAB key shows the methods supported by the type of the object the variable refers to."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python data model\n",
    "\n",
    "Let's review the notions of **object** and **method**.\n",
    "- Objects have three properties: *type*, *value* and *behavior*.\n",
    "- An object’s **type** determines the **operations that the object supports** and also defines the possible values for objects of that type.\n",
    "- The *value* are the **data** contained in the object, and the *behavior* consists of all the **methods** supported by the object.\n",
    "- A **method** is a portion of code that is executed on the object when requested."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "Strings can be concatenated (glued together) with the `+` operator, and repeated with `*`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 * 'pip' + 'po'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `+=` shorthand can be also used with string objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'pip'\n",
    "s += 'po'\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String literal can span multiple lines using the triple quotes `'''`. In order to avoid end of lines being included, we can use the backslash character `\\`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('''\\\n",
    "Usage: thingy [OPTIONS]\n",
    "     -h                        Display this usage message\n",
    "     -H hostname               Hostname to connect to\n",
    "''')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some methods for the `string` type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'hello'\n",
    "print(s.capitalize())  # Capitalize a string\n",
    "print(s.upper())       # Convert a string to uppercase\n",
    "print('  world '.strip())  # Strip leading and trailing whitespace"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The syntax to invoke a method is `<expr>.<methodname>(<additional parameter values>)`\n",
    "\n",
    "The method is applied to the object obtained by evaluating `<expr>` \n",
    "- if `<expr>` is a variable like in `s.upper()`, then the object is the one referred to by the variable\n",
    "- if `<expr>` is an expression like in `'  world '.strip()`, then the object is created when the expression is evaluated\n",
    "\n",
    "`'  world '` is a *string literal*\n",
    "\n",
    "Here is a more complicated example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(3 * 'pip' + 'po').upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built-in function `dir` shows all the methods supported by an object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Names that have leading and trailing double underscores (dunders) are reserved for special use. These methods are known as **dunder methods**. This is a way for the Python system to use names that won’t conflict with user-defined names."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built-in function `len()` returns the **number of items in an object**. In case of strings, it returns the number of characters in it.\n",
    "\n",
    "Objects types can be **scalar** or **compound**.\n",
    "\n",
    "Scalar data types are `int`, `float`, `bool`, `str` and a few others. They correspond to objects whose state cannot be changed.\n",
    "\n",
    "Compound data types are divided in\n",
    "- **sequences** (such as a tuple, list, or range): the order of the elements is determined by the user\n",
    "- **collections** (such as a dictionary or set): the elements do not have a specific order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The characters in a string `s` can be accessed (in constant time) via the **indexing operator** `[ ]` with index values **from 0 to len(s)-1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'hello'\n",
    "s[len(s)-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'hello'[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python strings cannot be changed: they are *immutable*. Therefore, assigning to an indexed position in the string results in an error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0] = 'b'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NoneType\n",
    "\n",
    "The sole value of the type `NoneType` is `None`. `None` is typically used to represent the fact that a variable exists, but currently has no value assigned to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = None\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Booleans\n",
    "\n",
    "There are two Boolean values, whose literals are: `True` and `False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = True\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **boolean operators** are `or`, `and`, `not`. The first two are *short-circuit operators*: the evaluation of an expression (from left to right) is stopped as soon as its value is determined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t, f = True, False\n",
    "print(t and f, t or f, not t, sep=',  ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any object can be tested for truth value in a Boolean expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 0.1, 'pippo' \n",
    "if a and b: # if boolean expression is true then run next code block, otherwise skip it\n",
    "    print('True')\n",
    "print('Bye')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, an object is considered **true**.\n",
    "\n",
    "Here is a list of exceptions:\n",
    "- constants defined to be false: `None` and `False`\n",
    "- zero of any numeric type: `0`, `0.0`\n",
    "- empty sequences and collections: `''`, `()`, `[]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 0.0, '' \n",
    "if a or b: # if boolean expression is true then run next code block\n",
    "    print('True')\n",
    "else: # otherwise run the code block after the else statement\n",
    "    print('False')\n",
    "print('Bye')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has also *comparison operators* which evaluate to boolean\n",
    "\n",
    "| Operation| Meaning             |\n",
    "|----------|---------------------|\n",
    "|<         |strictly less than   |\n",
    "|<=        |less than or equal   |\n",
    "|>         |strictly greater than|\n",
    "|>=        |greater than or equal|\n",
    "|==        |equal                |\n",
    "|!=        |not equal            |\n",
    "\n",
    "The `==` operator checks whether two objects have the **same value** (irrespective of the type)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5 == 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7.999 < 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"pippo\"\n",
    "b = \"pip\" + \"po\"\n",
    "a == b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_1 = [2, 4, 6] # A list object\n",
    "list_2 = [2, 4] + [6] # Concatenating two lists\n",
    "list_1 == list_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(None == 0)\n",
    "print(None == '')\n",
    "print(None == False)\n",
    "print(None == None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, `int`, `float`, `bool`, and `str` are *scalar* data types. Most of the other data types are compound.\n",
    "\n",
    "Scalar values (like `3` or `'paper'`) are objects whose state cannot be changed. Therefore `a = 'paper'` and `b = a` means that both `a` and `b` refer to the same object `paper`. However, `a += 'ino'` causes `a` to refer to a **new object** `paperino` and leaves `b` unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'paper'\n",
    "b = a      # a and b refer to the same string object\n",
    "a += 'ino' # a refers to a new object, b is unchanged\n",
    "a == b"
   ]
  }
 ],
 "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.8.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}