Scarica Introduzione alla Programmazione Orientata agli Oggetti in Python - Prof. Boselli e più Appunti in PDF di Elementi di Informatica solo su Docsity!
CODIFICHE STRINGHE
Codifica: insieme di regole che permettono di associare concetti a configurazioni del supporto di memorizzazione/trasmissione. La stessa informazione può essere scritta su supporti differenti e con codifiche differenti. Lo stesso supporto può essere decodificato in maniera differente. PROBLEMA: Nell’informatica, la codifica del testo ha sempre creato problemi. Scenario (problema) tipico – Testo codificato con la codifica XYZ in sequenze di byte
- Sequenze di byte trasferite ad un altro programma/elaboratore
- Testo ricostruito usando una decodifica non adeguata
DIVERSE CODIFICHE PER IL TESTO
• ASCII
7bit per carattere, sono codificate solo le lettere dell’alfabeto inglese (niente lettere accentate)
- Latin-1 (ISO-8859-1) 8 bit per carattere, sono codificate le lettere delle principali lingue dell’europa dell’ovest Alcuni ‘slot’ sono lasciati non specificati (per sviluppi futuri)
- Windows- Variante del Latin-1, alcuni caratteri di uso poco frequente sono stati sostituiti
- Unicode
IL CODICE ASCII (American Standard Code for Information Interchange)
- è il codice alfanumerico più diffuso per scambio di informazioni fra sistemi di elaborazione
- costituisce di fatto uno standard per la codifica dell’informazione nei sistemi di elaborazione
- è codificato su 7 bit, quindi può rappresentare al massimo 2^7 = 128 simboli diversi Esiste una versione del codice ASCII che usa un ottavo bit (1 byte). Tale codice viene detto Codice ASCII esteso, ed è, ad esempio, usato nei personal computer IBM MS/DOS Es. ASCII code for space character: 32+0 = 32 ASCII code for 'L’: 64+12 = 76 ASCII code for 'a’: 96+1 = 97 PROBLEMA : non sono gestite le lettere accentate (non sono presenti nell’alfabeto inglese)
PER RISOLVERE IL PROBLEMA – DOPO L’ASCII
Per gestire i caratteri specifici delle lingue diverse dall’inglese sono state create diverse codifiche:
- ASCII estesa (8 bit)
- big5 (Traditional Chinese)
- iso-8859-1 “latin-1” (fra, ita, spa, ted…)
- iso-8859-7 (Greek)
- iso-8859-6 (Arabic)
- cp1140 (IBM Western Europe)
- … (ce ne sono un’infinità … una vera babele) Molte codifiche sono tra loro incompatibili. PROBLEMA: per decodificare correttamente una sequenza di bit, devo conoscere la codifica usata.
UNICODE
Lo standard Unicode è stato introdotto per rappresentare caratteri di testo in sistemi informatici, ed è stato assunto come standard internazionale con la sigla ISO/IEC 10646
- Unicode propone uno standard per rappresentare i caratteri e simboli di tutti i linguaggi scritti, simboli matematici etc.
- Arriva ad usare fino a 4 byte per carattere (file 4 volte più grossi rispetto alla codifica ASCII)
- 32 bit (4 byte)
- Codifica tutte le lingue conosciute
- Anche i segni speciali, es. © … VANTAGGI: codifica tutto! (per lo meno i caratteri delle lingue attualmente conosciute) Una stringa di caratteri Unicode necessita di un ulteriore trasformazione per poter essere salvata, scambiata tra sistemi, interpretata da un browser. Tale processo di trasformazione in stringa di byte (o anche stringa binaria) è demandato ad un codec.
DIRETTIVA CODING
- La direttiva coding stabilisce come decodificare le variabili create nello script
- Come scelgo la codifica per la direttiva coding?
- #coding=utf
- #coding:utf16 Alcuni modi corretti di scrivere la direttiva coding
-- coding: latin-1 --
- Dipende da come è stato codificato il file .py
- Gli editor di testo non usano tutti la stessa codifica
- Questo è il motivo per cui aprendo un file .txt con editor diversi ... a volte appaiono caratteri strani
- Per conoscere la codifica utilizzata, dovete consultare il manuale dell’editor DICHIARAZIONE ESPLICITA DI VARIABILI
- Esempio di script a="Cos'è quella scatola?” print(a) SyntaxError: Non-ASCII character '\xc3' in file es3_nolocale.py on line 1, but no encoding declared;
- Altro esempio: #coding=utf8 # utf8 è informazione di localizzazione a="Cos'è quella scatola?” print(a) # esecuzione senza problemi
- La direttiva coding deve essere inserita nelle prime due righe dello script
- In assenza di direttiva coding, in python 2.x (con x>=5): utilizzata la codifica ASCII
- Si può forzare python 2.x a memorizzare una stringa in Unicode: #coding=utf st='ciao' unst=st.decode('utf8') #decodifica da utf8 a unicode print(type(unst),unst) #(, u'ciao')
- … in forma breve unst=u'ciao’ #equivalente a : unst=‘ciao’.decode(‘…’) la codifica è quella specificata dalla direttiva coding
- La direttiva coding stabilisce come decodificare solo le variabili create nello script, per le altre variabili … LIBRERIA CODECS PER I FILE DI TESTO
- Python mette a disposizione la libreria codecs per aprire file di testo con codifiche diverse dalla ASCII import codecs f = codecs.open(’file.txt', ‘r’, encoding=’latin1’, errors=‘ignore’) … f.close()
- Permette di specificare dei parametri aggiuntivi rispetto alla open standard. Per il resto, il suo uso è identico alla libreria standard di apertura dei file – Si può continuare ad usare .read(), .readline() …
- Le stringhe lette dai comandi .read(), .readline(), vengono gestite in memoria come Unicode f = codecs.open(… encoding='utf-16’, errors=‘ignore’) Encoding e errors parametri opzionali: - possono non essere usati
- se usato: nome_parametro = valore
- encoding: permette di specificare la codifica
- errors: (possibili valori) ‘strict’, ‘ignore’, ‘replace’
- strict: il programma si blocca e genera un errore se incontra un carattere non riconosciuto nel file
- ignore: i caratteri non riconosciuti sono ignorati (come se non esistessero nel file)
- replace: si sostituisce un carattere speciale � ai caratteri non riconosciuti
Esempio import codecs f = codecs.open(’file.txt', ‘r’, encoding='utf-16’) for line in f: values=line.split(u‘;’ ) if values[0]==u”Rossi”: print(“Trovato”) f.close() I dati letti sono tutti memorizzati in stringhe in formato unicode.
STRINGHE E UNICODE
Cosa viene visualizzato (True o False)? #coding=utf print('ciao' == u'ciao') True Cosa viene visualizzato (True o False)? #coding=utf print('ciao né' == u'ciao né') False UnicodeWarning: Unicode equal comparison failed to convert both arguments to Unicode - interpreting them as being unequal Python 2.x cerca di convertire in automatico, ma non sempre riesce
encode()
A volte dobbiamo svolgere l’operazione contraria: passare da unicode a (raw) string Esempio frequente: libreria che richiede stringhe in formato ‘latin1’ #coding=utf import mialibreria # mette a disposizione la
funzione dosomething
st=u'Il libro è sul tavolo' rst=st.encode('latin1') #da unicode a sequenza di byte mialibreria.dosomething(rst) Potete utilizzare i metodi .decode() e .encode() per gestire le conversioni dei parametri in ingresso e in uscita di una funzione di una libreria esterna. Creazione di un file .csv per Excel Excel richiede che i .csv siano salvati usando la codifica ‘latin1’ #coding=utf import codecs f=codecs.open('data.csv','w', encoding='latin1', errors='ignore') cnt=u"""Nome;Cognome;Età Nicolò;Daprà; Jörge;Würst; """ f.write(cnt) #la libreria codecs esegue la conversione f.close()
chr() permette di passare da codice ASCII numerico (base 10) a carattere corrispondente >>>chr(60)
unichr() da codice Unicode numerico (base 10) a carattere corrispondente >>>unichr(102)
u’f’
ord() esegue l’operazione inversa: da carattere a codice numerico in base 10 >>>ord(‘<‘) >>>ord(u’f’)
PROGRAMMAZIONE AD OGGETTI
Finora abbiamo programmato scomponendo i compiti in funzioni (prog. strutturata o procedurale), ma un limite di questo approccio è leggere e aggiornare il programma. OOP (Object-oriented Programming) = paradigma di programmazione che prevede di assolvere i compiti con diversi oggetti che collaborano tra loro. Ciascun oggetto ha il suo insieme di dati (attributi) e di operazioni (metodi) che li elaborano. Nella OOP si creano oggetti che rappresentano elementi importanti di un’applicazione/parte realtà. PROGRAMMAZIONE PROCEDURALE I dati e le funzioni sono separate, e questo può creare una serie di problemi, perché è necessario:
- gestire dati e funzioni separatamente;
- importare le funzioni che vogliamo usare;
- passare i dati alle funzioni;
- verificare che i dati e le funzioni siano compatibili;
- è più difficile estendere e modificare le funzionalità;
- il codice è più difficile da mantenere;
PROGRAMMAZIONE AD OGGETTI
Gli oggetti svolgono la funzione di racchiudere in un unica unità organizzativa i dati e il comportamento. Questo ha diversi vantaggi:
- dati e funzioni sono raggruppati;
- è facile sapere quali operazioni possono essere eseguite sui dati;
- non è necessario importare funzioni per eseguire queste operazioni;
- non è necessario passare i dati alle funzioni;
- le funzioni sono compatibili con i dati;
- è più facile estendere e modificare le funzionalità;
- il codice è più semplice da mantenere;
CLASSI
Python da’ la possibilità di “impacchettare assieme” dati e funzioni (che lavorano sui dati) tra loro
- Esempio class file : #classe file (l’abbiamo usata senza saperlo) name=‘…’ #variabile, memorizza il nome del file def readline(…): #codice per leggere … #istruzioni … def close(…): #chiusura del file #istruzioni … All’interno di una classe, funzioni e variabili vengono chiamati metodi e attributi
OGGETTI
E’ comodo usare il concetto di classe su insiemi di dati diversi. Es. >>>f = open("prova.dat", “r") >>>g= open(”dati.txt", “w”) f e g sono due oggetti, cioè 2 istanze della classe file. Ogni oggetto eredita i metodi della classe, tuttavia i dati (i valori degli attributi) sono gestiti separatamente Es. >>>f.name ‘prova.dat’ >>>g.name ‘dati.txt’ >>>f.close() E’ possibile richiamare i metodi o accedere agli attributi di un oggetto >>>g.close() con la notazione punto
CLASSE = insieme di codice che contiene attributi e metodi Incapsulamento: il codice è diviso in • Interfaccia pubblica (insieme dei metodi di una classe)
- Implementazione privata dell’interfaccia (attributi) Polimorfismo: metodi con lo stesso nome invocati su oggetti diversi, ottenendo comportamenti differenti in base al contesto Ereditarietà: la possibilità di creare delle sottoclassi che modificano/specializzano/estendono il codice contenuto nel genitore
METODI
- Metodi modificatori che apportano modifiche all’oggetto su cui agiscono (es. setNome())
- Metodi di solo accesso (accessori) che interrogano l’oggetto su cui agiscono per ottenere informazioni senza modificarlo (es. getTotale()) f.readline() di che tipo è? f.write(“stringa”) di che tipo è?
METODO COSTRUTTORE
Esempio: class Villetta: def init(self, proprietario, indir): self.p = proprietario self.i = indirizzo def getDati(self): return "Villetta di %s in %s." % (self.p, self.i)
L’istruzione seguente richiama il costruttore
v1=Villetta('Rossi', 'Corso Italia 1')
L’interprete python è come se eseguisse v1 = Villetta(???, 'Rossi', 'Corso Italia 1’)
print(v1.getDati())#Villetta di Rossi in Corso Italia 1. Costruttore: init(self, … ) serve per inizializzare le variabili dell’oggetto. Il primo parametro di un metodo è sempre self. Il costruttore serve per • impostare i valori iniziali degli attributi
- eseguire eventuali lavori preparatori Esempio: v1=Villetta('Rossi', 'Corso Italia 1’) #v1 è ist. di class Villetta v2=Villetta('Verdi', ’P.za Piola 22’) #v2 è un’altra istanza print(v1.getDati() ) #Villetta di Rossi in Corso Italia 1. print(v2.getDati() ) #Villetta di Verdi in P.za Piola 22.
PARAMETRI OPZIONALI
Nei parametri formali di una funzione possono essere inseriti anche dei parametri opzionali: Esempio: Utilizzo: def interessi(capitale, tasso=0.05): >>>s=interessi(100) i=capitale*tasso >>>print(s) return i 5 c = interessi(prestito) >>>print(interessi(100, tasso=0.12)) … 12 Data una funzione: def fun1(par1, par2, opz1=100, opz2=False): …… I parametri attuali vanno disposti in questo modo: >>>a=fun1(10, 20, opz2=True, opz1=2) i parametri obbligatori vengono mappati sulla base della posizione i parametri opzionali vengono mappati in base al nome citato
METODI PARAMETRI OPZIONALI
I parametri opzionali possono essere usati sia nelle funzioni sia nei metodi degli oggetti. Es. def open(filename, mode, encoding=‘ascii’, errors=‘ignore’) #codice Es. uso dei parametri opzionali nei metodi : Valore di default del parametro opzionale Nell’invocazione di una funzione, i parametri opzionali vanno sempre per ultimi Viene utilizzato il valore di default se non è specificato il parametro opzionale Namespace: par1= par2= opz1= opz2=True Class CsvReader4: def init(self, fname): self.f=open(fname,'r’) def readRecord(self, sep=‘;’): line = self.f.readline() if line=='': return [] else: line = line.strip('\n') records = line.split(sep) return records cr = CsvReader4('prova.csv') r=cr.readRecord() while r!=[]: print(r) r=cr.readRecord()
EREDITARIETA’
L’ereditarietà rappresenta una relazione tra :
- Una superclasse (classe padre), più generica
- Una sottoclasse (classe figlia), più specifica La classe figlia eredita i dati (attributi) e il comportamento (metodi) dalla classe padre. Vantaggi:
- Il vantaggio dell’ereditarietà è quello di condividere parti di codice
- Permette di rappresentare oggetti aventi comportamenti diversi Spesso la diversità tra oggetti può essere espressa con una semplice variabile di oggetto, in questo caso non serve l’ereditarietà. Esempio:
- Se due veicoli differiscono solo per il consumo di benzina, usa una variabile di oggetto (es. kmPerLitro)
- Se due veicoli si comportano in modo differente, usa l’ereditarietà (es. auto e camion)
SOTTOCLASSE
In Python si definisce una sottoclasse specificando cosa la rende diversa dalla sua superclasse. Le sottoclassi ereditano dalla superclasse: – tutte le variabili di oggetto
- tutti i metodi che non si modificano La sottoclasse può aggiungere: – Variabili nuove (non presenti nella superclasse)
- Metodi nuovi (non presenti nella superclasse)
- Metodi che modificano il comportamento di metodi ereditati (sovrascrivono = override) Esempio: class Animale: #classe padre def init(self, nome): self.nome = nome def parla(self): print(“”) class Gatto(Animale): #classe figlia def parla(self): #overriding print("Miao!”) class Cane(Animale): #classe figlia def parla(self): #overriding print("Bau!”) g = Gatto("Garfield") g.parla() #Miao! c = Cane("Rocky") c.parla() #Bau!
- def class Figlia(Padre): La classe Figlia eredita dalla classe Padre tutto. es.: – il costruttore,
- l’attributo self.nome
- Overriding: quando una classe Figlia ridefinisce un metodo della classe Padre Es., il metodo parla()
- parla() e' un esempio di polimorfismo. Ha un comportamento diverso a seconda dell’oggetto su cui viene invocato.
EREDITARIETA’ MULTIPLA
class Camion(): def init(self, targa, proprietario): self.targa=targa self.prop=proprietario def getNumRuote(self): return 6 def getProprietario(self): return self.prop class Cisterna(): def setQtTrasp(self, qt): self.qt=qt def getQtTrasp(self): return self.qt class Autocisterna(Camion, Cisterna): def getNumRuote(self): return 8 a=Autocisterna('DF645HK','Rossi') a.setQtTrasp(50) print(a.getQtTrasp()) # print(a.getNumRuote()) # print(a.getProprietario()) #Rossi CONFLITTI class Auto(): def getNumRuote(self): return 4 def getNumPosti(self): return 5 class Barca(): def getLunghezza(self): return 5 def getNumPosti(self): return 10 class Anfibio(Barca, Auto): def colore(self): return "Rosso" af = Anfibio() print(af.getNumRuote()) # print(af.getLunghezza()) # print(af.getNumPosti()) # Una classe può ereditare da più padri class Figlia(Padre1, Padre2, …): La figlia eredita tutti i metodi ed attributi delle classi padri. La classe figlia può effettuare l’overriding di metodi, es. getNumRuote().
- Conflitto: due classi padri offrono un metodo con lo stesso nome. Ma in python, può esistere un solo metodo con lo stesso nome.
- Criteri di scelta del metodo che la figlia erediterà (da alto al basso):
- metodo nella classe figlia che fa overriding (se presente)
- la classe padre che appare più a sinistra tra le () nella dichiarazione della classe figlia Es. getNumPosti(). - No overriding: in Anfibio, non è definito getNumPosti() - getNumPosti() di Barca prevale sul metodo della classe Auto
INCAPSULAMENTO
Interfaccia pubblica della classe = insieme di tutti i metodi della classe, e la descrizione del comportamento Incapsulamento = è la strategia di mettere a disposizione un’interfaccia pubblica, mantenendo nascosti i dettagli implementativi. Es. usando un programma che è operativo da molto tempo, è normale che alcuni dettagli implementativi siano cambiati per rendere gli oggetti più efficienti, tenendo nascosti tali dettagli i miglioramenti non costringono chi usa il programma a fare modifiche dei dettagli implementativi. import codecs #Gest. file tradizionale f = codecs.open(’file.txt', ‘r’, encoding='utf-16’) f = open(’file.txt', ‘r’) s=f.readline() s=f.readline() f.seek(15) f.seek(15) f.close() f.close() Incapsulamento e Polimorfismo
- Entrambi gli oggetti condividono un’interfaccia comune (metodi readline, seek, close …)
- Diversa implementazione
- Comportamento diverso a seconda del contesto (scrivere/posizionarsi su un file UTF16 è diverso dallo scrivere/posizionarsi su un file ASCII) ENCAPSULATION: PROBLEMA Esempio: Il programma utilizzatore della class Studente ha avuto accesso alla struttura dati interna della classe. La struttura dati interna della classe è cambiata MA non è stato adeguato il codice del programma utilizzatore. class Studente(): def init(self, nome): self.nome = nome s=Studente("Mario Rossi") print(s.nome.upper()) #MARIO ROSSI #Modifico la classe Studente class Studente(): def init(self, nome): self.nome = nome.split(' ') s=Studente("Mario Rossi") print(s.nome.upper()) AMO FOLLEMENTE GIOGOTTA E LO SPOSERO’ #AttributeError: 'list' object has no attribute 'upper' RISOLVO IL PROBLEMA class Studente2(): def init(self, nome): self._nome = nome def getNome(self): return self._nome Le modifiche al codice sono frequenti, per modificare (tutti) i programmi che utilizzano una classe modificando solo la classe uso l’encapsulation. con s.nome accedo direttamente all'attributo s.nome è una stringa su cui posso richiamare il metodo upper() class Studente2(): def init(self, nome): self._nome = nome.split(’ ‘) def getNome(self): st="" for el in self._nome: st=st+el+' ' return st s=Studente2("Mario Rossi") print(s.getNome().upper()) #MARIO ROSSI
ECCEZIONI
Un’eccezione è un evento accidentale (spesso un errore) che accade durante l’esecuzione di un programma, che interrompe il normale flusso di esecuzione. Quando in uno script python viene sollevata un’eccezione:
- il programmatore può specificare del codice per gestire un’eccezione
- se il codice riesce a gestire l’eccezione, l’esecuzione del programma può continuare
- se l’eccezione non può essere gestita l’esecuzione dello script viene interrotta Un’eccezione è rappresentata attraverso un oggetto python (classe exception). Si possono definire nuove eccezioni con le classi.
MESSAGGI DI ERRORE
Traceback (most recent call last): File "", line 1, in? ZeroDivisionError: integer division or modulo by zero >>> 4 + spam* Traceback (most recent call last): File "", line 1, in? NameError: name 'spam' is not defined
Traceback (most recent call last): File "", line 1, in? TypeError: cannot concatenate 'str' and 'int' objects L'ultima riga di un messaggio di errore indica cos'è successo. Le eccezioni sono di diversi tipi, ed il loro tipo viene stampato come parte del messaggio.
GERARCHIA DELLE CLASSI DI ECCEZIONI
Ce ne sono molte di più, per es. NameError, AttributeError, SyntaxError …
ESEMPIO
Nel codice sotto, l’inserimento di uno 0 nella variabile d genera un errore. Potrei cercare di prevenire il problema con un’istruzione condizionale:
- Appesantisco il codice
- Immaginate di dover “mettere in sicurezza” con le istruzioni condizionali il codice seguente : n=input("Numeratore? ") # d=input("Denominatore? ") # print(n/d) #ZeroDivisionError: … n=input("Numeratore? ") d=input("Denominatore? ") if d!=0: print(n/d) else: print('Errore') r1 = n1/d r2 = n2/d r3 = n3/d
GESTIONE DELLE ECCEZIONI IN PYTHON
Il bloco try…except (#B1) viene eseguito … se non vengono sollevate eccezioni, il codice del blocco except non viene eseguito. Se nel blocco try…except viene sollevata una eccezione “ZeroDivisionError” :
- l’esecuzione del blocco try…except si interrompe
- viene subito eseguito il blocco di codice dopo la except (#B2)
- infine l’esecuzione riprende dal blocco di codice successivo a quello dopo la except (#B3) Se nel blocco try…except viene sollevata un’eccezione diversa dalla “ZeroDivisionError” l’esecuzione del programma viene interrotta.
ESEMPIO DI SINTASSI DELLA TRY…EXCEPT
try: #codice che potrebbe sollevare eccezioni (suite try) except NomeEccezione1: #clausola except #Codice per gestire l’eccezione 1 (gestore) except (NomeEccezione2, NomeEccezione3): #più eccezioni vanno messe tra () #Codice per gestire sia Eccezione 2 sia Eccezione 3 else: #opzionale (suite else) #codice eseguito solo se non vengono sollevate eccezioni Se nel blocco try…except
- vengono sollevate Eccez1, Eccez2, Eccez3, queste vengono gestite nei corrispondenti blocchi except
- qualsiasi altra eccezione non specificata in una except causa l’interruzione del programma
- Se nella suite try non vengono sollevate eccezioni, vengono saltate tutte le except e il programma continua l’esecuzione try: r1 = n1/d1 #blocco B r2 = n2/d r3 = n3/d except ZeroDivisionError: print("Divisione per 0") #B print("Controlla i valori") print("Fine programma”) #B
CLAUSOLA FINALLY
try : enunciati finally: enunciati A volte è necessario che alcune azioni vengano eseguite indipendentemente dal fatto che sia stata sollevata un’eccezione oppure no, la clausola finally serve a questo Usate la clausola finally ogni volta che dovete “fare pulizia”, ad esempio chiudendo un file
RIEPILOGO SINTASSI
