Sei sulla pagina 1di 15

lOMoARcPSD|7207373

Teoria Python

Computer Science (Università Commerciale Luigi Bocconi)

StuDocu non è sponsorizzato o supportato da nessuna università o ateneo.


Scaricato da ZhuoHao Hu (hualex26@gmail.com)
lOMoARcPSD|7207373

COMPUTER SCIENCE

Programmazione: insieme ordinato di istruzioni che un computer con competenze tecniche e soft skills
deve seguire per terminare un compito attraverso precise istruzioni che spacchettano il problema in attività
più semplici da eseguire con operazioni base  processo di sviluppo del software: analisi dei requisiti,
progettazione di cosa deve fare, implementazione delle linee guida con algoritmi che sono sequenze finite
di azioni codificate che risolvono il problema razionalizzando idee in pattern di istruzioni prima di tradurle in
uno specifico di programmazione (debugging elimina errori) e test (esecuzione)

Hardware: CPU che svolge operazioni, Memoria ROM RAM e di massa e dispositivi input/output che
comunicano attraverso canali BUS. Servono linguaggi di programmazione di alto libello in cui le istruzioni
diventano linguaggio macchina traducendo le informazioni in sequenze di 0 e 1 compreso dalla CPU,
attraverso:

- Compilazione: programma compilato produce un eseguibile utilizzabile direttamente


velocemente ma con difficoltà ad individuare gli errori
- Interpretazione: traduzione istruzione per istruzione con esecuzione lenta ma con difficoltà ad
individuare gli errori

Dal linguaggio macchina a Assembly, poi ad alto livello come Python. Il linguaggio di programmazione è
formale, specifica le istruzioni che un calcolatore può comprendere per risolvere un problema, con diverse
sintassi ma stesse logiche e regole di programmazione  quelli di alto livello usano sintassi simile
all’inglese, si dividono in:

- Dichiarativi: esplicano obiettivo


- Procedurali: definiscono algoritmi che portano all’obiettivo

Python: è sia procedurale che dichiarativo  di alto livello, interattivo, orientato agli oggetti in quanto
risolve problemi non con sequenze di istruzioni ma con attributi degli oggetti, ideato da Van Rossum nel
1989 e rilasciato nel 1991, per correggere i difetti degli altri linguaggi e prenderne punti di forza, il nome
deriva dal gruppo di comici inglesi Monty Python. Crea prototipi di applicazioni da ri-sviluppare grazie a
linguaggi più complessi. Diverse versioni ne hanno accresciuto la popolarità e la semplicità di utilizzo, è
open source, ampliato con librerie, è compatibile con i sistemi operativi più diffusi. È interattivo, ovvero si
possono scrivere le varie istruzioni nel prompt di comandi (shell); tipizza dinamicamente le variabili che
contengono dati calcolati dal programma.

Idle (integrated development and learning environment), ambiente di programmazione con:

- Shell: interprete in modalità interattiva a riga di comando, primo foglio quando si apre il
programma, ha messaggio di apertura seguito dal prompt >>> che indica che è pronto a
ricevere nuove istruzioni, che se sbagliate mostrano un messaggio di errore. Non si modifica o
cancellano comandi ma vengono riscritti, non si può ripulire ma va riavviata con Restart o
ctrl+f6; una volta chiuso il programma i dati non vengono salvati
- Editor: in modalità script, si apre con new file o ctrl+n, salva file con estensione .py; vengono
scritti programmi per intero che vengono eseguiti con run, run module o f5
- Configure idle: possono essere modificate e contengono keys con shortcut (combinazioni tasti).
History-previous alt+p richiama ultimo comando inserito che si vuole riscrivere. Si vede a quale
elemento corrisponde ogni colore (viola per funzioni built-in, verde per stringhe di testo e
commenti fuori dalle righe del codice, blu per output o nomi della funzione, rosso per errori e
commenti inseriti nelle righe preceduti da #, arancione per key-words

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

Per scrivere un programma va aperto editor e poi salvato il file con save as.

- Save si usa per file già rinominati poi modificati.


- Save as copy as per salvare una copia del file mantenendo aperto l’originale.
- Run module per eseguire il programma dopo averlo salvato.
- Check module per controllare errori di sintassi (altrimenti invalid syntax prima che venga
eseguito nella shell
- Dx sul file e selezionare apri e edit with idle per aprire e eseguire file.

Sintassi: formata da keywords con significato ben preciso da non usare per altri scopi, operatori,
punteggiatura e altri disposti nelle righe, non è rigida con gli spazi ma è preferibile lasciarli per leggibilità e
coerenza, è rigido per indentazione.

Keywords: and continue finally is raise as def for lambda return assert del from none true async elif global
nonlocal try await else if not while break except import or with class false in pass yield

Operatori matematici: numeri sono operandi e operazioni sono operatori matematici: + - * / (divisione con
resto) // (divisione senza resto) (con divisione si tronca la parte decimale non arrotondando se numero è
positivo e arrotondando per difetto se il risultato è negativo) % (modulo divide due numeri interi e
restituisce solo il resto) ** (esponente eleva a potenza); gli unici da utilizzare con le stringhe sono + che le
concatena e * che le ripete più volte. Non è possibile operare tra stringhe anche se il contenuto sembra
numerico.

Espressioni matematiche: operazioni tra parentesi poi applicato operatore con precedenza più alta, quindi
elevamento a potenza, moltiplicazione e divisione, addizione e sottrazione. Operatori con stessa priorità
valutati da sx verso dx, eccetto elevamento che va da dx a sx.

Stringhe di testo: racchiusa tra apici o virgolette, a seconda dei caratteri che contiene all’interno. Su più
righe si usano tripli appici o triple virgolette, se vogliamo andare a capo senza che l’output finale vada a
capo va inserito prima di andarci il blackslash (\)

Errori:

- Sintassi: syntax error, invalid syntax


- Esecuzione del programma: sintassi corretta ma nameerror, typeerror, con spiegazione sotto
l’ultima riga

Commenti: documentare passaggi e aggiungere note esplicative, se sulla stessa riga di codice iniziare con #
e sarà rosso (commenti), se su una riga a sé con tripli apici o triple virgolette (stringa di documentazione),
comandi preceduti da backslash / dentro la stringa (codici di escape): i più comuni sono funzioni built in

Funzioni built-in: parti di codice preconfezionate che eseguono operazioni in viola con testo tra virgolette o
apici in verde e altre parti in nero, nome va scritto tutto minuscolo, dopo averla scritta compare riquadro
giallo call tip della sintassi con parametri da inserire separati da virgola (si può modificare con show call tip).
Una funzione favorisce la creazione di un programma modulare, esegue compito specifico e restituisce
valore quando termina, se non o fa è void (vuota) e il valore non può essere memorizzato e riutilizzato. Le
funzioni produttive terminano sempre con return che ne chiude il corpo e dopo quello che viene scritto non
viene più preso in considerazione (non c’è nelle void). Funzioni produttive: inserendo return alla fine il
risultato rimane in memoria e si può richiamare, non produttiva è void, non mantiene il risultato.

Un elenco di elementi separati da virgole e tra parentesi tonde è una tupla, se tra quadre è una lista

Print: stampa sullo schermo una stringa di testo con parametri value da stampare, ‘ ‘ come sep che
indica con cosa separare i vari elementi, \n come end

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

Help: supporti che ricercano informazioni, nella shell in modalità interattiva trova dati su ogni
elemento. Help() visualizza informazioni su più elementi in sequenza. Python 3.x Manuals include la
documentazione navigabile.

Format: si possono formattare numeri, con argomenti (value, ‘format_spec’), formato tra apici
indica di prendere fino a una data cifra decimale, f=float (decimale); ‘.%’ moltiplica per cento; ‘,.2f’ prende 2
cifre decimali e separa le migliaia.

Funzioni matematiche: sum, pow (eleva a potenza), abs (valore assoluto), max e min, round
(arrotonda il numero float alla cifra indicata come secondo elemento)

Range: >>>range(start,stop,step). Start è numero di partenza intero (default 0), stop è il numero di
arrivo intero (escluso dal conteggio, fa fatto n finale+1), step individua intervalli tra un numero e l’altro che
la funzione può mostrare (default 1). Inserendo n float typerror: ‘float’ object cannot be interpreted as an
integer

Funzioni della libreria standard: già installate ma vanno richiamate se si vogliono utilizzare in un nuovo file

Funzioni di librerie esterne

Variabili: nomi che rappresentano un valore contenuto nella memoria del computer. Va inizializzata
dandole nome e valore con =operatore di assegnazione iniziale che si può modificare (>>> nome=valore). Si
possono usare nelle funzioni ma se non sono state inizializzate si restituisce nameerror name is not defined.
Vanno usati nomi significativi, brevi, iniziare con una minuscola o _ e un numero, non si usano caratteri
speciali, più parole separate da underscore_, vanno utilizzati caratteri minuscoli perché Python è care
sensitive. Se variabili chiamati come funzioni le funzioni perdono la loro utilità e se si usa ci sarà errore
Typeerror ‘int’ object is not callable. Per ristabilire validità della funzione va riavviata la shell. Processo di
riassegnazione elimina valore precedente dato dalla memoria, anche con un dato di un altro tipo
(tipizzazione dinamica, non va specificata perché ci pensa da solo: int, float (numero reale a virgola mobile),
bool (valore logico vero o falso), str (stringa di testo alfanumerico)). Per inizializzare più variabili insieme si
usa lo spacchettamento (assegnazione multipla)  operare con dati misti: il risultato dipenderà dai dati
usati, infatti int con int da int, float con float da float, int con float da float.

Funzione type: per riconoscere il tipo di dato del valore in questione, ma non esiste un tipo dato come
valuta, se si vuole una formattazione in valuta bisogna usare la funzione format, usando + al posto della
virgola la funzione non restituisce lo spazio tra $ e il numero). Es. >>>>total_amount=1000.90 >>>>
print(‘total amount: $’+format(total_amount,’.2f’)).

Funzione int: prende un valore e lo converte se possibile in un numero intero, per convertirlo ad un altro
tipo di dato nomevaribile_int=(nomevariabile). Se la conversione non è possibile esce valueerror: invalif
literal for int(). Convertendo float in int i numeri dopo il punto vengono troncati e non arrotondati.

Funzione float: converte interi e stringhe se possibile in numeri a virgola mobile

Funzione str: converte valore dell’argomento in stringa di testo (ad esempio per visualizzare un formato in
valuta)

Funzione input: fa immettere dati nella tastiera, usata con le variabili per essere usato come variabile,
restituito uno str, anche se si tratta di un valore numerico, se provato ad usare come tale restituisce errore.
Assegna un valore a una variabile. Affinchè restituisca dato diverso va usata funzione di conversione.

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

Strutture decisionali: dai codici sequenziali formati da funzioni che danno istruzioni una dopo l’altra
passiamo a condizioni e parametri che permettono di applicare scelte diverse (decisionali), implementate
con l’uso di istruzioni condizionali, possono essere semplici (esecuzione condizionale o ad alternativa
singola) e alternativa (o alternativa doppia) o condizioni in serie

If: istruzione condizionale, presente condizione per cui si eseguono istruzioni a,b.., se falsa si salta il blocco
di istruzioni

Espressioni booleane:

- if, possono restituire True o False (maiuscola obbligatoria) di tipo bool, non stringhe, usano
operatori di confronto  == (uguale a), != (diverso da), <, <=, >, >=  = è operatore di
assegnazione e == di confronto (si applicano tra variabili dello stesso tipo)
- if-else: ad alternativa doppia, si procede in modo duale, se if è vero si procede con le istruzione
a e b, se falsa con le istruzioni dell’else c e d
- i-elif-else: uguale alla struttura if-else ma con comando elif nel mezzo, insieme di else e id
costruendo strutture decisionali ad alternativa multipla

Operatori logici:

- and: contemporaneamente
- or: una delle due
- not: è falsa?
- Pass: operazione nulla che lascia le funzioni in sospeso

Costrutti iterativi: cicli: strutture di controllo per eseguire lo stesso blocco di codice più volte, controllati da
una condizione o da un contatore, differiscono per l’indicazione di quante volte ripetere:

- Ciclo while: controllato da una condizione, composto da clausola con condizione che assume
valori bool True/False e termina con due punti, blocco di istruzioni indentate. Quando la
condizione diventa falsa si esce dal ciclo e si passa all’esecuzione degli altri comandi, se non ha
fine definibile si usa while true con cui non si ribattezza la variabile prima di inserirla nel ciclo,
ma si deve usare keyword break if che permette di uscire dal ciclo
- Ciclo for: controllato da un contatore che determina numero di volte in cui si ripete, composto
da clausola for con nome di una variabile contatore, parola in (range) e due punti, poi blocco di
istruzioni indentate. Alla variabile contatore viene assegnato il primo valore di lista o range e a
quelle successive il valore della variabile incrementato, con numero di esecuzioni limitato.
- Cicli nidificati: inserendo for e while all’interno di altri cicli

Break per interrompere esecuzione di un ciclo forzandola e continue per attendere di completare la
scrittura delle istruzioni ma evitando di interrompere il programma

Funzioni personalizzate: create, si assegna un nome nel programma, si costruiscono programmi modulari
che permettono di riutilizzare il codice, semplicità e miglioramento nella fase di test. Va definita con def
nome della funzione (senza spazi, prima lettera non numero, niente parole chiave), tra parentesi parametri
(stringhe tra apici o virgolette) che indicano argomenti d’input, due punti, istruzioni indentate. Se non
servono parametri si scrivono parentesi vuote. Per far partire funzione va digitato nome nella shell.

Parametri: divisi da virgole, definiscono funzione, sono segna posti degli argomenti. Obbligatori (necessari)
o opzionali (hanno valore predefinito da assumere), vengono assegnati in ordine di come appaiono tra
parentesi negli argomenti della funzione. Sono denominati se si sceglie quale parametro assumerà quale
valore.

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

Variabili: locali definite nella funzione utilizzabili solo dalle istruzione all’interno (altrimenti da errore),
globali utilizzabili da ogni funzione e istruzioni del programma. Docstring: stringa di documentazione che
spiega o da informazioni, va inserita tra virgolette e subito dopo la definizione della funzione.

Funzioni con cicli: all’interno cicli o strutture condizionali if elif else, senza differenze di funzionamento,
distinguendo sempre tra funzione void e meno che salvano i valori se si inserisce return

Sequenze: oggetto che contiene diversi dati, usate in varie funzioni e operazioni:

- Stringhe: sequenza alfanumerica di caratteri, tra apici o virgolette, sono immutabili, per
modificare il contenuto di una stringa assegnata alla variabile va riassegnata la stringa corretta
alla variabile, oppure creare una nuova variabile. Operazioni tra stringhe effettuabili con
operatori matematici  + (concatena senza spazi tipi di dati uguali) * (ripete n volte stringa
iniziale) in (true se la stringa è contenuta in un’altra altrimenti false) not in (contrario in), is
(true se stringa uguale a un’altra sennò false)
- Liste: raccolta di diversi dati, chiamati elementi, racchiusi tra parentesi quadre e divisi da
virgole. Possono contenere tipi di dati diversi, non uniformi. Funzione print(lista) per
visualizzarne il contenuto. Operazioni  + (unisce più liste anche di dati diversi) * (lista che è
ripetizione di quella iniziale) in (true se contenuto nella lista altrimenti false) not in (contrario
in)

Indicizzazione (indexing): accede a singoli elementi di stringhe o liste che hanno una determinata posizione.
Se conteggio parte da sx si hanno numeri positivi da 0, se da dx numeri negativi da -1 (>>>sequenza[indice])

Slicing: seleziona precisa parte di stringa o lista attraverso gli indici.


(>>>sequenza[indice_iniziale:indice_finale]) se iniziale omesso parte da posizione 0, se omesso il finale
avviene da fine sequenza. Si può introdurre lo step per selezionare posizioni equidistanti (come range). Lo
slicing si fa anche con indici negativi, ma deve essere anche questo negativo. Per usare step negativo con
indici positivi va invertito l’indice iniziale con il finale. Lo slicing si usa anche per modificare uno o più
elementi dello slicing (date liste mutabili).

Funzioni delle stringhe: prevedono sintassi con argomenti stringhe o variabili contenenti stringhe:

- len() restituisce lunghezza stringa contando i caratteri, usata nei cicli dentro range
- min() restituisce valore più piccolo (nell’alfabeto si parte da ‘a’), distingue maiuscole e minuscole
- max() restituisce valore più grande (nell’alfabeto si parte da ‘z’), distingue maiuscole e minuscole

Metodi delle stringhe: legate a un preciso oggetto secondo la forma stringa.metodo(argomenti), ognuno
restituisce:

- upper() stringa dei caratteri maiuscoli


- .lower() stringa dei caratteri minuscoli
- .capitalize() stringa con prima maiuscola e poi tutte minuscole
- .strip() stringa con spazi iniziali e finali rimossi
- .find(sub) indice della prima occorrenza trovata cercando sottostringa specificata ‘sub’, se non viene
trovata restituito -1
- .replace(old,new) stringa con occorrenze della old sostituite con la new
- .startswith(prefix) true se all’inizio trova il prefix, altrimenti false
- .endswith(subfix) true se alla fine trova subfix, altrimenti false
- .count(sub) numero volte in cui compare sottostringa cercata nella stringa
- .split(iterable) lista di stringhe dividendo l’iniziale ad ogni spazio predefinito (possibile un separatore
diverso come argomento). Maxsplit indica numero massimo di divisioni da effettuare (-1 predefinito
indica di separare fino a fine stringa)

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

- .join(iterable) concatena elementi di una lista di stringhe in una stringa unica applicandola a un
separatore ‘ ‘, mentre la lista è argomento tra parentesi

Funzioni delle liste: built-in, restituiscono:

- len() numero elementi (lunghezza)


- min() elemento che inizia con valore minore, se gli argomenti della lista sono misti restituisce errore,
distingue minuscole e maiuscole
- max() elemento che inizia con valore maggiore, se gli argomenti della lista sono misti restituisce errore,
distingue minuscole e maiuscole
- list() converte oggetto iterabile in una lista
- sorted() restituisce lista ordinata in maniera crescente, se ha argomenti misti restituisce errore
- sum() somma elementi della lista se sono tutti numeri

Metodi delle liste: (alcuni non funzionano per liste a valori misti)

- .append(element) accoda alla lista nuovi elementi, si usa nelle istruzioni dei cicli creando una lista
vuota a cui aggiungere valori
- .insert(index,element) inserisce elemento chiesto nella posizione dettata dal parametro index.
Elemento precedente presente nella posizione non viene eliminato, ma si sposta
- .remove(element) Cerca l’elemento richiesto ed elimina la prima occorrenza.
- .pop([index]) cerca elemento corrispondente all’indice e lo elimina, se omesso indice eliminato
l’ultimo. .pop. restituisce elemento eliminato da riutilizzare altrove
- .extend(list2) accorda la list2 a quella di partenza
- .index(element) indice dell’element, se compare più volte restituisce solo la prima occorrenza
- .sort() ordina gli elementi della lista in modo crescente
- .reverse() inverte elementi della lista, per mantenere originale va copiata e modificata
- .clear() rimuove tutti gli elementi della lista
- .count(element) conta quante volte compare un elemento nella lista
- .copy() fa una copia della lista

Attraversamento di stringhe e liste:

- Indicizzazione o slicing: seleziona singoli elementi


- Cicli: per impostare istruzioni da eseguire su ogni elemento
- Metodi e funzioni per impostare cicli o istruzioni

Liste bidimensionali: ogni elemento di una lista è una lista con indice, per definirli
lista_principale[indice_principale][indice_sottolista], spesso si usa rappresentazione in righe e colonne

Tuple: elementi tra tonde (si usano anche senza parentesi ma complicato con le funzioni stabilire il confine)
separati da virgola, può contenere ogni tipo di dato. Sembrano liste, infatti sono argomento di funzioni e
operazioni e rispondono a indicizzazione e slicing ma le tuple sono immutabili, sicure e veloci, ma si può
convertire una lista in tupla (“list”) e viceversa (“tuple”):

- numeri[x] elemento con indice x


- numeri[x] da dx prende l’xesimo elemento
- numeri[x:y] elementi da indice x compreso a y escluso
- numeri[:x] elementi dal primo all’indice x escluso
- numeri[:x:y] elementi dal primo all’indice x escluso di y in y
- numeri[-x:-y] elementi da indice -x a -y escluso

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

Operatori delle tuple: + unisce due tuple in una nuova, * crea più copie e le unisce, in restituisce true se
contenuta altrimenti not, not in il contrario.

Funzioni built-in tuple: restituiscono

- len() numero elementi


- tuple() converte lista in tupla
- max() elemento maggiore, distingue maiuscole e minuscole
- min() elemento minore, distingue maiuscole e minuscole
- sorted() nuova lista con elementi della tupla crescenti
- sum() la somma elementi tupla

metodi tuple: restituiscono

- .index(element) indice dell’elemento cercato, se sono più prende la prima


- .count(element) numero di volte che elemento compare nella tupla

Attraversamento di tuple: elementi selezionati in sequenza e usati per slicing e indicizzazione per elemento
singolo, cicli pe applicare istruzioni a ogni elemento e funzioni e metodi per impostare combinazioni.

Dizionari: elementi strutturati con chiave e valore, non si usano operatori tradizionali ma logici. Elementi
non memorizzati in ordine particolare, si usa indicizzazione come nelle sequenze, per estrarre valore si usa
la chiave associatagli (nome_dizionario[chiave])), per aggiungere coppie (nome_dizionario[chiave]=valore)

Operatori logici dizionari: restituiscono

- in: true se chiave inclusa altrimenti false


- not: true se chiave non inclusa, altrimenti false
- is: true se dizionari sono identici, altrimenti false
- is not: true se dizionari non sono identici, altrimenti false

funzioni built-in dei dizionari: restituiscono:

- len() numero di elementi (coppie chiave-valore) di un dizionario.


- dict() Crea un dizionario vuoto, a meno che come argomento della funzione si abbiano degli oggetti
iterabili.
- max() chiave più grande di un dizionario (se stringa si parte da ‘z’). Distingue tra maiuscole e minuscole
- min() chiave più piccola di un dizionario (se stringa si parte da ‘a’). Distingue tra maiuscole e minuscole
- sorted() lista con le chiavi crescenti (se stringhe si parte da ‘a’)

Metodi dei dizionari: utili da utilizzare nei cicli for, resituiscono

- clear() rimuove elementi del dizionario che rimane vuoto


- .get(nome_chiave,[valore_default]) valore della chiave (nome_chiave), se non presente restituisce
None predefinito, o se inserito il valore_default opzionale. Il risultato si otterrebbe anche solo con
indicizzazione (nome_dizionario[nome_chiave]), ma se nome_chiave non appartenesse a
nome_dizionario darebbe errore (con get si può dare valore predefinito), se nome_chiave è definito in
nome_dizionario risulterà valore della chiave e eliminazione di nome_chiave e valore associato.
- .pop(nome_chiave,[valore_default]) rimuove nome_chiave e il valore associato e restituisce il suddetto
valore, se non presente restituisce KeyError o valore_default opzionale
- .popitem() Rimuove l’ultima coppia chiave-elemento aggiunti al dizionario e li restituisce come tupla.
- .update(nome_dizionario2) aggiunge chiavi e valori di nome_dizionario a quello esistente
- .items() crea oggetto dict_items con lista di tuple composte da ogni coppia chiave-valore
- .keys() crea oggetto dict_keys con lista delle chiavi del dizionario

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

- .values() crea oggetto dict_values con lista dei valori del dizionario
(keys() e values() definiscono view object, iterabili, immagini di dizionari in aggiornamento al loro
cambiamento, veloci da analizzare)

Accesso ai file: aprire o creare file di testo e modificarli:

- Accesso sequenziale: si accede e lo si legge dall’inizio alla fine


- Accesso diretto: si accede alla parte che interessa

Per aprire il file va aperta variabile a cui associare l’oggetto file (variabile=open(file,mode)), se il percorso è
omesso Python assume posizione uguale al programma, se nel percorso presenti ‘\’, il percordo di
procedura va fatto precedere da una r, così che non venga considerato carattere di escape: (Codici di
escape formati da backslash e altri caratteri in una stringa, non visualizzati nell’output danno però comandi
specifici, es. \n serve per mandare il testo a capo, \t allinea tabulazione, \ manda a capo il codice). Mode è
opzionale, di default è sola lettura, ma i diversi modi permettono:

- ‘r‘ sola lettura, il programma a apertura si posiziona a inizio prima riga (posizione 0), se file inestitente
da errore
- ‘w’ modalità scrittura, se file esiste già dati preesistenti vengono eliminati, altrimenti creato nuovo file
- ‘a’ modalità appened (aggiunta), si può scrivere alla fine dei dati esistenti dove viene posizionato, se
file non esiste viene creato
- ‘r+’ modalità lettura e scrittura, se file esiste dati non eliminati, se non esiste da errore
- ‘w+’ modalità lettura e scrittura, se file esiste dati eliminati, se non esiste viene creato nuovo file
- ‘a+’ modalità aggiunta e lettura, se esiste si posiziona dopo testo esistente altrimenti nuovo file

Attributi: Per scrivere e spostarsi in un file servono metodi, alla fine della modifica close (). Attributi, scritti
dopo il nome assegnato al file, dicono: variabile.name (percorso e nome), variabile.mode (modalità di
apertura), variabile.closed (true o false a seconda che file sia chiuso o aperto)  a differenza dei metodi
non ci sono argomenti e non si usano parentesi

Metodi per leggere file: per leggere dati e posizionarsi all’interno del testo:

- read(size) legge file da posizione corrente alla fine, se si inserisce size opzionale, leggere il numero di
byte impostato (n battute)
- .readline(size) legge contenuto di una riga, size opzionale
- .readlines(size) legge contenuto di tutte le righe fino alla fine del file e restituisce lista con elementi le
singole righe, size opzionale
- .seek(offset, [whence]) fa spostare puntatore da posizione desiderata, di n byte indicati da offset,
whence indica da dove partire (0=inizio, 1=corrente, 2=fine)
- .tell restituisce posizione del testo in byte dall’inizio, conta spazi e codici escape

Metodi per scrvere su file: per scrivere su un file aperto in modalità scrittura o aggiunta:

- .writable() true se si può scrivere sul file, altrimenti false


- .write(string) scrive contenuto inserito in string (vanno inseriti anche eventuali codici escape, alla fine
python restituisce numero di caratteri scritti e il puntatore va a fine testo
- .writelines(lines) scrive sequenza di righe in lines, vanno inseriti anche escape

Gestione degli errori: eseguendo un programma si incorre in errori e eccezioni:

- Sintassi: errore di scrittura del codice o struttura del programma, blocca esecuzione, se siamo
nell’editor e si vuole avviare restituito errore invalid syntax e evidenziato in rosso. Nella shell compare
errore traceback e indica punto incriminato, istruzione generatrice e tipo con descrizione

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

- Runtime: sintassi corretta ma operazioni non sono eseguibili in Python, come variabili non inizializzate,
divisione per zero, operatori non corretti per il tipo di dato
- Semantici: errore di scrittura

Eccezioni: exception è evento scatenato da errore di varia natura, si può scrivere codice per gestirla se la si
prevede (exception handling), se non è gestita (unhandled exception) causa errore e uscita dal blocco di
istruzioni

Try..except: per evitare messaggio di errore usando una funzione (exception handling), try ed except vanno
seguiti da ‘:’ e scritte con la stessa indentazione, così come le istruzioni, allo stesso livello.

Tipi di errore:

- AttributeError se metodo o attributo sono assegnati a un dato sbagliato


- IndexError se si usa indice troppo grande in una sequenza
- NameError se una variabile non viene trovata
- SyntaxError se c’è errore di sintassi
- TypeError se operazione o funzione è applicata a tipo di dato sbagliato
- ValueError se funzione o metodo riceve argomento di tipo corretto ma con valore non valido
- ZeroDivisionError se si divide numero per zero

Debugging: se scriviamo programma complesso nell’editor l’errore può manifestarsi impedendo


l’esecuzione del programma quando la si fa partire, allora va cercato bug nel codice. Rimuove gli errori di
ogni tipo e ottimizza programma, è processo sperimentabile che avviene durante e dopo la scrittura del
codice, usando i vari strumenti: modulo pdb nella libreria standard che analizza il codice o altri pacchetti
esterni gratuiti o a pagamento

Modulo: ri-usabilità del codice nel coding, aumentando efficienza del tempo di programmazione, grazie ai
moduli: file script di estensione .py con pezzi di codice con funzioni specifiche, organizzati per finalità di
utilizzo e contenuti omogenei. Moduli distinti in funzioni, classi di oggetti con tipi di dati speciali, metodi di
funzioni specifiche che lavorano con attributi, commenti e dati di esempio. Moduli già installati, creati
dall’utente che vanno ricaricati ad ogni apertura, moduli sviluppato da altri programmatori importabili da
siti appositi o con pip install module name dalla riga di comando del sistema operativo: cmd nel box di
ricerca del menù e nella riga di comando pip install module name

Pyperclip: permette funzionalità copia e incolla

- Pyperclip.copy(‘testo da copiare’) copia argomento negli appunti


- Pasted=pyperclip.paste() restituisce il contenuto di incolla come stringa

Per costruire programmi complessi va gerarchizzato codice top-down usando moduli e librerie con moduli
affini per finalità di utilizzo e contenuti omogenei. Si possono usare anche grandi librerie con sotto-librerie,
che dopo averle caricate devono dire a Python quale funzione (in quale modulo, sotto-libreria di quale
libreria) dovrà usare, ricorrendo alla dot notation che parte dal generale e poi va nel particolare

- Import: per importare moduli e librerie, importandone anche di più, dalla RAM, quindi ad ogni avvio
della shell vanno reimportati moduli e librerie utili.
- From: se serve una sola funzione e non tutta la libreria, per importare quella singolarmente
- Help: scopre quali moduli sono istallati sull’hard disk a prescindere dall’origine help(‘modules’)
- Dir: quali moduli attivi nella sessione corrente di lavoro dir()  modulo built-in apparirà come
‘__builtins__’, dir() immettendo modulo o libreria come suo argomento dice tutto ciò che contiene

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

Librerie di Python: standard istallata insieme e Python con diversi moduli utili, per utilizzarli vanno
importati, con validità solo per la sessione corrente (funzioni del modulo chiamate aggiungendo il nome
della libreria)

Libreria standard Python: 180 moduli di diversa complessità

- Modulo math; per lavorare con numeri reali, ha funzioni:


o math.ceil(x) arrotonda x per eccesso
o math.floor(x) arrotonda x per difetto
o math.sqrt(x) da radice quadrata di x
o math.pi da pi greco secondo approssimazione del pc
o math.exp(x) da e (Neplero) elevato a potenza x
o math.factorial da il fattoriale dell’intero positivo x
o math.gcd(a, b) da MCD tra a e b
o math.hypot(x, y) applica pitagora per trovare ipotenusa tra x e y
o math.isfinite(x) true se x diverso da 0/n e 0/0, sennò false
o math.isnan(x) true se x uguale a 0/0, sennò false
o math.log(x,[ baseA]) da log in base A di x, se omessa la base è 10
o math.logq (x) log in base q di x
o math.pow(x, y) Eleva x alla y
- modulo random: usa funzioni aleatorie per calcoli di probabilità, restituiscono:
o random.random() numero decimale tra 0 incluso e 1 escluso
o random.choice(sequenza) elemento casuale della sequenza (lista, tupla o stringa..)
o random.randrange(stop) random.randrange(start, stop,[step]) numero intero tra start incluso
se omesso uguale a 0 e stop, di step in step, se omesso uguale a 1, funzionamento uguale a
range
o random.randint(min, max) numero intero tra min e max inclusi
o random.seed(a = None) inizializza il generanote di numeri casuali con numero intero a, se
omesso o None usa valore dell’orologio del pc. Fa ottenere stessa sequenza di valori casuali
o random.shuffle(x) Permuta casualmente l’ordine della sequenza x.
o random.sample(population, k) lista di k elementi dalla lista population (senza reimmessa).
o random.sample(population, weights = None, k = 1) Estrae lista di k elementi dalla sequenza
population facendo campionamento (con reimmessa). Può rendere elementi equiprobabili se
weights ha valore uguale alla lunghezza di population, che contiene le diverse probabilità degli
elementi.
o random.gauss(mu, sigma) Genera numero casuale da una variabile casuale normale di media
mu e scarto quadratico medio sigma.
- Modulo turtle che permette un semplice uso grafico: la tartaruga si muove:
o bob = turtle.Turtle() costruisce oggetto tartaruga bob
o bob.forward(distanza) si muove avanti di distanza pixel
o bob.backward(distanza) si muove indietro di distanza pixel
o bob.goto(x, y) va alla posizione x,y
o bob.left(gradi) ruota (antiorario) dei gradi indicati
o bob.right(gradi) ruota (orario) dei gradi indicati
o bob.setheading(gradi) si orienta rispetto alla posizione originale dei gradi indicati
o bob.penup() non fa scrivere più alla tartaruga (solleva penna)
o bob.pendown() bob inizia a scrivere (abbassa penna)
o bob.begin_fill() bob colora interno delle figure disegnate
o bob.end_fill() bob smette di colorare le figure disegnate

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

o bob.pencolor(colore) imposta colore della penna di bob


o bob.width(dimensione) imposta larghezza della penna di bob
o bob.fillcolor(colore) imposta colore con cui bob colora le figure disegnate
o bob.shape(‘turtle’) cambia l’aspetto di bob
o bob.position() indica posizione attuale di bob, valori restituiti in tupla di valori x,y
o bob.heading() indica orientamento di gradi di bob
o canvas = turtle.Screen() fa nuovo oggetto canvas
o canvas.bgcolor(colore) cambia colore di finestra background
o canvas.addshape(“ninja.gif”) aggiunge alla finestra una nuova forma per il cursore
- modulo os e os.path che fanno interagire con la gestione file e la cartella del sistema operativo,
restituisce:
o os.listdir([path]) lista con nome di file e directory nella cartella del percorso path
o os.getcwd() stringa con percorso dell’attuale working directory
o os.chdir(path) Fa diventare il percorso path la nuova working directory.
o os.rename(oldName, newName) Rinomina il file o la directory
o os.remove(file) Cancella il file
o os.rmdir(path) Cancella la directory se vuota.
o os.path.join(path, filename) stringa concatenando path e filename data la sintassi del pc
o os.path.isfile(path) True se il percorso path termina con il nome di un file altrimenti false
o os.path.isdir(path) True se il percorso path termina con una directory, altrimenti False
- modulo openpyxl: legge e scrive file Excel con Python, funzioni utili resituiscono:
o MyNewXLfile= openpyxl.Workbook() crea file excel MyNewXLfile in memoria, con un nuovo
foglio si crea una nuova cartella di lavoro
o MyNewXLfile.save('MyFile.xlsx') Salva la cartella MyNewXLfile inMyFile.xlsx
o MyNewXLfile.active.title= 'MySheet' Rinomina foglio attivo nella cartella come MySheet
o MyNewXLfile.create_sheet('MyNewSheet') Crea nuovo foglio di lavoro di default alla fine della
cartella inserito in posizione n con valore min 0
o MyNewXLfile.sheetnames nomi di ogni foglio della cartella con dato di tipo List
o openpyxl.load_workbook('MyFile.xlsx') Carica in memoria il file esistente MyFile.xlsx
o MyNewXLfile['MySheet'] Attiva il foglio di lavoro MySheet nella cartella MyNewXLfile
o MyNewXLfile['MySheet']['A1'] = 'Ciao ragazzi!' Scrive Ciao ragazzi!' nella cella A1 del foglio di
lavoro MySheet nella cartella MyNewXLfile

Formattazione di una cella:

- MyActiveSheet['A1'].fill= openpyxl.styles.
- PatternFill(fill_type= 'solid', start_color= openpyxl.styles.colors.BLUE)
- MyActiveSheet['A1'].font = openpyxl.styles.Font(italic= True, bold= True, color =
openpyxl.styles.colors.WHITE)
- MyActiveSheet['A1'].alignment= openpyxl.styles.Alignment(horizontal= 'center')

Modulo webbrowser: controllore con interfaccia di alto livello per la visualizzazione di contenuti web,
funzioni:

- webbrowser.open(url, new=0) visualizza pagina url con il browser predefinito, se new=0 url aperto
nella stessa finestra del browser, se =1 pagina aperta in una nuova finestra, se =2 in una nuova scheda
del browser

modulo request: per interagire con il web automatizzando operazioni, attraverso funzioni:

- pagina = requests.get(URL) apre url e ne scarica contenuto

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

- pagina.text restituisce come testo contenuto HTML della pagina scaricata

modulo matplotlib.pyplot: di una potente libreria grafica in 2D, fa disegnare grafici di dispersione,
istogrammi, ispettogrammi e grafici a barre, funzione:

- matplotlib.pyplot.plot(X, Y, formats) disegna sul piano valori x,y, format prevede sintassi per il
controllo grafico (es. ‘-‘ per linea continua, ‘o’ per cerchi, ‘g’ per verde)

modulo datetime fornisce dati speciali connessi alle date:

- x = datetime.date(year, month, day) crea valore di tipo data


- y = datetime.time(hour, minute, second) crea valore di tipo time
- z = datetime.timedelta([days,[ seconds,[minutes,[hours,[ weeks]]]]]) crea valore duration dato dalla
differenza di due valori date o time
- x.weekday() da giorno della settimana come numero intero da 0 (lunedì) a 6 (domenica)
- x.isoformat() da una stringa con data in formato YYYY – MM DD.

Classi, attributi e metodi di programmazione a oggetti: essendo Python multi-paradigma, usa stili di
programmazione e approcci:

- procedurale che scompone il programma in blocchi di codice racchiudi da delimitatori con gerarchia a
piramide (sottoprogrammi o subroutine)
- procedurale con sequenza di funzioni concatenate
- programmazione orientata agli oggetti (OOP)

linguaggio a oggetti: ognuno utilizzato in più modi, a seconda del tipo di oggetto, le azioni da svolgere
modificano le caratteristiche degli attributi dell’oggetto e quelle che comportano l’uso dell’oggetto
nell’interazione con altri oggetti o l’utente. I vari oggetti hanno attributi e metodi (azioni da svolgere con
essi) (l’insieme di metodi di una classe è un’interfaccia), entrambi contenuti da blocco di codice chiamato
‘definizione di classe’. Ogni codice si riutilizza, quindi va reso meno complicato possibile, con logica DRY
( don’t repeat yourself). Principi della base di appoggio OOP sono:

- incapsulamento: non rende visibili agli altri oggetti le caratteristiche di una classe, facilita confivisione
con altri programmatori e velocizza il test di funzionamento, la sicurezza e la produttività
- ereditarietà: costruisce le classi anche partendo da altre preesistenti ereditando attributi e metodi
(classi figlie child e classi base parent)
- polimorfismo: si possono nominare ugualmente metodi che agiscono su oggetti diversi ma allo stesso
modo

classe: è una famiglia di oggetti di un tipo, esistenti in Python o librerie esterne o create da noi: per crearla
va assegnato un nome e definire attributi e metodi, ereditati dalla classe a cui appartengono, che si
possono comunque modificare, avendone altri aggiuntivi o diversi dall’origine

istanza: singolo oggetto appartenente alla classe, per crearla va nominata e assegnato l’oggetto, si possono
modificare i valori iniziali (impostati negli attributi) chiamando l’oggetto creato seguito dall’attributo da
modificare.

in Python ci sono tipi di dati elementari (stringhe, interi, float, logici) e strutture complesse chiamate
literals (tuple, liste, dizionari), creati con sintassi dedicata, semplice con elementi di riconoscimento che fa
individuare i vari literals. Cambiando tipo di dato grazie alle funzioni di conversione non si modifica
l’oggetto ma ne crea uno nuovo riassegnando il nome e il tipo (tipo è legato all’oggetto e non si può
modificare). Esistono precise regole di code-naming che identificano quando si sta usando o creando una
classe, facendo iniziare il nome della classe con una maiuscola. Con la funzione type si verifica la classe di
oggetti appartenente ad un elemento, per vedere il contenuto del modulo si usa la funzione dir(), se si

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

vogliono visualizzare gli attributi e i metodi si usa dir() con il nome della classe o dell’istanza, per una
spiegazione la funzione help, detta call tip, scrivendo il nome dell’oggetto seguito dal punto o aprendo la
parentesi dopo un metodo.

Le classi personalizzate: per creare oggetti va definita e creata una classe, ognuna basata sulla classe object
su cui si rifà, va definito il nome, le parentesi vanno messe per convenzione, così come i due punti e il
blocco sottostante indentato.

Oggetti: ogni tipo di dato è un’istanza (specifico oggetto appartenente a un determinato tipo) di un
oggetto, elemento astratto che ha un tipo a cui appartiene, una rappresentazione interna di dati
(linguaggio macchina), insieme di procedure-metodi per interagire. Tutto in Python è un oggetto, che può
essere definito dall’utente. Una classe è la descrizione astratta dell’oggetto, la famiglia o l’insieme di
oggetti di un certo tipo, l’istanza è un particolare caso di una classe, insieme specifico di valori assegnati
dagli attributi di una classe. Per crearlo va definito attraverso uno stampo dato dalla sua definizione,
generando oggetti identici tra loro, personalizzati con la definizione dei loro attributi, dando origine a una
classe di oggetti, la cui definizione parte dalla definizione della relativa classe. per arricchire l’oggetto di
attributi va costruito il metodo __init__, con almeno un argomento (dato che è un metodo) per
convenzione self, metodo costruttore non fa calcoli, deve solo definire degli attributi della futura istanza,
non termina perciò con return. Si possono aggiungere altri attributi, variabili o costanti, per poi creare
funzioni produttive, con argomento lo stesso che si è inserito prima (self), con schema di creazione. Si
possono aggiungere stringhe di documentazione nelle classi per dare spiegazioni e istruzioni nell’utilizzo,
con la funzione help verranno visualizzate anche le eventuali docstring. Per eliminare un oggetto va usata
la keyword del. Per crearne un duplicato non si può assegnare lo stesso nome ma usare il modulo copy,
modulo che contiene solo le funzioni copy e deepcopy.

Personalizzare attributi delle istanze: self è un parametro obbligatorio da inserire nel metodo __init__, si
possono inserire anche altri argomenti obbligatori o opzionali, tenendo presente che esistono attributi
specifici per ogni istanza e degli attributi relativi a tutta la classe, per consuetudine gli attributi di istanza si
scrivono nel metodo __init__, quelli di classe all’esterno.

Metodo speciale __str__: per costruire una rappresentazione di un oggetto in formato stringa, ogni classe
discende dalla classe object, se il metodo __str__ non è definito in una classe, Python lo recupera in object
(funzioni str(), print(), format()). Nella stringa si inserisce qualsiasi informazione utile all’utilizzazione
dell’oggetto, come unico argomento c’è self e si termina con return

Best practice nella creazione delle istanze: per non far modificare agli altri programmatori il contenuto del
codice si rendono attributi costanti, usando la funzione get, per rendere attributo modificabile si usa la
funzione set

Ereditarietà: gerarchizzazione di Python va creata e utilizzata, indicando nella sottoclasse child il nome
della classe base parent. Si possono inserire più sopraclassi in una sottoclasse

Overriding di metodi: a parità di nome di metodo Python privilegia l’esecuzione nella sottoclasse del
metodo nella sottoclasse stessa, infatti si presuppone che il livello di specializzazione dei livelli bassi sia
maggiore.

Overloading di metodi: se operatori assumono funzionalità diverse per ogni dato che usano, usando
metodi (es. __add__), caratteristica simile a quella degli operatori + e * in stringhe o numeri

Polimorfismo: consente al programma di decidere come usare una funzione o un metodo a seconda del
tipo di dato (una stessa funzione agisce diversamente su tipi di dati diversi)

Scaricato da ZhuoHao Hu (hualex26@gmail.com)


lOMoARcPSD|7207373

Scaricato da ZhuoHao Hu (hualex26@gmail.com)