Scarica Informatica e Python (Pandas e Matplotlib) e più Appunti in PDF di Elementi di Informatica solo su Docsity!
Informatica e Python
- Informatica = Informazione automatica.......................................................................................................................................
- IL COMPUTER................................................................................................................................................................................
- Componenti hardware:............................................................................................................................................................
- Il software può essere:............................................................................................................................................................
- Il file system.............................................................................................................................................................................
- Comandi della shell.................................................................................................................................................................
- Programmare.................................................................................................................................................................................
- Errori comuni...........................................................................................................................................................................
- Le variabili...............................................................................................................................................................................
- Strutture di controllo: IF...........................................................................................................................................................
- Strutture di controllo: WHILE...................................................................................................................................................
- Strutture di controllo: FOR.......................................................................................................................................................
- Le strutture dati.............................................................................................................................................................................
- Struttura dati: Scalare............................................................................................................................................................
- Struttura dati: Stringhe...........................................................................................................................................................
- Struttura dati: Tuple...............................................................................................................................................................
- Struttura dati: Liste................................................................................................................................................................
- Struttura dati: Dizionari..........................................................................................................................................................
- Ciclo FOR nelle strutture dati................................................................................................................................................
- Struttura dati multidimensionali: Lista di liste.........................................................................................................................
- Le funzioni....................................................................................................................................................................................
- I moduli.........................................................................................................................................................................................
- I file...............................................................................................................................................................................................
- Pandas..........................................................................................................................................................................................
- Formati file.............................................................................................................................................................................
- Leggere un file JSON....................................................................................................................................................
- Leggere un file XLS.......................................................................................................................................................
- Leggere un file CSV......................................................................................................................................................
- Gestione di date e orari.........................................................................................................................................
- Valori mancanti......................................................................................................................................................
- Encoding...............................................................................................................................................................
- Metodi....................................................................................................................................................................................
- Serie......................................................................................................................................................................................
- DataFrame.............................................................................................................................................................................
- Metodi comuni a serie e DataFrame.....................................................................................................................................
- Variabili..................................................................................................................................................................................
- Altri metodi.............................................................................................................................................................................
- Indici......................................................................................................................................................................................
- Fancy index...........................................................................................................................................................................
- Creazione di una nuova colonna...........................................................................................................................................
- Funzione describe()...............................................................................................................................................................
- Categorie...............................................................................................................................................................................
- Raggruppare le righe.............................................................................................................................................................
- Apply......................................................................................................................................................................................
- Tabella Pivot..........................................................................................................................................................................
- Elementi estremi....................................................................................................................................................................
- Concatenare DataFrame.......................................................................................................................................................
- Fondere DataFrame..............................................................................................................................................................
- Fusione con ordinamento..............................................................................................................................................
- Fusione con indice........................................................................................................................................................
- Fusione su colonne diverse...........................................................................................................................................
- Controllo delle corrispondenze..............................................................................................................................................
- Matplotlib......................................................................................................................................................................................
- Tipi di grafico - Plots..............................................................................................................................................................
- Tipi di grafico - Scatter...........................................................................................................................................................
- Tipi di grafico - Grafici a barre...............................................................................................................................................
Informatica = Informazione automatica
E’ la scienza che si occupa della rappresentazione e dell'elaborazione dell’informazione.
Dati: oggetto che si può raccogliere Informazione: Nozione, idea, rappresentazione
Elaborazione dell’informazione ● data -driven → basato sui dati che si hanno ● model -driven → basato su dei modelli matematici
Processo: programma che sta eseguendo delle operazioni Programmare significa:
- Far eseguire istruzioni ripetitive velocemente
- Ridurre l’errore umano
L’informazione viene rappresentata tramite il Bit ( Bi nary digi t ); ovvero tramite una rappresentazione binaria di 0 e 1. Con n bit possiamo rappresentare 2 n^ informazioni diverse. I caratteri vengono codificati dalla codifica UNICODE a 16 bit. un suo sottoinsieme è il set di caratteri ASCII a 8 bit. Un’ immagine è un insieme di informazioni che si può rappresentare tramite due tecniche: ● Raster L’immagine viene scomposta in una griglia e ad ogni cella [ pixel ] si associa un valore. Più è fitta la griglia più l’immagine è precisa. ● Vettoriale L’immagine viene descritta tramite figure geometriche elementari memorizzate nella posizione in cui sono collocate.
IL COMPUTER
Formato da:
- Hardware: Rappresenta la parte fisica del calcolatore
- Software: Rappresenta la componente astratta che guidano il computer a compiere delle azioni necessarie per trasformare le informazioni
Componenti hardware :
Dispositivi di input : acquisiscono informazioni dall’esterno ★ Tastiera ★ Mouse ★ Scanner ★ Videocamera Dispositivi di output : rendono disponibile le informazioni all'esterno del computer ★ Monitor ★ Stampante ★ Altoparlanti
Il file system
E’ composto da: ★ FILE ovvero unità logiche di memorizzazione. Possiedono: ○ Nome ○ Tipo ○ Posizione ○ Dimensione ○ Data e ora di creazione e modifica ○ Proprietario e creatore ○ Permessi di accesso ★ DIRECTORY ovvero le informazioni che servono per organizzare e fornire informazioni sui file. E’ organizzato ad albero. ○ Full path (percorso completo) rappresenta il percorso da compiere per trovare il file partendo dalla directory più esterna ○ Relative path (percorso relativo) rappresenta il percorso da compiere per trovare il file partendo dalla directory di lavoro
Windows Unix
Ogni disco è la radice di un albero separato Tutti i dischi sono montati sullo stesso albero
Si usa il back-slash ** Si usa lo slash /
Comandi della shell
- pwd : dove mi trovo
- cd percorso : cambia directory
- ls : cosa è contenuto nella directory
- man : manuale dei comandi, contiene la sintassi
- mkdir : crea una nuova directory
- mv : muovi il file
- cp : copia il file
- cat : stampa il contenuto del file
- less : legge il contenuto del file
- head : stampa le prime righe del file
- tail : stampa le ultime righe del file
- | : combina più comandi
- rm : cancella file e directory
- rmdir : cancella directory
- zip e unzip : comprime e decomprime file
- touch : crea un file vuoto
- chown : cambia l’utente proprietario e il gruppo assegnato al file
- chmod : cambia i permessi del file
- rg stringa : trova tutti i file che contengono una stringa
- fdfind stringa : trova tutti i file che contengono nel nome una stringa
- wc : conta righe
- > , >> : stampa messaggio in output
- htop : programmi in esecuzione e spazio di memoria
Simboli: ● / radice (e separatore delle directory) ● ~ home ●. qui ● .. su di uno ● - portami indietro ● ***** quello che vuoi
Usando i tasti freccia ↑ e ↓ si possono recuperare i comandi dati in precedenza. Premendo il tasto tab si attiva l'auto completamento della parola che si sta scrivendo.
Programmare
Programmare significa manipolare continuamente oggetti tramite azioni predefinite.
Algoritmo: procedimento che consente di ottenere la soluzione del problema eseguendo un insieme di operazioni
Per scrivere un algoritmo è necessario:
- Un linguaggio di programmazione
- Un Programma, una sequenza di informazioni che descrivono l’algoritmo
Linguaggi di programmazione: Sono linguaggi che permettono la codifica di algoritmi per renderli eseguibili dal calcolatore ➔ Linguaggi di alto livello ◆ Sono simili al linguaggio naturale ◆ Necessitano una traduzione per poter essere eseguiti dal calcolatore ◆ Sono indipendenti dalla macchina ➔ Linguaggi assembler ◆ Sono una sequenza di caratteri alfanumerici ◆ Necessitano una traduzione per poter essere eseguiti dal calcolatore ◆ Sono dipendenti dalla macchina ➔ Linguaggi macchina ◆ Sono una sequenza di istruzioni codificate in bit ◆ Non necessitano una traduzione per poter essere eseguiti dal calcolatore ◆ Sono dipendenti dalla macchina
Il processo di tradizione può avvenire tramite:
- Interprete: verifica e traduce istruzione per istruzione → Python
- Compilatore: verifica e traduce l’intero codice → C++
// Divisione intera Restituisce il più grande intero inferiore al risultato. Risultato= 1,5 → 1 Risultato= -3,5 → -
% Resto della divisione Si usa per determinare se un numero è multiplo di un altro o se un numero è pari o dispari
Operatori di incremento
Operatore Significato
a += b a = a + b
a -= b a = a - b
a *= b a = a * b
a /= b a = a / b
a %= b a = a % b
Operatori di confronto
Operatore Significato Operatore Significato
Maggiore >= Maggiore o uguale
< Minore <= Minore o uguale
== Uguale != Diverso
is Identità is not Non identità
Operatore di appartenenza
Operatore Significato
in Appartiene ad un gruppo
not in Non appartiene ad un gruppo
Istruzioni
Istruzioni in python Significato
print(variabile) o print(‘stringa’) Stampa a video una variabile o una stringa
print(‘stringa %d ’ %(variabile)) Stampa a video una stringa contenente una variabile:
- %d → variabile intera
- %f → variabile float
- %s → stringa
- \n → a capo
- \t → tabulazione
- __ → interruzione di riga viene ignorata
print(‘stringa’, variabile) Stampa a video una stringa contenente una variabile considerandola come una tupla
input(variabile) Acquisisce una variabile dall’utente
eval(variabile) o eval(‘stringa’) Trasforma una variabile o una stringa in un valore numerico
str(variabile) Converte una variabile generica in una stringa
type(variabile) Restituisce il tipo di una variabile
id(variabile) Restituisce lo spazio di memoria occupato dalla variabile. Si ha identità quando a due variabili è assegnato lo stesso spazio di memoria
Strutture di controllo: IF
if condizione: istruzioni
if condizione: istruzioni else : istruzioni
if condizione1: istruzioni elif condizione2: istruzioni else : istruzioni
Se una struttura condizionale viene inserita in un’altra struttura condizionale si parla di condizione annidata.
Strutture di controllo: WHILE
while condizione: istruzioni
La condizione viene verificata prima di eseguire le istruzioni. Le istruzioni si ripetono finché la condizione è soddisfatta.
La trace table è una tabella che viene costruita per tenere traccia delle variabili del programma e di come esse si modificano durante l’esecuzione.
Nel ciclo while è fondamentale che la variabile coinvolta nella condizione venga aggiornata durante l’iterazione altrimenti il ciclo non termina e si viene a creare un ciclo infinito.
Si possono classificare per:
Aggregazione Plasticità Omogeneità
Semplici Complesse Statiche Dinamiche Omogenee Eterogenee
fisso fisse
Proprietà delle principali strutture dati
Aggregazione Tipologia Plasticità Omogeneità
Scalare Semplice Statica Omogenea
Stringa Complessa Sequenza Statica Omogenea
Tupla Complessa Sequenza Statica Eterogenea
Lista Complessa Sequenza Dinamica Eterogenea
Dizionario Complessa Mappa Dinamica Eterogenea
Metodi: funzioni predefinite applicabili agli oggetti.
oggetto.metodo( parametri )
Struttura dati: Scalare
Ha un nome e un contenuto. Lo scalare è una struttura dati semplice , statica ed omogenea. Può essere di tipo: ● Numerico ○ int → numero intero (ℕ) ○ long → numero intero grande positivo e negativo (ℤ) ○ float → numero reale (ℝ) ○ complex → numero complesso (ℂ) ● Logico ○ bool → variabile booleana [True, False]
Struttura dati: Stringhe
Ha un nome e contiene una sequenza di caratteri. → a=’Ciao ciao’ La stringa è una struttura dati complessa di tipo sequenza , statica ed omogenea. Per accedere ad un carattere particolare si usa il suo indice, con indici negativi si considera il carattere corrispondente al numero partendo dal fondo.
a = C i a o c i a o
a[_] 0 1 2 3 4 5 6 7 8
a[_] -9 -8 -7 -6 -5 -4 -3 -2 -
Proprietà:
- Lunghezza di una stringa: len(a) → 9
- Slicing: ● a[:4] = a[0:4] → ‘Ciao’ ● a[5:] = a[5:8] → ‘ciao’ ● a[3:5] → ‘o c’ ● a[-3:-2] → ‘ia’
- Concatenazione: Si può allungare una stringa aggiungendone un'altra alla fine con il simbolo + a= ‘Ciao ciao’ b= ‘Hola hola’ c = a+b → Ciao ciao Hola hola Inoltre si può riscrivere una stessa stringa più volte utilizzando il simbolo ***** a= ‘Ciao ciao’ c = a*3 → Ciao ciao Ciao ciao Ciao ciao Metodi:
Metodo Significato Esempio
a.upper() Tutta la stringa diventa scritta in maiuscolo
a.upper()= ‘CIAO CIAO’
a.find( ‘char’ ) Restituisce l’indice della prima volta che trova il char cercato. Se non viene trovata restituisce -
a.find(‘ o’ ) → 3 a.find(‘ l’ ) → - 1
a.count( ‘char’ ) Restituisce il numero di volte che trova char nella stringa
a.count( ‘ia’ ) → 2
a.split( ‘sep’ ) Separa la stringa in tante stringhe utilizzando come carattere separatore sep
a.split( ‘ ’ ) → [‘Ciao’, ‘ciao’] a.split( ‘o’ ) → [‘Cia’, ‘ cia’]
a.strip( ‘char’ ) Restituisce la stringa senza i caratteri char all’inizio e alla fine
a=’Ciao’ a.strip( ‘’_ ) → [‘Ciao’]
Struttura dati: Tuple
Ha un nome e contiene una sequenza di oggetti. → t=(3, ‘ciao’, 15.2, 7t+8c) La tupla è una struttura dati complessa di tipo sequenza , statica ed eterogenea. Per accedere ad un oggetto si usa il suo indice.
Struttura dati: Liste
Ha un nome e contiene una sequenza di oggetti. → l=[3, ‘ciao’, 15.2, 7t+8c] La lista è una struttura dati complessa di tipo sequenza , dinamica ed eterogenea. Per accedere ad un oggetto si usa il suo indice.
l = 3 ciao 15.2 7t+8c
l[_] 0 1 2 3
l[_] -4 -3 -2 -
Proprietà:
- Lunghezza di una tupla: len(l) → 4
- Slicing: ● l[:1] = l[0:1] → [3, ‘ciao’)] ● l[1:] = l[1:3] → [‘ciao’, 15.2, 7t+8c] ● l[1:2] → [‘ciao’, 15.2] ● l[-2:-1] → [15.2, 7t+8c]
- Concatenazione: Si può allungare una stringa aggiungendone un'altra alla fine con il simbolo + l=[3, ‘ciao’, 15.2, 7t+8c] n=[‘Hola’, 123456] o = l+n → [3, ‘ciao’, 15.2, 7t+8c, ‘Hola’, 123456]
- Può essere modificata: l[1]=’hola’ → [3, ‘hola’, 15.2, 7t+8c]
Si può creare una lista vuota scrivendo lista=[ ] per poi riempirla con dei valori
Metodi
Metodo Significato Esempio
l.append( ‘elemento’ ) Aggiunge elemento in fondo alla lista
l.append(‘q’) → [3, ‘ciao’, 15.2, 7t+8c, ‘q’]
l.extend( ‘lista2’ ) Aggiunge lista2 alla fine della lista
lista2=[1,4] l.extend( ‘lista2’ ) → [3, ‘ciao’, 15.2, 7t+8c, 1, 4]
del l[ i ] Elimina l'elemento i -esimo della lista
del l[ 1 ] → [3, 15.2, 7t+8c] del l[ 1:2 ] → [3, 7t+8c]
l.sort() Ordina la lista l=[2,4,6,1,7,8] l.sort() → [1,2,4,6,7,8]
l.sort(reverse=True) Ordina la lista in ordine decrescente
l.sort() → [8,7,6,4,2,1]
sorted( lista ) Crea una nuova lista ordinata
nuoval=sorted(l) → [1,2,4,6,7,8]
list() Crea una copia di una lista che può essere modificata senza modificare l’originale, si crea un oggetto diverso
l2=list(l) → [3, ‘ciao’, 15.2, 7t+8c]
Struttura dati: Dizionari
Ha un nome e contiene diversi oggetti identificabili grazie ad una chiave. → d={(1: ’a’), (2: ’b’), (3: ’c’), (4: ’d’)} La lista è una struttura dati complessa di tipo mappa , dinamica ed eterogenea i cui elementi vengono identificati tramite un chiave. Per accedere ad un oggetto si usa il suo indice.
d = a b c d
chiave 1 2 3 4
Proprietà:
- Lunghezza di una tupla: len(d) → 4
- Può essere modificata: d[3]=’f’ → {(1: ’a’), (2: ’b’), (3: ’f’), (4: ’d’)}
Si può creare un dizionario vuoto scrivendo dizionario={ } per poi riempirla con dei valori
Metodi
Metodo Significato Esempio
d.keys() Restituisce la lista delle chiavi del dizionario
d.keys() → [1, 2, 3, 4]
d.values() Restituisce la lista dei valori contenuti nel dizionario
d.values() → [‘a’, ‘b’, ‘c’, ‘d’]
Ciclo FOR nelle strutture dati
for chiave in d: print(d[chiave]) istruzioni → Ottengo la stampa a video di tutti i valori contenuti nel dizionario Lo stesso si può fare con ogni struttura dati, stringa, lista, tupla e dizionario
Oppure, sfruttando la funzione range:
l=[1,2,3,4,5] rip = range(len( l )) print(rip) for indice in rip: print( l [indice])
Posizionale Con denominazione Lista di argomenti variabile
funz(‘uno’, ‘due’, ‘tre’) funz(par1=’uno’, par3=’tre’, par2=’due’)
Una funzione, al suo interno, può sfruttare un'altra funzione.
I moduli
Sono file che contengono definizioni di funzioni. Servono per ● l’archiviazione permanente di funzioni ● importare funzioni nel programma ● facilitare il riutilizzo del codice ● semplificare la scrittura di programmi complessi
Per usarli bisogna importarli nel file corrente.
import fibonacci as fibo → definizione di un alias del modulo istruzioni fibo. fib2(parametro) → in questo modo si può usare una funzione definita nel modulo fibonacci
Per svolgere compiti complessi può essere necessario utilizzare più moduli contemporaneamente. Il programma di installazione di python, oltre ad installare l’interprete, installa anche la libreria standard di python. Se, però, si ha bisogno di un modulo non presente nella libreria standard bisogna importarlo nel proprio computer. Per questo motivo sono stati introdotti i package manager che si occupano di installare i moduli aggiuntivi di Python.
Si possono importare anche funzioni da altri file Python presenti nel computer. Basta importare il nome del file e Python andrà a cercarlo all’interno del computer.
I file
Per poter interagire con un file bisogna aprire un flusso verso il file. nomeOggettoFile = open( nomeFile, modo)
Dove al posto di modo si può scrivere:
- ‘r’ → sola lettura
- ‘w’ → scrittura , se il file non esiste viene creato, se esiste si cancellano i dati contenuti
- ‘a’ → aggiunta , i dati si aggiungono dopo gli altri dati
Alla fine bisogna chiudere il file.
nomeOggettoFile. close()
Si può accedere ai dati del file in due modi:
- Accesso sequenziale: I dati vengono letti in successione così come si trovano
- Accesso diretto: I dati vengono letti in base a un indice
Istruzioni per l’accesso ai file
Operazione Istruzione Significato
Scrittura f.write(...)^ Nel file viene scritto ciò chesi trova tra le parentesi
Lettura
testo = f.read()
testo2 = f.read( 5 )
Legge il contenuto del file e lo immagazzina nella variabile testo. Se tra parentesi metto un numero legge solo i primi n caratteri
s = f.readline() Legge tutti i caratteri una riga per volta grazie a \n
l = f.readlines() Legger tutto il file e memorizza in una lista ogni riga del file
Posizionamento
f.seek( n ) Sposta il punto in cui inizia la lettura/scrittura di un file in n
f.tell() E’ la posizione in cui ci troviamo nel file
Per leggere un file si può sfruttare
Ciclo for Ciclo while
f = open( ”file.txt”, ”r” ) for line in f: print(line) f .open()
f = open( ”file.txt”, ”r” ) line=f .readline() while line!=””: print (line) line=f .readline() f .open()
Per non dimenticarsi di chiudere il file si può usare
with open( ‘file.txt’, ’r’ ) as f: istruzioni
dfNome = pd.read_csv( ‘indirizzo file’, thousand = ‘.’)
dfNome = pd.read_csv( ‘indirizzo file’, index_col = ‘nome_colonna_indice’)
Specifica il nome della colonna usata come indice (es. id_utente o Codice Fiscale)
Se i file assumono grandi dimensioni allora sono necessari maggiori tempi di elaborazione. Si può quindi ovviare a questo problema utilizzando:
- nrows : che specifica il numero di righe del file che devono essere lette [utile all’inizio ma non permette una visione completa dei dati]
- low_memory = False : che permette a pandas di usare una maggiore quantità di memoria per l'organizzazione dei dati. Inoltre Pandas riesce a leggere file compressi.
Gestione di date e orari
Le date e gli orari possono rappresentare un problema in quanto: ● Esiste il timestamp (ora e data insieme) ● Esiste il formato americano (mese\giorno\anno) o europeo (giorno\mese\anno) per le date ● Esistono diversi separatori per le date ( * o - o.* ) ● Esistono i diversi fusi orari
Si possono usare quindi diverse opzioni per manipolare i dati
Opzione Significato
dfNome = pd.read_csv( ‘nomefile.csv’, parse_dates= [0])
Esplicita le colonne che contengono date o timestamp dove 0 rappresenta la/e colonna/e dove applicare la formattazione
dfNome = pd.read_csv( ‘nomefile.csv’, parse_dates= [0], dayfirst= True )
Se si vuole usare il formato europeo per le date bisogna aggiungere l’opzione dayfirst= True
Valori mancanti
Si possono utilizzare dei valori specifici, detti sentinelle, per rappresentare valori mancanti. In fase di lettura si può usare: ★ na_values : una lista di stringhe che vengono interpretati come valori mancanti ★ keep_default_na : un booleano che indica se continuare ad interpretare le stringhe NaN, nan, N/A, null per rappresentare valori mancanti.
Quando queste opzioni vengono utilizzate, è opportuno aggiungere anche verbose = True : in questo modo vengono calcolati il numero di valori mancanti nelle colonne non-numeriche e si può controllare che le stringhe che codificano i valori mancanti non abbiano introdotti altri problemi. Se non serve la data si può scrivere più semplicemente come una stringa.
I valori mancanti sono rappresentanti con None. In Pandas possono anche essere rappresentati da numpy.nan: in questo caso è necessario importare la libreria numpy.
Encoding
L'encoding più utilizzato (ASCII) non permette di rappresentare le lettere accentate ed altri caratteri utilizzati in lingue diverse dall'Inglese. Ciò comporta alcuni problemi nel leggere file di dati con caratteri accentati che possono essere superati solo specificando l'encoding utilizzato nella creazione del file. Per i file con scritte in Italiano, gli encoding normalmente utilizzati sono iso-8859-1 e utf-.
Metodi
Metodo Significato
nomecolonna.str La colonna diventa una stringa
list(nomecolonna) Trasforma in lista una colonna
dfNome = pd.read_csv( ‘nomefile.csv’, na_values=9999-12-31)
Il valore 9999-12-31 viene considerato come valore mancante
nomecolonna.dtype Restituisce il tipo di valori contenuti nella colonna
type(dfNome) Restituisce il tipo (dataframe o serie)
Serie
Una serie è una lista di valori in colonna senza nome. Ogni riga viene identificata da un indice può non essere un numero. Si ottiene usando il metodo squeeze.
DataFrame
Un DataFrame è una tabella dove ogni colonna ha un nome e ogni riga ha un indice.
Metodi comuni a serie e DataFrame
Metodo Significato
dfNome.count() Mostra il numero di righe con valori non mancanti
dfNome.head( n ) Mostra le prime n righe
dfNome.tail( n ) Mostra le ultime n righe
