Sommario

Installazione ...................................................................................................................................... 3
Linguaggio Python..................................................................................................................... 3
Primo programma.................................................................................................................... 5
Installazione dell'IDE PyCharm ......................................................................................................... 6
Fondamenti .............................................................................................................................. 11
Commenti............................................................................................................................ 11
Variabili
Comandi di Ingresso e Uscita................................................................................................. 12
Operatori.............................................................................................................................. 13
Lista degli esercizi A ................................................................................................................ 15
Strutture condizionali ........................................................................................................... 18
Lista di esercizi B ................................................................................................................ 20
Strutture di ripetizione........................................................................................................... 22
Lista di Esercizi C ................................................................................................................ 23
Arrays.......................................................................................................................................... 26
Funzioni principali dell'array ..................................................................................................... 27
Alcuni esempi pratici........................................................................................................ 30
Array multidimensionali........................................................................................................ 31
Lista di esercizi D ................................................................................................................ 34
Funzioni ....................................................................................................................................... 36
Caratteristiche......................................................................................................................... 38
Esempio 01.............................................................................................................................. 39
Esempio 02.............................................................................................................................. 39
Esempio 03.............................................................................................................................. 40
Esempio 04.............................................................................................................................. 41
Esempio 05.............................................................................................................................. 41
Lista di esercizi E................................................................................................................. 42
Struttura dei Dati...................................................................................................................... 44
Dizionario dei dati................................................................................................................. 45
Esempio: Relazionare i meta-dati con i dati.................................................................... 49
Lista di esercizi F................................................................................................................. 50
Python e SQLite
Manipolando il database.............................................................................................. 53

1
 Comando INSERT..................................................................................................................... 53
Comando AGGIORNA................................................................................................................... 57
Comando DELETE .................................................................................................................... 58
Comando SELECT..................................................................................................................... 59
Comando WHERE.................................................................................................................... 60
Lavorare con più di un tavolo .................................................................................... 61
Lista di esercizi G.................................................................................................................. 63
Gestione delle Eccezioni............................................................................................................... 64
Gerarchia delle eccezioni........................................................................................................... 65
Azione di pulizia ...................................................................................................................... 67
Comando raise ........................................................................................................................ 67
Lista di esercizi H.................................................................................................................. 68
Archivi ...................................................................................................................................... 70
Python e Arduino
Riferimento Bibliografico .............................................................................................................. 72

2
Instalação

In questo capitolo impareremo come installare il linguaggio Python e il suo IDE in

Sistema Operativo Windows.

Linguaggio Python

Il linguaggio di programmazione Python può essere acquisito accedendo al suo

applicazione tramite l'[Link].

Seleziona il menu Download e scarica la versione Python 3.7.2. Esegui il file

scaricato e inizia la sua installazione.
Nella prima schermata seleziona l'opzione Aggiungi Python 3.7 a PATH e scegli l'opzione

Installazione personalizzata.

A seguire rimani selezionato tutte le opzioni e clicca su Avanti.

3
 Ogni opzione selezionata ha il seguente significato:
installa la documentazione del linguaggio;
pip: installa o pip che è usato per scaricare librerie sviluppate in Python;
tcl/tk e IDLE: installa la biblioteca Python per la creazione di interfacce grafiche;

Suite di test Python: installa la libreria Python responsabile per la gestione di

test del software;
py launcher: installa il launcher per applicazioni con estensione py.

Di seguito lascia contrassegnate le opzioni raccomandate. In Installazione personalizzata

locationcrie il seguente percorso di installazione:c:\sviluppo\python3. Clicca su

pulsanteInstalla segui il termine della tua installazione.

4
Primo programma

Ora testeremo se l'installazione

occorso come pianificato, creeremo
la nostra prima applicazione. Apri il Prompt
de Comando di Windows e digita il
seguente comando:

python –V

In questo comando verrà mostrata la versione

installata sul tuo computer. Per accedere al

ambiente di sviluppo digita il
comando:

python

Utilizza il comando print per stampare qualcosa sullo schermo. Prova la seguente riga di comando:

print("Ciao mondo")

Il comando presentato riguarda una funzione. Per definizione, ogni funzione deve possedere
parentesi. Nel caso presentato la funzione print ha ricevuto un contenuto di tipo testo. A
seguire con i seguenti comandi:

stampa("IF Goiano", "Trindade", 2019, sep=" ")

Stampa("IF Goiano", "Trindade", 2019, sep=".")

La funzione print consente di stampare diversi valori. Nota che ogni valore
deve essere separato da virgola. È consentito presentare valori di altri tipi che non
Il termine finale: sep=" ", definisce quale carattere sarà utilizzato come
separatore dei valori presentati.

Di seguito è presentata l'uscita prevista per i comandi digitati.

5
 Ora digita i seguenti comandi:

instituicao = “IF Goiano”

type(instituicao)
ano = 2019
tipo(ano)
print(instituzione, "Trinità", anno, sep=" ")

Repare que o comandotype(instituicao)etype(ano)imprime respectivamente

le uscite<class ‘str’> e<class ‘int’>. Questa uscita si riferisce ai tipi delle
variabiliistituzionedelanno.

Installando l'IDE PyCharm

Sviluppare programmi utilizzando il Prompt dei comandi può essere un compito

estremamente difficile a seconda della complessità dell'applicazione. A causa di questo

problema gli sviluppatori utilizzano applicazioni proprie per lo sviluppo di

software. Queste applicazioni sono conosciute con l'acronimo IDE, Integrated Development
Ambiente di Sviluppo Integrato.
In questo corso lavoreremo con l'IDE PyCharm, sviluppato dall'azienda Jet
Cervelli. Per scaricare questo strumento accedi all'indirizzo:

[Link]/pycharm/download

e scarica la versione Windows Community.

6
 Esegui il file, nella schermata che definisce la Cartella di Destinazione installa l'applicazione

no seguente indirizzo:

c:\sviluppo\PyCharm Community Edition 2018.3.2

Di seguito, nella Sezione Opzioni di Installazione, seleziona le seguenti opzioni:

lancier 64-bit;
Aggiungi la directory del lanciatore al PATH;

.py
e fai clic sul pulsante Avanti.

7
 Dopo aver completato l'installazione, apri il programma. Scegli l'opzione Crea
Nuovo progetto.

Sarà disponibile una schermata per definire il percorso del progetto e quale macchina virtuale
da utilizzare per il progetto.

8
EmLocationcree il seguente percorso:

c:\sviluppo\workspace\python\corso\primo

Nell'opzione Interprete del Progetto lascia selezionata la macchina virtuale consigliata. Clicca su

bottoneCrea.

Con il progetto creato, fai clic con il pulsante destro del mouse sul nome del progetto e scegli l'opzione

Nuovo File Python. Nomina il file come [Link].

9
Digitare il seguente codice:

Per eseguire clicca sul menu Esegui Premi i tasti Alt + Maiusc + F10. Il
il risultato sarà visualizzato nell'angolo in basso dello schermo dell'applicazione.

10
Fondamenti

Sviluppata da Guido van Rossum, la lingua Python è emersa nel 1991. Questa
la lingua ha le seguenti caratteristiche:
Interpretata: non utilizza le risorse direttamente dalla macchina;
Alto livello: basato su altre lingue;
Script: supporta la creazione di descrizioni;

Paradigma orientato agli oggetti: utilizza i concetti di classe e oggetti;

Tipizzazione dinamica: le variabili non hanno tipi definiti.
La struttura del linguaggio di programmazione determina che tutto il codice sia
Devidamente indentato. Le strutture e i blocchi non sono delimitati da un inizio e una fine.

Commenti

Un commento consente allo sviluppatore di scrivere qualcosa nel programma che non
sarà interpretato dal linguaggio. Questo commento può essere di una sola riga,
exemplo:

Questo è solo un commento

O di più linee:

´´´
Andai al mercato e digitai

i dati dei prodotti

che ho acquisito

´´´

O comentário de múltiplas linhas deve estar envolvido por três aspas simples no início
e chiusura.

Variabili

In Python una variabile deve avere solo un nome e un valore. Il tipo del
una variabile è definita attraverso il valore ricevuto, ovvero il linguaggio offre la creazione di
variabili non tipizzate, che non hanno un tipo predefinito.

11
 Essendo così una variabile essere un numero o un testo. Se è un numero,
questa potrebbe contenere valori:

intero memorizza valori interi;

flottante memorizza valori reali;
complesso memorizza valori che hanno una parte reale e una parte immaginaria.
Normalmente questi tipi sono impiegati in aree come l'Ingegneria Elettrica
e Statistica.

Un numero può essere generato anche tramite le funzioni: int(); float();

e complesso(). Esempio:

Le variabili che contengono valori di tipo testo devono essere racchiuse tra virgolette singole

o coppie. Esempio:

Per nominare una variabile, è permesso utilizzare qualsiasi carattere che non sia
simbolo chiave del linguaggio. Una variabile può avere qualsiasi nome, ad eccezione
le parole riservate del linguaggio.

Comandi di Ingresso e Uscita

12
 Lo sviluppatore potrà stampare un'uscita tramite il comando print. Questo
il comando può essere utilizzato nel seguente modo:

Stampando solo il testo desiderato. Esempio:

Sto stampando questo testo!

Stampando una sequenza di dati (variabili e testi). Esempio:

print("Ciao", nome)

Stampando una sequenza di dati che sono delimitati da un carattere o

Testo. Esempio:

print("Oggi", "avremo", sep = "$")

In Python è necessario utilizzare il comando input per acquisire l'input dell'utente.

Questo comando restituirà sempre un testo. Esempio:

nome = input(“Digite seu nome”)

Operatori

Il linguaggio offre quattro categorie di operatori: assegnazione; aritmetici;

relazionali e logici.

Operatore di assegnazione

Questo operatore ha l'obiettivo di definire il contenuto e il tipo di una variabile. Esso

è rappresentato dal simbolo uguale (=).

Operatori Aritmetici

Corrispondono agli operatori utilizzati nell'esecuzione di calcoli

matematici. Sono loro:

13
 Descrizione Símbolo
Addizione +
Sottrazione -
Divisione /
Moltiplicazione *
Resto %

Operatori Relazionali

Corrispondono agli operatori utilizzati nella creazione di frasi relazionali.

Questi operatori sono abbastanza utilizzati nelle strutture condizionali e di ripetizione.
Sono loro:

Descrizione Simbolo
Maior >
Minore <
Maggiore o uguale >=
Minore o uguale <=
Uguaglianza ==
Diverso !=

Operatori Logici

Partecipano alla costruzione di una sentenza logica. Sono utilizzati anche nei
strutture condizionali e di ripetizione. Essi sono:

Descrizione Símbolo
È logico e
OU logico oppure
NON logico non

Ogni operatore ha la seguente tabella di verità:

e
P Q Pe Q
Vero Vero Vero

14
 Vero Falso Falso
Falso Vero Falso
Falso Falso Falso

o
P Q Pe Q
Vero Vero Vero
Vero Falso Vero
Falso Vero Vero
Falso Falso Falso

non
P non P
Vero Falso
Falso Vero

Lista di esercizi A

1) Sviluppa un programma in Python in cui l'utente deve inserire il cateto adiacente e

cateto opposto relativo a un triangolo rettangolo. Il programma dovrà calcolare l'ipotenusa di questo
triangolo e le sue rispettive ragioni trigonometriche (seno, coseno e tangente). Stampa i
valori del seno, coseno e tangente.

Calcolo dell'ipotenusa:

h² = ca² + co²

Calcolo del seno, coseno e tangente

co ca co
petto cosseno tangente
h h ca
, dove:

h = hipotenusa;
ca = cateto adiacente;
co = cateto opposto.

15
2) Sviluppa un programma in Python che generi un numero casuale di quattro cifre (M
– Milhar, C – Centina, D – Dezena, U - Unità) variando tra 1000 e 9999. Il programma deve
calcolare e stampare la seguente espressione matematica:

U randi(M*10)
x
C 2 D

3) Sviluppa un programma in Python nel quale l'utente digiterà il raggio di un cerchio, la base e
l'altezza di un triangolo. Il programma deve calcolare l'area del cerchio e del triangolo e stampare
la differenza dell'area del triangolo rispetto all'area del cerchio.

4) L'IF Goiano - Campus Trindade desidera verificare quale sia stato il punteggio ottenuto da un
candidato determinato iscritto nel processo elettorale per coordinatore di corso. Il team di
gli sviluppatori hanno deciso di aiutare in questo compito creando un programma Python. In questo
l'algoritmo è necessario affinché l'utente inserisca: il numero di voti validi del segmento
docente al candidato; il totale dei voti validi dei docenti; il numero di voti validi del
segmento discente al candidato; e il numero di voti validi degli studenti. Il programma dovrà
eseguire il seguente calcolo:

2VDo1VDi
Vt  , essendo:
3Do3Di

Vt: Voti validi ottenuti dal candidato;

Voti validi del segmento docente al candidato;
Voti validi dei docenti;
VDi: Voti validi del segmento studentesco al candidato;
Voti validi degli studenti.

Al termine del calcolo, il valore dovrà essere visualizzato sullo schermo.

16
5) Sviluppa un programma in Python nel quale l'utente digiterà un angolo. Il programma
dovrà calcolare e stampare il seno, il coseno e la tangente di questo angolo.

6) Sviluppa un programma in Python che genera un numero casuale variando da 0 a 100.

Stampare il valore generato.

7) Sviluppa un programma in Python che generi 3 numeri casuali che variano

rispettivamente tra: 0 e 50; 10 e 40; 100 e 999. Stampa i valori generati.

8) Sviluppa un programma in Python in cui l'utente inserirà un valore iniziale e un valore

finale. Il programma dovrà generare un numero casuale all'interno dell'intervallo scelto dall'utente.
Stampa il numero generato.

9) Sviluppa un programma in Python nel quale l'utente dovrà inserire due numeri (n1 e n2).
il programma dovrà calcolare e stampare la seguente formula:

risultato  n1 n2  3

Suggerimenti:
Calcolare la potenza di un numero. Esempio:

2 ** 5 = 32

Calcolare la radice quadrata di un numero. Esempio:

4 ** (1/2) = 2

Generare numeri casuali. Esempio:

importa casuale
[Link](1, 9)

Genera PI

importa matematica

[Link]

Ottenere seno, coseno e tangente

importa matematica

17
x = [Link](85) #converte l'angolo da gradi a radianti
[Link](x) #seno
[Link](x) #cosseno
z = [Link](x) #tangente
y = [Link](z) #converte l'angolo da radiante a grado.

Strutture condizionali

Una struttura condizionale mira a verificare una frase relazionale e a partire da questa
La verifica avviene nella presa di decisione. Quest'azione si verifica quando la sentenza relazionale

per vera (True). È anche possibile eseguire azioni sul risultato della sentenza
relazionale sia falso (False).

Il linguaggio offre tre tipi di strutture condizionali: IF, ELIF e ELSE.

La struttura IF

Possiede la seguente sintassi:

se condizione:
comandi

onde:
se corrisponde al nome della struttura di condizione;
condizione sentenza relazionale da testare;
comandi tutti i comandi da eseguire da
struttura.

La struttura ELIF

Utilizzato esiste la necessità di testare varie frasi relazionali. Per ogni

Il test condizionale utilizza un ELIF. Questa struttura corrisponde all'if a cascata.
Osserva la tua sintassi:
se condicaoA:
comandoA
elif condizioneB:

18
 comandoB
elif condizioneC:
comandoC

dove:
se corrisponde al nome della struttura di condizione;
elif utilizzato per testare un'altra condizione oltre alla
principale
condicaoA; condicaoB; condicaoC frasi relative a
saranno testati;
comandoA; comandoB; comandoC tutti i comandi da eseguire
executados nos diferentes blocos.

La struttura ELSE

Utilizzando quando qualche sequenza di comandi sarà eseguita, anche

tutte le condizioni essendo false. Questa struttura deve essere accompagnata da una
struttura IF. Ecco la sua sintassi:

se condizione:
comandoA
altro:
comandoB

onde:
se corrisponde al nome della struttura di condizione;
altro utilizzato per eseguire un comando quando la condizione
contenuta nel if falso;
condizione sentenza relazionale da testare;
comandoA; comandoB tutti i comandi da eseguire
i nostri diversi blocchi.

A seconda del problema proposto, è possibile integrare tutte le strutture condizionali

in un'unica struttura, essendo che l'ELSE sarà sempre l'ultima struttura allocata.

19
Lista di esercizi B

1) Sviluppa un programma in Python in cui l'utente digiterà una lettera (da A a E) relativa
a un concetto di voto. Il programma dovrà convertire la lettera digitata in un voto secondo
con la tabella sottostante:

CONCEITO NOTA
A 95
B 85
C 75
D 65
E 30

Qualsiasi lettera digitata diversa da quella proposta nella tabella sopra, verrà stampata la seguente
mensagem “Conceito inválido”. Imprima a nota convertida.

2) Sviluppa un programma in Python in cui l'utente digiterà un valore relativo a x.

il programma dovrà calcolare e stampare il valore di def(x).

1 se x 1
2se1 x 2
f(x)
x²se2 x 3
x³se x 3

3) Sviluppa un programma in Python nel quale l'utente digiterà un valore numerico variando
tra 1 e 7. Il programma dovrà convertire questo numero in giorno della settimana secondo la
tabella seguente.

VALORE SAÍDA
1 DOMENICA
2 LUNEDÌ
3 MARTEDÌ
4 MERCOLEDÌ
5 GIOVEDÌ
6 VENERDÌ
7 SABATO

4) Sviluppa un programma in Python che legga un peso sulla Terra e il numero di un pianeta e
stampa il valore del tuo peso su questo pianeta. La relazione dei pianeti è data qui sotto insieme
con il valore delle gravità relative alla Terra:

20
 # GRAVITÀ RELATIVA Pianeta
1 0,37 MERCURIO
2 0,88 VENERE
3 0,38 MARTE
4 2,64 JÚPITER
5 1,15 SATURNO
6 1,17 URANO

Per il calcolo del peso considera la seguente formula:

p m g, essendo che:

p: peso;
m: massa;
g: gravità.

Calcola e stampa il peso sulla Terra e sul pianeta scelto.

5) La scuola "APRENDER" paga i propri insegnanti per ora/lezione. Fai un programma

in Python che calcola e visualizza lo stipendio di un insegnante. Si sa che il valore dell'ora/lezione segue
la tabella qui sotto:

Professore Livello 1 R$12,00 all'ora/lezione

Professore Livello 2 R$17,00 all'ora/lezione
Professore Livello 3 R$25,00 all'ora/lezione

6) Un'azienda concederà un aumento di stipendio ai suoi dipendenti, variabile in base

con il ruolo, come da tabella qui sotto. Fai un programma in Python che legga lo stipendio e il
carico di un dipendente e calcola il nuovo stipendio. Se il carico del dipendente non è nella tabella,
ele deverá, então, receber 40% de aumento. Mostre o salário antigo, o novo salário e a diferença
salariale.

CÓDIGO MERCE PERCENTUALE

101 Manager 10%
102 Ingegnere 20%
103 Tecnico 30%

7) Costruisci um programma em Python per determinare a situazione

(APPROVATO/ESAME/RESPINTO) di uno studente, data la sua frequenza (FREQ) (percentuale
da 0 a 100%) e il suo voto (NOTA) (voto da 0.0 a 10.0), essendo che:

21
 Condizione Situazione
Frequenza fino al 75% REPROVATO
Frequenza tra il 75% e il 100% e Voto fino a 3.0 REPROVATO
Frequenza tra il 75% e il 100% e Voto da 3.0 a 7.0 ESAME
Frequenza tra il 75% e il 100% e Voto tra il 7.0 e il 10.0 APPROVATO

Strutture di ripetizione

Le strutture di ripetizione sono utilizzate quando c'è la necessità di eseguire il

stesso blocco di comandi un numero finito di volte. In Python possiamo utilizzare due
istruzioni di ripetizione: WHILE; e FOR.

La struttura WHILE

O WHILE esegue un blocco di comandi N volte fino a quando la sua condizione non è soddisfatta.

Questa struttura ha la seguente sintassi:

mentre condicao:
comandi

onde:
mentre parola chiave che definisce la struttura;
condicao sentenza relazionale che definisce la quantità di
volte in cui i comandi saranno ripetuti;
comandos insieme di istruzioni da eseguire.

Esempio:

lifeRock = 5000;
iron = 0;
batida = 200;
mentre lifeRock >= 0:
ferro += 5
lifeRock -= batida
Stampa('Hai preso {0} ferro'.format(ferro))

La struttura FOR

Utilizzato per tracciare una raccolta di dati. Sintassi:

22
per variabile in lista:
comandi

dove:
per parola chiave della struttura;
variabile variabile che riceverà ogni elemento della lista;
lista lista di elementi;
comandi insieme di istruzioni.

Esempio:

compras = ['Cupim', 'Picanha', 'Carvão', 'Coração de galinha',

Pane all'aglio
Stampa('Lista dei prodotti per il barbecue')
per n in compras:
stampa(n)

Lista di Esercizi C

01) Sviluppa un programma in Python nel quale l'utente digiterà due valori interi (AeB).
Il programma dovrà generare 100 numeri casuali. Ogni valore generato dovrà essere compreso tra
intervallo digitato dall'utente (AeB). Stampa il valore maggiore generato dal programma.

02) Sviluppa un programma in Python nel quale l'utente digiterà il nome e i voti di 35
alunni. Ogni alunno ha cinque voti. Il programma dovrà stampare la media aritmetica di ciascuno
aluno è il nome dello studente che ha la media più alta.

03) Sviluppa un programma in Python nel quale l'utente inserirâ i seguenti dati di un
produto: o nome de um alimento; sua categoria (P – Proteína; C – Carboidrato; G – Gordura); e
il suo valore calorico. L'utente digiterà quanti alimenti desidera. La digitazione si concluderà quando il

Il valore calorico digitato è uguale a zero. Stampa il valore calorico totale di ciascuna categoria.

04) Sviluppa un programma in Python nel quale l'utente digiterà i seguenti dati di un
produto: o nome de um alimento; sua categoria (P – Proteína; C – Carboidrato; G – Gordura); e
il suo valore calorico. L'utente digiterà quanti alimenti vorrà. La digitazione terminerà quando il
valore calorico digitato è uguale a zero. Stampa:

23
 Quale categoria ha il valore calorico più alto;
Qual è il nome del cibo con il maggior valore calorico.

05) Sviluppa un programma in Python che calcoli la velocità media di 100 veicoli. Il
il programma dovrà calcolare e stampare la percentuale di veicoli la cui velocità media
ultrapassò gli 80 km/h. Ecco la formula della velocità media:

d
Vm , essendo che:
t

Vm velocidade média;
d distanza
t tempo.
06) Sviluppa un programma in Python che simuli il lancio di un dado a sei facce 2500
vezes. O programa deverá calcular e imprimir a porcentagens de números: uns; dois; três;
quattro; cinque e sei che sono stati ottenuti durante le 2500 giocate.

07) Sviluppa un programma in Python in cui l'utente digiterà la quantità di

Chilowattora (kWh) consumato in una casa per 12 mesi. Il programma dovrà presentare la
bandiera di ogni mese. Essendo la bandiera definita da:

kWh Bandiera
Fino a 172 kWh Verde
Tra 173 e 280 kWh Amarela
Ma che 281 kWh Rossa

08) Un naufrago si trova bloccato su un'isola. Ha una quantità X di cibo e Y di

bevanda. Si sa che al giorno consuma il 5% del cibo totale e il 3% della bevanda totale. Sviluppa
un programma in Python in cui l'utente digiterà il numero di cibo (X) e bevande (Y) che il
Il naufrago possiede inizialmente. Il programma dovrà presentare in quanti giorni è trascorso per
consumare tutta la cibo e bevande.

24
09) Un lucchetto ha 10 serrature. Si desidera creare un
programma che verifica quante tentativi una persona spenderà
fino a quando si apre il lucchetto. Sviluppa un programma in Python

che genera casualmente la serratura corretta. L'utente dovrà

scegliere la serratura che desideri aprire fino ad avere successo.

Stampa quante volte l'utente ha provato ad aprire il lucchetto.

25
Array

Umarraycorresponde a una struttura di dati di tipo lista che ha come obiettivo

memorizzare una collezione di dati. L'array può memorizzare qualsiasi tipo di valore:
caratteri; interi; reali. Può anche memorizzare un'altra array.

Per definire una lista, dichiara una variabile e fai in modo che riceva parentesi quadre.
Esempio:

x = []

In questo momento la variabile x memorizza un array senza elementi. Nel caso sia necessario

inizializzare la lista con elementi, aggiungere i valori separati da virgola. Esempio:

x = [5, 6, 7, 2, 4]

Il vettore ora ha cinque elementi.

5 6 7 2 4
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

Ogni elemento ha un indice (index) all'interno dell'elenco, dove il primo indice è

o zero (0).

Per accedere a un elemento della lista, utilizza il nome della variabile e inserisci tra parentesi quadre l'indice

desiderato.

x[3]
Sarà ottenuto il valore 2

In questo caso verrà ottenuto il valore 2 che si trova all'indice 3.

Per sostituire un valore, fai in modo che la variabile all'indice desiderato riceva il nuovo
valore.

x[2] = 35

26
 5 6 35 2 4
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

Sarà assegnato all'indice 2 il valore 35.

Caso seja necessário descobrir quantos elementos existem na lista, utilize a função
len().

len(x)

Nel caso citato, verrà restituito il valore 5.

Principali funzioni dell'array

Oltre alle risorse presentate, l'array contiene un insieme di funzioni che

permette allo sviluppatore di manipolare i suoi elementi. In questo argomento saranno presentati i

principali funzioni di un array.

Segue il insieme di funzioni:

[Link](el) Aggiungi un elemento alla fine della lista. Esempio:

[Link](69)

5 6 35 2 4 69
↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5

[Link](i, x) Aggiungi un elemento nella posizione desiderata. I

gli elementi rimanenti dopo l'indice scelto vengono spostati a destra della lista.
Esempio:

[Link](2, 24)

27
 5 6 24 35 2 4 69
↑ ↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5 6

[Link](x) Rimuovi il primo elemento della lista il cui valore è citato

nella funzione. Esempio:

[Link](4)

5 6 24 35 2 69
↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5

[Link]([i]) Rimuovi l'elemento dalla lista in base alla posizione specificata

e restituisce il valore rimosso. Se non viene specificato l'indice, verrà rimosso
l'ultimo elemento della lista. Esempio:

[Link](1)
# Il valore 6 sarà restituito. Lo stesso sarà escluso dalla lista.

5 24 35 2 69
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link](x[, inizio[, fine]]) Restituisce l'indice del valore desiderato.

Esempio:

[Link](35)
# Il valore restituito sarà 2

[Link](x) Restituisce il numero di elementi uguali al valore di

entrata. Esempio:

[Link](69)
Il valore restituito sarà 1

28
 [Link]() Inverte i valori della lista. Esempio:

[Link]()

69 2 35 24 5
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link](chiave=None, reverse=False) Ordina gli elementi della lista

in ordine crescente. Se il parametro reverse riceve True, il metodo di
l'ordinamento avviene in modo decrescente. Esempio:

[Link]()

2 5 24 35 69
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link](reverse=True)

69 35 24 5 2
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link]() Rimuovi tutti gli elementi dalla lista. Esempio:

[Link]()

Se desideri conoscere e approfondire le funzionalità disponibili, visita il sito:

[Link]

29
Alcuni esempi pratici

Esempio 01) Crea un programma in Python che carica un elenco di 15 elementi

con valori casuali che variano tra 100 e 1000. Il programma dovrà calcolare e
mostrare

a) O maior elemento da lista;

b) Il minore elemento della lista.

importa casuale
x = []
i=0
mentre i <= 14:
[Link]([Link](100, 1000))
i += 1
[Link]()
stampa(x)
stampa(x[0])
stampa(x[14])

Esempio 02) In una corsa ci sono 10 corridori. Sviluppa un programma in Python

che leggesse i valori del numero del corridore e il suo rispettivo tempo nella corsa. Inoltre
disso, il programma dovrà stampare la classificazione e il tempo di corsa, dal primo al
decimo classificato, identificando il numero di iscrizione del corridore relativo a quella
collocazione.

corredor = []
i=0
mentre i <= 2:
inscricao = input('Digite a inscrição: ')
tempo = int(input('Digite se tempo na corrida: '))
dados = [inscricao, tempo]
[Link](dati)
i += 1
[Link](key = lambda corredor:corredor[1])
count = 1
per i in corredor:

30
 stampa(count, 'º luogo: ', i[0], ' -> Tempo: ', i[1], sep='')
count += 1

Esempio 03) Sviluppa un programma in Python nel quale l'utente digiterà un

palavra. Imprima a palavra original e invertida. Compare se a palavra inversa é igual ao
originale.

palavra = input('Digite uma palavra: ')

x = lista(parola)
[Link]()
palavraInvertida = ''.join(x)
print('Parola: ', parola)
print('Parola invertita: ', parolaInvertita)
se parola == parolaInvertita:
print('PAROLE UGUALI')
altrimenti:
print('PAROLE DISTINTE')

Array multidimensionali

Gli array multidimensionali, noti anche come matrici, corrispondono a un elenco che
riceve una collezione di dati. Questa collezione di dati è rappresentata da un altro array.
Esempio:

x = [[1, 4], [3, 6], [2, 4]]

Linea
0 1 4
1 3 6
2 2 4
↑ ↑
0 1
Colonna

Per accedere a un dato di questa struttura utilizzare due parentesi quadre aggiungendo l'indirizzo della

linea e colonna.

31
x[1][0]
'''
Il valore restituito sarà 3 che è presente nella riga 1 e colonna 0
'''

Il sviluppatore potrà anche creare un array multidimensionale con dati di

diversi tipi. Considera l'immagine seguente:

Considera che nell'immagine mostrata, la listatabeladeverà avere quattro colonne per

dado. Ogni colonna ha una definizione e un tipo di dato:
id riceverà un intero corrispondente al codice di un utente;
utente riceverà un testo corrispondente al nome dell'account di un utente;
password riceverà un testo corrispondente alla password dell'account dell'utente;

ativo riceverà un booleano corrispondente se l'account utente è attivo

si trova attiva.
Per il caso citato, si può creare un array multidimensionale nel seguente modo:

tabela = [
[69, 'denecley@[Link]', '******', True],
[124, 'pepy@[Link]', 'pepylegal', True],
[548, '[Link]@[Link]', '123321', False],
[96, 'primopato@[Link]', 'primim2018', True],
[56, '[Link]@[Link]', 'alunos2019', False]
]

32
 Linea
0 69 denecley@[Link] ****** Vero
1 124 pepy@[Link] pepylegal Vero
2 548 [Link]@[Link] 123321 Falso
3 96 primopato@[Link] primim2018 Vero
4 56 [Link]@[Link] alunni2019 Falso
↑ ↑ ↑ ↑
0 1 2 3
Colonna

E se volessimo elencare tutti i conti disattivati?

Per la domanda sopra possiamo risolvere il problema nel seguente modo:

per linea in tabella:

se non linea[3]:
stampa(linha)

tu

list(filter(lambda linea: not linea[3], tabella))

Il comandolistconverte una serie di dati in una lista, array. Il comandofilterritira

todos os dados de uma lista a partir de um critério de filtro. Para utilizar o filtro use a
sintassi:

lambda valore: condizione

onde:
lambda parola chiave utilizzata per creare una variabile di
filtro
valore nome della variabile di filtro. Questa variabile riceverà
ogni valore della lista;

condizione criterio di selezione.

33
Ora, come possiamo catturare tutti gli account dogmail?

lista(filtro(lambda linea: 'gmail' in linea[1], tabella))

Lista di esercizi D

1) Crea un programma in Python che legga un elenco di 40 posizioni. Contare e scrivere quanti
valori pari egli possiede.

2) Crea un programma in Python che legga due liste di 20 posizioni e calcoli un'altra lista
contenendo, nelle posizioni pari i valori del primo e nelle posizioni dispari i valori del
secondo.

3) Fai un programma in Python che determini quanti numeri maggiori di 100 ci sono in una
lista di interi con 20 elementi. Riempire la lista con numeri casuali varianti tra 1 e
200.

4) Crea un programma in Python che legga i punteggi di 10 prove di un concorso e i nomi

dei rispettivi partecipanti. Registra i dati in un elenco. Presenta un ranking dei
collocati che hanno ottenuto più di 70 punti.

5) Crea un programma in Python che legga quindici numeri dall'utente e li memorizzi in una lista.
radice quadrata di ogni numero. Se il valore inserito è inferiore a zero, il numero -1 deve essere
attribuito all'elemento della lista. Dopo di che, il programma deve stampare tutti i valori
archiviati.

6) Crea un programma in Python che riceva l'altezza di 10 atleti. Memorizza l'altezza di

tutti gli atleti in un elenco. Questo programma deve stampare l'altezza di quegli atleti che hanno
altezza superiore alla media.

7) Scrivere un programma in Python che contenga un elenco G(13) che è il modello di un test
di lotteria sportiva, contenente i valori: A, B o C per ogni posizione di G. Leggere, poi, il
numero della carta di un scommettitore e un'altra lista risposta R (13). Verificare il numero di successi
e scrivere il numero del scommettitore e il suo numero di risultati. Se ci sono 13 risultati, aggiungere la
mensagem: "GANHADOR, PARABENS".

8) Fai un programma in Python che:

a) Leggi una frase;

b) Conta quanti spazi bianchi ci sono nella frase;
c) Conta quante volte appare la lettera A;
d) Stampa quanto calcolato nei punti b e c.

Dica: Accedi al sito

[Link]

9) Fai un programma in Python che, date due liste A e B di 20 elementi, effettui le

rispettive operazioni indicate da un'altra lista C di 20 elementi, fornita anch'essa da
utente, contenente le quattro operazioni aritmetiche in qualunque combinazione. Memorizza in

34
una lista che mostra il valore dell'operazione eseguita. Ad esempio, supponiamo che A[1] = 10, B[1] = 3
e C[1] = '*', allora D[1] = 30.

10) Fai un programma in Python che legga un elenco di 3 elementi e un elenco

multidimensionale di 3 x 3 elementi. Successivamente, il programma deve eseguire la moltiplicazione della lista
semplice per le colonne della lista multidimensionale. Mostra la nuova lista.

11) Crea un programma in Python nel quale l'utente digiterà una matrice con dimensioni M × N.
Per la matrice digitata, stampa a schermo i numeri pari contenuti nella matrice, considerando
separarli per riga. Vedi l'esempio per una matrice 4×4:

Ingresso:

1 2 3 4

5 6 7 8

10 11 23 21

1 2 3 1

Uscita:

2 4 6 8 10 2

12) Crea un programma in Python che legga una matrice quadrata 10x10 di numeri interi.
Verificare quanti numeri della diagonale principale sono dispari, scrivere anche, la somma e la
media di questi elementi.

13) Implementa un programma, utilizzando il Linguaggio Python, che legga 30 nomi e cognomi.
di persone. Ad ogni nome e cognome letto, controlla se le parole hanno la stessa lunghezza.

Se il nome e il cognome hanno la stessa lunghezza, concatena le parole e

escreva mensagem mostrando o nome completo;
Se il nome e il cognome hanno lunghezze diverse, scrivi un messaggio
mostrando che non hanno la stessa dimensione.

14) Fare un programma in Python che legga alla fine della mattina la chiusura della cassa di un
loja, cioè, il tuo rendimento alla fine della mattina. Lo stesso dovrà essere fatto alla fine del pomeriggio.

Questo rilievo deve essere effettuato tutti i giorni della settimana (dal lunedì al venerdì). A
fine della settimana, dopo aver effettuato tutte le letture, scoprire e scrivere il giorno e il turno che ha avuto maggiore

rendimento. Obs.: Utilizzare il concetto di matrice per risolvere questo esercizio.

35
Funzioni

In questo capitolo impareremo che cos'è e qual è lo scopo di una funzione. Considera la
situazione seguente:

i = 0
mentre i < 3:
Stampa('Scegli tre numeri')
n1 = int(input('Numero 1: '))
j = 1
fat = 1
mentre j <= n1:
grasso *= j
j += 1
stampa('Fattoriale: {0}'.format(fat))
n2 = int(input('Numero 2: '))
j = 1
fat = 1
mentre j <= n2:
grasso *= j
j += 1
print('Fattoriale: {0}'.format(fat))
n3 = int(input('Numero 3: '))
j = 1
fat = 1
mentre j <= n3:
grasso *= j
j += 1
print('Fattoriale: {0}'.format(fat))
i += 1

In questo esempio, lo sviluppatore chiede all'utente di inserire tre numeri tre volte.
Per ogni numero viene calcolato il suo fattoriale (esempio: 4! = 4 x 3 x 2 x 1) e stampato nella
tela. Nota che questo codice presenta una ripetizione delle seguenti istruzioni:

36
j = 1
fat = 1
mentre j <= n1:
grasso *= j
j += 1
stampa('Fattoriale: {0}'.format(fat))

E se lo sviluppatore volesse calcolare il fattoriale di 10 numeri 3 volte? Ci riesce?

immaginare la quantità di righe e codici ripetuti che verrebbero generati?

Per evitare situazioni come queste, i linguaggi di programmazione offrono una risorsa
denominato funzione.

La funzione corrisponde a un blocco di codice che può essere invocato quante volte
forem necessarie. Essa definisce un problema. L'uso delle funzioni ha come obiettivo:
Minimizzare la quantità di codice scritto;
Facilitare la comprensione del codice sorgente;

Distribuire la risoluzione del problema in piccoli moduli.

Allora come sarebbe il codice sopra utilizzando tale risorsa?

def fattoriale(n):
j = 1
fat = 1
mentre j <= n:
grasso *= j
j += 1
stampa('Fattoriale: {0}'.format(fat))

i = 0
mentre i < 3:
print('Scegli tre numeri')
n1 = int(input('Número 1: '))
fattoriale(n1)
n2 = int(input('Numero 2: '))
fattoriale(n2)

37
 n3 = int(input('Numero 3: '))
fattoriale(n3)
i += 1

Nel primo scenario, il codice scritto conteneva 25 righe, con l'applicazione della funzione c'è stata

la riduzione a 17 righe, con un risparmio del 32%. Nota anche che il

trecho

j = 1
fat = 1
mentre j <= n1:
grasso *= j
j += 1
stampa('Fattoriale: {0}'.format(fat))

è stata scritta solo una volta, all'interno della funzione fattoriale. Nel codice principale la funzione è stata

chiamata per nome e il valore di entrata tra parentesi.

fattoriale(n1)
fattoriale(n2)
fattoriale(n3)

Caratteristiche

La funzione presenta le seguenti caratteristiche:

Può essere invocata solo dopo la sua creazione;

Può ricevere o meno valori esterni, parametri;

Può restituire o meno un risultato. Quando si desidera restituire un valore è
è necessario utilizzare il comandoreturn.

Per creare la funzione utilizza questa sintassi:

def nomeFunzione(parametri):
comandos
ritorna valore

onde:

38
 def comando utilizado para definir uma função;
nomeFuncao il nome della funzione. Evita caratteri speciali e
espaço;
parametros definisci un'entrata di valori esterni. Se la
se la funzione non c'è, basta aprire e chiudere le parentesi. Se c'è
più di uno, sarà necessario separarli con una virgola;
comandi insieme di istruzioni che mirano a risolvere il
problema;
ritorna comando utilizzato per restituire un valore. Il return
permette di restituire un solo valore;

valore valore da restituire.

È importante sottolineare che un codice può avere quante più funzioni possibile.
necessarie.

Esempio 01

Sviluppa una funzione in Python che stampi un numero di righe:

*
**
***
****
*****

L'utente deve scegliere quante righe desidera stampare nel formato presentato.

Risoluzione:

def stampa(linee):
per i in range(1, righe + 1):
print('*' * i)

Esempio 02

39
Sviluppa una funzione in Python che riceve una lista contenente il nome e
cognome. Questa funzione dovrebbe restituire un'altra lista contenente il nome completo delle

pessoas que iniciam com ‘A’.

Risoluzione:

def filtro(lista):
f = list(filter(lambda item : item[0][:1] == 'A', lista))
r = []
per i in f:
[Link](i[0] + ' ' + i[1])
ritorna r

Esempio 03

Sviluppa una funzione in Python che riceve un elenco di ordini. Ogni elemento
possiede uno dei seguenti valori:

CREME CIoccolato Napoletano FLOCOS

la funzione deve restituire il nome dell'ordine più frequente.

Risoluzione:

def ordine(lista):
itens = ['CREME', 'CHOCOLATE', 'FLOCOS', 'NAPOLITANO']
maior = 0
sabor = ''
per elemento in articoli:

q = len(list(filter(lambda i : i == item, lista)))

se q >= maggiore:
maior = q
sabor = item
ritorna sapore

40
Esempio 04

Sviluppa una funzione in Python che restituisca gli elementi della diagonale principale di una

matrice di ordine N.

Risoluzione:

def dPrincipale(matrice):
indice = 0
diagonal = []
per linea in matrice:
[Link](linha[index])
indice += 1
ritorna diagonale

Esempio 05

Sviluppa una funzione in Python che riceva un numero corrispondente a

quantità di giochi della MEGA SENA da generare. La funzione dovrebbe restituire tutti
i numeri estratti dal computer. Una schedina contiene numeri da 1 a 60 e una
la giocata contiene 6 numeri.

Risoluzione:

def cartelas(quantità):
saida = []
per i in range(1, quantità + 1):
jogo = []
count = 0
mentre Vero:
num = [Link](1, 60)
se num non è in jogo:
[Link](num)
count += 1
se count == 6:
pausa
[Link]()

41
 [Link](jogo)
ritorno uscita

Lista di esercizi E

1) Sviluppa una funzione in Python che riceva un numero intero. La funzione deve restituire
um boolean indicando: true se o número for primo; e false se o número não for primo. Utilize a
seguente firma.

defisPrimo(numero)

2) Sviluppa una funzione in Python che riceva una matrice di testo e un attributo in più
anche del tipo testo. La funzione dovrà restituire un elenco contenente tutti i testi che
contenga il valore di input. Ecco la firma del metodo:

definire la ricerca(valori, ingresso)

Exemplo:

valores:

Cane vecchio non impara trucchi nuovi Il mio rospo jururu

Super Mario Fratello Non mostrare il rio

rio

Retorno:

Fratello Super Mario Mostra nessun rio

3) Sviluppa una funzione in Python che riceva quattro interi: il primo indica la quantità
di righe; il secondo indica la quantità di colonne; il terzo l'intervallo iniziale; e il quarto il
intervallo finale. La funzione dovrà restituire una matrice in base alla dimensione specificata e
preenchida com o valores aleatórios de acordo com o intervalo estipulado. Segue assinatura da
função:

defmatriceCasuale(riga, colonna, intervalloIniziale, intervalloFinale)

42
Esempio:

Ingresso:

matrizAleatoria(2, 3, 30, 60)

Saída:

45 32 56

31 50 41

43
Struttura dei Dati

In questo capitolo impareremo come costruire un modello concettuale a partire da una

struttura dei dati. Vedremo anche il significato di dizionario dei dati e come
possiamo fare per gestire questo dizionario.

Considera la seguente modellazione dei dati:

Nel modello presentato, i dati sono distribuiti nelle seguenti tabelle:

Corso; Server; Disciplina; e Matrice.
Curso La tabella Corso è responsabile di memorizzare il nome di qualsiasi corso
riferente a qualsiasi istituzione di insegnamento;

Server La tabella Server è responsabile della conservazione delle informazioni dei

server che agiscono come insegnanti. Ogni server ha un nome, un e-
mail e sua area di attivita;
Disciplina La tabella Disciplina è responsabile della conservazione delle informazioni di
tutte le discipline offerte in un corso. Ogni disciplina ha il corso al
qual é ofertada, seu nome, o período de oferta, a carga horária total, a carga
orario di presenza e il suo carico orario a distanza;

44
 Matrice La tabella Matrice è responsabile di correlare ogni disciplina con il suo
professore di stato.
Creeremo una struttura dati che permetterà allo sviluppatore di accedere al modello
relazionale presentato. I file che contengono il modello e i dati sono separati
in due categorie: dati per file csv che archiviano i dati; e meta-dati
per i file txt che memorizzano la logica strutturale di come i dati sono
organizzati.

Ad esempio, la tabella Corso ha la sua struttura memorizzata in data/meta-

data/[Link]. Questo file definisce le caratteristiche della tabella Corso:

Id bigint.
NomeCurso varchar.
Istituzione varchar.

Il file che contiene i dati si trova indata/data/[Link]. Ecco il formato

due dadi

1;Engenharia Elétrica;IF Goiano - Campus Trindade

2;Ingegneria Civile;IF Goiano - Campus Trindade
3;Ingegneria Informatica;IF Goiano - Campus Trindade
4;Master in Human Sciences;IF Goiano - Campus Trindade

Ogni dato è separato da punto e virgola (;), che corrisponde a una colonna della
tabella costruita.

Per iniziare il lavoro, il primo passo è trovare le strutture di dati di ciascuno

tabella e creare un dizionario. Il dizionario da creare sarà basato sui file
che definiscono la struttura e che sono archiviati nella cartella meta-dati.

Dicionário de dados

Anche conosciuto come mappa o array associativo, il dizionario dei dati ha come
funzione ricevere una struttura di dati astratta e relazionarla con le varie entrate di
dati.

Per creare un dizionario dei dati segui una delle seguenti sintassi.

45
dicionario = {
'Curso': []
}

Dove:
dizionario nome do dicionário de dados;
corso nome da estrutura da tabela a ser buscada.

Può anche essere scritto nel seguente modo:

dicionario = dict(Curso = [])

tu

dicionario = dict()
dicionario['Curso'] = []

Conoscendo il modo di costruzione, ora dovremo creare un dizionario che riceve

tutte le informazioni dei file contenuti nel cammino meta-dati. Il dizionario
dovrà essere costruito nel seguente formato:

dicionario = {
'Curso': [
('Id', 'bigint'),
('NomeCurso', 'varchar'),
('Instituicao', 'varchar')
]
}

La chiave (key) sarà composta dai nomi delle entità ([Link], [Link],
[Link], [Link]) e il loro contenuto attraverso i campi che definiscono ogni entità.

Per montare il dizionario dinamicamente, dovremo caricare tutti i file

contenuti nella pastameta-dati. Per catturare il nome dei file contenuti in una
pasta, utilizza il seguente codice sorgente:

importa os

46
per file in [Link]('data/meta-data'):
stampa(file)

Il codice presentato importa un modulo denominato 'os'. Questo modulo permetterà

caricare i file contenuti in una cartella tramite la funzione listdir, che restituisce la
lista contendo o nome dos arquivos. A saída esperada para esse código será:

[Link]
[Link]
[Link]
[Link]

Sebbene abbiamo i nomi dei file contenuti nei meta-dati, nota che questi
posseggono il nome con la sua estensione. Dobbiamo rimuovere l'estensione .txt. Possiamo rimuovere

attraverso la seguente funzione:

def ritirareEstensione(arquivo):
return [Link]('.')[0]

Avendo il percorso e il nome dei file, ora dobbiamo creare una funzione che consenta
caricare tutto il contenuto. Creeremo quindi la seguente funzione:

def leggiMetaData(arquivo):
dados = open('data/meta-data/' + arquivo, 'rt')
metaData = []
per riga in dati:
i = [Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
[Link]()
return metaData

La funzione open apre il file, a essa deve essere inviato il percorso del file e il
tipo di apertura, nel caso è aperto solo per lettura. Un file può essere aperto
secondo i caratteri:

'r' apre per la lettura (predefinito);

47
 'w' abre para escrita;
'x' apre per la creazione. Se esiste già un file con lo stesso nome, si verificherà un
erro;
'a' apre per scrittura, aggiungendo il contenuto alla fine del file se esistente;
'b' modo binario;
't' modo testo (standard);
'+' apre il file su disco aggiornando (leggendo e scrivendo);
'U' modo nuova riga (non aggiornato).

La variabile data riceve tutto il contenuto del file nella funzione open. Quando lo chiudi è
è necessario utilizzare la funzione close().

Juntando tutto il codice prodotto arriviamo al seguente risultato:

importa os

def ritirareEstensione(archivo):
return [Link]('.')[0]

def leggiMetaDati(archivo):
dati = open('data/meta-data/' + file, 'rt')
metaData = []
per linea in dati:
i = [Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
[Link]()
restituire metaDati

dicionario = {}
per file in [Link]('data/meta-data'):
tabela = retirarExtensao(file)
dicionario[tabela] = lerMetaData(file)

per chiave, valore in [Link]():

print('Entità: {}'.format(chave))
print('Attributi: ', valore)

48
Le informazioni contenute in questa entità sono definite dal nome di tupla. Una tupla è
creata con parentesi e a differenza della lista (parentesi quadre), la tupla è immutabile, questo

significa che una volta che il contenuto è definito, non sarà possibile modificarlo.

Entidade: Curso
Atributos: [
('Id', 'bigint'),
('NomeCurso', 'varchar'),
('Instituicao', 'varchar')
]

Nel caso del Corso abbiamo tre tuple. Nel nostro esempio, una tupla è costituita da due
dados: nome do campo; e tipo do campo.

Exemplo: Relacionando meta-dados com dados

In questo esempio metteremo in relazione i meta-datiCorso con i loro dati.

# Leggi tutti i meta-dati del file

Ritorna un elenco
def leggiMetaDati(arquivo):
dados = open('data/meta-data/' + arquivo, 'rt')
metaData = []
per linea in dati:
i = [Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
[Link]()
return metaData

# Separa una riga di dati del CSV

# Restituisce i dati in formato elenco
def leggiDado(tupla, linea):
linha = []
per l in range(0, len(tupla)):
[Link]([Link](';')[l])
ritorna linea

49
# Crea il dizionario ed estrae le informazioni
# in una tupla
dicionario = {}
dicionario['Curso'] = lerMetaData('[Link]')
tupla = []
per t in dizionario['Corso']:
[Link](t[0])

# Collega i dati con le tuple

dati = []
d = open('data/data/[Link]', 'rt')
per i in d:
linea = leggiDado(tupla, i)
Crea un dizionario per ogni riga di dato
x = {}
per chiave, valore in zip(tupla, linea):
x[key] = value
[Link](x)

[Link]()

Lista di esercizi F

1) Sviluppa un codice Python che crei le tuple dell'entità Server. Collega ogni tupla
con i tuoi dati.

2) Sviluppa un codice Python che crei le tuple dell'entità Disciplina. Relaziona ogni tupla.
con i tuoi dati.

3) Basato sull'esercizio 2, sviluppa un codice Python che visualizzi solo le discipline del
1º e 3º periodo.

4) Sviluppa un codice Python che mostri i seguenti dati:

Nome do Curso Unità Curricolare Periodo Carga Horária Total

NomeCurso UnitàCurricolare Periodo Cht

50
In questo esercizio sarà necessario collegare le entità Corso e Disciplina.

5) Crea la seguente applicazione in Python:

Scegli un'opzione:
1) Elencare corsi
2) Listar disciplinas
3) Elencare i server
4) Listar disciplina por período
5) Elencare le discipline per corso

6) Elencare il server per nome

7) Uscire

51
Python e SQLite

In questo capitolo impareremo come connettere il linguaggio Python con il database

SQLite. Vedremo come eseguire le principali routine di manipolazione nel database
dados: consulta; inserção; atualização; e remoção.

Un Sistema di Gestione di Basi di Dati (SGBD) è una struttura

utilizzata per memorizzare dati. Inoltre, consente che questi dati siano
memorizzati secondo un modello. Il SGDB offre anche risorse come
integrità e sicurezza del database.

Per connettere il linguaggio di programmazione al database, non sarà

è necessario importare librerie esterne. Il linguaggio Python ha già una funzionalità di
connessione nativa con il database SQLite.

Per testare la connessione con il database, crea un progetto chiamato BancoDados.

Nel progetto creato, costruisci un file Python e nomina con [Link].

Scarica il file [Link] presente nella disciplina dell'Ambiente Virtuale (Moodle).

Metti questo file nella stessa cartella di [Link]. Digita il seguente codice:

01 importare sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link]('SELECT * FROM prodotto')
05 stampera([Link]())
06 [Link]()

Linha 01:Importa o recurso responsável por conectar a linguagem com banco de

dati;
Linha 02:O comandoconnectrealiza a conexão com o banco de dados selecionado.
Questa funzione accetta solo il nome del database, nel caso in cui il file sia insieme a
[Link]. Se il database è in un'altra cartella, sarà necessario passare tutto
percorso. Esempio:c:\cartella\sottocartella\[Link];

Linee 03 a 05: Vedremo il significato di questi comandi nei prossimi argomenti;

Linea 06: Il comando close finale chiude la connessione. Necessario per chiudere il database.

dati.

52
Manipolando il database

In questo argomento impareremo come manipolare i dati all'interno del database. Per questo

considera il modello seguente.

Nel modello presentato abbiamo tre tabelle: prodotto; acquisto; acquisto_prodotto. Ognuna
la tabella ha la seguente funzione:
produto:armazena todos os produtos. Registra-se a descrição do produto e seu
preço unitário;
compra:armazena todas as compras realizadas. Registra-se a data de
realizzazione dell'acquisto e il luogo in cui è stato effettuato l'acquisto;

compra_produto:armazena todos os produtos que foram comprados em uma

determinato acquisto. Si registra il codice dell'acquisto, il codice del prodotto e
quantos produtos foram comprados (quantidade).

Comando INSERT

Il comando INSERT viene utilizzato quando si desidera inserire un dato nel database.
L'INSERT ha la seguente sintassi:

INSERISCI IN tabela (campos) VALORI (dados);

Dove:
INSERISCI IN: comando da istruzione;
tabela: nome da tabela que receberá o dado;
campi: nome dei campi separati da virgola (,);
VALORI: comando da istruzione;

53
 dados: dados relativo a cada campo. Cada dado deverá ser separado por vírgula
(,). I dati di tipo testo devono essere racchiusi tra virgolette singole.

Esempio 01: Si desidera inserire nella tabella prodotto i seguenti dati:

Descrizione Prezzo unitario

Cupim Bovino 12,89
Costelinha Suína Sadia o Perdigão 10.99

I comandi sarebbero:

INSERISCI IN prodotto (descrizione, precounit) VALORI ('Cupim Bovino',

12.89);

INSERT INTO prodotto (descrizione, precounit) VALUES ('Costina

Suína Sadia o Perdigão, 10.99);

Per ogni insieme di dati è stato effettuato un INSERT. Tuttavia è possibile anche
inserire nel seguente modo:

INSERISCI IN prodotto (descrizione, precounit) VALORI

('Cupim Bovino', 12,89)
Costelinhas di Maiale Sadia o Perdigão, 10.99

Per eseguire il comando INSERT all'interno del linguaggio Python, dovremo

scrivere il seguente codice:

01 import sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link](
05 'INSERIRE IN prodotto (descrizione, precounit) VALORI (?, ?), (?, ?
06 ('Cupim Bovino', 12.89, 'Costelinha Suína Sadia ou Perdigão', 10.99))
07 [Link]()
08 [Link]()

54
Linea 03: La funzione cursore è responsabile di eseguire qualsiasi manipolazione con il

database. Ogni volta che c'è la necessità di lavorare con una tabella, sarà
necessario chiamare questa funzione;

Linee 04, 05 e 06: Il comando esegui riceve quale comando deve essere eseguito.
In questo caso eseguiremo il seguente comando:

'INSERISCI IN prodotto (descrizione, prezzo_unitario) VALORI (?, ?), (?, ?)'

Il simbolo di interrogazione (?) indica che sarà necessario passare un parametro come
riferimento. In questo caso sarà necessario passare quattro parametri:

('Cupim Bovino', 12.89, 'Costelinha Suína Sadia ou Perdigão', 10.99)

'Cupim Bovino' 12,89 Costelinha Suína Sadia o Perdigão 10.99

↑ ↑ ↑ ↑
01 02 03 04

Linea 07: Il comando commit registra l'istruzione passata in execute. Questo comando

è necessario per effettuare l'operazione in banca.

Esempio 02: Si desidera inserire nella tabella prodotto il seguente dato:

Descrição Prezzo unitario

Filetto di Tilapia Geneseas 7,79

INSERT INTO prodotto (descrizione, precounit) VALUES ('Filetto di

Tilapia Geneseas', 7.79)

01 import sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link](
05 'INSERISCI IN prodotto (descrizione, precounit) VALORI (?, ?)'
06 ('Filé di Tilapia Geneseas', 7.79)
07 [Link]()
08 [Link]()

Per testare se i dati vengono memorizzati in [Link], utilizzare il seguente

sito:

55
[Link]

Per aprire il banco clicca su File Apri DB.

Clicca con il tasto destro sul prodotto e scegli Mostra tabella.

56
Comando AGGIORNA

Il comando UPDATE è responsabile della modifica di un dato che esiste già nella tabella. Esso

possiede la seguente sintassi:

AGGIORNA tabella SET campo = nuovoValore DOVE campoChiave = valore

Dove:
AGGIORNARE SET: comando da istruzione;
tabela: nome da tabela a ser utilizada;
campo: nome do campo a ser editado. Se houver mais campos a serem
alterati utilizza la virgola (,) per separarli;
novoValor: novo valor do campo;
DOVE: condizione di aggiornamento;
campoChave: código da tabela;
valor: valor do código.

Esempio 03: Cambiare il prezzo unitario del prodotto:

Id Descrizione Prezzo unitario

21 Cupim Bovino 12,89

per R$ 21,99.

AGGIORNA prodotto SET precounit = 21.99 DOVE id = 21

Per eseguire il comando UPDATE all'interno del linguaggio Python, dovremo

scrivere il seguente codice:

01 importare sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link](
05 AGGIORNA prodotto SET precounit = ? DOVE id = ?
06 [Link]()
07 [Link]()

57
Esempio 04: Cambia la descrizione e il prezzo unitario del prodotto:

Id Descrizione Prezzo unitario

23 Filé di Tilapia Geneseas 7.79

per

Id Descrição Prezzo unitario

23 Gambero DellMare 8.99

AGGIORNA prodotto SET descrizione = 'Camarão DellMare', precounit =

8.99 DOVE id = 23

01 import sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link](
05 UPDATE produto SET descricao = ?, precounit = ? WHERE id = ?
06 ('Camarão DellMare', 8.99, 23))
07 [Link]()
08 [Link]()

Comando DELETE

Il comando DELETE viene utilizzato per rimuovere un dato da una tabella del database
Dati. Ha la seguente sintassi:

DELETE FROM tabela WHERE campoChave = valor

Dove:
DELETE FROM: comando da istruzione;
tabela: nome da tabela a ser manipulada;
DOVE: condizione di rimozione;
campoChave: código da tabela;
valor: valor do código.

Esempio: Elimina il record 23.

58
CANCELLA DA prodotto DOVE id = 23

Per eseguire il comando DELETE all'interno del linguaggio Python, dovremo

scrivere il seguente codice:

01 importa sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link]('DELETE FROM prodotto WHERE id = ?', (23,))
05 [Link]()
06 [Link]()

Comando SELECT

Il comando SELECT è utilizzato per eseguire query sulle tabelle del database
dati. Ha la seguente sintassi di base:

SELEZIONA campi DA tabelle;

Dove:
SELECT: seleziona i campi da visualizzare;
campos: campos escolhidos para exibição;
DA: seleziona le tabelle utilizzate;
tabelas: tabelas escolhidas.

Esempio 05: Visualizza la descrizione di tutti i prodotti registrati.

SELECT descrizione FROM prodotto

01 importare sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link]('SELEZIONA descricao DA produto')
05 per riga in [Link]():
06 stampa(linha[0])
07 [Link]()
08 [Link]()

Esempio 06: Visualizza tutti i dati della tabella prodotto.

59
SELEZIONA * DA prodotto

01 importare sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link]('SELECT * FROM prodotto')
05 per linea in [Link]():
06 stampa('{0} - R$ {1}'.format(linha[1], linha[2]))
07 [Link]()
08 [Link]()

Per visualizzare tutti i campi di una tabella, utilizza il simbolo asterisco (*). Nel caso
sarà emessa una lista contenente: (id, descrizione, precounit).

Posição 0 id
Posizione 1 drescrizione
Posizione 2 precounit

Comando WHERE

Il comando WHERE è utilizzato per testare una determinata condizione. Può essere
costruito all'interno dei comandi: INSERT; UPDATE; o WHERE.

Esempio 07: Mostra tutti i prodotti il cui prezzo unitario è superiore a 500,00 €.

SELEZIONA * DA prodotto DOVE precounit > 500

01 importare sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link]('SELECT * FROM prodotto WHERE precounit > 500')
05 per linea in [Link]():
06 stampa('{0} - R$ {1}'.format(linha[1], linha[2]))
07 [Link]()
08 [Link]()

Esempio 08: Mostra tutti i prodotti la cui descrizione inizia con la lettera 'F'.

SELEZIONA * DA prodotto DOVE descrizione LIKE 'F%'

60
 01 importare sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link]("SELECT * FROM prodotto WHERE descrizione LIKE ?", ('F%',))
05 per riga in [Link]():
06 print('{0} - R$ {1}'.format(linha[1], linha[2]))
07 [Link]()
08 [Link]()

Lavorando con più di una tabella

Supponiamo di voler visualizzare tutti i prodotti realizzati in un determinato

compra. In questo caso avremmo bisogno di:

da tabella acquisto per identificare quale acquisto è stato effettuato;

dalla tabella compra_prodotto per identificare quali sono i prodotti di quella

compra; e
da tabella prodotto per mostrare la descrizione.

Il codice sarebbe il seguente:

SELEZIONA
descricao
DA
produto, compra, compra_produto
DOVE
[Link] = compra_produto.idcompra E
[Link] = acquisto_prodotto.id E
[Link] = 1

Interpretando il codice sopra, seleziona la descrizione del prodotto dell'acquisto il cui id è

uguale a 1. Dobbiamo collegare le tabelle, e per questo è necessario confrontare i

campi chiave della tabella principale con le loro rispettive riferimenti:

[Link] = compra_produto.idcompra E
[Link] = acquisto_prodotto.id

Segue il codice in Python che risolverebbe questo problema.

61
 01 import sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link](
05 'SELECT descricao FROM prodotto, acquisto, acquisto_prodotto ' +
06 'DOVE [Link] = compra_produto.idcompra E ' +
07 '[Link] = compra_prodotto.id E [Link] = 1')
08 per linea in [Link]():
09 stampa('{0}'.format(linha[0]))
10 [Link]()
11 [Link]()

Esempio 09: Presenta l'importo totale da pagare per l'acquisto il cui id è uguale a 1.

Per ottenere il totale di un acquisto, sarà necessario moltiplicare le colonne

precounitequantidadede ogni articolo. Per questo dobbiamo effettuare la seguente
consultazione

SELEZIONA
Descricao, precounit, quantidade
DA
produto, compra, compra_produto
DOVE
[Link] = compra_produto.idcompra E
[Link] = compra_produto.id E
[Link] = 1

Di seguito abbiamo il codice che risolve il problema.

01 import sqlite3
02 conn = [Link]('[Link]')
03 cursore = [Link]()
04 [Link](
05 'SELEZIONA descrizione, precounit, quantità DA prodotto, acquisto,
06 acquisto_prodotto DOVE [Link] = acquisto_prodotto.idacquisto E ' +
07 '[Link] = acquisto_prodotto.id E [Link] = 1')
08 totale = 0
09 per riga in [Link]():
10 stampa('{0} (R$ {1}) QUANT: {2}'.format(linha[0], linha[1], linha[2]))
11 totale += riga[1] * riga[2]
12 print('Totale da pagare: R$ {0}'.format(total))

62
 13 [Link]()
14 [Link]()

Linee 08 e 11: crea una variabile e successivamente accumula la somma della moltiplicazione di

preço unitário com a quantidade de cada produto.

Lista di esercizi G

1) Sulla base del database presentato, crea il seguente sistema.

L'utente entrerà in un menu che avrà le seguenti opzioni:

Scegli un'opzione:
1) Creare un nuovo prodotto
2) Creare un nuovo acquisto
3) Aggiungere un prodotto all'acquisto

4) Consultare i prodotti per nome

5) Consultare i dati dell'acquisto

6) Escludere un acquisto
7) Uscire

Cada opção realiza a seguinte operação:

1 L'utente inserirà i dati del nuovo prodotto e li salverà nel database;
2 L'utente potrà creare un nuovo acquisto
3 A partire da un acquisto, l'utente potrà aggiungere un articolo, prodotto, nella lista della spesa
4 A partire dalla descrizione, l'utente potrà consultare i prodotti registrati.
5 A partire da un acquisto, verranno elencati tutti i dati del prodotto e la sua quantità, così
come l'importo totale da pagare

6 L'utente uscirà dal sistema

63
Trattamento delle Eccezioni

Quando si scrive un codice, lo sviluppatore può commettere tre tipi di errori: errore logico;
erro di sintassi; errore di esecuzione.

L'errore logico si verifica quando lo sviluppatore commette un errore nelle regole di

attività dell'applicazione, questo tipo di errore viene solitamente scoperto quando gli utenti che

utilizzano il sistema scoprono l'incoerenza del problema con la soluzione presentata.

L'errore di sintassi si verifica nel momento in cui il codice viene scritto. Questo tipo di errore

è il più semplice da rilevare considerando che avviene durante la creazione del

progetto.

L'errore di esecuzione si verifica quando l'utente richiede la chiamata di un'azione e questa

a sua volta non riesce a essere completata a causa di un errore in qualche istruzione del
codice. La seguente istruzione è un esempio classico di un errore di esecuzione:

x = 1/0

In questa istruzione il sistema non segnala errori e consente che il codice venga eseguito. Nel
Durante l'esecuzione, verrà visualizzato il seguente messaggio:

Eccezione (chiamata più recente per ultima):

File "C:/sviluppo/ [Link]", riga 1, in <modulo>

x = 1/0
ZeroDivisionError: divisione per zero

In questo capitolo vedremo come gestire gli errori di esecuzione attraverso la gestione di

exceções. As palavras chavestry/exceptsão utilizadas na construção do tratamento

di eccezione. Utilizzando il trattamento delle eccezioni, lo stesso codice potrebbe essere scritto in

seguente forma:

prova:
x = 1/0
eccetto BaseException:
Errore di divisione per zero
print('Continua...')

64
Anche se si verifica l'errore, l'esecuzione non viene interrotta.

É possível declarar mais de umexceptpara tratar diferentes tipos de erro. Exemplo:

importa zipfile
prova:
banco_zip = [Link]("[Link]")
banco_zip.extractall(path="banco")
banco_zip.chiudi()
eccetto FileNotFoundError:
Stampa("File inesistente")
eccetto PermissionError:
Errore di permesso

In questo caso il codice gestisce due tipi di eccezione: il primo caso in cui non trova il file
(FileNotFoundError); e in secondo luogo, nel caso non ci sia autorizzazione per l'estrazione del
arquivo (PermissionError).

Gerarchia delle eccezioni

Per ogni errore è possibile specificare il suo tipo, ad esempio, quando un numero è diviso
per zero l'errore sollevato sarà ZeroDivisionError. In Python esiste una gerarchia
di errori.

BaseException
o SystemExit
o KeyboardInterrupt
o GeneratorExit
o Eccezione
. StopIteration
. ErroreAriaMetica
Errore di punto flottante
OverflowError
Eccezione di divisione per zero
. AssertionError
. AttributeError
. Errore di buffer
. Errore EOF
. ImportError
. Errore di ricerca

65
 IndexError
KeyError
. Errore di memoria
. NameError
UnboundLocalError
. OSError
BlockingIOError
ChildProcessError
Errore di Connessione
o BrokenPipeError
ErroreConnectionAborted
o ConnectionRefusedError
o ConnectionResetError
FileExistsError
FileNotFoundError
Errore di interruzione
IsADirectoryError
NotADirectoryError
Errore di autorizzazione
ProcessLookupError
TimeoutError
. Errore di riferimento
. RuntimeError
NonImplementatoErrore
. Errore di sintassi
Errore di indentazione
o Errore di Tabulazione

. SystemError
. TypeError
. ValueError
Errore Unicode
o UnicodeDecodeError
o UnicodeEncodeError
o UnicodeTranslateError
. Attenzione
Avviso di deprecazione
Avviso di deprecazione in sospeso
RuntimeWarning
Avviso di sintassi
AvvisoUtente
Avviso di futuro
Avviso di importazione
Avviso Unicode
BytesWarning
AvvisoRisorsa

Nel caso ci siano dubbi su quale eccezione utilizzare, è possibile invocare il trattamento degli errori.

primárioBaseException. Cada classe de exceção possui sua particularidades.

66
Azione di pulizia

Quando si scrive un codice che contiene la gestione delle eccezioni, può capitare che
sviluppare è necessario pulire qualche variabile, chiudere qualche file o procedura che
sii aperto. Considerando questi casi, esiste un comando opzionale che può essere
utilizzato insieme con try/except. Questo comando è conosciuto come finally.

Il comando finale eseguirà sempre il codice, indipendentemente dal fatto che si sia verificato un errore o meno.

no. Esempio:

def leggiMetaData(archivo):
prova:
dati = open('data/meta-data/' + file, 'rt')
metaData = []
per linea in dati:
i = [Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
eccetto FileNotFoundError:
Stampa('File non trovato.')
finalmente
[Link]()
return metaData

Comando alza

Questo comando viene utilizzato quando lo sviluppatore ha bisogno di provocare un errore controllato.

Segui la sintassi:

solleva Erro

dove:
alza parola chiave utilizzata per provocare l'errore;
Errore errore a essere invocato.

Esempio:

def verificare(sapore):

67
 se sabor non in ('CREME', 'CHOCOLATE', 'NAPOLITANO'):
solleva BaseException

provare:
sabor = input('Escolha o sabor de picolé: ')
verificare(sapore)
Ottima scelta
eccetto BaseException:
Non lavoriamo con questo sapore.

Lista di esercizi H

1) A partire dal codice presentato:

x = [1, 3, 5, 6, 7, 8]
i = 0
mentre i <= len(x):
stampa(x[i])
i += 1

crea un trattamento delle eccezioni per evitare il verificarsi dell'errore.

2) Crea un programma in Python che riceva n numeri e sommi questi numeri finché la somma
non superiore a 100. Il programma dovrà stampare il valore sommato (prima di raggiungere il numero
maggiore di 100) e dovrà informare quanti numeri sono stati sommati e qual è la media. Rifai il tuo

programma utilizzando le seguenti regole:

a. Utilizzare il trattamento delle eccezioni per gestire l'input dei dati;
b. Quando la somma sarà superiore a 100, il programma dovrà generare un'eccezione.

3) Scrivi un programma in Python che riempia un array con 10 posizioni. Il

l'utente fornirà i valori da inserire e le rispettive posizioni nell'array. Il
il programma deve gestire le eccezioni quando viene fornita una posizione inesistente dell'array

quando il valore fornito non è un numero.

68
4) Supponiamo che l'utente effettui transazioni nel suo conto corrente. Sviluppa un codice nel
qual utente digiterà il proprio saldo iniziale. Potrà effettuare un Addebito o un Accredito. Effettua una
eccezione nel caso in cui il saldo del cliente diventi negativo. L'importo del saldo non deve diventare negativo.

69
File

CROCE

70
Python e Arduino

71
Riferimento bibliografico

CRUZ, [Link]: Scrivi i tuoi primi programmi. 1ª ed. Casa do Código: São
Paulo. 1998.

MENEZES, N. Introduzione alla programmazione con Python: algoritmi e logica di

programmazione per principianti. 2ª ed. Novatec: San Paolo. 2014.

72