PYTHON per le DISCIPLINE SCIENTIFICHE
PROGRAMMARE TABLET E SMARTPHONE CON Py3 SU O.S. ANDROID,
Guida-PYTHON
PROGRAMMARE IN PYTHON, SU TABLET O SMARTPHONE su O.S. ANDROID.
- APPLICAZIONE NECESSARIA PER PROGRAMMARE su Tablet o Smartphone, in ambiente ANDROID
- DISPONIBILE SUL PLAY_STORE
Ambiente di sviluppo che appare per Py3 dopo averlo avviato.
Dopo aver digitato il codice di qualsiasi script per eseguirlo fare click su cerchio giallo. t
IL LINGUAGGIO PYTHON E LE SUE CARATTERISTICHE
LE PAROLE RISERVATE(keyword) DEL LINGUAGGIO
and del for is raise
assert elif from lambda return
break else global not try
class except if or while
continue exec import pass yield
def finally in print
N.B. Le parole riservate possono essere usate solo in funzione della loro valenza, e
nel loro ambito di pertinenza, ma non per definire variabili, costanti o altro ancora;
in questo caso verranno generati segnali di errore.
Sono degli identificatori riservati che comunicano al compilatore la dichiarazione
e/o istruzione che intende realizzare chi sta sviluppando il programma sorgente.
------------------------------------------------------------------------ -------------------------------------------------
Vademecum:
1) # sono indicate in questo modo tutte le righe di commento che non vengono eseguite dal compilatore ma solo visualizzate.
2) num =int(input(("dammi primo numero\n")) # le stringhe di testo vanno sempre fra le doppie virgolette e sono di colore rosso
3) print("ciao") # Questo è il codice e il colore grafico usato per la parola riservata print che consente di visualizzare quanto contenuto fra le doppie virgolette.
Per le parole riservate(elencate in alto) e per tutte le altre istruzioni (float(input("dammi la base"), sum, append, if, else, try, not, pass, return ...)viene usato lo stesso colore(azzurro); in sostanza, soltanto l'istruzione print ha un colore diverso.
5) questo simbolo significa invio da tastiera e conseguente elaborazione del codice.
6) gli Script realizzati devono essere salvati, con un nome coerente con l'applicazione, in una sotto_cartella predefinita, di nome Scripts, contenuta all'interno della cartella principale di Python; rimane certa la possibilità di salvare il file in qualsiasi directory, desktop compresa.
LE VARIABILI IN PYTHON La Variabile in Python, come in tutti i linguaggi, è un'area di memoria riservata per contenere
un valore numerico, o alfanumerico, che può essere modificato nel corso dell'esecuzione del procedimento risolutivo.
Possiamo definire una variabile in qualsiasi momento. Le variabili sono caratterizzate da tre elementi: il nome, il valore e il tipo.
E' opportuno scegliere i nomi delle variabili legati in modo funzionale all'applicazione che si sta sviluppando;
questo accorgimento aiuta a fissare meglio i concetti e a farci ricordare di cosa ci stiamo occupando.
nomi corretti di variabili
nome valore tipo
velocity 10 int
person = "john" string
stringa = "questa una stringa" string
Volume_Cilindro = 20.5 *10^1 float
TempAmbiente = -5.8 float
massimo = 10 int
minimo = -6 int
area = 0.5 float
pressione = 100.0 float
accelerazione = 4E6 float
Temperatura = 5.6 float
---------------------------------------------------------------------------------------
nomi errati di variabili
temp% = 50
pressione? = 2
8caso = 2
print = "ciao"
class = 4
N.B. Le variabili sono case sensitive e pertanto:
auto = 5 e Auto = 5 (sono due variabili distinte)
----------------------------------------------------------------
COSTANTI IN PYTHON
Peculiarità delle costanti in Python
- Vanno dichiarate, attribuendo loro un nome, prima di essere utilizzate.
- E' convenzione, comune ad altri linguaggi, usare dei nomi con solo lettere maiuscole in modo da evidenziare che si tratta proprio di una costante e, quindi, non modificabile.
- Usare nomi pertinenti con l'applicazione per rendere più chiaro cosa si sta facendo.
nome valore tipo
MASSIMO = 10 int
MINIMO = 20.5 float
SCONTO = 20 int
PERCENTUALE = 20 int
P_GRECO = 3.14 float
-----------------------------------------------------------------------------------
LE OPERAZIONI MATEMATICHE ELEMENTARI
In Matematica Osservazioni Con Python
a = 2*x+4*y/4 a= (2*x+4*y)/4 Sono necessarie le ( )
b = x*y/3 b = x*y/2 ( ) non necessarie: operatori hanno la stessa importanza
c = (1+temperatura) c = (1+ temperatura/100)**2 ( ) sono necessarie
√x^2+y^2 math.sqrt(x**2+y**2) sqrt è contenuto nel modulo matematico
pgreco math.pi il pgreco è contenuto nel modulo matematico
-------------------------------------------------------------------------------
Floor Division con Python e Resto
Es.
15 / 4 da, come risultato, 3.75 in matematica.
Se usiamo operatore // di Floor Division su interi positivi, tale operazione calcola il quoziente ma esclude il resto e quindi con il codice:
>>> print(15 // 4)
3 # verrà scartata la parte frazionaria 0.75
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Per ottenere il resto allora il codice diventa:
>>> print(15%4)
3 # verrà fornito il resto della divisione che è 3
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
>>> print(15//2)
7 # verrà scartata la parte frazionaria 0.5
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
>>> print(15%2)
1 # verrà fornito il resto della divisione
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Abbiamo il numero n = 1346
>>>print( n % 10) # Per qualsiasi n positivo, n % 10 restituisce ultimo numero di n e quindi 6.
6
>>>print(n % 100) # Restituisce solo le ultime due cifre e quindi 46
46
>>> print(n %1000) # Restituisce solo le ultime due cifre e quindi 346
346
>>>print( n //10) # Restituisce il numero senza ultima cifra 134.
134
>>>print( n //100) # Restituisce il numero senza ultime due cifre 13 .
13
>>> print(n //1000) # Restituisce il numero senza ultime tre cifre 1 .
1
print(n % 2) # Restituisce 0 se n è pari, restituisce 1 se n è dispari
10.0 / 4 = 2.5 # Divisione normale.
10.0 // 4 = 2 # Floor division (lascia solo la parte intera)
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
FORMATO DI STRINGA
Formato di stringa Uscita Osservazioni
areaT= 58 # dichiariamo delle variabili e poi le visualizziamo usando i vari formati di stringa
totale =2
peso=5.23467
saluto ="ciao"
# visualizziamo le variabili dichiarate
print("%10.2f" % areaT)
print("%d" % areaT) 5 8 Usa d per stampare interi
print("%5d" % areaT) .....5 8 Lascia 5 spazi vuoti e poi stampa il valore
print("%05d" % areaT) 0 0 0 5 8 Aggiunge tre 0 prima del valore stampato
print("Totale:%5d" % totale) Totale : 2 4 Stampa il risultato a dx usa cinque spazi
print("%f" % peso) 5 . 2 3 4 6 7 Usa f per i valori di tipo float- Non tronca
print("%.2f" % peso) 5 . 2 3 Tronca dopo la seconda decimale
print("%s" % saluto) c i a o Usa s per visualizzare una stringa
print("%d %.2f") 4 5 2 . 3 5 Stampare più valori sulla stessa riga
print("%8s" % saluto) c i a o Impone a 8 la larghezza della stringa e scrive c i a o
print("%-8s" % saluto) c i a o Visualizza c i a o sulla sinistra
print("%d%%" % totale) 2 % Aggiunge il simbolo di % al numero
N.B
Quando si comunica un valore numerico, proveniente da un calcolo qualsiasi, può accadere che lo stesso venga visualizzato con molti numeri dopo la virgola.
Per limitare tali numeri a due il codice da scrivere è il seg:
print ("%2f" areaT)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Per stampare lo stesso valore, spostato a destra di 10 posizioni, il codice è:
areaT= 24
print ("%10.2f" % areaT) # restituisce il valore di areaT spostato a dx di 10 posizioni/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Per stampare più cose sulla stessa riga il codice è il seg:
areaT=24
perimetro=30
print ("Area: %d Perimetro: %10.2f" % (areaT, perimetro)) # restituisce
Area:24 Perimetro:30
----------------------------------------------------------------------------------------------
CONVERSIONE DI TIPO
Python contiene un certo numero di funzioni intrinseche che consentono la conversione \n dei numeri e/o delle stringhe da un tipo all'altro. \nViene generato un segnale errore quando non è possibile.
Esempi
>>> y=int(6.435) # da 6 come intero
>>> print(y)
>>> x=float("12.566") # da 12.566 di tipo float
>>> print(x)
>>> z=str(36) # il 36 diventa stringa
>>> print(z)
>>> print(z+"volte") # da 36volte perchè concatena due stringhe
////////////////////////////////////////////////////////////////////////////////////////////
---------------------------------------------------------
Sito di RiferimentoModulo_math
https://stackoverflow.com/questions/18725917/python-drawing-a-circle-with-x-radius-using-forward
Per il calcolo area del cerchio
>>>from math import pi
>>>r= float(input ("Input the radius of the circle : "))
>>>print( "area of the circle with radius " + str(r) + " is: " + str(pi * r**2))
N.B. Tutte le funzioni trigonometriche accettano solo argomenti in radianti e non in gradi - per convertire da gradi in radianti occorre dividere per 360 e moltiplicare per 2Ï€.
Es: per calcolare il seno di 45 gradi devo trasformare prima angolo in radianti e poi usare la funzione seno su di esso. Vale, infatti, la proporzione: 360:2*pi = gradi:x da cui x= (gradi*2*pi)/360
>>>gradi=45
>>>angolo=(gradi*2*math.pi)/360 # trasforma i gradi in radianti
>>>print(math.sin(angolo) # restituisce il seno dell'angolo
>>>print(math.cos(angolo) # restituisce il coseno dell'angolo
>>>print(math.acos(angolo) # restituisce arcocoseno dell'angolo
>>>print(math.asin(angolo) # restituisce arcoseno dell'angolo
>>>print(math.tan(angolo) # restituisce a tangente dell'angolo
>>>print(math.atan(angolo) # restituisce arcotangente dell'angolo
>>> y =print(math.cos(angolo+ math.pi/4)) # prende pgreco(pi) lo divide per 4 e, al quoziente, somma il valore di angolo. Infine calcola il coseno di quanto ottenuto e lo attribuisce come valore alla variabile y.
log(x), log(x, 10) # logaritmo naturale di x e logaritmo in base 10 di x
>>> y =print(math.exp(math.log(10))) # viene calcolato, mediante log, il logaritmo naturale in base e di 10 e poi tale valore viene posto come esponente di e. Il risultato viene assegnato alla variabile y.
>>>decibel = math.log10(30) # attribuisce a decibel il logaritmo di 30 in base 10
>>> print(decibel) # visualizza il valore della variabile decibel.
ALTRE FUNZIONI DEL MODULO math nella SHELL di PYTHON
>>> import math
>>> print (math.abs(-5)) # restituisce il valore assoluto di -5 e quindi 5
5
>>> print(math.round(7.89)) # restituisce il valore intero più prossimo e quindi 8
8
>>>print( math.max(5,6,234,9,23)) # restituisce il più grande e quindi 234
234
>>> print(math.radians(90)) # converte in radianti e ci dà il valore 1.57079632679..
1.57079632679
>>> print(math.degrees(6.28)) # converte in gradi e ci da il valore 359.81749...
359.81749
>>>print (math.min(2,33,1234,6)) # restituisce il numero più piccolo 2
2
-------------------------------------------------------------------
INDENTAZIONE CON PYTHON
LE STRUTTURE DI CONTROLLO
L'indentazione caratterizza il codice e viene applicata per rendere migliore la leggibilità dello stesso. Viene usata nelle strutture di controllo che consentono di eseguire, in modo selettivo, una singola istruzione o un blocco di istruzioni dopo i due punti.
Istruzioni condizionali
if, elif, else
Si prendono più percorsi in relazione al verificarsi di condizioni.
ciclo for e ciclo while
Indentazione nelle istruzioni di ciclo controllate dalle istruzioni break e continue.
break serve a forzare una immediata uscita dal ciclo e l'esecuzione continua con la prima istruzione fuori dal ciclo.
Es.
i =1
while True:
print(i)
i +=1
if (i >10):
break
Esecuzione script
1
2
3
4
5
6
7
8
9
10 # il ciclo infinito si interrompe a 10
================================
Es.
i = 0
while i < 10:
i += 1
if (i == 3):
continue
print(i)
Esecuzione script
1
2
# non viene mandato in stampa il 3 ma il ciclo termina al 10 previsto
4
5
6
7
8
9
10
La differenza fra ciclo for e ciclo while consiste nel numero di ripetizioni:
- nel for, si prevede siano un numero ben definito.
- nel ciclo while il numero delle ripetizioni non si conosce e, a limite, può essere infinito. In entrambi, comunque, l' espressione test viene valutata all'inizio, prima di entrare nel corpo del ciclo. Solo se la variabile, o espressione test, risulta vera(true) viene eseguito il blocco che segue i due punti; se invece è false si prosegue alla prima istruzione successiva al while.
L'indentazione viene usata anche quando si definisce una classe con le segg. istruzioni:
class MyClass: # si crea una classe di nome MyClass
x = 5 # si dichiara la variabile e si attribuisce un valore
p1 = MyClass() # oggetto p1 appartenente a MyClass
print(p1.x) # si stampa il valore dell'oggetto p1 appartenente a MyClass
Come si applica indentazione al codice: occorre avanzare di tre spazi vuoti, dopo i due punti, e dopo aver cliccato su Invio; scrivere poi il resto del codice. Vedere i due esempi
Le istruzioni if, elif, else e l'indentazione del codice
Es. 1 Controlla il valore di una grandezza fisica (temperatura) e comunica delle informazioni specifiche al problema.
Formalizzazione in codice Python
--------------------------------------------------------------------------------------
temperatura = 40 # dichiara e inizializza la variabile temperatura
count = 0 # inizializza il contatore
if temperatura >= 50: # esegue il test e si chiede se la temperatura > = 50
print("hai superato il limite") # salta questa istruzione perchè la temperatura=40
elif temperatura > 0: # esegue istruzione perchè la temperatura è >0 e stampa(hai superato 0 gradi)
count = count+1 # incrementa il contatore
print("hai superato zero gradi ", count," volta") # conta e stampa quante volte si supera 0 gradi
else :
print("siamo sotto zero") # se nessuna delle situazioni precedenti si è verificata allora stampa(siamo sotto zero)
//////////////////////////////////////////////////////////////////////////////////////////////////////
Es. 2 Controlla se il codice di accesso è corretto
Formalizzazione in Python
-----------------------------------------------------
codice = int(input("digita un numero a 4 cifre\n")) # acquisisce il codice da tastiera
if codice == 1234: # esegue test sulla variabile codice e verifica se coincide con quello digitato
print("codice esatto") # stampa le tre righe sottostanti in caso di coincidenza
print("accesso consentito")
print("sei un membro del team")
else:
print("accesso negato") # stampa(accesso negato) in caso di codice non coincidente
/////////////////////////////////////////////////////////////////////////////////////////////////////
Es. 3 Gioco indovina una coppia di numeri
(Sono usate due parole riservate: and, or
Formalizzazione dello script in codice Python
------------------------------------------------------------------------------------------
x,y = 6,3 # sono dichiarate due variabili intere e contemporaneamente si attribuisce un valore
numero1 = float(input("dammi primo numero\n"))
numero2 = float(input("dammi secondo numero\n"))
if numero1 == x and numero2 == y:
print("hai vinto")
elif numero1 == x or numero2 == y:
print("hai vinto metà premio")
else:
print("hai perso")
//////////////////////////////////////////////////////////////////////////////////////////////////////
Es. 4 Sconto progressivo in funzione della spesa effettuata
Formalizzazione in codice Python
----------------------------------------------------------------
print("Sconto progressivo in funzione del numero dei pezzi acquistati")
pe=int(input("dimmi se i pezzi sono fino a 3(5% di sconto), a 5(10% di sconto),a 10(20% di sconto) o piu di dieci(30% di sconto)\n"))
if pe<=3:
n1=float(input("dammi numero prodotti\n"))
cp=float(input("costo del pezzo\n"))
sco=(cp*5)/100
print ((sco*n1),("sconto in euro"))
pagare=(cp-sco)*n1
print("devi pagare",pagare,"euro")
print(cp*n1,"euro che avresti dovuto pagare")
elif pe<=5:
n2=int(input("dammi il numero dei prodotti\n"))
cp=int(input("costo del pezzo\n"))
sco=(cp*10)/100
print (sco*n2),"sconto in euro"
pagare=(cp-sco)*n2
print("devi pagare",pagare,"euro")
print (cp*n2),"euro che avresti dovuto pagare"
elif pe<=10:
n3=int(input("dammi il numero dei prodotti\n"))
cp=int(input("dammi il costo del pezzo\n"))
sco=(cp*20)/100
print (sco*n3),"sconto in euro"
pagare=(cp-sco)*n3
print("devi pagare",pagare,"euro")
print((cp*n3),"euro che avresti dovuto pagare")
else:
n4=int(input("dammi il numero dei prodotti\n"))
cp=int(input("dammi il costo del pezzo\n"))
sco=(cp*30)/100
print (sco*n4),"sconto in euro"
pagare=(cp-sco)*n4
print ("devi pagare",pagare," euro")
Il ciclo while e indentazione del codice
Es.1
Squadre = ["Juve","Milan","Inter","Roma","FeroletoDellaChiesa"]
i=0 # inizializza il contatore che serve a fermare il ciclo dopo aver ispezionato la lista
while i < 4 : # 0 =< i < 5 inizia a contare da zero, che corrisponde alla Juve, e termina al quinto elemento relativo a FeroletoDellaChiesa. In buona sostanza, mentre i è minore di 4, fai quanto compreso fra le graffe
print(Squadre[i]) # stampa una squadra dietro l'altra
i=i+1 # incrementa il contatore
# lo script, messo in esecuzione dopo averlo salvato con estensione .py(es. squadre.py), stampa tutte le squadre contenute nella lista.
////////////////////////////////////////////////////////////////////////
Es.2
ciao
ciao
ciao
ciao
ciao
ciao
////////////////////////////////////////////////////////////////////////
Il Ciclo for annidato e indentazione del codice
Es.1 di ciclo for Mette nella lista res tutti gli elementi concatenati delle stringhe
Formalizzazione dello script in Python
-----------------------------------------------------------------
res=[] # crea una lista vuota create an empty list
for x in "pino": # la x ispeziona la stringa pino
for y in "gino" : # y ispeziona la stringa gino
res.append(x+y) # mette in res ogni elemento della stringa pino concatenato, con il +, a ogni elemento della stringa gino.
print(res) # stampa il contenuto di res.
['pg', 'pi', 'pn', 'po', 'ig', 'ii', 'in', 'io', 'ng', 'ni', 'nn', 'no', 'og', 'oi', 'on', 'oo']
////////////////////////////////////////////////////////////////////////
Es.2 di ciclo for Somma ogni elemento della lista con ogni elemento di b e comunica i risultati
Formalizzazione dello script in Python
------------------------------------------------------------------
a=[4,5]
b= [5,8]
for i in a:
for c in b:
x=i+c
print(x) # somma ogni elemento di a con ogni elemento di b e restituisce la sequenza..
----------
9
12
10
13 /////////////////////////////////////////////////////////////////////////////////////////////////////
Es. 3) di ciclo for Stampa fra un minimo e un massimo con intervallo di 2
Formalizzazione dello script in codice Python
-----------------------------------------------------------------
for x in range(9,20,2):
print(x) # stampa da 9 a 20 con intervallo di 2
------- ----
9 11 13 15 17 19
////////////////////////////////////////////////////////////////////////
Es. 4) di ciclo for Stampa i numeri da 0 a 9 in verticale
Formalizzazione in codice Python
----------------------------------------------------------------
for x in range(10):
print(x) # stampa i numeri da 0 a 9. La variabile x assume 10 valori a partire da zero.
---------
0
1
2
3
4
5
6
7
8
9
////////////////////////////////////////////////////////////////////////
Es. 5) di ciclo for Stampa i caratteri della stringa in verticale
Formalizzazione in codice Python
-----------------------------------------------------------------
a = "pattinaggio" # definisco la stringa
n = 0 # inizializzo il contatore
for x in a:
print(x,n) # stampa ogni singolo valore della stringa insieme ad ogni singolo valore del contatore n
n = n+1 # incrementa il contatore
---------
p 1
a 2
t 3
t 4
i 5
n 6
a 7
g 8
g 9
i 10
o 11
////////////////////////////////////////////////////////////////////////
Es. 6) di ciclo for
Tabellina del 4
Formalizzazione in codice Python
-----------------------------------------------------------------
a=4
for x in range(10):
print(a," per",x+1," =",a*(x+1))
4 x 1 fa 4
4 x 2 fa 8
4 x 3 fa 12
4 x 4 fa 16
4 x 5 fa 20
4 x 6 fa 24
4 x 7 fa 28
4 x 8 fa 32
4 x 9 fa 36
4 x 10 fa 40
////////////////////////////////////////////////////////////////////////
Es. 7) di ciclo while
Data una sequenza di numeri sommare quelli maggiori di un numero qualsiasi.
Formalizzazione dello script in codice Python
-----------------------------------------------------------------
print("dammi una sequenza di numeri e sommo quelli maggiori di 20")
k=3
so=0
while k!=0:
n=int(input("dammi un numero\n"))
if n >20:
so=so+n
print(so,"parziale somma numeri maggiori di 20")
else:
print("non sommabile")
print(so," numero da non ")
---------------------------------------------------------------
GLI OPERATORI CON PYTHON E LA LORO PRECEDENZA
[] Sequenza di elementi numerati a partire dallo zero detto ARRAY
** Elevazione a potenza
* / // % Moltiplicazione, divisione, resto della divisione, resto
+ - Addizione e sottrazione
< <= >= != minore, minore_uguale, maggiore_uguale, diverso
not boolean operatore negazione logica
or boolean operatore somma logica
and boolean operatore prodotto logico
Le Espressioni in Python
All'interno di una espressione gli operandi possono rappresentare: costanti(pgreco), variabili (h altezza di un triangolo), funzioni.
I COMMENTI AL CODICE CON PYTHON.
# Il mio primo programma con Python. Riga di commento che non viene eseguita. Si usa il simbolo cancelletto e solo all'inizio.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LE LISTE CON PYTHON
Es.1 di ciclo_for su una LISTA
N.B. Un lista e' semplicemente una sequenza di numeri e/o caratteri alfanumerici, separati da virgole, lunga quanto si vuole e riconoscibile perchè gli stessi sono contenti fra due parentesi quadre.
Si suppone di avere una lista del tipo a=[1,6,4,8,23] e si vuole individuare il massimo e il minimo in in essa contenuti.
Si usa il ciclo for, per ispezionare la lista, alla ricerca di minimo e massimo di n numeri che il linguaggio riconosce come min e max. Ecco come appare l'esecuzione dello script in ambiente di sviluppo QEdit.
N.B.
Le liste vengono indicizzate attribuendo al primo elemento il valore 0 e poi a seguire.
Le liste possono contenere sia numeri che stringhe.
Esempi di gestione delle LISTE
Es.1
>>>a=["Torino","Milano","126","8","giuseppe@libero.it"] # crea lista a
>>>print(a[1]) # stampa la stringa Milano
>>>print(a[4]) # stampa ila stringa giuseppe@libero.it
>>>a.append("Genova") # inserisce Genova nella lista
>>>print(a) # appare la lista Torino, Milano, 126,8, giuseppe@libero.it, Genova
>>>print(a.count("dentista") # risponde con 0 perchè non trova dentista nella lista
0
>>>print(a.reverse() # rovescia la lista
["giuseppe@libero.it","8", "126","milano","torino"]
>>>print(len(a) # conta gli elementi della lista
4
>>>a.insert(3,"pino") # inserisce pino nella lista alla posizione 3
>>>print(a) # restituisce la lista con pino nella posizione 3
["giuseppe@libero.it","8", "126","pino","milano","torino"]
////////////////////////////////////////////////////////////////////////
>>>numeri = [2,4,55,6,123] # Lista piena con valori numerici
>>>for i in range(len(numeri)) : # ciclo per ispezionare i numeri dentro array
>>> numeri[i] = i*i # effettua prodotto di ogni elemento per se stesso
print(numeri) #stampa il risultato del prodotto
>>>numeri.append("100") # fuori dal ciclo appende il numero 100 alla lista di numeri
2,4,55,6,123,100
////////////////////////////////////////////////////////////////////////
Es. 2 a = ["gino","151","milano","56"] # crea una lista di 4 elementi
>>> print(a[1]) # stampa 151
151
////////////////////////////////////////////////////////////////////////
>>>print(a[3]) # stampa 56
56
////////////////////////////////////////////////////////////////////////
>>> print(a[2]) # stampa milano
milano
////////////////////////////////////////////////////////////////////////
>>> a.append("genova") # aggiunge genova alla lista
torino, 151, milano, 56, genova
////////////////////////////////////////////////////////////////////////
Es.3
>>>a = ["torino","genova","milano","padova","trieste"] # crea lista di 5 elementi
>>>a.sort()
>>>print(a) # in ordine alfabetico: genova, milano, padova, torino,trieste
///////////////////////////////////////////////////////////////////////
>>>del a[3] # cancella elemento che occupa la quarta posizione cioè padova
////////////////////////////////////////////////////////////////////////
print(a.index("torino")) # restituisce il numero ordine di torino e quindi 0
///////////////////////////////////////////////////////////////////////
Es.4
>>>a= [12,5,234,6,87,57,1567]
>>>a.sort()
>>>print(a) # mette in ordine crescente 5 6 12 57 87 234 1567
>>>a.del() # cancella tutto il contenuto array
>>>del a[3] # cancella quarto elemento
////////////////////////////////////////////////////////////////////////
Es.5
>>>a= [12,5,234,6,87,57,1567] # crea lista
>>>a.append(1000) # uso parola riservata append per appendere elemento alla lista
>>>print(a) # aggiunge il 1000 alla lista che diventa a= [12,5,234,6,87,57,1567,1000]
12,5,234,6,87,57,1567,1000
////////////////////////////////////////////////////////////////////////
>>>print(a.index("234"))
2 # restituisce 2 in quanto indice del posto che occupa nella lista.
////////////////////////////////////////////////////////////////////////
>>>del a[234]
12,5,6,87,57,1567 # elimina elemento 234 dalla lista
////////////////////////////////////////////////////////////////////////
Es. 6
>>>a = [1,2,3]
>>>b=sum(a) # uso la funzione sum per sommare tutti gli elementi della lista a.
>>>print((b) ," somma gli elementi lista") # da come risultato
6 somma degli elementi lista
////////////////////////////////////////////////////////////////////////
Es.7
k=4 # contatore che fissa numero elementi delle liste
a=[] # lista vuota
b=[] # lista vuota
while k>1: # ciclo infinito se k>1
num1=int(input("dammi un numero della prima lista\n"))
num2=int(input("dammi un numero della seconda lista\n"))
a.append(num1) # mette num1 in a
b.append(num2) # mette num2 in b
k=k + 1 # decrementa il contatore k
if (sum(a)==sum(b): # confronta le somme degli elementi delle liste
print(" liste uguali") # comunica uguaglianza liste
print (a," lista a")
print (b," lista b")
else:
print("liste sono diverse") # comunica disuguaglianza liste
a.sort()
print(a,"lista a in ordine crescente")
b.sort()
print(b,"lista b in ordine crescente")
/////////////////////////////////////////////////////////////////////
Es.8
a=[] # crea una lista vuota
Q=2 # variabile di stop
count=0 # inizializza il contatore
while Q != 0:
num=float(input ("dammi numero\n"))
a.append (num)
coun t= count+1
print(sum a,"io sono la somma degli elementi della lista")
print(sum (a/count,"media della lista")
print(a [0],"io sono il primo elemento della lista")
////////////////////////////////////////////////////////////////////////
Es.9
CREA UNA LISTA DI N ELEMENTI E NE STAMPA IL CONTENUTO
i=3 # contatore inizializzato a 3 ma può assumere un valore qualsiasi
a=[] # creo una lista vuota
while i > 0: # creo ciclo controllato dal contatore i
nome = input ("dammi un nome\n")
i=i-1 # decremento contatore
a.append (nome) # metto il nome acquisito nella lista a,
print(a) # stampo lista completa.
print(a [0]," sono il primo elemento") # stampa i singoli componenti la lista.
print(a [1],"sono il secondo elemento")
print(a [2],"sono il terzo elemento")
////////////////////////////////////////////////////////////////////////
Es.10
CREA UNA LISTA IN MODO SEMPLICE
Formalizzazione in codice Python
-------------------------------------------------------------------
docenti=[] # crea una lista vuota che chiamo docenti[]
a=input("dammi i dati di a\n") # acquisisco un docente che chiamo a
docenti.append(a) # mette a dentro la lista docenti.
b=input("dammi i dati di b\n") # acquisisco altro docente che chiamo b
docenti.append(b) # mette b dentro la lista docenti.
c=input("dammi i dati di c\n") # acquisisce altro docente che chiamo c
docenti.append(c) # mette c dentro la lista docenti.
print(docenti) # stampa la lista dove appariranno i nomi dei docenti con eventuali altre indicazioni.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
NUMPY & PYTHON
NUMPY come supporto a PYTHON per la GESTIONE degli ARRAY e, quindi, per attività di MACHINE LEARNING
NumPy è un modulo importabile in ambiente windows per Python e consente di operare, anche e soprattutto, con gli array che, a loro volta, trovano largo impiego nella Scienza dei Dati.
Viene usato anche per applicazioni nel dominio dell'algebra lineare e non solo.
Python presenta una certa lentezza nell'elaborazione degli array(liste); NumPy elabora gli stessi con una velocità anche parecchie decine di volte più elevata(ha un modo diverso per il loro archivio in memoria). Tutto questo incide molto sulla velocità di elaborazione ed esecuzione dei dati quando gli stessi sono costituiti da array molto grandi o da database di grosse dimensioni.
Installazione di NumPy
Se hai Python3.5 e PIP già installati su un sistema, l'installazione di NumPy è molto semplice.
Per installare NumPy si deve accedere al prompt dei comandi di windows e digitare le iscrizioni:
C: \ Users \User Name> pip install numpy
Esempio completo
import numpy as np
lista = numpy.array ([2,4,6,8,10,12]) # crea una lista, o array, con un numero teoricamente infinito di elementi e possono essere associati a qualsiasi evento rappresentabile con numeri o stringhe.
print(lista) # visualizza gli elementi dell'array
2 4 6 8 10 12
print(type(lista)) # indica la tipologia di oggetti che si stanno analizzando
Dimensioni negli array
La dimensione negli array da una indicazione di quanto sia grande e, in buona sostanza, da quanti elementi è costituito.
Quando un array è nidificato vuol dire che risulta costituito da almeno due elementi che a loro volta sono degli array.
Array 0-D Crea un array 0-D con valore 167
import numpy as np
persone = np.array[167]
print(persone, " le persone presenti")
Restituisce
167 le persone presenti
__________________________
E' possibile creare array con elementi di tipo stringa:
import numpy
frutta =numpy.array(['banana','ciliegia','pesca'])
print(frutta)
print(frutta[0])
Restituisce
banana ciliegia pesca
banana
__________________________
Array 1-D
Costituito da elementi tipo O-D ed è chiamato array unidimensionale o 1-D.
Questi sono gli array più comuni e possono essere costituiti da moltissimi elementi.
Esempio
Crea un array 1-D contenente i valori 2,4, 6,8,10,14:
import numpy as np
numeri pari = np.array ([2,4,6,8,10,12,14]) # array di numeri pari
print(nmeripari)
___________________________
Matrici 2-D
Costituito da elementi di tipo 1-D ed è chiamato array 2-D.
Esempio
Creare un array 2-D contenente due array:
import numpy as np
paridispari = np.array ([[2,4,6,8,10], [1,2,3,5,7,11]])
print(paridispari)
__________________________________
Array 3D
Costituito da elementi di tipo 2-D ed è chiamato array 3-D.
Es. Creare un array 3D con due array 2D, entrambi contenenti due array con i valori:
import numpy as np
arraytred = np.array ([[[6,5,3,13], [4,55,7,45]], [[86,33,8,9], [4,7, 9, 11]]])
print(arraytred)
Come accedere a un singolo elemento dell'array
Accedi al terzo elemento del secondo array del primo array:
import numpy as np
accedere = np.array ([[[1, 92, 3], [44, 51, 600]], [[7,88, 9], [105, 11,312]]])
print(accedere[0, 1, 2])
Come funziona:
print([0, 1, 2]) stampa il valore 600.
In quanto: Il primo numero rappresenta la prima dimensione, che contiene due matrici:
[[1, 92, 3], [44, 51, 600]] e: [[7, 88, 9], [105, 11,312]]
Poiché abbiamo selezionato 0, ci rimane il primo array:
[[1, 92, 3], [44, 51, 600]]
Il secondo numero rappresenta la seconda dimensione, che contiene anche due matrici:
[1, 92, 3] e [44, 51, 600]
Poichè abbiamo selezionato 1, ci rimane il secondo array:
[44, 55,60]
Il terzo numero rappresenta la terza dimensione, che contiene tre valori:
44 51 600
avendo selezionato 2, finiamo con il terzo valore:
Restituisce 600
____________________________
Se al posto dei numeri ci fossero delle stringhe:
import numpy as np
accedere = np.array ([[['pino', 'gino', 'rino'], ['mario', 'giorgio', 'andrea']], [['carlo', 'antonio', 'rita' ], ['marco', 'michele', 'giacomo']]])
print(accedere[0, 1, 2])
Restituisce andrea
_________________
Come TAGLIARE uno o più elementi dell'array
Dal secondo elemento, tagliare gli elementi dall'indice 1 all'indice 4 (non incluso):
import numpy as np
taglia = np.array ([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(taglia[1, 1: 4])
Restituisce [1, 2, 3, 4, 5] [6, 10]
/////////////////////////////////////////////////////////////////////////////////////////////////////
STATISTICA(MEDIANA, DEVIAZIONE STANDARD, VARIANZA)
STATISTICA VIDEO
MACHINE_LEARNING VIDEO
Coloro che si occupano di MachineLearning non possono fare a meno di usare delle funzioni statistiche particolari: mediana, media, moda, deviazione standard, percentile, varianza. Tutte sono implementate dal modulo numpy e facilmente utilizzabili, con poche righe di codice, senza dover fare riferimento alla formule specifiche.
Senza il supporto di numpy siamo costretti a scrivere prima lo script in codice Python per poter usare tutte le funzioni, statistiche e non, che ci servono.
Si può accedere direttamente da o.s. Android(tablet o smartphone) ad un sito che consente di editare, testare e poi eseguire del codice, anche in Python, usando tutti i moduli di cui abbiamo bisogno. I moduli mancanti vengono installati automaticamente.
Il sito di rif.to è il seguente: www.REPL.IT
Occorre la registrazione fornendo nickname e password; ne vale la pena!
L' interfaccia che appare è quella sottostante; dopo aver editato il codice, relativo al generico problema, si avvia la sua esecuzione cliccando sul pulsante verde.
Per evidenziare tali aspetti, realizziamo uno script in Python per il calcolo di Media, Mediano, Varianza, DeviazioneStandard e lo confrontiamo con il codice relativo al modulo numpy.
Es. Abbiamo un array relativo al peso degli studenti di una classe costituita da n=25 persone, ma possono essere anche molti di più, e vogliamo calcolare i parametri statistici: media, varianza, deviazione standard, valore massimo e minimo....
Varianza, DeviazioneStandard, Media, Mediano, Percentile.
# codice in ambiente Python 3.6.5
n = 25 // sono 25 gli studenti della classe
b = [] // crea array vuoto per memorizzare dati relativi al problema
peso = [60, 80,80,60,70,85,70,65,60,65,60,58,70,80,75,65,60,55,60,70,70,70,70,60,65]
for x in peso:
media = sum (peso) /n
va = (x-media) **2
b.append(va)
mp = (80*3+70*7+65*4+55*1+60*7+85*2+58*1)/25
print(sum(b))
print(media, " media elementi array")
print(min(peso), " valore minimo array" )
print(max(peso), " valore massimo array" )
print(sum(b)/n, " varianza array")
print((sum(b)/n)**0.5, " deviazione Standard media ponderata su array da 25 elementi")
print(mp, " media ponderata su array da 25 elementi")
____________________
# codice con modulo NumPy in ambiente www.REPL.IT
import numpy
from scipy import stats // modulo necessario per calcolare la moda
peso = [60, 80,80,60,70,85,70,65,60,65,60,58,70,80,75,65,60,55,60,70,70,70,70,60,65]
moda = stats.mode(peso) //metodo per calcolare la moda
media = numpy.mean(peso) // il valore medio
mediano = numpy.median(peso) // valore centrale 9
percentile = numpy.percentile(peso, 27)
DevStandard = numpy.std(peso) // distanza media di tutti i valori dalla media
varianza = numpy.var(peso)
print(media, " valore medio")
print (mediano, " valore mediano")
__________________________
Esecuzione in REPL.IT
// Appare evidente che con il modulo Numpy non scriviamo del codice in puro Python ma usiamo lo stesso modulo, insieme a istruzioni e parole tipiche del linguaggio( print, import, from, random..), per accedere a tutti i metodi che lo stesso mette a disposizione. È evidente che va prima importato insieme a tutti gli altri che riteniamo necessari per la nostra applicazione.
///////////////////////////////////////////////////////////
LA DISTRIBUZIONE DEI DATI
LA DISTRIBUZIONE UNIFORME
Nel mondo reale, fisico e non, può essere difficile e oneroso raccogliere grandi quantità di dati da elaborare per i motivi più disparati.
Se, ad esempio, stiamo raccogliendo dei dati relativi ad un sensore di temperatura che fornisce una tensione variabile fra 0Volt e 5V in modo del tutto aleatorio, cioè non correlato ad altre grandezze, e questo viene fatto ogni minuto per un intero anno, risulta evidente che il relativo array di dimensioni 365x24x60 = 525600 comincia ad essere molto grande. Si deve considerare, infine, che dovremmo aspettare un anno per avere l'array completo. L' utilità di ricorrere a questi metodi è proprio questa: bypassare il problema reale e simularlo con una generazione i dati di tipo random, quindi artificiale, allo scopo di poter effettuare, nell'immediato, degli studi di tipo previsionale.
CODICE PER GENERARE IN MODO RANDOM UN SET DI BIG DATA RELATIVO ALLO SPECIFICO PROBLEMA.
import numpy
import matplotlib.pyplot as plt // modulo per rappresentare graficamente i risultati
Temperatura = numpy.random.uniform (0.0, 5.0, 5256) // togliamo 2zeri per semplificare
plt.hist (Temperatura , 5). // usa metodo per creare istogramma e il numero 5 rappresenta quante sono le barre(la prima il numero di valori per 0 < Temperatura <1 e a seguire)
plt.show () // mostra istogramma
//////////////////////////////
LA REGRESSIONE LINEARE CON NUMPY E PYTHON
print(" La regressione lineare utilizza la relazione tra i punti dati per tracciare una linea retta attraverso tutti loro. Questa riga può essere utilizzata per prevedere i valori futuri. Come si procede? Python ha metodi per trovare una relazione tra i punti dati e per tracciare una linea di regressione lineare. Nell'esempio seguente, l'asse x rappresenta i voti e l'asse y rappresenta le ore di studio impiegate per sostenere ogni singolo esame. Il termine regressione viene utilizzato quando si tenta di trovare la relazione tra le variabili e questo non è sempre possibile; nel nostro caso lo è in quanto da una osservazione degli array si nota che vi è una certa correlazione fra le ore di studio e i voti ottenuti, più ore di studio hanno comportato un voto generalmente più alto. L'obiettivo finale può essere quello di alzare la media a 27, dato che è a 26.5, allo scopo di ottenere la borsa di studio. Dobbiamo trovare il numero di ore di studio ottimali per portare la media al valore prefissato")
import numpy
import matplotlib.pyplot as plt
from scipy import stats
voti = [26,28,30,25,22,28,30,27,26,24,29,25,25,29,30,20,27,26,28,25,24,30]
ores = [45,58,60,48,35,65,66,54,53,54,64,50,50,62,69,40,58,55,59,44,50,66]
media=numpy.mean(voti)
print("RISULTATI IN USCITA ")
print("media dei voti =" , media)
slope, intercept, r, p, std_err = stats.linregress (voti, ores)
def myfunc (voti):
return slope * voti + intercept
mymodel = list (map(myfunc, voti))
plt.scatter (voti, ores)
plt.plot(voti, mymodel)
plt.show()
# INTERPRETAZIONE DELLO SCRIPT
# vengono importati i moduli necessari: import matplotlib. pyplot as plt e from scipy import stats. Si creano poi i due array relativi a voti[] e ores[]
# si esegue un metodo che consente di ottenere due grandezze necessarie per poter operare con la regressione lineare:pendenza, intercetta, r, p, std_err = stats.linregress (voti, ores)
# Viene creata una funzione che utilizza i valori ottenuti per generare un nuovo valore il quale rappresenta dove verrà posizionato sull'asse y(ores) il corrispondente valore di x(voti) :
# def myfunc (voti):
# pendenza di ritorno * voti + intercept
# Esegui ciascun valore dell'array voti tramite la funzione. Ciò comporterà un nuovo array con nuovi valori per l'asse y(ores):
# mymodel = list (mappa (myfunc, voti))
# Disegna il grafico a dispersione originale:
# plt.scatter (voti, ores)
# Disegna la linea di regressione lineare:
# plt.plot (voti , mymodel)
# Visualizza i risultati
plt.show ()
////////////////////////////////////////////////////////////////
LE TUPLE CON PYTHON
I dati contenuti in una tupla non possono essere modificati e devono essere racchiusi fra delle parentesi tonde.
Es.1
#Per creare una tupla
PrimaTupla = ("Milano ", "Torino", "Genova")
print(PrimaTupla)
Si può accedere agli elementi di una tupla indicando, fra due parentesi quadre, il numero indice di tale elenco partendo dal valore 0
Es.2
Stampa il secondo elemento nella tupla:
print(PrimaTupla[1]
#Indicizzazione negativa
Se si usa indicizzazione negativa vuol dire che si parte da ultimo elemento della T.
Es.3
Per stampare ultimo elemento della tupla:
print(PrimaTupla[-1])
#Gamma di indici
Se siamo interessati a un intervallo di indici occorre impostare da quale elemento si parte e dove si vuole arrivare.
In questo caso ci viene fornita una nuova tupla contenente i soli elementi specificati.
Es.1
#Restituisce il terzo, il quarto e il quinto elemento:
PrimaTupla = ("Milano ", "Torino", "Genova", "Ancona"," Firenze","Palermo")
print(PrimaTupla[2: 5])
#Nota: la ricerca inizia dall'indice 2 (incluso Genova) e termina all'indice 5 (non incluso Palermo ).
#Gamma di indici negativi
Come prima, occorre specificare gli indici negativi se si intende partire dalla fine della tupla.
Es.2
#In questo esempio vengono restituiti gli elementi dall'indice -3(incluso) all'indice -1 (escluso)
print (PrimaTupla[-3:-1])
#Modifica i valori di tupla
Essendo la tupla immutabile, è unica possibilità che abbiamo è quella di convertirla in un elenco, sul quale si vanno a fare le modifiche, e poi la si riconverte in un nuova tupla.
Es.3
#Convertire la tupla in un elenco per poterla modificare:
PrimaTupla = ("Milano ", "Torino", "Genova", "Ancona"," Firenze ","Palermo")
PrimaTupla=list(x)
PrimaTupla[1]=Bologna
print(PrimaTupla)
Il ciclo for può essere usato per ispezionare la T. e stampare gli elementi.
Es.4
#Scorri gli articoli e stampa i valori:
PrimaTupla = ("Milano ", " Torino", "Genova", "Ancona"," Firenze"," Palermo" )
for x in PrimaTupla:
print(x)
# Controlla se "Bologna " è presente nella tupla
Es.5
if "Bologna " in PrimaTupla:
print("Sè la città di," Bologna ", è nella tupla delle città ")
Lunghezza tupla: quanti elementi contiene?.
Come in altri linguaggi si usa il metodo len().
Es.6
# Stampa il numero di elementi nella tupla:
PrimaTupla = ("Milano ", "Torino", "Genova, "Ancona","Firenze","Palermo")
print(len (PrimaTupla))
Aggiungi elementi
#Una volta creata una tupla, non è possibile aggiungere elementi ad essa. Le tuple sono immutabili.
Crea tupla con un solo elemento :
# Per creare una tupla con un solo oggetto, devi aggiungere una virgola dopo l'elemento, altrimenti Python non lo riconoscerà come tupla.
Es.7
PrimaTupla = ("Bologna")
Rimuovi elementi
Nota: non è possibile rimuovere elementi in una tupla ma solo eliminare tutta la T
Es.8
#La parola chiave del può eliminare completamente la T. usando la parola riservata delete:
delete PrimaTupla
Congiunzione di due tuple usando il segno +
Es.9
#Unisciti a due tuple:
tuple1 = ("maria", "giovanni", "andrea")
tuple2 = (1, 2, 3)
tuple3 = tuple1 + tuple2
print(tuple3)
Il costruttore di tuple ()
# Risulta anche possibile usare il costruttore tuple () per creare una tupla.
Es.10
Utilizzo del metodo tuple () per creare una tupla:
PrimaTupla = tuple (("" bologna ","torino "," milano ")) # si nota la presenza delle doppie parentesi tonde
-----------------------------------------------------------------------------------------------
ALCUNI ESEMPI DI CICLO FOR IN ZIP MOLTO EFFICACI.
Es.1
DOPPIO ARRAY GESTITO IN MODO ELEGANTE DA UN CICLO FOR IN ZIP CHE INCASTRA I NUMERI PARI E DISPARI E LI STAMPA TUTTI DA 1 A 10
pari = [1,3,5,7,9]
dispari = [2,4,6,8,10]
for parinum, disparinum in zip(pari, dispari):
print(parinum)
print(disparinum)
Esecuzione dello script
1 2 3 4 5 6 7 8 9 10
Es.2
SOMMA GLI ELEMENTI CON LO STESSO INDICE MA MANTIENE INALTERATA LA DIMENSIONE ARRAY.
x = [1, 2, 3, 4]
y = [4, 5, 6, 7]
z = []
for i, j in zip(x, y):
z.append(i + j)
print(z)
#Esecuzione dello script
5 7 9 11 # genera un array zippato:somma gli elementi con lo stesso indice e lascia invariato il loro numero.
//////////////////////////////////////////////////
Una funzione lambda è una piccola funzione insita nel linguaggio ed è anche una reserved word dello stesso.
Accetta qualsiasi numero di argomenti, ma può avere solo una ben definita. espressione.
Es.1
Una funzione lambda che aggiunge 8 al numero passato come argomento e stampa il risultato:
x = lambda a: a + 8
print(x (5)) # risultato 13
Le funzioni Lambda possono accettare svariati argomenti:
Es.2
Una funzione lambda che moltiplica l'argomento a con l'argomento b e stampa il risultato:
y = lambda a, b: a * b
print(y (3,10)) # risultato 30
Es.3
Una funzione lambda che somma l'argomento a, b e c e stampa il risultato:
y = lambda a, b, c: a + b + c
print(x (20,30,10)) # risultato 60
Es.4
def auto(n):
return lambda a : a * n
doppio=auto(2)
triplo=auto(3)
print(doppio(22)) # risultato 44
print(triplo(22)) # risultato 66
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DATI DI INPUT
ACQUISIRE I DATI DA TASTIERA con:
h=int(input("dammi altezza triangolo\n")) # per le variabili intere
b=float(input("dammi base del triangolo\n")) # per le variabili in virgola mobile
nome=input("dimmi il tuo nome\n"); # per le variabili di tipo string
E' opportuno rendere il codice flessibile e quindi adattabile a tutti i problemi dello stesso tipo, indipendentemente dal valore intrinseco delle variabili; se le acquisiamo subito, è possibile utilizzarle all'interno del problema specifico, qualunque sia il loro valore. Python lo fa in modo eccellente ed immediato con il seguente codice:
b=float(input("dammi la base del triangolo\n"))
premendo invio appare un messaggio di dialogo, che si chiama prompt e nel quale appare la stringa contenuta fra la virgolette dammi la base triangolo; dopo aver digitato un numero qualsiasi(es, 5), tale valore viene attribuito alla variabile b e, da quel momento in poi, può essere utilizzato all'interno del codice. Tale valore può cambiare nel corso dell'esecuzione dello script.
In buona sostanza, in Python l'apparizione di un prompt e la lettura del dato esterno, inserito da tastiera, sono combinate in una sola operazione; la stessa istruzione mi fa apparire prima il messaggio fra le virgolette e, subito dopo aver digitato qualcosa, questo valore viene posto all'interno della variabile.
I casi possibili sono in realtà sono tre:
1) nel caso in cui si voglia acquisire un numero in virgola mobile il codice diventa
b=float(input("dammi la base triangolo\n")) # acquisisce la base da tastiera
temperatura=float(input("dammi la temperatura ambiente da controllare\n")) # acquisisce la temperatura con valore in virgola mobile
---------------------------------------------------------
2) nel caso in cui si voglia acquisire un numero intero il codice diventa..
b=int(input("dammi la base triangolo\n")) # acquisisce la base in caso di suo valore intero
---------------------------------------------------------
3) nel caso in cui si voglia acquisire una stringa allora il codice diventa....
nome = input("dammi il tuo nome\n") # acquisisce la stringa relativa al nome immesso.
o in alternativa
nome = input("dammi il tuo nome\n") # acquisisce la stringa relativa al nome immesso.
-------------------------------------------------------------------------------------
CODIFICARE CON PYTHON IL GENERICO PROBLEMA.
Ci si avvale di strumenti tipici della programmazione strutturata di tipo top/down.
Dopo attenta lettura del testo, occorre procedere alla stesura dello pseudocodice che consiste in:
individuare le variabili in ingresso del problema con le quali si andrà ad operare.
individuare le variabili di uscita che dovranno essere determinate al fine di rispondere ai quesiti proposti.
individuare eventuali costanti e attribuire loro il relativo valore ( PGRECO=3.14, SCONTO_PERCENTUALE=30, CAMBIO_EURO_DOLLARO=1.116 ).
sviluppare l'esercizio in relazione a quelle che sono le equazioni o relazioni che lo governano e che andranno risolte, come di norma. Infine eseguire i calcoli.
Comunicare i risultati con la parola riservata print(" "). Es. print (areaT," area del triangolo")
Controllare i risultati usando la calcolatrice.
----------------------------------------------------
ESEMPIO DI BASE PER CODIFICA IN CODICE PYTHON
1) Problema proposto:
Calcolo area di un triangolo
Modo di procedere per lo stesura dello pseudocodice:
individuo le due variabili del problema che sono la base e l'altezza e che per comodità chiamo b e a.
individuo le grandezze in uscita e in particolare, nel nostro caso, la sola area che chiamo per comodità areaT.
osservo che non esistono costanti da dichiarare per risolvere il problema specifico.
mi avvalgo della formula relativa all'area del triangolo(areaT = (b*a)/2 e la applico con riferimento alle due variabili di entrata che ho dovuto preventivamente acquisire.
eseguo i calcoli, a parte, e controllo se i risultati sono concordi con quelli previsti.
Analisi del problema:
Si tratta di un caso molto semplice in cui l'unica cosa possibile da fare è quella di acquisire le variabili di entrata b e a per poi applicare la formula risolutiva. \nIn questo modo possono essere affrontati gran parte dei problemi lineari come questo.
-----------------------------------------------------------------------------------------
Specifiche funzionali al problema
Grandezze in entrata o variabili del problema Grandezze in uscita
b base del triangolo areaT area del triangolo
a altezza del triangolo
Formalizzazione dello script relativo al problema in codice Python
------------------------------------------------------------------------------------------------------------
1 # Calcolo AreaTriangolo.
2 b=float(input("dammi la base triangolo\n")) # acquisisce la base da tastiera
3 a=float(input("dammi altezza del triangolo\n")) # acquisisce altezza da tastiera
4 areaT=(b*a)/2 # calcola area triangolo
5 print areaT," area del triangolo" # comunica il risultato relativo al valore di areaT
Analisi del codice:
Sezione dichiarativa e di acquisizione
-La prima riga rappresenta l'intestazione dello script, pertinente con il tipo di applicazione.
-Con la seconda e terza riga vengono acquisite le variabili del problema.
Sezione esecutiva.
-La quarta riga calcola area del triangolo.
Sezione emissione risultati.
-La quinta riga comunica il risultato con la parola riservata print."\n" La virgola consente di concatenare il valore numerico di areaT con la stringa "area del triangolo".
------------------
2) ESEMPIO DI BASE PER CODIFICA IN CODICE PYTHON
2^ Problema proposto:
Calcolo area e circonferenza del cerchio
Modo di procedere per lo stesura dello pseudocodice:
individuo unica variabile del problema, il raggio r del cerchio.
individuo la costante PGRECO necessaria per il calcolo sia dell'area che della circonferenza.
individuo le grandezze in uscita che sono areaCerchio e circoCerchio.
osservo che esiste una costante da dichiarare(PIGRECO) per risolvere il problema specifico.
mi avvalgo della formula relativa all'area del cerchio(areaCerchio = PGRECO*raggio**2) e di quella relativa alla circonferenza(circoCerchio=2*PGRECO*raggio) e le applico con riferimento alla variabile raggio che devo preventivamente acquisire.
eseguo i calcoli con una calcolatrice e mi segno i risultati.
Analisi del problema:
Si tratta di un caso molto semplice in cui l'unica cosa possibile da fare è quella di acquisire l'unica variabile del problema che è il raggio del cerchio.
Devo definire la costante PGRECO e assegnare ad essa il relativo valore.
Si applicano, infine, le due formule relative al calcolo dell'area e della circonferenza del cerchio. Si comunicano i risultati ottenuti.
Specifiche funzionali al problema
--------------------------------------------------------------------------
Grandezze in entrata o variabili del problema Grandezze in uscita
raggio raggio del cerchio areaCerchio
PGRECO costante di valore noto circoCerchio circonferenza
Formalizzazione dello script in codice Python -------------------------------------------------------------------
1 print("Calcolo area circonferenza del cerchio")
2 import math # importazione del modulo matematico
3 PGRECO =3.14 # dichiarazione e assegnazione della costante
4 raggio = float(input("dammi il raggio\n")) # acquisisce, in virgola mobile, il raggio da tastiera
5 areaCerchio = math.round(PGRECO*raggio**2) # calcolo area con valore arrotondato
6 circoCerchio = math.round(2*PGRECO*raggio) # calcolo circonferenza
7 print("Area del cerchio =", areaCerchio, " Circonferenza del Cerchio = ", circoCerchio) # comunica i risultati, su una sola riga, concatenando con la virgola
-----------------------------------------
Analisi del codice:
Sezione dichiarativa
-La prima riga rappresenta l'intestazione dello script
Sezione importazione moduli
-Con la seconda riga viene importato il modulo matematico.
Sezione dichiarativa e di acquisizione
-Con la terza si definisce la costante e si assegna il valore.
-Con la quarta si acquisisce la variabile del problema.
Sezione esecutiva.
-Con la quinta e sesta riga si eseguono i calcoli.
Comunicazione risultato.
-Con la settima si comunicano i risultati.
//////////////////////////////////////////////////////////////////////////////////////////////////////
3) ESEMPIO DI BASE PER CODIFICA IN CODICE PYTHON
Problema proposto:
Per pavimentare una stanza di lati (l, h) pari a m(mq) ci sono volute h ore di lavoro. \nVogliamo determinare quante ore occorrono per pavimentare una stanza di m1(mq)
Modo di procedere per lo stesura dello pseudocodice:
individuo le variabili del problema: l, h, l1, h1, ore.
osservo che non esistono costanti da dichiarare.
applico la formula risolutiva che ho trovato prima.
eseguo i calcoli
Analisi del problema
si tratta di una proporzionalità semplice nel senso che se aumenta la superficie aumenteranno anche le ore di lavoro. La proporzione può essere espressa nel modo seguente:
se è vero che per pavimentare (l x h)mq di superficie S occorre un certo numero di ore, che chiamiamo ore, sarà anche vero che per pavimentare (l1 x h1)mq di superficie S1 occorreranno ore1. E quindi: S : ore = S1 : ore1 e che risolta da ore1 = (ore*S1)/S"
Specifiche funzionali al problema
-----------------------------------------------------------------------------------------
Grandezze in entrata o variabili del problema Grandezze in uscita
l un lato della stanza in metri ore1 ore necessarie per pavimentare altra stanza
h altro lato della stanza
ore numero di ore per pavimentare la prima stanza
l1 primo lato altra stanza
h1 secondo lato altra stanza
Formalizzazione dello script in codice Python
----------------------------------------------------------------------------
# la proporzionalità semplice
print("Per pavimentare una stanza di l, h pari a m(mq) ci sono volute h ore di lavoro. Vogliamo determinare quante ore occorrono per pavimentare una stanza di m1(mq)")
print("si tratta di una proporzionalità semplice nel senso che se aumenta la superficie aumenteranno anche le ore di lavoro. La proporzione può essere espressa nel modo seguente:se è vero che per pavimentare (l x h mq) di superficie S occorre un certo numero di ore che chiamiamo ore di lavoro, sarà anche vero che per pavimentare l1, h1 mq si superficie S1 occorreranno ore1. E quindi: S : ore = S1 : ore1 e che risolta da ore1 = (ore*S1)/S")
print("DATI DI INGRESSO")
l = float(input("dammi un lato della stanza in metri\n"))
h = float(input("dammi altro lato della stanza in metri\n"))
ore = float(input("dammi il numero di ore per pavimentare la prima stanza\n"))
l1 = float(input("dammi primo lato altra stanza in metri\n"))
h1 = float(input("dammi secondo lato altra stanza in metri\n"))
S = l1*h1 # superficie finale da pavimentare
ore1= (ore*S1)/S
print("RISULTATI IN USCITA")
print(ore1,"ore necessarie per pavimentare", S1,")
//////////////////////////////////////////////////////////////////////////////////////////////////////
4) ESEMPIO DI BASE PER CODIFICA IN CODICE PYTHON
Problema proposto:
Si vuole studiare il moto di un corpo in caduta libera e, in particolare, quelli che sono gli spazi da esso percorsi in un intervallo di tempo predefinito(i primi 10 secondi). Tali valori, dopo essere stati accumulati dentro un array vuoto, vengono visualizzati sullo schermo con la parola riservata print.
Modo di procedere per lo stesura dello pseudocodice:
la variabile che interviene è il tempo t e il calcolo è relativo ai primi 10 secondi
osservo che esiste una costante da dichiarare, quella gravitazionale g, che interviene nella formula della caduta libera h = 0.5*g*t**2.
creo un array vuoto per depositare i dati che vengono generati durante il ciclo for.
uso il ciclo for t in range(1,11) che, dato il numero limitato di step(10), è certamente il più idoneo e risolve il progetto, in modo elegante ed efficace, come evidenzia il codice dello script. In questa fase: vengono eseguiti i calcoli relativi ad ognuno dei 10 secondi per l'equazione h = 0.5*g*t**2 e i valori, così ottenuti, posti nell'array a in precedenza creato. Si comunicano, infine, i risultati.
Analisi del problema
tipico problema di fisica che non presenta difficoltà in quanto l'unica equazione da considerare è quella relativa al moto, uniformemente accelerato, dei corpi in caduta libera e quindi soggetti alla sola forza di gravità g. L'equazione che governa tale moto è la classica h = 0.5*g*t**2 che viene applicata ed eseguita, per 10volte, come imposto dal ciclo for.
Specifiche funzionali al problema
---------------------------------------------------------------------------------------------------------
variabili di input grandezze in uscita
t variabile tempo y spazio percorso
Formalizzazione dello script in codice Python
--------------------------------------------------------------------------------------------------------
print("CORPO IN CADUTA LIBERA SOTTOPOSTO ALLA SOLA GRAVITA")
a=[]
for t in range(1,11):
h = 0.5*9.81*t**2
a.append(h)
print(h," spazio percorso dopo ",t," secondi")
---------------------------------
Analisi del codice:
- la prima riga con print visualizza sullo schermo la traccia del problema.
- la seconda crea un array vuoto di nome a e serve per accumulare i 10 risultati ottenuti per lo spazio h(t).
- la terza usa il ciclo for t in range(1,11) per imporre quante volte deve essere effettuato il calcolo sulla y(t).
- la quinta usa la parola riservata append() per collocare i 10 valori calcolati all'interno dell'array a.
- con la sesta riga si comunicano i risultati numerici mentre le stringhe di testo servono per commentare cosa abbiamo fatto.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SCRIPTS VARI PER ACQUISIRE MEGLIO CONCETTI_BASE
ACQUISIRE DATI E COMUNICARNE I RISULTATI (USO DELLE LISTE)
1) Acquisire dati da tastiera, elaborarli e comunicare i risultati sul video.
--------------------------------------------------------------
print("Un elettrodomestico generico assorbe una potenza espressa da un certo numero di watt; sapendo che esso viene utilizzato per un un certo numero di ore al giorno, calcolare l`energia consumata in un mese e il suo costo in euro")
print ("Soluzione: basta moltiplicare il numero di ore di utilizzo nel mese per i watt consumati dal dispositivo per il costo del kilowattore")
# dichiara le variabili ore e potenza di tipo float perchè si prevedono risultati non interi
print ("acquisire le variabili in entrata")
ore = float(input("dimmi quante ore viene utilizzato in un mese\n"))
pot = float(input("dimmi la potenza che consuma il tuo elettrodomestico\n"))
FasciaOraria=raw_input ("dammi la fascia oraria che può essere la F0_fascia unica la F1_Giorno la F2 e F3_sera e weekend\n")
if FasciaOraria == "F0":
EC = ore*pot*0.06804
print(EC, "energia consumata in un mese in fascia F0")
if FasciaOraria=="F1":
EC=ore*pot*0.07576
print(EC, " Energia consumata in un mese in fascia F1")
else:
EC=ore*pot*0.06393
print(EC, "Energia consumata in un mese in fascia F2 e F3")
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ACQUISIRE DATI RELATIVI ALLA TEMPERATURA E COMUNICARNE I RISULTATI (USO DELLE LISTE)
2) Acquisire dati da tastiera, memorizzarli e comunicarli a video.
Formalizzazione dello script in codice Python
----------------------------------------------------------------------------------------
k=4 # crea contatore e lo inizializza a 4 per acquisire 5 città
a=[] # crea la lista a.
b=[] # crea la lista b.
c=[] # crea la lista c.
while k>=0: # mentre k>=0 esegui le righe sottostanti
ci=input("città controllata\n") # acquisisce la città con valore di tipo string
a.append(ci) # pone la città dentro la lista creata e chiamata a
tempM=int(input("massimo di temperatura\n")) # acquisisce la tempM con valore di tipo int.
b.append(tempM) # pone la tempM dentro la lista creata e chiamata b.
tempm=int(input("minimo di temperatura\n")) # acquisisce la tempm con valore di tipo int.
c.append(tempm) # pone la tempm dentro la lista creata e chiamata c.
k=k-1 # scale di una unità il contatore
if tempM > max: # effettua un test sulla tempM e controlla se > max.
max = tempM # con test positivo pone tempM dentro la variabile di nome max, creata subito.
print (ci,"più calda con",max) # visualizza la città più calda
if tempm < min: # effettua un test sulla tempm e controlla se < min.
min = tempm # con test positivo pone tempm dentro la variabile di nome min, creata subito.
print(ci,"più fredda con",min) # visualizza la città più fredda
print(a,"città controllate") # visualizza la città acquisite
print(b,"temperature massime rilevate") # visualizza le temperature massime rilevate
print(c,"temperature minime rilevate") # visualizza le temperature minime rilevate
a.sort () # riordina i dati della lista a in ordine alfabetico e relativi alle città
b.sort () # riordina i dati della lista b in ordine alfabetico e relativi alle temperature massime tempM.
c.sort () # riordina i dati della lista c in ordine alfabetico e relativi alle temperature minime tempm.
print(b ,"temperature massime dalla più bassa alla più alta")
print(c, "temperature minime dalla più bassa alla più alta")
print(b[4], "temperatura massima")
print(c[0], "temperatura minima")
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3) Somma i primi 7 numeri successivi a un numero qualsiasi introdotto da tastiera. Uso del while
Formalizzazione in codice Python
---------------------------------------------------------
n = input("dammi un numero\n") # acquisisce n
stop =7 # crea e fissa il contatore a 7
a=[] # crea una lista vuota
i=1 # crea altro contatore
while (stop != 0): # crea ciclo infinito che si ferma quando stop=0
somma = n+i # incrementa contatore
a.append(somma) # mette somma dentro la lista a[ ]
stop=stop - 1 # decrementa contatore di stop
i=i+1 # incrementa contatore della somma
print(somma)
print(sum (a))
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ELENCO DIPENDENTI
4) Elenco Dipendenti. Realizzare uno script che mostri elenco degli impiegati e la loro funzione e ne conti anche il numero.
Formalizzazione dello script in codice Python
-------------------------------------------------------------------
count = 0 # crea il contatore e lo inizializza a 0.
D=["pino:insegnante","gino:bidello"," rino:preside", "dino:segretario"] # crea una lista lunga a caso
for x in D: # ispeziona la lista D
count = count + 1 # incrementa il contatore in modo che il primo elemento sia indicato con 1
print(x, count) # stampa gli elementi della lista e li conta singolarmente
print(count," numero complessivo di impiegati") # stampa il valore totale degli impiegati
////////////////////////////////////////////////////////////////////////
NUMERI_PERFETTI
5) Ricerca numeri perfetti
Stabilire se un numero qualsiasi, introdotto da tastiera, risulta essere un numero perfetto. Occorre ricordare che un numero va considerato perfetto quando la somma dei suoi divisori è uguale al numero stesso. Es. il numero sei 6(1,2,3) è perfetto in quanto la somma di 1+2+3=6.
Es. 28(1,2,4,7,14) è perfetto in quanto 28=1+2+4+7+14
Formalizzazione in codice Python
------------------------------------------------------------
while True: # crea un ciclo infinito
a=[] # crea una lista vuota
n=int(input("dammi il numero che vuoi controllare\n")) # acquisisce numero intero da tastiera
for x in range(1,n): # la x ispeziona da 1 a n con ciclo for
if n%x == 0 and n != x: # sono le condizioni per avere un numero pari e diverso da n
a.append(x) # mette il numero x nella lista vu
if(sum(a))= n: # verifica se la somma elementi della lista=n. Sono le condizioni per avere numero perfetto e stampa il risultato se vero.
print(n, " è un numero perfetto") # stampa il numero perfetto
Esecuzione dello script
////////////////////////////////////////////////////////////////////////
6) Uso del while Genera 10 numeri a partire dal numero qualsiasi introdotto data tastiera
n= int(input("dammi un numero qualsiasi\n"))
count = 0
a=[]
while count <= 9:
count = count +1
n= n+1
a.append(n)
print(a)
////////////////////////////////////////////////////////////////////////
7) Uso del while Effettua il prodotto fra numeri mediante la somma
n1= int(input("dammi un numero qualsiasi\n"))
n2= int(input("dammi un numero qualsiasi\n"))
count = 0
s = 0
while n2 != count:
count = count +1
s= s+1
print(s, "prodotto di ",n1," per ",n2)
////////////////////////////////////////////////////////////////////////
STABILIRE IL NUMERO MASSIMO FRA GLI N NUMERI ACQUISITI
8) Stabilire quale è il numero massimo fra tutti quelli introdotti da tastiera. La ricerca deve essere bloccata da un contatore.
Formalizzazione in codice Python
-------------------------------------------
print("stabilisce il massimo fra n numeri")
max = 1 # dichiara max come numero intero e assegna valore 1 ipotizzando tutti i numeri siano > 1
for x in range(5): # esegue un ciclo for con variabile x da 0 a 5 e pertanto richiede inserimento di 6 numeri.
n=int(input("dammi numero\n"))
if n > max: # test-verifica se il numero inserito e` maggiore di max
max = n # se n>max attribuisce il valore a max che prima vale 1 e poi diventa n.
print((n),"massimo")
else:
print("minore")
print(max,"numero maggiore fra quelli introdotti")
/////////////////////////////////////////////////////////////////////
ESEGUE LA SOMMA DI N NUMERI INSERITI DA TASTIERA
9) Sommare n numeri usando il ciclo while che si interrompe quando il contatore count diventa = 0
Formalizzazione dello script in codice Python
---------------------------------------------------------------------------------------------
somma=0 # creo la variabile somma e gli assegno il valore zero
count=int(input("dimmi quanti numeri vuoi sommare\n")) # creo la variabile count e prendo il valore da tastiera
while count > 0: # fino a quando count > 0 fai le cose che seguono
numero=int(input("dammi un numero\n")) # acquisisco la variabile numero
somma=somma+numero # sommo alla variabile somma il numero acquisito
count = count-1 # decremento il contatore che deve essere sempre > 0
print(somma, " somma dei numeri inseriti") # esco dal ciclo e stampo il valore della somma
////////////////////////////////////////////////////////////////////////
CREA UNA FUNZIONE CON L'ISTRUZIONE DEF IN PYTHON
La funzione è un blocco di righe di codice il cui compito è quello svolgere delle operazioni specifiche, contenute nella funzione stessa, quando viene chiamata.
Per creare una funzione si usa il def che ha ha bisogno di: un nome che la caratterizza(es. def Area_Triangolo(b, h) e degli argomenti da cui essa dipende. Occorre poi specificare, dopo due punti previsti dall'etica del linguaggio, che cosa la funzione deve svolgere e lo facciamo con la parola riservata return: return(b*h)/2 .
Si deve poi avviare la funzione richiamandola con lo stesso nome con il quale è stata creata print(Area_Triangolo(5,8). Notare che si sono attribuiti due valori a b e h (b=5 h=8).
Dobbiamo indentare il codice, relativo al return, mettendo i due punti dopo il nome e avanzando poi di tre spazi dopo il ritorno a capo.
Il codice completo diventa:
def AreaTriangolo(b,h):
return (b*h)/2
print AreaTriangolo (5,8)
--------------------------------------------
Es.1 Crea la funzione def Area_Triangolo(b,h) e poi la richiamo con istruzione print
Formalizzazione in codice Python
-------------------------------------------------------------------
1 b = float(input("dammi la base triangolo\n")) # acquisisce la base per rendere il problema dì tipo generale
2 h = float(input("dammi altezza triangolo\n")) # acquisisce altezza
3 def Area_Triangolo(b,h): # definizione della funzione specifica e delle variabili da cui dipende
return(b*h)/2 # quello che deve restituire la funzione
4 print(Area_Triangolo(b,h) # chiamata della funzione; altrimenti non viene eseguita
Commento del codice:
Con le righe 1 e 2 si rende il problema di tipo generale e quindi valido per qualsiasi coppia di valori delle variabili del problema.
Con la riga 3 si definisce la funzione e si evidenziano gli argomenti da cui dipende e, dopo l'indentazione ottenuta con avanzamento di tre posizioni, si specifica quello che la funzione deve fare con istruzione return(b*h)/2 o, in alternativa, con print(b*h)/2.
La quarta riga consente di visualizzare a schermo, e in relazione con i valori attribuiti alle variabili b e h, quello che si è impostato nella chiamata della funzione con print(Area_Triangolo(8,5))
////////////////////////////////////////////////////////////////////////
Es. 2 Stabilire se un numero è pari o dispari
Formalizzazione in codice Python
--------------------------------------------------------------
def PariDispari# definizione della funzione specifica e delle variabili
if x%2 == 0: # controlla se x è pari e ne stampa il valore
print(x, " è pari")
else: # altrimenti comunica che x è dispari
print(x," è dispari ")
PariDispari(20) # chiamata della funzione che comunica la parità del numero 20
////////////////////////////////////////////////////////////////////////
Es. 3 Somma due numeri
Formalizzazione in codice Python
------------------------------------------------------------------
def somma(a,b):
print(a+b)
somma(4, 5) # chiama la funzione e stampa 9 (somma di 4+5)
/////////////////////////////////////////////////////////////////////
Es. 4 IL GIOCO - Indovina numero - con la funzione def
Formalizzazione in Python
-------------------------------------------
def gioco():
x=123
y=1
while True:
a=int(input("dammi un un numero\n"))
if a > x:
print("numero troppo grande")
elif a > x:
print("il numero troppo piccolo")
else:
print("numeri uguali Hai vinto")
gioco() # chiamata della funzione
///////////////////////////////////////////////////////////////////
Es. 5) CALCOLO DEL FATTORIALE DI UN NUMERO N QUALSIASI
Formalizzazione in codice Python
-----------------------------
n= int(input("dammi un numero\n")) # acquisisco numero n
def Fatto(n): # crea la funzione def relativa al fattoriale
if n==0: # test condizionale
return 1 # restituisce 1 se test positivo
else: # altrimenti restituisce il fattoriale di n
return n*Fatto(n-1) # calcola il fattoriale
print(Fatto (n),"fattoriale di ", n)
////////////////////////////////////////////////////////////////////////
Es. 6) Come fare più cose contemporaneamente con la funzione def
Obiettivo: definire più funzioni nello stesso script e poi richiamarle, una alla volta, o contemporaneamente, quando servono.
Formalizzazione in codice Python
-------------------------------------------------------------------
print("Uso della funzione def per risolvere specifici problemi")
# Vengono acquisite due variabili di tipo float per definire la base e altezza e poi anche il raggio r del cerchio
# si definisce poi la prima funzione def Area_Tri che dipende dalle due variabili b, h e si stabilisce, dopo i due punti, il metodo che deve essere attuato: return (b*h)/2
# viene poi creata la funzione def Area_Qua e, attraverso la parola riservata print, si provvede a visualizzare il risultato della formula (b*h), che ne rappresenta l'area del quadrato.
# infine viene creata la funzione def Area_Cerchio(r) e, attraverso la parola riservata print, si provvede a visualizzare sia il risultato della formula (2*pgreco*r), che rappresenta l'area del cerchio, che quello della circonferenza 2*pgreco*r.
print("Codice Python")
print "acquisire le variabili del problema"
b=float(input("dammi base\n"))
h=float(input("dammi altezza\n"))
r=float ( input ( "dammi il raggio del cerchio\n"))
def Area_Tri(b,h):
return (b*h)/2
def Area_Qua (b):
return b*b
def AreaCerchio (r):
pgreco=3.14
return 2*pgreco*r,"circonferenza", pgreco*r**2,"area cerchio"
print(AreaCerchio (r)) # chiamata della funzione
print(Area_Qua (b, h)," area quadrato") # chiamata della funzione
print(Area_Tri(b,h), " area triangolo") # chiamata della funzione
DIFFERENZA FRA VARIABILE GLOBALE E LOCALE
Una variabile si considera globale quando è riconosciuta in tutte le parti del codice.
Una variabile si definisce locale quando viene riconosciuta solo all'interno di aree specifiche del codice, come ad es all'interno di un ciclo for o di un ciclo while o ancora, come nel caso sottostante, all'interno della funzione def.
Es. Per chiarire il concetto.
Formalizzazione in Python
----------------------------------
def uno()
x=10
print(x)
uno() # su questa riga chiama la funzione e stampa il valore 10 della variabile locale
print(x) # su questa riga chiama la funzione uno e stampa ancora il valore 10 della locale
esecuzione
10
10
--------------------------------------------------------
x=10 # x fuori dal def è una variabile globale
def uno():
x=15 # x è una variabile locale riconosciuta solo dalla def
print(x)
uno() # su questa riga chiama la funzione e stampa il valore 15
print(x) # il print fuori dal ciclo stampa il valore di x globale che vale 10
esecuzione
15
10
---------------------------------------------------------------
LE CLASSI IN PYTHON
In python esiste una funzione integrata nel linguaggio che viene eseguita dall'interprete, all'avvio della classe, che è la def__init__() che caratterizza tutte le classi. La si usa per attribuire dei valori alle proprietà dell'oggetto o per eseguire delle operazioni durante la modellizzazione dell'oggetto stesso.
Es.1
class Person: # crea la classe
def __init__(self,name,age): # usa la funzione per definire gli attributi della classe
self.name = name # self è un parametro che serve per accedere alle variabili della classe e deve essere il primo presente in qualsiasi funzione della classe.
self.age = age
def display(self): # definisce funzione per visualizzare
print("il tuo nome "+self.name)
print ("la tua età anni "+str(self.age))
p=Person ("Jonathan","27") # crea oggetto e attribuisce valori
p1=Person ("Stefano ","28") # crea secondo oggetto
p2=Person("Robert ","55") # crea terzo oggetto
p.display() # chiama funzione display(self) e visualizza proprietà oggetto p
p1.display()
p2.display()
/////////////////////
Es. 2
class Auto:
def __init__(self, cilindrata, cavalli):
self.cilindrata = cilindrata
self.cavalli = cavalli
def display(self):
print("la tua auto ha una cilindrata di "+self.cilindrata)
print ("la tua auto ha cavalli "+str(self.cavalli))
a = Auto("1600","110")
a.display()
//////////////
Es.3
class Area:
def __init__(self,b,h):
self.b=b
self.h=h
def display(self):
print("area quadrato "+str((self.b)*(self.h)))
print ("area triangolo "+str((self.b)(self.h)/2))
a= Area(30,20)
aT=Area(4,8)
a.display()
aT.display()
/////////////////////////////////////////////////////////////
Python Inheritance
L'ereditarietà ci consente di definire nuove classi che ereditano tutti i metodi e le proprietà da una classe creata in precedenza.
La classe genitrice è la classe principale dalla quale vengono ereditate tutte le caratteristiche della classe.
La classe figlio è la classe che eredita da un'altra classe e viene chiamata anche classe derivata.
Crea una classe genitrice: qualsiasi classe può essere una classe genitrice, quindi la sintassi è la stessa della creazione di qualsiasi altra classe:
Esempio
Crea una classe di nome Auto, con proprietà cilindrata e cavalli e poi un metodo per stampare
gli attributi della classe derivata.
class Auto:
def __init __ (self, cilindrata,cavalli):
self.cilindrata=cilindrata
self.cavalli=cavalli
def display(self):
print(self.cilindrata, self.cavalli)
# Utilizzare la classe Auto per creare un oggetto, quindi eseguire il metodo dislay() per visualizzare:
a = Auto("1600", "150")
a.display()
# Utilizzare la classe Auto per creare la classe Fuoristrada() che eredita da class Auto()
class Fuoristrada(Auto): # la classe Auto diventa il parametro della classe Fuoristrada derivata.
pass # utilizzare la parola chiave pass quando non si desidera aggiungere altre proprietà o metodi alla classe.
a=Fuoristrada("verricello","cassone") # crea oggetto della classe derivata con sue caratteristiche.
a.display() # mostra grandezze relative a oggetto di class Fuoristrada() che sono: verricello cassone
LE STRINGHE IN PYTHON
La stringa risulta costituita da una serie di caratteri, che possono essere sia numeri che lettere, delimitati dalle doppie virgolette.
Es1 "antonio@libero.it"
Es2 "36E"
Es3 "ristorante da mario"
-Per memorizzare una stringa essa va collocata all'interno di una variabile di tipo string.
Es.
a = "Ciao a tutti"
print(len(a)) # Restituisce 12 perchè conta anche gli spazi fra caratteri
print(a[3]) # Restituisce o il quarto elemento della stringa
print(a + !) # Restituisce Ciao a tutti! perchè concatena sulla stessa stringa
print(a * 2) # Restituisce Ciao a tuttiCiao a tutti
print(a.upper()) # Restituisce CIAO A TUTTI
print(a.lower()) # Restituisce ciao a tutti
a.replace("e","6")
print(a) # Restituisce Ciao e tutti
//////////////////////////////////////////////////////////////////////////////
N.B -Per concatenare due stringhe si usa operatore matematico +
nome = "giuseppe"
cognome = "mazzini"
persona = nome + cognome
print(persona) ↲ # restituisce
giuseppemazzini
////////////////////////////////////////////////////////////////////////////
-Per replicare una stringa si usa operatore * :
nome = "giuseppe" * 5
print (nome) # restituisce
giuseppegiuseppegiuseppegiuseppegiuseppe
////////////////////////////////////////////////////////////////////////
Lo stesso risultato si ottiene con:
print(nome * 5) # restituisce
giuseppegiuseppegiuseppegiuseppegiuseppe
///////////////////////////////////////////////////////////////////////
nome.replace("giuseppe","mazzini")
print(nome) # resituisce
giuseppemazzini
//////////////////////////////////////////////////////////////////////
-Per la conversione fra stringhe e numeri
nome="giuseppe" + str(1949)
print(nome) ↲ # restituisce
giuseppe1949
///////////////////////////////////////////////////////////////////////
-Da una stringa contenente valore numerico si ottiene il numero in essa contenuto. La stessa cosa se la stringa contiene un numero in virgola mobile:
Es.
anno = int("1949")
print(anno) # restituisce 1949
///////////////////////////////////////////////////////////////////////
prezzo = float("19.49")
print(prezzo) # restituisce 19.49
//////////////////////////////////////////////////////////////////////
-Per stampare sequenze di caratteri su varie righe si usa lo \n
print("$\n$$\n$$$\n$$$$\n$$$$$\") # restituisce
$
$$
$$$
$$$$
$$$$$
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ALTRE OPERAZIONI CON LE STRINGHE
Stato Risultato Osservazioni
stringa= "Giuseppe" la stringa viene settata Giuseppe stampa quello fra virgolette
sringa = stringa + "Garibaldi" viene settata a Giuseppe Garibaldi il + concatena le stringhe.
///////////////////////////////////////////////////////////////////////
print("Per favore" + " scrivi tuo nome: ") stampa Per favore scrivi il tuo nome:
///////////////////////////////////////////////////////////////////////
gruppo = str(56) + "th" gruppo viene settato a"56th" 56 è un intero, da convertire in stringa
///////////////////////////////////////////////////////////////////////
persone= "pino & gino"
n = len(persone) n viene settato a 11 - len sta per lunghezza - si contano anche gli spazi
///////////////////////////////////////////////////////////////////////
nome = "Giorgio"
lettera = string[1] lettera viene settata ad "i" Notare che la posizione 0 è quella della G.
///////////////////////////////////////////////////////////////////////
ultimo= string[len(string) - 1] ultimo viene settato a t ultimo carattere della stringa.
///////////////////////////////////////////////////////////////////////
string = "Ciao"
string = string + " a tutti" # Ciao a tutti Il segno + serve a concatenare le due stringhe
///////////////////////////////////////////////////////////////////////
print("Dammi altezza del triangolo:" +" e quella della base ")
Dammi altezza del triangolo: e quella della base
///////////////////////////////////////////////////////////////////////
classe = str(47) + "gold" 47gold Il numero 47 è un intero e viene convertito in stringa
iniziali= "A & G"
n = len(iniziali)
# n ha valore 5 perché sono 5 i caratteri. Gli spazi vuoti si contano.
///////////////////////////////////////////////////////////////////////
stringa = "Giuseppe"
ch = stringa[1] che viene settata a "i" perchè si parte a contare da 0.
ultimo = string[len(string-1)] ultimo viene settato a "e" ultimo carattere di Giuseppe.
///////////////////////////////////////////////////////////////////////
>>>a="marco"
>>>b=32
>>>c="milano"
>>>print("%s nato a %s ed ha %d anni" %(a, c, b)) # da: Marco nato a milano ed ha 32 anni
Marco nato a Milano ed ha anni 32
///////////////////////////////////////////////////////////////////////
>>>a="pino "
>>>print (len(a)) # restituisce 4
>>>print(a[3]) # restituisce 0
>>>print(a+"!") # restituisce pino!
>>>print(a*2) # restituisce pinopino
>>>print (a.upper()) # restituisce PINO
>>>print(a.lower()) # restituisce pino
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SHELL DI PYTHON
Possiamo operare con le stringhe direttamente nella Shell di Python.
Nella stringa "giuseppe", ma anche e in tutte le altre stringhe, i caratteri vengono identificati a partire dall'indice 0 e quindi nel ns. caso: g[0] i[1] u[2] s[3] e[4] p[5] p[6] e[7]
>>>nome = "giuseppe"
>>>print nome[:2] # restituisce gi le prime due
>>>print nome[:4] # restituisce gius le prime quattro
>>>print nome[2:] # restituisce useppe toglie le prime due
>>>print nome[1:] # restituisce iuseppe toglie la prima
>>>print nome[2:4] # restituisce us toglie le prime due e quelle dopo la quarta
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
I DIZIONARI CON PYTHON
In Python il dizionario è chiamato dict, che deriva dall'inglese dictionary, ed è formato da coppie chiave:valore e separate fra di loro da una virgola. Il tutto viene racchiuso fra parentesi graffe.
I dizionari si creano strutturando nel seg. modo:
- possono avere un nome qualsiasi.
- devono avere le due parentesi graffe di apertura e chiusura.
- le stringhe, separate fra loro da una virgola, possono essere in numero qualsiasi e, pertanto, il dizionario si può estendere quanto si vuole.
- la chiave del dizionario per il primo elemento è giorgio, per il secondo è andrea e via di seguito.
- il value o valore è rappresentato dalla stringa dopo i due punti di ogni elemento del dizionario.
- l'accesso ai valori dei singoli elementi avviene attraverso la chiave corrispondente.
#Es. di Dizionario
a={"giorgio":"038888488","andrea":"0989877798","marino":"4356677672"} # crea il dizionario a
chiave value chiave value chiave value
Operazioni che si possono fare sul Dizionario a che abbiamo creato:
print(a["giorgio"]) # restituisce il numero di telefono di giorgio e quindi 038888488
038888488
------------------------------------------------------------------
print(a.has_key("marino") # restituisce marino che è la chiave
marino
-------------------------------------------------------------------
print(a.values("andrea")) # restituisce il valore associato ad andrea
0989877798 # il numero di telefono associato ad andrea.
------------------------------------------------------------------
print(a) # appare tutto il dizionario
{"giorgio":"038888488","andrea":"0989877798","marino":"4356677672"}
------------------------------------------------------------------
print(a.keys()) # restituisce tutte le chiavi del dizionario
giorgio andrea marino
a["michele"] = "0989755555" # aggiunge michele al dizionario
-------------------------------------------------------------------
print(a) # appare tutto il dizionario con l'aggiunta di michele e del suo numer
{"giorgio":"038888488","andrea":"0989877798","marino":"4356677672","michele":"0989755555"}
------------------------------------------------------------------
print(len(a)) # restituisce la lunghezza e quindi il numero 4 dato che sono 4 gli elementi del D
-----------------------------------------------------------------------------------
Un Dizionario molto efficace
Il dizionario accumula delle informazioni e le restituisce quando le si richiama attraverso la chiave(diz.has_key(b) e che in sostanza significa: controlla se il dizionario diz contiene la chiave di quello che mi stai chiedendo e se la trovi allora mostra il contenuto associato, cioè il codice scritto dopo i due punti.
Formalizzazione dello script in codice Python
--------------------------------------------------------------------------------------------
print("Fammi delle domande e cerco di risponderti")
a={"come stai":"bene grazie","quanti anni hai":"32 anni"}
k=2
while k==2: # ciclo infinito in quanto k è =2 sempre e quindi continuerà a chiedere
b=input("chiedimi qualcosa contenuto nel dizionario e io ti rispondo se lo trovo\n")
if a.has_key(b): # se trova la chiave richiesta risponde. Va a vedere se il b immesso è chiave di a
print (a[b]) # stampa bene grazie se io ho immesso come richiesta come stai
else:
print (gy"non ho trovato nulla") # comunica se non ha trovato nulla
c=input("cosa rispondo alla domanda" +b) # crea una nuova variabile c per acquisire elemento
a[b] = c # aggiunge il nuovo elemento al dizionario
Altro Dizionario molto utile
Creiamo prima un dizionario relativo a tutto quello di nostro interesse; se lo interroghiamo lui risponde. La cosa notevole è quella che si può estendere il D. a dismisura e quindi diventa come un grande db.
Formalizzazione dello script in codice Python
-------------------------------------------------------------------
a={"autovettura":"corolla verso con targa gf67778gh","quale sport ti piace":"tennis","quando scade assicurazione":"6/7/2019"}
print(a["autovettura"] # risponde con il valore della chiave di autovettura
corolla verso con targa gf67778gh
print(a["quale sport ti piace"] # risponde con il valore della chiave di quale sport ti piace
tennis
print(a["quando scade assicurazione"] ) # con il valore chiave quando scade assicurazione
'6/7/2019'
--------------------------------------------------------------------------------------------------------------------------
ALCUNI MODULI DI PYTHON
Per utilizzare quelli contenuti in Python, li possiamo richiamare direttamente dalla Shell digitandone il codice relativo:
>>>import calendar ↲
>>>calendar.weekday(2009,12,25)
4 # restituisce 4 un giovedì che occupa la quarta posizione su sette giorni
///////////////////////////////////////////////////////////////////////
>>>print(calendar.monthrange(2009,1)) # restituisce (3,31)
(3,31) # comunica che si tratta del terzo giorno della settimana(Mercoledì) il mese è di 31 giorni
///////////////////////////////////////////////////////////////////////
>>>import calendar
>>>a= input("quale anno vuoi vedere\n") # digito un anno qualsiasi
>>>print(calendar.prcal(a) # mi fa vedere il calendario dell'anno che ho digitato come valore di a
>>>print(calendar.prcal(2009)) # mi fa vedere il calendario del 2009
////////////////////////////////////////////////////////////////////////
>>>import calendar
>>>calendar.prmonth(2009,01) # restituisce il calendario del mese di gennaio del 2009
////////////////////////////////////////////////////////////////////////
>>>from datetime import date
>>> oggi=date.today()
>>> print(oggi)
2018-12-1
>>> natale=date(2018,12,25)
>>> print(natale)
2018-12-25
>>> print(natale-oggi,"giorni che mancano a natale")
8 days, 0:00:00 giorni che mancano a natale
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Il modulo random e qualche applicazione
>>>import random
>>>random.choise("ciao a tutti")
c # restituisce un carattere a caso fra quelli contenuti nella stringa
///////////////////////////////////////////////////////////////////////
>>>import random
>>>random.randint(1,30)
4 # restituisce un numero qualsiasi compreso fra 1 e 30
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
SIMULAZIONE DI SISTEMI FISICI E NON CON PYTHON
SIMULAZIONE CRESCITA TOPINO
1) Tipico script che simula la crescita di un topino dalla nascita in poi.
Formalizzazione in codice Python
---------------------------------------------------------
print("crescita di topino nei primi giorni di vita")
print("peso alla nascita fra 80 e 100 grammi")
c=0 //contatore dei giorni
g=10 //contatore che blocca il ciclo while
pi=float(input ("peso iniziale topino\n"))
while g!=0:
scorie=float(input ("scorie oggi\n"))
mangia=float(input("mangia oggi\n"))
pi=pi+mangia-scorie
c=c+1
g=g-1
print( pi,"grammi peso del giorno", c)
print (pi,"grammi peso effettivo")
//////////////////////////////////////////////////////////////////
Simulazione di un semplice gioco
Es.2 UN GIOCO CON IL NUMERO VINCENTE
Abbiamo una lista che contiene n numeri, presi a caso, e in numero qualsiasi; il gioco si interrompe quando si indovina il numero stabilito dal codice.
Formalizzazione in codice Python
-------------------------------------------------------------------
nome=input ("dimmi come ti chiami\n") # tell me your name
print("gioco creato da ", nome)
print("devi indovinare un numero vincente fra quelli della lista e puoi sbagliare soltanto 4 volte prima di perdere 100 euro")
a=[12,24,1,66,88,3,7,5,8,10] # lista con 10 elementi
b=[]
k=3
print(a)
while k != 0: # ciclo infinito fino a k=0
print "guarda i numeri della lista che poi ti faccio delle domande"
num=int(input("dammi un numero che secondo il tuo parere risulta vincente\n"))
if num==a[4]: # si stabilisce il numero vincente 88: il quinto elemento delle lista
print(nome,"risposta esatta hai vinto")
else:
k=k-1 # decrementa contatore in base al numero di tentativi che si danno al giocatore
print(nome,"hai perso hai sbagliato", count," volte" )
////////////////////////////////////////////////////////////////////////
3) SIMULAZIONE DEL GIOCO DELLA SCHEDINA CON PYTHON
Se ci vogliamo affidare al caso, cioè a Python.
Lo script sottostante viene salvato sul desktop con il nome schedina.py. Appare l'icona, con il nome schedina, sulla quale si va a cliccare per eseguirlo. Viene generata, a caso, la sequenza dei 13 simboli 1x2.
Formalizzazione dello script in codice Python--------------------------------------------------------------
1 import random # importazione del modulo random in grado di generare a caso
2 a="1x2" # creazione della stringa di tre elementi
3 for x in range(13): # ciclo for per definire il numero di volte
4 ...print(random.choice(a)) # restituisce la schedina generando casualmente 1 x 2
x
2
1
1
x
x
x
2
1
1
x
x
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4) SIMULAZIONE ANDAMENTO CONTO BANCARIO CON PRELIEVI E DEPOSITI
print("UN CLIENTE DI UNA BANCA HA UN FIDO IN EURO, DA SPECIFICARE, IN QUANTO TITOLARE DI UN CONTO CON UN DEPOSITO IN MIGLIAIA DI EURO. VENGONO PRELEVATI, PERIODICAMENTE, DELLE SOMME SENZA MAI DEPOSITARE ALTRO DANARO. REALIZZARE IL SOFTWARE CHE PRODUCA IN USCITA DEI MESSAGGI CHE AVVISINO, OGNI VOLTA, SE SI PUO ANCORA PRELEVARE, OPPURE NO, E IL RESIDUO ANCORA DISPONIBILE")
conto= int(input("dimmi quanti euro hai sul conto\n")) # il progetto risulta valido qualunque sia il deposito iniziale e il valore del fido
fido=int(input("dimmi quanti euro ti sono stati accordati come fido\n"))
totale=conto +fido
k=10 # contatore che definisce il numero di transazioni
while k != 0:
k=k-1
preleva=float(input("quanto prelevi oggi\n"))
totale=totale-preleva
if totale >=0:
print("prelievo accordato sono disponibili ancora euro ",totale)
else:
print("NON PUOI PRELEVARE")
# se oltre a prelevare si provvede anche a depositare periodicamente allora il codice diventa:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
AUTOMI
SIMULAZIONE DI AUTOMI A STATI FINITI
1) SIMULAZIONE CON PROGETTO SOFTWARE DI UN AUTOMA A STATI FINITI
print("AUTOMA CASSAFORTE")
print("UN AUTOMA A STATI FINITI E RELATIVO AL MECCANISMO DI APERTURA DI UNA CASSAFORTE POSSIEDE, COME COMBINAZIONE DI SBLOCCO, IL CODICE 4 3 1 1 2. SI VUOLE PROGETTARE IL SOFTWARE IN GRADO DI RICONOSCERE TALE CODICE")
k=2 # fissa i possibili tentativi di digitazione del codice
a=[ ] # crea un array vuoto dove depositare le cifre immesse
codice=[4,3,1,1,2] # array modificabile contenente il codice
while k != 0:
k=k-1
c1= int(input("dammi prima cifra\n"))
c2= int(input("dammi seconda cifra\n"))
c3= int(input("dammi terza cifra\n"))
c4= int(input("dammi quarta cifra\n"))
c5= int(input("dammi quinta cifra\n"))
a.append(c1)
a.append(c2)
a.append(c3)
a.append(c4)
a.append(c5)
if a == codice:
print("SISTEMA SBLOCCATO PUOI ACCEDERE")
else:
print("SISTEMA BLOCCATO NON PUOI ACCEDERE")
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2) SIMULAZIONE DI UN AUTOMA A STATI FINITI DISTRIBUTORE AUTOMATICO
print("PROGETTA UN AUTOMA IN GRADO DI SIMULARE UN DISTRIBUTORE AUTOMATICO DI FRANCOBOLLI CHE ACCETTI MONETE DA 0.50cent, 0.20cent, 0.10cent di euro. Si conosce il prezzo del francobollo, ma si acquisisce il suo valore da tastiera per renderlo adattabile a eventuali cambiamenti, e si ipotizza che il distributore non fornisca resto se questo risulta inferiore a 20cent ")
a=[] # array vuoto per depositare il valore delle monete usate per pagare
c=4 # contatore per gestire il ciclo while
while c != 0:
c=c-1
monete5=float(input("da 50cent in euro\n")) # vengono acquisite le variabile da tastiera e poste in array a
a.append(monete5)
monete2=float(input("da 20cent centesimi in euro\n"))
a.append(monete2)
monete1=float(input("da 10cent in euro\n"))
a.append(monete1)
print(sum(a)) # stampa il valore della somma in euro acquisita
prezzoFra=float(input("prezzo francobollo in centesimi\n")) # acquisisce prezzo francobollo
francobolli=float(input("quanti francobolli vuoi\n")) # acquisisce numero di bolli
prezzopaga=francobolli*prezzoFra # calcola quanto pagare
resto=sum(a)-prezzopaga # calcola il resto
if(resto < 0.20): # se resto <20 comunica no resto
print("non da resto")
else:
print(resto," questo e il resto") # comunica resto, somma da pagare
print(prezzopaga,"somma da pagare") # cifra da pagare
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3) SIMULAZIONE CON PROGETTO SOFTWARE DI UN AUTOMA A STATI Finiti
AUTOMA DISTRIBUTORE AUTOMATICO
print("AUTOMA DISTRIBUTORE AUTOMATICO CHE EROGA UNA LATTINA DI COCA SOLO DOPO CHE SONO STATE INSERITE 2 MONETE DA 1euro")
print("AUTOMA FUNZIONA SOLO CON MONETE DA 1euro")
k=2 # contatore per definire quante volte si devono acquisire le monete
a=[ ] # array per depositare le monete
while k != 0:
k=k-1
moneta=int(input("dammi moneta da 1euro\n"))
a.append(moneta) # deposita le monete in a
if sum(a) == 2: # controlla se le monete sono 2
print("bibita erogata")
else:
print("non hai messo le monete previste ",a)
____________
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ALCUNI MODULI CON PYTHON
Il modulo time e alcune applicazioni
ModuloTIME Sito Rif.to
Nella Shell di Python, digitare quanto segue:
>>>import time # viene importato il modulo che consente di interagire con orologio di sistema
>>>time.sleep(3) # il sistema si ferma per 3 secondi
///////////////////////////////////////////////////////////////////////
>>>import time
>>>time.strftime("%a") # da il giorno settimana abbreviato
'Thu'
///////////////////////////////////////////////////////////////////////
>>>time.strftime("%aA") # il giorno completo
'Thursday'
///////////////////////////////////////////////////////////////////////
>>>time.strftime("%b") # il mese abbreviato
'Sep'
///////////////////////////////////////////////////////////////////////
>>>time.strftime("%B") # il mese completo
'September'
///////////////////////////////////////////////////////////////
>>>time.strftime("%m") # il mese in numero
'09'
///////////////////////////////////////////////////////////////////////
>>>time.strftime("%y") # il giorno in numero del mese in corso
'18'
///////////////////////////////////////////////////////////////////////
>>>time.strftime("%Y") # anno in corso 2018
'2018'
///////////////////////////////////////////////////////////////////////
>>>time.strftime("%C") #
'20'
///////////////////////////////////////////////////////////////////////
>>>time.strftime("%d") # il giorno corrente
'13'
///////////////////////////////////////////////////////////////////////
>>>time.strftime("%H") # orario attuale
'13'
///////////////////////////////////////////////////////////////////////
>>>time.stfrtime("%S") # i secondi
'32'
///////////////////////////////////////////////////////////////////////
>>>time.strftime("%M") #
'52'
///////////////////////////////////////////////////////////////////////
>>>time.strftime("%P") # post meridian
'pm'
Cosa appare nella SHELL di PYTHON digitando il codice di cui sopra.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LA GESTIONE DEGLI ERRORI CON PYTHON E LE PAROLE RISERVATE try e except.
Sito Rif.to try-except-python
////////////////////////////////////////////////////////////////
CREARE E IMPORTARE I MODULI PERSONALI CON PYTHON
Es.
Supponiamo di aver definito alcune funzioni di nostro interesse nel seg. modo:
def area_cerchio(r):
pgreco=3.14
return (pgreco*r*r)
def area_rettangolo(a,b):
return a*b
def saluto():
print("ciao a tutti")
--------------
Salvo il file con la solita procedura: File/Salva con nome/prova.py.
Quando ritorno nella Shell di Python e digito import prova, viene caricato il modulo che ho salvato e che può essere utilizzato senza problemi..
>>> import prova
>>> prova.saluto
ciao a tuti
>>> prova.area_cerchio(10) # attribuisco valore al raggio
628
>>> prova.area_rettangolo(10,10) # attribuisco valori ai due lati
100
N.B. Se viene modificato il modulo, tale modifica si ripercuote su tutte le applicazioni che usano quel modulo!
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1) APRIRE UN BROWSER CON PYTHON IN AMBIENTE WINDOWS
Formalizzazione in codice Python
---------------------------------------------------------------------------------------------
import webbrowser
webbrowser.open("http://www.google.it")
# oppure
import webbrowser.get("firefox")
x.open("https://www.google.it")
///////////////////////////////////////////////////////////////////////
2) AVVIARE APPLICAZIONE CON PYTHON IN AMBIENTE WINDOWS
Formalizzazione in codice Python
--------------------------------------------------------------------------------
import o.s. # accede al sistema operativo
os.startfile("notepad") # avvia il notepad di windows
os.startfile("c:\programmi\CCleaner\ccleaner.exe") # avvia la musica in base al percorso del file
///////////////////////////////////////////////////////////////////////
4) AVVIARE UN FILE .wav CON PYTHON IN AMBIENTE WINDOWS
Formalizzazione dello script in codice Python
-----------------------------------------------------------------------------
import windsound # si deve importare windsound in Python 2.5
windsound.PlaySound("c:\uccellini.wav",1)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CENNI SUL MODULO PYGAME IN AMBIENTE WINDOWS
Es.1 Creare una finestra per disegnare: tracciare una linea definita da parametri
# il modulo pygame serve per disegnare, realizzare giochi ecc.
import pygame # il modulo pygame viene importato
pygame.init() # inizializza pygame
schermo=pygame.display.set_mode((640,480)) # fissa area di lavoro in 640x480
rino=5 # variabile necessaria per utilizzare il ciclo while
x=10
y=10 # x e y sono variabili del piano xy per far muovere il punto a partire da quelle coordinate
while rino==5: # ciclo infinito perchè è sempre vero che 5=5
for evento in pygame.event.get(): # definisco una variabile evento e la uso per gestire gli eventi in pygame
if evento.type == pygame.QUIT(): # se il tipo di evento è il QUIT() allora chiudo applicazione
pygame.quit()
elif evento.type == pygame.KEYDOWN: # se il tipo di evento è il KEYDOWN allora disegna tenendo giù il mouse
if evento.key == pygame.k_a:
schermo.fill((0,0,0))
pygame.draw.line(schermo,(100,100,100),(x,y),(60,60),3)
pygame.display.flip()
x=x+1
y=y+1 # cancella il disegno precedente
# salvare con nome linea.py ed eseguire: premendo a apparirà una linea
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Es.2 creare una finestra per disegnare: tracciare una cerchio definito da parametri
import pygame
pygame.init() # inizializza pygame
schermo = pygame.display.set_mode((640,480)) # fissa area di lavoro in 640x480
schermo.fill((0,0,0)) # stabilisce il colore dello schermo che si può modificare
pygame.draw.circle(schermo,(34,65,78),(180,180),80,4)
pygame.display.flip() # cancella il disegno precedente
# salvare con cerchio.py ed eseguire: apparirà un cerchio
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
