Guida dedicata al linguaggio di programmazione python. (fonte in inglese)
Concetti base di sintassi:
I blocchi del codice vanno separati tramite indentazioni mediante tabulazioni (usare il tasto TAB, o meglio ancora 4 spazi consecutivi per ogni indentazione). Singole funzioni possono anche essere eseguite da terminale del sistema operativo usando il comando “python” (l’interprete python deve essere installato nel sistema)
Esempio Hello World:
#questo è un commento
print(“Ciao mondo”)
Uso di python come calcolatrice:
E’ possibile fare operazioni con i numeri passandole direttamente all’interprete da terminale. Python assegnerà il tipo di dato (int, float, ecc…) automaticamente:
es:
5*3
oppure si può scrivere un espressione anche in un file per calcolare una variabile
es. calcola vary nota varx
vary=varx+1
Testo e stringhe
Il testo in python va chiuso fra apostrofi o virgolette per essere considerato tale dall’interprete
'questo è un testo'
“questo è un testo”
str=”questa è una stringa”
strn=”1234″ #anche questa è una stringa di testo
E’ possibile usare anche le sequenze di escape:
\’ e \” permettono di usare nei testi i caratteri ‘ e ”
print("qui\' devo mettere l\'apostrofo")
print("\"questo testo è fra virgolette\"")
la sequenza di escape \n permette di andare a capo nell’output da terminale
print("prima riga \n seconda riga")
darà come output:
prima riga
seconda riga
Sommare le stringhe con l’operatore matematico + permette di unirle in sequenza, usando il * si ripetono più volte:
out="casa"+2*"matta"
print(out)
darà come output:
casamattamatta
2 stringhe scritte vicino sono unite automaticamente
'casa' 'matta'
'matta'
diventa
casamattamatta
Le stringhe sono indicizzabili
str='casa'
print(str[0])
restituirà “c”
usando numeri negativi si procede al contrario:
print(str[-1])
restituirà “a” dando come input la stringa precedente. -0 è uguale a 0 e parte dall’inizio, la prima lettera letta al contrario ha indice -1
E’ possibile anche definire un intervallo (in tal caso gli indici sono “fra le lettere”):
print(str[0:2])
restituirà “ca”
usare i : senza un valore porta a considerare l’inizio o la fine della stringa in automatico:
cprint(str[:2])
restituisce “ca”
print(str[2:])
restituisce “sa”
Le stringhe in python non possono essere modificate dal programma, sono immutabili! Se si vuole modificare una stringa bisogna crearne una copia corretta!
la funzione len() restituisce la lunghezza di una stringa in caratteri
len(str) restituirà 4 nell’esempio sopra
Liste
Le liste sono un insieme di elementi separati da virgole.
lista[1,2,3,4,5,6]
possono essere maneggiate allo stesso modo delle stringhe:
lista[0]
ad esempio restituirà 1
Al contrario delle stringhe le liste NON sono immutabili e possono essere modificate mediante operazioni di assegnazione:
lista[0]=a #trasformerà la lista in:
a,2,3,4,5,6
usando il metodo append è possibile aggiungere elementi a una lista:
lista.append(b) #trasforma così la lista
a,2,3,4,5,6,b
associare una lista a una variabile farà in modo che ogni cambiamento si ripercuota lungo tutta l’uguaglianza
lista=var
var.append(c)
sia lista che var avranno questo stesso contenuto, sono la stessa variabile:
a,2,3,4,5,6,b,c
utilizzare i : senza un elemento (slicing) crea una nuova lista parziale:
slice=lista(:2)
slice contiene:
a,2
E’ possibile anche creare liste indentate:
list1[1,2,3]
list2[a,b,c,list2]
list2[3,0] # restituirà 1
Cicli e controllo del flusso
Il ciclo while eseguirà il blocco di codice sottostante finchè la condizione espressa non sarà soddisfatta:
while n=10:
….n=n+1
….print(n)
Questo blocco stampa i numeri a schermo fino al 10 (i puntini sono necessari per scrivere la sintassi di indentazione sul blog, non fanno parte del codice e vanno sostituiti con una pressione del tasto TAB o con 4 spazi consecutivi per ogni indentazione)
Controllore IF (se)
Consente di eseguire diverse operazioni a seconda di diverse condizioni. Solo il primo if è obbligatorio, i successivi elif (altre condizioni da verificare se la prima non è valida) e l’else (ultima condizione da attuare se if e tutti gli elif non sono soddisfatti) sono facoltativi.
x=int(input("per favore scrivi un numero intero\n")
if x <0:
….x=0
…print(“x è un numero negativo, modificato a 0\n”)
elif x==2:
…print(“x è uguale a 2\n”)
else:
…print(“x è un intero diverso da due\n”)
Ciclo FOR
Al contrario di altri linguaggi come il C, il ciclo FOR in python si usa per applicare un certo blocco di codice a tutti gli elementi di una lista, NON HA VALENZA DI PROGRESSIONE ARITMETICA! Nel far questo può anche modificare la lista stessa, come nell’esempio sotto ove il ciclo proposto cancella l’elemento di valore “2”:
lista[0,1,2]
for i in lista.copy().items()
….. if i==2
……….del lista[i]
print(lista) #restituisce “0,1”
per evitare di fare modifiche poco controllabili alle liste di solito in questi casi è bene farne una copia mediante il metodo copy().items()
Funziona range()
Mediante range() è possibile utilizzare il ciclo FOR in modo simile ad altri linguaggi:
for i in range(x)
…..print(i)
Questo codice stampa i numeri da 1 a x ad esempio.
è possibile anche definire un limite inferiore da cui iniziare il range (in tal caso ad esempio è possibile enumerare i numeri da 2 a 5 settando opportunamente le variabili a come 2 e 5 come 5)
for i in range(a:x)
…print(i)
E’ possibile sia nei cicli While sia nei cicli FOR eseguire un’azione mediante il comando else: E’ possibile chiudere anticipatamente il ciclo con il comando break, mentre è possibile saltare un’iterazione del ciclo mediante continue
for i in range(x) #stringa mostrata una volta sola quando il ciclo si chiude alla condizione y=i
.....for y in range(z)
............print(y)
............if y=i:
..................break
.....else:
...........print("y=i")
for i in range(x)
.....for y in range(z)
............print(y)
............if y<=i:
................continue
............print("ora y<i") #non stampato se y>i
.....else:
............print("operazione terminata")
il comando pass
Pass non fa nulla a parte sospendere il programma fino alla pressione di un tasto. E’ utilizzato spesso durante la scrittura del codice come riempitivo per funzioni non ancora implementate
pass
Il costrutto MATCH
Match consente di fornire diverse alternative per proseguire il flusso di comandi del programma. Il costrutto _: include tutte le condizioni non specificate:
match x:
……..case 1:
………….print(“numero uno\n”)
……..case 2:
…………print(“numero due\n”)
…….case _:
…………print(“un altro numero\n”)
Funzioni
Le funzioni sono porzioni di codice che possono essere richiamate all’interno del programma mediante nomefunzione(variabili). utilizzando return è possibile che la funzione rilasci un valore come output. Mettendo un’uguaglianza nelle variabili di input nella definizione della funzione si definiranno dei valori di default che verranno utilizzati se questi non saranno definiti esplicitamente (nel caso in esempio somma() restituirà 3, ovvero lo stesso risultato di somma(2,1))
esempio:
def somma(x=2,y=1)
…………..a=x+y
…………..print(a) #questo print stampa il risultato indipendentemente da come è chiamata la variabile esternamente alla funzione
…………..return(a)
y=somma(2,1)
print(y) #questa funzione stamperà il numero 3
Dato che la funzione ogni volta che è chiamata modifica la lista di input, è possibile per evitare questo inserire un ciclo if apposito in modo che un comando venga eseguito solo in condizioni di default (nel nostro caso a lista vuota)
def f(a,X=none)
……..if X is none
…………….X.append(a)
……..return X
In presenza di tante variabili
funzione (pok1, /, pos1, *,ko1)
le variabili pos devono essere indicate nello stesso ordine, le ko con la giusta parla chiave, mentre le pok possono essere chiamate in entrambe le maniere
Espressioni lambda
il comando lambda può essere utilizzato per definire funzioni semplici lunghe una sola riga di codice (anche come input ad altre funzioni)
def somma(a,b)
……..return lambda x=a+b
Stringhe di descrizione
Possono essere incluse in funzioni usando 3 virgolette all’inizio e tre alla fine (“””)
def descrivi()
………..”””Descrizione
………..Non faccio nulla, descrivo solo
……….””””
………..pass
print(descrivi._doc_) #questo comando stampa la descrizione della funzione
Annotazioni
Argomenti opzionali che riportano informazioni sulla funzione, richiamabili mediante l’attributo ._annotations_
esempio:
def funzione(a: int, b: float) -> annot
……..print(funzione._annotation_) #stampa {‘a’ : <class int>, return 0 , ‘b’ : <class float>}
……..return o
Strutture di dati
Qui sotto si riporta il riassunti di alcuni metodi per lavorare sulle liste
list.append(x) aggiunge un elemento x alla lista
list.extend(iter) aggiunge tutti gli elementi di iter alla lista. equivale a iter=a[len(a):]
list.insert(i,x) inserisce l’elemento x nella posizione i
list.remove(x) rimuove l’elemento x
list.pop(i) rimuove l’elemento nella posizione i
list.clear() rimuove tutti gli elementi dalla lista
list.index(x[,start,[, end]) riporta la posizione dell’elemento x nella lista. Se l’elemento non è presente restituisce ValueError
list.count(x) riporta il numero di volte che l’elemento x è ripetuto nella lista
list.sort(argomenti vari) ordina gli elenenti di una lista secondo criteri specifici
list.reverse() inverte la posizione di tutti gli elementi della lista
list.copy() copia la lista
Le liste possono essere utilizzate come pile di elementi usando list.append(x) per aggiungere elementi x e list.pop() senza argomenti per togliere l’ultimo elemento della lista
Utilizzando collection.deque è possibile utilizzare funzioni nativamente progettate per aggiungere e rimuovere elementi da entrambi i lati delle liste (ad esempio per creare code, togliendo sempre l’elemento più vecchio)
from collections import deque
coda=deque([1,2,3])
coda.append(4) #aggiunge il numero 4 in coda alla lista
coda.popleft() recupera ed elimina il numero 1
coda.popleft() recupera ed elimina il numero 2
Mediante una list comprehensions è possibile creare liste mediante regole matematiche:
sommeuno= []
for x in range(10)
…..sommeuno.append(x+1) #restituisce i numeri da 0 a 11 come elenenti successivi della lista sommeuno
per evitare di ricalcolare ogni volta la variabile x è possibile utilizzare una funziona lambda
sommeuno=list(map(lambda x: x+1, range(10)))
oppure anche così:
sommeuno=[x+1 for x in range(10)]
usando del è possibile rimuovere intere liste, singoli elementi o anche intere righe di una matrice specificandone la posizione
matrix[1,2,3,4]
del matrix(0) rimuove il numero 1
del matrix(2:3) rimuove solo i numeri 2 e 3
del matrix rimuove tutti gli elementi della matrice
Tuple
Le tuple sono come le matrici ma immodificabili. Si dichiarano senza racchiudere gli elementi fra parentesi quadre. Le operazioni matematiche di somma seguono le stesse regole delle stringhe:
tupla=1,2,3,4
Set
I set sono come le liste, ma non ammettono elementi duplicati. Si dichiarano racchiudendo gli elementi fra parentesi graffe
set={1,2,3,4}
Analogamente alle list.comprension esistono funzoni di indicizzazioni analoghe per i set dette set comprension (stessa sintassi)
Dizionari
Sono associazioni fra un elemento costante (es tupla) usato come indice ed elementi variabili come contenuto. La posizione di ogni contenuto è definito dalla chiave ad essa associato e non da un numero
diz=dict([(k1: a), (k2: b)])
diz(k3)= c # diventa k1:a , k2:b, k3:c aggiungendo l’elemento c in k3
del diz(k3) #rimuove l’elemento c
k2 in diz #restituisce true
k2 not in diz #restituisce false
Metodi di loop
I metodi di loop possono essere utilizzati per trovare tutti gli elementi di un dizionario
dizionario={k1:a, k2:b}
for k,v in dizionario.items()
……..print(k,v) #restituisce tutte le chiavi ed i rispettivi contenuti del dizionario
Il metodo enumerate() può essere utilizzato per restituire la posizione di tutti gli elementi di una sequenza
seq=[a,b,c]
for i, v in enumerate(seq)
……print(i,v) #restituisce: 1 a, 2 b, 3 c
usando reversed() invece di enumerate si fa la numerazione in ordine inverso
Usando sorted() è possibile riordinare gli elementi, zip() unisce 2 liste, set() elimina i duplicati
Moduli
I moduli consentono di richiamare funzioni scritte in file separati da quello principale (che terminano sempre con estensione .py). Alcuni di questi moduli richiamano anche librerie esterne e/o standard. I moduli sono anche utili per dividere programmi dal codice molto lungo. Le variabili definite in un modulo sono separate dal resto del programma.
Se ad esempio nel file somma.py definisco questa funzione:
def sum(x,y)
……z=x+y
…..return z
nel file principale del programma main.py potrò richiamarla così:
import somma
a=1
b=2
c=somma.sum(a,b)
print(c) #stampa il numero 3
E’ possibile anche importare le funzioni singolarmente nel software per poterle poi usare direttamente senza specificare il nome del modulo
from somma import sum
a=1
b=2
c=sum(a,b)
se scrivo
from nomemodulo import *
importerò con il loro nome tutte le funzioni di nomemodulo. Per non creare confusione tutavia questa dicitura di solito non si usa
E’ possibile anche definire nuovi nomi per le funzioni importate o rinominare i moduli importati. Esempio:
from somma import sum as sommare
in tal caso potrò scrivere c=sommare(a,b)
analogamente
import somma as plus
mi permette di chiamare la medesima funzione così:
c=plus.sum(a,b)
I moduli possono anche essere eseguiti come script:
esempio:
python somma(3,2)
va però aggiunto questo codice:
if __name__ == “__main__”:
……. import sys
……..somma(int(sys.argv[1]), int(sys.argv[2]))
I moduli possono anche essere “ompilati” per essere eseguiti più velocemente. In tal caso i file compilati .pyc saranno salvati nella cartella __pycache__. i nomi dei file .pyc saranno sempre nomemodulo.cpython-x.x.pyc ove x.x è la versione usata del compilatore. I file compilati si creano con il modulo compileall
Moduli standard
Richiamabili mediante l’istruzione import sys
sys.ps1 e sys.ps2 specificano il prompt di default del terminale
dir() restituisce il contenuto di un modulo. nell’esempio di prima
dir(somma)
restituisce
[__name__, sum]
Pacchetti
I pacchetti sono insiemi di moduli messi dentro una directory e facilmente richiamabili. La prima directory ed ogni sottodirectory è accompagnata sempre da un file __init__.py che può essere vuoto o anche fornire inizializzazione a tutti i moduli sottostanti. I moduli ed i sottomoduli all’interno del singolo pacchetto si possono importare singolarmente:
import nomepacchetto.nomemodulo.nomesottomodulo
Tutte le sintassi di importazione già viste per i moduli valgono anche per i pacchetti.
Per importare tutti i moduli in un pacchetto mediante import * from pacchetto bisogna specificare __all__ nel file __init__.py
__all__
…..”modulo 1″,
…..”modulo 2″,
…..”modulo n”,
se _all__ non è specificato i moduli vanno importati come mostrato prima singolarmente (pratica peraltro preferibile)
è possibile importare anche sottomoduli di un pacchetto mediante la seguente dicitura
from . import sottomodulo
in tal caso il pacchetto deve essere specificato in __main__
la variabile __path__ può essere utilizzata per definire pacchetti contenuti in più directory, tale pratica comunque non è raccomandata
Input e output
Ci sono diversi modi per dare un output a schermo in un file. Abbiamo già visto la funzione print() per dare un output nel terminale.
E’ possibile anche formattare delle stringhe in questi altri modi:
metodo {and}
numero= 10
alimento= ‘uova’
f’sul tavolo ci sono {numero} {alimento}’ # restituisce la stringa: sul tavolo ci sono 10 uova
usando il metodo str.format() è possibile formattare l’output della stringa fornita a piacimento
numerocampione= 34_25_33
percentualesuccesso=33,2677
‘il campione {:-9} presenta una percentuale di successo pari al {:2.2%}’.format(numerocampione,percentualesuccesso)
#risulterà la stringa: il campione 342533 presenta una percentuale di successo pari al 33,27%. Le due variabili fornite in un caso non avranno i trattini bassi e nell’altro sarà espressa in percentuale. Ci sono diversi operatori di questo tipo
Le variabili possono inoltre essere facilmente convertite in stringhe mediante le funzioni repr() e str(). repr() si usa per fornire output comprensibili all’interprete, mentre str() fornisce output leggibili all’uomo.
esempi:
str(1/2)
#restituisce ‘0,5’ (come stringa)
ciao=’ciao mondo\n’
ciaom=repr(ciao)
print(ciaom) #restituisce ‘ciao mondo\n’ nel terminale completo di sequenze di escape e apostrofi. Si può usare repr() con qualunque oggetto python
usare and con un uguale fornirà output come questo
primo=1
f’Romolo è il {primo=} re di Roma
#fornisce la stringa: Romolo è il primo= 1 Re di Roma
Usando il metodo string.format() è possibilre anche cambiare l’ordine delle variabili di output. esempio
a=’cinque’
b=’tre’
‘ci sono {0} gatti in {1} stanze’.format(a,b) #restituisce: ci sono cinque gatti in tre stanze
‘ci sono {1} gatti in {0} stanze’.format(b,a) #restituisce: ci sono tre gatti in cinque stanze
E’ possibile anche specificare gli argomenti del metodo string.format:
‘ci sono {gatti} gatti in {stanze}’.format(gatti=’cinque’,stanze=’tre’) #restituisce ci sono cinque gatti in 3 stanze
I due metodi possono anche essere combinati, come già visto per le altre funzioni/metodi. E’ possibile anche usare un dizionario per fornire gli input alla funzione in modo ordinato
i metodi str.rjust(), str.ljust() ed str.center() altro non fanno che giustificare l’output nella console rispettivamente a destra, a sinistra e al centro. Hanno solo funzione estetica e non modificano la stringa fornita
str.zfill(n) invece inserisce un numero di zeri pari a n a sinistra della stringa
‘z’.zfill(2) #restituisce 00z
l’operatore modulo (%) è un vecchio modo per formattare le stringhe espresso nel modulo math (dare a inizio file import math)
Leggere e scrivere files
Per leggere un file si usa la funzione open()
file=open(‘nomefile’,’w’,encoding=”utf-8″)
Specificando come secondo argomento ‘w’ il file potrà essere solo scritto dopo l’apertura. Per aprire un file in sola lettura specificare ‘r’. Specificare ‘r+’ permetterà sia la lettura sia la scrittura. Specificando ‘a’ (appending) i nuovi contenuti verranno aggiunti alla fine del file. Se l’argomento viene omesso il file viene di default aperto in sola lettura.
encoding=”utf-8″permette di aprire il file come file di testo. L’accapo a riga viene letto in tutti i sistemi operativi come \n. E’ possibile aprire anche i file come binari o altre modalità.
Per essere sicuri di chiudere un file correttamente senza perdere dati è opportuno accompagnare la funzione open() alla parola chiave with, come da esempio sotto:
with open(‘nomefile’,’w’,encoding=”utf-8″) as file
….. dati=file.read()
file.closed() #questa funzione eseguita ora verifica che il file sia chiuso
la funzione file.write() permette di scrivere nel file. Usare le funzioni di read o write su un file chiuso genererà un errore. Ora vederemo in dettaglio le funzioni di I/O su file
Metodi delle funzioni file()
file.read() permette di leggere il contenuto di un file, come già descritto sopra.
file.readline() legge una sola riga di un file, cioè fino al primo /n che trova
E’ possibile leggere facilmente un file riga per riga con un semplice ciclo for come questo sotto
for line in file
…. print(line, end=’ ‘) #si può ovviamente anche usare file.readlines() o la funzione list(file) al medesimo scopo per far tutto in un colpo solo
file.write(“stringa”) scrive la stringa all’interno del file. Tutti gli oggetti che si vogliono scrivere in un file di testo devono obbligatoriamente essere convertiti in stringhe usando la funzione str() (o in formato binario se si scrive in un file binario)
file.tell() restituisce un numero intero che è l’indice attuale del puntatore all’interno del file
file.seek() permette di cambiare la posizione del puntatore
file.seek(offset,whence)
ove offset è lo spostamento rispetto al punto whence (che di default è 0 che rappresenta l’inizio del file. Specificando 1 invece si intende la posizione corrente del puntatore, mentre 2 indica la fine del file procedendo al contrario). Nei file di testo la prima posizione deve essere sempre ricavata mediante file.tell() o essere pari a zero per non avere errori di lettura e comportamenti imprevedibili. Le opzioni 0 e 2 su whence sono valide solo per i file binari)
Salvare la struttura dei dati mediante il formato JSON
E’ possibile in python salvare i dati in modo nativo in un file mediante il formato JSON. Questo permette di bypassare i limiti delle funzioni di I/O viste finora che lavorano solo con stringhe, inoltre il formato JSON è ampiamente utilizzato per la condivisione di dati anche in altri ambiti oltre al python e da tante differenti applicazioni.
JSON sta per JavaScript Notification Object. Il processso di creazione di stringhe JSON è chiamato serializzazione, l’opposto si denomina invece deserializzazione.
E’ possibile vedere la stringa JSON espressione di una variabile mediante un semplice comando:
import json
var=[‘alfa’, ‘beta’, ‘gamma’, 1] #questa è ovviamente una lista
json.dumps(var) #questo comando genera come output la stringa [‘alfa’, ‘beta’, ‘gamma’, 1]
la funzione json.dump(var, file) invece crea un file di testo con la stringa all’interno riferita alla variabile specificata.
per recuperare l’oggetto nel file json è sufficiente utilizzare la funzione json.load(file)
NOTA: i file json sono codificati SEMPRE in UTF-8, usare quindi la giusta impostazione con la funzione open() per aprire e scrivere questi file!
Le funzioni finora viste per lavorare sui file JSON tuttavia non consentono di lavorare con oggetti molto complessi facilmente, per cui si usa di solito la funzione pickle che vedremo dopo. Lavorare con oggetti complessi può inoltre produrre anche dei rischi di sicurezza, in quanto è possibile eseguire in tal modo codice malevolo se non si fa attenzione.
Errori ed eccezioni
Qui è esposta una carrellata degli errori più comuni che si possono ottenere da un interprete python in caso di problemi con il codice:
SyntaxError
L’errore di sintassi è in assoluto il più comune errore del principiante ed è figlio di una digitazione ortograficamente errata del codice. In tali casi l’interprete mostra nella console ove si trova l’errore ortografico.
Le Eccezioni sono errori che avvengono eseguendo codice ortograficamente corretto. Sono accompagnate da una descrizione dell’errore. Esempi:
Divisioni per zero: ZeroDivisionError
Variabili utilizzate in una funzione ma mai definite prima nel codice: NameError
Tentativo di utilizzare funzioni su dati ove non è previsto (es. concatenare tipi di dati non stringa come gli interi): TypeError
E’ possibile scrivere codice che nel caso rilevi un’eccezione non fermi il programma ma porti a modifiche nella sua esecuzione (ad esempio chiedendo un cambio dei dati di input)
while True
…..try:
………..x=int(input(“dammi un numero\n”)
………..break
….except (ValueError,TypeError) #si possono specificare quante eccezioni si vuole
………print(“numero non valido. Riprova!\n”)
try permette di ripetere in questo modo il codice nel caso venga rilevato per l’input dato un ValueError o un TypeError, mentre il programma prosegue oltre l’esecuzione se l’input è corretto. Nel caso l’input sia gravato da un eccezione diversa da ValueError o TypeError il programma da errore e si arresta come se questo codice non ci fosse. Se un’eccezione è specificata in una classe (vedi poi) viene valutata solo nell’ambito di quella classe
Mediante il comando raise è possibile forzare un’eccezione all’interno di un programma
esempio:
raise NameError(“Eccezione!”)
scrivibile semplicemente anche senza argomento, che non verrà specificato quindi in console, come:
raise NameError
E’ possibile anche concatenare in questo modo diverse eccezioni per aiutare il debug del codice.
E’ possibile anche definire eccezioni personalizzate:
try
…..raise NameError
finally
….print(“errore personalizzato\n”)
finally esegue i suoi comandi senza terminare il try, permettendo di personalizzare l’output di errore
mediante il metodo exception.add_note è possibile aggiungere descrizioni alle eccezioni:
try:
….raise TypeError(“tipo sbagliato”)
except Exception as e
…..e.add_note(“informazioni sull’errore”)
….raise
Le classi
Sono strutture di dati che uniscono assieme dati e le relative funzioni per elaborarli.
Le classi sono così definite:
class nomeclasse:
….prima riga codice
….seconda riga
…riga n di codice
Le righe di codice possono essere sia variabili sia funzioni
esempio:
class primaclasse:
…. a=2
…. b=3
…. def somma(a,b):
……..c=a+b
……..return c
posso inizializzare la mia classe così:
cl=primaclasse()
Posso chiamare le variabili così:
cl.a =3 # ridefinisce a
cl.somma(a,b) #restituisce 6
E’ possibile anche definire le classi con variabili sempre di valore diverso al momento della loro inizializzazione aggiungendo il metodo __init__ sotto class:
def _init_(self,alpha,beta)
……self.a=alpha
……self.b=beta
Le variabili definite staticamente sotto class saranno quindi comuni a tutte le classi inizializzate di quel tipo, mentre quelle definite da init avranno valori specifici per ogni istanza. la parola chiave self è usata pe riferirsi alla classe stessa nella definizione della classe
E’ possibile definire funzioni o variabili anche fuori da una classe e poi includerle, tuttavia non è una cosa consigliata, per evitare di confondere il lettore
Possono inoltre esistere classi derivate da altre, che ne ereditano le caratteristiche, definibili così, ridefinendone altre:
class classederivata(classepadre):
…
…
…
E’ possibile usare come classi padre anche singoli moduli complessi di altre classi
La funzione isistance(oggetto.classe) restituisce true se l’oggetto è della classe specificata
La funzione issubclass(classefiglia,classepadre) restituisce true se la classe figlia è figlia della classe padre
E’ possibile anche creare classio derivate che ereditano pezzi da più classi padre separandole con virgole
mettendo due trattini underscore prima della dichiarazione di una variabile nella definizione della classe è possibile creare una variabile o una funzione privata, inaccessibile da fuori dalla classe:
__nomevariabile() #non si può accedere da fuori tramite classe.nomevariabile()
Breve introduzione alla libreria standard
Il modulo os permette di accedere alle funzioni del sistema operativo:
import os #non usare mai come dichiarazione from os import * perchè il modulo os deve rimpiazzare la funzione open() standard
os.getcwd() #restituisce la directory corrente
os.chdir(‘nome/cartella’) #cambia la directory corrente
os.system(“comando da terminale”) #esegue un comando da terminale di sistema
dir(os) restituisce tutte le funzioni nel modulo os
help(os) restituisce un manuale di utilizzo completo del modulo os
il modulo shututil permette di lavorare più facilmente con i file
import shututil
shututil.copyfile(‘fileorig’,’filecopia’) #copia il file fileorig in filecopia
shututil.move(‘/vecchia/posizione’,’/nuova/posizione’) #sposta un file
il modulo glob permette di ottenere una lista dei file in una directory
import glob
glob.glob(‘*,py’) #restituisce tutti i file con estensione .py nella dir attuale
Il modulo sys si usa per gestire gli argomenti da linea di comando
Il modulo re è utile per lavorare su stringhe complesse
Il modulo math fornisce operazioni matematiche più complesse
Il modulo random permette di lavorare con scelte e numeri casuali
Il modulo statistics fornisce funzioni per la statistica
Sono disponibili vari moduli per gestire le comunicazioni via web. Ecco alcuni esempi:
from urllib.request import urlopen #apre il fileUTC.txt dal sito web >>> with urlopen('http://sitoweb/UTC.txt') as response: ... for line in response: ... line = line.decode() # converte i bit del file in stringa ... if line.startswith('datetime'): ... print(line.rstrip()) # Remove trailing newline ... datetime: 2022-01-01T01:36:47.689215+00:00 >>> import smtplib #spedisce la mail da un server mail locale >>> server = smtplib.SMTP('localhost') >>> server.sendmail('pincopallo@example.org', 'pancopillo@example.org', ... """To: pincopallo@example.org ... From: pancopillo@example.org ... ... Ti mando questo messagio. ... """) >>> server.quit()
Il modulo datetime serve a maneggiare date ed orari.
Il modulo zlib permette di lavorare con i file compressi. Lo stesso fanno il gzip, il bz2, lzma, zipfile e tarfile
Il modulo timeit fornisce misure di performance del sistema relativo al codice dato come imput, utile in fase di debug
I moduli doctest e unittest sono anch’essi utili nel debug del codice
I moduli xmlrpc.client ed xmlrpc.server sono utilizzati in vari protocolli di comunicazione. Per usarli non serve necessariamente conoscere XML
Il modulo mail è utile per gestire le email
Il modulo json lo abbiamo già visto ed è utile per archiviare tipi complessi di dati in file come stringhe, oltre a permettere a python di comunicare con altri linguaggi
Il modulo sqlite3 permette di lavorare con database sqlite
Il modulo reprlib contiene una versione di repr() adatta ad accorciare gli output complessi su console
il modulo pprint contiene una versione miglioranta di print() adatta ad ottenere output con formattazione complessa
Il modulo textwrap contiene funzioni atte a generate output adatti alle dimensioni dello schermo
Il modulo locale permette l’accesso alle funzioni relative alla lingua ed internazionali
Il modulo struct contiene le funzioni pack() e unpack() utili per lavorare con i file binari
Il modulo threading consente di gestire applicazioni multi-thread (ad esempio per far funzionare un processo in bacvkground)
Il modulo logging consente ai programmi di generare log di errore e non solo (di default tali output da console non sono visibili)
Il modulo weakref consente di tracciare gli oggetti in memoria e rimuoverli automaticamente quando non più necessari
Il modulo array , il modulo collections ed il modulo heapq forniscono nuovi tipi di lista più maneggevoli e/o performanti. decimal fornisce un tipo di dati a virgola mobile più performante per applicazioni complesse.