diff --git a/.github/workflows/generate-pdfs-on-release.yml b/.github/workflows/generate-pdfs-on-release.yml
deleted file mode 100644
index 4ba49ef..0000000
--- a/.github/workflows/generate-pdfs-on-release.yml
+++ /dev/null
@@ -1,61 +0,0 @@
-name: Generate PDFs on Release
-
-on:
-  release:
-    types: [created, published]
-
-jobs:
-  generate-pdfs:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-      
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y pandoc texlive-xetex texlive-fonts-recommended texlive-plain-generic
-          sudo apt-get install -y poppler-utils
-          pip install jupyter==1.1.1 nbconvert==7.16.6
-      
-      - name: Convert notebooks to PDF
-        run: |
-          mkdir -p pdfs
-          shopt -s nullglob
-          notebooks=(*.ipynb)
-          if [ ${#notebooks[@]} -eq 0 ]; then
-            echo "No notebooks found to convert"
-            exit 0
-          fi
-          for notebook in "${notebooks[@]}"; do
-            echo "Converting $notebook to PDF..."
-            jupyter nbconvert --to pdf "$notebook" --output-dir=pdfs || echo "Warning: Failed to convert $notebook"
-          done
-          
-          # Merge all PDFs into one
-          echo "Merging PDFs..."
-          pdfunite pdfs/*.pdf pdfs/corso-python-basic.pdf
-          echo "Conversion complete! Final merged file: corso-python-basic.pdf"
-      
-      - name: Upload PDFs to release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          shopt -s nullglob
-          pdfs=(pdfs/*.pdf)
-          if [ ${#pdfs[@]} -eq 0 ]; then
-            echo "No PDFs found to upload"
-            exit 0
-          fi
-          for pdf in "${pdfs[@]}"; do
-            echo "Uploading $pdf to release..."
-            gh release upload ${{ github.event.release.tag_name }} "$pdf" --clobber
-          done
diff --git a/.gitignore b/.gitignore
index 35469c4..dfb331a 100755
--- a/.gitignore
+++ b/.gitignore
@@ -28,6 +28,7 @@ server/package-lock.json
 
 .ipynb_checkpoints/
 
-# PDF files (generated by CI/CD)
 *.pdf
-pdfs/
+output_pdf/
+venv_pdf/
+pdf.sh
\ No newline at end of file
diff --git a/00_sommario_corso.ipynb b/00_sommario_corso.ipynb
index 821078f..885ee07 100755
--- a/00_sommario_corso.ipynb
+++ b/00_sommario_corso.ipynb
@@ -5,12 +5,12 @@
    "id": "9283dcca",
    "metadata": {},
    "source": [
-    "# 📚 Sommario del Corso Python per Principianti\n",
+    "# Sommario del Corso Python per Principianti\n",
     "\n",
     "Questo corso è un percorso introduttivo pensato per imparare a muovere i primi passi nel linguaggio Python. È uno dei pochi corsi per principianti di questo tipo disponibili interamente in italiano, progettato per offrire un apprendimento chiaro e accessibile.\n",
     "\n",
     "---\n",
-    "## 🧠 Python nell'Era dell'Intelligenza Artificiale\n",
+    "## Python nell'Era dell'Intelligenza Artificiale\n",
     "\n",
     "Saper programmare in Python oggi non significa solo imparare un linguaggio, ma acquisire una competenza fondamentale in particolare nel campo dell'Intelligenza Artificiale (AI) e dei Large Language Model (LLM).\n",
     "\n",
@@ -26,7 +26,7 @@
    "id": "47009f70",
    "metadata": {},
    "source": [
-    "## 📖 Moduli del corso\n",
+    "## Moduli del corso\n",
     "1. [Primi passi con Python](01_primi_passi.ipynb)\n",
     "2. [Sintassi base di Python](02_sintassi_base.ipynb)\n",
     "3. [Strutture dati](03_strutture_dati.ipynb)\n",
@@ -40,7 +40,7 @@
     "11. [Decorator, closure e funzioni avanzate](11_decorator_closure.ipynb)\n",
     "12. [Progetto conclusivo](12_progetto.ipynb)\n",
     "\n",
-    "## 🎯 Obiettivi del Corso\n",
+    "## Obiettivi del Corso\n",
     "- Imparare la sintassi base di Python.\n",
     "- Eseguire codice con Jupyter Notebook.\n",
     "- Capire variabili, tipi e strutture di controllo, cicli.\n",
diff --git a/01_primi_passi.ipynb b/01_primi_passi.ipynb
index cc5d36f..40b4f83 100755
--- a/01_primi_passi.ipynb
+++ b/01_primi_passi.ipynb
@@ -5,7 +5,7 @@
    "id": "8db108fa",
    "metadata": {},
    "source": [
-    "# 🐍 Primi passi con Python\n",
+    "# Primi passi con Python\n",
     "\n",
     "In questa lezione, vedremo cosa serve per iniziare, partendo dalle competenze di base agli strumenti per scrivere i primi programmi.\n",
     "\n",
@@ -17,11 +17,11 @@
    "id": "038c35b4",
    "metadata": {},
    "source": [
-    "## Pre-requisiti e strumenti necessari 🛠️\n",
+    "## Pre-requisiti e strumenti necessari\n",
     "\n",
     "### Competenze richieste\n",
     "\n",
-    "Questo corso è pensato per i **principianti assoluti**. Non è richiesta alcuna esperienza di programmazione pregressa. Le uniche competenze utili sono una conoscenza di base di come usare un computer e familiarità con l'uso di un browser web e del terminale (o Prompt dei comandi) del tuo sistema operativo."
+    "Questo corso è pensato per i **principianti assoluti**. Non è richiesta alcuna esperienza di programmazione pregressa. Le uniche competenze utili sono una conoscenza di base di come usare un computer e familiarità con l'uso di un browser web e del terminale (o Prompt dei comandi) del sistema operativo."
    ]
   },
   {
@@ -42,27 +42,112 @@
    ]
   },
   {
-   "cell_type": "markdown",
-   "id": "5697c534",
-   "metadata": {},
-   "source": [
+  "cell_type": "markdown",
+  "id": "installazione_python_dettagliata",
+  "metadata": {},
+  "source": [
     "### Installazione di Python e dell'editor\n",
     "\n",
-    "A seconda del sistema operativo in uso, i passaggi sono leggermente diversi. Prima di iniziare a programmare occorre assicurasi di avere Python installato e configurato correttamente prima di procedere.\n",
+    "Per iniziare a programmare in Python occorre assicurarsi che l’interprete sia installato correttamente sul proprio sistema.\n",
+    "I passaggi variano leggermente a seconda del sistema operativo.\n",
     "\n",
-    "**Su Linux**\n",
-    "- **Python:** È quasi sempre preinstallato. Si può verificare con il comando `python3 --version`.\n",
-    "- **Editor:** [Opzionale] Si può installare **VS Code** dal sito ufficiale o tramite il gestore di pacchetti (ad es., `sudo snap install code --classic`).\n",
+    "#### Installare Python su Linux\n",
     "\n",
-    "**Su macOS**\n",
-    "- **Python:** Scaricare l'installer dal **[sito ufficiale di Python](https://www.python.org/downloads/)** o usa Homebrew (`brew install python3`).\n",
-    "- **Editor:** [Opzionale] Si può installare **[VS Code](https://code.visualstudio.com/)** dal sito ufficiale.\n",
+    "La maggior parte delle distribuzioni Linux include già Python, ma spesso la versione usata dal sistema è diversa da quella che si vorrebbe usare per programmare.\n",
     "\n",
-    "**Su Windows**\n",
-    "- **Python:** Scaricare l'installer dal **[sito ufficiale di Python](https://www.python.org/downloads/)**. **Ricorda di spuntare la casella `Add Python to PATH`** durante l'installazione.\n",
-    "- **Editor:** [Opzionale] Si può installare **[VS Code](https://code.visualstudio.com/)** dal sito ufficiale."
-   ]
-  },
+    "Verificare se Python è installato dal terminale:\n",
+    "```bash\n",
+    "python3 --version\n",
+    "```\n",
+    "\n",
+    "**Ubuntu / Debian**\n",
+    "```bash\n",
+    "sudo apt update\n",
+    "sudo apt install python3 python3-pip python3-venv\n",
+    "```\n",
+    "\n",
+    "**Fedora**\n",
+    "```bash\n",
+    "sudo dnf install python3 python3-pip python3-virtualenv\n",
+    "```\n",
+    "\n",
+    "**Arch Linux / Manjaro**\n",
+    "```bash\n",
+    "sudo pacman -S python python-pip\n",
+    "```\n",
+    "\n",
+    "#### Installare Python su macOS\n",
+    "\n",
+    "Il metodo consigliato è quello di usare l'installer ufficiale che si può scaricare da: https://www.python.org/downloads/\n",
+    "\n",
+    "Come alternativa è possibile utilizzare il gestore di pacchetti Homebrew.\n",
+    "\n",
+    "**Che cos’è Homebrew?**\n",
+    "\n",
+    "Homebrew è un gestore di pacchetti per macOS, utile per installare software tramite terminale.\n",
+    "\n",
+    "Installazione Homebrew:\n",
+    "```bash\n",
+    "/bin/bash -c \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)\"\n",
+    "```\n",
+    "\n",
+    "Una volta installato Homebrew è possibile installare Python tramite Homebrew:\n",
+    "```bash\n",
+    "brew update\n",
+    "brew install python\n",
+    "```\n",
+    "\n",
+    "#### Installare Python su Windows\n",
+    "\n",
+    "1. Andare su: https://www.python.org/downloads/\n",
+    "2. Scaricare l’installer.\n",
+    "3. **Attivare l’opzione `Add Python to PATH`**.\n",
+    "4. Verificare l'installazione:\n",
+    "```powershell\n",
+    "python --version\n",
+    "```\n",
+    "\n",
+    "### Installazione dell’editor (VS Code)\n",
+    "Il metodo consigliato è quello di scaricare VS Code dal sito ufficiale https://code.visualstudio.com/\n",
+    "\n",
+    "**macOS (Homebrew):**\n",
+    "\n",
+    "VS Code è disponibile anche attraverso Homebrew:\n",
+    "```bash\n",
+    "brew install --cask visual-studio-code\n",
+    "```\n",
+    "\n",
+    "### Gestire più versioni di Python con pyenv\n",
+    "\n",
+    "Quando si lavora con Python, può essere necessario utilizzare **versioni diverse** per progetti differenti. Per evitare conflitti, si può usare **pyenv**, uno strumento che permette di installare e gestire più versioni di Python sullo stesso sistema.\n",
+    "\n",
+    "**Installazione macOS e Linux:**\n",
+    "Installare tramite script ufficiale:\n",
+    "```bash\n",
+    "curl https://pyenv.run | bash\n",
+    "```\n",
+    "\n",
+    "Aggiungere al file della shell (ad esempio ~/.bashrc o ~/.zshrc):\n",
+    "```bash\n",
+    "export PATH=\"$HOME/.pyenv/bin:$PATH\"\n",
+    "eval \"$(pyenv init -)\"\n",
+    "```\n",
+    "\n",
+     "**Installazione su Windows):**\n",
+    "Usare il progetto pyenv-win:\n",
+    "\n",
+    "```powershell\n",
+    "Invoke-WebRequest -UseBasicParsing -Uri \"https://pyenv-win.github.io/pyenv-win/install.ps1\" | Invoke-Expression\n",
+    "```\n",
+    "\n",
+    "**Comandi principali:**\n",
+    "- Lista versioni disponibili: `pyenv install --list`\n",
+    "- Installare una versione: `pyenv install 3.12.1`\n",
+    "- Impostare versione globale: `pyenv global 3.12.1`\n",
+    "- Impostare versione locale: `pyenv local 3.11.6`"
+  ]
+}
+,
   {
    "cell_type": "markdown",
    "id": "5050cc32",
@@ -92,7 +177,7 @@
    "id": "7c25e16f",
    "metadata": {},
    "source": [
-    "**Perché è così importante?** Questo semplice comando ci dimostra tre cose fondamentali:\n",
+    "**Perché è così importante?** Questo semplice comando dimostra tre cose fondamentali:\n",
     "- **Sintassi chiara:** La sintassi di Python è intuitiva e facile da leggere.\n",
     "- **Funzioni:** E' stata usata una funzione (`print()`). Le funzioni sono blocchi di codice riutilizzabili.\n",
     "- **Esecuzione:** E' stato eseguito un programma completo, anche se composto da una sola riga."
@@ -114,7 +199,7 @@
    "id": "a57a03aa",
    "metadata": {},
    "source": [
-    "### Interazione con l'utente: la funzione `input()` 💬\n",
+    "### Interazione con l'utente: la funzione `input()`\n",
     "\n",
     "Mentre `print()` permette di mostrare un output, la funzione **`input()`** consente di chiedere all'utente di inserire dei dati. Quando Python incontra `input()`, il programma si ferma e attende che l'utente scriva qualcosa e prema Invio. Il testo che l'utente inserisce viene restituito come una stringa. Spiegheremo in dettaglio come funziona `input()` più avanti nel corso, qui si può vederla in azione nel prossimo esempio."
    ]
@@ -125,7 +210,7 @@
    "metadata": {},
    "source": [
     "### Esempio: `greet.py`\n",
-    "Creare un file di testo e salvalo come `greet.py` in una cartella di lavoro. Al suo interno, scrivere il seguente codice:"
+    "Creare un file di testo e salvarlo come `greet.py` in una cartella di lavoro. Al suo interno, scrivere il seguente codice:"
    ]
   },
   {
@@ -148,7 +233,7 @@
    "id": "af5a1f21",
    "metadata": {},
    "source": [
-    "### Il costrutto `if __name__ == \"__main__\":` 🤔\n",
+    "### Il costrutto `if __name__ == \"__main__\":`\n",
     "\n",
     "Il primo blocco che viene all'attenzione è il blocco `if __name__ == \"__main__\":`. Questo è un costrutto comune e importante in Python. Serve a controllare se il file Python viene eseguito direttamente o se viene importato come modulo in un altro script.\n",
     "\n",
@@ -165,7 +250,7 @@
    "id": "7151f687",
    "metadata": {},
    "source": [
-    "### Passare argomenti esterni al programma 🚀\n",
+    "### Passare argomenti esterni al programma\n",
     "\n",
     "Spesso, invece di chiedere all'utente di inserire dati con `input()`, si vuole che il programma li riceva direttamente quando viene eseguito da terminale. Questo è possibile farlo usando il modulo della libreria standard `sys` e in particolare la lista `sys.argv`.\n",
     "\n",
@@ -206,13 +291,13 @@
     "\n",
     "Python ha una ricca **libreria standard** di moduli che si può importare per estendere le funzionalità all'interno di un codice. Le librerie sono collezioni di funzioni e strumenti predefiniti.\n",
     "\n",
-    "### Come e dove Python cerca i moduli 🗺️\n",
+    "### Come e dove Python cerca i moduli\n",
     "\n",
     "Quando un'istruzione `import` viene eseguita, Python cerca i moduli in una lista di percorsi predefinita, accessibile tramite la lista **`sys.path`** del modulo integrato `sys`. Questo meccanismo è fondamentale per capire come vengono trovate sia le librerie standard che quelle installate di terze parti.\n",
     "\n",
     "La lista `sys.path` include, tra gli altri, i seguenti percorsi:\n",
     "\n",
-    "1.  **La directory in cui si trova il tuo script.** Questo permette di importare facilmente i tuoi file (es. `import saluto`).\n",
+    "1.  **La directory in cui si trova il tuo script.** Questo permette di importare facilmente i file (es. `import saluto`).\n",
     "2.  **Le directory delle librerie standard di Python.** Qui si trovano i moduli base come `math`, `sys` e `os`.\n",
     "3.  **Le directory dove sono installate le librerie di terze parti.** Queste sono le librerie installate tramite `pip`.\n",
     "\n",
@@ -271,7 +356,7 @@
    "source": [
     "### Cos'è Jupyter Notebook?\n",
     "\n",
-    "Jupyter Notebook è un'applicazione web open-source che ti permette di creare e condividere documenti contenenti codice live, equazioni, visualizzazioni e testo esplicativo. È uno strumento essenziale per la **data science**, l'apprendimento automatico e la ricerca scientifica, ma è anche ideale per la didattica, poiché ti permette di eseguire piccoli blocchi di codice e vederne immediatamente i risultati."
+    "Jupyter Notebook è un'applicazione web open-source che permette di creare e condividere documenti contenenti codice live, equazioni, visualizzazioni e testo esplicativo. È uno strumento essenziale per la **data science**, l'apprendimento automatico e la ricerca scientifica, ma è anche ideale per la didattica, poiché permette di eseguire piccoli blocchi di codice e vederne immediatamente i risultati."
    ]
   },
   {
@@ -450,9 +535,9 @@
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/01/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/01/solutions)**\n",
     "\n",
     "---"
   ]
diff --git a/02_sintassi_base.ipynb b/02_sintassi_base.ipynb
index eeec1b5..c5df2cc 100755
--- a/02_sintassi_base.ipynb
+++ b/02_sintassi_base.ipynb
@@ -5,7 +5,7 @@
    "id": "7c690cce",
    "metadata": {},
    "source": [
-    "# ⌨️ Sintassi base di Python\n",
+    "# Sintassi base di Python\n",
     "\n",
     "---\n",
     "Dopo aver configurato l'ambiente di lavoro e aver scritto il primo programma, è il momento di esplorare la grammatica di base del linguaggio. In questa lezione, vedremo la sintassi fondamentale di Python: come si scrivono i commenti, l'importanza dell'indentazione, le variabili, i tipi di dati più comuni, le strutture di controllo del flusso e i cicli. Questi sono i concetti essenziali che si useranno in ogni programma."
@@ -61,7 +61,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "## Indentazione: Perché è così importante? 🤔\n",
+    "## Indentazione: Perché è così importante?\n",
     "\n",
     "L'**indentazione** è uno dei concetti più importanti e unici della sintassi di Python. A differenza di molti altri linguaggi (come Java o C++) che usano parentesi graffe `{}` per definire blocchi di codice, Python usa lo spazio bianco. Ogni blocco di codice, come quello all'interno di un'istruzione `if` o di un ciclo `for`, deve essere indentato con la stessa quantità di spazi.\n",
     "\n",
@@ -116,7 +116,7 @@
     "---\n",
     "## Variabili e assegnazioni\n",
     "\n",
-    "Una **variabile** è un contenitore a si assegna un valore. In Python, non è necessario dichiarare il tipo di una variabile in anticipo; l’interprete lo deduce automaticamente dal valore che le viene assegnato. Questo approccio si chiama **tipizzazione dinamica** ed è stato scelto per rendere il linguaggio più **semplice e veloce da scrivere**, soprattutto per chi inizia o per chi sviluppa prototipi. Non dover specificare il tipo riduce la quantità di codice “boilerplate” e permette di concentrarsi sulla logica.\n",
+    "Una **variabile** è un contenitore a cui si assegna un valore. In Python, non è necessario dichiarare il tipo di una variabile in anticipo; l’interprete lo deduce automaticamente dal valore che le viene assegnato. Questo approccio si chiama **tipizzazione dinamica** ed è stato scelto per rendere il linguaggio più **semplice e veloce da scrivere**, soprattutto per chi inizia o per chi sviluppa prototipi. Non dover specificare il tipo riduce la quantità di codice “boilerplate” e permette di concentrarsi sulla logica.\n",
     "\n",
     "I nomi delle variabili devono iniziare con una lettera o un underscore (`_`) e possono contenere lettere, numeri e underscore. Inoltre, sono **case-sensitive**: ad esempio `variabile`, `Variabile` e `VARIABILE` sono considerati tre identificatori distinti.\n",
     "\n",
@@ -478,37 +478,124 @@
   },
   {
    "cell_type": "markdown",
-   "id": "dcd2b015",
    "metadata": {},
    "source": [
     "---\n",
     "## Funzioni di input e output\n",
     "\n",
     "### Funzione `print()`\n",
-    "La funzione `print()` serve per visualizzare l'output a schermo. È estremamente versatile e supporta la formattazione avanzata con le **f-string** (`f-string`), un modo potente per incorporare variabili all'interno di una stringa in modo leggibile e conciso.\n",
+    "La funzione `print()` serve per visualizzare **dati o messaggi a schermo**. È estremamente flessibile e consente di:\n",
+    "- stampare più valori contemporaneamente,\n",
+    "- personalizzare il separatore (`sep`) e il termine della riga (`end`),\n",
+    "- formattare l'output con f-string, `format()` o placeholder `%`.\n",
     "\n",
+    "#### Argomenti base di `print()`\n",
+    "\n",
+    "```python\n",
+    "print('Ciao', 'mondo', sep=' - ', end='!\\n')\n",
+    "# Output: Ciao - mondo!\n",
+    "```\n",
+    "- `sep` → definisce il separatore tra più argomenti (di default è uno spazio)\n",
+    "- `end` → definisce cosa viene stampato alla fine della riga (di default è `\\n`, cioè nuova riga)\n",
+    "\n",
+    "#### F-string (formattazione moderna e leggibile)\n",
+    "\n",
+    "Le **f-string** (dal prefisso `f`) permettono di inserire variabili ed espressioni direttamente dentro una stringa:\n",
+    "\n",
+    "```python\n",
+    "nome = 'Luca'\n",
+    "saldo = 1234.567\n",
+    "print(f\"Ciao {nome}, il tuo saldo è {saldo:.2f}€\")\n",
+    "# Output: Ciao Luca, il tuo saldo è 1234.57€\n",
+    "```\n",
+    "- `{saldo:.2f}` → mostra due decimali (utile per importi o valori numerici)\n",
+    "- all’interno delle `{}` si possono anche eseguire **espressioni Python**, es. `{2 + 3}` → 5\n",
+    "\n",
+    "#### Metodo `str.format()`\n",
+    "\n",
+    "È una forma più vecchia ma ancora diffusa di formattazione:\n",
+    "\n",
+    "```python\n",
+    "nome = 'Paola'\n",
+    "anni = 28\n",
+    "print('Ciao {}, hai {} anni.'.format(nome, anni))\n",
+    "# Output: Ciao Paola, hai 28 anni.\n",
+    "\n",
+    "print('Ciao {n}, hai {a} anni.'.format(n=nome, a=anni))\n",
+    "```\n",
+    "\n",
+    "Si può controllare la formattazione numerica:\n",
+    "```python\n",
+    "print('Il prezzo è {:.2f}€'.format(19.99))  # 2 decimali\n",
+    "print('Numero: {:>6}'.format(42))           # allineato a destra in 6 spazi\n",
+    "```\n",
+    "\n",
+    "#### Placeholder in stile C (`%`)\n",
+    "\n",
+    "Un metodo più datato, ancora usato in alcuni script:\n",
+    "\n",
+    "```python\n",
+    "nome = 'Aldo'\n",
+    "eta = 25\n",
+    "print('Ciao %s, hai %d anni.' % (nome, eta))\n",
+    "# %s → stringa, %d → intero, %f → float\n",
+    "```\n",
+    "\n",
+    "#### Esempio comparativo\n",
+    "\n",
+    "| Metodo | Sintassi | Output |\n",
+    "|--------|-----------|--------|\n",
+    "| f-string | `f\"Ciao {nome}\"` | Ciao Luca |\n",
+    "| `format()` | `'Ciao {}'.format(nome)` | Ciao Luca ||\n",
+    "| `%` placeholder | `'Ciao %s' % nome` | Ciao Luca |\n",
+    "\n",
+    "Le **f-string** sono considerate la scelta **più moderna, leggibile e veloce**.\n",
+    "\n",
+    "---\n",
     "### Funzione `input()`\n",
-    "La funzione `input()` serve per leggere dati inseriti dall'utente tramite la tastiera. Restituisce sempre una **stringa**, quindi è necessario convertirla per usarla in operazioni matematiche."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9b088d70",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Example with print() and f-string\n",
-    "user_name = \"Mario\"\n",
-    "age = 30\n",
-    "print(f\"Hello, {user_name}. You are {age} years old.\")\n",
+    "La funzione `input()` serve per **leggere dati dall’utente**. Restituisce sempre una **stringa**, quindi è spesso necessario convertirla per usarla in calcoli numerici.\n",
     "\n",
-    "# Example with input() and casting\n",
-    "age_str = input(\"Enter your age: \")\n",
-    "age_int = int(age_str)\n",
-    "print(f\"In 5 years you will be {age_int + 5} years old.\")"
+    "```python\n",
+    "nome = input('Come ti chiami? ')\n",
+    "eta = int(input('Quanti anni hai? '))\n",
+    "print(f'Ciao {nome}, tra 10 anni avrai {eta + 10} anni!')\n",
+    "```"
    ]
-  },
+},
+{
+  "cell_type": "code",
+  "metadata": {},
+  "execution_count": null,
+  "outputs": [],
+  "source": [
+    "# Examples of f-strings and advanced formatting\n",
+    "name = 'Luca'\n",
+    "age = 28\n",
+    "balance = 1234.5678\n",
+    "\n",
+    "# Simple variable insertion\n",
+    "print(f'Hello {name}, you are {age} years old.')\n",
+    "\n",
+    "# Number formatting: decimals\n",
+    "print(f'Your balance is {balance:.2f}€')  # 2 decimals\n",
+    "\n",
+    "# Expressions inside f-strings\n",
+    "print(f'In 5 years you will be {age + 5}.')\n",
+    "\n",
+    "# Alignment and width\n",
+    "print(f'|{name:<10}|{age:^5}|{balance:>10.2f}|')\n",
+    "# < → align left, ^ → center, > → align right\n",
+    "\n",
+    "# Multiline with f-string\n",
+    "text = f'''\n",
+    "Hello {name},\n",
+    "You are {age}.\n",
+    "Your current balance is {balance:.2f}€\n",
+    "'''\n",
+    "print(text)"
+  ]
+}
+,
   {
    "cell_type": "markdown",
    "id": "bdea496b",
@@ -537,7 +624,12 @@
     "\n",
     "### Esercizio 5: Ciclo while\n",
     "- Chiedere all’utente di indovinare un numero segreto (ad esempio 7).\n",
-    "- Continuare a chiedere finché non indovina."
+    "- Continuare a chiedere finché non indovina.\n",
+    "\n",
+    "### Esercizio 6: Formattazione con f-string\n",
+    "- Creare due variabili: `name` e `balance` (ad esempio `name = 'Luca'`, `balance = 1234.567`).\n",
+    "- Stampare una frase usando una **f-string** che includa il nome e il saldo formattato con **due decimali**.\n",
+    "- Provare ad inserire anche un’espressione matematica direttamente dentro la f-string, ad esempio sommare 100 al saldo."
    ]
   },
  {
@@ -546,9 +638,9 @@
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/02/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/02/solutions)**\n",
     "\n",
     "---"
   ]
@@ -666,10 +758,10 @@
     "### Soluzione Esercizio 5: Ciclo while\n"
    ]
   },
-  {
+    {
    "cell_type": "code",
    "execution_count": null,
-   "id": "67dd4b16",
+   "id": "67dd4b17",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -687,6 +779,31 @@
     "    guess_number()" 
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "8337790f",
+   "metadata": {},
+   "source": [
+    "### Soluzione Esercizio 6: f-string\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "67dd4b16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def format_data():\n",
+    "    name = \"Luca\"\n",
+    "    balance = 1234.567\n",
+    "    print(f'Hi {name} Your balance is {balance:.2f} €')\n",
+    "    print(f'Hi {name} Your balance is now {balance + 100:.2f} €')\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    format_data()" 
+   ]
+  },
  {
    "cell_type": "markdown",
    "id": "footer",
diff --git a/03_strutture_dati.ipynb b/03_strutture_dati.ipynb
index 3ad2a7b..d8aa939 100755
--- a/03_strutture_dati.ipynb
+++ b/03_strutture_dati.ipynb
@@ -5,7 +5,7 @@
    "id": "e5d7700c",
    "metadata": {},
    "source": [
-    "# 📦 Strutture Dati in Python\n",
+    "# Strutture Dati in Python\n",
     "\n",
     "---\n",
     "In questo capitolo esploriamo le principali **strutture dati** in Python: liste, tuple, dizionari e insiemi. Sono contenitori fondamentali per gestire e organizzare collezioni di dati in modo efficiente."
@@ -16,7 +16,7 @@
    "id": "0655afda",
    "metadata": {},
    "source": [
-    "## A cosa servono le Strutture Dati? 🤔\n",
+    "## A cosa servono le Strutture Dati?\n",
     "\n",
     "Si può pensare alle strutture dati come a diversi tipi di **contenitori** specializzati, ognuno progettato per un compito specifico. Mentre una variabile può contenere un singolo valore (come un numero o una stringa), una struttura dati può tenere insieme un'intera collezione di valori, organizzandoli in un modo particolare.\n",
     "\n",
@@ -24,7 +24,7 @@
     "\n",
     "- Immaginiamo di avere una lista della spesa. E' opportuno avere una struttura in cui l'ordine è importante e si possono aggiungere/togliere elementi. In Python, per questo tipo di stritture si usa una **lista**.\n",
     "- Immaginiamo di voler memorizzare le coordinate fisse di un punto. Quello che serve è una struttura i cui elementi non possono essere modificati. In Python, si usa una una **tupla**.\n",
-    "- Immaginiamo di voler salvare i contatti di una rubrica? Serve una struttura che associ un nome a un numero di telefono. In Python, si usa un **dizionario**.\n",
+    "- Immaginiamo di voler salvare i contatti di una rubrica. Serve una struttura che associ un nome a un numero di telefono. In Python, si usa un **dizionario**.\n",
     "\n",
     "Nelle prossime sezioni, vedremo le caratteristiche di ogni struttura dati e i loro principali utilizzi."
    ]
@@ -89,7 +89,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "### Il metodo `join()` 🧩\n",
+    "### Il metodo `join()`\n",
     "\n",
     "Il metodo **`join()`** è un potente metodo delle stringhe, ma viene utilizzato per operare su strutture dati iterabili come le liste. Serve a concatenare tutti gli elementi di una lista (o tupla) in una singola stringa, utilizzando un **separatore** specificato.\n",
     "\n",
@@ -281,7 +281,7 @@
    "source": [
     "---",
     "\n",
-    "## Come accedere agli elementi (Indicizzazione, Chiavi e Slicing) 🎯\n",
+    "## Come accedere agli elementi (Indicizzazione, Chiavi e Slicing)\n",
     "\n",
     "Per accedere a un singolo elemento in una struttura dati si usano le **parentesi quadre `[]`**.\n",
     "\n",
@@ -344,7 +344,7 @@
     "- Un **Iteratore** è un oggetto che implementa il metodo `__next__()` e che tiene traccia della posizione corrente mentre percorre l'oggetto iterable. Quando non ci sono più elementi, solleva l'eccezione `StopIteration`.\n",
     "\n",
     "### Come funziona il ciclo `for`?\n",
-    "Quando scrivi un ciclo `for`, Python usa gli iteratori dietro le quinte. Ad esempio, `for elemento in lista:` esegue questi passaggi:\n",
+    "Quando si scrive un ciclo `for`, Python usa gli iteratori dietro le quinte. Ad esempio, `for elemento in lista:` esegue questi passaggi:\n",
     "\n",
     "1.  Chiama la funzione `iter()` sulla `lista` per ottenere un **iteratore**.\n",
     "2.  Ripete la chiamata alla funzione `next()` sull'iteratore per ottenere l'elemento successivo.\n",
@@ -370,19 +370,12 @@
       "# it creates an iterator with iter(fruits) and calls next() until StopIteration"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "---"
-   ]
-  },
   {
  "cell_type": "markdown",
  "metadata": {},
  "source": [
   "---\n",
-  "## La parola chiave `yield` 🔄\n",
+  "## La parola chiave `yield`\n",
   "\n",
   "In Python, la parola chiave **`yield`** viene usata all’interno di una funzione per trasformarla in un **generatore**.  \n",
   "Un generatore è una funzione speciale che produce una sequenza di valori uno alla volta, **senza calcolare tutti i risultati in anticipo**.  \n",
@@ -461,7 +454,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "## Perché Python non ha gli array primitivi? 🤔\n",
+    "## Perché Python non ha gli array primitivi?\n",
     "\n",
     "A differenza di linguaggi come C, C++ o Java, Python non include un tipo di dato primitivo per gli array. La ragione risiede nella filosofia del linguaggio, che predilige la **flessibilità** e la **generalità** rispetto all'ottimizzazione di basso livello per casi specifici.\n",
     "\n",
@@ -477,14 +470,14 @@
 "metadata": {},
 "source": [
 "---\n",
-"## Comprehensions ed Espressioni Generatrici 🌟\n",
+"## Comprehensions ed Espressioni Generatrici\n",
 "\n",
 "Le *comprehensions* sono una delle caratteristiche più eleganti e potenti di Python. Permettono di creare nuove collezioni (liste, dizionari o insiemi) in modo **compatto**, **leggibile** e spesso più **efficiente** rispetto ai cicli tradizionali.\n",
 "\n",
 "Invece di scrivere diversi cicli `for` o usare funzioni come `map()` e `filter()`, possiamo combinare logica, iterazione e condizione in un'unica espressione chiara.\n",
 "\n",
 "---\n",
-"### 🔹 List Comprehension\n",
+"### List Comprehension\n",
 "Le *list comprehensions* sono la forma più comune. Consentono di generare una lista a partire da un iterabile.\n",
 "\n",
 "**Esempio base:**\n",
@@ -512,7 +505,7 @@
 "```\n",
 "\n",
 "---\n",
-"### 🔹 Dict Comprehension\n",
+"### Dict Comprehension\n",
 "Permettono di costruire un **dizionario** in un’unica riga.\n",
 "\n",
 "```python\n",
@@ -531,7 +524,7 @@
 "```\n",
 "\n",
 "---\n",
-"### 🔹 Set Comprehension\n",
+"### Set Comprehension\n",
 "Gli *insiemi* (set) in Python non ammettono duplicati. Con una *set comprehension* possiamo creare facilmente collezioni di elementi unici.\n",
 "\n",
 "```python\n",
@@ -544,7 +537,7 @@
 "Un vantaggio importante è che, anche se un valore appare più volte nel ciclo, l’insieme lo terrà una sola volta.\n",
 "\n",
 "---\n",
-"### 🔹 Generator Expression ⚙️\n",
+"### Generator Expression\n",
 "Le *generator expressions* sono molto simili alle list comprehensions, ma invece di creare l’intera lista in memoria, producono i valori **uno alla volta**, quando servono. Questo le rende ideali per lavorare con grandi quantità di dati o flussi infiniti.\n",
 "\n",
 "```python\n",
@@ -563,15 +556,15 @@
 "```\n",
 "\n",
 "---\n",
-"### 🧠 Quando usare cosa\n",
-"- Usa **list comprehensions** quando ti serve effettivamente una lista in memoria.\n",
-"- Usa **dict** o **set comprehensions** per creare collezioni chiave-valore o insiemi unici.\n",
-"- Usa **generator expressions** per flussi di dati o quando vuoi risparmiare memoria.\n",
+"### Quando usare cosa\n",
+"- Usare **list comprehensions** quando serve effettivamente una lista in memoria.\n",
+"- Usare **dict** o **set comprehensions** per creare collezioni chiave-valore o insiemi unici.\n",
+"- Usare **generator expressions** per flussi di dati o quando si vuole risparmiare memoria.\n",
 "\n",
 "Le comprehensions non sono solo sintatticamente più belle, ma spesso più veloci dei cicli tradizionali, grazie all’implementazione interna ottimizzata di Python.\n",
 "\n",
 "---\n",
-"📘 **Curiosità storica:** Le comprehensions derivano direttamente dal linguaggio **Haskell** e, in parte, da **Set-builder notation** della matematica. Python le ha introdotte nella versione 2.0 (anno 2000), e da allora sono diventate uno standard nella scrittura di codice Pythonic.\n"
+"**Curiosità storica:** Le comprehensions derivano direttamente dal linguaggio **Haskell** e, in parte, da **Set-builder notation** della matematica. Python le ha introdotte nella versione 2.0 (anno 2000), e da allora sono diventate uno standard nella scrittura di codice Pythonic.\n"
 ]
 },
   {
@@ -704,9 +697,9 @@
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/03/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/03/solutions)**\n",
     "\n",
     "---"
   ]
diff --git a/04_gestione_errori.ipynb b/04_gestione_errori.ipynb
index 34df491..cd24980 100755
--- a/04_gestione_errori.ipynb
+++ b/04_gestione_errori.ipynb
@@ -4,11 +4,11 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "# ⚠️ Gestione degli Errori in Python\n",
+        "# Gestione degli Errori in Python\n",
         "\n",
         "---\n",
         "\n",
-        "In questo capitolo si descrive la gestone degli errori (eccezioni) che si verificano durante l'esecuzione del programma. Una corretta gestione degli errori è essenziale per rendere il codice più robusto e affidabile."
+        "In questo capitolo viene descritto come gestire gli errori (eccezioni) che si possono verificare durante l'esecuzione dei programma. Una corretta gestione degli errori è essenziale per rendere il codice più robusto e affidabile."
       ]
     },
     {
@@ -175,9 +175,9 @@
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/04/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/04/solutions)**\n",
     "\n",
     "---"
   ]
diff --git a/05_funzioni_moduli.ipynb b/05_funzioni_moduli.ipynb
index 04ed03b..6f3c99b 100755
--- a/05_funzioni_moduli.ipynb
+++ b/05_funzioni_moduli.ipynb
@@ -4,11 +4,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# ⚙️ Funzioni e Moduli\n",
+    "# Funzioni e Moduli\n",
     "\n",
     "---",
     "\n",
-    "In questo capitolo esploriamo le **funzioni**, per organizzare il codice in blocchi riutilizzabili, e i **moduli**, per importare e usare codice scritto da altri o da noi stessi."
+    "In questo capitolo esploriamo le **funzioni**, necessarie per organizzare il codice in blocchi riutilizzabili, e i **moduli**, per importare e usare codice scritto da altri o da noi stessi."
    ]
   },
   {
@@ -38,7 +38,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Argomenti delle funzioni 💬\n",
+    "### Argomenti delle funzioni\n",
     "\n",
     "Gli **argomenti** (o parametri) sono i valori che vengono passati a una funzione per permetterle di eseguire il suo compito in modo dinamico. Vengono specificati tra parentesi nella definizione della funzione.\n",
     "\n",
@@ -70,7 +70,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Argomenti variabili: *args e **kwargs 🧩\n",
+    "### Argomenti variabili: *args e **kwargs\n",
     "\n",
     "Non sempre è possibile sapere in anticipo quanti argomenti verranno passati a una funzione. In questi casi si possono usare gli **argomenti variabili**.\n",
     "\n",
@@ -108,7 +108,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### Riepilogo 📘\n",
+    "#### Riepilogo\n",
     "\n",
     "| Tipo di argomento | Sintassi | Esempio di uso | Tipo dentro la funzione |\n",
     "|--------------------|-----------|----------------|--------------------------|\n",
@@ -122,7 +122,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Valori di ritorno: `return` ➡️\n",
+    "### Valori di ritorno: `return`\n",
     "\n",
     "Una funzione può restituire un valore al chiamante utilizzando l'istruzione **`return`**. Questo è fondamentale quando il compito della funzione è calcolare qualcosa. Se una funzione non ha un'istruzione `return`, restituirà automaticamente il valore speciale `None`."
    ]
@@ -177,7 +177,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Argomenti con valori di default ⚙️\n",
+    "### Argomenti con valori di default\n",
     "\n",
     "Si può assegnare un **valore predefinito** a un argomento direttamente nella definizione della funzione. Se l'utente non fornisce un valore per quell'argomento al momento della chiamata, verrà utilizzato il valore di default. Gli argomenti con valori predefiniti devono essere definiti **dopo** tutti gli argomenti senza un valore di default.\n",
     "\n",
@@ -204,7 +204,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Il significato di `None` come valore predefinito ❓\n",
+    "### Il significato di `None` come valore predefinito\n",
     "\n",
     "In Python, `None` è un tipo di dato speciale che rappresenta l'**assenza di un valore**. È l'equivalente del concetto di *null* in altri linguaggi di programmazione. Quando un argomento di una funzione ha un valore di default `None`, significa che l'argomento è opzionale, e se non viene passato alcun valore, la funzione può comportarsi in modo diverso. Questo è molto utile per creare funzioni flessibili.\n",
     "\n",
@@ -267,7 +267,7 @@
   "cell_type": "markdown",
   "metadata": {},
   "source": [
-    "### Visibilità e Scope delle Variabili 🔍\n",
+    "### Visibilità e Scope delle Variabili\n",
     "\n",
     "In Python, la **visibilità** (scope) indica *dove* una variabile o una funzione è accessibile nel codice. Ogni volta che Python deve risolvere un nome (una variabile o una funzione), segue la regola **LEGB**, che specifica l'ordine di ricerca:\n",
     "\n",
@@ -332,7 +332,7 @@
    "id": "4d634076",
    "metadata": {},
    "source": [
-    "### Come e dove Python cerca i moduli 🗺️\n",
+    "### Come e dove Python cerca i moduli\n",
     "\n",
     "Quando un'istruzione `import` viene eseguita, Python cerca i moduli in una lista di percorsi predefinita, accessibile tramite la lista **`sys.path`** del modulo integrato `sys`. Questo meccanismo è fondamentale per capire come vengono trovate sia le librerie standard che quelle installate di terze parti.\n",
     "\n",
@@ -365,7 +365,7 @@
    "source": [
     "---",
     "\n",
-    "## Strutturare un progetto Python: le cartelle 📁\n",
+    "## Strutturare un progetto Python: le cartelle\n",
     "\n",
     "Quando il codice cresce, un'ottima pratica è organizzarlo in cartelle e file. Una cartella che contiene uno o più file `.py` e un file speciale chiamato `__init__.py` è chiamata **pacchetto**.\n",
     "\n",
@@ -502,9 +502,9 @@
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/05/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/05/solutions)**\n",
     "\n",
     "---"
   ]
diff --git a/06_fileio.ipynb b/06_fileio.ipynb
index 59ccc40..bb17af8 100755
--- a/06_fileio.ipynb
+++ b/06_fileio.ipynb
@@ -4,7 +4,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "# 💾 Gestione dei File (File I/O) in Python\n",
+        "# Gestione dei File (File I/O) in Python\n",
         "\n",
         "Questa lezione insegnerà a leggere e scrivere dati da e verso i file, una competenza fondamentale per molti programmi Python. Vedremo come aprire, leggere, scrivere e chiudere i file in modo sicuro."
       ]
@@ -163,7 +163,7 @@
     "Quando si apre un file in Python, è buona pratica chiuderlo sempre dopo l'uso, altrimenti il programma può consumare risorse inutilmente o bloccare l’accesso ad altri processi. Scrivere `f.close()` a mano, però, è soggetto a errori. Il costrutto `with` risolve questo problema automaticamente.\n",
     "\n",
     "---\n",
-    "### 🧠 Come funziona\n",
+    "### Come funziona\n",
     "\n",
     "La sintassi è la seguente:\n",
     "\n",
@@ -177,7 +177,7 @@
     "Il file viene **aperto all’inizio del blocco** e **chiuso automaticamente** al termine, anche in caso di errore o eccezione.\n",
     "\n",
     "---\n",
-    "### ✍️ Esempio di scrittura in un file\n",
+    "### Esempio di scrittura in un file\n",
     "\n",
     "```python\n",
     "with open('data.txt', 'w') as f:\n",
@@ -192,7 +192,7 @@
     "- Se esiste, il suo contenuto viene cancellato prima di scrivere.\n",
     "\n",
     "---\n",
-    "### 📖 Esempio di lettura da un file\n",
+    "### Esempio di lettura da un file\n",
     "\n",
     "```python\n",
     "with open('data.txt', 'r') as f:\n",
@@ -205,7 +205,7 @@
     "- Se il file non esiste, Python solleva un `FileNotFoundError`.\n",
     "\n",
     "---\n",
-    "### ➕ Aggiungere contenuto a un file (append)\n",
+    "### Aggiungere contenuto a un file (append)\n",
     "\n",
     "```python\n",
     "with open('data.txt', 'a') as f:\n",
@@ -215,7 +215,7 @@
     "- `'a'` significa *append mode*: il contenuto viene aggiunto in fondo al file, senza cancellare quello esistente.\n",
     "\n",
     "---\n",
-    "### 🧩 Lettura riga per riga\n",
+    "### Lettura riga per riga\n",
     "Invece di leggere tutto il file in un’unica stringa, si può scorrere il file riga per riga:\n",
     "\n",
     "```python\n",
@@ -227,7 +227,7 @@
     "Questo approccio è più efficiente per file di grandi dimensioni, poiché non carica tutto in memoria.\n",
     "\n",
     "---\n",
-    "### ⚙️ Modalità di apertura più comuni\n",
+    "### Modalità di apertura più comuni\n",
     "\n",
     "| Modalità | Significato | Descrizione breve |\n",
     "|-----------|--------------|------------------|\n",
@@ -261,7 +261,7 @@
  "metadata": {},
  "source": [
   "---\n",
-  "## Streaming e file di grandi dimensioni 💾\n",
+  "## Streaming e file di grandi dimensioni\n",
   "\n",
   "Quando si lavora con file di grandi dimensioni, leggere tutto il contenuto in memoria può causare problemi. Si possono usare due approcci per ovviare al problema, leggere il file **riga per riga** o in **blocchi** usando un ciclo o generatori.\n",
   "\n",
@@ -309,22 +309,15 @@
         "Leggere il file `names.txt` creato nell'esercizio precedente e stampare il numero totale di righe (nomi)."
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "---"
-      ]
-    },
    {
   "cell_type": "markdown",
   "id": "72c70c56",
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/06/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/06/solutions)**\n",
     "\n",
     "---"
   ]
diff --git a/07_libreria_standard.ipynb b/07_libreria_standard.ipynb
index 472128e..4d4290a 100755
--- a/07_libreria_standard.ipynb
+++ b/07_libreria_standard.ipynb
@@ -5,7 +5,7 @@
    "id": "401a54c8",
    "metadata": {},
    "source": [
-    "# 📚 Panoramica della Libreria Standard di Python\n",
+    "# Panoramica della Libreria Standard di Python\n",
     "\n",
     "La **Libreria Standard di Python** è una vasta collezione di moduli e pacchetti che vengono installati insieme a Python. Offre una ricca gamma di funzionalità, dall'interazione con il sistema operativo alla gestione dei dati, senza la necessità di installare nulla di aggiuntivo.\n",
     "\n",
@@ -171,7 +171,7 @@
    "id": "8f8955f2",
    "metadata": {},
    "source": [
-    "## Metodi delle Stringhe: Manipolazione e Formattazione ✍️\n",
+    "## Metodi delle Stringhe: Manipolazione e Formattazione\n",
     "\n",
     "Le stringhe in Python non sono solo sequenze di caratteri, ma veri e propri oggetti con una vasta gamma di metodi integrati per manipolarle e formattarle in modo efficiente. A differenza di molti moduli della libreria standard, questi metodi non richiedono un `import` e possono essere chiamati direttamente sulla stringa stessa.\n",
     "\n",
@@ -267,23 +267,15 @@
     "Stampare il risultato finale."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "85024755",
-   "metadata": {},
-   "source": [
-    "---"
-   ]
-  },
   {
   "cell_type": "markdown",
   "id": "72c70c517",
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/07/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/07/solutions)**\n",
     "\n",
     "---"
   ]
diff --git a/08_librerie.ipynb b/08_librerie.ipynb
index 42852e1..90b47e0 100755
--- a/08_librerie.ipynb
+++ b/08_librerie.ipynb
@@ -5,8 +5,8 @@
    "id": "401a54c9",
    "metadata": {},
    "source": [
-    "# 🌐 Gestione di Pacchetti e Ambienti Virtuali\n",
-    "Oltre alla Libreria Standard di Python, la community ha creato migliaia di pacchetti esterni che offrono funzionalità aggiuntive. Per gestirli in modo efficiente e professionale, vengono usati due strumenti fondamentali: pip e gli ambienti virtuali."
+    "# Gestione di Pacchetti e Ambienti Virtuali\n",
+    "Fino ad abbiamo utlizzato pacchetti già installati insieme a Python appartenenti alla libreria standard. Oltre alla libreria standard di Python, la community ha creato migliaia di pacchetti esterni che offrono funzionalità aggiuntive. Per gestirli in modo efficiente e professionale, vengono usati due strumenti fondamentali: pip e gli ambienti virtuali."
    ]
   },
   {
@@ -222,10 +222,10 @@
   "\n",
   "La libreria **Requests** è lo standard de facto in Python per inviare richieste HTTP. Nasce per rendere più leggibile e user-friendly l’interazione con servizi web e API RESTful, evitando la complessità delle librerie standard come `urllib`.  \n",
   "\n",
-  "#### 📌 Dove trovare la documentazione\n",
+  "#### Dove trovare la documentazione\n",
   "La documentazione ufficiale è disponibile su: [https://requests.readthedocs.io/](https://requests.readthedocs.io/).  \n",
   "\n",
-  "#### 🔑 Metodi principali\n",
+  "#### Metodi principali\n",
   "I metodi di `requests` corrispondono ai principali **verbi HTTP**:\n",
   "- **`requests.get(url, params=None, **kwargs)`** → Recupera risorse da un server (es. scaricare dati).  \n",
   "- **`requests.post(url, data=None, json=None, **kwargs)`** → Invia dati ad un server, tipicamente per creare nuove risorse.  \n",
@@ -233,14 +233,14 @@
   "- **`requests.patch(url, data=None, **kwargs)`** → Aggiorna parzialmente una risorsa.  \n",
   "- **`requests.delete(url, **kwargs)`** → Elimina una risorsa sul server.  \n",
   "\n",
-  "#### ⚙️ Oggetto `Response`\n",
+  "#### Oggetto `Response`\n",
   "Una chiamata HTTP restituisce un oggetto `Response`, che espone proprietà utili:\n",
   "- `.status_code` → codice di stato HTTP (200, 404, 500, …).  \n",
   "- `.headers` → intestazioni della risposta.  \n",
   "- `.text` → contenuto della risposta come stringa.  \n",
   "- `.json()` → converte automaticamente il contenuto in JSON (se la risposta è in formato valido).  \n",
   "\n",
-  "#### 🧩 Funzionalità aggiuntive\n",
+  "#### Funzionalità aggiuntive\n",
   "- **Autenticazione**: `requests.get(url, auth=('user', 'pass'))`.  \n",
   "- **Headers personalizzati**: `requests.get(url, headers={'User-Agent': 'my-app'})`.  \n",
   "- **Timeout**: `requests.get(url, timeout=5)` per evitare attese infinite.  \n",
@@ -274,17 +274,17 @@
   "\n",
   "**NumPy** (Numerical Python) è la libreria fondamentale per il calcolo scientifico in Python. È progettata per lavorare in modo estremamente efficiente con grandi quantità di dati numerici e offre un’ampia gamma di funzioni matematiche e strumenti di manipolazione di array multidimensionali.  \n",
   "\n",
-  "#### 📌 Dove trovare la documentazione\n",
+  "#### Dove trovare la documentazione\n",
   "La documentazione ufficiale è disponibile su: [https://numpy.org/doc/stable/](https://numpy.org/doc/stable/).  \n",
   "\n",
-  "#### 🔑 Concetti e oggetti principali\n",
+  "#### Concetti e oggetti principali\n",
   "- **`ndarray`** → struttura dati principale, un array N-dimensionale ottimizzato per velocità e memoria.  \n",
   "- **Funzioni di creazione**: `np.array()`, `np.zeros()`, `np.ones()`, `np.arange()`, `np.linspace()`.  \n",
   "- **Operazioni vettoriali**: somma, sottrazione, moltiplicazione e divisione eseguite in modo element-wise, molto più rapide delle liste Python.  \n",
   "- **Funzioni statistiche**: `np.mean()`, `np.median()`, `np.std()`, `np.min()`, `np.max()`.  \n",
   "- **Algebra lineare**: `np.dot()`, `np.linalg.inv()`, `np.linalg.eig()`.  \n",
   "\n",
-  "#### ⚙️ Vantaggi principali\n",
+  "#### Vantaggi principali\n",
   "- **Prestazioni elevate**: sfrutta implementazioni ottimizzate in C per operazioni numeriche.  \n",
   "- **Compatibilità**: è alla base di molte librerie scientifiche e di machine learning come Pandas, SciPy, Scikit-learn, TensorFlow.  \n",
   "- **Operazioni su array**: consente di manipolare dati multidimensionali con slicing, reshaping e broadcasting.  \n"
@@ -312,14 +312,14 @@
   "\n",
   "**Pandas** è la libreria di riferimento per la manipolazione e l’analisi dei dati in Python. Introduce due nuove strutture dati fondamentali: **Series** (simili a vettori) e **DataFrame** (simili a tabelle), rendendo semplice lavorare con dati strutturati come file CSV, Excel, database SQL o JSON.  \n",
   "\n",
-  "#### 📌 Dove trovare la documentazione\n",
+  "#### Dove trovare la documentazione\n",
   "La documentazione ufficiale è disponibile su: [https://pandas.pydata.org/docs/](https://pandas.pydata.org/docs/).  \n",
   "\n",
-  "#### 🔑 Oggetti principali\n",
+  "#### Oggetti principali\n",
   "- **`Series`** → array monodimensionale etichettato, utile per rappresentare una colonna o un vettore di dati.  \n",
   "- **`DataFrame`** → struttura tabellare bidimensionale con righe e colonne etichettate, analoga a un foglio Excel o a una tabella SQL.  \n",
   "\n",
-  "#### ⚙️ Operazioni comuni sui DataFrame\n",
+  "#### Operazioni comuni sui DataFrame\n",
   "- **Creazione**: `pd.DataFrame()` a partire da dizionari, liste, array o file esterni.  \n",
   "- **Import/Export**: `pd.read_csv()`, `pd.read_excel()`, `df.to_csv()`, `df.to_excel()`.  \n",
   "- **Selezione e filtraggio**: `df['col']`, `df[['col1','col2']]`, `df.loc[]`, `df.iloc[]`.  \n",
@@ -327,7 +327,7 @@
   "- **Gestione dei dati mancanti**: `df.dropna()`, `df.fillna()`.  \n",
   "- **Unione e concatenazione**: `pd.concat()`, `pd.merge()`, `df.join()`.  \n",
   "\n",
-  "#### 🧩 Vantaggi principali\n",
+  "#### Vantaggi principali\n",
   "- Semplifica la pulizia, l’analisi e la trasformazione dei dati.  \n",
   "- Ampio supporto per diversi formati di input/output.  \n",
   "- Si integra perfettamente con NumPy e librerie di machine learning.  \n"
@@ -358,17 +358,17 @@
   "\n",
   "**Matplotlib** è la libreria più diffusa per la creazione di grafici in Python. Il modulo `pyplot` fornisce un'interfaccia semplice e simile a MATLAB, permettendo di costruire grafici 2D in modo rapido e personalizzabile.  \n",
   "\n",
-  "#### 📌 Dove trovare la documentazione\n",
+  "#### Dove trovare la documentazione\n",
   "La documentazione ufficiale è disponibile su: [https://matplotlib.org/stable/api/pyplot_summary.html](https://matplotlib.org/stable/api/pyplot_summary.html).  \n",
   "\n",
-  "#### 🔑 Funzioni principali\n",
+  "#### Funzioni principali\n",
   "- **Grafici di base**: `plt.plot()`, `plt.bar()`, `plt.scatter()`, `plt.hist()`, `plt.boxplot()`.  \n",
   "- **Personalizzazione grafici**: `plt.title()`, `plt.xlabel()`, `plt.ylabel()`, `plt.legend()`, `plt.grid()`, `plt.xticks()`, `plt.yticks()`.  \n",
   "- **Gestione figure**: `plt.figure(figsize=(w,h))`, `plt.subplot()`, `plt.tight_layout()`.  \n",
   "- **Salvataggio e output**: `plt.show()`, `plt.savefig()`.  \n",
   "- **Colori e stili**: modificabili con parametri come `color`, `linestyle`, `marker`.  \n",
   "\n",
-  "#### 🧩 Vantaggi principali\n",
+  "#### Vantaggi principali\n",
   "- Estrema flessibilità e controllo su quasi ogni elemento del grafico.  \n",
   "- Possibilità di creare figure statiche, animate o interattive.  \n",
   "- Si integra bene con NumPy e Pandas per visualizzare dati numerici o DataFrame.  \n"
@@ -405,16 +405,16 @@
   "\n",
   "Il modulo **`re`** fa parte della libreria standard di Python e permette di lavorare con **espressioni regolari**, ovvero schemi testuali che consentono di cercare, estrarre e manipolare stringhe in modo molto potente. È utile per compiti come validazione di input, parsing di testi, sostituzioni complesse e analisi di log o dati testuali.  \n",
   "\n",
-  "#### 📌 Dove trovare la documentazione\n",
+  "#### Dove trovare la documentazione\n",
   "La documentazione ufficiale è disponibile su: [https://docs.python.org/3/library/re.html](https://docs.python.org/3/library/re.html).  \n",
   "\n",
-  "#### 🔑 Funzioni principali\n",
+  "#### Funzioni principali\n",
   "- **Ricerca e matching**: `re.match()`, `re.search()`, `re.findall()`, `re.finditer()`.  \n",
   "- **Sostituzione e split**: `re.sub()`, `re.subn()`, `re.split()`.  \n",
   "- **Compilazione di pattern**: `re.compile(pattern, flags=0)` per riutilizzare pattern precompilati.  \n",
   "- **Oggetto Match**: `.group()`, `.groups()`, `.start()`, `.end()`, `.span()`.  \n",
   "\n",
-  "#### 🧩 Vantaggi principali\n",
+  "#### Vantaggi principali\n",
   "- Permette di individuare pattern complessi in stringhe in modo compatto ed efficiente.  \n",
   "- Supporta flag per modificare il comportamento dei match, come case-insensitive (`re.I`) o multi-line (`re.M`).  \n",
   "- Essenziale per analisi di testi, parsing di dati strutturati in file o log, e validazioni di formati come email, numeri di telefono o codici.  \n"
@@ -506,9 +506,9 @@
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/08/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/08/solutions)**\n",
     "\n",
     "---"
   ]
diff --git a/09_oop.ipynb b/09_oop.ipynb
index c6e73df..37d99a5 100755
--- a/09_oop.ipynb
+++ b/09_oop.ipynb
@@ -5,7 +5,7 @@
    "id": "b5207154",
    "metadata": {},
    "source": [
-    "# 👨‍💻 Programmazione Orientata agli Oggetti (OOP) - Concetti Base\n",
+    "# Programmazione Orientata agli Oggetti (OOP) - Concetti Base\n",
     "\n",
     "La **Programmazione Orientata agli Oggetti (OOP)** è un paradigma di programmazione che organizza il codice intorno a dati e oggetti, piuttosto che a funzioni e logica. L'idea è quella di creare 'oggetti' che rappresentano entità del mondo reale e che combinano dati (attributi) con le funzionalità che li manipolano (metodi)."
    ]
@@ -161,7 +161,7 @@
    "id": "719c17f4",
    "metadata": {},
    "source": [
-    "## Incapsulamento: Dati Protetti 🔒\n",
+    "## Incapsulamento: Dati Protetti\n",
     "\n",
     "L'**incapsulamento** è un principio fondamentale dell'OOP che consiste nel nascondere i dettagli interni di un oggetto e proteggerne i dati dall'accesso diretto ed esterno. In Python, usiamo delle convenzioni per indicare che un attributo non dovrebbe essere modificato direttamente:\n",
     "- Un singolo underscore (`_`) suggerisce che l'attributo è **protetto** (`_attributo_protetto`).\n",
@@ -212,7 +212,7 @@
    "id": "b73c734e",
    "metadata": {},
    "source": [
-    "## L'operatore `isinstance()`: Controllo del Tipo 🤔\n",
+    "## L'operatore `isinstance()`: Controllo del Tipo\n",
     "\n",
     "L'operatore integrato `isinstance()` è una funzione molto utile per verificare se un oggetto è un'**istanza** di una determinata classe o di una delle sue sottoclassi.\n",
     "\n",
@@ -270,7 +270,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## L'operatore `is` vs `==`: Identità e Uguaglianza 🔍\n",
+    "## L'operatore `is` vs `==`: Identità e Uguaglianza\n",
     "\n",
     "In Python esistono due modi diversi di confrontare gli oggetti:\n",
     "\n",
@@ -305,7 +305,7 @@
    "id": "c5de76d0",
    "metadata": {},
    "source": [
-    "## Polimorfismo: Tante Forme, Stesso Comportamento 🎭\n",
+    "## Polimorfismo: Tante Forme, Stesso Comportamento\n",
     "\n",
     "Il **polimorfismo** permette a oggetti di classi diverse di rispondere in modo specifico allo stesso metodo. Questo rende il codice più flessibile e facile da estendere."
    ]
@@ -353,7 +353,7 @@
    "id": "f92678a7",
    "metadata": {},
    "source": [
-    "## Classi Astratte 📝\n",
+    "## Classi Astratte\n",
     "\n",
     "Una **classe astratta** serve come modello e non può essere istanziata direttamente. Contiene uno o più **metodi astratti** (metodi senza implementazione), che devono essere obbligatoriamente implementati da qualsiasi sottoclasse che eredita da essa. Questo garantisce una struttura comune per tutte le classi derivate.\n",
     "\n",
@@ -426,7 +426,7 @@
         "    print(e)\n",
         "```\n",
         "\n",
-        "➡️ Questo approccio permette di creare messaggi di errore più chiari e di gestire condizioni speciali nel codice."
+        "Questo approccio permette di creare messaggi di errore più chiari e di gestire condizioni speciali nel codice."
       ]
     },
   {
@@ -462,9 +462,9 @@
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/09/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/09/solutions)**\n",
     "\n",
     "---"
   ]
diff --git a/10_testunit.ipynb b/10_testunit.ipynb
index 20feae2..0498927 100755
--- a/10_testunit.ipynb
+++ b/10_testunit.ipynb
@@ -5,7 +5,7 @@
    "id": "c612dfe5",
    "metadata": {},
    "source": [
-    "# 🧪 Test Unitari con `unittest` \n",
+    "# Test Unitari con `unittest` \n",
     "\n",
     "Il **testing del software** è un processo cruciale che verifica che un programma funzioni come previsto. Non si tratta solo di trovare bug, ma di garantire la qualità, l'affidabilità e la manutenibilità del codice nel tempo. Tra le varie strategie di testing, il **testing unitario** è la più granulare e riesce ad essere eseguita dagli stessi sviluppatori."
    ]
@@ -174,9 +174,9 @@
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/10/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/10/solutions)**\n",
     "\n",
     "---"
   ]
diff --git a/11_decorator_closure.ipynb b/11_decorator_closure.ipynb
index 44730b7..26e42b7 100755
--- a/11_decorator_closure.ipynb
+++ b/11_decorator_closure.ipynb
@@ -5,7 +5,7 @@
    "id": "c612dfe6",
    "metadata": {},
    "source": [
-    "# ⚙️ Decorator e Funzioni Avanzate in Python \n",
+    "# Decorator e Funzioni Avanzate in Python \n",
     "\n",
         "In questo capitolo approfondiremo alcuni concetti avanzati sulle **funzioni in Python**:\n",
     "\n",
@@ -20,7 +20,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 🧩 Funzioni come oggetti di prima classe\n",
+    "## Funzioni come oggetti di prima classe\n",
     "\n",
     "In Python, le funzioni sono considerate **oggetti di prima classe**. Questo significa che si possono trattare esattamente come qualsiasi altra variabile (come un numero o una lista):\n",
     "\n",
@@ -59,7 +59,7 @@
    "source": [
     "--- \n",
     "\n",
-    "## 🧱 Funzioni annidate (Nested Functions)\n",
+    "## Funzioni annidate (Nested Functions)\n",
     "\n",
     "Una funzione può essere **definita all'interno** di un'altra funzione. Questo è utile per incapsulare logica o creare funzioni di supporto locali, in quanto la funzione interna è visibile **solo** all'interno della funzione esterna.\n",
     "\n",
@@ -89,7 +89,7 @@
    "source": [
     "--- \n",
     "\n",
-    "## 🌀 Closure\n",
+    "## Closure\n",
     "\n",
     "Una **closure** è una funzione annidata che **ricorda i valori delle variabili** dell’ambiente (scope) in cui è stata creata, **anche dopo che quell’ambiente (la funzione esterna) è stato distrutto** (ha terminato l'esecuzione).\n",
     "\n",
@@ -126,7 +126,7 @@
    "source": [
     "--- \n",
     "\n",
-    "## 🎨 Decorator personalizzati\n",
+    "## Decorator personalizzati\n",
     "\n",
     "Un **decorator** è una funzione che prende un'altra funzione e ne estende il comportamento **senza modificarne il codice originale**. Sfrutta in maniera intensiva i concetti di *funzioni di prima classe* e *closure*.\n",
     "\n",
@@ -168,7 +168,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## ⚙️ Decorator con argomenti\n",
+    "## Decorator con argomenti\n",
     "\n",
     "Un decorator può anche accettare **parametri**, grazie a un ulteriore livello di funzioni annidate."
    ]
@@ -194,21 +194,36 @@
     "greet()"
    ]
   },
-  {
+{
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## 🧰 Decorator integrati in Python\n",
+    "## Decorator integrati in Python\n",
     "\n",
     "Python fornisce alcuni decorator integrati:\n",
     "- `@staticmethod`\n",
     "- `@classmethod`\n",
     "- `@property`\n",
     "\n",
-    "Qui vengono mostrati alcuni esempi:"
+    "#### `@staticmethod`\n",
+    "- Trasforma un metodo in una funzione \"normale\" contenuta nella classe.\n",
+    "- Non riceve automaticamente `self` (istanza) o `cls` (classe).\n",
+    "- Utile per funzioni di utilità legate logicamente alla classe ma che non usano i dati della classe.\n",
+    "\n",
+    "#### `@classmethod`\n",
+    "- Definisce un metodo che riceve la **classe** come primo argomento, chiamato `cls`.\n",
+    "- Utile per creare metodi costruttori alternativi o lavorare su dati di classe.\n",
+    "- Funziona correttamente anche con le classi derivate.\n",
+    "\n",
+    "#### `@property`\n",
+    "- Permette di definire attributi controllati: si accede a un metodo come se fosse una variabile.\n",
+    "- Migliora l'incapsulamento senza cambiare l'interfaccia dell'oggetto.\n",
+    "- Può avere un getter, un setter (`@<nome>.setter`) e un deleter (`@<nome>.deleter`).\n",
+    "\n",
+    "### Esempio:"
    ]
-  },
-  {
+},
+{
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
@@ -237,12 +252,64 @@
     "        return cls(1)\n",
     "\n",
     "c = Circle(5)\n",
-    "print(c.radius)\n",
+    "print('Initial radius:', c.radius)\n",
+    "\n",
+    "# setter usage\n",
+    "c.radius = 10\n",
+    "print('Updated radius:', c.radius)\n",
+    "\n",
+    "# isntance method usage\n",
     "Circle.info()\n",
+    "\n",
+    "# classmethod usage\n",
     "unit = Circle.unit_circle()\n",
-    "print(unit.radius)"
+    "print('Unit circle radius:', unit.radius)\n"
    ]
-  },
+},
+{
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## `@dataclass`: decorator per creare classi \"automatiche\"\n",
+    "\n",
+    "Il decorator `@dataclass`, introdotto in Python 3.7, permette di generare automaticamente diversi metodi di una classe, come:\n",
+    "- `__init__`\n",
+    "- `__repr__`\n",
+    "- `__eq__`\n",
+    "- (opzionale) metodi di confronto: `<`, `<=`, `>`\n",
+    "\n",
+    "È utile per rappresentare strutture dati senza dover scrivere molto codice boilerplate.\n",
+    "\n",
+    "Basta applicare `@dataclass` sopra la classe e definire gli attributi come variabili di classe.\n",
+    "\n",
+    "Si può configurare con parametri come:\n",
+    "- `frozen=True` → crea oggetti immutabili\n",
+    "- `order=True` → abilita i confronti (`<`, `>=`, ...)\n",
+    "- `default` / `default_factory` → valori di default\n",
+    "\n",
+    "### Esempio:"
+   ]
+},
+{
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "\n",
+    "@dataclass\n",
+    "class Point:\n",
+    "    x: float\n",
+    "    y: float\n",
+    "\n",
+    "p1 = Point(3, 4)\n",
+    "p2 = Point(3, 4)\n",
+    "\n",
+    "print('Point:', p1)         #  __repr__\n",
+    "print('Are equal?', p1 == p2)  # __eq__\n"
+   ]
+},
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -266,9 +333,9 @@
   "metadata": {},
   "source": [
     "---\n",
-    "## 💡 Soluzioni\n",
+    "## Soluzioni\n",
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice delle soluzioni](code/11/solutions)**\n",
+    "> **[Clicca qui per vedere il codice delle soluzioni](code/11/solutions)**\n",
     "\n",
     "---"
   ]
diff --git a/12_progetto.ipynb b/12_progetto.ipynb
index 3befc1c..c81df7f 100755
--- a/12_progetto.ipynb
+++ b/12_progetto.ipynb
@@ -5,7 +5,7 @@
    "id": "c32b393f",
    "metadata": {},
    "source": [
-    "# 🚀 Progetto finale: Gestione di un inventario avanzato\n",
+    "# Progetto finale: Gestione di un inventario avanzato\n",
     "\n",
     "---\n",
     "## Introduzione al progetto\n",
@@ -30,7 +30,7 @@
   "metadata": {},
   "source": [
     "\n",
-    "> 📂 **[Clicca qui per vedere il codice del progetto](code/12/solutions)**\n"
+    "> **[Clicca qui per vedere il codice del progetto](code/12/solutions)**\n"
   ]
 },
   {
@@ -39,7 +39,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "## Preparazione del Progetto con Ambienti Virtuali 💻\n",
+    "## Preparazione del Progetto con Ambienti Virtuali\n",
     "\n",
     "Prima di scrivere il codice, occorre creare un ambiente isolato per il nostro progetto. Questo ci assicura che le dipendenze non entrino in conflitto con altri progetti sul tuo sistema.\n",
     "\n",
@@ -62,7 +62,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "## Struttura del Progetto e Gestione delle Dipendenze 📁\n",
+    "## Struttura del Progetto e Gestione delle Dipendenze\n",
     "\n",
     "Per un'organizzazione chiara e professionale, il progetto è suddiviso in più file. Questo rende il codice più facile da leggere, testare e mantenere.\n",
     "\n",
@@ -100,7 +100,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "## Implementazione del Codice 💻\n",
+    "## Implementazione del Codice\n",
     "\n",
     "Di seguito il codice suddiviso nei rispettivi file. **Eseguire ogni cella in ordine per creare i file del progetto prima di eseguire `main.py` o i test.**"
    ]
@@ -425,7 +425,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "## Esecuzione del Progetto e Simulazione 🚀\n",
+    "## Esecuzione del Progetto e Simulazione\n",
     "\n",
     "Dopo aver eseguito le celle precedenti (il che creerà i file `.py`), si può avviare il programma principale e interagire con esso. Eseguire la cella seguente per avviare il menu del programma."
    ]
@@ -446,7 +446,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "## Test Unitari con `unittest` 🧪\n",
+    "## Test Unitari con `unittest`\n",
     "\n",
     "Ora che il progetto è stato implementato, è fondamentale testarne le funzionalità in modo automatico. Aggiungeremo una cartella `tests` alla struttura del progetto, dove scriveremo i nostri test unitari per la classe `GestoreInventario`.\n",
     "\n",
diff --git a/README.md b/README.md
index e66630d..8b464f0 100755
--- a/README.md
+++ b/README.md
@@ -1,23 +1,23 @@
-# 🐍 Corso Python Basic
+# Corso Python Basic
 
 [![Python Version](https://img.shields.io/badge/python-3.11-blue.svg)](https://www.python.org/downloads/release/python-3110/)
 [![GitHub Release](https://img.shields.io/github/v/release/h-anamai/corso-python-basic?color=green)](https://github.com/h-anamai/corso-python-basic/releases)
 
 
-Benvenuto al corso base di Python! Questo repository contiene una serie di notebook progettati per guidarti nei primi passi con il linguaggio Python, con esempi pratici ed esercitazioni.
+Benvenuti al corso base di Python! Questo repository contiene una serie di notebook progettati per iniziare ad usare con efficacia il linguaggio Python, con esempi pratici ed esercitazioni.
 
-Per domande e contenuti extra, unisciti ai nostri canali:
+Per domande e contenuti extra, sono a disposizione i seguenti nostri canali:
 
 [![Telegram](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/+gTwagH1r9kVjMjY0)
 [![Discord](https://img.shields.io/badge/Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/gkjMTFSVc)
 
-Visita il sito ufficiale del corso dove potrai anche ottenere il badge di completamento del corso!
+Inoltre è possibile visitare il sito ufficiale del corso dove si potrà ottenere il badge di completamento del corso!
 
 [![GitHub Pages](https://img.shields.io/badge/GitHub%20Pages-online-brightgreen?style=for-the-badge&logo=github)](https://h-anamai.github.io/corso-python-basic/)
 
 
 
-## 📚 Sommario
+## Sommario
 
 | Modulo                                                   | Descrizione                                          |
 |----------------------------------------------------------|------------------------------------------------------|
@@ -36,7 +36,7 @@ Visita il sito ufficiale del corso dove potrai anche ottenere il badge di comple
 | [12_progetto.ipynb](12_progetto.ipynb)                   | Realizzazione di una semplice applicazione           |
 | [appendix.ipynb](appendix.ipynb)                         | La storia di Python                                  |
 
-## 🎯 Obiettivi del corso
+## Obiettivi del corso
 
 - Imparare la sintassi base di Python
 - Eseguire codice in un ambiente interattivo (Jupyter)
@@ -47,21 +47,27 @@ Visita il sito ufficiale del corso dove potrai anche ottenere il badge di comple
 
 ---
 
-## ▶️ Come usare i notebook
+## Codice e soluzioni agli esercizi
 
-Puoi aprire e utilizzare i notebook in diversi modi, a seconda delle tue preferenze e del tuo ambiente di lavoro. Se vuoi lavorare in locale occorre prima installare `pip`.
+Tutte le soluzioni agli esercizi proposti nei vari capitoli sono disponibili nella cartella [_**code**_ ](code/) del repository e suddivisi per i vari capitoli.
+
+---
+
+## Come usare i notebook
+
+Si possono aprire e utilizzare i notebook in diversi modi, a seconda delle preferenze e dell'ambiente di lavoro utilizzato. Per lavorare in locale occorre prima installare `pip`.
 
-### ⚙️ Installare `pip`
+### Installare `pip`
 
 `pip` è il gestore di pacchetti di Python e serve per installare librerie aggiuntive (come `notebook` o `jupyterlab`).  
-In molte distribuzioni recenti di Python è già incluso, ma in caso contrario puoi installarlo così, aprendo un terminale:
+In molte distribuzioni recenti di Python è già incluso, ma in caso contrario si pul installare aprendo un terminale:
 
 ```bash
 pip --version
 ```
 
 Se il comando restituisce un numero di versione, significa che `pip` è già installato.  
-In alternativa, puoi provare con:
+In alternativa, provare con:
 
 ```bash
 python -m pip --version
@@ -69,15 +75,15 @@ python -m pip --version
 
 ---
 
-#### 🔹 Installazione su Linux / macOS
+#### Installazione su Linux / macOS
 
-Se `pip` non è presente, puoi installarlo usando il comando:
+Se `pip` non è presente, si può installare usando il comando:
 
 ```bash
 python3 -m ensurepip --upgrade
 ```
 
-oppure installa tramite **apt** (Ubuntu/Debian):
+oppure installarlo tramite **apt** (Ubuntu/Debian):
 
 ```bash
 sudo apt update
@@ -94,12 +100,12 @@ brew install python3
 
 ---
 
-#### 🔹 Installazione su Windows
+#### Installazione su Windows
 
-1. Scarica l’installer ufficiale di Python da [python.org](https://www.python.org/downloads/).
-2. Durante l’installazione, assicurati di selezionare l’opzione **“Add Python to PATH”**.
+1. Scaricare l’installer ufficiale di Python da [python.org](https://www.python.org/downloads/).
+2. Durante l’installazione, assicurasi di selezionare l’opzione **“Add Python to PATH”**.
 3. `pip` verrà installato automaticamente.
-4. Se serve, puoi aggiornarlo con:
+4. Se serve, aggiornarlo con:
 
 ```bash
 python -m pip install --upgrade pip
@@ -107,35 +113,35 @@ python -m pip install --upgrade pip
 
 ---
 
-#### 🔹 Anaconda / Miniconda
+#### Anaconda / Miniconda
 
-Se utilizzi **Anaconda** o **Miniconda**, `pip` è già incluso.  
-Puoi verificarlo con:
+Se si utilizza **Anaconda** o **Miniconda**, `pip` è già incluso.  
+Verificarlo con:
 
 ```bash
 conda list pip
 ```
 
-In alternativa, puoi installarlo/aggiornarlo con:
+In alternativa, installarlo/aggiornarlo con:
 
 ```bash
 conda install pip
 ```
 
-### ✅ Con Jupyter Notebook (installazione locale)
+### Con Jupyter Notebook (installazione locale)
 
-Se vuoi lavorare in locale, installa Jupyter e avvia il server:
+Se si vuole lavorare in locale, installare Jupyter e avviare il server:
 
 ```bash
 pip install notebook
 jupyter notebook
 ```
 
-Dopo aver eseguito il comando, si aprirà una finestra nel browser da cui potrai navigare tra le cartelle e aprire i file `.ipynb`.
+Dopo aver eseguito il comando, si aprirà una finestra nel browser da cui si potrà navigare tra le cartelle ed aprire i file `.ipynb`.
 
 ---
 
-### ✅ Con JupyterLab (interfaccia avanzata)
+### Con JupyterLab (interfaccia avanzata)
 
 JupyterLab offre un’interfaccia più moderna e completa rispetto a Jupyter Notebook:
 
@@ -146,29 +152,29 @@ jupyter lab
 
 ---
 
-### ✅ Con VS Code
+### Con VS Code
 
-1. Installa [Visual Studio Code](https://code.visualstudio.com/).
-2. Aggiungi l’estensione **Python** e l’estensione **Jupyter**.
-3. Apri il progetto e clicca direttamente sui file `.ipynb` per eseguirli all’interno di VS Code.
+1. Installare [Visual Studio Code](https://code.visualstudio.com/).
+2. Aggiunger l’estensione **Python** e l’estensione **Jupyter**.
+3. Aprire il progetto e cliccare direttamente sui file `.ipynb` per eseguirli all’interno di VS Code.
 
 ---
 
-### ✅ Con Google Colab (nessuna installazione richiesta)
+### Con Google Colab (nessuna installazione richiesta)
 
-Se non vuoi installare nulla, puoi aprire i notebook direttamente su [Google Colab](https://colab.research.google.com/):
+Se si vuole installare nulla, si possono aprire i notebook direttamente su [Google Colab](https://colab.research.google.com/):
 
 [![Apri in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/h-anamai/corso-python-basic)
 
-1. Vai su Colab e seleziona **File → Carica notebook**.
-2. Oppure usa il badge qui sopra.
-3. Avrai a disposizione un ambiente gratuito in cloud, già pronto per l’uso.
+1. Andare su Colab e selezionare **File → Carica notebook**.
+2. Oppure usare il badge qui sopra.
+3. Si avrò a disposizione un ambiente gratuito in cloud, già pronto per l’uso.
 
 ---
 
-### ✅ Con Binder (esecuzione online dal repository)
+### Con Binder (esecuzione online dal repository)
 
-Puoi anche eseguire i notebook online senza installazioni tramite [Binder](https://mybinder.org/):
+Si possono anche eseguire i notebook online senza installazioni tramite [Binder](https://mybinder.org/):
 
 [![Esegui su Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/h-anamai/corso-python-basic/HEAD)
 
@@ -176,7 +182,7 @@ Basta cliccare sul badge e attendere l’avvio dell’ambiente interattivo.
 
 ---
 
-## 🧑‍💻 Risorse per imparare Jupyter e i notebook `.ipynb`
+## Risorse per imparare Jupyter e i notebook `.ipynb`
 
 Per approfondire come si usano i notebook interattivi e Jupyter, ecco alcuni link utili per imparare a sfruttare al meglio questi strumenti:
 
@@ -203,10 +209,4 @@ Per approfondire come si usano i notebook interattivi e Jupyter, ecco alcuni lin
 
 ---
 
-## 💻 Codice e soluzioni agli esercizi
-
-Tutte le soluzioni agli esercizi proposti nei vari capitoli sono disponibili nella cartella [_**code**_ ](code/) del repository e suddivisi per i vari capitoli.
-
----
-
 &copy; 2025 hanam.ai - All rights reserved. | Built with precision for real-time data streaming excellence.
diff --git a/appendix.ipynb b/appendix.ipynb
index 2468b53..18f57d3 100755
--- a/appendix.ipynb
+++ b/appendix.ipynb
@@ -4,7 +4,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "# 📚 Appendice\n",
+        "# Appendice\n",
         "\n",
         "In questa appendice ci sono informazioni sulla storia di Python, le versioni principali, le applicazioni moderne e le convenzioni di stile PEP8."
       ]
@@ -43,7 +43,7 @@
         "- Ha una **grande comunità open source** e una vasta collezione di librerie e framework (come Flask, Django, NumPy, Pandas, ecc.).\n",
         "- È spesso il **linguaggio consigliato per iniziare a programmare** per via della sua sintassi leggibile.\n",
         "\n",
-        "> 📈 Nel 2020–2024 è stato tra i linguaggi più usati al mondo secondo vari indici (TIOBE, Stack Overflow Developer Survey)."
+        "> Nel 2020–2024 è stato tra i linguaggi più usati al mondo secondo vari indici (TIOBE, Stack Overflow Developer Survey)."
       ]
     },
     {
diff --git a/code/02/solutions/exercise06.py b/code/02/solutions/exercise06.py
new file mode 100755
index 0000000..0b72a27
--- /dev/null
+++ b/code/02/solutions/exercise06.py
@@ -0,0 +1,9 @@
+def format_data():
+    name = "Luca"
+    balance = 1234.567
+    print(f'Hi {name} Your balance is {balance:.2f} €')
+    print(f'Hi {name} Your balance is now {balance + 100:.2f} €')
+
+
+if __name__ == "__main__":
+    format_data()
\ No newline at end of file