• Passa al contenuto principale
  • Skip to secondary menu
  • Passa alla barra laterale primaria
logo openoikos

openoikos

Soluzioni CAD low cost

banner nanocad italia
  • Home
  • Chi sono e di cosa parlo
  • Blog
    • NANOCAD free
    • NANOCAD
    • GIS
    • Grafica
    • Altri software
    • Programmazione
    • Android
    • Hardware
    • Web

Programmazione

Nelle spire del Python (lezione 6): tuple, liste e dizionari

2 commenti

tutorial python 6

tutorial python 6

Sesto incontro con Python, ancora non ho ricevuto feedback, quindi proseguiamo con il linguaggio.

Vediamo meglio come lavorare con gli iterabili, ovvero tuple, liste e dizionari.
In altri linguaggi sarebbero chiamati array, scalar, hashtables e simili nomi.
Si tratta in pratica di variabili che contengono sequenze di dati.
Ma in Python ogni cosa è un oggetto, come vedremo presto, per cui ha dei metodi, ovvero funzioni dell’oggetto, specifiche, per la manipolazione dell’oggetto stesso.
Abbiamo tre tipi di oggetti, le tuple e le liste che sono semplici liste di elementi assortiti e i dizionari che invece sono coppie chiave-valore.
Vediamole in dettaglio.

TUPLE
Una tupla è una sequenza di elementi assortiti. Si riconosce perché gli elementi sono racchiusi, alla creazione o inizializzazione della tupla, tra parentesi tonde.

>>> mia_tupla = (1,’ciccio’, 3.14, “Giovanni dalle bande nere”)

Come vedete possono essere eterogenee, ovvero contenere qualsiasi tipo di elemento. Un esempio di tupla piu’ sensato è il seguente:

>>> settimana = (“Lunedì”, “Martedì”, “Mercoledì”, “Giovedì”, “Venerdì”, “Sabato”, “Domenica”)

Possiamo quindi selezionare un giorno della settimana con

>>> settimana[indice]

dove indice è un valore compreso tra 0 e 6.

Ricordate sempre che gli indici iniziano con 0 e hanno come valore massimo il numero di elementi meno 1.

Per esempio per stampare tutti gli elementi potremmo scrivere
>>> settimana = (“Lunedì”, “Martedì”, “Mercoledì”, “Giovedì”, “Venerdì”, “Sabato”, “Domenica”)
>>> for a in range(0, len(settimana)):
>>> print settimana[a]

e otterremo come output
Lunedì
Martedì
Mercoledì
Giovedì
Venerdì
Sabato
Domenicapy61

Bene, manca un particolare importante: le tuple sono delle costanti. Una volta assegnate non si possono modificare. Né aggiungere né sottrarre elementi.
Certo possiamo tranquillamente scrivere

>>> settimana = (‘Lun’, ‘Mar’, ‘Mer’, ‘Gio’, ‘Ven’, ‘Sab’, ‘Dom’)

ma in realtà avremo creato un altro oggetto con la stessa etichetta.

A cosa servono le tuple?

Le tuple sono più veloci delle liste. Se state definendo un gruppo costante di valori e l’unica cosa che intendete farci è iterare al suo interno, usate una tupla invece di una lista.
Potete rendere più sicuro il vostro codice “proteggendo dalla scrittura” i dati che non devono essere modificati.

Le tuple possono essere convertite in liste e viceversa. La funzione built-in tuple prende una lista e ritorna una tupla con gli stessi elementi, mentre la funzione list prende una tupla e ritorna una lista. In effetti, tuple congela una lista e list scongela una tupla.

Possiamo controllare se un elemento è presente in una tupla:
>>> ‘Sabato’ in settimana
True

mentre
>>> ‘Giovanni’ in settimana
False

Inoltre possiamo controllare quale sia l’indice dell’elemento
>>> settimana[‘sabato’] 5

E poi possiamo estrarre un certo numero di elementi con lo slicing
>>> settimana[2:4]
(‘Mercoled\xc3\xac’, ‘Gioved\xc3\xac’)

\xc3\xac è la rappresentazione UTF-8 della lettera accentata.
UTF-8 è una codifica che ci permette di descrivere qualsiasi carattere, inclusi quelli di lingue tipo cinese o arabo.

In pratica i due valori all’interno delle parentesi quadre, indicano l’inizio e la fine delle fette. Qui dobbiamo aprire una parentesi:

Se usiamo un indice averemo una situazione tipo:
‘a’,’b’,’c’,’d’,’e’
0 1 2 3 4

Invece con lo slicing
‘a’,’b’,’c’,’d’,’e’
0 1 2 3 4 5

Per cui posto che abbiamo la tupla
>>> miatupla = (‘a’,’b’,’c’,’d’,’e’)
>>> miatupla[2:4]
(‘c’, ‘d’)

Questa cosa funziona anche con le stringhe come avremo occasione di vedere in seguito.

LISTE
Le liste sono simili alle tuple, ma sono modificabili e si inizializzano con le parentesi quadre.

>>> mia_lista = [1,2,3,4,5,6,7]python liste
>>> mia_lista
[1, 2, 3, 4, 5, 6, 7]

Ma possiamo aggiungere elementi alla lista
>>> mia_lista.append(8)
>>> mia_lista
[1, 2, 3, 4, 5, 6, 7,8]

>>> mia_lista.insert(2,10)
>>> mia_lista
[1, 2, 10, 3, 4, 5, 6, 7, 8]

>>> mia_lista.extend([11,12])
>>> mia_lista
[1, 2, 10, 3, 4, 5, 6, 7, 8, 11, 12]

Possiamo fare ricerche
>>> mia_lista.index(10)
2

E possiamo anche fare cose tipo:
>>> mia_lista[mia_lista.index(10)]
10

che ci conferma che index ha tornato il valore corretto.

Possiamo anche togliere elementi

>>> mia_lista.remove(10)
>>> mia_lista
[1, 2, 3, 4, 5, 6, 7, 8, 11, 12]

oppure
>>> mia_lista.pop()
12
>>> mia_lista
[1, 2, 3, 4, 5, 6, 7, 8, 11]

Ma non abbiamo finito, perché possiamo anche fare cose tipo
>>> mia_lista = mia_lista + [‘a’,’b’]
>>> mia_lista
[1, 2, 3, 4, 5, 6, 7, 8, 11, ‘a’, ‘b’]

>>> mia_lista += [‘c’]
[1, 2, 3, 4, 5, 6, 7, 8, 11, ‘a’, ‘b’, ‘c’]

>>> altra_lista = [1,2,3] * 3
>>> altra_lista
[1, 2, 3, 1, 2, 3, 1, 2, 3]

Inoltre una lista può avere come elementi altre liste, tuple e dizionari
>>> nuova_lista = [1,2,3,’a’,[‘AAA’, ‘BBB’], (1,2,3)]
>>> nuova_lista
[1, 2, 3, ‘a’, [‘AAA’, ‘BBB’], (1, 2, 3)]
>>> nuova_lista[2:5]
[3, ‘a’, [‘AAA’, ‘BBB’]] liste python

DIZIONARI
Un dizionario e’ una specie di lista dove l’indice non è il numero (progressivo) assegnato dalla lista stessa, in base all’ordine di apparizione e che è mutabile ma bensì un valore che decidiamo noi (un numero, una stringa etc.) e quindi immutabile.

Per contro una lista torna sempre nello stesso ordine (quello in cui sono ordinati gli elementi in base all’indice) mentre un dizionario può tornare ogni volta gli elementi in maniera differente. Se eseguiamo un
>>> mio_dizio = {1: ‘AAA’, ‘2’: ‘BBB’, ‘3’: ‘CCC’, 4: ‘DDD’}

e poi invochiamo diverse volte
>>> mio_dizio

non è garantito che tutte le volte torni lo stesso ordine, sopratutto se nel mezzo ho fatto operazioni (aggiunto, rimosso o modificato elementi).
Esiste una versione speciale l’OrderedDict che torna sempre nello stesso ordine, come una lista, ma si tratta di un caso differente, di cui parleremo in futuro.

Vediamo ora quali siano i metodi propri di un dizionario.
>>> mio_dizio = {“server”:”mpilgrim”, “database”:”master”}
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘database’: ‘master’}
>>> mio_dizio[“server”]
‘mpilgrim’
>>> mio_dizio[“database”]
‘master’
>>> mio_dizio[“mpilgrim”]
Traceback (innermost last):
File “<interactive input>”, line 1, in ?
KeyError: mpilgrim
python dizionario

Abbiamo definito un dizionario assegnandogli delle coppie chiave:valore, abbiamo fatto stampare il contenuto, abbiamo fatto stampare i valori delle due chiavi, ma quando abbiamo cercato di passare come chiave un contenuto abbiamo ricevuto un errore.

Vediamo ora come modificare un dizionario
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘database’: ‘master’}
>>> mio_dizio[“database”] = “pubs”
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘database’: ‘pubs’}
>>> mio_dizio[“uid”] = “sa”
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘pubs’}
dizionari python

In pratica abbiamo aggiunto una nuova chiave (uid) assegnandogli un valore con la semplice istruzione [‘uid’] = ‘sa’, e modificato il valore della chiave ‘database’ con un sistema analogo.
Se si indica una chiave esistente se ne modifica il valore, in caso contrario si aggiunge una coppia chiave:valore.

Notate che il nuovo elemento (chiave ‘uid’, valore ‘sa’) sembra trovarsi nel mezzo. Infatti è una semplice coincidenza che gli elementi appaiano ordinati nel primo esempio; è comunque una coincidenza anche il fatto che ora appaiano disordinati.

Un dizionario può, esattamente come le liste e le tuple, contenere elementi eterogenei.
Ecco un esempio
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘pubs’}
>>> mio_dizio[“retrycount”] = 3
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, ‘retrycount’: 3}
>>> mio_dizio[42] = “douglas”
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}

Per rimuovere un elemento da un dizionario si fa così
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> del mio_dizio[42]
>>> mio_dizio
{‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, ‘retrycount’: 3}
>>> mio_dizio.clear()
>>> mio_dizio
{}
dizionario python

del rimuove l’elemento con la chiave indicata, il metodo clear() invece rimuove tutte le coppie chiave:valore del dizionario, lasciando un dizionario vuoto.

In Python le stringhe usate come chiavi o nomi di variabili sono case sensitive, ovvero c’è differenza tra maiuscole e minuscole, come possiamo vedere qui di seguito
mio_dizio = {}
>>> mio_dizio[“key”] = “value”
>>> mio_dizio[“key”] = “other value”
>>> mio_dizio
{‘key’: ‘other value’}
>>> mio_dizio[“Key”] = “third value”
>>> mio_dizio
{‘Key’: ‘third value’, ‘key’: ‘other value’}

‘Key’ e ‘key’ sono due chiavi diverse tra loro.

Per avere un valore di una chiave inserita si possono usare due strade
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> mio_dizio[‘database’]
‘master’
>>> mio_dizio.get(‘database’)
‘master’

Il secondo e’ un metodo più chiaro, il primo è più immediato.

Se voglio l’elenco dei valori contenuti nel dizionario
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> mio_dizio.values()
[3, ‘douglas’, ‘master’, ‘sa’, ‘mpilgrim’]

che mi torna sotto forma di lista. In maniera simile posso avere l’elenco delle chiavi
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> mio_dizio.keys()
[‘retrycount’, 42, ‘database’, ‘uid’, ‘server’]

Ma posso anche farmi tornare una lista di tuple che contengono le coppie chiave:valore
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> mio_dizio.items()
[(‘retrycount’, 3), (42, ‘douglas’), (‘database’, ‘master’), (‘uid’, ‘sa’), (‘server’, ‘mpilgrim’)]

Per sapere se un dizionario contenga o meno una data chiave si puo’ usare il metodo has_key()
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> mio_dizio.has_key(‘server’)
True
>>> mio_dizio.has_key(‘nonserver’)
False

Oppure possiamo scrivere
>>> mio_dizio = {‘server’: ‘mpilgrim’, ‘uid’: ‘sa’, ‘database’: ‘master’, 42: ‘douglas’, ‘retrycount’: 3}
>>> ‘server’ in mio_dizio
True
>>> ‘nonserver’ in mio_dizio
False

Per farci tornare separatamente le coppie possiamo utilizzare un ciclo for come segue
>>> for key,value in mio_dizio.items():
>>> print key, value
retrycount 3
42 douglas
database master
uid sa
server mpilgrim

Bene per oggi chiudiamo qui.
Nella prossima lezione potremo dare una occhiata ad uno dei piu’ potenti strumenti che Python ci mette a disposizione: le List Comprehensions, che ci permettono di racchiudere in una sola stringa, di elevata leggibilità, istruzioni complesse per la gestione di stringhe, liste e dizionari.

Arrivederci alla prossima.

Altre letture utili:
Programmare con Python. Guida completa
Python
Programmare in Python

Nelle spire del Python (lezione 5): eseguire operazioni ripetitive

1 commento

python for

logo pythonEccoci qui per il quinto incontro. Oggi scopriremo come si eseguono operazioni ripetitive in Python.
Abbiamo due possibilità di eseguire operazioni ripetitive.
Per un preciso numero di volte oppure fino a che non si verifica una data condizione.

Prima possibilità: il FOR
L’istruzione FOR ci permette di eseguire un certo numero di iterazioni come segue
>>> for a in range(1, 10):
>>> print a
e otterremo come outputpython for
1
2
3
4
5
6
7
8
9

La funzione predefinita range prende due parametri, il valore iniziale e quello finale (in realtà si deve aumentare di uno il valore finale, capiremo tra breve perché) ed esegue un numero di iterazioni pari alla differenza tra i due (10-1 = 9) assegnando alla variabile “a” il valore conteggiato.

Ovviamente possiamo fare di meglio, ad esempio stampare solo i numeri dispari, con il seguente codice
>>> for a in range(1, 10, 2):for-2
>>> print a

che stamperà
1
3
5
7
9

Il secondo parametro indica lo step, ovvero di quanto si deve incrementare il contatore.

Ora facciamo un giochino.
Chi è uso a risolvere le parole crociate conosce quelle definizioni tipo “Arteria senza pari”, dove si devono scrivere solo le lettere dispari della parola.
Vediamo come Python ci viene in aiuto:

>>> parola = “arteria”for-3
>>> for a in range(0,len(parola),2):
>>> print parola[a]

a
t
r
a
la funzione len() ci torna la lunghezza della stringa che gli passiamo.
Quindi range con parametri 0, len(parola) e 2 ci permette di avere gli indici (posizioni delle lettere) dispari.
L’istruzione print parola[a] stampa la lettera che ha indice a.

Come dire se avessimo scritto
>>> print parola[3] avremmo ottenuto come output
r
che è la lettera nella quarta posizione (tenete conto che gli indici in Python iniziano sempre da 0).

In seguito vedremo come possiamo ritagliare solo una parte (substring o sottostringa) da una stringa, ma per ora ci basta l’indice.

Abbiamo visto quindi come fare un ciclo con un numero di iterazioni predefinito. Che sia con un valore fisso o con la lunghezza di una stringa, sempre un preciso numero di iterazioni avranno luogo.

Abbiamo pero’ la possibilita’ di eseguire un numero di iterazioni indefinite che terminano al verificarsi di una determinata condizione. Un poco come se iniziassimo un loop infinito (ciclo senza un valore limite maggiore) e ne uscissimo se una istruzione if <condizione>: si verifica.
Che poi si potrebbe fare con le istruzioni:
>>> from random import randintfor-4
>>> for x in iter(int, 1):
>>> print x
>>> if randint(1,9) == 3:
>>> break

stamperà 0 per un numero indefinito di volte.

Rieseguite le istruzioni più volte, al limite racchiudendole in una funzione con codice come il seguente:
>>> from random import randint
>>> def funzione():
>>> for x in iter(int, 1):
>>> print x
>>> if randint(1,9) == 3:
>>> break
>>> funzione()

Chiamando più volte funzione() non dovrete digitare tutte le volte il gruppo di istruzioni.

L’istruzione from random import randint importa dal package random la funzione randint.
randint con due parametri (i due estremi) genera un numero intero casuale tra i due estremi.
Quando il numero generato è uguale a 3 l’istruzione break interrompe il ciclo.
Però fare le cose cosi’ non è molto comodo. Facciamo pertanto conoscenza con l’istruzione while.

Seconda possibilità: il WHILE

>>> from random import randint
>>> while randint(1,9) != 3:
>>> print “ciao”

stamperà ciao un numero variabile di volte, in base a quando verrà generato il numero 3 da randint.
Ovviamente se allargassimo da 9 a 90 o a 900 il limite le probabilita’ che il ciclo termini diminuiranno in maniera proporzionale.

Abbiamo visto quindi come con while fino a che non si verifica la condizione abbiamo un ciclo.
Qui la condizione la impostiamo dall’istruzione.
Un ciclo infinito con while possiamo averlo con
>>> while 1 == 1:
>>> print “ciao”

Arrivederci alla prossima settimana.

Altre letture utili:
Programmare con Python. Guida completa
Python
Programmare in Python

Nelle spire del Python (lezione 4): come prendere decisioni

Lascia un commento

python or and

logo python Siamo arrivati al quarto incontro. Sarà il caso di vedere come prendere decisioni.
Per decidere possiamo usare l’istruzione
if condizione:
    codice assortito
altro codice a scelta
ovviamente se la condizione e’ verificata “codice assortito” verrà eseguito e poi verrà eseguito “altro codice a scelta”, altrimenti verrà eseguito solamente “altro codice a scelta”

Possiamo anche far fare qualcosa se la condizione non dovesse essere verificata, con l’istruzione
if condizione:
    codice assortito
else:
    codice alternativo
altro codice a scelta
“codice alternativo” verrà eseguito in alternativa a “codice assortito”. Al contrario del caso precedente uno dei due viene eseguito in ogni caso prima eseguire “altro codice a scelta”.

Abbiamo anche la possibilità di controllare differenti condizioni.
if condizione1:
    codice condizione1
elif condizione2:
    codice condizione2
altro codice a scelta
Se si verifica la condizione1 viene eseguito “codice condizione1”, se si verifica la condizione1 viene eseguito “codice condizione2”, in ogni caso viene eseguito “altro codice a scelta”

Ovviamente possiamo avere entrambe le cose:
if condizione1:
    codice condizione1
elif condizione2:
    codice condizione2
else:
    codice alternativo
altro codice a scelta

Vediamo quindi le condizioni con qualche esempio.
Un esempio è
a = input(“Inserire un valore: “)
if a < 0:
    print “Il valore inserito è negativo”
elif a > 0 and a <= 10:
    print “Il valore inserito e’ compreso tra 1 e 10”
elif a == 0:
    print “Il valore inserito è zero”
else:
    print “il valore inserito è maggiore di 10”
print “Abbiamo finito”

if-elif-else
Volutamente ho inserito una clausola elif che esegue due test
elif a > 0 and a <= 10:

In pratica se il valore inserito è maggiore di 0 e inferiore a 10 la condizione è verificata.

Abbiamo così scoperto anche il costrutto and che permette di legare assieme due condizioni.
Inoltre abbiamo una serie di operatori di comparazione
== uguale
< minore di
> maggiore di
<= minore o uguale di
>= maggiore o uguale di
!= diverso da

Oltre all’operatore and di congiunzione, abbiamo anche quello alternativo or che si usa come segue:
a = input(“Inserire un numero: “)
if a < 0 or a > 0:
print “A non e’ uguale a zero”
else:
print “A e’ uguale a zero”
python if

Si possono combinare anche entrambi MA si deve stare attenti alle precedenze. Per evitare sorprese è bene usare le parentesi per avere la certezza che otterremo quel che vogliamo.
a = input(“Inserire un numero”)
if (a > 0 or a < 0) and a != 100:
print “A differente da zero e da cento”
python or and

Abbiamo anche l’operatore di negazione not.
a = None
if not a:
print “1”
else:
print “2”
python if not
stamperà 1. Se invece scriviamo

a = 1
if not a:
print “1”
else:
print “2”
python if not
stamperà 2.

Arrivederci alla prossima settimana con i cicli.

Altre letture utili:
Programmare con Python. Guida completa
Python
Programmare in Python

Nelle spire del Python (lezione 3): giocare con i numeri

Lascia un commento

python numeri

logo pythonBene eccoci al terzo appuntamento con Python.
Dunque, abbiamo visto come stampare a video, cosa siano variabili costanti, come ricevere un input dall’utente, come scrivere delle funzioni e come passare loro dei parametri.
Sebbene ci sia ancora molto lavoro da fare, già qualcosa siamo in grado di farlo.
Ora vediamo come giocare con i numeri.

>>> 10 + 20
30
>>> 10 – 5
5
>>> 10 * 2
20
>>> 10 / 2
5
>>> 11 / 2
5

python numeri

Oops, sembra che qualcosa non abbia funzionato. 11 diviso 2 dovrebbe dare 5.5.
Per farlo dobbiamo dire all’interprete che almeno una delle due cifre è decimale. Proviamo così:
>>> 11.0 / 2
5.5

Possiamo anche farlo in maniera diversa:
>>> float( 11 ) / 2
5.5

Il metodo float (che è integrato nel sistema) è un casting, ovvero facciamo capire al sistema che il valore o la variabile vanno considerati come di un tipo diverso, nel nostro caso come cifra decimale invece che intera.

Per dire possiamo anche fare una cosa del tipo:
>>> float( “11” ) / 2
5.5

Eppure “11” è una stringa, se non ci credete potete scrivere
>>> type(“11”)
<type ‘str’>

Ma se è una stringa come può essere divisa per 2 e tornare per di più un valore decimale? E se scrivessimo
>>> int( “11” ) / 2
5

numeri python

Questa operazione (casting) può essere fatta anche all’opposto, da numero a stringa, ecco un esempio:

>>> type(“11”)
<type ‘str’>
>>> type( 11 )
<type ‘int’>
>>> type( str( 11 ) )
<type ‘str’>

numeri python

Python dove può esegue in automatico il casting, l’esempio della divisione (ma vale anche per le altre operazioni matematiche) ne è la prova: 11.0 è un numero decimale, 2 sarebbe un intero ma viene convertito (casting) in decimale (float) per poter eseguire correttamente l’operazione.
Ovviamente possiamo scrivere anche:
>>> 11 / 2.0
5.5

Se comunque volessimo conoscere il resto della divisione? Semplice
>>> 11 % 2
1
>>> 23 % 3
2
Attenzione, è il residuo, non la parte decimale.

Altri operatori che possiamo usare sono la divisione intera
>>> 13.0 // 2
6.0

Notate che se avessimo scritto invece
>>> 13.0 / 2
6.5

e l’elevamento a potenza
>>> 2 ** 2
4
>>> 2 ** 3
8
>>> 2 ** 4
16
>>> 2 ** 5
32

numeri python

Gli operatori hanno delle precedenze, per l’esattezza abbiamo
**
/,*, %
+,-

Questo comporta che se scriviamo
>>> 15 % 6 * 2 + 3
9

In pratica
>>> 15 % 6
3
>>> 3 * 2
6
>>> 6 + 3
9

Se volessimo invece ottenere che il risultato di 15 % 6 sia moltiplicato per 2 + 3?
>>> 15 % 6 * (2 + 3)
15

Perché diventa
>>> 15 % 6
3
>>> 3 + 2
5
>>> 3 * 5
15

Le parentesi sono importantissime quindi per essere certi dell’ordine di elaborazione dei comandi.

Esistono anche altri operatori, i cosidetti operatori di shift (>> e <<) e di confronto bitwise (&, ^ e |) ma che per ora esulano da quanto ci interessa sapere.

Una considerazione: Python e’ un linguaggio typed, ovvero una variabile una volta assegnata prende il tipo con cui viene assegnata. Per capirci:

>>> a = 1
>>> type(a)
<type ‘int’>
>>> b = 12.2
>>> type(b)
<type ‘float’>
>>> c = True
>>> type(c)
<type ‘bool’>
>>> d = ‘ciao’
>>> type(d)
<type ‘str’>

numeri python

Però se assegniamo alla variabile un differente tipo cosa accade?
La variabile (o meglio l’etichetta che gli abbiamo assegnato) viene collegata ad una nuova locazione di memoria (e quindi ad un differente valore).
Non ci credete? Vediamo:
>>> a = 1
>>> id(a)
34259288
>>> a = ‘ciao’
>>> id(a)
140531248445120

numeri python

Ovviamente i valori che otterrete saranno differenti da quelli che ho mostrato, sono gli indirizzi di memoria dove sono memorizzati i valori.
Ma quello che conta è che al cambiare dell’assegnazione non abbiamo una sovrascrittura ma una riassegnazione del valore.
Altri linguaggi che prevedono che una variabile sia inizializzata ad un certo tipo (intero, virgola mobile, stringa, booleano etc.) poi non permettono di cambiare il tipo.
Ovviamente questo ha i suoi pro e i suoi contro.

Altra cosa importante sul casting è che se scriviamo
>>> a = 1
>>> b = ‘ciao’
>>> a+b
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: unsupported operand type(s) for +: ‘int’ and ‘str’

Questo perché abbiamo cercato di sommare/accodare due tipi tra loro non compatibili. Se scriviamo:
>>> a = 1
>>> b = 2.4
>>> a+b
3.4

numeri python

Qui l’intero viene convertito automaticamente in float e poi i due numeri sono sommati tra loro.
Possiamo anche fare:
>>> a = ‘Ciao ‘
>>> b = ‘Guido’
>>> a+b
‘Ciao Guido’

Questo perché l’operatore + viene overloaded, ovvero cambia comportamento (sommare/accodare) a seconda dei casi. Volendo possiamo fare:
>>> a = 1
>>> b = ‘ ciao’
>>> str(a)+b
‘1 ciao’

Qui abbiamo eseguito un casting del numero in stringa e quindi l’operatore ha potuto valutare quale comportamento doveva avere (accodare).

Ultime cose: quando abbiamo provato a sommare/accodare un intero ed una stringa abbiamo ricevuto un messaggio di errore.
Il Traceback è un track dello stack degli errori che ci indica l’errore e dove si trova. Come vedremo prossimamnente se l’errore è in un file ci indicherà anche la riga esatta. Meglio di così.

Ultima cosa prima di chiudere, proviamo:
>>> 3 * ‘Ciao ‘
‘Ciao Ciao Ciao ‘

Se si moltiplica una stringa per un valore si ottiene la stringa ripetuta più volte. Ecco un esempio di quando torna particolarmente comodo:
>>> a = ‘Ciao \n’
>>> b = 20 * “-”
>>> print a + b
ciao

numeri python

Arrivederci alla prossima settimana.

Altre letture utili:
Programmare con Python. Guida completa
Python
Programmare in Python

Nelle spire del Python (lezione 2): variabili, funzioni e parametri

Lascia un commento

logo python

logo python

Nella seconda lezione del nostro corso di programmazione Python ci occupiamo ancora del comando print.

Una cosa particolare del comando è che permette di definire parti della stringa stampata come sottostringhe variabili, così da avere un dinamismo nell’uso.

Un esempio banale:
>>> print “Ciao %s!” % “Mario”
Ciao Mario!

CiaoMario

Come vedete abbiamo definito un placeholder %s (che significa che si attende una stringa) all’interno della stringa da stampare e dopo il comando %, posto dopo la chiusura della stringa, abbiamo passato una stringa da stampare.

Certo che così risulta essere abbastanza inutile, tanto vale scrivere Mario al posto di %s e evitare tutto il resto.

Ma se al posto della stringa “Mario” poniamo una variabile, ovvero un contenitore di valori che possono mutare nel tempo[1], potremo far stampare quello che ci pare.

Ecco un esempio di applicazione complessa.

Andremo per gradi, nella prima versione definiremo una variabile poi la passeremo come argomento a print.

>>> nome = “Giovanni”
>>> print “Ciao %s!” % nome
Ciao Giovanni!

Adesso proviamo a farci dire dall’utente cosa stampare. Per farlo dovremo introdurre un nuovo comando, raw_input.

>>> nome = raw_input(“Inserisci il nome: “)
Inserisci il tuo nome e premi il tasto ENTER:

Poniamo di inserire Luigi, a seguire scriveremo

>>> print “Ciao %s!” % nome
Ciao Luigi!

ciao luigi

Complichiamo le cose. Facciamo sì che si scriva una volta sola il codice e si possa usare molte volte. Per farlo creeremo una funzione che verrà poi richiamata.

>>> def stampa_nome():
>>>
>>> print “Ciao %s” % nome

Il codice inizia con l’assegnazione di un nome alla funzione, per mezzo dell’istruzione def seguita dal nome della funzione[2] con due parentesi tonde, dentro cui possiamo, volendo passare dei parametri[3] e per finire il segno dei : (due punti) che implica la fine della riga.

>>> def stampa_nome():

Le righe seguenti, fino al termine della definizione della funzione stessa, saranno indentate di alcuni caratteri, sempre lo stesso numero, mi raccomando, per definire il blocco.

In altri linguaggi (derivati come sintassi dal C, come Java C++, C# e PHP) si utilizzano le parentesi graffe aperte e chiuse per definire un blocco { }, altri (pascal) usano due statement begin e end.

Python ha scelto la via più semplice, che richiede meno sforzo, e rende più leggibile il codice prodotto.

L’indentazione di solito e’ di 4 spazi (preferibile usare spazi anziché tabulazioni[4]) ma c’è chi ne usa 2 o 3 o persino 8.

Le due righe successive nell’esempio sono rientrare di 4 spazi (oltre a quello che subito dopo il prompt >>> che mettiamo solo per aumentare la leggibilità ma va ignorato da voi quando trascrivete gli esempi).

A questo punto se scriveremo

>>> stampa_nome()

otterremo

Inserisci il tuo nome e premi il tasto ENTER:
Ciao Luigi!

Sempre che si sia scritto Luigi prima di premere Enter.

Ultima versione e con questa terminiamo questo secondo incontro, qui useremo due funzioni, cosi da vedere come si passino dei parametri.

>>> def inserisci_nome():
>>> nome = raw_input(‘Inserisci il tuo nome: ‘)
>>> stampa_nome( nome )
>>>
>>> def stampa_nome( nome ):
>>> print “Ciao %s” % nome

Qui abbiamo due funzioni, la prima, inserisci_nome, chiede il nome e poi chiama la seconda, stampa_nome, passandogli la variabile nome come parametro.

Per lanciare il tutto possiamo scrivere

>>> inserisci_nome()

ma volendo possiamo anche scrivere

>>> stampa_nome( ‘Guido’ )

che stamperà

Ciao Guido!

inserisci nome

Alla prossima lezione ragazzi.
E … scrivete chiedendo tutto quello che vi salta in mente.
[1]. Si chiamano variabili perché possono variare, in informatica delle variabili immutabili sono definite costanti, perché una volta definite non cambiano mai. Per convenzione in quasi tutti i linguaggi si definiscono con tutte lettere maiuscole.

[2]. Per convenzione le funzioni sono definite con lettere minuscole e l’underscore _ come separatore.
Si tratta di convenzioni, siete liberi di violarle, ma a parte la maledizione del faraone VanRossumkhamen che si abbatterà su di voi, scriverete del codice fuori standard e sarete deprecati sulla pubblica piazza dall’intera comunità dei puristi del linguaggio. Quindi se lo fate lo farete a vostro rischio e pericolo.

[3]. I parametri di una funzione sono delle variabili che si passano alla funzione stessa. C’è un altro modo di usare variabili che siano utilizzabili dalla funzione, ed è quello di usare variabili cosiddette “globali”. Per motivi che capirete più avanti questa pratica e’ sconsigliata.

[4]. Usando spazi si è certi che le spaziature rimangano sempre tali anche quando il testo viene convertito ad esempio in HTML, PDF, Epub etc.

Altre letture utili:

Programmare con Python. Guida completa

Python

Programmare in Python

Nelle spire del Python (lezione 1): il comando print

Lascia un commento

console python

Questo è il primo di una serie di post che definiscono un vero e proprio corso di programmazione sul linguaggio Python.

Con questo articolo Carlos Catucci inizia la collaborazione con il blog openoikos, diventandone un autore.

Se altri volessero proporre altri contenuti, compatibilmente alle tematiche del sito, troveranno la stessa ospitalità.

python_sh-150x150Il linguaggio Python è stato creato da Guido Van Rossum, insignito del titolo di “benevolo tiranno a vita” dagli appassionati utilizzatori del linguaggio stesso.

Il Python è un linguaggio particolarmente attento alla pulizia e alla semplicità  del codice, multipiattaforma (gira persino su tablet e smartphone).

Si tratta di un linguaggio ad alto livello, molto “natural speaking”, con una sintassi elegante.

guido van rossum
Guido Van Rossum

Python è anche un liguaggio semi-interpretato, un poco come Java, visto che gli applicativi per girare richiedono un runtime ovvero una virtual machine, che fa girare codice meta-compilato.

O meglio, per essere precisi, lo fa se trova il meta-compilato e quest’ultimo ha una data di creazione uguale o maggiore del sorgente; in caso contrario provvede prima a ricompilare (o compilare se non esiste il meta-compilato) i sorgenti. Ed in questo è nettamente superiore a Java.

Viene usato dalla NASA per applicazioni di calcolo complesse, dalla Industrail Light and Magic, e da tantissime altre aziende.

Ma sopratutto ci sono moltissimi applicativi software scritti in Python. E in particolare ce ne sono tantissimi di grafica scritti o scriptabili in Python.

Lo scopo di questi articoli e’ di fornire un corso di programmazione del linguaggio, ma non uno dei soliti corsi sterili dove qualcuno impartisce lezioni programmate e se non avete capito e’ un vostro problema.

L’idea è di creare un corso che si dipana in base alle domande/richieste delle persone che vorranno seguirlo. Si inizia con questa prima lezione dove ci approcciamo al linguaggio, e vediamo con qualche esempio come funzioni. Se chi deciderà di seguirlo mi farà  domande o richieste, cercherò’ di proseguire seguendo le indicazioni.

 Cominciamo a vedere come funziona un programma Python.

Per lanciare un programma serve una console, quindi su Linux/MacOsX aprirete una console, su Windows una Command (mi scuso fin d’ora per eventuali imprecisioni nell’utilizzo di Windows, sono anni che lo evito).

Una volta aperta la nostra console digiteremo python.

Scusate, dimenticavo, su macchine Windows dovete prima installare Python, gli altri sistemi operativi lo includono di serie. Speriamo che a Redmond prima o poi si facciano furbi.

console python
console di python

Dopo avere digitato il comando python apparira un prompt composto da tre simboli maggiore (>>>).

Quindi quando vedrete scritto qualcosa tipo: 

>>> print “Ciao mondo” 

potete ignorare i 3 > e il primo spazio successivo. Per eseguire dovrete scrivere solamente 

print “Ciao mondo” 

Ecco che senza intenzione abbiamo eseguito il primo programma Python che, en passant, è anche il tipico “primo programma” che viene eseguito nei tutorial di ogni linguaggio. 

Subito dopo il prompt troveremo quanto abbiamo indicato all’interno dei doppi apici, ovvero 

Ciao mondo 

Ecco come viene il tutto: 

>>> print “Ciao mondo”

Ciao mondo

>>> 

La parte tra doppi apici è una stringa che vogliamo far stampare a video, mentre print è una istruzione che indica all’interprete di stampare quanto segue.

Certo cosi’ sembra davvero poco pratico, ma scopriremo piano piano come sia potente l’istruzione print (e anche il resto).

Per prima cosa dobbiamo dire che oltre ai doppi apici possiamo, se preferiamo, racchiudere tra apici singoli, per python non fa differenza alcuna. Quindi se volessimo virgolettare una frase all’interno della stringa potremmo scrivere 

>>> print ‘E Giovanni disse: “Ciao amici, come state?” 

Ma cosa accadrebbe se all’interno della stringa fosse presente anche un’apostrofo (ovvero un apice singolo)? Per ovviare a questo problema (e ad un altro che vedremo subito dopo) esiste la possibilità  di racchiudere la stringa tra 3 apici (singoli o doppi). 

>>> print “””E Giovanni disse: “Salve amici, dov’eravate finiti?”. Non ottenne alcuna risposta.””” 

Il secondo vantaggio del triplice apice lo troviamo perché possiamo spezzare la stringa su più righe senza che sia necessario usare un simbolo di continuazione (nello specifico sarebbe la barra invertita, il simbolo \ in pratica, detto counterslash, ma lo vedremo in seguito).

Potremo quindi avere un qualcosa del tipo: 

>>> print “””E Giovanni disse:

“Salve amici, dov’eravate finiti?”.

Non ottenne alcuna risposta.””” 

L’interprete sa che fino a che non verranno chiusi i tripli apici, il comando non è completo. 

Per questa volta chiudiamo qui l’articolo, ma nella prossima lezione vedremo di capire cosa siano le variabili e che uso se ne possa fare assieme al comando print.

 

Altre letture utili:

Programmare con Python. Guida completa

Python

Programmare in Python

Barra laterale primaria

Scarica gratis i nostri software

Prenota il video corso

Partecipa al nostro forum

forum nanocad italia

Post in evidenza

software computi gratuiti

I migliori 3 software gratuiti per computi metrici

blocchi cad gratis

I migliori siti per scaricare blocchi CAD gratis

video tutorial autocad

I migliori video tutorial gratuiti su AutoCAD

come impostare scala autocad

Il CAD e l’equivoco delle scale

retini nanocad

Come aggiungere nuovi retini a nanoCAD free

sistemi riferimento italia

Tutorial QGIS 4: i Sistemi di Riferimento più usati in Italia

proiezioni geografiche

Tutorial QGIS 3: la rappresentazione della Terra ed i Sistemi di Riferimento

formati qgis

Tutorial QGIS 2: i formati dell’informazione geografica

logo qgis

Tutorial QGIS 1: l’evoluzione dell’informazione geografica e il GIS open source

alternative autocad lt

Le alternative gratis ad AutoCAD LT per il CAD 2D

OPENOIKOS di Fabrizio Pieri - P.IVA 02181310562 - email: openoikos@gmail.com