From ca92da5638194be3dae717c6ea1f2b100a29e76d Mon Sep 17 00:00:00 2001 From: hifly81 Date: Sat, 8 Nov 2025 14:19:01 +0100 Subject: [PATCH 1/2] aggiunto paragrafo su f-string --- 01_primi_passi.ipynb | 12 +-- 02_sintassi_base.ipynb | 171 +++++++++++++++++++++++++++----- code/02/solutions/exercise06.py | 9 ++ 3 files changed, 159 insertions(+), 33 deletions(-) create mode 100755 code/02/solutions/exercise06.py diff --git a/01_primi_passi.ipynb b/01_primi_passi.ipynb index cc5d36f..1941b25 100755 --- a/01_primi_passi.ipynb +++ b/01_primi_passi.ipynb @@ -21,7 +21,7 @@ "\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." ] }, { @@ -48,7 +48,7 @@ "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", + "A seconda del sistema operativo in uso, i passaggi sono leggermente diversi. Prima di iniziare a programmare occorre assicurarsi di avere Python installato e configurato correttamente prima di procedere.\n", "\n", "**Su Linux**\n", "- **Python:** È quasi sempre preinstallato. Si può verificare con il comando `python3 --version`.\n", @@ -92,7 +92,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." @@ -125,7 +125,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:" ] }, { @@ -212,7 +212,7 @@ "\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 +271,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." ] }, { diff --git a/02_sintassi_base.ipynb b/02_sintassi_base.ipynb index eeec1b5..58ab26d 100755 --- a/02_sintassi_base.ipynb +++ b/02_sintassi_base.ipynb @@ -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", + "### Funzione `print()` 🖨️\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", - "### 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", + "#### 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 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." ] }, { @@ -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/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 From 6527aba429be1fade94c56c34e9f7a8dfa27a2b1 Mon Sep 17 00:00:00 2001 From: hifly81 Date: Sat, 8 Nov 2025 14:40:03 +0100 Subject: [PATCH 2/2] wording --- 03_strutture_dati.ipynb | 29 +++++++++++------------------ 04_gestione_errori.ipynb | 2 +- 05_funzioni_moduli.ipynb | 2 +- 3 files changed, 13 insertions(+), 20 deletions(-) diff --git a/03_strutture_dati.ipynb b/03_strutture_dati.ipynb index 3ad2a7b..ed05219 100755 --- a/03_strutture_dati.ipynb +++ b/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" ] }, { diff --git a/04_gestione_errori.ipynb b/04_gestione_errori.ipynb index 34df491..f65627c 100755 --- a/04_gestione_errori.ipynb +++ b/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." ] }, { diff --git a/05_funzioni_moduli.ipynb b/05_funzioni_moduli.ipynb index 04ed03b..8078482 100755 --- a/05_funzioni_moduli.ipynb +++ b/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." ] }, {