parte 5° alfabeto informatico

Così ogni elemento in una lista può essere indicizzato in due modi differenti: dall'inizio della lista e dalla fine della lista.
Un'altro metodo molto funzionale per estrarre elementi da una lista sono le sezioni. Ecco un'altro esempio per avere un'idea di come usarle:
>>> list = [0,'Fred',2,'S.P.A.M.','Stocking',42,"Jack","Jill"]
>>> list[0]
0
>>> list[7]
'Jill'
>>> list[0:8]
[0, 'Fred', 2, 'S.P.A.M.', 'Stocking', 42, 'Jack', 'Jill']
>>> list[2:4]
[2, 'S.P.A.M.']
>>> list[4:7]
['Stocking', 42, 'Jack']
>>> list[1:5]
['Fred', 2, 'S.P.A.M.', 'Stocking']
Le sezioni sono utilizzate per estrarre parti di liste. La sintassi per estrarre sezioni è list[primo_indice:ultimo_indice]. La sezione selezionata va da primo_indice all'indice prima di ultimo_indice. È possibile utilizzare entrambi i metodi di indicizzazione:
>>> list[-4:-2]
['Stocking', 42]
>>> list[-4]
'Stocking'
>>> list[-4:6]
['Stocking', 42]
Un'altro trucco con le sezioni è non specificare l'indice. Se il primo indice non viene specificato, Python assumerà il primo indice della lista come indice da cui partire. Se il successivo indice non è specificato, si intenderà tutto il resto della lista. Ecco altri esempi:
>>> list[:2]
[0, 'Fred']
>>> list[-2:]
['Jack', 'Jill']
>>> list[:3]
[0, 'Fred', 2]
>>> list[:-5]
[0, 'Fred', 2]
Ancora un'altro programma d'esempio (copiate ed incollate, se volete, la definizione di poem):
poem = ["<B>","Jack","and","Jill","</B>","went","up","the","hill","to","<B>",\
"fetch","a","pail","of","</B>","water.","Jack","fell","<B>","down","and",\
"broke","</B>","his","crown","and","<B>","Jill","came","</B>","tumbling",\
"after"]

def get_bolds(list):
true = 1
false = 0
## Dichiara is_bold come falso, quindi stiamo guardando una
## porzione di testo non in grassetto.
is_bold = false
## start_block rappresenta l'indice delle porzioni di testo in
## grassetto.
start_block = 0
for index in range(len(list)):
## TAG che rappresenta l'inizio del grassetto.
if list[index] == "<B>":
if is_bold:
print "Error: Extra Bold"
##print "Not Bold:",list[start_block:index]
is_bold = true
start_block = index+1
## TAG che rappresenta la fine del grassetto.
## Ricordate che l'ultimo numero in una sezione
## rappresenta l'indice e dopo l'ultimo indice usato.
if list[index] == "</B>":
if not is_bold:
print "Error: Extra Close Bold"
print "Bold [",start_block,":",index,"] ",\
list[start_block:index]
is_bold = false
start_block = index+1

get_bolds(poem)
E questo è l'output:
Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']
La funzione get_bold scorre una lista dividendola in parole e chiamate. Le chiamate che cerca sono <B> che inizia il testo in grassetto e <\B> che lo termina. La funzione get_bold ricerca l'inizio e la fine delle chiamate.
La prossima funzione delle liste è la copia. Se volete, potete provare questo semplice esempio:
>>> a = [1,2,3]
>>> b = a
>>> print b
[1, 2, 3]
>>> b[1] = 10
>>> print b
[1, 10, 3]
>>> print a
[1, 10, 3]
Probabilmente vi sorprenderà in quanto una modifica a b modifica anche a. Questo grazie all'istruzione b = a che restituisce b come riferimento ad a. Significa che b non è altro che un'altro nome per riferirsi ad a, il risultato è che una modifica a b è una modifica ad a. Ciò nonostante alcune tipologie di assegnamento non significano la creazione di un doppio nome per una lista:
>>> a = [1,2,3]
>>> b = a*2
>>> print a
[1, 2, 3]
>>> print b
[1, 2, 3, 1, 2, 3]
>>> a[1] = 10
>>> print a
[1, 10, 3]
>>> print b
[1, 2, 3, 1, 2, 3]
In questo caso b non è un riferimento ad a in quanto l'istruzione a*2 crea una nuova lista. b quindi si riferisce ad a*2 e non ad a. Tutti gli assegnamenti creano un riferimento. Quando passate una lista come argomento ad una funzione create un riferimento. La maggior parte delle volte non dovrete preoccuparvi di creare un riferimento anziché una copia. Tuttavia, quando dovete modificare una lista senza cambiarne un'altra, assegnata ad un nome differente, dovete assicurarvi di aver creato una copia e non un riferimento.
Esistono diversi modi per copiare una lista. Il modo più semplice è usare le sezioni poiché creano sempre una nuova lista perfino se la sezione comprende tutta la lista:
>>> a = [1,2,3]
>>> b = a[:]
>>> b[1] = 10
>>> print a
[1, 2, 3]
>>> print b
[1, 10, 3]
La sezione [:] crea una nuova copia della lista. In questo modo si può copiare una lista, ma qualsiasi sottolista creata in seguito si riferirà alla rispettiva sottolista della lista originale. Potete ovviare al problema copiando anche le sottoliste usando la funzione deepcopy del modulo copy:
>>> import copy
>>> a = [[1,2,3],[4,5,6]]
>>> b = a[:]
>>> c = copy.deepcopy(a)
>>> b[0][1] = 10
>>> c[1][1] = 12
>>> print a
[[1, 10, 3], [4, 5, 6]]
>>> print b
[[1, 10, 3], [4, 5, 6]]
>>> print c
[[1, 2, 3], [4, 12, 6]]
Innanzitutto notate che a è una lista di liste. L'istruzione b[0][1] = 10 cambia sia la lista b che la lista a, mentre c rimane inalterata. Questo accade perché b continua ad essere un riferimento ad a se vengono utilizzate le sezioni; c invece è una copia completa, ottenuta grazie alla funzione deepcopy.
Perciò dovrete preoccuparvi dei riferimenti ogni volta che userete la funzione ``=''? La buona notizia è che dovrete occuparvi dei riferimenti solamente quando utilizzate dizionari e liste. Numeri e stringhe creano dei riferimenti, ma quando vengono modificati creano una copia, quindi non potrete mai modificarli inaspettatamente.
Adesso vi starete probabilmente chiedendo perché vengono usati i riferimenti. La motivazione, sostanzialmente, è la loro velocità. È molto più veloce fare un riferimento ad una lista di migliaia di riferimenti che copiarli tutti. Un'altra ragione è che permettono di avere una funzione che modifichi una lista o un dizionario. Tenete in considerazione tutto questo se vi troverete ad avere strani errori in relazione a dati modificati quando quest'ultimi non avrebbero dovuto subire alcun cambiamento.
14. La rivincita delle stringhe
Ora presenteremo un trucco che può essere usato con le stringhe:
def shout(string):
for character in string:
print "Gimme a "+character
print "'"+character+"'"

shout("Lose")

def middle(string):
print "The middle character is:",string[len(string)/2]

middle("abcdefg")
middle("The Python Programming Language")
middle("Atlanta")
E l'output è:
Gimme a L
'L'
Gimme a o
'o'
Gimme a s
's'
Gimme a e
'e'
The middle character is: d
The middle character is: r
The middle character is: a
Questo programma dimostra che le stringhe sono per alcuni aspetti simili alle liste. La procedura shout dimostra che un ciclo for può essere usato con le stringhe esattamente nello stesso modo in cui veniva usato con le liste. La procedura middle mostra come possa essere utilizzato il len anche con le stringhe, così come gli indici e le sezioni. Molte funzionalità delle liste funzionano con le stringhe.
La prossima funzione utilizzerà alcune funzionalità specifiche delle stringhe:
def to_upper(string):
## Converte la stringa in maiuscolo.
upper_case = ""
for character in string:
if 'a' <= character <= 'z':
location = ord(character) - ord('a')
new_ascii = location + ord('A')
character = chr(new_ascii)
upper_case = upper_case + character
return upper_case

print to_upper("This is Text")
Con l'output che è:
THIS IS TEXT
Il motivo per cui questo codice funziona è che il computer rappresenta i caratteri delle stringhe come numeri da 0 a 255. Python ha una funzione chiamata ord (abbreviazione di ordinale) che ritorna un carattere come un numero. Esiste anche una funzione corrispondente chr che converte un numero in un carattere. Capito questo, il programma dovrebbe essere chiaro. Il primo dettaglio è la linea: if 'a' <= character <= 'z': che controlla se la lettera è minuscola. Se è così, allora prosegue alla linea successiva. La linea: location = ord(character) - ord('a') converte i numeri corrispondenti alle lettere nel codice ASCII, in numeri da 0 a 36, quindi la linea new_ascii = location + ord('A') converte la lettera minuscola in maiuscola.
Adesso, qualche esercizio interattivo da digitare:
>>> # Da intero a stringa.
...
>>> 2
2
>>> repr(2)
'2'
>>> -123
-123
>>> repr(-123)
'-123'
>>> # Da stringa a intero.
...
>>> "23"
'23'
>>> int("23")
23
>>> "23"*2
'2323'
>>> int("23")*2
46
>>> # Da decimale a stringa.
...
>>> 1.23
1.23
>>> repr(1.23)
'1.23'
>>> # Da decimale a intero.
...
>>> 1.23
1.23
>>> int(1.23)
1
>>> int(-1.23)
-1
>>> # Da stringa a decimale.
...
>>> float("1.23")
1.23
>>> "1.23"
'1.23'
>>> float("123")
123.0
Se non l'avete ancora indovinato, la funzione repr converte un intero in stringa e la funzione int converte una stringa in intero. La funzione float converte una stringa in un numero in virgola mobile. La funzione repr ritorna una rappresentazione stampabile di qualcosa. Ecco alcuni esempi di quanto detto:
>>> repr(1)
'1'
>>> repr(234.14)
'234.14'
>>> repr([4,42,10])
'[4, 42, 10]'
La funzione int prova a convertire una stringa (o un numero in virgola mobile) in un intero. Esiste anche una funzione simile, float che converte un numero intero in numero in virgola mobile. Un'altra funzione di Python è eval che ritorna il tipo di dato che viene immesso. La funzione eval prende una stringa e ritorna i dati che Python rileva. Per esempio:
>>> v=eval('123')
>>> print v,type(v)
123 <type 'int'>
>>> v=eval('645.123')
>>> print v,type(v)
645.123 <type 'float'>
>>> v=eval('[1,2,3]')
>>> print v,type(v)
[1, 2, 3] <type 'list'>
Se usate la funzione eval dovete controllare il valore che ritorna per assicurarvi che sia quello che vi aspettate.
Un'altra funzione utile in string è split. Questo è un esempio:
>>> import string
>>> string.split("This is a bunch of words")
['This', 'is', 'a', 'bunch', 'of', 'words']
>>> string.split("First batch, second batch, third, fourth",",")
['First batch', ' second batch', ' third', ' fourth']
Notate come split converte una stringa in una lista di stringhe. La stringa viene divisa in corrispondenza di ogni spazio o di un secondo argomento (in questo caso la virgola).
14.1 Esempi
# Questo programma richiede un'eccellente conoscenza dei numeri
# decimali.

def to_string(in_int):
"Converts an integer to a string"
out_str = ""
prefix = ""
if in_int < 0:
prefix = "-"
in_int = -in_int
while in_int / 10 != 0:
out_str = chr(ord('0')+in_int % 10) + out_str
in_int = in_int / 10
out_str = chr(ord('0')+in_int % 10) + out_str
return prefix + out_str

def to_int(in_str):
"Converts a string to an integer"
out_num = 0
if in_str[0] == "-":
multiplier = -1
in_str = in_str[1:]
else:
multiplier = 1
for x in range(0,len(in_str)):
out_num = out_num * 10 + ord(in_str[x]) - ord('0')
return out_num * multiplier

print to_string(2)
print to_string(23445)
print to_string(-23445)
print to_int("14234")
print to_int("12345")
print to_int("-3512")
L'output è: