{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "Per visualizzare questa presentazione come slides dovrete installare RISE ([github.com/damianavila/RISE](https://github.com/damianavila/RISE)).\n",
    "Prima di eseguire il codice degli esempi eseguite il codice di cleanup dell'ultima cella!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center>\n",
    "<h1>Corsi Python 2019</h1>\n",
    " \n",
    "<img src=\"img/logo-black.svg\" />\n",
    "</center>\n",
    "<center>Filippo Cremonese (fcremo@poul.org)</center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Cosa vedremo oggi\n",
    "\n",
    "- file\n",
    "- comprehension\n",
    "- tipi e conversioni\n",
    "- metodi di str\n",
    "- libreria standard\n",
    "- pip e virtualenv\n",
    "\n",
    "Trovate le slide su [slides.poul.org](https://slides.poul.org/) e gli esempi su [gitlab.poul.org/corsi/Python](https://gitlab.poul.org/corsi/Python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# File IO\n",
    "\n",
    "Per aprire un file si utilizza la funzione `open()`.\n",
    "\n",
    "```\n",
    "f = open(\"miofile.txt\")\n",
    "```\n",
    "Python supporta due tipi di file: testuali e binari"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# File testuali\n",
    "\n",
    "```python\n",
    "f1 = open(\"miofile1.txt\", \"r\") # apertura in lettura\n",
    "f2 = open(\"miofile2.txt\", \"w\") # apertura in scrittura dall'inizio\n",
    "f3 = open(\"miofile3.txt\", \"a\") # apertura in scrittura dalla fine\n",
    "```\n",
    "\n",
    "I file di testo vengono letti/scritti usando un __encoding__ per rappresentare i caratteri in formato binario in modo trasparente.\n",
    "\n",
    "Es: nell'encoding `utf-8`(default) il carattere `A` viene codificato come il byte di valore `0x41`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# File binari\n",
    "\n",
    "Per aprire un file in modalità binaria basta aggiungere `b` al secondo parametro di `open()`\n",
    "```python\n",
    "f1 = open(\"miofile1.bin\", \"rb\") # apertura in lettura\n",
    "f2 = open(\"miofile2.bin\", \"wb\") # apertura in scrittura dall'inizio\n",
    "f3 = open(\"miofile3.bin\", \"ab\") # apertura in scrittura dalla fine\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Scrivere file testuali\n",
    "\n",
    "Il metodo `write` di un file testuale accetta stringhe (`str`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"miofile.txt\", \"w\")\n",
    "f.write(\"Ciao!\\n\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "!cat miofile.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Scrivere file binari\n",
    "Sui file binari, invece, si scrivono e leggono `bytes`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"miofile.bin\", \"wb\")\n",
    "f.write(b\"\\xDE\\xAD\\xBE\\xEF\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "!cat miofile.bin | xxd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Esempio: leggere un file testuale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"miofile.txt\")\n",
    "letto = f.read()\n",
    "print(\"Letti: {} caratteri\".format(len(letto)))\n",
    "print(\"{}\".format(letto))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Scrivere e leggere file testuali (2)\n",
    "\n",
    "Per leggere un file una riga alla volta possiamo fare così:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "f = open(\"python_zen.txt\")\n",
    "for riga in f:\n",
    "    print(\"Letta riga:\", riga)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Chiudere file\n",
    "\n",
    "I file aperti vanno chiusi!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Il costrutto with\n",
    "\n",
    "Per evitare di dimenticarsi di chiudere un file aperto possiamo usare questo costrutto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"python_zen.txt\") as f:\n",
    "    contenuto = f.read()\n",
    "\n",
    "print(contenuto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Il file viene chiuso automaticamente"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## List comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Lista di tutti i numeri fino a 10\n",
    "numbers = [i for i in range(10)]\n",
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Lista dei numeri pari fino a 10\n",
    "evens = [i for i in numbers if i % 2 == 0]\n",
    "evens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Lista dei quadrati dei numeri pari fino a 10\n",
    "squares = [i**2 for i in evens]\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dict comprehension\n",
    "\n",
    "In modo analogo possiamo creare dizionari."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Dizionario dei numeri fino a 10, associati al loro valore al quadrato.\n",
    "squares = {i: i**2 for i in range(10)}\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Set - costruzione\n",
    "\n",
    "Insiemi matematici: contengono elementi unici non ordinati."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "insieme = set() # crea un insieme vuoto\n",
    "insieme.add(1)\n",
    "insieme.add(2)\n",
    "insieme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "insieme = {1, 2}  # equivalente a insieme = set([1,2])\n",
    "insieme.remove(2)\n",
    "insieme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "insieme.add(1)  # 1 è già presente, l'insieme rimarrà immutato\n",
    "insieme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Set - operazioni"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "A = {1,2,3,4}\n",
    "B = {2,4,6,8}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# differenza\n",
    "A - B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Unione\n",
    "A | B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Intersezione\n",
    "A & B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Set comprehension\n",
    "\n",
    "È possibile in modo analogo creare anche dei set usando le comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "A = {i for i in range(20)} # set dei numeri fino a 20\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tipi di dato"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Tipi\n",
    "\n",
    "Finora abbiamo visto che esistono diversi tipi di dato: interi, float, stringhe, liste, dizionari, ...\n",
    "\n",
    "Possiamo ottenere il tipo di una variabile o di un dato usando `type`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "type(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "type(1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "type(\"ciao\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "type([1,\"due\",3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Conversioni di tipo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "stringa = \"1\"\n",
    "type(stringa) # le variabili prendono il tipo del dato contenuto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# conversione str -> int\n",
    "numero = int(stringa) \n",
    "type(numero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Questa conversione solleverà un'eccezione\n",
    "numero_err = int(\"ciao\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Conversioni di tipo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "stringa = \"Partecipanti: \"\n",
    "n = 150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "#Errato! stringa + numero\n",
    "stringa + n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# conversione int -> str\n",
    "stringa + str(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Nella pratica per creare stringhe è meglio usare `format()`, che gestisce le conversioni"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"Partecipanti: {}\".format(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Metodi di `str`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"Ciao {}\".format(\"Luca\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"Ciao {surname} {name}\".format(name=\"Luca\", surname=\"Anonimo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Format (2)\n",
    "\n",
    "È molto utile per formattare numeri o creare tabelle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "1/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"{:.4}\".format(1/3) # Tiene solo 4 cifre decimali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"{:8}\".format(123) # Allinea a destra il numero su 8 colonne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "numeri = [1 / i for i in range(1, 6)]\n",
    "stringhe = [\"{:12.5}\".format(n) for n in numeri]\n",
    "print(\"Colonna 1\".center(12))\n",
    "for s in stringhe:\n",
    "    print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Format (3)\n",
    "\n",
    "`format()` è potente ma complesso, leggete la [documentazione](https://docs.python.org/3/library/string.html#formatstrings) e gli esempi per i dettagli su come usarlo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Formattazione - Altri metodi utili"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"stringa\".ljust(20, \"-\") # esiste anche rjust"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"stringa\".center(20, \"-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"   stringa   \".strip() # lstrip/rstrip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"stringa\".replace(\"i\", \"o\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Ricerca"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"collo\" in \"colloquio\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"ciao ci sentiamo\".count(\"ci\") # numero di occorrenze di \"ci\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"stringalunga\".find(\"inga\") # indice di \"inga\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"Prova prova\".endswith(\"ova\") # esiste anche startswith()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Casing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"maggior rispetto e leggibilità\".upper() # esiste anche lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"ciao ci sentiamo\".capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Split e join"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\"a,bi,ci,di\".split(\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "\" - \".join([\"uno\", \"due\", \"tre\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Documentazione\n",
    "\n",
    "Ci sono molti altri metodi. Consultate la documentazione!\n",
    "\n",
    "[docs.python.org/3/library/stdtypes.html#string-methods](https://docs.python.org/3/library/stdtypes.html#string-methods)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Libreria standard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Libreria standard\n",
    "\n",
    "Python include una **enorme** libreria standard.\n",
    "\n",
    "Prima di scrivere codice controllate se esiste modulo che risolve il vostro problema!\n",
    "\n",
    "[docs.python.org/3/library/index.html](https://docs.python.org/3/library/index.html)\n",
    "\n",
    "Vediamo un po' di moduli che potrebbero esservi utili."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Math\n",
    "\n",
    "Contiene funzioni per calcolare potenze, radici, logaritmi, funzioni trigononometriche."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "math.sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "math.sin(math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "math.log(math.e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "math.exp(3) # calcola e^3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Random\n",
    "\n",
    "Contiene funzioni per generare numeri e scelte casuali"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "random.choice([\"uno\", \"a\", \"caso\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "random.random() # numero casuale N. 0 <= N < 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "random.randint(10, 20) # numero casuale N. 10 <= N <= 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "random.gauss(5, 2) # numero casuale da distribuzione normale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Random\n",
    "\n",
    "**Non** usatelo per crittografia (usate `os.urandom`)\n",
    "\n",
    "Meglio ancora, non inventate i vostri algoritmi crittografici."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Time, Datetime, Calendar\n",
    "\n",
    "Funzioni per ottenere, misurare e manipolare date e orari"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import time\n",
    "time.time() # secondi dal 01/01/1970 00:00:00 UTC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "time.sleep(2.5) # sospende il processo per 2.5 secondi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "t = time.gmtime() # oggetto rappresentante l'ora corrente\n",
    "time.strftime(\"%H:%M %d/%m/%y\", t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "time.strptime(\"17:04 08/05/19\", \"%H:%M %d/%m/%y\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Logging\n",
    "\n",
    "Funzioni per stampare log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import logging\n",
    "logger = logging.getLogger()\n",
    "# Livelli predefiniti: DEBUG, INFO, WARNING, ERROR, CRITICAL\n",
    "logger.setLevel(logging.WARNING)\n",
    "logger.debug(\"Debug message\") # Non viene mostrato (DEBUG < INFO)\n",
    "logger.warning(\"Warning message\") # Viene mostrato (WARNING > INFO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Itertools\n",
    "\n",
    "Iteratori, combinazioni, permutazioni, ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import itertools\n",
    "itertools.combinations([1,2,3], 2) # Combinazioni senza ripetizioni. Ritorna un generatore!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "list(itertools.combinations([1,2,3], 2)) # conversione a lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "list(itertools.product([1,2], [3,4], [5,6])) # prodotto cartesiano"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Espressioni regolari\n",
    "\n",
    "Funzioni per cercare/modificare testo usando regex."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import re\n",
    "pattern = \"[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\\\.[a-zA-Z0-9-.]+\"\n",
    "mail_re = re.compile(pattern)\n",
    "testo = \"Un lungo testo contenente indirizzi@email.com ma anche altro, prova@test.it\"\n",
    "# Ricerca\n",
    "mail_re.findall(testo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Sostituzione\n",
    "mail_re.sub(\"<nospam>\", testo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Le regex sono stringhe che specificano un pattern.\n",
    "\n",
    "Qui trovate una guida [docs.python.org/3/howto/regex.html#regex-howto](https://docs.python.org/3/howto/regex.html#regex-howto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Pip e virtualenv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Pip e virtualenv\n",
    "\n",
    "Python ha un ecosistema di librerie contribuite dagli utenti.\n",
    "\n",
    "Per installarle si utilizza `pip`.\n",
    "\n",
    "È buona prassi mantenere un ambiente isolato per ogni progetto, usando `virtualenv`.\n",
    "\n",
    "```bash\n",
    "$ # creazione\n",
    "$ python -m venv miovirtualenv\n",
    "$ # attivazione\n",
    "$ source miovirtualenv/bin/activate \n",
    "(miovirtualenv) $ # installazione nel virtualenv attivo\n",
    "(miovirtualenv) $ pip install getch \n",
    "(miovirtualenv) $ # esecuzione nel virtualenv attivo\n",
    "(miovirtualenv) $ python mioscript.py \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Pip e virtualenv - rimozione\n",
    "\n",
    "```bash\n",
    "(miovirtualenv) $ pip uninstall getch\n",
    "(miovirtualenv) $ deactivate\n",
    "# rimozione\n",
    "$ rm -rf miovirtualenv\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Moduli 101\n",
    "\n",
    "Per dividere il codice in più file si creano dei *moduli*.\n",
    "\n",
    "Un modulo è una di queste due cose:\n",
    "\n",
    "- un file chiamato `modulo.py`, oppure\n",
    "- una cartella chiamata `modulo`\n",
    "  - contenente un file `__init__.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Moduli 101 (2)\n",
    "\n",
    "È possibile importare codice in due modi:\n",
    "\n",
    "```python\n",
    "import modulo\n",
    "from modulo import funzione_1, funzione_2\n",
    "```\n",
    "\n",
    "Al momento dell'import il codice di `modulo.py` o di `__init__.py` viene eseguito, e le funzioni e variabili globali vengono rese importabili"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Thank you!\n",
    "\n",
    "Rilasciato sotto licenza Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International\n",
    "<center>\n",
    "    <img src=\"img/creativecommons-by-nc-sa.svg\" style=\"height:150px;\" />\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# Reset\n",
    "RESET = True\n",
    "examples = [\"miofile.txt\", \"miofile.bin\"]\n",
    "if RESET:\n",
    "    import os\n",
    "    for e in examples:\n",
    "        try:\n",
    "            os.remove(e)\n",
    "        except Exception as e:\n",
    "            print(e)\n",
    "else:\n",
    "    print(\"Done nothing to reset\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "rise": {}
 },
 "nbformat": 4,
 "nbformat_minor": 2
}