MARAPCANA.

TODAY - seguici sempre sul nostro sito - tutti i libri in download

gratuito
MANUALE DI PROGRAMMAZIONE IN PYTHON

1. I concetti base
Installazione di Python

Scaricare e installare Python 3

Aprire un browser e cercare su Google “download Python 3”.

Cliccare poi sul primo risultato della ricerca relativo all’indirizzo www.python.org.

Dalla home sito web, cliccare sul pulsante “Download Python 3.7.2” (o la versione attualmente
disponibile) per avviare il download.

Una volta completato, avviare il programma e cliccare sulla prima opzione “Install Now”. Una volta
completato il caricamento, cliccare su “close”.

1.1 Scaricare ed installare l’ambiente di sviluppo PyCharm

Come effettuato in precedenza, aprire il browser e cercare su Google “pycharm”.

Cliccare sul primo risultato che compare e che ha come riferimento il sito www.jetbrains.com.
Cliccare poi su “Download now” e dalla pagina che si apre, selezionare delle due versioni
disponibili, la “Community”.

Una volta accettate le condizioni inerenti al software, il download partirà.

Completato lo scaricamento del programma, avviarlo e seguire la procedura di installazione.

Cliccare quindi su “Next”, lasciando selezionato il percorso riportato e procedere ancora con
“Next”.

Dalla schermata successiva, lasciare abilitate le opzioni per “Create Desktop Shortcut” e
selezionare sotto a “Create Associations”, l’estensione .py, in modo tale da utilizzare sempre questo
programma come applicazione di default.

Cliccare poi su “Next” e Install” per avviare l’installazione. Una volta completata l’installazione,
cliccare su “Finish”.
Cliccare poi sull’icona sul desktop di PyCharm per avviare il programma e selezionare l’opzione
“do not import settings”. Accettare la privacy policy cliccando su “Continue”.

Alla schermata successiva, cliccare poi su “Don’t send”. Scegliere un tipo di tema tra “Darcula” e
“Light”.

Cliccare su “Create New Project” e assegnare il nome “test 1”. Infine, cliccare su “Create”.

Cliccare su “Close” per iniziare.

Selezionare “test 1”, cliccare sopra con il tasto destro e da menu selezionare “New > Python file”.

Inserire il nome “Prima prova”, e confermare cliccando su “OK”.

Dalla tab selezionata di primaProva.py, scrivere:

print(“Hello World!”);

Dal menu in alto, selezionare “Run” e scegliere “primaProva”.

Sotto dovrebbe essere disponibile il risultato della stringa stampata.

1.2 Assegnamento di una variabile

Con l’assegnamento si definisce il nome di una variabile e il valore ad esso associata.

Per questo motivo, la variabile può essere definita come un contenitore che sarà riutilizzato
successivamente per lo sviluppo del programma.
Es: miaVar = 78
miaVar2 = “ciao”

Nel primo esempio, la variabile contiene un valore numerico, mentre nel secondo contiene una
stringa, ovvero un valore di tipo testo, che si contraddistingue con l’utilizzo dei doppi apici.

Per visualizzare a video in output il valore della variabile, utilizziamo la funzione Print():

print(miaVar1)
print(miaVar2)

Dal menu laterale di sinistra, è possibile cliccare con il tasto destro su primaProva.py, “Run
primaProva”, in modo tale da eseguire il programma.

Sotto saranno quindi riportati i valori definiti precedente nelle variabili.

1.3 Tipo di una variabile

Il tipo di variabile corrisponde alla natura del valore inserito all’interno.

Attraverso la funzione type(), si definisce il valore ad essa associato. Questo argomento sarà
approfondito successivamente.

Per conoscere il tipo di variabile definita precedentemente, scriviamo quindi:

type(miaVar1)
type(miaVar2)

Nel momento in cui sarà eseguito il programma, non sarà però possibile vedere il risultato, previa
l’utilizzo della funzione Print(). È quindi necessario utilizzarla, affinché il risultato venga
visualizzato.

print(type(miaVar1))
print(type(miaVar1))

Rieseguendo il programma, verrà visualizzato il risultato <class ‘int’> e <class ‘str>,

rispettivamente per l’intero e la stringa.

1.4 Best practice assegnamento variabile

Le variabili devono soddisfare i seguenti criteri:

Il nome deve avere senso compiuto in modo da essere riutilizzato successivamente con più facilità;

Non esiste una lunghezza prestabilita, sebbene si consiglia di evitare nomi troppo lunghi;
Possono contenere lettere e numeri;

Non possono iniziare con un numero;

Si può utilizzare lo stampatello, ma meglio assicurarci che non sia la prima lettera.

PyCharm evidenzierà in rosso le variabili che non sono ammesse in Python.

1.5 Keyword riservate

Alcune specifiche keyword dovrebbero essere evitate nell’assegnazione delle variabili in python,
perché già esistenti a livello base di funzionalità.

Alcuni esempi sono: and, from, in, or, not, while, true, false, class, for, is, import, ecc…

1.6 Gli operatori

Gli operatori sono simboli speciali che sono utilizzati per eseguire operazioni aritmetiche. Le
parentesi ne definisco la precedenza.

Gli operatori sono:

+ Addizione
- Sottrazione
* Moltiplicazione
/ Divisione

Es:
print(8 + 8)
print(8 * 8)

Utilizzando invece le parentesi, possiamo definire operazioni più complesse.

Es:

print((8 * 8) + 6))

Il risultato sarà quindi 70.

In un secondo caso, è possibile invece eseguire prima l’addizione e poi la moltiplicazione.

Es:
print(8 * (8 + 6))

1.7 Le espressioni

Le espressioni sono una combinazione di valori, variabili e operatori.

I tre elementi sono stati precedentemente affrontati in questa sezione.

Rivedendo i concetti espressi prima, si assegna il valore numerico alle variabili “a” e “b”.

a = 67
b = 68

A questo punto, si definisce una terza variabile “c” che contiene variabili e operatori:

c = (a + b) * b

Stampando poi la variabile c si visualizza il valore finale di 11310, ottenuto dall’espressione creata
prima:

print(c)

L’operatore “+” ha anche una funzionalità extra che riguarda la concatenazione di stringhe.
Anziché effettuare un’addizione, le stringhe vengono attaccate insieme.

Es:

str1 = “ciao”
str2 = “mondo”

print(str1 + str2)

Eseguendo “Run” sul programma, il risultato sarà:

ciaomondo

In questa prima fase non sono presenti spazi che verranno poi successivamente affrontati.

1.8 input da tastiera

Come per altri linguaggi di programmazione, un’operazione frequente riguarda l’inserimento di dati
da parte dell’utente direttamente da tastiera. La funzione input() serve appunto per questo scopo.

È quindi sufficiente dichiarare una variabile e passare la funzione input, come da esempio
sottostante:

testoInserire = input()

A questo punto, è possibile stampare la variabile:

print(testoInserire)

Una volta eseguito il programma, questo ultimo sarà in attesa dell’input, senza che sia infatti presente
un exit code.

Inserendo ad esempio “ciao” e premendo invio, il programma passerà alla funzione print() e
stamperà il valore.
1.9 Commentare il codice

Commentare il codice serve per migliorare la leggibilità, soprattutto in base alla complessità del
progetto e alla necessità di aggiornare continuamente il codice.

Per questo motivo, è consigliabile inserire un commento per ogni linea di codice.

In Python, i commenti si inseriscono aggiungendo un #.

In questo modo il codice inserito successivamente al simbolo “#”, non sarà eseguito.

Questa operazione è particolarmente utile per nascondere momentaneamente delle parti di codice.

Un esempio di commento:

#inserimento input utente

testoInserire = input()
print(testoInserire)

1.14 Funzione Type – Esercizio 1

Le funzioni print() e type() sono le due funzioni viste nel corso di questa sezione.
Es:

print(type(“ciao mondo”))
print(type(7))
print(type(6.8))
print(type(“6.8”))

Eseguendo quindi codice, varranno restituiti i rispettivi valori:

<class ‘str’>
<class ‘int>
<class ‘float>
<class ‘str’>

1.15 Funzione Print – Esercizio 2

Il secondo esercizio riguarda nello specifico la funzione print().

Es:
messaggio = “ciao come stai?”
numeroIntero = 78
numeroConVirgola = 6.8

print(messaggio)
print(numeroIntero)
print(numeroConVirgola)

Eseguendo il programma, verranno stampati i valori dichiarati nelle variabili.

Durante la fase scrittura, PyCharm facilita l’inserimento dei dati attraverso la compilazione.

Infatti scrivendo solamente “print(m)“ il programma ci suggerisce l’elenco di variabili che

presentano la stessa iniziale e in questo caso quindi “print(messaggio)”.

1.16 Operatori aritmetici – Esercizio 3

L’esercizio relativo agli operatori aritmetici riguarda i messaggi di errore rilevati dal programma a
causa di problemi nella sintassi.

Es:
Inserimento di un numero come primo elemento in una variabile.
1valore = 5

Inserimento di un carattere speciale per dichiarare una variabile.

@valore = 8

Inserimento di una keyword non consentita come “class”.

class = “ciao”

Durante l’esecuzione PyCharm si bloccherà all’esecuzione della prima variabile.

Per quanto riguarda le espressioni invece, il linguaggio di programmazione presenta delle priorità
degli operatori:

L’esponenziale, definito con **, viene eseguito prima dell’addizione:

alfa = 3**2+1
print(alfa)

Risultato: 10

Divisione e moltiplicazione:

beta = 3*3+4
print(beta)

Risultato: 13

Divisione e sottrazione da sinistra verso destra :

gamma = 5 - 3-1
print(gamma)

Risultato: 1

1.17 Concatenazione tra stringhe – Esercizio 4

Oltre alla divisione, sotto viene riportato un esempio di operazione con l’operatore modulo che
viene utilizzato per restituire il resto dalla divisione ed è espresso con il simbolo “%”.

Es:
divisione = 7 / 3
print(divisione)

resto = 7 % 3
print(resto)

Concatenazione tra stringhe con l’operatore “+”.

Es:

primaStringa = “alfa”
secondaStringa = “beta”
print(primaStringa + secondaStringa)

Risultato:

alfabeta

2. I costrutti di selezione

2.1 Valori booleani

Un’espressione booleana può assumere solo due valori:

True (Vero)
False (Falso)

1 == 1 Vero
1 == 0 Falso

A differenza dall’operazione di assegnamento “=”, l’operatore “==” serve per effettuare un

confronto tra due operandi.

Es:

print(5 == 5)

Questa condizione risulta vera “TRUE”.

print(5 == 6)

Nel secondo caso invece, la condizione risulta falsa “FALSE”.

Inoltre, è anche possibile utilizzare altri operatori di confronto quali:

(>=) Maggiore
(>=) Minore
!= Diverso

2.2 Operatori di confronto

Sotto alcuni esempi di confronto di valori e i rispettivi risultati ottenuti, attraverso gli operatori di
confronto:

print(5 < 7)

Risultato:
true

print(5 < 5)

Risultato:
false

print(5 == 5)
Risultato:
true

print(5 > 5)

Risultato:
false

print(5 >= 5)

Risultato:
false

print(5 != 5)

Risultato:
false

print(5 != 9)

Risultato:
true

2.3 Operatori logici

And: Restituisce true quando entrambi le condizioni sono vere

Or: Restituisce true quando una delle condizioni è vera
Not: Nega un’espressione

Es:
a=8
print(a > 9 and a < 20)

Il confronto a < 9 è vero perché 8 è inferiore a 9, mentre a < 20 è falso perché 8 è un valore più
piccolo di 20. Utilizzando però l’operatore and, entrambi le due condizioni devono essere vere.
Dato che solo una delle due è vera, la condizione finale sarà FALSE.
Un secondo esempio in cui invece la condizione è true:
a = 12
print(a > 9 and a < 20)

Risultato:
true

Nel successivo esempio, viene applicato l’operatore or. La condizione è vera perché almeno una
delle condizioni è vera:

a = 12
print(a > 9 or a < 20)

Risultato:
true

Un esempio di condizione falsa con l’operatore or:

a=4
print(a > 9 or a == 20)

Risultato:
false

Un esempio di condizione con l’operatore not:

a=4
b=8

print(not(a > b))

Risultato:
true

2.4 Costrutto IF

If in italiano significa “se”. Infatti, il costrutto If controlla se l’espressione all’interno delle parentesi
tonde, risulta vera o falsa. Se l’espressione è vera, il resto del programma sarà eseguito, mentre in
caso contrario si bloccherà. Il blocco if termina sempre con “:”. È importante che print() sia
sempre indentato affinché la formattazione venga riconosciuta da PyCharm.

Es:
valore = 20

if(valore >10):
print(“il valore è maggiore di 10”)
Risultato:
L’espressione valore > 10 è uguale e quindi viene stampata la stringa “ il valore è maggiore di 10”.

Esempio di condizione false:

valore = 9

if(valore >10):
print(“il valore è maggiore di 10”)
Risultato:
valore > 10 non è vera e quindi viene stampato niente.

Un esempio con l’operatore >=

valore = 10

if(valore >=10):
print(“il valore è maggiore di 10”)
Risultato:
il valore è maggiore di 10

2.5 If multipli

È possibile avere allo stesso tempo più condizioni if.

Es:
valore = 20

if (valore == 10):
print(“il valore è uguale a 10”)

if (valore == 20):
print(“il valore è uguale a 20”)

if (valore == 30):
print(“il valore è uguale a 30”)

Risultato:
il valore è uguale a 20
Un altro esempio in cui entrambi le condizioni si verificano:
valore = 3

if (valore == 10):
print(“il valore è uguale a 10”)

if (valore <= 20):

print(“il valore è uguale a 20”)

if (valore <= 30):

print(“il valore è uguale a 30”)

Risultato:
il valore è uguale a 20
il valore è uguale a 30
2.6 Costrutto if – else

Il costrutto if – else controlla se (if) la condizione booleana all’interna del blocco if è vera, per cui
il contenuto inserito viene eseguito, altrimenti (else) se il valore è diverso e quindi la condizione è
falsa, viene eseguito il codice del blocco else.

valore = 3

if (valore == 10):
print(“il valore è uguale a 10”)

else:
print(“il valore inserito non è 10”)

Risultato:
il valore inserito non è 10
La condizione non è vera perché Il valore 3 non è pari a 10.
La condizione è invece false perché valore 3 NON è 10.

2.7 Costrutto ELSEIF

Nel caso in cui si abbia necessità di utilizzare più possibilità, possiamo applicare il costrutto
If / elseif (altrimenti se) / else.
Nel caso in cui sia presente, il costrutto Else (altrimenti) deve essere l’ultimo
Elif è la forma contratta di else if
Non ci sono limiti nei costrutti if
Le condizioni sono esaminate in ordine sequenziale
In caso di condizione vera, il codice appartenente al blocco del costrutto sarà eseguito e
di seguito il blocco if / elseif / else terminerà.

Es:
valore = 300

if (valore == 10):
print(“il valore è uguale a 10”)

elseif (valore == 20):

print(“il valore è uguale a 20”)
elseif (valore == 30):
print(“il valore è uguale a 30”)

else:
print(“il valore NON è 10-20-30”)

Risultato:

il valore NON è 10-20-30

2.8 IF nested

Le nested condition, sono costrutti condizionali incorporati all’interno di altri costrutti condizionali.
Devono essere utilizzati con attenzione capendo il flusso del programma.

Es:
valore = 4
if (valore > 15):
print(“il valore è maggiore di 15”)

else:
if (valore < 7):
print(“il valore è minore di 7 ”)
else:
print(“il valore è maggiore di 7”)

Risultato:
il valore è minore di 7

2.9 Costrutto TRY – EXCEPT

Il costrutto TRY – EXCEPT è consigliato per gestire gli errori, ovvero situazioni in cui il valore
inserito è errato o NON PREVISTO.

Il blocco EXCEPT viene eseguito SOLO in caso in errore di inserimento di un valore in input.

Es:
valorePrimo = 30
key:
print(valore)
except:
print(“la variabile valore non è definita”)

Risultato:
la variabile valore non è definita

2.10 Valori pari e dispari – Esercizio 1

Nell’esercizio riportato sotto si fa utilizzo della funzione int() per convertire il valore inserito tra
parentesi in un intero. Con l’uso della funzione input(), il programma richiede all’utente di inserire
un numero. Dopodiché, effettua il controllo attraverso i costrutti if – else. Inoltre, si fa uso
dell’operatore modulo visto nella sezione 1, per ottenere il resto della divisione.

#numeri PARI o DISPARI

numeroInserito = int(input("Inserire il numero"))

if (numeroInserito % 2 == 1):
print("Il numero è dispari")
else:
print("Il numero è pari")

Inserendo ad esempio 7, il risultato sarà:

Il numero è dispari

2.11 Indovina la figura geometrica – Esercizio 2

Inserito in numero di lati da input, l’obbiettivo è conoscere il tipo di figura geometrica.

#quale figura geometrica?

numeroLati = int(input("Inserire il numero di lati"))

if (numeroLati == 3):
print("è un triangolo!")

elif(numeroLati == 4):
print("è un quadrilatero!")

elif(numeroLati == 5):
print("è un pentagono!")
elif(numeroLati == 6):
print("è un esagono!")

else:
print("numero lati NON consentito...riprova!")

Inserendo il valore 3 in input, il risultato sarà:

è un triangolo!

Inserendo invece 8, non verrà trovata alcuna corrispondenza e sarà perciò eseguito else:
numero lati NON consentito...riprova!

2.12 Tipologia di triangolo – Esercizio 3

In questo tipo di esercizio, l’obbiettivo è conoscere il tipo di triangolo. Saranno utilizzati gli
operatori AND e OR visti in questa sezione. Sulla base dei tre valori inseriti da input, i costrutti if /
elseif / else mostreranno il tipo di triangolo corrispondente.

#tipo di triangolo

primoLato = int(input("Inserire la dimensione del primo lato"))

secondoLato = float(input("Inserire la dimensione del secondo lato"))
terzoLato = float(input("Inserire la dimensione del terzo lato"))

if(primoLato == secondoLato and secondoLato == terzoLato):

print("È un triangolo equilatero!")

elif(primoLato == secondoLato or secondoLato == terzoLato or terzoLato == primoLato):

print("È un triangolo isoscele!")

else:
print("È un triangolo scaleno")

3. I costrutti di iterazione – WHILE/FOR

3.1 Incremento e decremento pattern comune

Durante l’aggiornamento di una VARIABILE, molto spesso il nuovo VALORE dipende dal VALORE
PRECEDENTE.

Secondo la sintassi riportata sotto, la variabile X dipende dal valore X + 1.

Prima però di effettuare un UPDATE (aggiornamento) della variabile, è però necessario
INIZIALIZZARLA, ovvero assegnare un valore iniziale.

X=0
X = X +1

Es:
x = 0 #inizializzazione

print(x)

x=x+2

print(x)

x=x+2

print(x)

Risultato:
0
2
4

Un secondo esempio invece con la sottrazione:

x = 10

print(x)

x=x- 2

print(x)

x=x- 2

print(x)

Risultato:
10
8
6
3.2 Costrutto WHILE

Il termine “iterare” significa appunto ripetere un’operazione e come programmatore, la

RIPETIZIONE DI TASK ha un ruolo fondamentale.

Secondo il flusso di esecuzione infatti:

1. Si valuta se la condizione booleana (contenuta tra parentesi) è VERA o FALSA.
2. Il costrutto WHILE (finché) esegue il codice all’interno del suo blocco fino a che la
condizione è VERA.
3. Appena la condizione è FALSA, esce dal blocco WHILE, eseguendo quindi le altre
istruzioni.

Ogni volta che viene eseguito il blocco WHILE, si effettua un CICLO completo.

Es:
x=1

while (x <= 10):

print(x)
x=x+1
print("Valore raggiunto!")

Il ciclo parte l’inizializzazione della variabile x uguale a 1. Il costrutto WHILE controlla poi che il
valore sia inferiore o uguale a 10. Se la condizione viene soddisfatta, entra nel ciclo stampando il
valore di x e aggiungendo 1 a x.

Il ciclo quindi riparte con x = 2 e da qui effettua il ciclo WHILE fino a che il valore di x diventa 10.

Quando x è invece 11, la condizione non è più verificata perché non è minore o uguale a 10, quindi
viene stampato Valore aggiunto .
Un secondo esempio effettua l’operazione di decremento partendo da 10:

x = 10

while (x > 0):

print(x)
x=x- 1

print("Valore raggiunto!")

3.3 Condizione WHILE TRUE

Come visto con il costrutto WHILE, il ciclo termina quando la condizione è FALSA. Tuttavia, a volte
abbiamo la necessità di LOOP INFINITI che non hanno CONDIZIONI DI USCITA.

while (True):

testo = input("inserisci un testo")

print(testo)

print("Sono uscito!")
La condizione è sempre vera, il ciclo eseguito all’infinito, chiederà sempre di inserire da input un
valore.

3.3 Costrutto BREAK-CONTINUE

Nel caso in cui vogliamo forzare ESPLICITAMENTE l’uscita da un blocco di iterazione, possiamo
utilizzare la keyword BREAK.

In un secondo caso, con la keyword CONTINUE, possiamo invece avere la necessità di terminare
l’iterazione corrente e passare a quella successiva.

Es:
while True:
testo = input("inserisci un testo")
if testo == "terminato":
break
print(testo)
 continue
print("terminato")

Il programma permette di inserire da input un testo. Nel caso in cui non corrisponda a “terminato”, il
testo viene stampato e il ciclo continua. Essendo una condizione vera, il ciclo continuerà fino a che il
testo inserito non corrisponderà a “terminato”.

3.4 Costrutto FOR

Il costrutto WHILE visto precedentemente prevede che la condizione venga eseguita fino a che è
vera. Il ciclo FOR invece viene utilizzato quando le iterazioni sono ben definite e note. Ad esempio,
una lista di oggetti da scorrere oppure una lista di nomi all’interno di un file.

Es:
colori = ["rosso","verde","giallo"]
for scorricolore in colori:
print("Il colore inserito è", scorricolore)
Colori è una lista che contiene le stringe dei singoli colori.
“ scorricolore ” è una variabile creata nel ciclo che permette di scorrere i colori contenuti all’interno
di “colori”.

3.5 Contatore numeri lista – Esercizio 1

Il programma prevede la somma di numeri interi contenuti in una lista definita con “numeri”. La
variabile “somma” viene poi inizializzata a 0. “Numero” conterrà gli elementi della lista.
Inizialmente quindi somma sarà uguale a 0 = 0 + 1. Il valore 1 corrisponde infatti al primo elemento
presente nella lista “numeri”. Al passo successivo invece avremo 1 = 1 + 10. Di seguito l’operazione
verrà ripetuta per tutti i valori nella lista.

#somma numeri contenuti nella lista

numeri = [1,10,20,30,40,50]
somma = 0
for numero in numeri:
somma = somma + numero
print (somma)

3.6 Tabellina del dieci – Esercizio 2

Nell’esercizio seguente sono state inizializzate a 0 le due variabili “contatoreA” e “contatoreB”. Con
il costrutto WHILE, la condizione è vera fino a che contatoreA è <= 100. Una volta in cui la
condizione sarà FALSA, usciremo invece dal ciclo WHILE.

#tabellina del dieci

contatoreA = 0
contatoreB = 0

while contatoreA <= 100:

print ("10 *", contatoreB, " è uguale a ", contatoreA)
contatoreA = contatoreA + 10
contatoreB = contatoreB + 1

Risultato:
3.7 Stampa dei caratteri – Esercizio 3

Nel seguente programma si definisce la variabile “frutta” che contiene la stringa “lampone”. Il ciclo
FOR ha il compito di iterare tutte le lettere (“lettera”) contenute in “frutta”. Per ognuna viene quindi
stampata la stringa di testo, con un contatore che viene incrementato ogni volta di 1.

#stampa lettera
frutta = "lampone"
contatore = 1
for lettera in frutta:
print("La lettera", contatore, "è", lettera)
contatore = contatore + 1
Risultato:
La lettera 1 è uguale l
La lettera 2 è uguale a
La lettera 3 è uguale m
La lettera 4 è uguale p
La lettera 5 è uguale o
La lettera 6 è uguale n
La lettera 7 è uguale e

3.8 Calcolo del fattoriale – Esercizio 4

Il fattoriale è il valore di un numero moltiplicato per i suoi precedenti. Ad esempio, il fattoriale di 4

è 3x2x1.

#calcolo fattoriale
n=5
fattoriale = 1

for i in range(1, n + 1):

fattoriale = fattoriale * i
print("Il fattoriale di",n, "è", fattoriale)

Risultato:

Il fattoriale di 5 è 120

3.9 Numeri pari e numeri dispari – Esercizio 5

In questo esercizio, l’obbiettivo è ottenere tutti i numeri presenti uno specifico range utilizzando
WHILE.

#numeri Pari e numeri dispari

numero = 1

while (numero < 10):

if (numero%2 == 1):
print("Il numero "+str(numero)+" è dispari")

else:
print("Il numero " + str(numero) + " è pari")

numero = numero+1
Risultato:

Il numero 1 è dispari
Il numero 2 è pari
Il numero 3 è dispari
Il numero 4 è pari
Il numero 5 è dispari
Il numero 6 è pari
Il numero 7 è dispari
Il numero 8 è pari
Il numero 9 è dispari

4. Le funzioni

4.1 Le funzioni

Le funzioni servono per riutilizzare la stessa porzione di codice più volte. La funzione riesegue il
codice ogni volta che la funzione stessa viene richiamata all’interno del programma, come una sorta
di template. La funzione visualizzerà in output il risultato.

La funzione print(), vista più volte, è una tipologia di funzione built-in, ovvero precostituita in
Python.

È importante ricordare che:

Tutto quello che viene definito tra parentesi tonde è l’ARGOMENTO della funzione
L’argomento della funzione contiene un VALORE o una VARIABILE che viene poi
riutilizzato eventualmente come INPUT della funzione
La funzione quindi prende in ingresso un ARGOMENTO, effettua una COMPUTAZIONE
e restituisce (RITORNA) un VALORE.

Es:
print(“Ciao Mondo!”)

4.2 Funzioni Built-in

Le funzioni Built-in sono già presenti e non hanno quindi bisogno di un’ulteriore definizione. Le
altre funzioni, invece, definite all’interno del programma sono utili per evitare di riscrivere la stessa
porzione di codice più volte. Una volta definite quindi, possiamo andare a modificare direttamente la
parte interessata.

Un esempio di funzione Built-in è len() che serve a ottenere la lunghezza di una stringa.

Es:
prin(len(“ciao mondo!”))

Risultato:
11

4.3 I moduli – Modulo Math – Random

Per funzioni Built-in di tipo matematico, abbiamo la necessità di importare il MODULO MATH che
contiene un elenco di funzioni predefinite. La documentazione ufficiale Python riporta a cosa servono
le singole funzioni.

Il comando per effettuare l’importazione è:

>>> import math

Nell’esempio sottostante vogliamo utilizzare la funzione SORT (radice quadrata) presente nel
modulo MATH. 144 è il valore passato come argomento della funzione.

>>> math.sqrt(144)

Un secondo esempio è la funzione RANDOM:

import random
x = random.random()
print(x)

Risultato:
0.9905085566975174

4.4 Definizione di una funzione

Possiamo definire una propria funzione utilizzando la keyword “def” seguita dal nome della
funzione. Utilizzare una funzione migliora la leggibilità del codice, la manutenzione e le performance
del programma.

def stampaTesto():
print(“Ciao mondo”)

Per richiamare la funzione ed eseguirla:

>>> stampaTesto()

Es:

def stampaTesto():
print("Ciao Mondo!")
print("Ciao Mondo!")
print("Ciao Mondo!")
print("Ciao Mondo!")
 print("Ciao Mondo!")
print("Ciao Mondo!")
print("Ciao Mondo!")

stampaTesto()
stampaTesto()
stampaTesto()
stampaTesto()
stampaTesto()
stampaTesto()

4.5 Funzioni di una funzione

È possibile utilizzare una FUNZIONE all’interno della DEFINIZIONE di un’altra funzione.

def ristampaTesto():
stampaTesto():

Es:
def stampaTesto():
print("Ciao Mondo!")
print("Ciao Mondo!")
print("Ciao Mondo!")
print("Ciao Mondo!")
print("Ciao Mondo!")
 print("Ciao Mondo!")
print("Ciao Mondo!")

def ristampaTesto():
stampaTesto()

#stampaTesto()
ristampaTesto()

Risultato:
Ciao Mondo!
Ciao Mondo!
Ciao Mondo!
Ciao Mondo!
Ciao Mondo!
Ciao Mondo!
Ciao Mondo!

4.6 Argomenti di una funzione

Nell’esempio riportato viene passato un ARGOMENTO (parametro) alla funzione:

def stampaFiore(nomeFiore):
print(nomeFiore)

stampaFiore("girasole")
stampaFiore("tulipano")

Risultato:
girasole
tulipano

4.7 Variabili come argomento di funzione

Come argomento della funzione, è possibile utilizzare un’ESPRESSIONE o una VARIABILE.

def stampaFiore(nomeFiore):
print(nomeFiore)

fiore = "margherita"
stampaFiore("girasole")
stampaFiore("tulipano")
stampaFiore(fiore)

Risultato:
girasole
tulipano
margherita

È importante ricordare che il nome della variabile “fiore” non è in relazione con il parametro della
funzione “nomeFiore”.

4.8 Valore di ritorno – Esercizio 1

Nell’esercizio, l’obbiettivo è definire la funzione moltiplica() che serve moltiplicare un valore

passato come argomento x. RETURN serve per restituire 5 moltiplicato per un valore.

#funzione moltiplica
def moltiplica(x):
return 5 * x

y=6
print(moltiplica(3))
print(moltiplica(5))
print(moltiplica(9))
z = moltiplica(y)

print(z)

Risultato:
15
25
45
30
4.9 Funzione con 2 parametri – Esercizio 2

La funzione accetta due parametri in ingresso: “nome” ed “eta”. Il parametro di default è eta = 50.
Quindi se non viene specificato di default, il valore di “eta” è 35.

#stampa informazioni
def stampaInfo( nome, eta ):
print ("Nome: ", nome)
print ("Età ", eta)

stampaInfo( eta = 50, nome = "carlo" )

stampaInfo( nome = "marco", eta= 67 )

Risultato:
Nome: carlo
Età: 50

Nome: marco
Età: 67

4.10 Funzione somma – Esercizio 3

La funzione somma() accetta due argomenti. “totaleSomma” contiene la somma dei due argomenti.
“totale” richiama la funzione somma() passando i due valori.

#calcolo somma
def somma( arg1, arg2 ):
totaleSomma = arg1 + arg2
print ("Stampa dentro la funzione : ", totaleSomma)

totale = somma( 10, 20 );

print ("Stampa fuori dalla funzione : ", totale)

Risultato:
Stampa dentro dalla funzione : 30
Stampa fuori dalla funzione : 30

4.11 Funzione valore assoluto – Esercizio 4

La funzione serve a calcolare il valore assoluto. Passato il parametro “num” alla funzione
valore_assoluto(), il ciclo if – else, viene utilizzato per restituire i valori di “num” e “-num”. Ad
esempio nel caso di -4, dato che il valore è inferiore a 0, il valore assoluto restituito è 4.

#calcolo valore assoluto

def valore_assoluto(num):
if (num >= 0):
return num
else:
return -num
print(valore_assoluto(2))
print(valore_assoluto(-78))

Risultato:
2
78

4.12 Funzione elevato a potenza – Esercizio 5

La funzione restituisce x*x e quindi un valore elevato a potenza.

#x elevato alla seconda

def f(x):
return x*x
print(f(3))

print(f(3) + f(4))

Risultato:
9
25

5. Le stringhe

5.1 Stringhe e indici

Le stringhe sono tipologie di dato contenente una sequenza di caratteri. L’INDICE è importante
perché definisce il POSIZIONAMENTO all’interno di una stringa, sulla quale è possibile
spostarsi verso destra o sinistra.

Un’operazione frequente è l’ESTRAZIONE di un carattere da una stringa. Il valore 0 in Python

definire il primo valore dell’indice all’interno di una stringa. Il valore quindi indicato tra parentesi
quadre ne definisce il posizionamento.

>>> primaLettera = colore[0]

Es:

colore = "rosso"

primoCarattere = colore[4]

print(primoCarattere)
Risultato:
o

5.2 Funzione LEN()

La funzione len() serve per ottenere la lunghezza di una stringa. Non ha necessità di importare un
modulo.

colore = "arancione"

lunghezza = len(colore)

print(lunghezza)

Risultato:
9

5.3 Scorrere gli elementi di una stringa

Un’operazione frequente è scorrere il contenuto di una stringa con un CICLO quale FOR o WHILE.

Elementi fondamentali per lo scorrimento sono:

inizializzazione di una variabile
definizione di un indice
 pattern di incremento x = x + 1 e x = x-1 oppure rispettivamente x++ e x--

5.4 Scorrere gli elementi di una stringa - WHILE

Si definisce una variabile per la stringa e poi una variabile “indice” inizializzata a 0. Il costrutto
WHILE contiene una condizione che utilizza la funzione len() a cui viene passato l’argomento
“frutta”.
Utilizzando “frutta[indice]” e stampando poi “carattere”, il ciclo visualizzerà ad ogni iterazione la
lettera stampata.

frutta = "mandarino"

indice = 0
while(indice < len(frutta)):
carattere = frutta[indice]
print(carattere)
indice = indice + 1

Risultato:
m
a
n
d
a
r
i
n
o
5.5 Scorrere gli elementi di una stringa - FOR

Il costrutto FOR si utilizza quando c’è una struttura definita.

Con il FOR, si indica di scorrere i singoli caratteri di una stringa, stampandoli.

colore = "verde"

for carattere in colore:

print(carattere)

print(carattere)

Risultato:
v
e
r
d
e
5.6 Contatore caratteri stringa

Un’operazione frequente è conoscere quante volte un carattere appare all’interno di una stringa.
Per questo compito, si utilizza il costrutto di SELEZIONE.

Nell’esempio sottostante, si utilizza un ciclo FOR per scorrere la stringa. Oltre a questo, si controlla
con IF se carattere è uguale ad “a” e in tale caso, si incrementa “numeroOccorrenze” di 1. In questo
modo il ciclo scorre la stringa e stampa il numero di volte che il carattere “a” è presente in
“arancia”.

frutto = "arancia"

numeroOccorrenze = 0

for carattere in frutto:

if(carattere == "a"):
numeroOccorrenze = numeroOccorrenze + 1
print(numeroOccorrenze)
Risultato:
1
2
3

5.7 Confronto tra stringhe

Il costrutto IF viene utilizzato per un confronto tra stringhe.

Es:
parola1 = "insalata"
parola2 = "insalata"

if (parola1 == parola2):
print("stessa stringa")
else:
print("stringa differente")

Risultato:
stessa stringa

5.8 Stringhe e funzioni Built-in

La funzione type() permette di conoscere il contenuto passato. Nel caso specifico, l’esempio sotto
riportato visualizza la tipologia stringa. La funzione DIR() invece riporta tutte le funzioni disponibili
da utilizzare con il tipo string.

colore = "GIALLO"

print(type(colore))

print(dir(colore))

Risultato:

La funzione LOWER() serve ad esempio per convertire i caratteri della stringa in minuscolo, mentre
CAPITALIZE() in maiuscolo.

colore2 = colore.lower()
print(colore2)

colore3 = colore2.capitalize()
print(colore3)

Risultato:
5.9 Cercare elementi di una stringa

Nel caso in cui ci sia necessità di estrarre SOLO alcune informazioni di una stringa, è possibile
utilizzare FIND().

Es:
email = "da [email protected]"
cercaChiocciola = email.find("d")
print(cercaChiocciola)

L’indice parte da 0, quindi find() ricercherà la posizione dalla lettera all’interno della stringa.

Risultato:
0
5.10 Slicing di una stringa – Esercizio 1

Nell’esempio sottostante si utilizzano gli indici definendo un punto di inizio e fine. Nel caso
specifico quindi vengono visualizzate le lettere comprese nell’intervallo da 3 a 6.

stringa = "ciao Mondo"

stringa2 = stringa[3:6]
print(stringa2)

Risultato:
oM
La funzione STRIP() serve per eliminare gli spazi.

stringa = " ciao Mondo "

print(stringa.strip())

Risultato:
ciao Mondo
5.11 Splitting di una stringa – Esercizio 2

La funzione REPLACE() accetta due parametri: l’elemento da sostituire e quello che va sostituito.

Es:
stringa = "ciao Mondo"
print(stringa.replace("M", "m"))

Risultato:
ciao mondo
La funzione SPLIT() è applicata alla stringa e dato l’elemento separatore “,” vengono create delle
sottostringhe.

stringa = "ciao,Mondo, ciao"

print(stringa.split(","))

Risultato:
[‘ciao’, ‘Mondo’]

5.12 Concatenazione tra stringhe – Esercizio 3

Nel caso sottostante, l’operatore + serve per concatenare delle stringhe.

str1 = 'Ciao'
str2 ='Mondo'

print('str1 + str2 = ', str1 + str2)

print('str1 * 3 =', str2 * 3)

Risultato:
str1 + str2 = CiaoMondo
str1 * 3 = MondoMondoMondo

In questo caso invece viene controllato se le lettere sono presenti nella stringa. Il risultato è un
valore booleano TRUE o FALSE.

print("a" in "programma")

print("o" in 'casa')

Risultato:
True
False
 6. Le liste

6.1 Le liste

Così come le STRINGHE, anche le LISTE contengono una sequenza di valori, con la differenza
principale che le STRINGHE possono contenere solo caratteri, mentre le LISTE contengono
qualsiasi tipo di valore definiti come elementi o items.

[20,10,”rosso”,”verde”,[10,”giallo”]]

Gli elementi in una lista sono separati dalla virgola. Nell’esempio sottostante, la lista contiene una
seconda lista all’interno, ma questa potrebbe essere anche vuota, con la possibilità di assegnare poi
dei valori di una lista ad una variabile.

Es:
colore = ["rosso","verde","giallo"]

colore[0] = "blu"

a = [1,10,"verde"]

b = []

print(colore)
#print(a)
#print(b)

Risultato:
["rosso","verde","giallo"]
[1,10,"verde"]
[]

6.2 Scorrere elementi di una lista

Come per le stringhe, per scorrere gli elementi di una lista si usa un CICLO.

Nel caso sottostante si utilizza il costrutto FOR senza specificare la condizione come nel costrutto
WHILE.

frutta = ["mela","pera","arancia","mandarino"]

for elemento in frutta:

print(elemento)

Risultato:
mela
pera
arancia
mandarino
6.3 Aggiornare elementi lista

Per SCRIVERE o AGGIORNARE gli elementi di una lista, è necessario utilizzare gli INDICI per
indicare ogni elemento nella lista.

La funzione len() controlla la lunghezza della lista.

L’obbiettivo è scorrere la lista e moltiplicare ogni elemento per 10.

valori = [10,20,30,40,50]
print(valori)
for indice in range(len(valori)):
valori[indice] = valori[indice] * 10

print(valori)
Risultato:
[10,20,30,40,50]
[100,200,300,400,500]
6.4 Lista – Funzioni Built-in
Alcune funzioni Built-in sono utilizzate per le liste con APPEND(), che serve per inserire in fondo
un altro elemento. La funzione accetta un argomento “e”, ovvero il valore da inserire.

alfabeto = ["a","b","c","d"]

alfabeto.append("e")

print(alfabeto)

Risultato:
["a","b","c","d","e"]

SORT() è un’altra funzione da utilizzare con le liste e serve per riordinare gli elementi.

alfabeto = ["d","a","c","b"]

alfabeto.append("e")

print(alfabeto)

Risultato:
["a","b","c","d"]
6.5 Eliminare elementi lista

Specificando l’indice, il metodo POP() permette la rimozione di un elemento.

alfabeto = ["d","a","c","b"]

elemento = alfabeto.pop[0]

print(elemento)

Risultato:
["a","c","b"]
d
In alternativa possiamo usare DEL() che non salva il valore eliminato:

alfabeto = ["d","a","c","b"]

del alfabeto[0]

print(alfabeto)

Risultato:

["a","c","b"]

6.6 Lista Sum() – Max() – Min()

Altre funzioni Built-in da utilizzare con le liste sono:

LEN() restituisce il numero di elementi in una lista
MAX() restituisce il valore numerico maggiore in una lista
MIN() restituisce il valore numerico minore in una lista
SUM() somma i valori in una lista

Es:
listaNumerica = [5,2,8,6,1,9]

print(len(listaNumerica))

print(max(listaNumerica))

print(min(listaNumerica))
print(sum(listaNumerica))

Risultato:
6
9
1
31

6.7 Ordinare elementi lista – Esercizio 1

Nell’esercizio sottostante si crea una lista vuota che conterrà dei numeri. Si inizializza una variabile
valoreInserito che prende in input dei valori convertiti in interi. Il ciclo WHILE serve per controllare
che la condizione sia vera fino a che non viene inserito 0.
Ogni volta viene aggiunto alla lista un nuovo valore. Infine, la lista viene ordinata.

listaNumerica = []
valoreInserito = int(input("Inserisci un valore. Premi 0 per uscire"))

while(valoreInserito != 0):
listaNumerica.append(valoreInserito)
valoreInserito = int(input("Inserisci un valore. Premi 0 per uscire"))

listaNumerica.sort()
print(listaNumerica)

Risultato:
Inserisci un valore. Premi 0 per uscire6
Inserisci un valore. Premi 0 per uscire5
Inserisci un valore. Premi 0 per uscire2
Inserisci un valore. Premi 0 per uscire4
[2,4,5,6]

6.8 Rimuovere duplicati lista - Esercizio 2

Nell’esercizio si controlla con il costrutto IF se la parola inserita da input è già presente o meno
all’interno della lista, e in tal caso il valore viene aggiunto alla lista corrente.

listaParole = []
parola = input("Inserisci una parole. Premi ENTER per uscire")

while(parola != ""):
if parola not in listaParole:
listaParole.append(parola)
parola = input("Inserisci una parole. Premi ENTER per uscire")

print(listaParole)

Risultato:
Inserisci una parole. Premi ENTER per uscirecasa
Inserisci una parole. Premi ENTER per uscirecane
Inserisci una parole. Premi ENTER per uscirecane
Inserisci una parole. Premi ENTER per uscirecane
Inserisci una parole. Premi ENTER per usciregatto
Inserisci una parole. Premi ENTER per usciretopo
["casa", "cane", "gatto", "topo"]

6.9 Verificare presenza elemento - Esercizio 3

Il costrutto IF serve per controllare se un elemento è presente nella lista.

miaLista = ["mela", "banana", "arancia"]

if "mela" in miaLista:
print("mela è in questa lista!")

Risultato:
mela è in questa lista!
6.10 Slicing di una lista – Esercizio 4

L’obbiettivo dell’esercizio è stampare i valori definiti in un intervallo specifico. I due punti

definiscono la fine. Ad esempio [2:5], stamperà i valori compresi dall’indice 2 al 5.

miaLista = ['p','r','o','g','r','a','m','i','z']

print(miaLista[2:5])

print(miaLista[:-5])

print(miaLista[5:])

print(miaLista[:])

Risultato:
['o','g','r']
['p','r','o','g']
['a','m','i','z']
['p','r','o','g','r','a','m','i','z']
6.11 Lista – potenza del due – Esercizio 5

Ogni elemento della lista viene elevato alla potenza del 2, indicata con **.

lista = []
for x in range(10):
lista.append(2 ** x)

print(lista)

Risultato:
[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
 7. Le tuple
7.1 Le tuple

Le tuple sono molto simili alle liste, ma a sono IMMUTABILI. Inoltre, si utilizzano gli indici come
per le liste, ma per dichiararle si utilizzano le parentesi tonde.

L’esercizio sottostante dimostra appunto che tentando di modificare un elemento della tupla, PyCharm
restituisce un errore.

#tupla1 = ("albero","casa","letto","cucina")

#tupla1[0] = "fiore"

lista1 = ["albero","casa","letto","cucina"]

lista1[0] = "fiore"

print(lista1)

#print(tupla1)

Risultato:

7.2 Scorrere/cercare elementi tupla – Esercizio 1

Con le tuple si possono utilizzare sia il costrutto FOR che WHILE, come visti precedentemente con
le liste. L’esempio sotto riporta l’utilizzo del ciclo FOR per scorrere gli elementi di una tupla.

miaTupla = ("mela", "banana", "fragola")

for x in miaTupla:
print(x)
Risultato:
mela
banana
fragola

Nel secondo esercizio invece, non essendo presente l’elemento “mela” nella tupla, il programma
esce.

miaTupla = ("banana", "fragola")

if "mela" in miaTupla:
print("mela è in questa tupla")

Risultato:
7.3 Aggiungere elementi tupla – Esercizio 2

La funzione LEN() viene utilizzata per visualizzare il numero di elementi contenuti in una tupla.

miaTupla = ("mela", "banana", "fragola")

print(len(miaTupla))

Risultato:
3

Nel secondo esercizio viene aggiunto un elemento nella tupla, sebbene questa sia immutabile.
PyCharm infatti restituisce un errore.

miaTupla = ("mela", "banana", "fragola")

miaTupla[2] = "arancia"
print(miaTupla)

Risultato:
7.4 Cancellare elemento tupla – Esercizio 3

Nell’esercizio viene provato ad eliminare l’elemento della tupla con indice 0. Come alternativa
viene invece eliminata l’intera tupla.

miaTupla = ("mela", "banana", "fragola")

#del miaTupla[0]
del miaTupla

#print(miaTupla)

Risultato:

7.5 Slicing di una tupla – Esercizio 4

L’esercizio effettua la stampa degli elementi della tupla nell’intervallo specificato.

miaTupla = ('p','r','o','g','r','a','m','i','z')
print(miaTupla[1:4])

print(miaTupla[:-7])

print(miaTupla[7:])

print(miaTupla[:])

Risultato:

7.6 Concatenazione tra tuple – Esercizio 5

L’esercizio verifica la concatenazione di una tupla.

print((“casa”, 2, 3) + (4, “cucina”, 6))

print((“mela”,) * 3)

Risultato:
(“casa”, 2, 3, 4, “cucina”, 6)
(“mela”, “mela”, “mela”)
7.7 Confronto elementi tupla – Esercizio 6

Nell’esercizio sotto riportato vengono utilizzate le funzioni Built-in COUNT() e INDEX().

miaTupla = ('a','p','p','p','l','e',)

#print(miaTupla.count('p'))

print(miaTupla.index('a'))

Risultato:
0
#print((1,2,3) == (1,2,3))

print((1,2,7) == (1,2,3))

Risultato:
False
 8. I dizionari

8.1 I dizionari

I dizionari sono simili alle liste, ma mentre nelle liste gli indici sono valori interi, i dizionari creano
una corrispondenza (mapping) tra gli indici (KEYS) e i valori stessi. Quindi l’associazione è di tipo
KEY + VALUE.

DICT() serve per definire un dizionario vuoto.

8.2 Inserimento di elementi

Nell’esempio sottostante vengono inseriti degli elementi (KEY-VALUE) all’interno di un dizionario

vuoto. Le associazioni di ogni elemento sono definite come mapping.

Es:
brandToModel = dict()

brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}

print(brandToModel)

Risultato:
{"fiat":"punto","opel":"corsa","ford":"fiesta"}

8.3 Ricerca dei VALORI

Nel caso in cui la necessità sia ricercare un valore specifico in un dizionario, possiamo fare uso
della seguente sintassi:

print(brandToModel["ford"])

Il valore tra parentesi quadre è la KEY, dato che appunto con i dizionari siamo sempre in presenza
dell’associazione KEY-VALUE. La funzione LEN() ritorna il numero KEY-VALUE all’interno del
dizionario.

Es:
brandToModel = dict()

brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}

print(brandToModel["ford"])

Risultato:
fiesta

8.4 Ricerca delle CHIAVI

L’operatore IN serve per verificare se un elemento è presente come KEY all’interno di un dizionario.
L’esempio sottostante ricerca il valore “ford” all’interno del dizionario brandToModel. Come visto
in precedenza, la funzione LEN() serve per ritornare il numero KEY-VALUE all’interno del
dizionario.

brandToModel = dict()
brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}

a = "ford" in brandToModel
print(a)

#print(brandToModel["ford"])

#print(len(brandToModel))

Risultato:
True

8.5 Conteggio vocali e consonanti

L’esercizio riportato sotto ha come finalità, data una parola in un dizionario, di contare quante volte
consonanti e vocali appaiono al suo interno. Verrà quindi realizzata un’associazione
consonante/vocale in cui si conteggia quante volte la chiave si ripete. Anche per i dizionari, il
costrutto di iterazione e selezione è essenziale.

Il programma scorrerà quindi tutte le lettere contenute all’interno della stringa “orologio”. Allo
stesso tempo, controllerà se “carattere” è presente in “ mioDizionario ”. Alla prima iterazione, il
dizionario è vuoto e quindi il ciclo passerà direttamente ad else. Successivamente partendo dal primo
carattere, verrà creata la prima associazione (MAPPING). Ogni volta se presente un carattere, verrà
incrementato il dizionario.

parola = "orologio"

mioDizionario = dict()
for carattere in parola:

if (carattere in mioDizionario):
mioDizionario[carattere] = mioDizionario[carattere] + 1
else:
mioDizionario[carattere] = 1

print(mioDizionario)

Risultato:

Il risultato sarà quindi l’associazione della lettera (CHIAVE) e il numero di volte in cui viene
visualizzata (VALORE) all’interno della parola.

8.6 Il metodo GET()

Il metodo GET() è utile perché se la KEY è presente ritorna il suo valore, altrimenti ritorna un
valore di default.

brandToModel = dict()
brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}

print(brandToModel.get(‘for’))

Risultato:
None
Il programma ritorna il valore se la chiave esiste all’interno del dizionario, altrimenti ritorna il
valore di default None (non presente).

8.7 Scorrere gli elementi del dizionario

Il ciclo FOR serve per scorrere le chiavi del dizionario e parallelamente stampa i valori.

brandToModel = dict()
brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}

for key in brandToModel:

print(key,brandToModel[key])

Risultato:
fiat punto
opel corsa
ford fiesta
8.8 Estrarre KEY/VALORE – Funzioni Bult-in – Esercizio 1

L’obbiettivo dell’esercizio è utilizzare la funzione Bult-in VALUES() per estrarre i valori del
dizionario brandToModel. Il ciclo FOR serve per estrarre tutti i valori del dizionario.

#estrarre valori dizionario

brandToModel = dict()
brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}
for x in brandToModel.values():
print(x)

Risultato:
punto
corsa
fiesta
Nel secondo esempio invece, utilizzando la funziona ITEMS() si vuole ottenere la coppia degli
elementi CHIAVE-VALORE.

#estrarre key.values dizionario

brandToModel = dict()
brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}
for x, y in brandToModel.items():
print(x, y)

Risultato:
fiat punto
opel corsa
ford fiesta
8.9 Rimuovere elementi – Funzioni Bult-in – Esercizio 2

La funzione Bult-in POP() serve per eliminare un mapping dal dizionario.

#rimuovere un elemento dal dizionario

brandToModel = dict()
brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}

brandToModel.pop("fiat")
brandToModel.pop("opel")

print(brandToModel)

Risultato:
{"ford":"fiesta"}
Un altro esempio utilizza il metodo POPITEM() che non fa uso di un argomento e serve per
eliminare l’ultimo elemento del dizionario.

#rimuovere ultimo elemento dizionario

brandToModel = dict()
brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}
brandToModel.popitem()
print(brandToModel)

Risultato:
{"fiat":"punto","opel":"corsa"}
8.10 Rimuovere elementi – keyword DEL – Esercizio 3

La keyword DEL serve per eliminare una chiave racchiusa tra parentesi quadre.

brandToModel = dict()
brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}
del brandToModel["fiat"]
print(brandToModel)

Risultato:

{"opel":"corsa","ford":"fiesta"}
Il secondo esempio ha la finalità invece di eliminare l’intero dizionario utilizzando sempre la
keyword DEL. Provando a stampare il dizionario, verrà restituito un messaggio di errore in quanto il
dizionario non esiste più.

brandToModel = dict()
brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}
del brandToModel

print(brandToModel)

Risultato:
8.11 Elevamento alla seconda – Esercizio 4

La funzione CLEAR() serve per rimuovere gli elementi ma mantenere il dizionario stesso.

brandToModel = dict()
brandToModel = {"fiat":"punto","opel":"corsa","ford":"fiesta"}
brandToModel.clear()
print(brandToModel)

Risultato:
{}
L’esercizio sottostante inserisce i valori nel dizionario elevando il valore a seconda ogni volta in
base allo scorrimento da 0 a 9.

radice = {}
for x in range(10):
radice[x] = x*x

print(radice)

Risultato:
 9. Le classi

9.1 Le classi

Un oggetto può contenere al suo interno una o più FUNZIONI oltre a DATI (attributi) utilizzati dalle
funzioni stesse. La keyword CLASS serve a definire una classe che include ATTRIBUTI e
METODI.

Ogni metodo, come le funzioni, inizia con la keyword DEF. Nell’esempio sottostante è presente la
definizione di una classe InvitatiFesta . L’attributo in oggetto è “x”, mentre il metodo è “SELF”.
Come si può notare SELF è sempre il primo parametro passato. Tutto quello che è racchiuso nella
definizione della classe (attributi e metodi) è un TEMPLATE .

Solo eseguendo InvitatiFesta(), viene effettivamente creato l’oggetto. “contaInvitati” fa quindi

riferimento all’oggetto appena creato e serve per sfruttare attributi e metodi.

Ogni volta che “festa” viene richiamato, la variabile x sarà incrementata di 1 perché si riferisce
all’istanza. L’operazione di ripete quattro volte.

class InvitatiFesta:

x=0

def festa(self):
self.x = self.x +1
print("Invitato numero", self.x)

contaInvitati = InvitatiFesta()
contaInvitati2 = InvitatiFesta()

contaInvitati.festa()
contaInvitati.festa()
contaInvitati.festa()
contaInvitati.festa()
contaInvitati.festa()

contaInvitati2.festa()
contaInvitati2.festa()
contaInvitati2.festa()
contaInvitati2.festa()
contaInvitati2.festa()
Risultato:

9.2 Elementi di una classe

TYPE serve per verificare la natura di ATTRIBUTI o METODI.

class InvitatiFesta:

x=0

def festa(self):
self.x = self.x +1
print("Invitato numero", self.x)

contaInvitati = InvitatiFesta()

print(type(contaInvitati.festa))

Risultato:
<class ‘method’>

9.3 Oggetti e ciclo di vita

L’oggetto ha un ciclo di vita che comprende la parte in cui viene creato e poi distrutto. Quando un
oggetto viene creato, le variabili associate vengono CREATE e poi DISTRUTTE.

I metodi per verificare i due stati sono:

__init__(self)
__del__(self)

Nell’esempio sottostante è presente una variabile di iterazione in cui la variabile 0 è uguale a 0.

Viene successivamente chiamato il metodo festa(). Successivamente il metodo termina il suo ciclo di
vita perché non ci sono altre operazioni legate all’oggetto ed entra nella fase di distruzione in cui
vengono distrutte le variabili associate a contaInvitati .

Es:
class InvitatiFesta:

x=0

def __init__(self):
print("FASE DI CREAZIONE", self.x)

def festa(self):
 self.x = self.x +1
print("Invitato numero", self.x)

def __del__(self):
print("FASE DI DISTRUZIONE", self.x)

contaInvitati = InvitatiFesta()

contaInvitati.festa()
contaInvitati.festa()
contaInvitati.festa()
contaInvitati.festa()
contaInvitati.festa()

Risultato:

9.4 Creazione di più oggetti

Un altro esempio prevede invece la creazione di più oggetti appartenenti alla stessa classe. Il metodo
__init__(self) serve per definire valori diversi iniziali per ognuno degli oggetti creati.
È quindi presente l’inizializzazione della variabile x a 0 che conterà il numero degli invitati e la
definizione della stringa vuota nomeInvitato . Al metodo init viene passato l’argomento “nome”. La
stringa conterrà quindi “nome”. Per ciascun oggetto verrà richiamato il metodo festa().

class InvitatiFesta:

x=0
nomeInvitato = ""

def __init__(self, nome):

self.nomeInvitato = nome

def festa(self):
self.x = self.x + 1
print("nome invitato: ", self.nomeInvitato)

InvitatoA = InvitatiFesta("xxxx")
InvitatoB = InvitatiFesta("pluto")
Invitatoc = InvitatiFesta("marco")

InvitatoA.festa()
InvitatoB.festa()
Invitatoc.festa()

Risultato:
nome invitato: xxxx
nome invitato: pluto
nome invitato: marco
9.5 Ereditarietà

Un’altra caratteristica della programmazione ad oggetto è l’EREDITARIETÀ (inheritance). Per

ereditarietà si intende la possibilità di creare una nuova classe (classe figlio / child class)
estendendo una classe già esistente (classe genitore / parent class).

Nell’esempio sottostante, “InvitatiStanzaA” è una classe nuova creata sulla base di “InvitatiFesta”. Il
metodo festa() è ereditato dalla classe genitore. “InvitatoD” è un oggetto della sottoclasse.

class InvitatiFesta:

x=0
nomeInvitato = ""

def __init__(self, nome):

self.nomeInvitato = nome

def festa(self):
self.x = self.x + 1
print("nome invitato: ", self.nomeInvitato)

class InvitatiStanzaA(InvitatiFesta):
 y=0

def festaStanzaA(self):
self.y = self.y + 1
self.festa()
print(self.nomeInvitato, "numero invitati", self.y)

InvitatoA = InvitatiFesta("pippo")
InvitatoB = InvitatiFesta("pluto")
InvitatoC = InvitatiFesta("marco")
InvitatoD = InvitatiStanzaA()

InvitatoA.festa()
InvitatoB.festa()
InvitatoC.festa()
InvitatoD.festaStanzaA()

Risultato:

9.6 Classe Persona – Esercizio 1

La classe “Persona” contiene il metodo init a cui viene passato l’argomento nome ed eta.
L’oggetto “persona1” viene passato “pippo” e “36”.

class Persona:

def __init__(self, nome, eta):

self.nome = nome
self.eta = eta

def funzioneStampaNome(self):
print("Il mio nome Ë " + self.nome)

def funzioneStampaeta(self):
print("la mia eta Ë " , self.eta)

persona1 = Persona("Luigi", 36)

persona1.funzioneStampaNome()
persona1.funzioneStampaeta()

Risultato:
il mio nome è Luigi
la mia eta è 36

9.6 Classe Robot – Esercizio 2

La classe “Robot” viene definita. def __init__(self, name) serve per l’inizializzazione del robot,
mentre def die(self) per la distruzione.
Il metodo def say_hi(self) serve invece per salutare. def how_many(cls) definisce il numero di robot
presenti.

class Robot:
"""Represents a robot, with a name."""

# A class variable, counting the number of robots

population = 0

def __init__(self, name):

"""Initializes the data."""
self.name = name
print("(Initializing {})".format(self.name))

# When this person is created, the robot

# adds to the population
Robot.population = Robot.population + 1

def die(self):
"""I am dying."""
print("{} is being destroyed!".format(self.name))

Robot.population = Robot.population - 1

if Robot.population == 0:
print("{} was the last one.".format(self.name))
else:
print("There are still {:d} robots working.".format(
Robot.population))

def say_hi(self):
"""Greeting by the robot.

Yeah, they can do that."""

print("Greetings, my masters call me {}.".format(self.name))

@classmethod
def how_many(cls):
"""Prints the current population."""
print("We have {:d} robots.".format(cls.population))

droid1 = Robot("R2-D2")
droid1.say_hi()
Robot.how_many()
droid2 = Robot("C-3PO")
droid2.say_hi()
Robot.how_many()

print("\nRobots can do some work here.\n")

print("Robots have finished their work. So let's destroy them.")

droid1.die()
droid2.die()

Robot.how_many()

Risultato:

10. I file

10.1 Ottenere directory corrente

La prima azione eseguibile su un file è l’apertura, seguita poi dalla LETTURA e SCRITTURA.
Le operazioni sono quindi:
Ottenere la directory di lavoro corrente
Ottenere la lista di file presenti nella directory

È necessario quindi:
importare il modulo OS (operating system) per agire con diverse funzioni
Utilizzare la funzione GETCWD() (get current word directory) che permette di ottenere
la directory corrente
Ottenere la lista delle directory di lavoro con LISTDIR().
Verrà infine restituito un file handle che sarà manipolabile.

import os
cwd = os.getcwd()
files = os.listdir(cwd)
print(cwd, files)

Risultato:

10.2 Apertura file – Lettura righe

La funzione OPEN() serve per aprire il file e restituire il file handle modificabile. Nel caso in cui il
file non venga trovato, viene restituito un messaggio di errore.

import os
cwd = os.getcwd()
files = os.listdir(cwd)
print(cwd, files)

fileopen = open(r"C:\Users\Administrator\PycharmProjects\test10\fileProva.txt")
print(fileopen)

Risultato:
10.3 Conteggio righe di un file

Un file può essere visto come una SEQUENZA DI LINEE, di cui ognuna contiene implicitamente il
carattere “\n” a fine stringa.

Il programma sottostante conta quante linee sono presenti all’interno di un file. La variabile
“contatore” è inizializzata a 0 e il contatore si incrementerà per ogni linea presente nel FILE.

import os
cwd = os.getcwd()
files = os.listdir(cwd)

#print(cwd, files)

fileopen = open(r"C:\Users\Administrator\PycharmProjects\test10\fileProva.txt")
#print(fileopen)

contatore = 0

for linea in fileopen:

contatore = contatore +1

print(contatore)

Risultato:
5
10.4 File – Funzione StartsWith()

La funzione Built-in StartsWith() serve per ricercare un elemento testuale all’interno del file.

Nell’esempio sottostante viene effettuata una ricerca di parole che cominciano con “prodotto”. È
presente una variabile contatore inizializzata a 0 e il ciclo FOR scorre gli elementi presenti nel file.

import os
cwd = os.getcwd()
files = os.listdir(cwd)

#print(cwd, files)

fileopen = open(r"C:\Users\Administrator\PycharmProjects\test10\fileProva.txt")
#print(fileopen)

contatore = 0

for linea in fileopen:

if linea.startswith("prodotto"):
print(linea)

Risultato:
10.5 Rimozione spazi bianchi

Partendo dal concetto che ogni stringa contiene in fondo “\n”, la funzione RSTRIP() ha la finalità di
eliminare gli spazi bianchi al termine di ogni linea.

import os
cwd = os.getcwd()
files = os.listdir(cwd)

#print(cwd, files)

fileopen = open(r"C:\Users\Administrator\PycharmProjects\test10\fileProva.txt")
#print(fileopen)

for linea in fileopen:

linea = linea.rstrip()
if linea.startswith("prodotto"):
print(linea)

Risultato:
prodotto 1
prodotto 2
10.6 Ricerca di una stringa

Il metodo FIND() permette di trovare le linee dove una stringa è contenuta. Se la stringa non viene
trovata restituisce -1.

Nell’esempio sottostante non viene trovata la stringa a e quindi stampa il valore contenuto in else.

import os
cwd = os.getcwd()
files = os.listdir(cwd)
#print(cwd, files)

fileopen = open(r"C:\Users\Administrator\PycharmProjects\test10\fileProva.txt")
#print(fileopen)

for linea in fileopen:

linea = linea.rstrip()
if linea.find("prodotto 3") == -1:
continue
else:
print(linea)
print("uscita....")

Risultato:
uscita...
10.6 Scrittura di un file

Nel caso della scrittura, si utilizza un parametro aggiuntivo “w”. L’esempio apre il file
“prova4.txt” se presente, altrimenti lo crea. Con la funzione WRITE() viene effettuata la scrittura e
poi successivamente con CLOSE() verrà processata la chiusura.

fileopen = open("prova4.txt", "w")

print(fileopen)
stringa1 = "prova prova provaaaaana"

fileopen.write(stringa1)

fileopen.close()

Risultato:

Min 2:12

Nel secondo esempio vengono utilizzate due stringhe:

fileopen = open("prova5.txt", "w")

#print(fileopen)
stringa1 = "prova prova provaaaaana\n"
stringa2 = "prova prova provaaaaana"

fileopen.write(stringa1)
fileopen.write(stringa2)

fileopen.close()

Risultato:
10.7 Metodo read() – readline()

L’attributo “r” si riferisce all’apertura del file in sola lettura. Con READ() l’obbiettivo è leggere i
primi 11 caratteri contenuti nel file.

f = open("prova5.txt", "r")
print(f.read(11))

Risultato:
prova prova
Il metodo readline() legge invece la prima linea del file. Lanciando nuovamente il file viene
stampata la riga successiva.

f = open("prova5.txt", "r")
print(f.readline())
print(f.readline())

Risultato:

10.8 Metodo append() – write()

Il ciclo FOR serve per scorrere le righe contenute nel file “prova5.txt” e stampare ogni riga.

f = open("prova5.txt", "r")
for x in f:
print(x)

Risultato:
L’attributo APPEND serve per attaccare la stringa in fondo al file.

f = open("prova5.txt", "a")
f.write("prova prova provaaaaana6")

Risultato:

L’esempio sottostante effettua la sovrascrittura di tutto il contenuto del file.

f = open("prova5.txt", "w")
f.write("sovrascrivo tutto!!")

Risultato:
10.8 Eliminare di un file

L’attributo “x” crea il file e se il file è già presente riporta un errore. Nel caso in cui non esista, non
restituisce errori.

f = open("file7.txt", "x")

Risultato:
0:37

Il metodo REMOVE() che elimina un file, può essere utilizzato importando il modulo OS. Nel caso
in cui sia stato già rimosso il file, viene restituito un messaggio di errore.

import os
os.remove("file7.txt")

Risultato:
L’esercizio sottostante utilizza anche EXISTS() per verificare se il file esiste. Nel caso in cui il file
esista, non viene restituito alcun errore.

import os
if os.path.exists("file8.txt"):
os.remove("file8.txt")
else:
print("Il file NON esiste!")

Risultato:

11. Python e la Rete

11.1 Socket – Gethostname()

Il SOCKET è un elemento fondamentale nella programmazione di rete ed è quindi
l’INTERFACCIA/PORTA che permette la RICEZIONE e l’INVIO di messaggi da parte di due
PROCESSI APPLICATIVI che possono essere un server e un client.

L’esempio sfrutta le SOCKET per far comunicare due processi applicativi all’interno della stessa
macchina.

Il modulo socket deve essere importato:

import socket

Il protocollo di TRASPORTO è di tipo TCP.

L’obbiettivo è ottenere l’hostname del proprio PC, ovvero il nome. Per fare un secondo controllo
possiamo andare in Pannello di controllo > Sistema.

import socket
print(socket.gethostname())

Risultato:

11.2 Ottenere IP Address

Un passo successivo è convertire l’hostname in indirizzo IP. GETHOSTBYNAME() accetta come

argomento l’host che abbiamo ottenuto dalla funzione utilizzata prima.

import socket
host = "EC2AMAZ-SFJIEAU"
print('{} : {}'.format(host, socket.gethostbyname(host)))
Risultato:

11.3 Da IP a Hostname

In un nuovo esempio, l’obbiettivo è ottenere l’hostname partendo dall’indirizzo IP trovato in

precedenza utilizzando SOCKET.GETHOSTBYADDR().

import socket
hostname, aliases, addresses = socket.gethostbyaddr("10.0.0.34")
print('Nome host:', hostname)

Risultato:

11.4 Protocollo e numero di porta

Specificato un protocollo è possibile visualizzare il numero di porta.
L’esempio presenta una variabile “url” che contiene la stringa comprensiva di protocollo. La
funzione URLPARSE() calcola il parse dell’URL. La variabile porta contiene
SOCKET.GETSERVBYNAME() a cui viene passato il parsing trovato in precedenza. In uscita verrà
restituita la porta associata.

import socket
from urllib.parse import urlparse
url = "ftp://www.google.it"
parsed_url = urlparse(url)
port = socket.getservbyname(parsed_url.scheme)
print(parsed_url.scheme, port)

Risultato:
ftp 21

11.5 Da URL a porta associata

Specificata una certa URL, è possibile ottenere i protocolli su porte standard associati a tali URL:

import socket
from urllib.parse import urlparse
for porte in [80, 443, 22,21]:
MiaUrl = '{}://google.it/'.format(socket.getservbyport(porte))
print(MiaUrl)

Risultato:
11.6 Contenuto di una pagina WEB

Il modulo SOCKET può essere utilizzato anche per lavorare con le pagine web, ma nel caso
specifico è più corretto fare uso della libreria “urllib”. Questa permette di usare le pagine web
come file.

Data una URL, l’obbiettivo è aprirla e mostrarne il contenuto.

import urllib.request
fhand = urllib.request.urlopen('https://www.sterntaler.lt/robots.txt')
for line in fhand:
print(line.decode().strip())

Risultato:
11.7 Creazione CLIENT/SERVER

Il modulo SERVER, come evidenziato dall’utilizzo del metodo WHILE TRUE, resterà sempre in
attesa di una connessione.

L’architettura client/server è basata su un localhost, per cui entrambi sono ulla macchina locale
contemporaneamente con indirizzo 127.0.0.1.

Il client si connette al server che è in esecuzione sulla stessa porta 16000. Viene effettuato quindi il
binding sulla porta 16000. Il server attende che arrivi una connessione. Quando la connessione sarà
attiva, verrà stampato l’indirizzo del client. I dati vengono ricevuti in segmenti e non in un’unica
soluzione. Nel caso di messaggi lunghi, questi vengono divisi e poi ritrasmessi. Una volta terminati i
dati, la connessione verrà chiusa con SOCKET.CLOSE().

Modulo server:

import socket
import sys

# Si parte con la creazione del SOCKET. AF_INET per indirizzi IPv4 e SOCK_STREAM per
protocollo TCP.
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# è necessario collegare il SERVER ad una porta.

# in questo caso sulla porta 15000 locale.
indirizzo_server = ('localhost', 16000)
print("Il server è in ESECUZIONE")
sock.bind(indirizzo_server)

# Il server attende che arrivi una connessione

sock.listen(1)

while True:
# Sempre in attesa di una connessione (ciclo WHILE)
print("Sono in attesa di una connessione...")
connection, client_address = sock.accept()
try:
print('connessione da', client_address)

# Riceve i dati in piccoli segmenti e li ritrasmette

while True:
dati_ricevuti = connection.recv(16)
print('ricevuti {!r}'.format(dati_ricevuti))
if dati_ricevuti:
print('reinvio dei dati al client')
connection.sendall(dati_ricevuti)
else:
print("DATI TERMINATI")
break

finally:
# Chiusura della CONNESSIONE
connection.close()

Modulo client:

import socket
import sys

# Crea un socket TCP/IP

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connette il socket alla porta alla quale il server Ë in ascolto
indirizzo_server = ('localhost', 16000)
print('connessione a {} porta {}'.format(*indirizzo_server))
sock.connect(indirizzo_server)

try:

# Invio dati
messaggio = b'ciao mondo...ciao mondo...ciao mondo'
print(format(messaggio))
sock.sendall(messaggio)

# calcolo lunghezza del messaggio

ricezione_messaggio_parziale = 0
ricezione_messaggio_completo = len(messaggio)

while ricezione_messaggio_parziale < ricezione_messaggio_completo:

dati_ricevuti = sock.recv(400)
ricezione_messaggio_parziale = len(dati_ricevuti) + ricezione_messaggio_parziale
print('ricevuti {!r}'.format(dati_ricevuti))

finally:
print('chiusura socket')
sock.close()

Risultato del client:

Risultato del server:
 12. Python e Database

12.1 Installazione SQLite Browser

Il database è una struttura dati complessa i cui elementi sono:

righe
colonne
tabelle

SQLite Browser è un programma con interfaccia grafica utile per effettuare le operazioni sulle
tabelle. È disponibile all’indirizzo https://sqlitebrowser.org/.
Sul sito web dal menu “Download”, è possibile scaricare la versione del programma per il sistema
operativo in uso sul computer.

Una volta partito il download, è sufficiente accettare i termini di utilizzo e proseguire avanti.
Cliccare poi su “Install”. Una volta terminata l’installazione, è possibile aprire il programma.
12.2 Creazione della prima tabella

In questa fase viene importato il modulo “sqlite3”. SQLITE3.CONNECT() è il nome del database.

import sqlite3
conn = sqlite3.connect('biblioteca.sqlite')
cur = conn.cursor()
conn.close()

Risultato:

La verifica può essere effettuata controllando direttamente se il database è stato creato nelle cartelle.
Il nome del database è “biblioteca.sqlite”.
È possibile adesso procedere alla creazione di una tabella che conterrà titolo e autore del libro.
La variabile “cur” è una sorta di database handle che andrà ad eseguire le query indicate con
CREATE (secondo il linguaggio SQL) all’interno di EXECUTE(). Infine verrà chiusa la
connessione con conn.close(). Il database cambierà dimensione una volta creata la tabella.

import sqlite3
conn = sqlite3.connect('biblioteca.sqlite')
cur = conn.cursor()
cur.execute('CREATE TABLE Libro (Titolo TEXT, Autore TEXT)')
conn.close()

Risultato:
SQL Lite Browser viene utilizzato per verificare se il database è stato creato correttamente.

12.3 Inserimento dati nella tabella

Una volta definita la tabella e i campi, è possibile inserire le informazioni. cur.execute() definirà le
query di inserimento dei dati, utilizzando INSERT.

import sqlite3
conn = sqlite3.connect('biblioteca.sqlite')
cur = conn.cursor()
cur.execute('INSERT INTO Libro (Titolo, Autore) VALUES (?, ?)', ('LibroA', 'AutoreA'))
cur.execute('INSERT INTO Libro (Titolo, Autore) VALUES (?, ?)', ('LibroB', 'AutoreB'))
cur.execute('INSERT INTO Libro (Titolo, Autore) VALUES (?, ?)', ('LibroC', 'AutoreC'))
cur.execute('INSERT INTO Libro (Titolo, Autore) VALUES (?, ?)', ('LibroD', 'AutoreD'))
conn.commit()
cur.close()
Risultato:

Tornando su SQL Lite Browser, il database ha aggiornato il contenuto con i dati aggiunti all’interno.
12.4 Operazione di SELECT

Le operazioni principali esaminate in questa fase sono quelle di:

Selezione (SELECT)
Aggiornamento (UPDATE)
Cancellazione (DELETE)

Partendo dalla SELECT, l’operazione seleziona dei dati della tabella. Il ciclo FOR serve per
scorrere le righe e visualizzarle con COMMIT().

import sqlite3
conn = sqlite3.connect('biblioteca.sqlite')
cur = conn.cursor()
cur.execute('SELECT Autore, Titolo FROM Libro ')
for row in cur:
print(row)
conn.commit()
cur.close()

Risultato:

12.5 Operazione di UPDATE

L’operazione di UPDATE utilizza set per impostare “Autore”. Il valore “AutoreF” viene aggiornato.
import sqlite3
conn = sqlite3.connect('biblioteca.sqlite')
cur = conn.cursor()
cur.execute("update Libro set Autore = (?) where Titolo = (?) ", ("AutoreF", "LibroD"))
conn.commit()
cur.close()

Risultato:

Verificando SQL Lite Browser, è possibile vedere come il campo sia stato automaticamente
aggiornato una volta effettuata l’operazione su PyCharm.
12.6 Operazione di DELETE

L’operazione DELETE serve per la cancellazione del libro con stringa “AutoreA”.

import sqlite3
conn = sqlite3.connect('biblioteca.sqlite')
stringa="AutoreA"
cur = conn.cursor()
cur.execute("delete from Libro where Autore=(?)", (stringa,))
conn.commit()
cur.close()

Risultato:
Aprendo SQL Lite Browser è visualizzabile il contenuto aggiornato.