From 29a6725d0daa24f5e52f175c0663bf1f822b57ad Mon Sep 17 00:00:00 2001 From: hifly81 Date: Tue, 25 Nov 2025 01:04:03 +0100 Subject: [PATCH] v 5.0 --- .gitignore | 5 +- 00_sommario_corso.ipynb | 8 +-- 01_primi_passi.ipynb | 133 ++++++++++++++++++++++++++++++------- 02_sintassi_base.ipynb | 12 ++-- 03_strutture_dati.ipynb | 18 ++--- 04_gestione_errori.ipynb | 6 +- 05_funzioni_moduli.ipynb | 24 +++---- 06_fileio.ipynb | 27 +++----- 07_libreria_standard.ipynb | 16 ++--- 08_librerie.ipynb | 42 ++++++------ 09_oop.ipynb | 18 ++--- 10_testunit.ipynb | 6 +- 11_decorator_closure.ipynb | 20 +++--- 12_progetto.ipynb | 14 ++-- README.md | 30 ++++----- appendix.ipynb | 4 +- 16 files changed, 227 insertions(+), 156 deletions(-) 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 1941b25..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,7 +17,7 @@ "id": "038c35b4", "metadata": {}, "source": [ - "## Pre-requisiti e strumenti necessari 🛠️\n", + "## Pre-requisiti e strumenti necessari\n", "\n", "### Competenze richieste\n", "\n", @@ -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 assicurarsi 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", @@ -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." ] @@ -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,7 +291,7 @@ "\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", @@ -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 58ab26d..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", @@ -483,7 +483,7 @@ "---\n", "## Funzioni di input e output\n", "\n", - "### Funzione `print()` 🖨️\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", @@ -552,7 +552,7 @@ "Le **f-string** sono considerate la scelta **più moderna, leggibile e veloce**.\n", "\n", "---\n", - "### Funzione `input()` ⌨️\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", "```python\n", @@ -638,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", "---" ] diff --git a/03_strutture_dati.ipynb b/03_strutture_dati.ipynb index ed05219..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", @@ -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", @@ -375,7 +375,7 @@ "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", @@ -454,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", @@ -470,7 +470,7 @@ "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", @@ -697,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 f65627c..cd24980 100755 --- a/04_gestione_errori.ipynb +++ b/04_gestione_errori.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# ⚠️ Gestione degli Errori in Python\n", + "# Gestione degli Errori in Python\n", "\n", "---\n", "\n", @@ -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 8078482..6f3c99b 100755 --- a/05_funzioni_moduli.ipynb +++ b/05_funzioni_moduli.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# ⚙️ Funzioni e Moduli\n", + "# Funzioni e Moduli\n", "\n", "---", "\n", @@ -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 fd5efad..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." ] @@ -198,7 +198,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 🧰 Decorator integrati in Python\n", + "## Decorator integrati in Python\n", "\n", "Python fornisce alcuni decorator integrati:\n", "- `@staticmethod`\n", @@ -270,7 +270,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## 🧩 `@dataclass`: decorator per creare classi \"automatiche\"\n", + "## `@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", @@ -333,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 c9ee4f4..0acec21 100755 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# 🐍 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) @@ -17,7 +17,7 @@ Visita il sito ufficiale del corso dove potrai anche ottenere il badge di comple -## 📚 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,17 +47,17 @@ Visita il sito ufficiale del corso dove potrai anche ottenere il badge di comple --- -## 💻 Codice e soluzioni agli esercizi +## 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. --- -## ▶️ Come usare i notebook +## Come usare i notebook 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`. -### ⚙️ 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: @@ -75,7 +75,7 @@ python -m pip --version --- -#### 🔹 Installazione su Linux / macOS +#### Installazione su Linux / macOS Se `pip` non è presente, puoi installarlo usando il comando: @@ -100,7 +100,7 @@ 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”**. @@ -113,7 +113,7 @@ python -m pip install --upgrade pip --- -#### 🔹 Anaconda / Miniconda +#### Anaconda / Miniconda Se utilizzi **Anaconda** o **Miniconda**, `pip` è già incluso. Puoi verificarlo con: @@ -128,7 +128,7 @@ In alternativa, puoi installarlo/aggiornarlo con: conda install pip ``` -### ✅ Con Jupyter Notebook (installazione locale) +### Con Jupyter Notebook (installazione locale) Se vuoi lavorare in locale, installa Jupyter e avvia il server: @@ -141,7 +141,7 @@ Dopo aver eseguito il comando, si aprirà una finestra nel browser da cui potrai --- -### ✅ Con JupyterLab (interfaccia avanzata) +### Con JupyterLab (interfaccia avanzata) JupyterLab offre un’interfaccia più moderna e completa rispetto a Jupyter Notebook: @@ -152,7 +152,7 @@ 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**. @@ -160,7 +160,7 @@ jupyter lab --- -### ✅ 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/): @@ -172,7 +172,7 @@ Se non vuoi installare nulla, puoi aprire i notebook direttamente su [Google Col --- -### ✅ 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/): @@ -182,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: 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)." ] }, {