Guida a Python - Corso base - Capitolo 2: tipi di dati: numeri, booleani, none, char, stringhe. Lo slicing

Capitolo 2: Tipi di dati: numeri, booleani, none (null), caratteri, stringhe. Lo slicing.

In Python, una variabile viene creata semplicemente specificandone il nome ed assegnandole un valore, senza preoccuparsi di doverne definire il tipo.

I tipi di dati primitivi di Python, comuni anche ad altri linguaggi sono:

• dati numerici (interi e a virgola mobile);
• booleani (True / False);
• None;
• stringhe (e caratteri, che sono stringhe con un solo elemento).

L'insieme dei dati primitivi di Python è poi arricchito dalla presenza di tipi più "complessi":

• liste;
• insiemi;
• tuple;
• dizionari.

Li prenderemo tutti in esame.

Sarà poi possibile, ovviamente, definire nuove classi, ciascuna con proprio campi e metodi.

Per definire una variabile numerica, in Python, sarà sufficiente quindi scrivere:

nomeVariabile = valore;

Il limite di dimensione di un numero è quello dato dalla memoria del computer.

Esempi:

>>> a = 5;

>>> b = a / 2;

>>> print a, b

5 2

 

Attenzione ! Python ha effettuato un arrotondamento ad intero ! Per specificare valori in virgola mobile, dichiarateli con il .0 finale (la virgola dei valori decimali, in Python, viene resa con il punto . ), ad esempio così:

>>> c = 2.0
>>> print c
2.0

o effettuate un casting esplicito (conversione di tipo forzata; ne riparleremo più avanti) (utile nel caso di variabili intere inserite in espressioni), ad esempio così:

>>> b = float(a) / 2
>>> print b
2.5

Il tipo float identifica, appunto, i valori in virgola mobile, e con float(n) possiamo convertire in float il valore numerico n; allo stesso modo, con int(p) possiamo convertire in intero (privo di valori decimali) il parametro p.

Un variabile può anche essere convertita "al volo", assegnandole... se stessa:

>>> b = float(a) / 2
>>> print b
2.5
>>> b = int(b)
>>> print b
2
>>>

E' possibile anche definire numeri complessi, utilizzando i suffissi J o j:

>>> valore = 5 - 2j
>>> print valore
(5-2j)

e ricavarne le parti reali e immaginarie mediante i campi (parleremo di campi e metodi degli oggetti in maniera più approfondita in seguito) real e imag:

>>> print valore.real
5.0
>>> print valore.imag
-2.0
>>>

In Python, i valori booleani sono: True e False.

E' possibile creare una variabile booleana semplicemente assegnandole o True o False, SENZA apici, altrimenti staremo definendo delle stringhe ("True" e "False"), e non dei booleani !

Scriveremo dunque, ad esempio:

>>> mioTrue = True

>>> mioFalse = False

Scrivere, invece,

>>> stringa1 = "True"

>>> stringa2 = "False"

comporterà la creazione di due STRINGHE.

Il tipo None identifica... un valore nullo, senza tipo ! In altri linguaggi, la sua controparte è null.

Può essere utilizzato, ad esempio, per creare una variabile senza darle un valore preciso (magari perchè ancora non è disponibile, ma va calcolato), ad esempio con:

>>> nullo = None
>>> print nullo
None
>>>

Le stringhe (parole, insiemi di caratteri) e caratteri (singole lettere, viste da Python come stringhe formate da un solo elemento) vanno create assegnando ad una variabile una o più lettere racchiuse tra apici o doppi apici:

>>> stringa1 = 'miaStringa1'
>>> stringa2 = "miaStringa2"
>>> print stringa1, stringa2
miaStringa1 miaStringa2
>>>

In realtà, non abbiamo un tipo di dato a parte per i caratteri: si tratta di stringhe di un solo elemento.

Le stringhe sono immutabili, nel senso che non è possibile sostituire una parte di una stringa; per modificare una stringa, occorre riassegnarla completamente.

E' possibile effettuare delle concatenazioni di stringhe mediante il segno + :

>>> stringa1 = "stringa1"
>>> stringa2 = "stringa2"
>>> stringa3 = stringa1 + "; " + stringa2
>>> print stringa3
stringa1; stringa2
>>>

Oltre a concatenare due stringhe, possiamo anche moltiplicare una stringa per un numero: l'effetto sarà quello di ripetere la stringa per quel dato numero di volte; es.:

>>> prova = "prova"
>>> prova = prova * 5
>>> print prova
provaprovaprovaprovaprova
>>>

Con le stringhe è possibile utilizzare particolari caratteri, detti caratteri di escape, che implementano operazioni particolari all'interno di una stringa (gli effetti saranno visibili in fase di visualizzazione della stringa):

• \n   : "line feed" (ritorno a capo)
• \b   : "backspace"
• \t   : "tab"

Es:

>>> stringa = "Ciao come stai ?\nBene, grazie !\tTu ?"
>>> print stringa
Ciao come stai ?
Bene, grazie ! Tu ?
>>>

Le stringhe sono, in realtà, degli oggetti non banali, provvisti di un gran numero di metodi; es.:

• il metodo find("[carattere]") cerca il carattere passato come parametro nella stringa e restituisce l'indice (la posizione) di tale carattere, se presente; in caso di più risultati, restituirà l'indice della prima occorrenza di [carattere], restituirà, infine, -1 qualora [carattere] non dovesse essere trovato:

>>> prova = "ciao come stai ?"
>>> prova.find("c")
0
>>> prova.find("i")
1
>>> prova.find("x")
-1
>>>

• il metodo strip() rimuove gli spazi all'inizio e alla fine della stringa;
• il metodo replace(sottostringa1, sottostringa2) sostituisce la porzione di stringa "sottostringa1" con la stringa "sottostringa2", come mostra l'esempio:

>>> stringaoriginale = "Ciao a tutti !"
>>> stringa2 = stringaoriginale.replace("a tutti", "amico mio")
>>> print stringa2
Ciao amico mio !
>>>

• il metodo split("[stringa di splitting]") suddivide la stringa in più parti ad ogni occorrenza di "[stringa di splitting]"; le varie stringhe "generate" verranno inserite in un oggetto di un particolare tipo, la lista, che tratteremo nel prossimo capitolo; es.:

  >>> prova.split(" ")
  ['ciao', 'come', 'stai', '?']
  >>>

• il metodo join unisce gli elementi presenti in una lista in un'unica stringa, separandoli con la stringa che invoca tale metodo; esempio:

>>> nuovaStringa = " ".join(['ciao', 'come', 'stai', '?'])
>>> print nuovaStringa
ciao come stai ?
>>>

Per una trattazione completa, si rimanda alla documentazione ufficiale di Python.

Una tecnica utilizzabile sulle stringhe e su tutti gli oggetti "iterabili" (ossia, composti da sequenze di oggetti, sulle quali (le sequenze) è possibile effettuare un'iterazione, per "scorrerle"; le stringhe sono, in effetti, sequenze ordinate di caratteri) è quella dello "slicing" (lett.: tagliare a fette): attraverso la notazione

elementoIterabile[indicePartenza : indiceArrivo]

è possibile estrapolare una parte di un elemento, in particolare quella racchiusa tra l'indice indicePartenza e l'indice indiceArrivo; se NON specificheremo uno dei due indici, Python interpreterà la cosa come "dall'inizio" (se non specificheremo il primo indice) o "fino alla fine" (se non specificheremo l'ultimo).

Esempi:

>>> stringa = "Ciao come stai ?"
>>> stringa1 = stringa[:2]
>>> print stringa1
Ci
>>> stringa2 = stringa[3:5]
>>> print stringa2
o
>>> stringa3 = stringa[5:]
>>> print stringa3
come stai ?
>>>

In Python, le stringhe sono immutabili, per cui non potremo usare lo slicing per riscrivere porzioni di una stringa, mentre potremo farlo con altri tipi di dati come le liste, come vedremo.

NOTA: è possibile recuperare velocemente l'ultimo carattere di una stringa (e, in generale, l'ultimo elemento di un oggetto iterabile) con:

[-1]

Esempio:

>>> stringa = "Ciao come stai ?"
>>> ultimoElemento = stringa[-1]
>>> print ultimoElemento
?
>>> print stringa[-1]
?
>>> stringa[-1]
'?'
>>>