├── .gitignore ├── Correzioni_Esercizi ├── Es_Condizioni │ ├── ES1_Condizioni.py │ ├── ES2_Condizioni.py │ └── ES3_Condizioni.py └── ReadME ├── Esempi _codice ├── ES_TryExpext_medium.py ├── ES_Variabili.py ├── ES_tryexcept_easy.py ├── Es_Astrazione.py ├── Es_Classi.py ├── Es_Condizioni.py ├── Es_Decoratori.py ├── Es_Ereditarietà.py ├── Es_Ereditarietà_2.py ├── Es_Funzioni.py ├── Es_Incapsulamento.py ├── Es_Incapsulamento2.py ├── Es_NumPY_1.py ├── Es_Numpy_1.5.py ├── Es_Polimorfimso.py ├── Es_Strutture_dati.py ├── Es_TryExcp.py ├── Es_mio_modulo.py ├── Es_moduli.py ├── Es_personalizzazione_grafici_Matplot.py └── Es_personalizzazione_grafici_Seaborn.py ├── README.md ├── Requisiti_Di_Sistema └── Slide_Link ├── Es_1.jpg ├── Es_Classi_Extra ├── Es_Facili_Classi_Extra ├── Filippo - Esercizi classi extra ├── ATTESA TRACCE DIFFICILI │ └── VUOTO.txt ├── es facili │ ├── README.md │ ├── es1.py │ ├── es2.py │ └── es3.py └── es medi │ ├── README.md │ ├── es1.py │ ├── es2.py │ └── es3.py ├── Link_Lavagna ├── Link_Slide └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | share/python-wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | MANIFEST 28 | 29 | # PyInstaller 30 | # Usually these files are written by a python script from a template 31 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 32 | *.manifest 33 | *.spec 34 | 35 | # Installer logs 36 | pip-log.txt 37 | pip-delete-this-directory.txt 38 | 39 | # Unit test / coverage reports 40 | htmlcov/ 41 | .tox/ 42 | .nox/ 43 | .coverage 44 | .coverage.* 45 | .cache 46 | nosetests.xml 47 | coverage.xml 48 | *.cover 49 | *.py,cover 50 | .hypothesis/ 51 | .pytest_cache/ 52 | cover/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | .pybuilder/ 76 | target/ 77 | 78 | # Jupyter Notebook 79 | .ipynb_checkpoints 80 | 81 | # IPython 82 | profile_default/ 83 | ipython_config.py 84 | 85 | # pyenv 86 | # For a library or package, you might want to ignore these files since the code is 87 | # intended to run in multiple environments; otherwise, check them in: 88 | # .python-version 89 | 90 | # pipenv 91 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 92 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 93 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 94 | # install all needed dependencies. 95 | #Pipfile.lock 96 | 97 | # UV 98 | # Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. 99 | # This is especially recommended for binary packages to ensure reproducibility, and is more 100 | # commonly ignored for libraries. 101 | #uv.lock 102 | 103 | # poetry 104 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 105 | # This is especially recommended for binary packages to ensure reproducibility, and is more 106 | # commonly ignored for libraries. 107 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 108 | #poetry.lock 109 | 110 | # pdm 111 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. 112 | #pdm.lock 113 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it 114 | # in version control. 115 | # https://pdm.fming.dev/latest/usage/project/#working-with-version-control 116 | .pdm.toml 117 | .pdm-python 118 | .pdm-build/ 119 | 120 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm 121 | __pypackages__/ 122 | 123 | # Celery stuff 124 | celerybeat-schedule 125 | celerybeat.pid 126 | 127 | # SageMath parsed files 128 | *.sage.py 129 | 130 | # Environments 131 | .env 132 | .venv 133 | env/ 134 | venv/ 135 | ENV/ 136 | env.bak/ 137 | venv.bak/ 138 | 139 | # Spyder project settings 140 | .spyderproject 141 | .spyproject 142 | 143 | # Rope project settings 144 | .ropeproject 145 | 146 | # mkdocs documentation 147 | /site 148 | 149 | # mypy 150 | .mypy_cache/ 151 | .dmypy.json 152 | dmypy.json 153 | 154 | # Pyre type checker 155 | .pyre/ 156 | 157 | # pytype static type analyzer 158 | .pytype/ 159 | 160 | # Cython debug symbols 161 | cython_debug/ 162 | 163 | # PyCharm 164 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can 165 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 166 | # and can be added to the global gitignore or merged into this file. For a more nuclear 167 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 168 | #.idea/ 169 | 170 | # Ruff stuff: 171 | .ruff_cache/ 172 | 173 | # PyPI configuration file 174 | .pypirc 175 | -------------------------------------------------------------------------------- /Correzioni_Esercizi/Es_Condizioni/ES1_Condizioni.py: -------------------------------------------------------------------------------- 1 | print("=== Controllo a 3 livelli con numeri ===") 2 | 3 | # Primo livello 4 | numero1 = int(input("Inserisci un numero per sbloccare il Livello 1 (>= 10 richiesto): ")) 5 | if numero1 >= 10: 6 | print("Livello 1 sbloccato!") 7 | 8 | # Secondo livello 9 | numero2 = int(input("Inserisci un numero per sbloccare il Livello 2 (>= 20 richiesto): ")) 10 | if numero2 >= 20: 11 | print("Livello 2 sbloccato!") 12 | 13 | # Terzo livello 14 | numero3 = int(input("Inserisci un numero per sbloccare il Livello 3 (>= 30 richiesto): ")) 15 | if numero3 >= 30: 16 | print("Livello 3 sbloccato! Hai ottenuto l’accesso completo.") 17 | else: 18 | print("Numero troppo piccolo per sbloccare il Livello 3. Accesso negato.") 19 | else: 20 | print("Numero troppo piccolo per sbloccare il Livello 2. Accesso negato.") 21 | else: 22 | print("Numero troppo piccolo per sbloccare il Livello 1. Accesso negato.") 23 | -------------------------------------------------------------------------------- /Correzioni_Esercizi/Es_Condizioni/ES2_Condizioni.py: -------------------------------------------------------------------------------- 1 | # Menu testuale che permette di: 2 | # 1) Aggiungere un elemento 3 | # 2) Rimuovere un elemento 4 | # 3) Visualizzare la lista 5 | # 4) Svuotare/eliminare tutta la lista 6 | # 5) Uscire 7 | 8 | lista_elementi = [] 9 | 10 | while True: 11 | print("\n--- MENU ---") 12 | print("1) Aggiungi elemento") 13 | print("2) Rimuovi elemento") 14 | print("3) Visualizza lista") 15 | print("4) Elimina tutta la lista") 16 | print("5) Esci") 17 | 18 | scelta = input("Seleziona un'opzione: ") 19 | 20 | if scelta == "1": 21 | elemento = input("Inserisci l'elemento da aggiungere: ") 22 | lista_elementi.append(elemento) 23 | print(f"Elemento '{elemento}' aggiunto con successo.") 24 | 25 | elif scelta == "2": 26 | elemento = input("Inserisci l'elemento da rimuovere: ") 27 | if elemento in lista_elementi: 28 | lista_elementi.remove(elemento) 29 | print(f"Elemento '{elemento}' rimosso con successo.") 30 | else: 31 | print(f"Elemento '{elemento}' non trovato nella lista.") 32 | 33 | elif scelta == "3": 34 | print("Contenuto della lista:") 35 | if len(lista_elementi) == 0: 36 | print("[Lista vuota]") 37 | else: 38 | for elem in lista_elementi: 39 | print(f"- {elem}") 40 | 41 | elif scelta == "4": 42 | lista_elementi.clear() 43 | print("Lista completamente eliminata.") 44 | 45 | elif scelta == "5": 46 | print("Uscita dal programma.") 47 | break 48 | 49 | else: 50 | print("Scelta non valida, riprova.") 51 | -------------------------------------------------------------------------------- /Correzioni_Esercizi/Es_Condizioni/ES3_Condizioni.py: -------------------------------------------------------------------------------- 1 | accounts = [] # Lista di account, ognuno è [id, nome, password] 2 | next_id = 1 # Contatore per l'ID progressivo 3 | 4 | scelta = input("Vuoi creare un nuovo account? (s/n): ") 5 | 6 | if scelta.lower() == 's': 7 | # Creazione di un nuovo account 8 | nome = input("Inserisci il tuo nome: ") 9 | password = input("Inserisci la tua password: ") 10 | 11 | # Costruiamo la lista con i dati 12 | nuovo_account = [next_id, nome, password] 13 | accounts.append(nuovo_account) 14 | 15 | print(f"Account creato con successo! ID assegnato: {next_id}") 16 | next_id += 1 17 | 18 | nome = input("Inserisci il tuo nome di nuovo: ") 19 | password = input("Inserisci la tua password di nuovo: ") 20 | 21 | if nome.lower() and password.lower() in nuovo_account: 22 | print("Account esistente") 23 | -------------------------------------------------------------------------------- /Correzioni_Esercizi/ReadME: -------------------------------------------------------------------------------- 1 | Correzioni degli esercizi 2 | -------------------------------------------------------------------------------- /Esempi _codice/ES_TryExpext_medium.py: -------------------------------------------------------------------------------- 1 | def esempio_completo(lista, dizionario, file_path): 2 | """ 3 | Esegue diverse operazioni per illustrare il catch delle principali famiglie di errori: 4 | 1) Accesso a lista e dizionario 5 | 2) Apertura file 6 | 3) Conversione e divisione aritmetica 7 | """ 8 | try: 9 | # 1) LookupError: accesso a indice e chiave 10 | elemento = lista[2] # può sollevare IndexError 11 | valore = dizionario["chiave"] # può sollevare KeyError 12 | 13 | # 2) OSError: apertura file 14 | with open(file_path, 'r') as f: 15 | contenuto = f.read().strip() 16 | 17 | # 3) ValueError/TypeError/ZeroDivisionError 18 | numero = int(contenuto) # ValueError se contenuto non è numerico 19 | risultato = numero / 0 # ZeroDivisionError 20 | 21 | print("Risultato complessivo:", risultato) 22 | 23 | except IndexError as e: 24 | print("Errore di indice (LookupError):", e) 25 | 26 | except KeyError as e: 27 | print("Errore di chiave (LookupError):", e) 28 | 29 | except FileNotFoundError as e: 30 | print("File non trovato (OSError):", e) 31 | 32 | except PermissionError as e: 33 | print("Permessi insufficienti (OSError):", e) 34 | 35 | except ValueError as e: 36 | print("Conversione non valida (ValueError):", e) 37 | 38 | except TypeError as e: 39 | print("Tipo dati non compatibile (TypeError):", e) 40 | 41 | except ZeroDivisionError as e: 42 | print("Divisione per zero non permessa (ArithmeticError):", e) 43 | 44 | except Exception as e: 45 | # Qualunque altra eccezione imprevista 46 | print("Errore imprevisto:", e) 47 | 48 | else: 49 | # Eseguito solo se non è caduto alcun except 50 | print("Tutte le operazioni sono andate a buon fine.") 51 | 52 | finally: 53 | # Viene sempre eseguito 54 | print("Fine funzione esempio_completo.") 55 | 56 | # --- Esempio di chiamata --- 57 | if __name__ == "__main__": 58 | lis = [10, 20] # lista troppo corta per lis[2] 59 | diz = {"altra": "valore"} # non contiene "chiave" 60 | percorso = "non_esiste.txt" # file inesistente 61 | 62 | esempio_completo(lis, diz, percorso) 63 | -------------------------------------------------------------------------------- /Esempi _codice/ES_Variabili.py: -------------------------------------------------------------------------------- 1 | # Esempio 1: Assegnazione di base 2 | # Qui creiamo variabili di diversi tipi e stampiamo il loro valore. 3 | numero_intero = 10 # Variabile di tipo intero 4 | numero_decimale = 3.14 # Variabile di tipo float 5 | testo = "Ciao Python" # Variabile di tipo stringa 6 | vero_falso = True # Variabile booleana 7 | 8 | print("Intero:", numero_intero) 9 | print("Decimale:", numero_decimale) 10 | print("Stringa:", testo) 11 | print("Booleano:", vero_falso) 12 | 13 | # Esempio 2: Assegnazione multipla 14 | # Possiamo assegnare più variabili in una sola istruzione. 15 | x, y, z = 1, 2, 3 16 | print("\nAssegnazione multipla -> x:", x, "y:", y, "z:", z) 17 | 18 | # Esempio 3: Ridefinizione di variabili 19 | # In Python, una variabile può cambiare tipo in qualsiasi momento. 20 | x = 100 21 | print("\nDopo la ridefinizione, x:", x) 22 | x = "Ora sono una stringa" 23 | print("Dopo la ridefinizione, x:", x) 24 | 25 | # Esempio 4: Operazioni aritmetiche con variabili 26 | a = 5 27 | b = 2 28 | somma = a + b 29 | differenza = a - b 30 | prodotto = a * b 31 | divisione = a / b 32 | divisione_intera = a // b 33 | resto = a % b 34 | potenza = a ** b 35 | 36 | print("\nOperazioni aritmetiche con a=5 e b=2:") 37 | print("Somma:", somma) 38 | print("Differenza:", differenza) 39 | print("Prodotto:", prodotto) 40 | print("Divisione:", divisione) 41 | print("Divisione intera:", divisione_intera) 42 | print("Resto:", resto) 43 | print("Potenza:", potenza) 44 | 45 | # Esempio 5: Utilizzo di variabili in espressioni logiche 46 | maggiore = a > b 47 | uguale = a == b 48 | minore_o_uguale = b <= 2 49 | 50 | print("\nEspressioni logiche:") 51 | print("a > b :", maggiore) 52 | print("a == b:", uguale) 53 | print("b <= 2:", minore_o_uguale) 54 | 55 | # Esempio 6: Variabili e concatenazione di stringhe 56 | nome = "Mario" 57 | cognome = "Rossi" 58 | nome_completo = nome + " " + cognome 59 | print("\nConcatenazione di stringhe -> nome completo:", nome_completo) 60 | 61 | # Esempio 7: Variabili in liste 62 | lista_numeri = [1, 2, 3] 63 | lista_numeri[1] = 20 # Assegnazione di un nuovo valore a un elemento della lista 64 | print("\nLista numeri dopo la modifica:", lista_numeri) 65 | 66 | # Esempio 8: Variabili in tuple (immutabili) 67 | # Le tuple, a differenza delle liste, non possono essere modificate dopo la creazione. 68 | coordinate = (10, 20) 69 | print("\nCoordinate (tuple):", coordinate) 70 | 71 | # Esempio 9: Variabili in dizionari 72 | dizionario = { 73 | "nome": "Mario", 74 | "eta": 30 75 | } 76 | print("\nDizionario iniziale:", dizionario) 77 | dizionario["citta"] = "Roma" # Aggiunta di una nuova chiave-valore 78 | print("Dizionario dopo l'aggiunta di una chiave 'citta':", dizionario) 79 | 80 | # Esempio 10: Gestione di variabili con funzioni (senza OOP) 81 | def stampa_variabili(): 82 | # Questa funzione usa variabili locali 83 | locale_a = 10 84 | locale_b = 20 85 | print("\nNella funzione, locale_a:", locale_a, "locale_b:", locale_b) 86 | 87 | stampa_variabili() 88 | 89 | # Esempio 11: Variabili globali 90 | VALORE_GLOBALE = 100 91 | 92 | def modifica_globale(): 93 | global VALORE_GLOBALE 94 | VALORE_GLOBALE = 200 # Modifica la variabile globale 95 | 96 | print("\nPrima della modifica:", VALORE_GLOBALE) 97 | modifica_globale() 98 | print("Dopo la modifica globale:", VALORE_GLOBALE) 99 | -------------------------------------------------------------------------------- /Esempi _codice/ES_tryexcept_easy.py: -------------------------------------------------------------------------------- 1 | def esempio_basilare(): 2 | """ 3 | Legge due numeri da input e ne stampa la somma. 4 | Se si verifica *qualsiasi* errore (input non numerico, EOF, ecc.), 5 | stampa un messaggio generico. 6 | """ 7 | try: 8 | a = int(input("Inserisci il primo numero: ")) 9 | b = int(input("Inserisci il secondo numero: ")) 10 | print(f"La somma è: {a + b}") 11 | except Exception as e: 12 | # Cattura tutte le eccezioni ereditate da Exception 13 | print(f"Errore generico: {e}") 14 | 15 | if __name__ == "__main__": 16 | esempio_basilare() 17 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Astrazione.py: -------------------------------------------------------------------------------- 1 | """ 2 | Esempio di astrazione in Python: 3 | - Uso del modulo abc (Abstract Base Class) 4 | - Classe astratta Shape con metodi astratti area() e perimetro() 5 | - Sottoclassi Circle e Rectangle che implementano i metodi astratti 6 | - Funzione che sfrutta il polimorfismo sulle classi astratte 7 | """ 8 | 9 | import math 10 | from abc import ABC, abstractmethod 11 | 12 | # ============================================================== 13 | # CLASSE ASTRATTA 14 | # ============================================================== 15 | 16 | # classe astratta 17 | class Shape(ABC): 18 | """ 19 | Classe astratta (non istanziabile direttamente) che rappresenta 20 | una figura geometrica generica. Definisce i metodi area() e perimetro() 21 | come astratti, obbligando le sottoclassi a implementarli. 22 | """ 23 | @abstractmethod 24 | def area(self): 25 | """ 26 | Restituisce l'area della figura geometrica. 27 | (Da implementare nelle sottoclassi.) 28 | """ 29 | pass 30 | 31 | @abstractmethod 32 | def perimetro(self): 33 | """ 34 | Restituisce il perimetro della figura geometrica. 35 | (Da implementare nelle sottoclassi.) 36 | """ 37 | pass 38 | 39 | # metodi reale, metodo di istanza 40 | def descrivi(self): 41 | """ 42 | Metodo facoltativo (non astratto) che può essere usato, sovrascritto 43 | o esteso dalle sottoclassi, se desiderato. 44 | """ 45 | return "Sono una forma geometrica." 46 | 47 | 48 | # ============================================================== 49 | # SOTTOCLASSI CHE IMPLEMENTANO L'ASTRAZIONE 50 | # ============================================================== 51 | 52 | class Circle(Shape): 53 | """ 54 | Sottoclasse di Shape che rappresenta un cerchio. 55 | Deve implementare area() e perimetro() definiti come astratti. 56 | """ 57 | def __init__(self, raggio): 58 | self.raggio = raggio 59 | 60 | def area(self): 61 | return math.pi * (self.raggio ** 2) 62 | 63 | def perimetro(self): 64 | return 2 * math.pi * self.raggio 65 | 66 | def descrivi(self): 67 | """ 68 | Sovrascrive descrivi() per aggiungere info sul raggio del cerchio. 69 | """ 70 | return f"Sono un Cerchio con raggio={self.raggio:.2f}" 71 | 72 | 73 | class Rectangle(Shape): 74 | """ 75 | Sottoclasse di Shape che rappresenta un rettangolo. 76 | """ 77 | def __init__(self, larghezza, altezza): 78 | self.larghezza = larghezza 79 | self.altezza = altezza 80 | 81 | def area(self): 82 | return self.larghezza * self.altezza 83 | 84 | def perimetro(self): 85 | return 2 * (self.larghezza + self.altezza) 86 | 87 | def descrivi(self): 88 | return f"Sono un Rettangolo con larghezza={self.larghezza} e altezza={self.altezza}" 89 | 90 | 91 | # ============================================================== 92 | # FUNZIONI DI ESEMPIO 93 | # ============================================================== 94 | 95 | def stampa_info_shape(shape_obj): 96 | """ 97 | Funzione che accetta un oggetto di tipo Shape (o derivato) e ne stampa le info: 98 | - descrizione 99 | - area 100 | - perimetro 101 | """ 102 | print(shape_obj.descrivi()) 103 | print(f"Area: {shape_obj.area():.2f}") 104 | print(f"Perimetro: {shape_obj.perimetro():.2f}") 105 | print("---") 106 | 107 | 108 | def main(): 109 | # Non possiamo istanziare Shape direttamente, perché è una classe astratta: 110 | # shape = Shape() # -> Errore: TypeError: Can't instantiate abstract class 111 | 112 | # Creiamo invece istanze delle sottoclassi concrete: 113 | circle = Circle(raggio=5) 114 | rectangle = Rectangle(larghezza=3, altezza=7) 115 | 116 | # Usiamo la stessa funzione polimorfica su oggetti di sottoclassi diverse 117 | print("=== ESEMPIO DI ASTRATTAZIONE CON SHAPE, CERCHIO E RETTANGOLO ===") 118 | stampa_info_shape(circle) 119 | stampa_info_shape(rectangle) 120 | 121 | 122 | if __name__ == "__main__": 123 | main() 124 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Classi.py: -------------------------------------------------------------------------------- 1 | 2 | """ 3 | Esempi unificati di polimorfismo e utilizzo di classi in Python: 4 | - classi semplici con __str__ 5 | - ereditarietà e polimorfismo (Animale, Cane, Gatto) 6 | - dizionari contenenti istanze di classi diverse 7 | - operator overloading (__add__) con la classe Contatore 8 | - differenza tra __str__ e __repr__ (classe Punto) 9 | """ 10 | 11 | # ============================================================== 12 | # ESEMPIO 1: CLASSE 'Persona' CON METODO __str__ 13 | # ============================================================== 14 | 15 | class Persona: 16 | """ 17 | Rappresenta una persona, con nome ed età. 18 | Il metodo __str__ restituisce una stringa descrittiva dell'oggetto. 19 | """ 20 | def __init__(self, nome, eta): 21 | self.nome = nome 22 | self.eta = eta 23 | 24 | def __str__(self): 25 | # Viene richiamato quando facciamo: print(istanza_di_Persona) 26 | return f"Persona(nome={self.nome}, eta={self.eta})" 27 | 28 | 29 | # ============================================================== 30 | # ESEMPIO 2: CLASSI PER IL POLIMORFISMO (Animale, Cane, Gatto) 31 | # ============================================================== 32 | 33 | class Animale: 34 | """ 35 | Classe base (genitore) per vari tipi di animali. 36 | Definisce un metodo astratto 'verso' e un __str__ generico. 37 | """ 38 | def __init__(self, nome): 39 | self.nome = nome 40 | 41 | def verso(self): 42 | """ 43 | Metodo che dovrebbe essere implementato dalle sottoclassi. 44 | """ 45 | raise NotImplementedError("Implementare il metodo 'verso' nella sottoclasse.") 46 | 47 | def __str__(self): 48 | """ 49 | Restituisce una descrizione generica di un animale. 50 | """ 51 | return f"Animale(nome={self.nome})" 52 | 53 | 54 | class Cane(Animale): 55 | """ 56 | Sottoclasse che estende Animale per rappresentare un Cane. 57 | """ 58 | def verso(self): 59 | return "Bau!" 60 | 61 | def __str__(self): 62 | # Overriding del metodo __str__ 63 | return f"Cane(nome={self.nome})" 64 | 65 | 66 | class Gatto(Animale): 67 | """ 68 | Sottoclasse che estende Animale per rappresentare un Gatto. 69 | """ 70 | def verso(self): 71 | return "Miao!" 72 | 73 | def __str__(self): 74 | # Overriding del metodo __str__ 75 | return f"Gatto(nome={self.nome})" 76 | 77 | 78 | # ============================================================== 79 | # ESEMPIO 3: UTILIZZO DI OGGETTI IN DIZIONARI, CICLI E CONDIZIONI 80 | # ============================================================== 81 | 82 | def esempio_dizionario_animali(): 83 | """ 84 | Crea un dizionario di animali (Cane e Gatto), 85 | itera sulle voci e mostra il polimorfismo di 'verso()'. 86 | """ 87 | animali_domestici = { 88 | "Fido": Cane("Fido"), 89 | "Luna": Gatto("Luna"), 90 | "Miao": Gatto("Miao"), 91 | "Rex": Cane("Rex") 92 | } 93 | 94 | for nome, animale in animali_domestici.items(): 95 | print(f"Chiave: {nome} -> Oggetto:", animale) 96 | print("Verso:", animale.verso()) # Polimorfismo 97 | if isinstance(animale, Gatto): 98 | print(" -> Questo è un Gatto, si dice che ami le coccole a modo suo...") 99 | elif isinstance(animale, Cane): 100 | print(" -> Questo è un Cane, si dice che ami giocare con la palla...") 101 | print("---") 102 | 103 | 104 | # ============================================================== 105 | # ESEMPIO 4: OPERATOR OVERLOADING (__add__) CON LA CLASSE 'Contatore' 106 | # ============================================================== 107 | 108 | class Contatore: 109 | """ 110 | Classe che tiene traccia di un contatore (valore numerico). 111 | Esempio di operator overloading su __add__. 112 | """ 113 | def __init__(self, valore=0): 114 | self.valore = valore 115 | 116 | def __add__(self, altro): 117 | """ 118 | Permette di usare l'operatore + tra due Contatore o 119 | tra un Contatore e un numero (int, float). 120 | """ 121 | if isinstance(altro, Contatore): 122 | return Contatore(self.valore + altro.valore) 123 | elif isinstance(altro, (int, float)): 124 | return Contatore(self.valore + altro) 125 | else: 126 | raise TypeError(f"Operazione non supportata tra Contatore e {type(altro)}") 127 | 128 | def __str__(self): 129 | return f"Contatore(valore={self.valore})" 130 | 131 | 132 | # ============================================================== 133 | # ESEMPIO 5: __str__ VS __repr__ (classe 'Punto') 134 | # ============================================================== 135 | 136 | class Punto: 137 | """ 138 | Rappresenta un punto 2D con coordinate x, y. 139 | Mostra la differenza tra __repr__ e __str__. 140 | """ 141 | def __init__(self, x, y): 142 | self.x = x 143 | self.y = y 144 | 145 | def __repr__(self): 146 | # Usata ad esempio nella shell o in contesti di debug 147 | return f"Punto(x={self.x}, y={self.y})" 148 | 149 | def __str__(self): 150 | # Usata con print() per una rappresentazione più user-friendly 151 | return f"({self.x}, {self.y})" 152 | 153 | 154 | # ============================================================== 155 | # FUNZIONE MAIN PER DIMOSTRARE TUTTI GLI ESEMPI 156 | # ============================================================== 157 | 158 | def main(): 159 | # Esempio 1: Persona con __str__ 160 | print("===== ESEMPIO 1: Persona con __str__ =====") 161 | mario = Persona("Mario", 30) 162 | anna = Persona("Anna", 25) 163 | print(mario) 164 | print(anna) 165 | 166 | # Esempio 2: Polimorfismo con classi Animale, Cane, Gatto 167 | print("\n===== ESEMPIO 2: Polimorfismo con Animale, Cane, Gatto =====") 168 | fido = Cane("Fido") 169 | luna = Gatto("Luna") 170 | animali = [fido, luna] 171 | for animale in animali: 172 | print(animale, "| Verso:", animale.verso()) 173 | 174 | # Esempio 3: Dizionario di animali 175 | print("\n===== ESEMPIO 3: Dizionario di Animali =====") 176 | esempio_dizionario_animali() 177 | 178 | # Esempio 4: Operator overloading con Contatore 179 | print("\n===== ESEMPIO 4: Operator overloading (Contatore) =====") 180 | c1 = Contatore(10) 181 | c2 = Contatore(5) 182 | c3 = c1 + c2 183 | c4 = c3 + 100 184 | print("c1:", c1) 185 | print("c2:", c2) 186 | print("c1 + c2 =", c3) 187 | print("c3 + 100 =", c4) 188 | 189 | # Esempio 5: __str__ vs __repr__ con Punto 190 | print("\n===== ESEMPIO 5: __str__ vs __repr__ (Punto) =====") 191 | p = Punto(3, 5) 192 | print("print(p) -> chiama __str__:", p) 193 | print("repr(p) -> chiama __repr__:", repr(p)) 194 | 195 | 196 | # ============================================================== 197 | # Avvio dello script (se eseguito come main) 198 | # ============================================================== 199 | if __name__ == "__main__": 200 | main() 201 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Condizioni.py: -------------------------------------------------------------------------------- 1 | # Esempio 1: If, Elif, Else 2 | # Assegniamo un valore a "x" e lo valutiamo con delle condizioni. 3 | x = 10 4 | 5 | if x > 10: 6 | print("x è maggiore di 10") 7 | elif x == 10: 8 | print("x è uguale a 10") 9 | else: 10 | print("x è minore di 10") 11 | 12 | # Esempio 2: Ciclo for con range() 13 | # Stampiamo i numeri da 0 a 4 usando range(5). 14 | for i in range(5): 15 | print("Valore di i nel for con range(5):", i) 16 | 17 | # Esempio 3: Ciclo for per iterare su una lista 18 | frutti = ["mela", "banana", "ciliegia"] 19 | for frutto in frutti: 20 | print("Frutto:", frutto) 21 | 22 | # Esempio 4: Ciclo while 23 | # Contiamo da 1 a 5 utilizzando while. 24 | contatore = 1 25 | while contatore <= 5: 26 | print("Contatore mentre è in esecuzione il while:", contatore) 27 | contatore += 1 # Incrementiamo il contatore 28 | 29 | # Esempio 5: Utilizzo di break e continue 30 | numeri = [1, 2, 3, 4, 5, 6, 7] 31 | for numero in numeri: 32 | if numero == 4: 33 | print("Trovato il 4, interrompo il ciclo con break.") 34 | break # Interrompe il ciclo se numero è 4 35 | elif numero == 2: 36 | print("Trovato il 2, salto il resto di questa iterazione con continue.") 37 | continue # Salta il resto dell'iterazione se numero è 2 38 | print("Numero elaborato:", numero) 39 | 40 | # Esempio 6: Condizioni annidate 41 | # Usiamo condizioni if annidate per verificare più criteri. 42 | a = 5 43 | b = 10 44 | if a < b: 45 | print("\na è minore di b") 46 | if b == 10: 47 | print("b è esattamente 10") 48 | else: 49 | print("a non è minore di b") 50 | 51 | # Esempio 7: Ciclo while con condizione più complessa 52 | # Continuiamo a chiedere un valore finché l'utente non inserisce "stop". 53 | # (Se vuoi provare su un IDE interattivo, decommenta) 54 | """ 55 | valore = "" 56 | while valore != "stop": 57 | valore = input("Digita qualcosa (digita 'stop' per terminare): ") 58 | print("Hai digitato:", valore) 59 | """ 60 | 61 | # Esempio 8: Uso di variabili per contare iterazioni 62 | # Creiamo un ciclo for che itera su una lista e conta quanti elementi superano la soglia. 63 | soglia = 3 64 | valori = [1, 4, 2, 6, 3, 7, 2] 65 | count_superiori = 0 66 | 67 | for v in valori: 68 | if v > soglia: 69 | count_superiori += 1 70 | 71 | print("\nNumero di elementi che superano la soglia di", soglia, ":", count_superiori) 72 | 73 | # Esempio 9: If in linea (One-line if statement) 74 | num = 20 75 | messaggio = "Maggiore di 10" if num > 10 else "Minore o uguale a 10" 76 | print("\nMessaggio:", messaggio) 77 | 78 | # Esempio 10: Cicli for annidati 79 | # Stampiamo le coordinate di una piccola griglia (2x2) 80 | for riga in range(2): 81 | for colonna in range(2): 82 | print(f"Coordinate (riga={riga}, colonna={colonna})") 83 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Decoratori.py: -------------------------------------------------------------------------------- 1 | def decoratore(funzione): 2 | def wrapper(*args, **kwargs): 3 | 4 | 5 | print (*args) 6 | x = args 7 | x +=int(input("inserisci un numero")) 8 | if x > 0: 9 | funzione(x) 10 | else: 11 | print("sei un pippo") 12 | return wrapper 13 | 14 | 15 | 16 | 17 | 18 | 19 | @decoratore 20 | def quadrato(x): 21 | print(x*x) 22 | 23 | @decoratore 24 | def cubo(x): 25 | print(x*x*x) 26 | 27 | quadrato(2) 28 | quadrato(-1) 29 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Ereditarietà.py: -------------------------------------------------------------------------------- 1 | 2 | """ 3 | Esempi unificati di Ereditarietà in Python. 4 | Mostra: 5 | - Classe base e classi derivate 6 | - Overriding di metodi 7 | - Uso di super() 8 | - Ereditarietà multipla 9 | """ 10 | 11 | # ============================================================== 12 | # ESEMPIO 1: CLASSE BASE "Veicolo" E DUE SOTTOCLASSI "Auto" E "Moto" 13 | # ============================================================== 14 | 15 | class Veicolo: 16 | """ 17 | Classe base per i veicoli. 18 | """ 19 | def __init__(self, marca, modello): 20 | self.marca = marca 21 | self.modello = modello 22 | 23 | def accendi_motore(self): 24 | """ 25 | Metodo di base per l'accensione del motore. 26 | """ 27 | return f"Motore di {self.marca} {self.modello} acceso." 28 | 29 | def descrivi(self): 30 | """ 31 | Restituisce una stringa descrittiva del veicolo. 32 | """ 33 | return f"Veicolo di marca {self.marca}, modello {self.modello}" 34 | 35 | class Auto(Veicolo): 36 | """ 37 | Sottoclasse di Veicolo che rappresenta un'automobile. 38 | """ 39 | def __init__(self, marca, modello, porte): 40 | # Richiama il costruttore della classe base 41 | super().__init__(marca, modello) 42 | self.porte = porte 43 | 44 | def accendi_motore(self): 45 | """ 46 | Esempio di overriding del metodo accendi_motore() 47 | """ 48 | base_message = super().accendi_motore() 49 | return base_message + " (Auto) Rumore di un motore a benzina/diesel o elettrico..." 50 | 51 | def descrivi(self): 52 | """ 53 | Sovrascrive descrivi() per aggiungere info sul numero di porte. 54 | """ 55 | return f"Automobile {self.marca} {self.modello} con {self.porte} porte" 56 | 57 | class Moto(Veicolo): 58 | """ 59 | Sottoclasse di Veicolo che rappresenta una motocicletta. 60 | """ 61 | def __init__(self, marca, modello, cilindrata): 62 | super().__init__(marca, modello) 63 | self.cilindrata = cilindrata 64 | 65 | def accendi_motore(self): 66 | return f"Motore della moto {self.marca} {self.modello} acceso! (Cilindrata {self.cilindrata}cc)" 67 | 68 | # ============================================================== 69 | # ESEMPIO 2: FUNZIONE CHE UTILIZZA IL POLIMORFISMO 70 | # ============================================================== 71 | 72 | def avvia_veicolo(veicolo): 73 | """ 74 | Funzione che sfrutta il polimorfismo: richiede un oggetto di tipo 'Veicolo' 75 | (o derivato) e chiama i suoi metodi, senza preoccuparsi di quale sottoclasse sia. 76 | """ 77 | print("Descrizione:", veicolo.descrivi()) 78 | print("Accensione:", veicolo.accendi_motore()) 79 | print("---") 80 | 81 | # ============================================================== 82 | # ESEMPIO 3: EREDITARIETÀ MULTIPLA (SEMPLICE ESEMPIO) 83 | # ============================================================== 84 | 85 | class Elettrico: 86 | """ 87 | Mixin (o classe base separata) per veicoli elettrici. 88 | """ 89 | def ricarica_batteria(self): 90 | return "Batteria in carica..." 91 | 92 | class AutoElettrica(Auto, Elettrico): 93 | """ 94 | Sottoclasse che eredita da Auto e dal mixin Elettrico. 95 | """ 96 | def accendi_motore(self): 97 | # Overriding con comportamento specifico per auto elettrica 98 | base_message = super(Auto, self).accendi_motore() # chiamata su Veicolo 99 | return base_message + " (AutoElettrica) Silenziosa all'accensione!" 100 | 101 | # ============================================================== 102 | # FUNZIONE PRINCIPALE 103 | # ============================================================== 104 | 105 | def main(): 106 | # Creiamo istanze delle varie classi 107 | v = Veicolo("Generico", "Basic") 108 | a = Auto("Fiat", "Punto", 5) 109 | m = Moto("Yamaha", "XMAX", 300) 110 | ae = AutoElettrica("Tesla", "Model 3", 5) 111 | 112 | # Usiamo la funzione polimorfica avvia_veicolo() su ciascuna istanza 113 | print("=== ESEMPIO DI EREDITARIETA' CON VEICOLO, AUTO, MOTO ===") 114 | avvia_veicolo(v) 115 | avvia_veicolo(a) 116 | avvia_veicolo(m) 117 | 118 | print("=== ESEMPIO DI EREDITARIETA' MULTIPLA (AUTO ELETTRICA) ===") 119 | avvia_veicolo(ae) 120 | # Usiamo un metodo definito nella classe Elettrico 121 | print("Ricarica batteria:", ae.ricarica_batteria()) 122 | 123 | # ============================================================== 124 | 125 | if __name__ == "__main__": 126 | main() 127 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Ereditarietà_2.py: -------------------------------------------------------------------------------- 1 | class Base: 2 | def __new__(cls, *args, **kwargs): 3 | # __new__ is called to create a new instance 4 | print(f"Creating instance of {cls.__name__} using __new__") 5 | instance = super().__new__(cls) 6 | return instance 7 | 8 | def __init__(self): 9 | # Standard initializer 10 | print(f"Initializing {self.__class__.__name__}") 11 | 12 | def greet(self): 13 | print("Hello from Base") 14 | 15 | def __init_subclass__(cls, **kwargs): 16 | # Called when a class inherits from Base 17 | print(f"Initializing subclass {cls.__name__} from Base using __init_subclass__") 18 | super().__init_subclass__(**kwargs) 19 | 20 | 21 | class Derived1(Base): 22 | def greet(self): 23 | print("Hello from Derived1") 24 | # Using super() to call the parent class method 25 | super().greet() 26 | 27 | 28 | class Derived2(Base): 29 | def greet(self): 30 | print(" -") 31 | print("Hello from Derived2") 32 | 33 | 34 | 35 | class Combined(Derived1, Derived2): 36 | def greet(self): 37 | print("Hello from Combined") 38 | # This will call the next method in the MRO 39 | super().greet() 40 | 41 | 42 | if __name__ == '__main__': 43 | # Visualizzare il Method Resolution Order (MRO) 44 | print("Method Resolution Order (MRO) per Combined:") 45 | print(Combined.__mro__) 46 | print() 47 | 48 | # Visualizzare le classi base di Derived1 49 | print("Classi base (bases) di Derived1:") 50 | print(Derived1.__bases__) 51 | print() 52 | 53 | # Visualizzare le sottoclassi immediate di Base 54 | print("Sottoclassi immediate di Base:") 55 | print(Base.__subclasses__()) 56 | print() 57 | 58 | # Creare un'istanza della classe Combined che attiva __new__ e __init__ 59 | obj = Combined() 60 | print() 61 | 62 | # Chiamata al metodo greet() che utilizza super() e la MRO 63 | obj.greet() 64 | print() 65 | 66 | # Utilizzo di isinstance e issubclass 67 | print("Verifica con isinstance e issubclass:") 68 | print("obj è un'istanza di Derived1?", isinstance(obj, Derived1)) 69 | print("obj è un'istanza di Base?", isinstance(obj, Base)) 70 | print("Combined è una sottoclasse di Derived2?", issubclass(Combined, Derived2)) 71 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Funzioni.py: -------------------------------------------------------------------------------- 1 | # Esempio 1: Funzione semplice senza parametri e senza return 2 | def saluta(): 3 | 4 | #Questa funzione stampa un saluto. 5 | #Non prende parametri e non restituisce alcun valore. 6 | 7 | print("Ciao! Questa è una funzione che non richiede parametri.") 8 | 9 | # Chiamata della funzione 10 | saluta() 11 | 12 | 13 | 14 | # Esempio 2: Funzione con parametri e return 15 | def somma(x, y): 16 | """ 17 | Questa funzione prende due parametri (x, y), 18 | calcola la somma e restituisce il risultato. 19 | """ 20 | risultato = x + y 21 | return risultato 22 | 23 | # Esempio di utilizzo della funzione 'somma' 24 | valore1 = 5 25 | valore2 = 10 26 | risultato_somma = somma(valore1, valore2) # uguale a scrivere valore 1 + valore 2 27 | print("Somma di", valore1, "e", valore2, "=", risultato_somma) 28 | print (somma(valore1, valore2)) 29 | 30 | 31 | # Esempio 3: Funzione con parametri opzionali (default) 32 | def moltiplica(a, b=2): 33 | """ 34 | Questa funzione moltiplica 'a' e 'b'. 35 | 'b' ha un valore di default di 2. 36 | """ 37 | return a * b 38 | 39 | # Chiamate della funzione 'moltiplica' con e senza parametro opzionale 40 | print("\nMoltiplicazione con parametro opzionale b=2:", moltiplica(3)) 41 | print("Moltiplicazione con b specificato a 4:", moltiplica(3, 4)) 42 | 43 | # e uguale a fare 44 | moltx = moltiplica(2,3) 45 | print(f"il risultato è {moltx}") 46 | # e uguale 47 | print("il risultato è ", moltx) 48 | 49 | risultato2 = moltiplica(moltiplica(3,3) , moltiplica(3,3)) 50 | risultato3=moltiplica(9,9) 51 | risultato2 = moltiplica( moltiplica(2,5) , moltiplica(2,5)) 52 | risultato3 = (10,10) 53 | 54 | 55 | # Esempio 4: Funzione che utilizza condizioni (if-elif-else) 56 | def descrivi_numero(num): 57 | """ 58 | Se num > 0: stampa "Positivo" 59 | Se num < 0: stampa "Negativo" 60 | Altrimenti: stampa "Zero" 61 | """ 62 | if num > 0: 63 | return print("\nIl numero", num, "è Positivo.") 64 | elif num < 0: 65 | return print("\nIl numero", num, "è Negativo.") 66 | else: 67 | return print("\nIl numero è Zero.") 68 | 69 | # Chiamate di esempio 70 | descrivi_numero(10) 71 | descrivi_numero(-5) 72 | descrivi_numero(0) 73 | 74 | 75 | # Esempio 5: Funzione che utilizza un ciclo for 76 | def stampa_lista_elementi(lista_elementi): 77 | """ 78 | Itera su una lista e stampa ogni elemento. 79 | """ 80 | print("\nStampa degli elementi della lista:") 81 | for elem in lista_elementi: 82 | print(" -", elem) 83 | 84 | # Lista di esempio da passare alla funzione 85 | frutti = ["Mela", "Banana", "Ciliegia"] 86 | stampa_lista_elementi(frutti) 87 | 88 | #quindi sono identici i funzionamenti con tutti i tipi 89 | numeri = [1,2,3,4] 90 | stampa_lista_elementi(numeri) 91 | 92 | 93 | # Esempio 6: Funzione che utilizza un ciclo while 94 | def conta_fino_a_n(n): 95 | """ 96 | Conta da 1 fino a n utilizzando un ciclo while e stampa ogni valore. 97 | """ 98 | contatore = 0 99 | print("Conta da 1 fino a ", n) 100 | while contatore <= n: 101 | print(contatore, end=" ") 102 | contatore += 1 103 | print() # Stampa di un a capo finale 104 | 105 | # Chiamata della funzione 106 | conta_fino_a_n(5) 107 | 108 | 109 | # Esempio 7: Funzione che utilizza break e continue 110 | 111 | def cerca_valore(lista_valori, valore_cercato): 112 | """ 113 | Cerca 'valore_cercato' in 'lista_valori'. 114 | Se lo trova, interrompe il ciclo (break). 115 | Salta qualsiasi valore pari (continue), e non lo valuta. 116 | """ 117 | for val in lista_valori: 118 | # Se è un numero pari, continua alla prossima iterazione 119 | if val % 2 == 0: 120 | continue 121 | 122 | if val == valore_cercato: 123 | print(f"\nValore {valore_cercato} trovato, interrompo la ricerca.") 124 | break 125 | else: 126 | print(f"Valore {val} non è quello cercato.") 127 | 128 | # Chiamata della funzione con un esempio 129 | numeri = [2, 4, 5, 7, 11, 12, 13] 130 | cerca_valore(numeri, 11) 131 | 132 | 133 | # Esempio 8: Funzione con cicli annidati 134 | def stampa_tabella_moltiplicazione(dim): 135 | """ 136 | Stampa la tabella di moltiplicazione da 1 a 'dim'. 137 | Utilizza cicli for annidati. 138 | """ 139 | print(f"\nTabella di moltiplicazione 1x{dim}:") 140 | for i in range(1, dim+1): 141 | for j in range(1, dim+1): 142 | print(f"{i*j:4d}", end="") # Formattazione per allineare i risultati 143 | print() # A capo dopo ogni riga 144 | 145 | # Chiamata della funzione 146 | stampa_tabella_moltiplicazione(5) 147 | 148 | 149 | # Esempio 9: Funzione ricorsiva (facoltativo, mostra un uso particolare delle funzioni) 150 | def fattoriale(n): 151 | """ 152 | Calcola il fattoriale di 'n' ricorsivamente. 153 | n! = n * (n-1) * (n-2) * ... * 1 154 | """ 155 | if n <= 1: 156 | return 1 157 | else: 158 | return n * fattoriale(n - 1) 159 | 160 | # Chiamata della funzione ricorsiva 161 | numero = 5 162 | print(f"\nFattoriale di {numero}:", fattoriale(numero)) 163 | 164 | 165 | 166 | 167 | def quadrato_iterno(n): 168 | risultato = n*n 169 | print(risultato) 170 | 171 | 172 | def quadrato(n): 173 | return n*n 174 | 175 | 176 | num = int(input()) 177 | quadrato(num) 178 | 179 | def quadrato2(): 180 | x= int(input()) 181 | return x*x 182 | 183 | print(quadrato()) 184 | 185 | def cubo(n): 186 | return n*n*n 187 | 188 | 189 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Incapsulamento.py: -------------------------------------------------------------------------------- 1 | class Encapsulated: 2 | def __init__(self, name, age): 3 | # Imposta gli attributi interni 4 | self._name = name 5 | self._age = age 6 | 7 | def __getattribute__(self, attr): 8 | # Intercetta ogni accesso agli attributi 9 | print(f"__getattribute__: Accesso a '{attr}'") 10 | return object.__getattribute__(self, attr) 11 | 12 | def __getattr__(self, attr): 13 | # Chiamato solo se l'attributo non esiste 14 | print(f"__getattr__: '{attr}' non trovato, restituisco None") 15 | return None 16 | 17 | def __setattr__(self, attr, value): 18 | # Controlla ogni assegnazione agli attributi 19 | print(f"__setattr__: Impostazione di '{attr}' a {value}") 20 | object.__setattr__(self, attr, value) 21 | 22 | def __delattr__(self, attr): 23 | # Controlla l'eliminazione degli attributi 24 | print(f"__delattr__: Eliminazione dell'attributo '{attr}'") 25 | object.__delattr__(self, attr) 26 | 27 | @property 28 | def name(self): 29 | # Getter per la proprietà 'name' 30 | print("property getter: Recupero 'name'") 31 | return self._name 32 | 33 | @name.setter 34 | def name(self, value): 35 | # Setter per la proprietà 'name' 36 | print("property setter: Imposto 'name' a", value) 37 | self._name = value 38 | 39 | @name.deleter 40 | def name(self): 41 | # Deleter per la proprietà 'name' 42 | print("property deleter: Eliminazione di 'name'") 43 | del self._name 44 | 45 | 46 | if __name__ == '__main__': 47 | print("Creazione dell'oggetto Encapsulated:") 48 | obj = Encapsulated("Alice", 30) 49 | print() 50 | 51 | # Accesso diretto tramite property e attributo 52 | print("Accesso a 'name' tramite property:") 53 | print(obj.name) # Attiva __getattribute__ e il getter della property 54 | print() 55 | 56 | print("Accesso diretto a '_age':") 57 | print(obj._age) # Attiva __getattribute__ 58 | print() 59 | 60 | # Accesso ad un attributo inesistente per attivare __getattr__ 61 | print("Tentativo di accesso a 'salary' (non esistente):") 62 | print(obj.salary) 63 | print() 64 | 65 | # Uso dei built-in getattr, setattr, hasattr, delattr 66 | print("Uso di hasattr per 'name':", hasattr(obj, "name")) 67 | print("Uso di getattr per 'name':", getattr(obj, "name")) 68 | print() 69 | 70 | print("Uso di setattr per aggiornare 'name' a 'Bob':") 71 | setattr(obj, "name", "Bob") # Attiva __setattr__ e il setter della property 72 | print("Nome aggiornato:", obj.name) 73 | print() 74 | 75 | print("Uso di delattr per eliminare l'attributo '_age':") 76 | delattr(obj, "_age") # Attiva __delattr__ 77 | print("Tentativo di accesso a '_age' dopo eliminazione:", 78 | getattr(obj, "_age", "Non trovato")) 79 | print() 80 | 81 | print("Uso del deleter della property 'name':") 82 | del obj.name # Attiva il deleter della property, e di conseguenza __delattr__ 83 | print("Tentativo di accesso a 'name' dopo eliminazione:", 84 | getattr(obj, "name", "Non trovato")) 85 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Incapsulamento2.py: -------------------------------------------------------------------------------- 1 | 2 | """ 3 | Esempi unificati di incapsulamento in Python: 4 | - attributi 'privati' tramite convenzione (_ e __) 5 | - uso di property (getter e setter) 6 | - metodi pubblici vs metodi 'nascosti' 7 | """ 8 | 9 | # ============================================================== 10 | # ESEMPIO 1: PERSONA CON ATTRIBUTE MANGEMENT (GETTER, SETTER) 11 | # ============================================================== 12 | 13 | class Persona: 14 | """ 15 | Classe che dimostra un uso "classico" dell'incapsulamento in Python 16 | con getter e setter, tramite property. 17 | """ 18 | def __init__(self, nome, eta): 19 | self._nome = nome # Convenzione: attributo "protetto" 20 | self._eta = eta # Convenzione: attributo "protetto" 21 | 22 | @property 23 | def nome(self): 24 | """ 25 | Getter per il nome (uso della property). 26 | """ 27 | return self._nome 28 | 29 | @nome.setter 30 | def nome(self, nuovo_nome): 31 | """ 32 | Setter per il nome (uso della property). 33 | Qui possiamo aggiungere logiche di validazione. 34 | """ 35 | if not nuovo_nome: 36 | raise ValueError("Il nome non può essere vuoto.") 37 | self._nome = nuovo_nome 38 | 39 | @property 40 | def eta(self): 41 | """ 42 | Getter per l'età (property). 43 | """ 44 | return self._eta 45 | 46 | @eta.setter 47 | def eta(self, nuova_eta): 48 | """ 49 | Setter per l'età. 50 | """ 51 | if nuova_eta <= 0: 52 | raise ValueError("L'età non può essere negativa.") 53 | self._eta = nuova_eta 54 | 55 | def descrivi(self): 56 | """ 57 | Metodo pubblico per descrivere la Persona. 58 | """ 59 | return f"Persona: {self._nome}, età: {self._eta}" 60 | 61 | 62 | # ============================================================== 63 | # ESEMPIO 2: CONTO BANCARIO CON INCAPSULAMENTO 64 | # ============================================================== 65 | 66 | class ContoBancario: 67 | """ 68 | Classe che illustra l'uso del double underscore per "nascondere" 69 | effettivamente un attributo, e l'uso di metodi pubblici 70 | per controllarne l'accesso. 71 | """ 72 | def __init__(self, intestatario, saldo_iniziale=0.0): 73 | self.intestatario = intestatario 74 | # Double underscore: Python "offusca" (name mangling) l'attributo 75 | self.__saldo = saldo_iniziale 76 | 77 | def deposita(self, importo): 78 | if importo <= 0: 79 | raise ValueError("L'importo da depositare deve essere positivo.") 80 | self.__saldo += importo 81 | 82 | def preleva(self, importo): 83 | if importo <= 0: 84 | raise ValueError("L'importo da prelevare deve essere positivo.") 85 | if importo > self.__saldo: 86 | raise ValueError("Saldo insufficiente per il prelievo.") 87 | self.__saldo -= importo 88 | 89 | def get_saldo(self): 90 | """ 91 | Metodo pubblico per leggere il saldo, senza dare 92 | accesso diretto all'attributo interno __saldo. 93 | """ 94 | return self.__saldo 95 | 96 | def descrivi(self): 97 | return f"Conto di {self.intestatario}, saldo: {self.__saldo:.2f} €" 98 | 99 | def _metodo_interno(self): 100 | """ 101 | Convenzione di underscore singolo per indicare 102 | un metodo "interno" (non pensato per l'uso esterno). 103 | """ 104 | # In pratica non viene impedito l'accesso, 105 | # ma è una convenzione d'uso. 106 | return "Metodo 'interno' di ContoBancario." + self.__metodo_interno2() 107 | 108 | def __metodo_interno2(self): 109 | """ 110 | Convenzione di underscore singolo per indicare 111 | un metodo "interno" (non pensato per l'uso esterno). 112 | """ 113 | # In pratica non viene impedito l'accesso, 114 | # ma è una convenzione d'uso. 115 | return "Metodo 'interno' di ContoBancario." 116 | 117 | 118 | # ============================================================== 119 | # ESEMPIO 3: UTILIZZO DI GETTER, SETTER E ATTRIBUTI 'PRIVATI' 120 | # ============================================================== 121 | 122 | def main(): 123 | print("=== ESEMPIO 1: INCAPSULAMENTO IN 'Persona' CON PROPERTY ===") 124 | p = Persona("Mario", 30) 125 | print(p.descrivi()) 126 | 127 | # Modifichiamo attributi tramite property 128 | p.nome = "Luigi" 129 | p.eta = 40 130 | print("Dopo aggiornamento property:", p.descrivi()) 131 | 132 | # Se proviamo a impostare un valore scorretto, otteniamo un ValueError 133 | try: 134 | p.eta = -10 135 | except ValueError as e: 136 | print("Errore nell'impostazione di eta:", e) 137 | 138 | print("\n=== ESEMPIO 2: CONTO BANCARIO CON __saldo PRIVATO ===") 139 | conto = ContoBancario("Anna", 1000.0) 140 | print(conto.descrivi()) 141 | 142 | # Depositare una somma 143 | conto.deposita(500) 144 | print("Dopo deposito di 500:", conto.descrivi()) 145 | 146 | # Prelevare una somma 147 | conto.preleva(300) 148 | print("Dopo prelievo di 300:", conto.descrivi()) 149 | 150 | # Accesso al saldo tramite metodo apposito 151 | print("Saldo attuale (via get_saldo()):", conto.get_saldo()) 152 | 153 | # Tentativo di accedere direttamente a __saldo: non esiste come attributo pubblico 154 | # print(conto.__saldo) # -> causerebbe un AttributeError 155 | # Python lo rende disponibile come _ContoBancario__saldo in maniera "nascosta" 156 | 157 | # Esempio di chiamata ad un metodo "interno" 158 | # convenzione _metodo_interno (non impedisce l'accesso, ma sconsiglia di usarlo) 159 | interno = conto._metodo_interno() 160 | print("Chiamata al metodo interno:", interno) 161 | 162 | 163 | if __name__ == "__main__": 164 | main() 165 | -------------------------------------------------------------------------------- /Esempi _codice/Es_NumPY_1.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | 3 | # Creazione di un array unidimensionale 4 | array_1d = np.array([1, 2, 3, 4, 5]) 5 | print("Array unidimensionale:", array_1d) 6 | 7 | # Creazione di un array bidimensionale 8 | array_2d = np.array([[1, 2, 3], [4, 5, 6]]) 9 | print("Array bidimensionale:", array_2d) 10 | 11 | 12 | # np.arange è utilizzato per generare array con valori in un intervallo specificato. 13 | # Array da 0 a 9 14 | array_range = np.arange(10) 15 | print("Array da 0 a 9:", array_range) 16 | 17 | # Array da 10 a 20 con step di 2 18 | array_step = np.arange(10, 20, 2) 19 | print("Array da 10 a 20 con step di 2:", array_step) 20 | 21 | 22 | # np.reshape permette di cambiare la forma di un array esistente senza cambiare i suoi dati. 23 | # Reshape di un array 1D in un array 2D (2 righe, 5 colonne) 24 | array_1d = np.arange(10) 25 | array_reshaped = array_1d.reshape((2, 5)) 26 | print("Array reshape da 1D a 2D:", array_reshaped) 27 | 28 | # Reshape automatico con -1 29 | array_reshaped_auto = array_1d.reshape((-1, 2)) 30 | print("Array reshape con -1 per inferire automaticamente le dimensioni:", array_reshaped_auto) 31 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Numpy_1.5.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | 3 | # Creazione di un array con valori mancanti (NaN) 4 | data = np.array([1, 2, np.nan, 4, 5, np.nan, 7]) 5 | 6 | # Rimozione dei valori mancanti 7 | clean_data = data[~np.isnan(data)] 8 | print("Dati puliti:", clean_data) # Output: [1. 2. 4. 5. 7.] 9 | 10 | 11 | import numpy as np 12 | 13 | # Creazione di un array di dati 14 | data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) 15 | 16 | # Definizione della finestra per la media mobile 17 | window_size = 3 18 | 19 | # Calcolo della media mobile 20 | moving_average = np.convolve(data, np.ones(window_size)/window_size, mode='valid') 21 | print("Media mobile:", moving_average) # Output: [2. 3. 4. 5. 6. 7. 8.] 22 | 23 | 24 | import numpy as np 25 | 26 | # Creazione di un segnale con due frequenze 27 | t = np.linspace(0, 1, 500) 28 | signal = np.sin(2 * np.pi * 5 * t) + np.sin(2 * np.pi * 20 * t) 29 | 30 | # Calcolo della Trasformata di Fourier 31 | fft_signal = np.fft.fft(signal) 32 | 33 | # Frequenze associate 34 | freqs = np.fft.fftfreq(len(fft_signal)) 35 | 36 | print("Trasformata di Fourier:", fft_signal) 37 | print("Frequenze associate:", freqs) 38 | 39 | 40 | import numpy as np 41 | 42 | # Numero di simulazioni 43 | num_simulations = 10000 44 | 45 | # Generazione di rendimenti giornalieri casuali 46 | daily_returns = np.random.normal(0, 0.01, num_simulations) 47 | 48 | # Simulazione del valore finale di un investimento iniziale 49 | initial_investment = 1000 50 | final_value = initial_investment * np.cumprod(1 + daily_returns) 51 | 52 | print("Valore finale simulato dell'investimento:", final_value[-1]) 53 | 54 | 55 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Polimorfimso.py: -------------------------------------------------------------------------------- 1 | """ 2 | Esempio unificato di polimorfismo in Python: 3 | - Polimorfismo tramite ereditarietà (classe base Animale e sottoclassi Cane, Gatto) 4 | - Polimorfismo con operator overloading (__add__) nella classe Contatore 5 | - Polimorfismo "duck typing" con funzioni che accettano oggetti di tipo diverso 6 | """ 7 | 8 | # ============================================================== 9 | # ESEMPIO 1: POLIMORFISMO CON EREDITARIETÀ (Animale, Cane, Gatto) 10 | # ============================================================== 11 | 12 | class Animale: 13 | """ 14 | Classe base (genitore) per tutti i tipi di animali. 15 | Definisce un metodo 'verso' e un metodo 'descrivi', 16 | pensati per essere sovrascritti dalle sottoclassi. 17 | """ 18 | def __init__(self, nome): 19 | self.nome = nome 20 | 21 | def verso(self): 22 | """ 23 | Metodo 'placeholder': verrà implementato dalle sottoclassi 24 | con suoni diversi ('Bau!', 'Miao!', ecc.). 25 | """ 26 | raise NotImplementedError("Questo metodo deve essere implementato dalla sottoclasse.") 27 | 28 | def descrivi(self): 29 | """ 30 | Descrizione generica di un animale. 31 | """ 32 | return f"Animale di nome {self.nome}" 33 | 34 | class Cane(Animale): 35 | """ 36 | Sottoclasse di Animale che rappresenta un Cane. 37 | """ 38 | def verso(self): 39 | return "Bau!" 40 | 41 | def descrivi(self): 42 | return f"Sono un Cane, mi chiamo {self.nome}" 43 | 44 | class Gatto(Animale): 45 | """ 46 | Sottoclasse di Animale che rappresenta un Gatto. 47 | """ 48 | def verso(self): 49 | return "Miao!" 50 | 51 | def descrivi(self): 52 | return f"Sono un Gatto, mi chiamo {self.nome}" 53 | 54 | def fai_parlare_animali(animali): 55 | """ 56 | Funzione che prende una lista di oggetti di tipo 'Animale' (o derivati) 57 | e invoca i loro metodi in modo polimorfico. 58 | """ 59 | for animale in animali: 60 | print(animale.descrivi()) 61 | print("Il verso che faccio:", animale.verso()) 62 | print("---") 63 | 64 | 65 | # ============================================================== 66 | # ESEMPIO 2: POLIMORFISMO CON OPERATOR OVERLOADING (__add__) 67 | # ============================================================== 68 | 69 | class Contatore: 70 | """ 71 | Classe che mostra il polimorfismo con operator overloading. 72 | Ridefinisce __add__ per gestire la somma con altri Contatore o numeri. 73 | """ 74 | def __init__(self, valore=0): 75 | self.valore = valore 76 | 77 | def __add__(self, altro): 78 | """ 79 | Permette l'uso di 'c1 + c2' o 'c1 + numero'. 80 | """ 81 | if isinstance(altro, Contatore): 82 | # Sommiamo i valori di entrambi i contatori 83 | return Contatore(self.valore + altro.valore) 84 | elif isinstance(altro, (int, float)): 85 | # Sommiamo il valore del contatore con un numero 86 | return Contatore(self.valore + altro) 87 | else: 88 | raise TypeError(f"Operatore + non supportato tra Contatore e {type(altro)}") 89 | 90 | def __str__(self): 91 | return f"Contatore({self.valore})" 92 | 93 | def esempio_operator_overloading(): 94 | """ 95 | Esempio pratico di come l'overloading (__add__) permetta 96 | a Contatore di comportarsi in modo polimorfico con diversi tipi. 97 | """ 98 | c1 = Contatore(10) 99 | c2 = Contatore(5) 100 | c3 = c1 + c2 # Somma tra due Contatore 101 | c4 = c3 + 100 # Somma tra Contatore e un intero 102 | #c5 = c3 + "100" # Somma errata non consetita 103 | print("c1:", c1) 104 | print("c2:", c2) 105 | print("c1 + c2 =", c3) 106 | print("c3 + 100 =", c4) 107 | #print("c5", c5) 108 | 109 | 110 | 111 | # ============================================================== 112 | # ESEMPIO 3: POLIMORFISMO "DUCK TYPING" 113 | # ============================================================== 114 | 115 | def somma_elementi(iterabile): 116 | """ 117 | Funzione che cerca di "sommare" tutti gli elementi di un iterabile 118 | (lista, tupla, stringa - in cui avviene concatenazione -, ecc.). 119 | Questo è un esempio di duck typing: 120 | se gli oggetti in 'iterabile' supportano l'operatore '+', la funzione funziona. 121 | """ 122 | risultato = None 123 | for elem in iterabile: 124 | if risultato is None: 125 | risultato = elem 126 | else: 127 | risultato += elem 128 | return risultato 129 | 130 | def esempio_duck_typing(): 131 | """ 132 | Esempio di come la funzione 'somma_elementi' 133 | si comporta in modo polimorfico a seconda degli oggetti. 134 | """ 135 | numeri = [1, 2, 3, 4] 136 | testo_list = ["Hello", " ", "World", "!"] 137 | stringa = "ABC" # Ogni carattere sarà 'sommato' (concatenato) 138 | 139 | print("\nSomma elementi in list di interi:", numeri, "->", somma_elementi(numeri)) 140 | print("Somma elementi in list di stringhe:", testo_list, "->", somma_elementi(testo_list)) 141 | print("Somma (concatenazione) dei caratteri in:", stringa, "->", somma_elementi(stringa)) 142 | 143 | 144 | # ============================================================== 145 | # FUNZIONE PRINCIPALE 146 | # ============================================================== 147 | 148 | def main(): 149 | # Esempio 1: Polimorfismo con ereditarietà 150 | print("=== ESEMPIO 1: POLIMORFISMO CON EREDITARIETA' (Animale, Cane, Gatto) ===") 151 | lista_animali = [ 152 | Cane("Fido"), 153 | Gatto("Micio"), 154 | Cane("Rex") 155 | ] 156 | fai_parlare_animali(lista_animali) 157 | 158 | # Sammy = Cane("Samantha") 159 | fai_parlare_animali([Sammy]) 160 | 161 | # Esempio 2: Operator overloading con Contatore 162 | print("\n=== ESEMPIO 2: POLIMORFISMO CON OPERATOR OVERLOADING (Contatore) ===") 163 | esempio_operator_overloading() 164 | 165 | # Esempio 3: Duck typing 166 | print("\n=== ESEMPIO 3: POLIMORFISMO 'DUCK TYPING' ===") 167 | esempio_duck_typing() 168 | 169 | if __name__ == "__main__": 170 | main() 171 | -------------------------------------------------------------------------------- /Esempi _codice/Es_Strutture_dati.py: -------------------------------------------------------------------------------- 1 | """ 2 | Esempi unificati di strutture dati in Python: 3 | - Liste 4 | - Tuple 5 | - Set 6 | - Dizionari 7 | - Condizioni e cicli 8 | - Funzioni 9 | """ 10 | 11 | def esempi_liste(): 12 | """ 13 | Mostra varie operazioni su liste: 14 | creazione, aggiunta, rimozione, slicing, cicli, etc. 15 | """ 16 | print("=== LISTE ===") 17 | # Creazione di una lista 18 | numeri = [1, 2, 3, 4] 19 | parole = ["mirko","mirko","mirko"] 20 | misto =["mirko", 13, True, 13.23 ] 21 | vuota = [] 22 | 23 | print("Lista Stringhe:", parole) 24 | print("Lista Misto:", misto) 25 | print("Lista iniziale:", numeri) 26 | 27 | # Aggiunta di un elemento alla fine (append) 28 | numeri.append(5) 29 | vuota.append(1) 30 | print("Dopo append(5):", numeri) 31 | 32 | # Inserimento in posizione specifica (insert) 33 | numeri.insert(2, 99) 34 | print("Dopo insert(2, 99):", numeri) 35 | 36 | # Rimozione di un elemento tramite valore (remove) 37 | numeri.remove(99) 38 | print("Dopo remove(99):", numeri) 39 | 40 | # Rimozione dell'ultimo elemento (pop) 41 | ultimo = numeri.pop() 42 | print(f"Dopo pop() -> elemento rimosso: {ultimo}, lista:", numeri) 43 | 44 | # Slicing 45 | # numeri[inizio:fine] => sotto-lista dall'indice 'inizio' fino a 'fine-1' 46 | print("Slicing numeri[0:2]:", numeri[0:2]) 47 | 48 | # Iterazione su lista 49 | print("Iterazione sui valori di 'numeri':") 50 | for val in numeri: 51 | print(" -", val) 52 | 53 | # List comprehension: creiamo una lista di quadrati 54 | quadrati = [x*x for x in numeri] 55 | print("Quadrati dei numeri:", quadrati) 56 | 57 | 58 | def esempi_tuple(): 59 | """ 60 | Mostra operazioni con tuple (immutabili). 61 | """ 62 | print("\n=== TUPLE ===") 63 | # Creazione di una tupla 64 | coordinate = (10, 20) 65 | print("Tupla coordinate:", coordinate) 66 | print("Primo elemento:", coordinate[0]) 67 | print("Secondo elemento:", coordinate[1]) 68 | 69 | # Le tuple sono immutabili, non si può fare coordinate[0] = 100 70 | # coordinate[0] = 100 -> ERRORE 71 | 72 | # Possiamo iterare su una tupla come su una lista 73 | print("Iterazione sulla tupla:") 74 | for val in coordinate: 75 | print(" -", val) 76 | 77 | # Possiamo "spacchettare" (unpack) una tupla in più variabili 78 | x, y = coordinate 79 | print(f"x = {x}, y = {y}") 80 | 81 | 82 | def esempi_set(): 83 | """ 84 | Mostra operazioni con i set (insiemi) in Python. 85 | """ 86 | print("\n=== SET ===") 87 | # Creazione di un set 88 | lettere = {'a', 'b', 'c', 'a'} # 'a' è duplicato, verrà ignorato 89 | print("Set iniziale (duplicati rimossi):", lettere) 90 | 91 | # Aggiunta di un elemento 92 | lettere.add('d') 93 | print("Dopo add('d'):", lettere) 94 | 95 | # Rimozione di un elemento (se esiste) 96 | lettere.discard('b') 97 | print("Dopo discard('b'):", lettere) 98 | 99 | # Verifica se un elemento è nel set 100 | if 'c' in lettere: 101 | print("L'elemento 'c' è nel set") 102 | else: 103 | print("L'elemento 'c' non è nel set") 104 | 105 | # Operazioni di unione, intersezione, differenza 106 | set1 = {1, 2, 3} 107 | set2 = {3, 4, 5} 108 | unione = set1.union(set2) # {1, 2, 3, 4, 5} 109 | intersezione = set1.intersection(set2) # {3} 110 | differenza = set1.difference(set2) # {1, 2} 111 | differenza2 = set2.difference(set1) # {4, 5} 112 | 113 | print("Set1:", set1) 114 | print("Set2:", set2) 115 | print("Unione:", unione) 116 | print("Intersezione:", intersezione) 117 | print("Differenza:", differenza) 118 | print("Differenza 2:", differenza2) 119 | 120 | 121 | def esempi_dizionari(): 122 | """ 123 | Mostra operazioni con i dizionari: 124 | creazione, accesso, aggiunta, rimozione, cicli, etc. 125 | """ 126 | print("\n=== DIZIONARI ===") 127 | # Creazione di un dizionario 128 | persona = { 129 | "nome": "Mario", 130 | "eta": 30, 131 | "citta": "Roma" 132 | # qui si aggiungono nuovi elementi 133 | } 134 | print("Dizionario persona:", persona) 135 | 136 | # Accesso ai valori 137 | print("Nome:", persona["nome"]) 138 | print("Età:", persona["eta"]) 139 | 140 | # Aggiunta/aggiornamento di una chiave 141 | persona["professione"] = "Ingegnere" 142 | print("Dopo aggiunta 'professione':", persona) 143 | 144 | # Rimozione di una chiave 145 | del persona["citta"] 146 | print("Dopo rimozione 'citta':", persona) 147 | 148 | # Verifica se una chiave esiste 149 | if "eta" in persona: 150 | print("La chiave 'eta' esiste nel dizionario.") 151 | 152 | # Iterazione su chiavi e valori 153 | for chiave, valore in persona.items(): 154 | print(f" - Chiave: {chiave}, Valore: {valore}") 155 | 156 | # Esempio di dizionario annidato 157 | rubrica = { 158 | "contatto1": { 159 | "nome": "Luigi", 160 | "numero": "123456789" 161 | }, 162 | "contatto2": { 163 | "nome": "Anna", 164 | "numero": "987654321" 165 | } 166 | } 167 | print("\nRubrica annidata:", rubrica) 168 | 169 | # Iterazione su dizionario di dizionari 170 | for contatto_id, dati in rubrica.items(): 171 | print(f"Contatto: {contatto_id}") 172 | for k, v in dati.items(): 173 | print(f" {k.capitalize()}: {v}") 174 | 175 | 176 | def main(): 177 | """ 178 | Funzione principale che chiama le varie sezioni di esempio. 179 | """ 180 | #esempi_liste() 181 | #esempi_tuple() 182 | esempi_set() 183 | #esempi_dizionari() 184 | 185 | 186 | if __name__ == "__main__": 187 | main() 188 | -------------------------------------------------------------------------------- /Esempi _codice/Es_TryExcp.py: -------------------------------------------------------------------------------- 1 | def leggi_file_e_dividi(nome_file, divisore): 2 | """ 3 | Questa funzione tenta di: 4 | 1) Aprire un file e leggerne il contenuto come numero. 5 | 2) Dividere quel numero per un divisore passato come parametro. 6 | Gestisce possibili errori di I/O e di divisione per zero. 7 | """ 8 | try: 9 | # Provo ad aprire il file in modalità lettura di testo 10 | with open(nome_file, 'r') as f: 11 | contenuto = f.read().strip() # Leggo tutto e tolgo eventuali spazi 12 | numero = float(contenuto) # Converto la stringa in numero float 13 | 14 | # Provo a dividere il numero per il divisore 15 | risultato = numero / divisore 16 | 17 | except FileNotFoundError as e: 18 | # Questo blocco viene eseguito se il file non esiste 19 | print(f"Errore: il file '{nome_file}' non è stato trovato.") 20 | return None 21 | 22 | except ValueError as e: 23 | # Se la conversione in float fallisce (es. contenuto non numerico) 24 | print(f"Errore: contenuto del file non valido per la conversione a numero ({e}).") 25 | return None 26 | 27 | except ZeroDivisionError as e: 28 | # Gestione specifica della divisione per zero 29 | print("Errore: non posso dividere per zero!") 30 | return None 31 | 32 | except Exception as e: 33 | # Blocco generico per qualsiasi altra eccezione non prevista 34 | print(f"Si è verificato un errore inatteso: {e}") 35 | return None 36 | 37 | else: 38 | # Questo blocco viene eseguito solo se non ci sono state eccezioni 39 | print(f"Divisione completata con successo: {numero} / {divisore} = {risultato}") 40 | return risultato 41 | 42 | finally: 43 | # Viene sempre eseguito, sia che l’operazione abbia avuto successo, sia che ci sia stato un errore 44 | print("Fine della funzione leggi_file_e_dividi.") 45 | 46 | # --- Esempio di utilizzo --- 47 | if __name__ == "__main__": 48 | # Caso 1: file esistente, numero valido, divisore diverso da zero 49 | leggi_file_e_dividi("dati.txt", 2) 50 | 51 | # Caso 2: file inesistente 52 | leggi_file_e_dividi("non_esiste.txt", 5) 53 | 54 | # Caso 3: file presente ma contenuto non numerico 55 | leggi_file_e_dividi("stringa.txt", 3) 56 | 57 | # Caso 4: tentativo di divisione per zero 58 | leggi_file_e_dividi("dati.txt", 0) 59 | -------------------------------------------------------------------------------- /Esempi _codice/Es_mio_modulo.py: -------------------------------------------------------------------------------- 1 | x = 10 2 | 3 | def somma(z,y): 4 | return x + y + z 5 | 6 | class Prova(): 7 | pass 8 | -------------------------------------------------------------------------------- /Esempi _codice/Es_moduli.py: -------------------------------------------------------------------------------- 1 | import mio_modulo as mm 2 | 3 | print(mm.x) 4 | 5 | copia_di_x = mm.x 6 | nuova_variabile = mm.somma(5,5) 7 | 8 | somma = mm.somma(5,6) 9 | print(somma) 10 | 11 | 12 | Esempio_oggetto = mm.Prova() 13 | -------------------------------------------------------------------------------- /Esempi _codice/Es_personalizzazione_grafici_Matplot.py: -------------------------------------------------------------------------------- 1 | import matplotlib.pyplot as plt 2 | import numpy as np 3 | 4 | # Generiamo dati di esempio 5 | x = np.linspace(0, 10, 100) 6 | y = np.sin(x) 7 | 8 | # Creiamo il grafico 9 | plt.figure(figsize=(8, 4)) # imposta la dimensione della figura (larghezza, altezza) 10 | plt.plot(x, y) # disegna y in funzione di x 11 | plt.title("Grafico di sin(x)") # titolo del grafico 12 | plt.xlabel("Asse X") # etichetta asse X 13 | plt.ylabel("Asse Y") # etichetta asse Y 14 | plt.grid(True) # mostra la griglia 15 | plt.show() # visualizza il grafico 16 | 17 | 18 | ---------------------------------------------------------------------------- 19 | 20 | import matplotlib.pyplot as plt 21 | 22 | # Dati di esempio 23 | x = [1, 2, 3, 4, 5] 24 | y1 = [2, 3, 5, 7, 11] # serie 1 25 | y2 = [1, 4, 6, 8, 9] # serie 2 26 | 27 | plt.figure(figsize=(6, 4)) 28 | 29 | # Serie 1: linea rossa tratteggiata con marker a cerchio 30 | plt.plot(x, y1, 31 | color='red', # colore linea 32 | linestyle='--', # stile linea (tratteggiata) 33 | marker='o', # marker a cerchio 34 | label='Serie 1') # etichetta per la legenda 35 | 36 | # Serie 2: linea blu continua con marker a quadrato 37 | plt.plot(x, y2, 38 | color='blue', 39 | linestyle='-', 40 | marker='s', # marker a quadrato 41 | label='Serie 2') 42 | 43 | plt.title("Confronto Serie 1 e Serie 2") 44 | plt.xlabel("Indice") 45 | plt.ylabel("Valore") 46 | plt.legend(loc='upper left') # posiziona la legenda in alto a sinistra 47 | plt.grid(linestyle=':') # griglia punteggiata 48 | plt.tight_layout() # ottimizza spaziatura 49 | plt.show() 50 | 51 | 52 | 53 | ---------------------------------------------------------------------------- 54 | 55 | 56 | import matplotlib.pyplot as plt 57 | import numpy as np 58 | 59 | t = np.linspace(0, 2*np.pi, 200) 60 | 61 | # Creiamo una figura con 2 righe e 1 colonna di subplot 62 | fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 6), sharex=True) 63 | 64 | # Primo subplot: seno 65 | ax1.plot(t, np.sin(t), color='purple') 66 | ax1.set_title("Funzione seno") 67 | ax1.grid(True) 68 | 69 | # Secondo subplot: coseno 70 | ax2.plot(t, np.cos(t), color='green') 71 | ax2.set_title("Funzione coseno") 72 | ax2.set_xlabel("Angolo (rad)") 73 | ax2.grid(True) 74 | 75 | plt.tight_layout() 76 | plt.show() 77 | 78 | 79 | ---------------------------------------------------------------------------- 80 | 81 | 82 | 83 | import matplotlib.pyplot as plt 84 | import numpy as np 85 | 86 | # Modifichiamo i parametri globali di matplotlib 87 | plt.rcParams['font.size'] = 12 # dimensione font di default 88 | plt.rcParams['font.family'] = 'serif' # famiglia di font 89 | plt.rcParams['axes.titlesize'] = 14 # dimensione del titolo degli assi 90 | plt.rcParams['axes.labelsize'] = 12 # dimensione delle etichette degli assi 91 | plt.rcParams['lines.linewidth'] = 2 # spessore linea di default 92 | plt.rcParams['lines.markersize'] = 8 # dimensione marker di default 93 | 94 | # Dati di esempio 95 | x = np.linspace(0, 4*np.pi, 100) 96 | y = np.sin(x) * np.exp(-x/10) 97 | 98 | plt.figure(figsize=(7,4)) 99 | plt.plot(x, y, marker='D', label='sin(x)·exp(-x/10)') 100 | plt.title("Damping della sinusoide") 101 | plt.xlabel("x") 102 | plt.ylabel("y") 103 | plt.legend() 104 | plt.grid(True) 105 | plt.show() 106 | 107 | 108 | ---------------------------------------------------------------------------- 109 | 110 | 111 | 112 | import matplotlib.pyplot as plt 113 | import numpy as np 114 | 115 | # Dati 116 | x = np.linspace(0, 2*np.pi, 50) 117 | y = np.sin(x) 118 | 119 | plt.figure(figsize=(6,4)) 120 | plt.plot(x, y, label='sin(x)') 121 | 122 | # Punto di massimo 123 | max_idx = np.argmax(y) 124 | x_max, y_max = x[max_idx], y[max_idx] 125 | plt.scatter([x_max], [y_max], color='red') # evidenziamo il punto 126 | plt.annotate("Massimo locale", 127 | xy=(x_max, y_max), # coordinate del punto 128 | xytext=(x_max+0.5, y_max-0.3), # posizione del testo 129 | arrowprops=dict(arrowstyle="->", lw=1.5)) # freccia 130 | 131 | plt.title("Annotazione di un punto critico") 132 | plt.xlabel("x") 133 | plt.ylabel("sin(x)") 134 | plt.legend() 135 | plt.grid(True) 136 | plt.show() 137 | 138 | -------------------------------------------------------------------------------- /Esempi _codice/Es_personalizzazione_grafici_Seaborn.py: -------------------------------------------------------------------------------- 1 | import seaborn as sns 2 | import numpy as np 3 | import matplotlib.pyplot as plt 4 | 5 | # Impostiamo uno stile seaborn 6 | sns.set_theme(style="darkgrid") 7 | 8 | # Generiamo dati di esempio 9 | x = np.linspace(0, 10, 100) 10 | y = np.sin(x) 11 | 12 | # Creiamo il grafico 13 | plt.figure(figsize=(8, 4)) 14 | sns.lineplot(x=x, y=y) 15 | plt.title("Grafico di sin(x) con seaborn") 16 | plt.xlabel("Asse X") 17 | plt.ylabel("Asse Y") 18 | plt.show() 19 | 20 | 21 | ------------------------------------------------------------- 22 | 23 | 24 | import seaborn as sns 25 | import matplotlib.pyplot as plt 26 | 27 | # Dati di esempio 28 | x = [1, 2, 3, 4, 5] 29 | y1 = [2, 3, 5, 7, 11] 30 | y2 = [1, 4, 6, 8, 9] 31 | 32 | sns.set_theme(style="whitegrid", palette="muted") 33 | 34 | plt.figure(figsize=(6, 4)) 35 | # Tracciamo entrambe le serie specificando un'etichetta e uno stile di marker 36 | sns.lineplot(x=x, y=y1, marker="o", label="Serie 1") 37 | sns.lineplot(x=x, y=y2, marker="s", label="Serie 2") 38 | 39 | plt.title("Confronto Serie 1 e Serie 2 con seaborn") 40 | plt.xlabel("Indice") 41 | plt.ylabel("Valore") 42 | plt.legend(loc="upper left") 43 | plt.tight_layout() 44 | plt.show() 45 | 46 | 47 | ----------------------------------------------------------------- 48 | 49 | 50 | import seaborn as sns 51 | import numpy as np 52 | 53 | # Creiamo un DataFrame per sfruttare relplot 54 | import pandas as pd 55 | t = np.linspace(0, 2*np.pi, 200) 56 | df = pd.DataFrame({ 57 | "t": np.concatenate([t, t]), 58 | "valore": np.concatenate([np.sin(t), np.cos(t)]), 59 | "funzione": ["seno"]*len(t) + ["coseno"]*len(t) 60 | }) 61 | 62 | # relplot genera automaticamente sottotrame se dividiamo per "funzione" 63 | sns.set_theme(style="ticks") 64 | 65 | g = sns.relplot( 66 | data=df, 67 | x="t", y="valore", 68 | kind="line", 69 | col="funzione", # una colonna per ogni funzione 70 | height=4, aspect=1.5, # dimensioni di ciascuna subplot 71 | facet_kws={"sharex": True} 72 | ) 73 | g.set_axis_labels("Angolo (rad)", "Valore") 74 | g.set_titles("{col_name}") 75 | plt.show() 76 | 77 | --------------------------------------------------------------- 78 | 79 | import seaborn as sns 80 | import numpy as np 81 | import matplotlib.pyplot as plt 82 | 83 | # Definiamo tema, font e palette 84 | sns.set_theme( 85 | context="talk", # dimensione del font pensata per presentazioni 86 | style="whitegrid", # griglia chiara 87 | palette="coolwarm", # palette dei colori 88 | font="serif", # famiglia di font 89 | rc={ # parametri rc aggiuntivi 90 | "axes.titlesize": 16, 91 | "axes.labelsize": 14, 92 | "lines.linewidth": 2, 93 | "lines.markersize": 8 94 | } 95 | ) 96 | 97 | # Dati di esempio 98 | x = np.linspace(0, 4*np.pi, 100) 99 | y = np.sin(x) * np.exp(-x/10) 100 | 101 | plt.figure(figsize=(7, 4)) 102 | sns.lineplot(x=x, y=y, marker="D", label="sin(x)·exp(-x/10)") 103 | plt.title("Damping della sinusoide con seaborn") 104 | plt.xlabel("x") 105 | plt.ylabel("y") 106 | plt.legend() 107 | plt.show() 108 | 109 | 110 | 111 | ---------------------------------------------------------------------- 112 | 113 | 114 | import seaborn as sns 115 | import numpy as np 116 | import matplotlib.pyplot as plt 117 | 118 | # Dati 2D di esempio 119 | X, Y = np.meshgrid(np.linspace(0, 1, 30), np.linspace(0, 1, 30)) 120 | Z = np.sin(X * np.pi) * np.cos(Y * np.pi) 121 | 122 | sns.set_theme(style="dark") 123 | plt.figure(figsize=(6, 5)) 124 | # Creiamo una heatmap con barra colore integrata 125 | sns.heatmap(Z, 126 | cmap="viridis", # mappa dei colori 127 | cbar_kws={"label": "Intensità"}, 128 | square=True, # caselle quadrate 129 | xticklabels=5, # mostra un tick ogni 5 130 | yticklabels=5) 131 | plt.title("Heatmap di esempio con seaborn") 132 | plt.xlabel("Asse X") 133 | plt.ylabel("Asse Y") 134 | plt.show() 135 | 136 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Aula di Python per Analisi dei Dati e Machine Learning 2 | 3 | Benvenuti nella repository dell'Aula di Python per Analisi dei Dati e Machine Learning. Questo spazio raccoglie codici extra, esempi pratici, esercitazioni e relative correzioni, pensati per supportare l'apprendimento e la pratica degli argomenti trattati durante le lezioni. 4 | 5 | ## Contenuto della Repository 6 | 7 | - **Codici di esempio**: Script e notebook che illustrano i principali concetti e tecniche di analisi dati e machine learning. 8 | - **Esercitazioni**: Attività pratiche per mettere in pratica quanto appreso in classe. 9 | - **Correzioni**: Soluzioni e spiegazioni dettagliate per ciascuna esercitazione. 10 | - **Risorse aggiuntive**: Materiali di approfondimento e link a documentazioni ufficiali e tutorial. 11 | 12 | 13 | -------------------------------------------------------------------------------- /Requisiti_Di_Sistema: -------------------------------------------------------------------------------- 1 | 2 | ## Requisiti 3 | 4 | - **Python 3.x** 5 | - **Gestione degli ambienti virtuali**: si consiglia l'uso di [venv](https://docs.python.org/3/library/venv.html), [Pipenv](https://pipenv.pypa.io/) o [conda](https://docs.conda.io/) per isolare le dipendenze. 6 | - **Librerie Python**: 7 | - numpy 8 | - pandas 9 | - matplotlib 10 | - scikit-learn 11 | - jupyter 12 | 13 | È possibile installare tutte le dipendenze necessarie tramite il comando: 14 | 15 | ```bash 16 | pip install -r requirements.txt 17 | -------------------------------------------------------------------------------- /Slide_Link/Es_1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MaSTERmIKK/Aula_Python/ee281757ba972442f4fbbe35256e54377d7677f7/Slide_Link/Es_1.jpg -------------------------------------------------------------------------------- /Slide_Link/Es_Classi_Extra: -------------------------------------------------------------------------------- 1 | 🔵 Esercizio 1: Registro Studenti 2 | Crea due classi: Studente e Registro. 3 | 4 | Classe Studente: 5 | Attributi: nome, cognome, voti (lista) 6 | 7 | Metodi: 8 | 9 | aggiungi_voto(voto) 10 | 11 | media() → restituisce la media dei voti 12 | 13 | Classe Registro: 14 | Attributo: studenti (lista di oggetti Studente) 15 | 16 | Metodi: 17 | 18 | aggiungi_studente(studente) 19 | 20 | media_classe() → calcola la media complessiva di tutti gli studenti 21 | 22 | migliore_studente() → ritorna il nome dello studente con media più alta 23 | 24 | Obiettivo: usare più classi che interagiscono, operare su liste di oggetti. 25 | 26 | 🔵 Esercizio 2: Sistema di gestione prodotti 27 | Crea una classe Prodotto e una classe Magazzino. 28 | 29 | Classe Prodotto: 30 | Attributi: nome, prezzo, quantità 31 | 32 | Classe Magazzino: 33 | Attributo: prodotti (lista di oggetti Prodotto) 34 | 35 | Metodi: 36 | 37 | aggiungi_prodotto(prodotto) 38 | 39 | valore_totale() → calcola il valore totale del magazzino (somma di prezzo × quantità) 40 | 41 | cerca_prodotto(nome) → ritorna il prodotto se esiste, altrimenti un messaggio di errore 42 | 43 | Obiettivo: esercitarsi con gestione di liste, ricerca, moltiplicazioni e strutture condizionali. 44 | 45 | 🔵 Esercizio 3: Gestione Playlist Musicale 46 | Crea una classe Brano e una classe Playlist. 47 | 48 | Classe Brano: 49 | Attributi: titolo, artista, durata (in minuti, es. 3.5) 50 | 51 | Classe Playlist: 52 | Attributo: brani (lista di oggetti Brano) 53 | 54 | Metodi: 55 | 56 | aggiungi_brano(brano) 57 | 58 | durata_totale() → somma tutte le durate 59 | 60 | cerca_per_artista(nome) → stampa tutti i titoli dei brani di quell’artista 61 | 62 | Obiettivo: gestione di tuple o oggetti con cicli, somma e filtri. 63 | -------------------------------------------------------------------------------- /Slide_Link/Es_Facili_Classi_Extra: -------------------------------------------------------------------------------- 1 | 🟠 Esercizio 1: Classe "Libro" 2 | Crea una classe chiamata Libro che rappresenti un libro. La classe deve contenere: 3 | 4 | un costruttore con i seguenti attributi: titolo, autore, anno_pubblicazione 5 | 6 | un metodo descrizione() che ritorna una stringa con tutte le informazioni del libro 7 | 8 | un metodo è_recente() che ritorna True se l’anno di pubblicazione è maggiore o uguale a 2020, altrimenti False 9 | 10 | Obiettivo: comprendere costruttori, attributi e metodi base. 11 | 12 | 🟠 Esercizio 2: Classe "Contatore" 13 | Crea una classe chiamata Contatore che simula un contatore numerico. Deve avere: 14 | 15 | un attributo valore, inizializzato a 0 16 | 17 | un metodo incrementa() che aumenta valore di 1 18 | 19 | un metodo azzera() che riporta valore a 0 20 | 21 | un metodo mostra() che stampa il valore corrente 22 | 23 | Obiettivo: gestire lo stato di un oggetto con metodi semplici. 24 | 25 | 🟠 Esercizio 3: Classe "Studente" 26 | Scrivi una classe Studente con: 27 | 28 | attributi: nome, cognome, voti (lista di interi) 29 | 30 | metodo aggiungi_voto(voto) per aggiungere un voto alla lista 31 | 32 | metodo media() per calcolare e restituire la media dei voti 33 | 34 | metodo scheda() che stampa nome, cognome e media 35 | 36 | Obiettivo: lavorare con attributi mutabili (liste) e semplici logiche di calcolo. 37 | -------------------------------------------------------------------------------- /Slide_Link/Filippo - Esercizi classi extra/ATTESA TRACCE DIFFICILI/VUOTO.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MaSTERmIKK/Aula_Python/ee281757ba972442f4fbbe35256e54377d7677f7/Slide_Link/Filippo - Esercizi classi extra/ATTESA TRACCE DIFFICILI/VUOTO.txt -------------------------------------------------------------------------------- /Slide_Link/Filippo - Esercizi classi extra/es facili/README.md: -------------------------------------------------------------------------------- 1 |

Tracce esercizi

2 | 3 |

🟠 Esercizio 1: Classe "Libro"

4 |

5 | Crea una classe chiamata Libro che rappresenti un libro. La classe deve contenere: 6 | 7 | - un costruttore con i seguenti attributi: titolo, autore, anno_pubblicazione 8 | 9 | - un metodo descrizione() che ritorna una stringa con tutte le informazioni del libro 10 | 11 | - un metodo è_recente() che ritorna True se l’anno di pubblicazione è maggiore o uguale a 2020, altrimenti False 12 | 13 | Obiettivo: comprendere costruttori, attributi e metodi base. 14 |

15 | 16 | # 17 | 18 |

🟠 Esercizio 2: Classe "Contatore"

19 |

20 | Crea una classe chiamata Contatore che simula un contatore numerico. Deve avere: 21 | 22 | - un attributo valore, inizializzato a 0 23 | 24 | - un metodo incrementa() che aumenta valore di 1 25 | 26 | - un metodo azzera() che riporta valore a 0 27 | 28 | - un metodo mostra() che stampa il valore corrente 29 | 30 | Obiettivo: gestire lo stato di un oggetto con metodi semplici. 31 |

32 | 33 | # 34 | 35 |

🟠 Esercizio 3: Classe "Studente"

36 | 37 |

38 | Scrivi una classe Studente con: 39 | 40 | - attributi: nome, cognome, voti (lista di interi) 41 | 42 | - metodo aggiungi_voto(voto) per aggiungere un voto alla lista 43 | 44 | - metodo media() per calcolare e restituire la media dei voti 45 | 46 | - metodo scheda() che stampa nome, cognome e media 47 | 48 | Obiettivo: lavorare con attributi mutabili (liste) e semplici logiche di calcolo. 49 |

50 | -------------------------------------------------------------------------------- /Slide_Link/Filippo - Esercizi classi extra/es facili/es1.py: -------------------------------------------------------------------------------- 1 | # 🟠 Esercizio 1: Classe "Libro" 2 | 3 | class Libro: 4 | def __init__(self, titolo, autore, anno_pubblicazione): # costruttore 5 | self.titolo = titolo 6 | self.autore = autore 7 | self.anno_pubblicazione = anno_pubblicazione 8 | self.recente = False # Attributo che sarà aggiornato se il libro è recente 9 | 10 | def descrizione(self): # stampa la descrizione del libro 11 | return f"Il libro {self.titolo}, scritto da {self.autore}, è stato pubblicato nel {self.anno_pubblicazione}" 12 | 13 | def e_recente(self): # verifica se è recente 14 | if self.anno_pubblicazione >= 2020: 15 | self.recente = True # se la data di pubblicazione è nel 2020 o dopo, la variabile viene riscritta come True 16 | return f"Il libro è recente?....{self.recente}" 17 | 18 | titolo = input("Inserisci il titolo del libro: ") 19 | autore = input("Inserisci l'autore del libro: ") 20 | anno_pubblicazione = int(input("Inserisci l'anno di pubblicazione: ")) 21 | 22 | l = Libro(titolo, autore, anno_pubblicazione) # Istanzia un oggetto di tipo Libro con i parametri forniti: titolo, autore e anno_pubblicazion 23 | 24 | print(l.descrizione()) 25 | print(l.e_recente()) -------------------------------------------------------------------------------- /Slide_Link/Filippo - Esercizi classi extra/es facili/es2.py: -------------------------------------------------------------------------------- 1 | #🟠 Esercizio 2: Classe "Contatore" 2 | 3 | class Contatore: 4 | def __init__(self): # costruttore che non accetta parametri esterni 5 | self.valore = 0 6 | 7 | def incrementa(self): # funzione per incrementare il valore 8 | self.valore += 1 9 | print("Valore incrementato con successo") 10 | 11 | def azzera(self): 12 | if self.valore == 0: # verifica che il valore sia già uguale a 0 prima di azzerare 13 | print("Il valore è già uguale a zero, non c'è bisogno di azzerarlo") 14 | self.valore = 0 15 | print("Valore azzerato con successo") 16 | 17 | def mostra(self): # mostra il valore 18 | print(f"Il valore è: {self.valore}") 19 | 20 | c = Contatore() # istanzia un oggetto senza passarne parametri 21 | 22 | while True: # menù per chiedere all'utente cosa fare 23 | whatdo = int(input("Cosa vuoi fare?\nIncrementare di uno il valore del contatore (1)\nAzzerare il valore del contatore (2)\nMostrare il valore del contatore (3)\nUscire (4)\n")) 24 | match whatdo: 25 | case 1: 26 | c.incrementa() 27 | case 2: 28 | c.azzera() 29 | case 3: 30 | c.mostra() 31 | case 4: 32 | break 33 | case _: 34 | break -------------------------------------------------------------------------------- /Slide_Link/Filippo - Esercizi classi extra/es facili/es3.py: -------------------------------------------------------------------------------- 1 | # 🟠 Esercizio 3: Classe "Studente" 2 | 3 | class Studente: 4 | def __init__(self, nome, cognome, voti): # costruttore 5 | self.nome = nome 6 | self.cognome = cognome 7 | self.voti = voti 8 | 9 | def aggiungi_voto(self): # funzione per aggiungere un voto alla lista passata 10 | while True: 11 | votoNuovo = int(input("Inserisci il voto da aggiungere alla lista: ")) 12 | self.voti.append(votoNuovo) 13 | whatdo = input("Vuoi aggiungere altri voti? (s/n)").lower() 14 | if whatdo != "s": 15 | break 16 | 17 | def media(self): # calcola la media effettuando la somma dei parametri nella lista per poi dividerla per il numero dei parametri 18 | media = sum(self.voti) / len(self.voti) if len(self.voti) > 0 else 0 # se la lista è vuota restituisce 0 19 | 20 | def scheda(self, media): # prende il valore della media passato dalla funzione media 21 | print(f"Nome: {self.nome}\nCognome: {self.cognome}\nMedia: {media}") 22 | 23 | voti = [1,4,6,3,2,7,8,4,2] # lista voti da passare 24 | f = Studente("Filippo", "pippo", voti) 25 | f.aggiungi_voto() 26 | media = f.media() 27 | f.scheda(media) -------------------------------------------------------------------------------- /Slide_Link/Filippo - Esercizi classi extra/es medi/README.md: -------------------------------------------------------------------------------- 1 |

Tracce esercizi

2 | 3 |

🔵 Esercizio 1: Registro Studenti

4 |

5 | Crea due classi: Studente e Registro. 6 | 7 | - Classe Studente: 8 | - Attributi: nome, cognome, voti (lista) 9 | 10 | - Metodi: aggiungi_voto(voto); media() → restituisce la media dei voti 11 | 12 | - Classe Registro: 13 | - Attributo: studenti (lista di oggetti Studente) 14 | 15 | - Metodi: aggiungi_studente(studente); media_classe() → calcola la media complessiva di tutti gli studenti; migliore_studente() → ritorna il nome dello studente con media più alta 16 | 17 | Obiettivo: usare più classi che interagiscono, operare su liste di oggetti. 18 |

19 | 20 | # 21 | 22 |

🔵 Esercizio 2: Sistema di gestione prodotti

23 |

24 | Crea una classe Prodotto e una classe Magazzino. 25 | 26 | - Classe Prodotto: 27 | - Attributi: nome, prezzo, quantità 28 | 29 | - Classe Magazzino: 30 | - Attributo: prodotti (lista di oggetti Prodotto) 31 | - Metodi: aggiungi_prodotto(prodotto); valore_totale() → calcola il valore totale del magazzino (somma di prezzo × quantità); cerca_prodotto(nome) → ritorna il prodotto se esiste, altrimenti un messaggio di errore 32 | 33 | Obiettivo: esercitarsi con gestione di liste, ricerca, moltiplicazioni e strutture condizionali. 34 | 35 | # 36 | 37 |

🔵 Esercizio 3: Gestione Playlist Musicale

38 |

39 | Crea una classe Brano e una classe Playlist. 40 | 41 | - Classe Brano: 42 | - Attributi: titolo, artista, durata (in minuti, es. 3.5) 43 | 44 | - Classe Playlist: 45 | - Attributo: brani (lista di oggetti Brano 46 | - Metodi:aggiungi_brano(brano); durata_totale() → somma tutte le durate; cerca_per_artista(nome) → stampa tutti i titoli dei brani di quell’artista 47 | 48 | Obiettivo: gestione di tuple o oggetti con cicli, somma e filtri. 49 |

50 | -------------------------------------------------------------------------------- /Slide_Link/Filippo - Esercizi classi extra/es medi/es1.py: -------------------------------------------------------------------------------- 1 | # 🔵 Esercizio 1: Registro Studenti 2 | 3 | # Avviso: l'esercizio contiene funzioni e procedimenti aggiuntivi non richiesti esplicitamente nelle tracce 4 | 5 | idStudenti = 0 # Variabile globale per assegnare un ID unico a ogni studente, utile per calcolare il miglior studente 6 | 7 | class Studente: 8 | def __init__(self, nome, cognome): # costruttore che accetta parametri 9 | self.nome = nome 10 | self.cognome = cognome 11 | self.registro_materie = { 12 | "Matematica": [], 13 | "Italiano": [], 14 | "Storia": [], 15 | "Scienze": [], 16 | "Inglese": [] 17 | } # chiave,materia: valore,lista dei voti 18 | 19 | def aggiungi_voto(self): # funzione per aggiungere voti alla lista grazie al ciclo 20 | while True: 21 | materiaVoto = input("Lista materie:\nMatematica, Italiano, Storia, Scienze, Inglese.\nInserisci la materia a cui vuoi aggiungere il voto: ") 22 | materiaVoto_capitalizzata = materiaVoto.capitalize() # rende la prima lettera maiuscola 23 | 24 | if materiaVoto_capitalizzata in self.registro_materie: # verifica che la materia scelta sia presente nel dizionario delle materie 25 | votoDaAggiungere = int(input("Inserisci il voto da aggiungere: ")) 26 | self.registro_materie[materiaVoto_capitalizzata].append(votoDaAggiungere) # aggiunge il valore alla lista 27 | continuare = input("Aggiungere un altro voto? (s/n): ").lower() 28 | if continuare != "s": 29 | break 30 | else: 31 | print("Materia non valida, riprova.") 32 | 33 | def media_voti(self): # calcola la media delle materie 34 | mediaMaterie = [] # lista che contiene la media di ogni materia 35 | 36 | # Cicla su ogni coppia chiave-valore del dizionario delle materie dello studente 37 | # 'materia' sarà il nome della materia (es. "Matematica"), 'voti' la lista dei voti associati 38 | for materia, voti in self.registro_materie.items(): 39 | mediaMateria = sum(voti) / len(voti) if len(voti) > 0 else 0 # calcola la media, se la lista è vuota restituisce 0 40 | mediaMaterie.append(mediaMateria) 41 | mediaFinale = sum(mediaMaterie) / len(mediaMaterie) if len(mediaMaterie) > 0 else 0 # calcola la media, se la lista è vuota restituisce 0 42 | print(f"La media generale di {self.nome} {self.cognome} è {mediaFinale:.2f}") 43 | return mediaFinale # restituisce il valore perchè serve per calcolare la media della classe 44 | 45 | 46 | class Registro: 47 | def __init__(self): 48 | self.dizStudenti = {} # chiave, idstudente: valore, istanza Studente creata 49 | self.trovaStudenti = {} # ad ogni id, associa il nome dello studente 50 | self.mediaStudenti = [] # lista che contiene i valori delle medie finali di ogni studente 51 | 52 | def aggiungi_studenti(self): # funzione per istanziare oggetti di classe Studente 53 | global idStudenti 54 | while True: 55 | nomeStudente = input("Inserisci il nome dello studente: ") 56 | cognomeStudente = input("Inserisci il cognome dello studente: ") 57 | s = Studente(nomeStudente, cognomeStudente) 58 | 59 | s.aggiungi_voto() # richiama il metodo della classe Studente 60 | 61 | self.dizStudenti[idStudenti] = s # associa id a oggetto studente nel dizionario 62 | self.trovaStudenti[idStudenti] = nomeStudente # associa id a nome studente nel dizionario 63 | print(f"{nomeStudente}, il tuo ID è {idStudenti}") 64 | idStudenti += 1 65 | 66 | mediaFinale = s.media_voti() # memorizza la media finale per passarla alla funzione media classe 67 | self.mediaStudenti.append(mediaFinale) 68 | 69 | continuare = input("Continuare ad aggiungere studenti? (s/n): ").lower() 70 | if continuare != "s": 71 | break 72 | return self.mediaStudenti 73 | 74 | def media_classe(self): # calcola la media della classe considerando la lista delle medie degli studenti 75 | if len(self.mediaStudenti) == 0: 76 | print("Nessuno studente registrato.") 77 | return 78 | mediaClasse = sum(self.mediaStudenti) / len(self.mediaStudenti) 79 | print(f"La media della classe è: {mediaClasse:.2f}") # formatta il numero con 2 cifre decimali 80 | 81 | def migliore_studente(self, medie): # trova il miglior studente 82 | if not medie: 83 | print("Nessuno studente registrato.") 84 | return 85 | 86 | media_massima = max(medie) # Trova la media più alta 87 | id_migliore = medie.index(media_massima) # Prende l'indice (che è anche l'ID) 88 | 89 | nome_migliore = self.trovaStudenti.get(id_migliore) # Recupera il nome dallo studente 90 | print(f"Il miglior studente è {nome_migliore} con una media di {media_massima:.2f}") 91 | 92 | 93 | 94 | 95 | # Esecuzione del programma 96 | r = Registro() 97 | medie = r.aggiungi_studenti() 98 | r.media_classe() 99 | r.migliore_studente(medie) 100 | 101 | -------------------------------------------------------------------------------- /Slide_Link/Filippo - Esercizi classi extra/es medi/es2.py: -------------------------------------------------------------------------------- 1 | # 🔵 Esercizio 2: Sistema di gestione prodotti 2 | 3 | # Avviso: l'esercizio contiene funzioni e procedimenti aggiuntivi non richiesti esplicitamente nelle tracce 4 | 5 | class Prodotto: 6 | def __init__(self, nome, prezzo,quantita): # costruttore con parametri nome, prezzo e quantità 7 | self.nome = nome 8 | self.prezzo = prezzo 9 | self.quantita = quantita 10 | 11 | class Magazzino: 12 | def __init__(self): # costruttore 13 | self.listaProdotti = [] 14 | self.totale = 0 15 | 16 | def aggiungi_prodotto(self): 17 | nome = input("Inserisci il nome del prodotto da aggiungere: ") 18 | nome = nome.capitalize() # prima lettera maiuscola 19 | prezzo = float(input("Inserisci il prezzo del prodotto (usare il punto (.) per i centesimi): ")) 20 | quantita = int(input("Inserisci il numero intero di pezzi da aggiungere: ")) 21 | p = Prodotto(nome, prezzo, quantita) # istanzia un oggetto Prodotto con attributi nome, prezzo, quantità 22 | self.listaProdotti.append(p) # aggiunge l'oggetto Prodotto alla lista dei prodotti 23 | 24 | def valoreTotale(self): 25 | self.totale = 0 # Reset della somma totale 26 | for prodotto in self.listaProdotti: # per ogni oggetto nella lista prende i valori prezzo e quantità 27 | self.totale += prodotto.prezzo * prodotto.quantita 28 | print(f"Il valore totale del tuo magazzino è {self.totale:.2f}") 29 | 30 | def cerca_prodotto(self): 31 | cercare = input("Inserisci il nome del prodotto da cercare: ") 32 | cercare = cercare.capitalize() # prima lettera maiuscola 33 | trovato = False # impostato su false per cercare i prodotti 34 | for prodotto in self.listaProdotti: 35 | if prodotto.nome == cercare: 36 | print(f"Prodotto: {prodotto.nome}, prezzo: {prodotto.prezzo}, quantità: {prodotto.quantita}") 37 | trovato = True 38 | break 39 | print("Il prodotto non è presente nel magazzino") 40 | 41 | m = Magazzino() # istanzia oggetto magazzino senza passarne parametri 42 | print("Il tuo magazzino al momento è vuoto! Aggiungi almeno un prodotto!") 43 | 44 | while True: 45 | m.aggiungi_prodotto() # aggiunge il prodotto al magazzino 46 | scelta = input("Vuoi aggiungere un altro prodotto? (s/n): ").lower() 47 | if scelta != "s": 48 | break 49 | 50 | while True: 51 | scelta = int(input("\nCosa desideri fare adesso?\nCercare un prodotto (1)\nVisionare il valore totale del magazzino (2)\nAggiungere un altro prodotto (3)\nUscire (4): ")) 52 | match scelta: #menu 53 | case 1: 54 | m.cerca_prodotto() 55 | 56 | case 2: 57 | m.valoreTotale() 58 | 59 | case 3: 60 | m.aggiungi_prodotto() 61 | 62 | case 4: 63 | break 64 | 65 | case _: # caso standard che si verifica che non ci sono corrispondenze 66 | break -------------------------------------------------------------------------------- /Slide_Link/Filippo - Esercizi classi extra/es medi/es3.py: -------------------------------------------------------------------------------- 1 | # 🔵 Esercizio 3: Playlist musica 2 | 3 | # Avviso: l'esercizio contiene funzioni e procedimenti aggiuntivi non richiesti esplicitamente nelle tracce 4 | 5 | class Brano: 6 | def __init__(self, titolo, artista, durata): # costruttore con parametri passati 7 | self.titolo = titolo 8 | self.artista = artista 9 | self.durata = durata 10 | 11 | class Playlist: 12 | def __init__(self): # costruttore 13 | self.listaBrani = [] # lista dove aggiungere oggetti Brano 14 | self.durata = 0 15 | 16 | def aggiungi_brano(self): # aggiunge un brano alla playlist 17 | titolo = input("Inserisci il titolo del brano: ") 18 | artista = input("Inserisci il titolo dell'artista: ") 19 | durata = float(input("Inserisci la durata del brano in minuti (es. 3.5): ")) 20 | titolo, artista = titolo.capitalize() , artista.capitalize() # prima lettera maiuscola 21 | c = Brano(titolo, artista, durata) 22 | self.listaBrani.append(c) 23 | 24 | def durata_totale(self): # durata totale playlist 25 | self.durata = 0 26 | for canzone in self.listaBrani: 27 | self.durata += canzone.durata # somma la durata di ogni canzone 28 | durataOre = self.durata / 60 # divide i minuti per 60 in modo da ottenere le ore 29 | print(f"La durata totale della tua playlist è di {self.durata} minuti o, se preferisci, {durataOre:.2f} ore") 30 | 31 | def cerca_per_artista(self): # cerca canzone nella lista 32 | artistaDaCercare = input("Inserisci il nome dell'artista: ") 33 | artistaDaCercare = artistaDaCercare.capitalize() 34 | trovato = False # impostato False per la ricerca 35 | for artista in self.listaBrani: 36 | if artistaDaCercare == artista.artista: 37 | print(f"Canzoni associate all'artista: {artista.titolo}") 38 | trovato = True # impostato a True per non esaudire la condizione nella riga successiva 39 | if not trovato: 40 | print("Artista non trovato") 41 | 42 | def elimina_canzone(self): # rimuove canzone dalla lista brani 43 | titoloDaEliminare = input("Inserisci il titolo della canzone da eliminare: ") 44 | ArtistaDaEliminare = input("Inserisci l'artista della canzone da eliminare: ") # per evitare ridondanze di titoli richiede anche l'artista della canzone 45 | titoloDaEliminare, ArtistaDaEliminare = titoloDaEliminare.capitalize(), ArtistaDaEliminare.capitalize() 46 | trovato = False 47 | for canzone in self.listaBrani: 48 | if titoloDaEliminare == canzone.titolo and ArtistaDaEliminare == canzone.artista: # verifica che ci siano corrispondenze di titolo e artista contemporaneamente 49 | self.listaBrani.remove(canzone) # rimuove la canzone interessata 50 | print("Canzone rimossa") 51 | trovato = True 52 | break 53 | if not trovato: 54 | print("Canzone non trovata") 55 | 56 | def playlist_completa(self): # stampa intera playlist con titolo,artista e durata per ogni canzone 57 | if len(self.listaBrani) == 0: 58 | print("La playlist è vuota") 59 | else: 60 | for canzone in self.listaBrani: 61 | print(f"Titolo: {canzone.titolo}, artista: {canzone.artista}, durata {canzone.durata}") 62 | 63 | p = Playlist() #istanzia un oggetto Playlist 64 | 65 | print("La tua playlist al momento è vuota! Aggiungi almeno un brano!") 66 | while True: 67 | p.aggiungi_brano() # aggiungi brano alla playlist 68 | scelta = input("Vuoi continuare ad aggiungere brani? (s/n): ").lower() 69 | if scelta != "s": 70 | break 71 | 72 | while True: 73 | scelta = int(input("\nCosa vuoi fare?\nAggiungi un brano (1)\nStampa durata playlist (2)\nCerca canzoni per artista (3)\nRimuovi una canzone dalla playlist (4)\nStampa intera playlist (5)\n Esci (6): ")) 74 | match scelta: # menu 75 | case 1: 76 | p.aggiungi_brano() 77 | 78 | case 2: 79 | p.durata_totale() 80 | 81 | case 3: 82 | p.cerca_per_artista() 83 | 84 | case 4: 85 | p.elimina_canzone() 86 | 87 | case 5: 88 | p.playlist_completa() 89 | 90 | case 6: 91 | break 92 | 93 | case _: 94 | break -------------------------------------------------------------------------------- /Slide_Link/Link_Lavagna: -------------------------------------------------------------------------------- 1 | https://www.canva.com/design/DAF-0MM5VGM/cGgbVIA_wpmb-VzmhBD0Kg/edit?utm_content=DAF-0MM5VGM&utm_campaign=designshare&utm_medium=link2&utm_source=sharebutton 2 | -------------------------------------------------------------------------------- /Slide_Link/Link_Slide: -------------------------------------------------------------------------------- 1 | https://www.canva.com/design/DAGNONH11dQ/ri6igYYiuYnxh6Sn77rmAA/edit?utm_content=DAGNONH11dQ&utm_campaign=designshare&utm_medium=link2&utm_source=sharebutton 2 | -------------------------------------------------------------------------------- /Slide_Link/README.md: -------------------------------------------------------------------------------- 1 | # Slide e link 2 | Qui ci sono i lnk e i riferimenti a slide e materiali extra per il corso 3 | --------------------------------------------------------------------------------