wording

Author: hifly81

03_strutture_dati.ipynb

@@ -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."
    ]
@@ -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,13 +370,6 @@
       "# it creates an iterator with iter(fruits) and calls next() until StopIteration"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "---"
-   ]
-  },
   {
  "cell_type": "markdown",
  "metadata": {},
@@ -484,7 +477,7 @@
 "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"
 ]
 },
   {

04_gestione_errori.ipynb

@@ -8,7 +8,7 @@
         "\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."
       ]
     },
     {

05_funzioni_moduli.ipynb

@@ -8,7 +8,7 @@
     "\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."
    ]
   },
   {