Python

python

pitone

Panoramica

Il linguaggio Python è un linguaggio di scripting object oriented, che supporta pienamente la programmazione strutturata, di alto livello, interpretato, progettato appositamente per garantire una semplicità estrema nella codifica del programma e al tempo stesso una grandissima leggibilità del codice.

Vantaggi

è un linguaggio potentissimo, con cui è possibile scrivere software estremamente complessi, tanto da essere adottato tra i linguaggi di programmazione standard per l’implementazione di servizi da aziende come Google e la NASA.

Tipi di variabili

Tipi di variabile

stringa (str)

intero (int)

I numeri in virgola mobile rappresentano numeri con parte decimale. Possono essere espressi anche in notazione scientifica testo = 'Hello, World'

Gli interi rappresentano numeri interi, positivi o negativi, senza parte decimale. numero_intero = 42

booleano (bool)

virgola (float)

I valori booleani rappresentano la verità (True) o la falsità (False). Sono spesso utilizzati in espressioni condizionali. vero_o_falso = true

Le stringhe rappresentano sequenze di caratteri. Possono essere definite utilizzando singoli o doppi apici. numero_float = 3,14

Tipi di variabile

tupla (tuple)

lista (list)

Le tuple sono simili alle liste, ma sono immutabili, il che significa che non possono essere modificate dopo la loro creazione.tupla_colori = ['rosso', 'verde', 'giallo']

Le liste sono sequenze ordinate(indicizzate) di elementi. Gli elementi possono essere di qualsiasi tipo, permette duplicati e le liste sono modificabili. lista_numeri = [1, 2, 3, 4, 5]

dizionario (dict)

insieme (set)

Sono collezioni ordinate e modificabili, non permettono duplicati. dizionario_persona = {'nome': 'Alice', 'età': 25}

Gli insiemi rappresentano collezioni non ordinate(non indicizzate) di elementi unici. Vengono spesso utilizzati per operazioni insiemistiche come unione, intersezione e differenza. insieme_vocali = {'a', 'b', 'c', 'd', 'e'}

Tipizzazione dinamica

Tipizzazione dinamica

In Python, è importante notare che il tipo di una variabile può cambiare dinamicamente durante l'esecuzione del programma. Questa caratteristica è nota come "tipizzazione dinamica".

variabile = 42 # Intero variabile = "Hello" # Stringa

Casting

int()

numero_intero = int("42")

Casting

float()

numero_float = float("3.14")

Il "casting" in programmazione si riferisce alla conversione di un tipo di dato in un altro. In Python, puoi eseguire il casting utilizzando diverse funzioni integrate che consentono la conversione tra tipi di dati.

str()

testo = str(42)

list(), tuple(), set()

lista_da_tupla = list((1, 2, 3)) insieme_da_lista = set([1, 2, 3])

bool()

booleano = bool(42)

Operatori

Operatori Aritmetici

+ (addizione)

/ (divisione)

% (resto)

- (sottrazione)

* (moltiplicazione)

** (potenza)

Esempio

# Divisione result_div = x / y print("Divisione di x per y:", result_div) # Output: 2.0 # Divisione intera (parte intera del risultato) result_floor_div = x // y print("Divisione intera di x per y:", result_floor_div) # Output: 2 # Resto della divisione result_mod = x % y print("Resto della divisione di x per y:", result_mod) # Output: 0 # Esponenziazione result_exp = x ** y print("x elevato alla potenza di y:", result_exp) # Output: 100000

# Dichiarazione di due variabili intere x = 10 y = 5 # Utilizzo degli operatori aritmetici # Somma result_sum = x + y print("Somma di x e y:", result_sum) # Output: 15 # Differenza result_diff = x - y print("Differenza di x e y:", result_diff) # Output: 5 # Prodotto result_prod = x * y print("Prodotto di x e y:", result_prod) # Output: 50

Operatori di Confronto

== (uguaglianza)

> (maggiore)

>= (maggiore uguale)

< (minore)

!= (diverso)

<= (minore uguale)

Esempio

# Dichiarazione di due variabili a = 10 b = 5 # Utilizzo degli operatori di confronto # Uguaglianza result_equal = a == b print("a è uguale a b:", result_equal) # Output: False # Disuguaglianza result_not_equal = a != b print("a è diverso da b:", result_not_equal) # Output: True # Maggiore di result_greater_than = a > b print("a è maggiore di b:", result_greater_than) # Output: True

# Minore di result_less_than = a < b print("a è minore di b:", result_less_than) # Output: False # Maggiore o uguale a result_greater_than_or_equal = a >= b print("a è maggiore o uguale a b:", result_greater_than_or_equal) # Output: True # Minore o uguale a result_less_than_or_equal = a <= b print("a è minore o uguale a b:", result_less_than_or_equal) # Output: False

Operatori di Identità

Operatori di Appartenenza

Operatori Logici

and (E logico)

in (in sequenza)

is (sono uguali)

or (O logico)

is not (non sono uguali)

not in (non in sequenza)

not (NON logico)

Esempio

# Dichiarazione di una lista lista = [1, 2, 3, 4, 5] # Utilizzo degli operatori di appartenenza # Appartenenza in print("2 appartiene alla lista:", 2 in lista) # Output: True # Appartenenza non in print("6 non appartiene alla lista:", 6 not in lista) # Output: True # Dichiarazione di una stringa stringa = "hello" # Appartenenza in per le stringhe print("'e' appartiene alla stringa:", 'e' in stringa) # Output: True print("'z' non appartiene alla stringa:", 'z' not in stringa) # Output: True

Esempio

# Dichiarazione di due variabili booleane a = True b = False # Utilizzo degli operatori logici # Operatore AND result_and = a and b print("Risultato di a and b:", result_and) # Output: False # Operatore OR result_or = a or b print("Risultato di a or b:", result_or) # Output: True # Operatore NOT result_not_a = not a print("Risultato di not a:", result_not_a) # Output: False result_not_b = not b print("Risultato di not b:", result_not_b) # Output: True

Esempio

# Dichiarazione di due variabili con lo stesso valore x = [1, 2, 3] y = [1, 2, 3] # Utilizzo degli operatori di identità # Verifica se x e y puntano alla stessa area di memoria print("x is y:", x is y) # Output: False # Verifica se x e y non puntano alla stessa area di memoria print("x is not y:", x is not y) # Output: True # Dichiarazione di una variabile che punta allo stesso oggetto z = x # Verifica se x e z puntano alla stessa area di memoria print("x is z:", x is z) # Output: True # Verifica se x e z non puntano alla stessa area di memoria print("x is not z:", x is not z) # Output: False

Strutture Condizionali

Strutture Condizionali

else

if

elif

(opzionale)

(necessary)

(opzionale)

Fornisce un blocco di codice da eseguire se nessuna delle condizioni precedenti è vera.

Utilizzato per eseguire un blocco di codice se una condizione è vera.

Sta per "else if". Permette di verificare condizioni aggiuntive se la prima condizione non è vera.

Esempio

# Definizione di una variabile x = 10 # Utilizzo dell'istruzione if, elif e else per eseguire controlli condizionali multipli if x > 10: print("x è maggiore di 10") elif x == 10: print("x è uguale a 10") else: print("x è minore di 10")

Strutture Iterative

Strutture Condizionali

for

while

Esegue un blocco di codice finché una determinata condizione è vera. La condizione viene verificata prima di ogni iterazione.

Utilizzato per iterare su una sequenza (liste, tuple, stringhe, etc.). Esegue un blocco di codice per ogni elemento nella sequenza.

Esempio

# Utilizzo di for per stampare numeri da 1 a 5 print("Utilizzo di for:") for i in range(1, 6): print(i) # Utilizzo di while per stampare numeri da 1 a 5 print("\nUtilizzo di while:") numero = 1 while numero <= 5: print(numero) numero += 1

Gestione delle Eccezioni

Gestione delle Eccezioni

Sollevamento di un'Eccezione

Un'eccezione può essere sollevata manualmente utilizzando l'istruzione raise. Ad esempio, raise ValueError("Messaggio di errore") solleverà un'eccezione di tipo ValueError con un messaggio specificato.

Cattura di un'Eccezione

Per gestire un'eccezione, si utilizza il blocco try, except. Il codice problematico viene inserito nel blocco try. Se si verifica un'eccezione, il controllo passa al blocco except corrispondente. Se nessuna eccezione si verifica, il blocco except viene ignorato.

Finally di un'Eccezione

Il blocco finally (opzionale) viene eseguito sempre, sia che si verifichi un'eccezione che no. Viene utilizzato per eseguire operazioni di "pulizia" o per garantire che alcune azioni vengano eseguite indipendentemente dall'occorrenza di un'eccezione.

Esempio

# Utilizzo di try-except-finally per gestire un'eccezione di divisione per zero try: numeratore = 10 denominatore = 0 risultato = numeratore / denominatore print("Il risultato della divisione è:", risultato) except ZeroDivisionError: print("Errore: divisione per zero!") finally: print("Esecuzione del blocco finally.") # Altri codici possono continuare qui...

Funzione

Funzione

In Python, una funzione è un blocco di codice organizzato e riutilizzabile che può essere chiamato per eseguire un'azione specifica. Le funzioni consentono di suddividere il codice in unità più piccole e modulari, rendendo il programma più leggibile, manutenibile e riutilizzabile.

Python fornisce diverse funzioni predefinite come print(), len(), e input(), che possono essere utilizzate direttamente senza la necessità di definirle.

Definizione e Chiamata di una Funzione

Una funzione in Python viene definita utilizzando la parola chiave def, seguita dal nome della funzione e da parentesi tonde. All'interno delle parentesi, è possibile dichiarare i parametri che la funzione accetta. Il blocco di codice associato alla funzione è indentato sotto la sua dichiarazione.

Per eseguire una funzione, è necessario chiamarla utilizzando il suo nome seguito da parentesi tonde. Gli argomenti, se presenti, vengono passati all'interno delle parentesi.

Esempio

# Definizione della funzione def saluta(): """ Questa funzione stampa un saluto generico. """ print("Ciao! Benvenuto.") # Chiamata della funzione saluta() # Stampa: Ciao! Benvenuto.

Parametri ed Argomenti

Parametri e Argomenti

I parametri sono variabili dichiarate nella definizione della funzione e rappresentano i valori che la funzione può accettare durante la sua esecuzione. Gli argomenti sono i valori reali passati alla funzione durante la sua chiamata. Una funzione può restituire un valore utilizzando l'istruzione return. Il valore restituito può essere assegnato a una variabile o utilizzato direttamente.

Esempio

# Definizione della funzione def saluta(nome): """ Questa funzione accetta una stringa 'nome' come argomento e stampa un saluto personalizzato. """ print("Ciao,", nome, "! Benvenuto.") # Chiamata della funzione saluta("Alice") # Stampa: Ciao, Alice! Benvenuto. saluta("Bob") # Stampa: Ciao, Bob! Benvenuto.

Scope delle Variabili

Scope delle Variabili

In programmazione, lo scope di una variabile si riferisce all'area del programma in cui la variabile è accessibile e può essere utilizzata. Python definisce diverse tipologie di scope, che determinano quando e dove una variabile può essere letta o modificata

Scope delle Variabili

Scope di Funzione

Scope Locale

Built-in Scope

Scope Globale

Le variabili definite all'interno di una funzione sono locali a quella funzione. Possono essere utilizzate solo all'interno della funzione in cui sono state definite. Non sono accessibili al di fuori della funzione.

Le variabili predefinite di Python, come print, len, ecc., appartengono a uno scope built-in. Sono accessibili da qualsiasi parte del programma.

Le variabili definite al di fuori di qualsiasi funzione o blocco di codice sono globali. Sono accessibili da qualsiasi parte del programma, inclusi all'interno delle funzioni. Possono essere modificate all'interno delle funzioni utilizzando la parola chiave global.

Si verifica quando ci sono funzioni annidate. Una variabile definita in una funzione madre è accessibile anche nelle funzioni figlie annidate. Non è accessibile al di fuori delle funzioni coinvolte.

Esempio

# Variabile globale x = 10 def funzione_esterna(): # Variabile locale alla funzione_esterna y = 20 def funzione_interna_locale(): # Variabile locale alla funzione_interna_locale z = 30 print("Dentro funzione_interna_locale:", x, y, z) def funzione_interna_incapsulata(): # Utilizzo della keyword 'nonlocal' per indicare che 'y' appartiene al livello superiore nonlocal y y = 25 print("Dentro funzione_interna_incapsulata:", x, y)

print("Dentro funzione_esterna (prima delle chiamate alle funzioni interne):", x, y) funzione_interna_locale() funzione_interna_incapsulata() print("Dentro funzione_esterna (dopo le chiamate alle funzioni interne):", x, y) # Stampa del valore di 'x' prima di chiamare la funzione_esterna print("Prima di chiamare la funzione_esterna:", x) # Chiamata alla funzione_esterna funzione_esterna() # Stampa del valore di 'x' dopo la chiamata della funzione_esterna print("Dopo la chiamata della funzione_esterna:", x)

Librerie e Moduli

Librerie e Moduli

Le librerie standard di Python sono insiemi di moduli e pacchetti predefiniti che offrono una vasta gamma di funzionalità e strumenti. Queste librerie sono incluse nell'installazione di base di Python, quindi non è necessario scaricarle separatamente. Puoi utilizzare queste librerie per eseguire molte attività comuni di programmazione senza dover scrivere il codice da zero.

Libreria e Moduli

Per utilizzare una libreria, devi importarla nel tuo script o programma Python. Puoi farlo con l'istruzione import. import nome_libreria

Le librerie sono spesso suddivise in moduli, ciascuno dei quali fornisce funzionalità specifiche. Puoi importare solo il modulo di cui hai bisogno. from nome_libreria import modulo

Puoi assegnare alias ai nomi delle librerie o dei moduli per rendere più breve il loro utilizzo. import nome_libreria as nl

math

Libreria Standard

Operazioni matematiche avanzate.

datetime

Manipolazione di date e orari.

Se hai bisogno di funzionalità che non sono incluse nelle librerie standard, puoi installare librerie di terze parti utilizzando strumenti come pip. pip install nome_libreria.

os

Funzionalità del sistema operativo, come la gestione dei file.

randam

Generazione di numeri casuali.

json

Manipolazione di dati JSON.

Esempio

# Importazione delle librerie standard di Python import math import random # Variabile globale x = 10 # Variabile locale y = 20 # Stampa del valore di 'x' prima di eseguire il calcolo trigonometrico print("Prima del calcolo trigonometrico:", x) # Esecuzione del calcolo trigonometrico angolo_radiani = math.radians(45) seno_angolo = math.sin(angolo_radiani) print("Il seno di 45 gradi è:", seno_angolo) # Generazione di un numero casuale numero_casuale = random.randint(1, 100) print("Numero casuale generato:", numero_casuale) # Stampa del valore di 'x' dopo il calcolo trigonometrico print("Dopo il calcolo trigonometrico:", x)

Classi e Oggetti

Classe

Una classe è un modello o un prototipo per creare oggetti. È una struttura che definisce gli attributi (variabili) e i metodi (funzioni) che gli oggetti di quella classe avranno.

Oggetto

Un oggetto è un'istanza di una classe. Puoi creare oggetti basati sulla classe precedentemente definita.

Attributo

Gli attributi sono le variabili associate a un oggetto. Possono essere definiti nella classe e assegnati agli oggetti durante la loro creazione.

Metodo

I metodi sono le funzioni associate a un oggetto. Possono eseguire azioni sull'oggetto o restituire informazioni su di esso.

Esempio

class Automobile: def __init__(self, marca, modello, anno): self.marca = marca self.modello = modello self.anno = anno self.velocita = 0 def accelera(self, valore): self.velocita += valore print(f"L'automobile {self.marca} {self.modello} ha accelerato a {self.velocita} km/h.") # Creazione di un'istanza della classe Automobile mia_auto = Automobile("Toyota", "Corolla", 2022) # Utilizzo del metodo accelera sull'oggetto mia_auto mia_auto.accelera(50)

Ereditarietà

Una classe può ereditare gli attributi e i metodi di un'altra classe. Questo favorisce la riutilizzabilità del codice.

Esempio

class Moto(Veicolo): def __init__(self, marca, modello, cilindrata): super().__init__(marca, modello) self.cilindrata = cilindrata def info(self): return f"Moto: {self.marca} {self.modello}, Cilindrata: {self.cilindrata}cc" # Creazione di istanze delle classi e chiamata dei metodi auto = Automobile("Toyota", "Corolla", 4) moto = Moto("Honda", "CBR1000RR", 1000) print(auto.info()) # Stampa: Automobile: Toyota Corolla, Porte: 4 print(moto.info()) # Stampa: Moto: Honda CBR1000RR, Cilindrata: 1000cc

class Veicolo: def __init__(self, marca, modello): self.marca = marca self.modello = modello def info(self): return f"Veicolo: {self.marca} {self.modello}" class Automobile(Veicolo): def __init__(self, marca, modello, porte): super().__init__(marca, modello) self.porte = porte def info(self): return f"Automobile: {self.marca} {self.modello}, Porte: {self.porte}"

Incampsulamento

Python supporta l'incapsulamento per nascondere l'implementazione interna di una classe. Gli attributi e i metodi possono essere pubblici, protetti o privati.

Esempio

class Automobile: def __init__(self, marca, modello): self.marca = marca self.modello = modello self.__velocita = 0 # Attributo privato def accelera(self, valore): if valore > 0: self.__velocita += valore def ottieni_velocita(self): return self.__velocita # Creazione di un'istanza della classe Automobile mia_auto = Automobile("Toyota", "Corolla") # Accedere all'attributo privato tramite il metodo getter print("Velocità attuale:", mia_auto.ottieni_velocita()) # Accelerare l'auto mia_auto.accelera(50) # Accedere all'attributo privato tramite il metodo getter print("Velocità dopo l'accelerazione:", mia_auto.ottieni_velocita())

Poliformismo

Gli oggetti di classi diverse possono rispondere allo stesso metodo in modo diverso. Ad esempio, il metodo informazioni() può essere implementato in modo diverso in diverse classi.

Esempio

class Animale: def suono(self): pass class Cane(Animale): def suono(self): return "Bau Bau!" class Gatto(Animale): def suono(self): return "Miao Miao!" # Funzione che accetta un oggetto di tipo Animale e chiama il metodo suono def emetti_suono(animale): print(animale.suono()) # Creazione di istanze di diverse classi e chiamata della funzione animale1 = Cane() animale2 = Gatto() emetti_suono(animale1) # Stampa: Bau Bau! emetti_suono(animale2) # Stampa: Miao Miao!

Apertura di un File

Apertura di un File

Per aprire un file, puoi utilizzare la funzione open. Questa funzione richiede il percorso del file e la modalità di apertura (lettura, scrittura, aggiunta, ecc.).

Modalità Comuni

'r'

Lettura (default).

'w'

Scrittura (sovrascrive il file esistente).

Esempio with open("nome_file.txt", "r") as file: contenuto = file.read() print(contenuto)

'a'

Aggiunta (appende al file esistente).

'b'

Modalità binaria.

The End