{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conversioni tra bool e altri tipi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il tipo bool viene automaticamente convertito in intero, quando serve:  `False` è equivalente a `0` e `True` è equivalente a 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False + 45"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True + 45"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Di converso, quasi tutti i tipi vengono convertiti in `bool` quando necessario, secondo queste regole:\n",
    "  * tipo `int`:  il numero `0` diventa `False`, qualunque altro numero diventa `True`\n",
    "  * tipo `float`: come `int`\n",
    "  * tipo `str`: la stringa vuota `\"\"` diventa `False`, tutto il resto diventa `True`\n",
    "  \n",
    "Conversioni simili valgono anche per altri tipi che vedremo in futuro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n"
     ]
    }
   ],
   "source": [
    "if \"ciao\":\n",
    "  print(\"a\")\n",
    "else:\n",
    "  print(\"b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Valutazione degli operatori booleani\n",
    "*(parzialmente trattato nella sezione Argomenti Avanzati 3.4 del libro di testo)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando una espressione contiene `and` e `or` non è necessario calcolare tutte le sotto-espressioni. Ad esempio, se `x = True`, il risultato di `x or y` sarà sicuramente `True`, non è necessario calcolare `y`. Analogamente, se `x = False`, il risultato di `x and y` sarà sicuramente `False`.\n",
    "\n",
    "In questi casi, Python evita di calcolare la sotto-espressione che non è necessaria. Si parla di **valutazione a corto-circuito**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 0\n",
    "x == 0 or 1/x == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il risultato è `True` perchè `x` è uguale a 0. Notare che `1/x == 1` non viene calcolato. Se lo fosse, si genererebbe un errore di divisione per 0, come qui sotto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_762042/2308263197.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "1/x == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In realtà, il comportamento degli operatori booleani è ancora più strano. Ad esempio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"c\" and \"a\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perché `\"c\" and \"a\"` restituisce `\"a\"` come risultato ? Per capire questa cosa e altre stranezze simili, bisogna esamonare la vera definizione degli operatori `and` e `or`.\n",
    "  * `x and y`: se `x` si converte in `False`, il risultato è `x` altrimenti è `y`\n",
    "  * `x or y`: se `x` si converte in `True`, il risultato è `x`, altrimenti è `y`\n",
    "\n",
    "Se `x` ad `y` sono booleani, questo corrisponde alla definizione standard dei connettivi `and` e `or` in logica, ma se non sono booleani, si ottengono risultati strani.\n",
    "\n",
    "Esaminiamo ad esempio l'espressione `\"c\" and a\"`. Viene prima controllato il risultato della conversione di `\"c\"` in booleano. Siccome `\"c\"` non è la stringa nulla, esso corrisponde a `True`, quindi, in accordo alla definizione sopra il risultato è `\"a\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+1 or 1/0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Per quanto riguarda l'espressione `1+1 or \"ciao\"` qui sopra: `1+1` viene calcolato e convertito in booleano. Poiché 1+1=2 non è nullo, in booleano corrisponde a `True`. Per la definizione di sopra, il risultato è `2` e `1/0` non viene neanche calcolato."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il motivo di questo strano comportamento di `and` e `or` è che, in certe sistuazioni, può tornare comodo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# L'espressione condizionale\n",
    "*(sezione Argomenti Avanzati 3.1 del libro di testo)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Spesso capita di avere codice di queso tipo:\n",
    "```python\n",
    "if condizione: \n",
    "    x = v1\n",
    "else:\n",
    "    x = v2\n",
    "```\n",
    "in cui si assegna il valore `v1` o `v2` alla variabile `x` a seconda del risultato di `condizione`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un modo alternativo di scrivere questo pezzo di codice è usare l'*espressione condizionale* (che appunto come dice il nome, è una espressione e non una istruzione). Ha la forma:\n",
    "```python\n",
    "v1 if condizione else v2\n",
    "```\n",
    "I risultato di questa espressione è `v1` se condizione è `True` e `v2` se condizione è `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 if 2 == 2 else 33"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "42 if 2 == 3 else 33"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "È possibile anche mettere in cascata varie espressione condizionali, come nell'esempio che segue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'febbraio'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mese = 2\n",
    "\"gennaio\" if mese == 1 else \"febbraio\" if mese ==2 else \"marzo\" if mese == 3 else \"altro mese\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una espressione condizionale restituisce un risultato, esattamente come l'operazione + esegue la somma di due numeri e restituice un risultato. Col risultato possiamo farci quello che vogliamo: assegnarlo ad una variabile, stamparlo, darlo come argomento ad un metodo. Ad esempio, il seguente frammento di codice assengna all variabile `nome` il valore `Dumbo` se la variabile `numero_zampe` è 4, altrimenti assegna il valore `nemo`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dumbo\n"
     ]
    }
   ],
   "source": [
    "numero_zampe = 4\n",
    "nome = \"Dumbo\" if numero_zampe == 4 else \"Nemo\"\n",
    "print(nome)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ATTENZIONE**\n",
    "\n",
    "Scrivere \n",
    "```python\n",
    "nome = \"Dumbo\" if numero_zampe == 4 else nome = \"Nemo\"\n",
    "```\n",
    "è sbagliato è genera un errore a tempo di compilazione. Questo perché l'espressione condizionale non sceglie tra eseguire una istruzione o eseguirne un'altra (quello lo fa l'*istruzione condizionale*) ma tra restituire un valore  restituirne un altro. Le due alternative, quella prima di `if` e quella dopo di `else`, non possono essere istruzioni, ma solo valori (o altre espressoni).\n",
    "\n",
    "In particolare potete pensare che nella istruzione\n",
    "```python\n",
    "nome = \"Dumbo\" if numero_zampe == 4 else \"Nemo\"\n",
    "```\n",
    "ci siano delle parentesi implicite e che quindi l'istruzione si legga come:\n",
    "```python\n",
    "nome = (\"Dumbo\" if numero_zampe == 4 else \"Nemo\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Esercizio**\n",
    "\n",
    "Modificare il programma per determinare il colore di una casella della scacchiera visto nella lezione scorsa, in moda da utilizzare l'*espressione condizionale* invece dell'*istruzione condizionale*\n",
    "\n",
    "*Soluzione*\n",
    "\n",
    "Vedi `programma_231019_1_scacchiera.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Le f-stringhe\n",
    "\n",
    "L'istruzione `print` standard non consente di formattare l'output in maniera molto raffinata. Ad esempio, se la variabile `x` contiene un prezzo in euro, vorremmo stamparlo usando sempre due cifre dopo la virgola."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1\n"
     ]
    }
   ],
   "source": [
    "x = 2.10\n",
    "print(x)  # vorremmo stampre 2.10, ma in realtà stampa 2.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se abbiamo molti numeri da stampare uno dopo l'altro, vorremmo essere in grado di allinearli tutti verso destra. Ad esempio:\n",
    "```python\n",
    "print(355)\n",
    "print(1)\n",
    "print(-45)\n",
    "```\n",
    "vorremmo che stampasse\n",
    "```\n",
    "355\n",
    "  1\n",
    " -4\n",
    "```\n",
    "e invece stampa\n",
    "```\n",
    "355\n",
    "1\n",
    "-4\n",
    "```\n",
    "perché allinea tutto a sinistra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "355\n",
      "1\n",
      "-4\n"
     ]
    }
   ],
   "source": [
    "print(355)\n",
    "print(1)\n",
    "print(-4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esiste vari modi in Python per formattare l'output in maniera corretta. Il vostro libro vi spiega un metodo un po' obsoleto basato nella Sezione 2.5.3. Qui vi spiego invece l'uso delle f-stringhe."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una *f-stringa* è una stringa che inizia con una lettera `f` fuori dalle virgolette (`f` sta per formatted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ciao sono una f-stringa'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Ciao sono una f-stringa\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All'apparenza la `f` davanti sembra inutile, ma se le f-stringhe contengono una espressione tra parentesi graffa, questa espressione viene calcolata e il risultato sostituito nella stringa risultante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "y = 4.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ecco il numero 4 e 0.5'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Ecco il numero {x+2} e {y-4}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notare che nelle stringhe normali tutto ciò non succede."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ecco il numero {x+2} e {y-4}'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Ecco il numero {x+2} e {y-4}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ecco altri esempi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ciao 1'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Ciao {abs(5-6)}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ciao Michele'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nome=\"Michele\"\n",
    "f\"Ciao {nome}\""
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quindi le f-stringhe sono un metodo per inserire espressioni (tipicamente nomi di variabili) all'interno di una stringa. La cosa interessante per i nostri scopi è che, sempre dentro le graffe, è possibile specificare come formattare il risultato dell'espressione prima di inserirla nella stringa. Per far ciò, dopo l'espressione, si inserisce il carattere di due punti `:` e poi si specifica il formato con [apposito mini-linguaggio](https://docs.python.org/3/library/string.html#formatspec).\n",
    "\n",
    "La cosa più semplice che si può fare è, dopo i due punti, inserire un numero intero. Questo è il numero di caratteri che l'espressione occuperà nella stringa. Nell'esempio che segue, la variabile `x` viene rimpiazzata col suo valore che è 2, ma a questo 2 vengono aggiunti altri 9 spazi in modo da occupare comunque il numero di caratteri specificato, che è 10.\n",
    "\n",
    "Ad esempio:\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ecco il numero          2 che occupa 10 spazi ed è allineato a destra'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Ecco il numero {x:10} che occupa 10 spazi ed è allineato a destra\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si noti che il numero, all'interno dello spazio di 10 caratteri che gli è stato dedicato, è stato allineato a destra. Le stringhe, invece, vengono allineate a sinistra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mi chiamo Michele             , ciao'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Mi chiamo {nome:20}, ciao\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Per i `float`,è possibile anche specificare il numero di caratteri che vogliamo dopo la virgola, come nel seguente esempio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ecco il numero       4.50 che occupa 10 spazi, di cui 2 per le cifre decimali'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Ecco il numero {y:10.2f} che occupa 10 spazi, di cui 2 per le cifre decimali\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si può anche specificare solo la precisione senza lo spazio che il numero deve occupare."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ecco il numero 4.50 con 2 cifre decimali'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Ecco il numero {y:.2f} con 2 cifre decimali\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Infine, si possono allineare a sinistra anche i numeri mettendo il simbolo `<` prima della lunghezza del campo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ecco il numero 4.50       come sopra ma allineato a sinistra'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Ecco il numero {y:<10.2f} come sopra ma allineato a sinistra\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'elenco di tutto ciò che è possibile specificare dopo i due punti è molto lungo, e vi rimando alla documentazione sul [mini-linguaggio per la specifica della formattazione](https://docs.python.org/3/library/string.html#formatspec)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Esercizio P2.5**\n",
    "\n",
    "Scrivere un programma che chiede all'utente due numeri interi e visualizza:\n",
    "\n",
    "   * la somma\n",
    "   * la differenza\n",
    "   * il prodotto\n",
    "   * il valore medio\n",
    "   * la distanza (cioè il valore assoluto della differenze)\n",
    "   *  il valore massimo\n",
    "   * il valore minimo\n",
    "\n",
    "Far sì che l'output sia allinato come segue:\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "*Soluzione*\n",
    "\n",
    "Vedere `programma_231019_2_allineamento.py` e `programma_231019_2_allineamento_bis.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Domanda dagli studenti\n",
    "\n",
    "**Mi è stato chiesto durante la lezione se, invece di usare le f-stringhe, è possibile utilizzare il carattere tabulazione.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La risposta secca a questa domanda è no, ma ne approfitto per spiegare cosa è il carattere tabulazione e perché non è adatto a risolvere i problemi di formattazione del testo.\n",
    "\n",
    "Il carattere di tabulazione (da ora in poi chiamato semplicemente HT per *horizontal tabulation*) ha codice ASCII 9, e può essere inserito in una stringa Python con il codice di escape `\\t`. Quando il carattere HT viene inviato in stampa, il suo effetto è spostare il cursore avanti fino al *tab stop* successivo. La posizione di questi tab stop dipendono dal sistema operativo, ma in generale si trovano in tutte le colonne multiple di 8. Pertanto, il comando\n",
    "```python\n",
    "print(\"aa\\tbb\")\n",
    "```\n",
    "stamparà due `a`, poi 6 spazi in modo da raggiungere la colonna numero 8, quindi due `b`.\n",
    "\n",
    "Invece \n",
    "```python\n",
    "print(\"aaaa\\tbb\")\n",
    "```\n",
    "Invece stamparà quattro `a`, poi 4 spazi in modo da raggiungere la colonna numero 8, quindi due `b`.\n",
    "\n",
    "Vediamo un esempio un po' più complesso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t 1 \tb\n",
      "a\t 10 \tb\n",
      "aa\t 20 \tb\n",
      "aa       300 \tb\n"
     ]
    }
   ],
   "source": [
    "print(\"\\t\",1,\"\\tb\")\n",
    "print(\"a\\t\",10,\"\\tb\")\n",
    "print(\"aa\\t\",20,\"\\tb\")\n",
    "print(\"aa      \",300,\"\\tb\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Come si vede nell'esempio di sopra, abbiamo usato la tabulazione per allineare tutti i numeri e le lettere `b`. Tuttavia, l'uso delle tabulazioni ha enormi limitazioni:\n",
    "  * non consente di specificare quanto spazio riservare per le varie informazioni, i tab stop sono in posizione fissa;\n",
    "  * non consente di allineare i valori a destra: i numeri 1, 10, 20, etc.. sono tutti stati allineati a sinistra;\n",
    "  * si richia l'incompatibilità tra sistemi che usano posizioni differenti per i tab stop.\n",
    "\n",
    "Per questi motivi, è meglio non usare il carattere tabulazione. Si tratta più che altro di un retaggio delle vecchie macchine da scrivere.\n",
    "\n",
    "Diverso è il discorso per le tabulazioni nei word-processor, come LibreOffice Writer o Microsoft Word. Qui le tabulazioni sono molto più sofisticate: è possibile configurare la posizione dei tab stop, decidere che tipo di allineamento usare per ognuno di essi, etc... Ma nessuna di queste funzionalità è presente quando si usa il carattere di tabulazione in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assegnazione aumentata\n",
    "*(sezione Argomenti Avanzati 2.2 del libro di testo)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le istruzioni di assegnazione aumentata sono la combinazione, in una unica istruzione, di una istruzione di assegnamento e un operatore binario.\n",
    "\n",
    "Ad esempio `v += espressione` calcola la somma della variabile `v` con il valore di `espressione`, e assegna il risultato a `v`. In altre parole, equivale a `v = v + espressione`. Analogamente esistono `-=`, `*=`, etc..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "x += 3\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Per chi ha precedenti esperienze di progammazione con C, Java o simili, si noti che Python non supporta invece le operazioni di autoincrement `++` e autodecremento `--`. Ad esempio l'istruzione:\n",
    "```java\n",
    "x++\n",
    "```\n",
    "non è valida, ma può essere rimpiazzata da\n",
    "```python\n",
    "x += 1\n",
    "```"
   ]
  }
 ],
 "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}