Le Stringhe

In Python le stringhe sono sequenze di caratteri, in codifica Unicode UTF-8, che , una volta definite, non possono essere modificate. Tutto quello che abbiamo visto per le sequenze si applica anche alle stringhe; in questa parte riassumiamo e completiamo le informazioni sulle stringhe.

Nel codice Python le stringhe sono rappresentate come una sequenza di caratteri fra apici. Possono essere utilizzati indifferentemente apici singoli, oppure il doppio apice. Se una stringa e' delimitata da apici singoli puo' contenere doppi apici e viceversa, ad esempio sono stringhe valide:

'12345"6789'
"12345'6789"

Una stringa puo' essere vuota; una stringa vuota e' definita da:

a=''

Una stringa puo' essere composta da piu' linee, se delimitata da tre apici o tre doppi apici, esempio:

''' questa stringa
continua in questa riga '''

"""
altra stringa multilinea
anche questa linea fa parte della stringa """

Stringhe una dietro l'altra sono concatenate, anche se sono separate da spazi:

a='abcd' 'efg'
a== "abcdefg"

Entro le stringhe hanno significato particolare alcune sequenze precedute da backslash : "\" Alcune di queste sono un residuo delle codifiche che venivano utilizzate il controllo del carrello per le stampanti a modulo continuo, altre sono usate per inserire valori in diverse codifiche.

La decodifica di questi caratteri speciali non avviene nelle stringhe "raw", che sono indicate dalla lettera r prima della stringa, ad esempio:

a=r"12n4g"

Alcuni di queste sequenze speciali sono:

\\ : e' il carattere "\" (Backslash)

\' : apice singolo '

\" : doppio apice "

\a : e' un suono di allarme (ASCII Bell (BEL) )

\b : indica indietro un carattere (ASCII Backspace (BS) )

\f : indica che si va a capo (ASCII Formfeed (FF) )

\n : indica che si va a capo (ASCII Linefeed (LF))

\r : indica che si va a capo (ASCII Carriage Return (CR))

\t : tabulazione orizzontale (ASCII Horizontal Tab (TAB))

\v : tabulazione verticale (ASCII Vertical Tab (VT))

\xhh : carattere in notazione esadecimale ( hh sono le cifre esadecimali)

\ooo : carattere in notazione ottale ( ooo sono le cifre ottali)

\0 : carattere nullo

Per specificare la codifica unicode si possono usare le notazioni:

\uxxxx : ove xxxx sono cifre esadecimali

\Uxxxxxxxx : ove xxxxxxxx sono cifre esadecimali

\N{name} : nome unicode del carattere

In Python 2 i caratteri fra apici rappresentavano stringhe in codifica ASCII, e per usare codifica Unicode si doveva usare la lettera u od U avanti alla stringa: a=u"asdl" . Questo non e' piu' necessario in Python 3 perche' di default la codifica e' UTF-8.

Una notazione simile a quella usata per le stringhe puo' essere usata per definire sequenze di byte. Per farlo, davanti alla stringa si mette il carattere "b" ; ad esempio per creare sequenza di bytes ed assegnarle il riferimento "a"

a=b'abcd'

Ci sono diversi caratteri che indicano che si va a capo, quello che si usa in Unix (e Linux) e': \n , il DOS non usa gli stessi caratteri di Unix per indicare la fine di una linea. \r \f \t \v sono comandi che servivano a controllare il carrello nelle stampanti a modulo continuo.

Sottostringhe

Ai singoli caratteri di una stringa od a sottostringhe si puo' accedere facilmente, utilizzando un indice, fra parentesi quadre. Il primo carattere di una stringa ha l'indice 0. Indici negativi indicano che si inizia a contare da fine linea: -1 e' l'ultimo elemento. Sottostringhe sono individuate da coppie di indici separate da :, il primo valore della coppia e' l'indice del primo carattere che si estrae, vengono estratti caratteri fino al secondo indice (escluso), quindi ad esempio 0:3 indica caratteri nelle posizioni: 0,1,2, il carattere in posizione 3 non viene estratto. Se manca il primo indice si inizia dal primo carattere, se manca il secondo si arriva a fine stringa. Un terzo valore, opzionale, indica il passo con cui si estraggono i caratteri; ad esempio un passo 2 estrae un carattere si ed uno no. Se il terzo valore manca si intende sia 1 e vengono estratti tutti gli elementi fra gli indici indicati. Passi negativi vanno all'indietro, nella sequenza dei caratteri, questo modo di estrarre elementi (slicing), vale per tutte le sequenze, non solo per le stringhe.

Esempi:

a='0123456'

a[0]        vale '0'
a[1]        vale '1'
a[-1]       vale '6'
a[-2]       vale '5'

a[:] a[0:]  sono tutta la stringa
a[:0]       e' la stringa vuota

a[:3]      vale '012'
a[3:]      vale '3456'


a[0:2]     vale: '01'
a[1:3]     vale: '12'
a[:-1]     vale: '012345'
a[-3:-1]   vale: '45'
a[-1:-3]   vale '' (la stringa vuota)

a[::-1]    vale  '6543210'  (ribalta la stringa)

a[0:5:2]   vale '024'    (da 0 a 5, passo 2 )

a[1::2] vale: '135' , si va dall'elemento 1 alla fine della stringa
                      prendendo un elemento si ed uno no.

a[1::3] vale:  '14'    si prende un elemento ogni 3.

a[-1:-5:-2] vale '64' : passo negativo va all'indietro.
a[-1:-3:1]   vale '' :la stringa vuota:  il passo e' +1 e' in avanti.
                      e' come: a[-1:-3]

Una stringa puo' facilmente essere separata in caratteri, con una assegnazione del tipo:

f1,f2,f3='abc'

f1,f2 ed  f3 assumono i valori dei caratteri 'a', 'b', 'c'

Operazioni su stringhe

L'operatore "+" concatena le stringhe; l'operatore "*" ripete una stringa un certo numero di volte:

Esempi:

a='0123456'
b='abcdefg'

a+b  e' la stringa: '0123456abcdefg'
b*2  e' la stringa: 'abcdefgabcdefg'

L'operatore "in" da risultato: True se una sottostringa e' compresa in una stringa:

Esempi:

'0' in a    vale: True
'01' in a   vale: True
'09' in a   vale: False

In una istruzione for su una stringa la variabile assume i valori dei caratteri della stringa. Ad esempio, l'espressione nell'esempio seguenteproduce, nei cicli del loop, un valore di "i" che assume, in ordine, tutti i valori dei caratteri della stringa

for i in a:
   i

Funzioni per le stringhe

Ci sono molte funzioni per trattare le stringhe; se: a= '0123456' ; b='abcedfg' :

len(a) e' 7: il numero di caratteri della stringa

min(a) e' '0' il carattere piu' piccolo (nella sequenza dei caratteri ASCII)

max(a) e' '6'

max(b) vale: 'g'

Alcune funzioni sono attributi dell'oggetto stringa, per cui la sintassi e' diversa:

b.index('c') e': 2 : l'indice del carattere 'c' nella stringa

b.capitalize() e' la stringa: 'Abcdefg' (primo carattere maiuscola)

b.upper() e' la stringa: 'ABCDEFG' ( muta i caratteri in maiuscolo)

b.lower() muta i caratteri in minuscolo

b.replace('a','X') e' la stringa: 'Xbcdefg' , cambia il carattere a in X

b.replace('a','X',3) effettua la sostituzione per le prime 3 sottostringhe che trova (di default fa la sostituzione per tutte)

split : la funzione split, dato in argomento un separatore, crea una lista con le parti della stringa. L'argomento di default di split e' uno spazio bianco, bianchi ripetuti sono compattati; la funzione e' un attributo dell'oggetto stringa.

Esempi:

 b='1,2,3' ; s=b.split(',')  # produce ['1', '2', '3']

'   a   b '.split()  produce: ['a', 'b']

join : la funzione unisce piu' stringhe in una sola, separandole con una stringa data.

'-',join(s)      #  produce:  '1-2-3'

Esempi di Conversioni di numeri in stringhe e viceversa ( qui a='123456' ):

int(a) e' il numero 123456, analogamente str(450) e' la stringa '450'

float(a) muta una stringa in un numero in virgola mobile.

str(1.6E3) e' la stringa '1600.0'

ord('A') da 65, codice ascii del carattere

chr(65)  fornisce 'A'

bin(2)     produce: '0b10'

hex(16)  produce: '0x10'

oct(8)  produce: '0o10'

Ci sono molte altre funzioni per le stringhe: funzioni che riconoscono se una stringa e' minuscola o maiuscola od un numero, per trovare sottostringhe, per contare quante volte una sottostringa e' contenuta in una stringa, per trasformare tabulazioni in spazi bianchi, per trovare in che punto di una stringa si trova una sottostringa, per vedere se una sottostringa termina od inizia con certi caratteri, per creare una stringa che ne contenga un'altra piu' piccola al centro etc. Alcune di queste funzioni sono nella tabella che segue:

stringa.rstrip()     : elimina \n alla fine

stringa.isalpha()    : True se contiene solo caratteri alfabetici

stringa.isnumeric()  : True se e' un numero

stringa.islower()    : True se caratteri minuscoli

stringa.isupper()   : True se caratteri maiuscoli

stringa.expandtabs(4)          : mette 4 spazi al posto dei tab

stringa.ljust(width,fillchar)  : allinea la stringa a sinistra
stringa.rjust(width,fillchar)  : allinea la stringa  a destra

stringa.startswith(stringa2) : True se inizia con la stringa2
stringa.endsswith(stringa2)  : True se finisce con la stringa2

Abbiamo gia' visto l'operatore "%" , che permette di trasformare numeri e stringhe in un'unica stringa "formattando" i dati in modo simile a come viene effettuato dalle funzioni di stampa del linguaggio C, ad esempio:

a=3
b=7.9E3
c=' xxx %s yyy %i zzz %f '% ('000',a,b)

c==' xxx 000 yyy 3 zzz 7900.000000 '

L'istruzione fa si che nella stringa: ' xxx %s yyy %i zzz %f ' vengono sostituiti i valori della tupla: ('000',a,b), intesi rispettivamente come una stringa, un intero, un decimale. %s %i %f sono qui indicatori di formato, rispettivamente per stringhe, interi, valori float.

Esistono parecchi specificatori di formato, ad esempio: %5.3f e' un numero float in un campo di 5 spazi, con 3 cifre per i decimali.

Come nel linguaggio C, sono possibili sostituzioni piu' complesse, in modo da creare stringhe che siano adatte a stampe di tabelle etc.

Esempi:

x=3
'%2d %3d %4d' % (x, x*x, x*x*x)
produce: 3   9   27
%2d indica decimale con spazio per 2 cifre, %3d, con 3 cifre.

Si puo' anche usare un dizionario per le variabili da formattare:

template = '%(motto)s, %(pork)s and %(food)s'
template % dict(motto='spam', pork='ham', food='eggs')

produce: 'spam, ham and eggs'

In python3 c'e' anche la funzione "format" per fare questo, e Rossun diceva che l'operatore "%" sarebbe stato eliminato prima o poi. L'uso della funzione format e':

'{0} {1}, {2:.0f} you'.format(1, 'spam', 4.0)

format ha come argomenti le variabili da formattare, ed e' un attributo delle stringhe. La stringa di formattazione ha i place-holders per gli argomenti rappresentati con numeri, fra parentesi graffe, seguiti da ":" e la specifica di formato.

Si puo' anche usare la sintassi seguente (keyword arguments) per specificare i place-holders

'{motto}, {0} and {food}'.format(42, motto=3.14, food=[1, 2])

Produce: '3.14, 42 and [1, 2]'