01_Intro Python_2024.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "eb8dc1d0-5bd5-4d54-9909-c72c599d91db"
    },
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduzione\n",
    "\n",
    "Concepito alla fine degli anni '80 come linguaggio di scripting, Python è diventato uno strumento essenziale per molti programmatori, ingegneri, ricercatori e data scientist nel mondo accademico e industriale. \n",
    "\n",
    "Il fascino di Python sta nella sua semplicità, e nella vastità di strumenti specifici che sono stati costruiti su di esso negli anni, come ad esempio, le librerie Python usate nel calcolo scientifico e nella scienza dei dati.\n",
    "\n",
    "\n",
    "Caratteristiche:\n",
    "\n",
    "* Linguaggio interpretato\n",
    "\n",
    "* Sintassi semplice\n",
    "\n",
    "* Curva di apprendimento elevata\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Comunità Python italiana: [www.python.it](http://www.python.it)\n",
    "\n",
    "Python Tutorial: [The Real Python](https://realpython.com)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Riferimenti**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Riferimenti per questa parte iniziale:\n",
    "\n",
    "A Whirlwind Tour of Python\n",
    "\n",
    "Testo Gratuito: https://s3-us-west-2.amazonaws.com/python-notes/a-whirlwind-tour-of-python-2.pdf\n",
    "\n",
    "https://github.com/jakevdp/WhirlwindTourOfPython\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python è stato originariamente sviluppato come linguaggio didattico, ma la sua facilità d'uso e la sua sintassi pulita lo hanno portato ad essere adottato sia dai principianti che dagli esperti. La pulizia della sintassi di Python ha portato alcuni a chiamarlo \"pseudocodice eseguibile\", e in effetti spesso è molto più facile leggere e comprendere uno script Python piuttosto che leggere uno script simile scritto in un altro linguaggio. \n",
    "\n",
    "**Versioni di Python**\n",
    "\n",
    "\n",
    "NOTA: Fino a qualche anno fa esistevano due diverse versioni di Python molto diffuse: Python 2.x e Python 3.x.\n",
    "\n",
    "Le differenze tra le versioni sono rilevanti, quindi non c'è compatibilità tra il codice scritto in Python 2.x e quello scritto in Python 3.x.\n",
    "\n",
    "\n",
    "Python 2.0 fu introdotto nel 2000.\n",
    "\n",
    "Python 3.0 è stato introdotto alla fine del 2008. A quel tempo moltissime librerie erano già state distribuite usando Python 2.\n",
    "\n",
    "Gran parte della comunità di sviluppatori non è passata immediatamente a Python 3.0 ed è rimasta \"fedele\" a Python 2.7.\n",
    "\n",
    "Ad oggi tutte le librerie più importanti sono state portate su Python 3\n",
    "\n",
    "Dal 1 gennaio 2020 Python 2.7 non è più mantenuto, quindi si consiglia vivamente di utilizzare Python 3.\n",
    "\n",
    "\n",
    "### Integrated Development Environment (IDE)\n",
    "\n",
    "IDE comuni (PyCharm, Spider, VSCode, ecc ...)\n",
    "\n",
    "Web Integrated Development Environment (WIDE) es. Jupyter \n",
    "\n",
    "### Installare Python\n",
    "\n",
    "Si può effettuare il download di Python dal sito ufficiale: https://www.python.org\n",
    "\n",
    "In alternativa si può utilizzare una delle due versioni della distribuzione di Anaconda:\n",
    "\n",
    "- Miniconda fornisce l'interprete Python, e anche uno strumento da riga di comando chiamato conda che funge da gestore di pacchetti multipiattaforma, simile agli strumenti apt o yum che usano gli utenti Linux.\n",
    "\n",
    "- Anaconda include sia Python che conda e in aggiunta include una suite di altri pacchetti preinstallati orientati verso l'elaborazione scientifica.\n",
    "\n",
    "https://www.anaconda.com/download/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iniziamo ###\n",
    "\n",
    "### Alcune note di sintassi ###\n",
    "\n",
    "**Commenti:**\n",
    "\n",
    "I commenti in Python sono indicati da un cancelletto (#), e qualsiasi cosa sulla riga che segue il segno di cancelletto viene ignorata dall'interprete. \n",
    "\n",
    "Si possono avere commenti autonomi nonché commenti in linea che seguono un'istruzione. \n",
    "\n",
    "Per esempio:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#questo è un commento \n",
    "\n",
    "x += 2 # anche questo è un commento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python non ha una sintassi specifica per i commenti su più righe, come la sintassi /* ... */ usata in C e C++, di fatto le stringhe multilinea sono spesso usate come commenti su più righe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "commento \n",
    "su più\n",
    "linee\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "commento \n",
    "su più\n",
    "linee\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Terminare una istruzione:**\n",
    "\n",
    "La fine di una istruzione è semplicemente contrassegnata dalla fine della riga. Ciò è in contrasto con linguaggi come C e C++, dove ogni istruzione deve terminare con un punto e virgola (;).\n",
    "\n",
    "In Python, se desideri che un'istruzione continui alla riga successiva, è possibile utilizzare \"\\\" per indicarlo.\n",
    "\n",
    "**Indentare il codice (non solo per leggibilità)**\n",
    "\n",
    "Nei linguaggi di programmazione, un blocco di codice è un insieme di istruzioni che dovrebbero essere trattate come un'unità. In C, ad esempio, i blocchi di codice sono indicati da parentesi graffe. In Python il blocco di codice è indicato dalla tabulazione."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Assegnazione delle variabili in Python**\n",
    "\n",
    "Per definire una variabile in Python occorre scrivere prima il nome della variabile, quindi usare l'operatore di assegnazione = seguito da un valore o da una espressione.\n",
    "\n",
    "La sintassi generale per assegnare un valore al nome della variabile è la seguente:\n",
    "\n",
    "*nome_variabile = valore*\n",
    "\n",
    "NOTA: I nomi delle variabili in Python devono rispettare le seguenti regole:\n",
    "\n",
    "- possono contenere solo lettere, numeri e il carattere di sottolineatura _\n",
    "- devono iniziare con una lettera o con il carattere di sottolineatura ma non con un numero\n",
    "- non possono contenere spazi o punteggiatura\n",
    "- non possono essere racchiusi tra virgolette\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: le variabili non possono avere come nome le **Parole riservate**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Here is a list of the Python keywords.  Enter any keyword to get more help.\n",
      "\n",
      "False               class               from                or\n",
      "None                continue            global              pass\n",
      "True                def                 if                  raise\n",
      "and                 del                 import              return\n",
      "as                  elif                in                  try\n",
      "assert              else                is                  while\n",
      "async               except              lambda              with\n",
      "await               finally             nonlocal            yield\n",
      "break               for                 not                 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(\"keywords\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"ciao\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "somma = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(somma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(somma * somma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "somma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(somma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipi di dati *built-in* in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipi Semplici ##"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Tipo\t| Esempio |\tDescrizione |\n",
    "|-------|---------|-------------|\n",
    "| int\t|x = 1\t  |numeri interi  |\n",
    "|float\t|x = 1.0  |\tnumeri reali |\n",
    "|complex|\tx = 1 + 2j\t| numeri complessi |\n",
    "|bool\t|x = True |\tbooleani |\n",
    "|str\t|x = 'abc'|\tstringhe |\n",
    "|NoneType|\tx = None  |null |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interi ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un numero intero è un numero intero, negativo, positivo o zero. In Python, le variabili intere sono definite assegnando un numero intero a una variabile. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = \"jajaja \""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La funzione *type()* di Python può essere utilizzata per determinare il tipo di dati di una variabile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La funzione *print()* di Python può essere utilizzata per stampare a video il valore di una variabile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jajaja \n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gli interi Python sono un po' più sofisticati dei numeri interi in altri linguaggi come C. In C gli interi sono a precisione fissa, e di solito raggiungono un overflow a valori vicino a $2^{31}$ o $2^{63}$. Gli interi in Python sono a precisione variabili, ciò consente di calcoli che in altri linguaggi porterebbero ad un overflow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1606938044258990275541962092341162602522202993782792835301376"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 200"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numeri a virgola mobile (floating point)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I numeri in virgola mobile o float sono un altro tipo di dati Python. I float sono decimali, positivi, negativi e zero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = 5.4\n",
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I float possono anche essere rappresentati da numeri in notazione scientifica con gli esponenti.\n",
    "\n",
    "Sia una *e* che una *E* possono essere utilizzate per definire i float in notazione scientifica. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 5.12e12\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5120000000000.0\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0.000005\n",
    "y = 5e-6\n",
    "\n",
    "x == y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, un float può essere definito usando un punto decimale . quando viene assegnata una variabile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5.\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un numero intero può essere esplicitamente convertito in float con il *costruttore* float:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 8\n",
    "y = float(x)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una caratteristica di Python (nota: versione 3) è che la divisione tra interi per default viene considerata come tipo floating-point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=5\n",
    "b=2\n",
    "c=a/b\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=a//b # floor operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attenzione a usare i floating point per fare confronti (questo non vale solo in Python ma anche in altri linguaggi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1 + 0.2 == 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.2 + 0.6 == 0.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.30000000000000004\n"
     ]
    }
   ],
   "source": [
    "print (0.1 + 0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numeri complessi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un numero complesso è definito in Python usando una componente reale + una componente immaginaria indicata dalla lettera *j*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 3 + 4j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.imag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3-4j)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.conjugate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(c)  # sqrt(c.real ** 2 + c.imag ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stringhe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le stringhe sono sequenze di lettere, numeri, simboli e spazi. In Python, le stringhe possono avere quasi qualsiasi lunghezza. \n",
    "\n",
    "Le stringhe sono assegnate a una variabile usando le virgolette singole ' ' o le doppie virgolette \" \"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=\"Open Data Management \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1=s*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Open Data Management Open Data Management Open Data Management \n"
     ]
    }
   ],
   "source": [
    "print(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "s2=\"Corso di \"+\".... \"+s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Corso di .... Open Data Management '"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Indexing**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'indicizzazione delle stringhe è il processo di estrazione di caratteri da una stringa in un ordine specifico. \n",
    "\n",
    "In Python, le stringhe sono indicizzate usando parentesi quadre [ ]. \n",
    "\n",
    "Importante: Il conteggio inizia da 0 e finisce a n-1 (dove n è la lunghezza della stringa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'D'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[36], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m s[\u001b[38;5;241m30\u001b[39m]\n",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "s[30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Slicing**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pen'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Open '"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Open Data Management '"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Open Data Management'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attenzione agli operatori sulle stringhe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[44], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m s\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m5\u001b[39m\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "s+5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Open Data Management 5'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s+str(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Funzioni sulle stringhe*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'OPEN DATA MANAGEMENT '"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Open Data Management '"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'OPEN DATA MANAGEMENT '"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=s.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Open data management '"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.find(\"data\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.find(\"E\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.lower().find(\"BAS\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Python è dynamically-typed***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1           # x è un intero \n",
    "x = 'hello'   # x è una stringa "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Questo non significa che Python è type free"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1           # x è un intero \n",
    "type(x)\n",
    "x = 'hello'   # x è una stringa \n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipo Booleano ###"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il tipo booleano è un tipo semplice con due valori possibili: *True* e *False*\n",
    "\n",
    "Ricorda che i valori booleani fanno distinzione tra maiuscole e minuscole: *True* e *False* devono essere scritti in maiuscolo!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = (10 < 5)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I booleani possono anche essere costruiti utilizzando il costruttore *bool()* \n",
    "\n",
    "I valori di qualsiasi altro tipo possono essere convertiti in booleani. \n",
    "\n",
    "Ad esempio, qualsiasi tipo numerico diverso da 0 è True mentre se uguale a zero è False:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bool(\"una frase qualunque\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "9401baae-204b-4042-b453-119ffa783193"
    }
   },
   "source": [
    "# Strutture Dati (built-in)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Abbiamo visto i tipi semplici di Python: int, float, complex, str, bool\n",
    "\n",
    "Python ha anche diversi tipi composti predefiniti (built-in), che fungono da contenitori per altri tipi. \n",
    "\n",
    "I tipi di composti in Python sono:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Nome | Esempio               | Descrizione                         | Tipo             |\n",
    "|------|-----------------------|-------------------------------------|------------------|\n",
    "| list | [1, 2, 3]             | Collezione di elementi              |Mutabile          |\n",
    "| tuple| (1, 2, 3)             | Collezione di elementi              |Immutabile        |\n",
    "| set  | {1, 2, 3}             | Insiemi non ordinati di valori unici|Mutabile          |\n",
    "| dict | {'a':1, 'b':2, 'c':3} | Mappa non ordinata (chiave, valore) |Mutabile          |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "2d8f2326-ac75-4702-a3ae-71600b527a24"
    }
   },
   "source": [
    "#### *Liste*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "0aaf411d-a8a3-4e35-bd7a-f7c7c4d3e13a"
    }
   },
   "source": [
    "Una lista contiene i suoi valori tra parentesi quadre:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "2cbd2356-0f6c-418e-90b6-61e3aa2ae0ce"
    }
   },
   "outputs": [],
   "source": [
    "lista=[10, 20, 30, 40]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "02cdd1c4-14fb-4603-a6d6-0dd08608d688"
    }
   },
   "source": [
    "Non necessariamente gli elementi di una lista devono essere tutti dello stesso tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "c0620dc8-7672-43e5-8ff0-594f058c856f"
    }
   },
   "outputs": [],
   "source": [
    "[20,30.,\"Python\",[\"a\", c]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "nbpresent": {
     "id": "1c1f88ef-ddee-419b-b47b-5bf0dd9d568f"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=[0,1,2,3]\n",
    "len(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.append(78)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "nbpresent": {
     "id": "818664b9-c94f-4141-a90e-e2b9c0fe9eeb"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 78]\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conseguenza delle varibili come puntatori"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "x=[1,2,3]\n",
    "y=x\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.append(4) # inseriamo 4 alla lista puntata da x "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4487121728"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4487121728"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[0]=4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 2, 3, 4]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 2, 3, 4]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "x = 'una stringa' \n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Che succede se..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=10\n",
    "y=x\n",
    "x += 5\n",
    "print(\"x =\", x)\n",
    "print(\"y =\", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numeri, stringhe, e altri tipi semplici sono immutabili.\n",
    "\n",
    "Quando chiamiamo x += 5 non stiamo modificando il valore 5 dell'oggetto puntato da x, ma piuttosto stiamo cambiando l'oggetto a cui x punta.\n",
    "\n",
    "Per questo motivo il valore di y non è influenzato da questa operazione.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=10\n",
    "y=x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x += 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Come duplicare una lista?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=[1,2,3] \n",
    "y=x\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.append(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [10, 20, \"ciao\", 80]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = x.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.append(5)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Altre operazioni sulle liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "c0c7fc87-580e-4e47-b74a-5b24aecc88b4"
    }
   },
   "outputs": [],
   "source": [
    "a=[0,1,2,3,4,5,6,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.append(11)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# l'addizione concatena due liste\n",
    "a+[13,17,19]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=[2,5,1,4,3,4]\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ordinamento \"in place\" (sostituisce i valori)\n",
    "a.sort()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.sort(reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota** questo metodo sort cambia i valori della lista, se invece volessi creare una nuova lista con i valori ordinati:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = sorted(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.insert(5,200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 78, 200]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.remove(4) # rimuove il primo elemento che contiene il valore 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rimuove l'elemento con indice 1 (il secondo elemento)\n",
    "del a[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gli elementi di una lista di stringhe li possiamo utilizzare per creare una stringa unica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [\"ciao\",\"casa\",\"esempio\"]\n",
    "valori = ','.join(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valori"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### _Indexing_ e _slicing_ nelle liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Indexing_ è l'operazione di recuperare un singolo valore dalla lista, _slicing_ si riferisce all'accesso di valori multipli (una sottolista della lista di partenza)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L=[2,3,5,7,11]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# l'indicizzazione parte da zero\n",
    "\n",
    "L[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nelle liste gli ultimi elementi possono essere acceduti usando numeri negativi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# zero può essere omesso\n",
    "L[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# accedere agli ultimi 3 elementi\n",
    "L[-3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# è possibile specificare un terzo intero che rappresenta lo step di selezione\n",
    "\n",
    "L[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cosa produce la seguente istruzione?\n",
    "\n",
    "L[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota:** entrambe le operazioni di _indexing_ e di _slicing_ possono essere usate per asseganre i valori in una lista "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[1] = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[1:3] = [15, 26]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L[1:5:2] = [22, 27]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "52e54a38-1b1c-4901-ad2b-ba708cbf9226"
    }
   },
   "source": [
    "#### *Tuple*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una tupla contiene i suoi elementi tra parentesi tonda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "ef36be8c-27ab-4961-9218-2d4f5234db3c"
    }
   },
   "outputs": [],
   "source": [
    "t=(\"a\",\"b\",\"c\")\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le parentesi tonde possono essere omesse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t='a',\"b\",\"c\"\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "e145ce34-7843-47f0-bab3-058dbe65a951"
    }
   },
   "outputs": [],
   "source": [
    "t[0]=\"d\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "f0b73716-4eb8-4b99-a219-0313f3cfd92d"
    }
   },
   "outputs": [],
   "source": [
    "listaconv=list(t)\n",
    "\n",
    "listaconv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "listaconv[0]=\"d\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "listaconv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le tuple sono spesso usato in Python nel caso di funzioni che devono restituire valori multipli."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 0.125\n",
    "x.as_integer_ratio()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I valori multipli restituiti da una funzione possono essere assegati a singole variabili come segue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(numeratore, denominatore) = x.as_integer_ratio() \n",
    "print(numeratore)\n",
    "print(denominatore)\n",
    "print(numeratore / denominatore)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "4216f01e-82fc-4b81-abc8-c695aa738dc3"
    }
   },
   "outputs": [],
   "source": [
    "a=6\n",
    "c=3\n",
    "print(a,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp=a\n",
    "a=c\n",
    "c=temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "e3ee67f3-496a-4eba-b65b-3297a3790219"
    }
   },
   "outputs": [],
   "source": [
    "# scambio di valori\n",
    "a,c=c,a\n",
    "print(a,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(numeratore1, _) = x.as_integer_ratio() \n",
    "print(numeratore1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(_, denominatore1) = x.as_integer_ratio() \n",
    "print(denominatore1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "tuple con un solo valore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (42) # questa non è una tupla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (42,) # questa è una tupla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Caratteristiche delle tuple**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*(poco) meno uso di lemoria*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List memory usage: 280\n",
      "Tuple memory usage: 264\n"
     ]
    }
   ],
   "source": [
    "# Confrontare l'uso di memoria tra liste e tuple\n",
    "list_example = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "tuple_example = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n",
    "\n",
    "print(\"List memory usage:\", list_example.__sizeof__())  \n",
    "# Output: List memory usage: 136\n",
    "\n",
    "print(\"Tuple memory usage:\", tuple_example.__sizeof__())  \n",
    "# Output: Tuple memory usage: 120 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Hashable**\n",
    "\n",
    "Le tuple sono *hashable*(https://docs.python.org/3/glossary.html#term-hashable), il che significa che possono essere utilizzate come chiavi nei dizionari. Questa funzionalità consente un'organizzazione dei dati più efficiente e flessibile nel codice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creare un dizionario con tuple come chiavi\n",
    "employee_salaries = {\n",
    "    (\"Mario\", \"Rossi\"): 70000,\n",
    "    (\"Carlo\", \"Bianchi\"): 80000,\n",
    "    (\"Marco\", \"Rossi\"): 60000,\n",
    "}\n",
    "\n",
    "# accedere ai dati usando le tuple come chiavi\n",
    "salary = employee_salaries[(\"Mario\", \"Rossi\")]\n",
    "print(\"Il salario di Mario è:\", salary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "employee_salaries = {\n",
    "    [\"Mario\", \"Rossi\"]: 70000,\n",
    "    (\"Carlo\", \"Bianchi\"): 80000,\n",
    "    (\"Marco\", \"Rossi\"): 60000,\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perché usare le tuple Python?\n",
    "\n",
    "Comprendere i vantaggi delle tuple Python e riconoscere quando utilizzarle può migliorare significativamente l'efficienza, la leggibilità e la manutenibilità del codice. Di seguito alcuni vantaggi specifici dell'utilizzo delle tuple nei vari progetti.\n",
    "\n",
    "**Miglioramento delle prestazioni del codice**\n",
    "\n",
    "Le tuple offrono un'efficienza della memoria superiore e tempi di esecuzione più rapidi rispetto alle liste, rendendole la scelta perfetta per situazioni in cui prestazioni ottimali sono cruciali o quando si lavora con dati non variabili. Scegliendo una tupla, beneficiamo di un ridotto consumo di memoria e di una migliore velocità di elaborazione. Questa ottimizzazione rende il nostro codice più efficiente, in particolare quando si lavora con dataset di grandi dimensioni o applicazioni sensibili alle prestazioni.\n",
    "\n",
    "**Integrità dei dati**\n",
    "\n",
    "L'immutabilità delle tuple impedisce modifiche accidentali, assicurando che i dati rimangano coerenti e affidabili durante l'esecuzione del programma.\n",
    "\n",
    "**Versatilità**\n",
    "\n",
    "Le tuple Python possono essere utilizzate per vari scopi, come la memorizzazione di più valori restituiti da una funzione, la rappresentazione di record di dimensioni fisse o la funzione di chiavi nei dizionari.\n",
    "\n",
    "**Leggibilità**\n",
    "\n",
    "Le tuple possono contribuire a rendere il codice più leggibile indicando esplicitamente che i dati archiviati sono costanti e non devono essere modificati.\n",
    "\n",
    "\n",
    "Applicazioni reali delle tuple riguardano: la rappresentazione di coordinate, date, colori RGB, o valori multipli restituiti dalle funzioni."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *Insiemi*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elementi tra parentesi graffe (le ripetizioni vengono ignorate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primi = {2, 3, 5, 7}\n",
    "dispari = {1, 3, 5, 7, 9}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(primi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primi = {2, 3, 5, 7, 5 , 5, 7, 2, 3, 2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1,2,3,2,2,3,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "listaset=set(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista=list(listaset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# unione tra insiemi\n",
    "primi | dispari      # usando un operatore\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primi.union(dispari) # equivalente richiamando un metodo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# intersezione\n",
    "primi & dispari             \n",
    "primi.intersection(dispari)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# differenza\n",
    "primi - dispari           \n",
    "primi.difference(dispari) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = set('opendata')\n",
    "b = set('bigdata')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### *Insiemi frozen*\n",
    "Il *frozenset* è solo una versione immutabile di un insieme. Mentre gli elementi di un insieme possono essere modificati in qualsiasi momento, gli elementi del frozenset rimangono gli stessi dopo la creazione.\n",
    "\n",
    "Per questo motivo, i frozenset possono essere utilizzati come chiavi. Ma come gli insiemi, non sono ordinati.\n",
    "\n",
    "La sintassi per creare un frozenset() è:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frozenset([iterable])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuple of vowels\n",
    "vowels = ('a', 'e', 'i', 'o', 'u')\n",
    "\n",
    "fSet = frozenset(vowels)\n",
    "print('The frozen set is:', fSet)\n",
    "\n",
    "# frozensets are immutable\n",
    "fSet.add('v')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Come per i normali insiemi, *frozenset* possono anche usare differenti operazioni come: *copy()*, *difference()*, *intersection()*, e *union()*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "96ec19e4-c4c9-4aa4-8029-e08e502ee974"
    }
   },
   "source": [
    "#### *Dizionari*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "2e26bfb3-7c9d-4c17-bbf4-bcc3d06fc8c1"
    }
   },
   "outputs": [],
   "source": [
    "d={\"Matematica\":30,\"Fisica\":28,\"Reti\":27}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gli elementi sono accessibili e settati tramite la setssa sintassi di indicizzazione utilizzata per le liste, tranne che per i dizionari l'indice non _zero-based_ ma si basa su una chiave valida nel dizionario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "a8cb08a0-c4d4-4524-a0b1-6a1a57caa90b"
    }
   },
   "outputs": [],
   "source": [
    "d['Matematica']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d={\"Matematica\":30,\"Fisica\":28,\"Reti\":27,0:\"ciao\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['Matematica']='30 e lode'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "7938d9b5-4672-4e73-9f51-091cb83356b1"
    }
   },
   "outputs": [],
   "source": [
    "d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "nbpresent": {
     "id": "a8db22c0-77f8-4456-8f4f-33378bdced7e"
    }
   },
   "outputs": [],
   "source": [
    "d.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Occorre tenere presente che i dizionari non mantengono alcun ordine per i parametri di input."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.5"
  },
  "nbpresent": {
   "slides": {
    "05fbc29e-040c-42f1-92e8-6ea9c9e5d1bb": {
     "id": "05fbc29e-040c-42f1-92e8-6ea9c9e5d1bb",
     "prev": "46f39f01-04b1-4b98-a658-8cce9fa47b37",
     "regions": {
      "6d6fbd67-eeba-4bf1-b599-3a115b204ad1": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "89a0e611-c617-4a23-a370-3e1f945610b3",
        "part": "whole"
       },
       "id": "6d6fbd67-eeba-4bf1-b599-3a115b204ad1"
      }
     }
    },
    "0dcdabd2-50ce-4866-b3ca-ac4821218a4f": {
     "id": "0dcdabd2-50ce-4866-b3ca-ac4821218a4f",
     "prev": "6bb98a6f-f808-471e-8af6-3ec805c17a26",
     "regions": {
      "b7929dd9-7f63-40e3-ba93-927eb729f4bf": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "9bff614c-00dc-49ad-8386-efa8002125bb",
        "part": "whole"
       },
       "id": "b7929dd9-7f63-40e3-ba93-927eb729f4bf"
      }
     }
    },
    "1037f9f2-15ff-4122-aa19-1725d378406e": {
     "id": "1037f9f2-15ff-4122-aa19-1725d378406e",
     "prev": "e0ace681-763e-40b1-8be3-afc19c396e2f",
     "regions": {
      "bd703a86-4e4a-45af-8208-c0248ff90097": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "e4189b85-b810-439f-b0e2-9d8c6c77b2bf",
        "part": "whole"
       },
       "id": "bd703a86-4e4a-45af-8208-c0248ff90097"
      }
     }
    },
    "11d81164-7047-4fac-b9fe-c5fa1cbb24ba": {
     "id": "11d81164-7047-4fac-b9fe-c5fa1cbb24ba",
     "prev": "9574098c-70cc-456c-b401-00f99ec90f31",
     "regions": {
      "5ae5b42b-cdb0-45aa-b214-28988fe1b9f5": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "c93eb5ba-f9a0-4d71-95d8-3601369d481d",
        "part": "whole"
       },
       "id": "5ae5b42b-cdb0-45aa-b214-28988fe1b9f5"
      }
     }
    },
    "1272a6a9-7016-4076-9165-0ddd3fa346ff": {
     "id": "1272a6a9-7016-4076-9165-0ddd3fa346ff",
     "prev": "4dcbb552-42d3-4a6d-b9c0-fea57cf015b8",
     "regions": {
      "8d1d684b-3b5a-49f1-8f58-17fbf8059629": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "e3ee67f3-496a-4eba-b65b-3297a3790219",
        "part": "whole"
       },
       "id": "8d1d684b-3b5a-49f1-8f58-17fbf8059629"
      }
     }
    },
    "1fb99cfa-1a1b-4d60-87c7-03abf50cd90e": {
     "id": "1fb99cfa-1a1b-4d60-87c7-03abf50cd90e",
     "prev": "66de0ce3-ae0a-4090-b92f-576745c23803",
     "regions": {
      "1c44b0f2-98d2-45cd-a183-8406b5430333": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "7938d9b5-4672-4e73-9f51-091cb83356b1",
        "part": "whole"
       },
       "id": "1c44b0f2-98d2-45cd-a183-8406b5430333"
      }
     }
    },
    "290fa467-e94e-482c-bccd-86cef6aaf14b": {
     "id": "290fa467-e94e-482c-bccd-86cef6aaf14b",
     "prev": "3141931b-8d90-4f3f-8683-310ccc19bd1c",
     "regions": {
      "4b31b033-7f83-4f1b-a920-330f05aadc89": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "dab09041-31e6-4923-8b37-88ef9a905560",
        "part": "whole"
       },
       "id": "4b31b033-7f83-4f1b-a920-330f05aadc89"
      }
     }
    },
    "2c787429-d522-4aca-a3ca-4f58932aa36e": {
     "id": "2c787429-d522-4aca-a3ca-4f58932aa36e",
     "prev": "88ae630e-a95c-4e6e-a4a8-c9c93cc92d1a",
     "regions": {
      "72320b4b-4878-4b8f-85cc-6a2205303a2e": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "9401baae-204b-4042-b453-119ffa783193",
        "part": "whole"
       },
       "id": "72320b4b-4878-4b8f-85cc-6a2205303a2e"
      }
     }
    },
    "3141931b-8d90-4f3f-8683-310ccc19bd1c": {
     "id": "3141931b-8d90-4f3f-8683-310ccc19bd1c",
     "prev": "712c413c-c0e8-4c06-80c5-46e5a855492a",
     "regions": {
      "fa0a37ec-71c9-450b-8870-866a40709752": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "d692da7c-c656-4e4f-b420-12e277eef8c1",
        "part": "whole"
       },
       "id": "fa0a37ec-71c9-450b-8870-866a40709752"
      }
     }
    },
    "394789f1-4bc6-4b2e-a963-3db36e36996b": {
     "id": "394789f1-4bc6-4b2e-a963-3db36e36996b",
     "prev": "47a9957e-d16c-427e-bba4-e85393d0e339",
     "regions": {
      "6d1229c7-ec1a-4d58-a994-6ad35a038fbc": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "52e54a38-1b1c-4901-ad2b-ba708cbf9226",
        "part": "whole"
       },
       "id": "6d1229c7-ec1a-4d58-a994-6ad35a038fbc"
      }
     }
    },
    "3ccbb819-0cbe-42d9-896b-5c3ebe904249": {
     "id": "3ccbb819-0cbe-42d9-896b-5c3ebe904249",
     "prev": "a5552fe0-82c4-460a-a0e8-5bf24a63bd2d",
     "regions": {
      "2c0c3d3f-d4e3-4d6a-a11c-27d54bdb607e": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "be99b59a-bd50-4e0d-9254-98011267d514",
        "part": "whole"
       },
       "id": "2c0c3d3f-d4e3-4d6a-a11c-27d54bdb607e"
      }
     }
    },
    "46f39f01-04b1-4b98-a658-8cce9fa47b37": {
     "id": "46f39f01-04b1-4b98-a658-8cce9fa47b37",
     "prev": "74f4069e-f957-4200-8bee-2247961a0b8f",
     "regions": {
      "39943f6e-3167-43d8-a279-eac0c68a0827": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "036b982b-ef8c-44c9-b1ae-70098dba040b",
        "part": "whole"
       },
       "id": "39943f6e-3167-43d8-a279-eac0c68a0827"
      }
     }
    },
    "47a9957e-d16c-427e-bba4-e85393d0e339": {
     "id": "47a9957e-d16c-427e-bba4-e85393d0e339",
     "prev": "5fe25894-5d6a-428e-8beb-7f3e726d8d13",
     "regions": {
      "26ad5ecb-5c0d-4073-86d2-295cf725a8e1": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "c0c7fc87-580e-4e47-b74a-5b24aecc88b4",
        "part": "whole"
       },
       "id": "26ad5ecb-5c0d-4073-86d2-295cf725a8e1"
      }
     }
    },
    "4d9a51a9-98fb-4647-aa84-4ad81cdd68ef": {
     "id": "4d9a51a9-98fb-4647-aa84-4ad81cdd68ef",
     "prev": "b21635ae-0312-4f48-b4d0-6ec294585262",
     "regions": {
      "21385a7f-951e-4074-909f-d059fd15c254": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "f4a78003-14ae-464c-ac56-3637c48a4cb4",
        "part": "whole"
       },
       "id": "21385a7f-951e-4074-909f-d059fd15c254"
      }
     }
    },
    "4dcbb552-42d3-4a6d-b9c0-fea57cf015b8": {
     "id": "4dcbb552-42d3-4a6d-b9c0-fea57cf015b8",
     "prev": "88f9dc86-c2aa-48a4-bcb6-1d64124e1837",
     "regions": {
      "325af035-3975-44f0-9372-1d03c6680bd3": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "4216f01e-82fc-4b81-abc8-c695aa738dc3",
        "part": "whole"
       },
       "id": "325af035-3975-44f0-9372-1d03c6680bd3"
      }
     }
    },
    "4e9d80e1-5291-49ef-b7e7-eb7157e8f4a3": {
     "id": "4e9d80e1-5291-49ef-b7e7-eb7157e8f4a3",
     "prev": "d430f02a-3d46-409a-bf69-c71d44bcdc14",
     "regions": {
      "7ab17f73-9a8e-4572-b687-bda8a7f2da2b": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "6ea6db85-489e-4484-8984-1fd4e517fdb3",
        "part": "whole"
       },
       "id": "7ab17f73-9a8e-4572-b687-bda8a7f2da2b"
      }
     }
    },
    "56de28ea-3bfa-4a38-b8a7-1689a693f6a8": {
     "id": "56de28ea-3bfa-4a38-b8a7-1689a693f6a8",
     "prev": "75873ada-5439-40a3-b388-ca99d8908e09",
     "regions": {
      "a408956a-4796-4ad9-b70e-599ca00606ec": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "aa637427-9f4d-42fa-88db-3c508bcf4509",
        "part": "whole"
       },
       "id": "a408956a-4796-4ad9-b70e-599ca00606ec"
      }
     }
    },
    "574d59cd-7fcc-44cf-9488-f3496608cb43": {
     "id": "574d59cd-7fcc-44cf-9488-f3496608cb43",
     "prev": "cbbb07b3-498b-43f5-b3f7-446bea97064a",
     "regions": {
      "b2b30333-e9eb-4dab-aed5-3e21a92247d0": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "ee736210-6c71-4e23-8576-ac36a6952778",
        "part": "whole"
       },
       "id": "b2b30333-e9eb-4dab-aed5-3e21a92247d0"
      }
     }
    },
    "5fe25894-5d6a-428e-8beb-7f3e726d8d13": {
     "id": "5fe25894-5d6a-428e-8beb-7f3e726d8d13",
     "prev": "bf040e93-4a1a-4096-9bc0-1a3b67d0c8f4",
     "regions": {
      "d700a620-c1df-40a2-baba-049a364c5e38": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "3925e51b-166f-44b2-8098-52e66011ed72",
        "part": "whole"
       },
       "id": "d700a620-c1df-40a2-baba-049a364c5e38"
      }
     }
    },
    "6623d00c-fb73-4f44-9480-b142931fb6b8": {
     "id": "6623d00c-fb73-4f44-9480-b142931fb6b8",
     "prev": "faff6b27-1b0e-47cd-874d-3f0f6ff002a2",
     "regions": {
      "4d486dae-867d-422f-865f-d47667564c66": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "2cbd2356-0f6c-418e-90b6-61e3aa2ae0ce",
        "part": "whole"
       },
       "id": "4d486dae-867d-422f-865f-d47667564c66"
      }
     }
    },
    "66de0ce3-ae0a-4090-b92f-576745c23803": {
     "id": "66de0ce3-ae0a-4090-b92f-576745c23803",
     "prev": "e934b62f-92a3-44e5-adf5-cbec0ac38c76",
     "regions": {
      "11d2f6b7-c91f-455b-8321-e64f763b460f": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "a8cb08a0-c4d4-4524-a0b1-6a1a57caa90b",
        "part": "whole"
       },
       "id": "11d2f6b7-c91f-455b-8321-e64f763b460f"
      }
     }
    },
    "6bb98a6f-f808-471e-8af6-3ec805c17a26": {
     "id": "6bb98a6f-f808-471e-8af6-3ec805c17a26",
     "prev": "8cfcacba-965d-4823-b4dc-954fbe7621b6",
     "regions": {
      "76a84111-30cc-4777-9876-303bc62a04d1": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "3f934a21-f8b4-424f-b3df-fada580721d3",
        "part": "whole"
       },
       "id": "76a84111-30cc-4777-9876-303bc62a04d1"
      }
     }
    },
    "6d969d0d-f009-4922-a4d2-8bedec46ccb4": {
     "id": "6d969d0d-f009-4922-a4d2-8bedec46ccb4",
     "prev": "81b8ad8e-451e-463d-bba3-4a3d0bd7dd55",
     "regions": {
      "7ccb1605-2f42-43fa-a569-521365cf404e": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "c0620dc8-7672-43e5-8ff0-594f058c856f",
        "part": "whole"
       },
       "id": "7ccb1605-2f42-43fa-a569-521365cf404e"
      }
     }
    },
    "6df0c082-26af-41e3-98a7-16a5077cbe0e": {
     "id": "6df0c082-26af-41e3-98a7-16a5077cbe0e",
     "prev": "f8b67542-7616-47bf-a785-5b8fcb7479db",
     "regions": {
      "021a5176-a306-440c-99c5-d8a625bf8b46": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "e831dc00-fa04-404c-8a63-2c0b8aab7f7e",
        "part": "whole"
       },
       "id": "021a5176-a306-440c-99c5-d8a625bf8b46"
      }
     }
    },
    "6ee68258-c322-4be1-a39f-4fb70eb0b1dc": {
     "id": "6ee68258-c322-4be1-a39f-4fb70eb0b1dc",
     "prev": "7722ac92-68fb-40c1-a89f-174262ae2c0d",
     "regions": {
      "6e1fa148-cdf1-4a89-89ed-cb28a5c72686": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "4389ceaa-cb4b-41f2-b66c-7b355c021ce0",
        "part": "whole"
       },
       "id": "6e1fa148-cdf1-4a89-89ed-cb28a5c72686"
      }
     }
    },
    "6f7b624a-d5e0-4a37-bac2-e10ff8fd7f12": {
     "id": "6f7b624a-d5e0-4a37-bac2-e10ff8fd7f12",
     "prev": "78fdd37b-171e-422f-9d9a-4c7ebb7cc69f",
     "regions": {
      "220548e0-2ce9-42c3-833e-469ce04af92e": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "aa374bdf-4d99-4dfc-a09c-da12d33cc252",
        "part": "whole"
       },
       "id": "220548e0-2ce9-42c3-833e-469ce04af92e"
      }
     }
    },
    "7042bea2-63d8-4bf4-974a-88d1de595300": {
     "id": "7042bea2-63d8-4bf4-974a-88d1de595300",
     "prev": "c8a21eaa-e5d2-4ee9-82b0-7e08b4ac89c0",
     "regions": {
      "9f3c2157-48ea-4565-98d4-23f97937fad9": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "818664b9-c94f-4141-a90e-e2b9c0fe9eeb",
        "part": "whole"
       },
       "id": "9f3c2157-48ea-4565-98d4-23f97937fad9"
      }
     }
    },
    "712c413c-c0e8-4c06-80c5-46e5a855492a": {
     "id": "712c413c-c0e8-4c06-80c5-46e5a855492a",
     "prev": "6ee68258-c322-4be1-a39f-4fb70eb0b1dc",
     "regions": {
      "b25276df-5296-4fd2-9349-bb13e1c0989e": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "2fe34863-35de-43e5-8eb9-6c2299205621",
        "part": "whole"
       },
       "id": "b25276df-5296-4fd2-9349-bb13e1c0989e"
      }
     }
    },
    "74f4069e-f957-4200-8bee-2247961a0b8f": {
     "id": "74f4069e-f957-4200-8bee-2247961a0b8f",
     "prev": "d56a3ba3-9b3d-426a-803d-c2975df2988e",
     "regions": {
      "6a822e00-a0ba-46a0-baa9-588e9561e892": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "11f26db5-0b4e-428a-87b5-a418c2f10a12",
        "part": "whole"
       },
       "id": "6a822e00-a0ba-46a0-baa9-588e9561e892"
      }
     }
    },
    "753f47a8-d105-4749-9ca3-7ac8c6b8ce06": {
     "id": "753f47a8-d105-4749-9ca3-7ac8c6b8ce06",
     "prev": "0dcdabd2-50ce-4866-b3ca-ac4821218a4f",
     "regions": {
      "b96feefa-7e55-4c0e-9de1-0414150b79c2": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "2d8f2326-ac75-4702-a3ae-71600b527a24",
        "part": "whole"
       },
       "id": "b96feefa-7e55-4c0e-9de1-0414150b79c2"
      }
     }
    },
    "75873ada-5439-40a3-b388-ca99d8908e09": {
     "id": "75873ada-5439-40a3-b388-ca99d8908e09",
     "prev": "6df0c082-26af-41e3-98a7-16a5077cbe0e",
     "regions": {
      "cdae9f06-483b-42e8-b7a8-da21b60f5127": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "018f712c-8546-443c-9b19-bb38c887d1df",
        "part": "whole"
       },
       "id": "cdae9f06-483b-42e8-b7a8-da21b60f5127"
      }
     }
    },
    "76a3cfdf-3fb8-4164-9c30-8e51e3849cf0": {
     "id": "76a3cfdf-3fb8-4164-9c30-8e51e3849cf0",
     "prev": "3ccbb819-0cbe-42d9-896b-5c3ebe904249",
     "regions": {
      "00683752-4e37-4c92-a43e-93ffe8395d1e": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "03cc3cc1-0257-4219-9764-eef4bf0b2050",
        "part": "whole"
       },
       "id": "00683752-4e37-4c92-a43e-93ffe8395d1e"
      }
     }
    },
    "7722ac92-68fb-40c1-a89f-174262ae2c0d": {
     "id": "7722ac92-68fb-40c1-a89f-174262ae2c0d",
     "prev": "2c787429-d522-4aca-a3ca-4f58932aa36e",
     "regions": {
      "cecabb82-075f-4225-afaa-d7baec3b1907": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "b54d31d8-d2ef-42db-b902-fa856ecf8225",
        "part": "whole"
       },
       "id": "cecabb82-075f-4225-afaa-d7baec3b1907"
      }
     }
    },
    "78fdd37b-171e-422f-9d9a-4c7ebb7cc69f": {
     "id": "78fdd37b-171e-422f-9d9a-4c7ebb7cc69f",
     "prev": "e904d68a-8788-4014-8de4-b632db85924d",
     "regions": {
      "70c4e8e9-34f6-4693-a97d-9706a4963381": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "89fa82df-6ec8-4529-8979-064fe245ace4",
        "part": "whole"
       },
       "id": "70c4e8e9-34f6-4693-a97d-9706a4963381"
      }
     }
    },
    "80746e4a-55be-4ffb-bb23-0ebac11c10ec": {
     "id": "80746e4a-55be-4ffb-bb23-0ebac11c10ec",
     "prev": "56de28ea-3bfa-4a38-b8a7-1689a693f6a8",
     "regions": {
      "83cefce6-a784-4706-ae3d-0583fd492432": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "776bd522-a8f3-4904-98fb-410816fb9684",
        "part": "whole"
       },
       "id": "83cefce6-a784-4706-ae3d-0583fd492432"
      }
     }
    },
    "81b8ad8e-451e-463d-bba3-4a3d0bd7dd55": {
     "id": "81b8ad8e-451e-463d-bba3-4a3d0bd7dd55",
     "prev": "6623d00c-fb73-4f44-9480-b142931fb6b8",
     "regions": {
      "597a9c0f-ca24-438e-b252-a18aad01514d": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "02cdd1c4-14fb-4603-a6d6-0dd08608d688",
        "part": "whole"
       },
       "id": "597a9c0f-ca24-438e-b252-a18aad01514d"
      }
     }
    },
    "88ae630e-a95c-4e6e-a4a8-c9c93cc92d1a": {
     "id": "88ae630e-a95c-4e6e-a4a8-c9c93cc92d1a",
     "prev": "94d33e36-4091-45f7-8251-76118d3e0a97",
     "regions": {
      "ca744c9f-537d-4bcd-b1b6-80f5c8c3bac5": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "9575f727-78c7-4dfa-8be0-6db5e5a2d49b",
        "part": "whole"
       },
       "id": "ca744c9f-537d-4bcd-b1b6-80f5c8c3bac5"
      }
     }
    },
    "88f9dc86-c2aa-48a4-bcb6-1d64124e1837": {
     "id": "88f9dc86-c2aa-48a4-bcb6-1d64124e1837",
     "prev": "cb6abaff-0c89-4618-81c9-dfb6def096b2",
     "regions": {
      "f2389494-ad87-43b2-ab41-f87bdaec166f": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "f0b73716-4eb8-4b99-a219-0313f3cfd92d",
        "part": "whole"
       },
       "id": "f2389494-ad87-43b2-ab41-f87bdaec166f"
      }
     }
    },
    "8cfcacba-965d-4823-b4dc-954fbe7621b6": {
     "id": "8cfcacba-965d-4823-b4dc-954fbe7621b6",
     "prev": "290fa467-e94e-482c-bccd-86cef6aaf14b",
     "regions": {
      "803e415b-65f0-444b-8b26-f0f59aafbab1": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "02987002-3810-4c73-ab51-91690f6cc29e",
        "part": "whole"
       },
       "id": "803e415b-65f0-444b-8b26-f0f59aafbab1"
      }
     }
    },
    "8e914bf1-4b57-4863-a427-3189aa871222": {
     "id": "8e914bf1-4b57-4863-a427-3189aa871222",
     "prev": "7042bea2-63d8-4bf4-974a-88d1de595300",
     "regions": {
      "0f70e311-f196-4b80-8d97-675030754798": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "53307708-9336-4d73-a65f-048e5ddaf3e0",
        "part": "whole"
       },
       "id": "0f70e311-f196-4b80-8d97-675030754798"
      }
     }
    },
    "94d33e36-4091-45f7-8251-76118d3e0a97": {
     "id": "94d33e36-4091-45f7-8251-76118d3e0a97",
     "prev": "edcf0f8a-1c46-4cb6-81ae-48b8b2919bf4",
     "regions": {
      "bd5d59de-ec27-4efc-a8e7-f5b75b2cfde5": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "f32a6a6b-0951-4bff-b04b-f75091aff0e2",
        "part": "whole"
       },
       "id": "bd5d59de-ec27-4efc-a8e7-f5b75b2cfde5"
      }
     }
    },
    "953cc654-d1c2-4293-9fd5-b869dde4e1cb": {
     "id": "953cc654-d1c2-4293-9fd5-b869dde4e1cb",
     "prev": "ac7de46a-f366-497d-8d39-d6956a04b6d4",
     "regions": {
      "e08935b7-e17c-464e-9504-4ac52d777be2": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "496aef00-1219-4f68-9c8b-4ed863e32d64",
        "part": "whole"
       },
       "id": "e08935b7-e17c-464e-9504-4ac52d777be2"
      }
     }
    },
    "9574098c-70cc-456c-b401-00f99ec90f31": {
     "id": "9574098c-70cc-456c-b401-00f99ec90f31",
     "prev": "574d59cd-7fcc-44cf-9488-f3496608cb43",
     "regions": {
      "8791cdbb-d26f-4cf3-b18f-e51f3f6df39a": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "99a29f2a-7fd6-42a4-ad79-1b9ef5288b84",
        "part": "whole"
       },
       "id": "8791cdbb-d26f-4cf3-b18f-e51f3f6df39a"
      }
     }
    },
    "95f59796-7dbb-4f09-950c-dc1fd9861e63": {
     "id": "95f59796-7dbb-4f09-950c-dc1fd9861e63",
     "prev": null,
     "regions": {
      "9b435fb6-fdee-42ce-a064-1bd0432b9397": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "eb8dc1d0-5bd5-4d54-9909-c72c599d91db",
        "part": "whole"
       },
       "id": "9b435fb6-fdee-42ce-a064-1bd0432b9397"
      }
     }
    },
    "a3b3f126-2d94-43b8-a211-d65785017305": {
     "id": "a3b3f126-2d94-43b8-a211-d65785017305",
     "prev": "05fbc29e-040c-42f1-92e8-6ea9c9e5d1bb",
     "regions": {
      "a3c45c04-cda5-4d38-ac3a-6ebf750e267c": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "2e875098-e45b-4fb8-9f18-0813e8965d7f",
        "part": "whole"
       },
       "id": "a3c45c04-cda5-4d38-ac3a-6ebf750e267c"
      }
     }
    },
    "a5552fe0-82c4-460a-a0e8-5bf24a63bd2d": {
     "id": "a5552fe0-82c4-460a-a0e8-5bf24a63bd2d",
     "prev": "a3b3f126-2d94-43b8-a211-d65785017305",
     "regions": {
      "9fba4441-8f7e-43d2-9cac-b9f0f2b1f045": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "81a32d0a-e959-4712-99da-a547100c0b14",
        "part": "whole"
       },
       "id": "9fba4441-8f7e-43d2-9cac-b9f0f2b1f045"
      }
     }
    },
    "ac7de46a-f366-497d-8d39-d6956a04b6d4": {
     "id": "ac7de46a-f366-497d-8d39-d6956a04b6d4",
     "prev": "1037f9f2-15ff-4122-aa19-1725d378406e",
     "regions": {
      "6b483752-88fb-424e-a556-9f6a673fbf70": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "8e31fb00-b85f-4ac1-9bcd-125ca784333f",
        "part": "whole"
       },
       "id": "6b483752-88fb-424e-a556-9f6a673fbf70"
      }
     }
    },
    "b21635ae-0312-4f48-b4d0-6ec294585262": {
     "id": "b21635ae-0312-4f48-b4d0-6ec294585262",
     "prev": "1fb99cfa-1a1b-4d60-87c7-03abf50cd90e",
     "regions": {
      "35d6f9e6-38ae-42b5-b5a3-9939a5be6a98": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "a8db22c0-77f8-4456-8f4f-33378bdced7e",
        "part": "whole"
       },
       "id": "35d6f9e6-38ae-42b5-b5a3-9939a5be6a98"
      }
     }
    },
    "bf040e93-4a1a-4096-9bc0-1a3b67d0c8f4": {
     "id": "bf040e93-4a1a-4096-9bc0-1a3b67d0c8f4",
     "prev": "8e914bf1-4b57-4863-a427-3189aa871222",
     "regions": {
      "dad1f069-bcd1-4b98-8526-9c1b9056a2cd": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "042cb4fd-b94e-4d7b-9667-fd0b087b074a",
        "part": "whole"
       },
       "id": "dad1f069-bcd1-4b98-8526-9c1b9056a2cd"
      }
     }
    },
    "c2c86084-a81c-448e-9e2e-53cf31374d61": {
     "id": "c2c86084-a81c-448e-9e2e-53cf31374d61",
     "prev": "95f59796-7dbb-4f09-950c-dc1fd9861e63",
     "regions": {
      "6b3fc3da-4d65-42f2-8d9c-0d238f9aa9af": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "58d3f034-4bf4-46b0-bd9f-18245b29c0ac",
        "part": "whole"
       },
       "id": "6b3fc3da-4d65-42f2-8d9c-0d238f9aa9af"
      }
     }
    },
    "c8a21eaa-e5d2-4ee9-82b0-7e08b4ac89c0": {
     "id": "c8a21eaa-e5d2-4ee9-82b0-7e08b4ac89c0",
     "prev": "6d969d0d-f009-4922-a4d2-8bedec46ccb4",
     "regions": {
      "850965fc-b63b-43dc-9c5b-928f0a7051be": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "1c1f88ef-ddee-419b-b47b-5bf0dd9d568f",
        "part": "whole"
       },
       "id": "850965fc-b63b-43dc-9c5b-928f0a7051be"
      }
     }
    },
    "cb6abaff-0c89-4618-81c9-dfb6def096b2": {
     "id": "cb6abaff-0c89-4618-81c9-dfb6def096b2",
     "prev": "d4191e74-6533-4e78-a002-b38d90856993",
     "regions": {
      "619bbc44-9f25-465f-be9a-cf0f180985af": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "e145ce34-7843-47f0-bab3-058dbe65a951",
        "part": "whole"
       },
       "id": "619bbc44-9f25-465f-be9a-cf0f180985af"
      }
     }
    },
    "cbbb07b3-498b-43f5-b3f7-446bea97064a": {
     "id": "cbbb07b3-498b-43f5-b3f7-446bea97064a",
     "prev": "4e9d80e1-5291-49ef-b7e7-eb7157e8f4a3",
     "regions": {
      "921ef546-3e2a-4cd4-b345-06d632c49739": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "b33b393f-baa2-4e13-8b41-98c1d9747844",
        "part": "whole"
       },
       "id": "921ef546-3e2a-4cd4-b345-06d632c49739"
      }
     }
    },
    "cc0d06ab-e7d6-4cdf-a3f2-fbf31e677e72": {
     "id": "cc0d06ab-e7d6-4cdf-a3f2-fbf31e677e72",
     "prev": "80746e4a-55be-4ffb-bb23-0ebac11c10ec",
     "regions": {
      "89bbe9e2-8ca6-43c5-8fb5-47f33387c228": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "5406f817-187c-4699-9a70-5641eb2e80cb",
        "part": "whole"
       },
       "id": "89bbe9e2-8ca6-43c5-8fb5-47f33387c228"
      }
     }
    },
    "d4191e74-6533-4e78-a002-b38d90856993": {
     "id": "d4191e74-6533-4e78-a002-b38d90856993",
     "prev": "394789f1-4bc6-4b2e-a963-3db36e36996b",
     "regions": {
      "5f57c351-eee6-4b21-9816-8ede7575557e": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "ef36be8c-27ab-4961-9218-2d4f5234db3c",
        "part": "whole"
       },
       "id": "5f57c351-eee6-4b21-9816-8ede7575557e"
      }
     }
    },
    "d430f02a-3d46-409a-bf69-c71d44bcdc14": {
     "id": "d430f02a-3d46-409a-bf69-c71d44bcdc14",
     "prev": "c2c86084-a81c-448e-9e2e-53cf31374d61",
     "regions": {
      "d7f21525-8307-4ed1-96ce-a3839875fcb3": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "983546ef-e6a6-4f74-97da-008bcbceefac",
        "part": "whole"
       },
       "id": "d7f21525-8307-4ed1-96ce-a3839875fcb3"
      }
     }
    },
    "d56a3ba3-9b3d-426a-803d-c2975df2988e": {
     "id": "d56a3ba3-9b3d-426a-803d-c2975df2988e",
     "prev": "4d9a51a9-98fb-4647-aa84-4ad81cdd68ef",
     "regions": {
      "ed8f527b-5c11-429e-8eb4-b50ba088ffb8": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "3e640779-f697-4a90-82c4-998053c2f863",
        "part": "whole"
       },
       "id": "ed8f527b-5c11-429e-8eb4-b50ba088ffb8"
      }
     }
    },
    "d9faf521-2d9a-43fc-a42b-80f9a77dff62": {
     "id": "d9faf521-2d9a-43fc-a42b-80f9a77dff62",
     "prev": "cc0d06ab-e7d6-4cdf-a3f2-fbf31e677e72",
     "regions": {
      "b8e416ec-eea5-421a-afca-deda3ff363f7": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "8d707134-9fc5-4726-8632-ff8adcc5874b",
        "part": "whole"
       },
       "id": "b8e416ec-eea5-421a-afca-deda3ff363f7"
      }
     }
    },
    "e0ace681-763e-40b1-8be3-afc19c396e2f": {
     "id": "e0ace681-763e-40b1-8be3-afc19c396e2f",
     "prev": "d9faf521-2d9a-43fc-a42b-80f9a77dff62",
     "regions": {
      "38b4d06e-f9c5-4b18-9e06-3c06d2fe5337": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "42eaeda6-8cad-4c62-bb03-686f4ff6f403",
        "part": "whole"
       },
       "id": "38b4d06e-f9c5-4b18-9e06-3c06d2fe5337"
      }
     }
    },
    "e40d996e-9b03-4ba2-9a74-89f0aa3b8932": {
     "id": "e40d996e-9b03-4ba2-9a74-89f0aa3b8932",
     "prev": "1272a6a9-7016-4076-9165-0ddd3fa346ff",
     "regions": {
      "04a59772-617b-4790-b620-06924d80a6c9": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "96ec19e4-c4c9-4aa4-8029-e08e502ee974",
        "part": "whole"
       },
       "id": "04a59772-617b-4790-b620-06924d80a6c9"
      }
     }
    },
    "e904d68a-8788-4014-8de4-b632db85924d": {
     "id": "e904d68a-8788-4014-8de4-b632db85924d",
     "prev": "11d81164-7047-4fac-b9fe-c5fa1cbb24ba",
     "regions": {
      "cf4875b6-f638-4fb6-a461-2a837da3f03a": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "4b5bccd4-334d-4eeb-8a90-b4b2385f1046",
        "part": "whole"
       },
       "id": "cf4875b6-f638-4fb6-a461-2a837da3f03a"
      }
     }
    },
    "e934b62f-92a3-44e5-adf5-cbec0ac38c76": {
     "id": "e934b62f-92a3-44e5-adf5-cbec0ac38c76",
     "prev": "e40d996e-9b03-4ba2-9a74-89f0aa3b8932",
     "regions": {
      "b0bc2fea-b762-484d-b960-0b0bc629ee6d": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "2e26bfb3-7c9d-4c17-bbf4-bcc3d06fc8c1",
        "part": "whole"
       },
       "id": "b0bc2fea-b762-484d-b960-0b0bc629ee6d"
      }
     }
    },
    "edcf0f8a-1c46-4cb6-81ae-48b8b2919bf4": {
     "id": "edcf0f8a-1c46-4cb6-81ae-48b8b2919bf4",
     "prev": "6f7b624a-d5e0-4a37-bac2-e10ff8fd7f12",
     "regions": {
      "d41dfdf5-5cf4-4ab3-9002-88030c2b9f1a": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "7d0426ab-c490-46dd-bde3-7e5693f15296",
        "part": "whole"
       },
       "id": "d41dfdf5-5cf4-4ab3-9002-88030c2b9f1a"
      }
     }
    },
    "ee5c3e81-0c9f-4811-89b2-b46e5eed5328": {
     "id": "ee5c3e81-0c9f-4811-89b2-b46e5eed5328",
     "prev": "76a3cfdf-3fb8-4164-9c30-8e51e3849cf0",
     "regions": {
      "0861e38a-cba0-4097-a42c-b36378978b52": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "f2d731ea-a4f8-45bb-9671-6ca10aa19189",
        "part": "whole"
       },
       "id": "0861e38a-cba0-4097-a42c-b36378978b52"
      }
     }
    },
    "f8b67542-7616-47bf-a785-5b8fcb7479db": {
     "id": "f8b67542-7616-47bf-a785-5b8fcb7479db",
     "prev": "ee5c3e81-0c9f-4811-89b2-b46e5eed5328",
     "regions": {
      "a86cd7e8-a083-4dde-82f0-4d7d46efd21e": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "0fab704d-7d6b-45a9-b274-3b5c7fc7791f",
        "part": "whole"
       },
       "id": "a86cd7e8-a083-4dde-82f0-4d7d46efd21e"
      }
     }
    },
    "faff6b27-1b0e-47cd-874d-3f0f6ff002a2": {
     "id": "faff6b27-1b0e-47cd-874d-3f0f6ff002a2",
     "prev": "753f47a8-d105-4749-9ca3-7ac8c6b8ce06",
     "regions": {
      "7cf3f859-7e11-4ca5-b53d-72c330e41387": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "0aaf411d-a8a3-4e35-bd7a-f7c7c4d3e13a",
        "part": "whole"
       },
       "id": "7cf3f859-7e11-4ca5-b53d-72c330e41387"
      }
     }
    }
   },
   "themes": {}
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}