installation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Installazione\n",
    "\n",
    "In questa guida vedremo se e come installare Python, le librerie addizionali, il notebook Jupyter e infine la gestione degli ambienti virtuali."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"> \n",
    "\n",
    "**A volte non serve nemmeno installare!**\n",
    "    \n",
    "Volendo puoi programmare direttamente online con i seguenti servizi\n",
    "    \n",
    "NOTA 1: se vuoi provarne uno, ricordati sempre di controllare che sia Python **3** ! \n",
    "    \n",
    "NOTA 2: Come per ogni servizio online, quando è offerto gratuitamente non abusarne. Se cerchi di processare un terabyte di dati al giorno senza pagare una sottoscrizione, rischi che ti neghino il servizio.\n",
    "   \n",
    "</div> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Python 3 su repl.it](https://repl.it/languages/python3): permette di editare codice Python anche in modo collaborativo con altri utenti, e supporta anche librerie come Matplotlib.\n",
    "\n",
    "[Python Tutor](http://pythontutor.com/visualize.html#py=3): permette di eseguire una istruzione alla volta offrendo un'utile visualizzazione di cosa accade 'sotto il cofano'\n",
    "\n",
    "[Google Colab](https://colab.research.google.com): permette di editare in modo collaborativo fogli Jupyter e di salvarli sul Google Drive. \n",
    "\n",
    "* NOTA 1: potrebbe darsi che non riusciate ad accedere coi vostri account universitari (es. ` @studenti.unitn.it`). In tal caso, usate account personali `@gmail.com`\n",
    "* NOTA 2: l'aspetto 'collaborativo' del Colab è cambiato nel corso del tempo, **fate bene attenzione a cosa succede quando operate in due sullo stesso documento**. Una volta (2017)  le modifiche fatte da uno erano immediatamente viste dagli altri, ultimamente (2019) paiono visibili solo quando si salva - peggio, vanno a sovrascrivere eventuali modifiche fatti da altri.\n",
    "\n",
    "[Demo online di Jupyter](http://try.jupyter.org): a volte funziona non sempre è disponibile. Se riesci ad accedere, ricordati di selezionare nel menù _Kernel->Change kernel->Python 3_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Installazione Python\n",
    "\n",
    "Ci sono vari modi per installare Python 3 e le sue librerie: c'è la distribuzione ufficiale di Python 'liscia' come anche gestori di pacchetti (es. Anaconda) o  ambienti preconfezionati (es. Python(x,y)) che forniscono sia Python più varie librerie extra. Inoltre, una volta completata l'installazione, Python 3 contiene un comando `pip` (a volte per python 3 si chiama `pip3`) che permette di installare in seguito da linea di comando eventuali librerie mancanti.  \n",
    "\n",
    "Il modo migliore per scegliere cosa installare dipende da quale sistema operativo si ha e cosa ci si intende fare. In questo libro useremo Python 3 e librerie scientifiche, quindi cercheremo di creare un ambiente adatto a supportare questo scenario. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**Attenzione: Prima di installare roba a caso scaricata da internet, leggi bene questa guida!**\n",
    "\n",
    "Abbiamo cercato di renderla abbastanza generica, ma non essendoci stato possibile testare tutti i vari casi potrebbero insorgere dei problemi, se avete qualche dubbio chiedete ai mentor.\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**Attenzione: non sovrapporre distribuzioni di Python alla stessa versione !**\n",
    "\n",
    "Vista la varietà di metodi di installazione e il fatto che Python si trova già in molti programmi, può darsi che abbiate già Python installato senza saperlo, magari in versione 2, ma a noi serve la 3! Sovrapporre diversi ambienti Python con la stessa versione potrebbe causare problemi, di nuovo se avete qualche dubbio chiedete ai mentor. \n",
    "</div> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installazione Windows\n",
    "\n",
    "Per Windows, ti consigliamo di installare la distribuzione [Anaconda per Python 3.6](https://www.anaconda.com/download/#windows) o maggiore, che oltre all'gestore di pacchetti nativo di Python `pip`, fornisce anche il più generico gestore di pacchetti da linea di comando `conda`. \n",
    "\n",
    "Una volta installato, verifica che funzioni così:\n",
    "\n",
    "1. clicca sull'icona di Windows in basso a sinistra e cerca 'Anaconda Prompt'. Dovrebbe apparire una console dove inserire comandi, con scritto qualcosa come `C:\\Users\\David> `. NOTA: per lanciare i comandi di Anaconda, usa solo questa console speciale. Se usie la console di default di Windows (`cmd`), Windows non sarà in grado di  trovare Python.\n",
    "\n",
    "2. Nella console di Anaconda, scrivi\n",
    "\n",
    "```bash\n",
    "conda list\n",
    "```\n",
    "\n",
    "Dovrebbe apparire una lista di pacchetti installati, tipo\n",
    "\n",
    "```\n",
    "# packages in environment at C:\\Users\\Jane\\AppData\\Local\\Continuum\\Anaconda3:\n",
    "#\n",
    "alabaster                 0.7.7                    py35_0  \n",
    "anaconda                  4.0.0               np110py35_0  \n",
    "anaconda-client           1.4.0                    py35_0  \n",
    "...\n",
    "numexpr                   2.5                 np110py35_0  \n",
    "numpy                     1.10.4                   py35_0  \n",
    "odo                       0.4.2                    py35_0  \n",
    "...\n",
    "yaml                      0.1.6                         0  \n",
    "zeromq                    4.1.3                         0  \n",
    "zlib                      1.2.8                         0\n",
    "\n",
    "```\n",
    "\n",
    "3. Prova Python3, scrivendo sempre nella console di Anaconda:\n",
    "\n",
    "```bash\n",
    "C:>  python\n",
    "```\n",
    "\n",
    "Dovrebbe apparire qualcosa tipo \n",
    "\n",
    "```\n",
    "Python 3.6.3 (default, Sep 14 2017, 22:51:06) \n",
    "MSC v.1900 64 bit (Intel)[GCC 5.4.0 20160609] on win64\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>>\n",
    "```\n",
    "\n",
    "<br/>\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**Attenzione**: Con Anaconda, devi scrivere `python` invece che `python3`!\n",
    "\n",
    "Sei hai installato Anaconda per Python3,  userà automaticamente la versione di Python corretta semplicemente scrivendo `python`. Se scrivi `python3` riceverai un'errore di file non trovato !\n",
    "</div>\n",
    "\n",
    "\n",
    "<br/>\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**Attenzione**: Se hai Anaconda, usa sempre `conda` per installare i moduli Python ! Quindi se nelle istruzioni nei prossimi tutorial vedi scritto `pip3 install qualcosa`, dovrai usare invece `conda install qualcosa`\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installazione Mac\n",
    "Per gestire al meglio le app installate sul Mac indipendentemente da Python, in genere conviene installare un cosiddetto _gestore di pacchetti_. Ce ne sono vari, e uno tra i più popolari su Mac è [Homebrew](https://brew.sh/). Quindi suggeriamo di installare prima Homebrew e poi tramite esso installare Python 3, più eventualmente in seguito altri componenti che ci interessano. In linea di massima, per l'installazione abbiamo tradotto qua in italiano e semplificato [questa guida](https://www.digitalocean.com/community/tutorials/how-to-install-python-3-and-set-up-a-local-programming-environment-on-macos).\n",
    "\n",
    "\n",
    "<br/>\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**Attenzione: controlla se hai già un gestore di pacchetti !** \n",
    "\n",
    "Se hai già installato un gestore di pacchetti come per esempio _Conda_ (nella distribuzione _Anaconda_), _Rudix_, _Nix_, _Pkgsrc_, _Fink_ o _MacPorts_, forse Homebrew non ti serve e ti conviene usare quello che già hai. In questi casi, chiedi ai mentor.  Se hai già _Conda/Anaconda_, può andar bene a patto di avere la versione per Python 3. \n",
    "</div>\n",
    "\n",
    "— 1 Apri il Terminale\n",
    "\n",
    "Il terminale di MacOS è un'applicazione che puoi usare per accedere alla linea di comando. Come qualunque altra applicazione, la puoi trovare andando in _Finder_, navigando nella cartella _Applicazioni_, e quindi nella cartella _Accessori_. Da lì, fai doppio click sul _Terminale_ per aprirlo come ogni altra applicazione. In alternativa, puoi usare _Spotlight_ tenendo premuto i tasti _Command_ e _Spazio_ per trovare il Terminale scrivendone il nome nella barra che appare.\n",
    "\n",
    "— 2 Installa Homebrew eseguendo nel terminale questo comando: \n",
    "\n",
    "```bash\n",
    "/usr/bin/ruby -e \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)\"\n",
    "```\n",
    "— 3 Aggiungi `/usr/local/bin` al `PATH`\n",
    "\n",
    "In questo passaggio dal nome inquietante, una volta che l'installazione di Homebrew è completata, ti assicurerai che vengano sempre sempre usate le applicazioni installate con Homebrew, invece che quelle che Mac OS X potrebbe selezionare automaticamente:\n",
    "\n",
    "— 3.1 Apri un nuovo Terminale.\n",
    "\n",
    "— 3.2 Da dentro il terminale, digita il comando \n",
    "\n",
    "```bash \n",
    "ls -a\n",
    "```\n",
    "\n",
    "Verrà visualizzata la lista di tutti i file presenti nella cartella della home. In questi file, verifica se esiste un file con il seguente nome: `.profile` (nota il punto all'inizio):\n",
    "\n",
    "- Se esiste: salta al punto seguente\n",
    "- Se non esiste, per crearlo digita il comando seguente:\n",
    "\n",
    "    ```bash\n",
    "        touch  $HOME/.profile\n",
    "    ```\n",
    "    \n",
    "— 3.3 Apri con text edit il file `.profile` appena creato dando il comando: \n",
    "\n",
    "```bash\n",
    "open -e  $HOME/.profile \n",
    "```\n",
    "\n",
    "— 3.4 In text edit, aggiungi alla fine del file questa riga:\n",
    "\n",
    "```bash\n",
    "export PATH=/usr/local/bin:$PATH\n",
    "```\n",
    "— 3.5 Salva e chiudi sia Text Edit che il Terminale\n",
    "\n",
    "— 4 Verifica che Homebrew sia installato correttamente, digitando in un nuovo Terminale:\n",
    "\n",
    "```bash\n",
    "brew doctor\n",
    "```\n",
    "\n",
    "Se non ci sono aggiornamenti da fare, il Terminale dovrebbe mostrare:\n",
    "\n",
    "```bash\n",
    "Your system is ready to brew.\n",
    "```\n",
    "\n",
    "Altrimenti, potresti vedere un warning che consiglia di eseguire un altro comando come `brew update` per assicurarti che l'installazione di Homebrew sia aggiornata. \n",
    "\n",
    "— 5. Installa python3 (Ricordati il '3' !): \n",
    "\n",
    "```bash\n",
    "brew install python3\n",
    "```\n",
    "\n",
    "Assieme a Python 3, Homebrew installerà anche il gestore di pacchetti interno di Python `pip3` che useremo in seguito. \n",
    "\n",
    "— 6 Verifica che Python3 sia installato correttamente. Eseguendo questo comando dovrebbe apparire la scritta  \"/usr/local/bin/python3\":\n",
    "\n",
    "```bash\n",
    "which python3\n",
    "```\n",
    "\n",
    "Dopodichè, prova a lanciare \n",
    "\n",
    "```bash\n",
    "python3\n",
    "```\n",
    "\n",
    "Dovresti vedere qualcosa di simile: \n",
    "\n",
    "```bash\n",
    "Python 3.6.3 (default, Nov 17 2016, 17:05:23) \n",
    "[GCC 5.4.0 20160609] on mac\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>>\n",
    "```\n",
    "Per uscire da Python, scrivi `exit()` e invio.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installazione Linux\n",
    "\n",
    "Fortunatamente, tutte le distribuzioni Linux sono già fornite con gestori di pacchetti per installare facilmente le applicazioni. \n",
    "\n",
    "- Se hai Ubuntu:\n",
    "\n",
    "    1. segui la guida di [Immersione in Python 3, capitolo 0 - Installare Python](http://gpiancastelli.altervista.org/dip3-it/installare-python.html) in particolare andando alla sotto sezione [installazione in Ubuntu](http://gpiancastelli.altervista.org/dip3-it/installare-python.html#ubuntu)\n",
    "    \n",
    "    2. dopo aver completato la guida, installa anche `python3-venv`: \n",
    "        ```bash\n",
    "        sudo apt-get install python3-venv\n",
    "        ```\n",
    "- Se _non_ hai Ubuntu, [guarda questa nota](http://gpiancastelli.altervista.org/dip3-it/installare-python.html#other) e/o chiedi ai mentor.\n",
    "\n",
    "Per verificare l'installazione, prova a lanciare da terminale\n",
    "\n",
    "```bash\n",
    "python3\n",
    "```\n",
    "\n",
    "Dovresti vedere qualcosa di simile: \n",
    "\n",
    "```bash\n",
    "Python 3.6.3 (default, Nov 17 2016, 17:05:23) \n",
    "[GCC 5.4.0 20160609] on linux\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installare pacchetti\n",
    "\n",
    "Si può estendere Python installando diversi pacchetti gratuiti. Il modo migliore per farlo, varia a seconda del sistema operativo e del gestore di pacchetti installato\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**ATTENZIONE**: Andremo ad usare comandi _di sistema_. Se vedi `>>>` sulla riga dei comandi, vuol dire che sei dentro l'interprete Python e devi prima uscirne: per farlo, scrivi `exit()` e premi Invio.\n",
    "</div>\n",
    "\n",
    "\n",
    "In quello che segue, per provare  vedere se il tutto funziona, al posto di `NOMEPACCHETTO` puoi scrivere `requests` che è una libreria per il web.\n",
    "\n",
    "\n",
    "Se hai Anaconda:\n",
    "\n",
    "- clicca sull'icona di Windows in basso a sinistra e cerca 'Anaconda Prompt'. Dovrebbe apparire una console dove inserire comandi, con scritto qualcosa come `C:\\Users\\David>`. (NOTA: per lanciare i comandi di Anaconda, usa solo questa console speciale. Se usi la console di default di Windows (cmd), Windows non sarà in grado di trovare Python)\n",
    "\n",
    "- Nella console scrivi `conda install NOMEPACCHETTO`\n",
    "\n",
    "Se hai Linux/Mac (`--user` installa nella propria home) apri il Terminal e dai questo comando:\n",
    "\n",
    "- ` python3 -m pip install --user NOMEPACCHETTO `\n",
    "\n",
    "- **NOTA:** Se ricevi errori che dicono che il comando `python3` non viene trovato, togli il `3` dopo `python` \n",
    "\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "\n",
    "**INFO**: volendo esiste anche un comando di sistema `pip` (o `pip3` a seconda del sistema). Lo puoi chiamare direttamente con <br/> `pip install --user NOMEPACCHETTO` <br/>\n",
    "\n",
    "Noi installiamo invece con comandi del tipo `python3 -m pip install --user NOMEPACCHETTO` per uniformità e per essere sicuri di installare pacchetti per la versione 3 di Python\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Notebook Jupyter\n",
    "\n",
    "### Eseguire il notebook Jupyter\n",
    "\n",
    "Un editor comodo che si può usare per Python è [Jupyter](http://jupyter.org/):\n",
    "\n",
    "* Se hai installato Anaconda, dovresti trovarlo già nel menu di sistema e anche nell'Anaconda Navigator.\n",
    "* Anche se non hai installato Anaconda, comunque cercalo nel menu di sistema chissamai che per qualche caso fortuito sia già installato\n",
    "* Se non lo trovi nel menu di sistema, potresti comunque averlo dalla linea di comando, \n",
    "\n",
    "Prova  se funzionano: \n",
    "\n",
    "```bash\n",
    "jupyter notebook\n",
    "```\n",
    "\n",
    "Oppure, in alternativa\n",
    "\n",
    "```bash\n",
    "python3 -m notebook\n",
    "```\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**ATTENZIONE**: `jupyter` NON è un comando Python, bensì un comando _di sistema_.\n",
    "\n",
    "Se vedi `>>>` sulla riga dei comandi vuol dire che devi prima uscire dall'interprete Python scrivendo `exit()` e premendo Invio!\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**ATTENZIONE**: Se Jupyter non è installato appariranno dei messaggi di errore, in questo caso non ti spaventare e [vai all'installazione](#Installare-il-notebook-Jupyter---tutti-i-sistemi-operativi).\n",
    "\n",
    "</div>\n",
    "\n",
    "Un browser dovrebbe aprirsi automaticamente con Jupyter, e nella console dovresti vedere dei messaggi come qua sotto. Nel browser dovresti vedere i file nella cartella da cui hai lanciato Jupyter. \n",
    "Se non parte nessun browser ma vedi un messaggio come qua sotto, allora copia l'indirizzo che vedi in un browser internet, preferibilmente Chrome, Safari o Firefox\n",
    "\n",
    "```\n",
    "$ jupyter notebook \n",
    "[I 18:18:14.669 NotebookApp] Serving notebooks from local directory: /home/da/Da/prj/softpython/prj\n",
    "[I 18:18:14.669 NotebookApp] 0 active kernels \n",
    "[I 18:18:14.669 NotebookApp] The Jupyter Notebook is running at: http://localhost:8888/?token=49d4394bac446e291c6ddaf349c9dbffcd2cdc8c848eb888\n",
    "[I 18:18:14.669 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).\n",
    "[C 18:18:14.670 NotebookApp] \n",
    "    \n",
    "    Copy/paste this URL into your browser when you connect for the first time,\n",
    "    to login with a token:\n",
    "        http://localhost:8888/?token=49d4394bac446e291c6ddaf349c9dbffcd2cdc8c848eb888\n",
    "\n",
    "```\n",
    "\n",
    "<br/>\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**ATTENZIONE 1**: in questo caso l'indirizzo è `http://localhost:8888/?token=49d4394bac446e291c6ddaf349c9dbffcd2cdc8c848eb888`, ma il tuo sarà sicuramente diverso!\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**ATTENZIONE 2**: Mentre il server Jupyter è attivo, non puoi mettere comandi nel terminale !\n",
    "\n",
    "Nella console vedi l'output del server di Jupyter, che è attivo e in un certo senso 'ha preso il controllo' del terminale. Questo significa che se anche scrivi dei comandi dentro il terminale, questi **non** verranno eseguiti!   \n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Salvare i fogli Jupyter\n",
    "\n",
    "Puoi salvare il foglio corrente in  Jupyter premendo `Control-S` mentre sei nel browser.\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**ATTENZIONE: NON APRIRE LO STESSO DOCUMENTO IN PIU' TAB !!**\n",
    "\n",
    "Fai attenzione a non aprire lo stesso notebook in più tab, modifiche su tab differenti possono sovrascriversi a caso ! Per evitare queste spiacevolissime situazioni, assicurati di avere una sola tab per docmento. Se apri accidentalmente lo stesso notebook in tab differenti, semplicemente chiudi la tab di troppo.\n",
    "\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "\n",
    "**Salvataggi automatici**\n",
    "\n",
    "Le modifiche ai notebook sono automaticamente salvate dopo qualche minuto. \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Spegnere il server di Jupyter\n",
    "\n",
    "Prima di chiudere il server di Jupyter,  ricordati di salvare nel browser i fogli modificati sinora.\n",
    "\n",
    "Per chiudere correttamente Jupyter, *non* chiudere brutalmente il terminale. Piuttosto,  nel terminale da dove lo hai lanciato premi `Control-c`, dovrebbe apparirti questa domanda, a cui devi rispondere `y` (se non rispondi entro 5 secondi, poi dovrai ripremere `Control-c` perchè ti venga rifatta la domanda):\n",
    "\n",
    "```\n",
    "Shutdown this notebook server (y/[n])? y\n",
    "[C 11:05:03.062 NotebookApp] Shutdown confirmed\n",
    "[I 11:05:03.064 NotebookApp] Shutting down kernels\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Navigare i notebook\n",
    "\n",
    "(Opzionale) Per migliorare l'esperienza di navigazione dei fogli Jupyter, potresti voler installare qualche estensione Jupyter, come `toc2` che mostra le intestazioni dei paragrafi nella barra a sinistra. Per installarlo:\n",
    "\n",
    "Installa le [Jupyter contrib extensions](https://github.com/ipython-contrib/jupyter_contrib_nbextensions):\n",
    "\n",
    "\n",
    "**1a. Se hai Anaconda:** Apri Anaconda Prompt (o il Terminale se hai Mac / Linux), e scrivi:\n",
    "\n",
    "```bash\n",
    "conda install -c conda-forge jupyter_contrib_nbextensions \n",
    "```\n",
    "\n",
    "**1b. Se non hai Anaconda:** Apri il terminale e scrivi: \n",
    "\n",
    "```bash\n",
    "python3 -m pip install --user jupyter_contrib_nbextensions\n",
    "```\n",
    "\n",
    "**2. Installalo in Jupyter:**\n",
    "\n",
    "```bash\n",
    "jupyter contrib nbextension install --user\n",
    "```\n",
    "\n",
    "**3. Abilita le estensioni:**\n",
    "\n",
    "```bash\n",
    "jupyter nbextension enable toc2/main\n",
    "```\n",
    "**Una volta installato**: Per vedere le tabelle dei contenuti in un documento dovrai premere un bottone lista all'estremità destra della barra degli strumenti\n",
    "\n",
    "![iuiu3234](_static/img/toc2-jupyter.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Se per caso non lo vedi il bottone:**\n",
    "\n",
    "1. vai nell'interfaccia principale di Jupyter\n",
    "2. controlla la tab `Nbextensions`\n",
    "3. Assicurati che `Table of Contents(2)` sia abilitato\n",
    "4. Poi chiudi Jupyter, riaprilo, e vai su un foglio, dovresti finalmente vedere il bottone\n",
    "\n",
    "![eer23d](_static/img/toc2-jupyter-enable.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Installare il notebook Jupyter - tutti i sistemi operativi\n",
    "\n",
    "Se non sei riuscito a [trovare e/o far partire Jupyter](#Eseguire-il-notebook-Jupyter), probabilmente  vuol dire che bisogna installarlo !\n",
    "\n",
    "Puoi provare ad installare jupyter con `pip` (il gestore di moduli nativo di Python).\n",
    "\n",
    "\n",
    "Per installare, esegui questo comando:\n",
    "\n",
    "```bash\n",
    "    python3 -m pip install --user jupyter -U\n",
    "```\n",
    "\n",
    "Una volta installato, segui la sezione [Eseguire il notebook Jupyter](#Eseguire-il-notebook-Jupyter)\n",
    "\n",
    "<br/>\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**ATTENZIONE**: NON serve installare Jupyter dentro [ambienti virtuali](#Fare-progetti-Python-con-gli-ambienti-virtuali).\n",
    "\n",
    "Jupyter è da considerarsi un'applicazione a livello di sistema, dovrebbe essere indipendente dagli ambienti virtuali. Se sei all'interno di un ambiente virtuale (per es. la linea di comando inizia con una scritta tra parentesi tipo `(myprj)`), esci dall'ambiente scrivendo `deactivate` \n",
    "\n",
    "</div>\n",
    "\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "\n",
    "**HELP**: Se hai problemi ad installare Jupyter, intanto che aspetti aiuto puoi provare la [versione dimostrativa online](https://try.jupyter.org/) (nota che non è sempre disponibile) o [Google Colab](http://colab.research.google.com/)\n",
    "</div>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Fare progetti Python con gli ambienti virtuali\n",
    "\n",
    "<br/>\n",
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "**ATTENZIONE**: Se sei alle prime armi con Python, puoi saltare questa sezione. \n",
    "\n",
    "La dovresti leggere se hai già fatto progetti personali in Python che vuoi evitare di compromettere, oppure quando vuoi fare un progetto da consegnare a qualcuno.\n",
    "</div>\n",
    "\n",
    "\n",
    "Quando cominciamo un nuovo progetto in Python, di solito ci accorgiamo in fretta che bisogna estendere Python con delle librerie particolari, per esempio per disegnare grafici. Non solo, potremmo anche voler installare dei programmi Python non scritti da noi che a loro volta avranno bisogno delle loro librerie per funzionare.\n",
    "\n",
    "Ora, potremmo installare tutte queste librerie extra in un unico calderone per tutto il computer, ma ogni progetto può richiedere le sue specifiche versioni di ogni libreria, e a volte potrebbe non gradire le versioni installate da altri progetti. Peggio ancora,  potrebbe aggiornare automaticamente librerie usate da vecchi progetti, rendendo il codice dei vecchi progetti non più eseguibile.  Quindi è PRATICAMENTE NECESSARIO  separare per bene ogni progetto e le sue librerie da quelle degli altri: a tal fine si può creare un cosiddetto _virtual environment_.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creare ambienti virtuali\n",
    "\n",
    "* **Se hai installato Anaconda**, per creare ambienti virtuali ti conviene usare il suo gestore di pacchetti `conda`. Supponendo che vogliamo chiamare il nostro progetto `myprj` (ma potrebbe essere un nome qualunque), da mettere in una cartella dallo stesso nome `myprj`, per creare un ambiente virtuale possiamo dare questo comando:\n",
    " \n",
    "    ```bash\n",
    "    conda create -n myprj\n",
    "    ```\n",
    "    Il comando potrebbe chiederti di scaricare dei pacchetti, dai pure conferma.\n",
    "\n",
    "* **Se _non_ hai installato Anaconda**,  per creare ambienti virtuali ti conviene usare il modulo nativo di Python `venv`: \n",
    "\n",
    "    ```bash\n",
    "    python3 -m venv myprj\n",
    "    ```\n",
    "\n",
    "Entrambi i metodi creano la cartella `myprj` e la riempiono con tutti i file Python necessari per avere un progetto completamente isolato dal resto del computer. Ma adesso, come possiamo dire a Python che vogliamo lavorare proprio con quel progetto lì?  Dobbiamo _attivare_ l'ambiente come segue. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attivare un ambiente virtuale\n",
    "\n",
    "Per attivare l'ambiente virtuale, dobbiamo usare comandi diversi a seconda del sistema operativo (ma sempre dal terminale)\n",
    "\n",
    "**Su Linux & Mac (senza Anaconda)**: \n",
    "\n",
    "```bash\n",
    "source myprj/bin/activate\n",
    "```\n",
    "\n",
    "**Attivare environment su Windows con Anaconda**:\n",
    "\n",
    "```bash\n",
    "activate myprj\n",
    "```\n",
    "\n",
    "Una volta che l'ambiente è attivato, nel prompt dei comandi dovremmo vedere il nome dell'ambiente (in questo caso `myprj`) in parentesi tonde all'inizio della riga:\n",
    "```\n",
    "(myprj) directory/corrente >\n",
    "```\n",
    "\n",
    "Il prefisso ci fa sapere che l'ambiene `myprj` è correntemente attivo, perciò tutti i comandi Python che daremo useranno le impostazioni e le librerie di quell'ambiente. \n",
    "\n",
    "Nota: dentro l'ambiente virtuale, si può usare il comando `python` invece di `python3`, e `pip` invece di `pip3`, ma noi consigliamo comunque di essere espliciti e aggiungere sempre 3 così da evitare possibili confusioni.\n",
    "\n",
    "**Disattivare un ambiente**: \n",
    "\n",
    "Scrivere nella console il comando `deactivate`. Una volta disattivato l'ambiente, il nome dell'ambiente `(myprj)` all'inizio del prompt dovrebbe scomparire. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eseguire gli ambienti da dentro Jupyter\n",
    "\n",
    "Come abbiamo detto in precedenza, Jupyter è un'applicazione a livello di sistema, quindi dovrebbe esserci uno e un solo Jupyter. Ciononostante, durante l'esecuzione di Jupyter, potremmo voler eseguire i nostri comandi Python in un particolare ambiente Python. Per fare ciò, dobbiamo configurare Jupyter perchè usi l'ambiente desiderato. Nella terminologia di Jupyter, le configurazioni si chiamano _kernel_: esse definiscono i programmi lanciati da Jupyter (siano essi versioni di Python o anche altri linguaggi, tipo R). Il kernel corrente per un foglio è visibile in alto a destra.  Per avere il kernel che vogliamo, ci sono diversi modi:\n",
    "\n",
    "#### Se hai Anaconda\n",
    "\n",
    "Jupyter dovrebbe essere disponibile nel Navigator. Se nel Navigator abiliti un environment (per es per Python 3), quando poi lanci Jupyter e crei un foglio dovresti avere l'ambiente desiderato attivo, o quantomeno poter scegliere un kernel con quell'ambiente. \n",
    "\n",
    "#### Se non hai Anaconda\n",
    "\n",
    "In questo caso, la procedura è un po' più complicata:\n",
    "    \n",
    "— 1 Dal Terminale, [attiva il tuo ambiente](#Attivare-un-ambiente-virtuale)    \n",
    "\n",
    "— 2 Crea un kernel Jupyter:\n",
    "```bash\n",
    "    python3 -m ipykernel install --user --name myprj\n",
    "```\n",
    "NOTA: qua `myprj` è il nome _del kernel Jupyter_. Usiamo lo stesso nome dell'ambiente solo per questioni di\n",
    "praticità.\n",
    "\n",
    "— 3 Disattiva il tuo ambiente, lanciando\n",
    "\n",
    "```bash\n",
    "    deactivate\n",
    "```\n",
    "\n",
    "A questo punto, ogni volta che lanci Jupyter, se tutto è andato bene nella voce 'Kernel' dei notebook dovresti poter selezionare il kernel che hai appena creato (in questo esempio, avrebbe il nome `myprj`)\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "\n",
    "**NOTA**: il passaggio di creazione del kernel va fatto una sola volta per progetto\n",
    "\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "\n",
    "**NOTA**: Non serve attivare l'ambiente prima di lanciare Jupyter!\n",
    "\n",
    "Durante l'esecuzione di Jupyter semplicemente seleziona il kernel desiderato. Ciononostante, conviene eseguire Jupyter dalla cartella del nostro ambiente virtuale, così vedremo tutti i file del progetto nella home di Jupyter.\n",
    "\n",
    "</div>              "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Approfondimenti\n",
    "\n",
    "Per approfondimenti su come usare editor diversi da Jupyter e l'architettura di Python, puoi leggere il foglio [Strumenti e script](https://it.softpython.org/tools/tools-sol.html)."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit 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.7.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}