Tutorial sulle stringhe in Python

Slicing delle stringhe in Python

Poiché le stringhe sono una sequenza di caratteri, puoi accedervi tramite slicing e indicizzazione proprio come faresti con liste o tuple in Python. Le stringhe sono indicizzate rispetto a ciascun carattere nella stringa e l'indicizzazione parte da 0:

Nella stringa qui sopra, il primo indice è C ed è indicizzato a 0. L'ultimo carattere è un punto ., che è il sedicesimo carattere della stringa. Puoi anche accedere ai caratteri nella direzione opposta partendo da -1, il che significa che puoi usare -1 come valore di indice per accedere a . nella stringa. C'è anche uno spazio tra Chocolate e cookie: anche questo fa parte della stringa e ha un suo indice, il nono in questo caso. Puoi verificarlo usando lo slicing.

Poiché ogni carattere in una stringa Python ha un corrispondente numero di indice, puoi accedere e manipolare le stringhe allo stesso modo degli altri tipi di dati sequenziali. Lo slicing è una tecnica in Python che ti consente di ottenere uno specifico elemento o un sottoinsieme di elementi da un contenitore usando i loro valori di indice. Lo slicing ti evita di dover scrivere cicli per scorrere gli indici della stringa per trovare o accedere a determinate sottostringhe.

snack = "Chocolate cookie."
print(snack[0])
print(snack[9])
print(snack[-1])

C

.

Supponiamo che tu voglia estrarre la sottostringa 'cookie' dalla stringa qui sotto. Come lo faresti?

In questi casi, usi lo slicing di intervallo.

La sintassi per lo slicing di intervallo è la seguente: [Indice iniziale (incluso): Indice finale (escluso)]

snack = "Chocolate cookie."
print(snack[10:16])

cookie

Puoi farlo anche usando un valore negativo per l'indice finale:

print(snack[10:-1]) # -1: poiché l'indice finale è escluso nello slicing.

cookie

Lo slicing senza specificare l'indice finale significa che catturi i caratteri dall'indice iniziale fino all'ultimo indice della frase. Allo stesso modo, lo slicing senza l'indice iniziale significa che parti dal primo indice della stringa fino all'indice finale:

# Valore finale non fornito
print(snack[0:]) 

# Valore iniziale non fornito (valore finale escluso secondo la sintassi)
print(snack[:-1])

# Anche questo è consentito
print(snack[:])

Chocolate cookie.
Chocolate cookie
Chocolate cookie.

Lo slicing delle stringhe può accettare anche un terzo parametro, lo stride, che indica di quanti caratteri vuoi avanzare dopo che il primo carattere è stato recuperato dalla stringa. Il valore di stride è impostato su 1 per impostazione predefinita.

Vediamo stride in azione per capirlo meglio:

number_string = "1020304050"
print(number_string[0:-1:2])

12345

Suggerimento: una cosa molto carina che puoi fare con lo striding è invertire una stringa:

print(number_string[::-1]) #

0504030201

Il valore -1 per lo stride ti permette di partire dall'ultimo carattere e poi muoverti di un carattere alla volta.

In alternativa, se fornisci -2 come valore, parti dall'ultimo carattere e ti muovi di due caratteri alla volta:

print(number_string[::-2]) #

00000

Operazioni comuni sulle stringhe

Slicing e slicing di intervallo sono le operazioni più comuni che potresti dover eseguire sulle stringhe. C'è anche la concatenazione delle stringhe, che è semplice come un'addizione:

string1 = 'Chocolate'
string2 = 'cookie'

snack = string1 + " " + string2
print(snack)

Chocolate cookie

Tuttavia, questo non funzionerà se provi a concatenare una stringa con un altro tipo di dato.

cost = 15
string1 = "The total in Euro is: "

bill = string1 + cost
print(bill)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-218-7d5c5248b927> in <module>()
      2 string1 = "The total in Euro is: "
      3 
----> 4 bill = string1 + cost
      5 print(bill)


TypeError: Can't convert 'int' object to str implicitly

Qui hai provato a concatenare una stringa con un valore intero, cosa non consentita. L'interprete non può capire implicitamente se stai cercando di eseguire una semplice addizione tra interi o una concatenazione di stringhe. Prova invece così:

bill = string1 + str(cost)
print(bill)

The total in Euro is: 15

Questo perché hai convertito esplicitamente un intero in una stringa e poi applicato la concatenazione. Per saperne di più sulle conversioni di tipo di dato, dai un'occhiata a questo tutorial.

Per ripetere una stringa, usa l'operatore *.

single_word = 'hip '
line1 = single_word * 2 + 'hurray! '
print(line1 * 3)

hip hip hurray! hip hip hurray! hip hip hurray! 

Puoi anche verificare la presenza di una sottostringa usando in e not in:

sub_string1 = 'ice'
sub_string2 = 'glue'
string1 = 'ice cream'
if sub_string in string1:
    print("There is " + sub_string + " in " + string1)
if sub_string2 not in string1:
    print("Phew! No " + sub_string2 + " in " + string1)

There is ice in ice cream
Phew! No glue in ice cream

Python offre molti metodi integrati o funzioni helper per manipolare le stringhe. Sostituire una sottostringa, mettere in maiuscolo alcune parole in un paragrafo, trovare la posizione di una stringa all'interno di un'altra sono alcune delle operazioni possibili con questi metodi.

Eccone alcuni nel dettaglio:

• str.capitalize(): restituisce una copia della stringa con il primo carattere in maiuscolo.

str.capitalize('cookie')

'Cookie'

• str.islower(): restituisce true se tutti i caratteri della stringa sono minuscoli, false altrimenti.

snack = 'cookie'
snack.islower()

True

• str.find(substring): restituisce l'indice più basso nella stringa in cui viene trovata la sottostringa. Puoi anche specificare l'indice di inizio e di fine all'interno della stringa in cui cercare la sottostringa. Restituisce -1 se la sottostringa non viene trovata.

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

• str.count(substring): conta quante volte una sottostringa compare nella stringa. Puoi anche specificare l'indice di inizio e fine per la stringa.

str1 = 'I got you a cookie, do you like cookies?'
str2 = 'cookie'
str1.count(str2)

2

• str.isspace(): restituisce True se nella stringa ci sono solo caratteri di spaziatura, false altrimenti. I caratteri di spaziatura sono spazi, tabulazioni, a capo, ecc.

Questo può essere utile quando lavori con dataset reali, che potrebbero non codificare sempre correttamente gli spazi durante la conversione da un formato all'altro.

str_space = '   '
str_space.isspace()

True

str_tab = '\t'
str_tab.isspace()

True

str_nextline = '''\n'''
str_nextline.isspace()

True

Nota: hai notato \t, \n qui sopra? Si chiamano caratteri di escape. Iniziano con un \ (backslash). Internamente non sono interpretati come normali stringhe, ma come caratteri speciali che rappresentano qualcos'altro. Per esempio, \t rappresenta una tabulazione. Ci sono molti altri caratteri di escape e puoi saperne di più nel nostro tutorial sulle Regex in Python.

• str.lstrip(): rimuove tutti gli spazi iniziali nella stringa. Un'altra funzione utile quando lavori con dataset reali.

str1 = " I can't hear you. Are you alright? "
str2 = " Yes, all is good."
str3 = str1.lstrip() + str2.lstrip()
print(str3)

I can't hear you. Are you alright? Yes, all is good.

• str.isdigit(): restituisce True se la stringa contiene solo cifre e False altrimenti.

number_string = "1020304050"
number_string.isdigit()

True

• str.replace(substring, new): sostituisce tutte le occorrenze della sottostringa nella stringa con new. Puoi anche definire un terzo argomento max, che sostituisce al massimo max occorrenze della sottostringa. Ricorda che non è una sostituzione in place: l'immutabilità vale ancora e viene effettivamente creata una nuova stringa.

string1 = 'hip hip hurray! hip hip hurray! hip hip hurray!'
string2 = string1.replace('hip', 'Hip')
print(string1)
print(string2)

hip hip hurray! hip hip hurray! hip hip hurray!
Hip Hip hurray! Hip Hip hurray! Hip Hip hurray!

string1.replace('hip', 'Hip', 2)

'Hip Hip hurray! hip hip hurray! hip hip hurray!'

• str.split(delimiter=""): divide la stringa in base al delimitatore (spazio se non fornito) e restituisce una lista di sottostringhe.

dessert = 'Cake, Cookie, Icecream'
list_dessert = string1.split(',')

Puoi trovare un elenco esaustivo dei metodi delle stringhe in Python qui.

Formattazione delle stringhe

Python supporta diversi modi per formattare una stringa. In questa sezione, imparerai di più su queste formattazioni!

% Formattazione

Il modulo % è un'operazione integrata in Python. È noto come operatore di interpolazione. Devi fornire % seguito dal tipo di dato che deve essere formattato o convertito. L'operazione % sostituisce quindi l'espressione '%datatype' con uno o più elementi del tipo di dato specificato:

print("I bought %d Euro worth of %s!" %(200, 'cookies'))

I bought 200 Euro worth of cookies!

Hai visto %d per gli interi e %s per le stringhe. Altri tipi di conversione disponibili sono: o per valori ottali, x per esadecimali, f per numeri in virgola mobile in formato decimale, c per singolo carattere (accetta intero o stringa di un carattere).

La classe formatter

La classe formatter è una delle classi stringa integrate. Fornisce la possibilità di effettuare sostituzioni di variabili complesse e formattazione dei valori usando il metodo format(). Ti consente di creare e personalizzare i tuoi comportamenti di formattazione delle stringhe riscrivendo i metodi pubblici che contiene: format(), vformat(). Ha alcuni metodi pensati per essere sostituiti dalle sottoclassi: parse(), get_field(), get_value(), check_unused_args(), format_field() e convert_field(). Tuttavia, per semplicità, vedrai in azione solo la funzione più usata, format()...

print("I bought {0} Euro worth of {1}!".format(200,'cookies')) #Accessing values by position

I bought 200 Euro worth of cookies!

print("I bought {total} Euro worth of {item}!".format(total = 200, item = 'cookies')) #Accessing values by name

I bought 200 Euro worth of cookies!

'{:#<10}'.format('Cake') #Allineamento a sinistra per la parola 'Cake', spazi riempiti con '#'

'Cake######'

'{:#^10}'.format('Cake') #Allineamento centrato per la parola 'Cake', spazi riempiti con '#'

'###Cake###'

'{:#>10}'.format('Cake') #Allineamento a destra per la parola 'Cake', spazi riempiti con '#'

'######Cake'

for num in range(1,10): 
        print('{0:{width}}'.format(num, width=5), end=' ')

    1     2     3     4     5     6     7     8     9 

Template string

Invece delle normali sostituzioni basate su %, i template supportano sostituzioni basate su $. L'idea alla base dell'introduzione dei template in Python 2.4 era che, sebbene la formattazione con % sia potente e ricca, è soggetta a errori e anche piuttosto rigida nei formati che seguono '%', rendendola complessa. Un errore comune con la formattazione % è dimenticare il carattere di formato finale, per esempio la e in %(variabl)e.

I template hanno alcuni metodi definiti al loro interno: substitute() e safe_substitute(). Ecco come puoi usarli:

from string import Template #First you will need to import 'Tempalte' class

money = dict(who = 'You', to_whom = 'baker')
Template('$who owe the $to_whom a total of $$100').substitute(money)

'You owe the baker a total of $100'

Hai notato il $$ nell'esempio sopra?

Questo perché nei template $$ è un carattere di escape che viene sostituito con un singolo $. È una delle regole dei template. Un'altra regola riguarda come definisci l'identificatore all'interno del template: c'è la sintassi usuale $identifier, ma anche ${identifier}.

Significa che ${identifier} è lo stesso di $identifier, ma può essere usato in scenari come:

word = dict(noun = 'feed')
Template('Please don\'t stop ${noun}ing me').substitute(word)

"Please don't stop feeding me"

Vediamo come puoi usare substitute() e safe_substitute().

fact = Template('$alter_ego is weak but wait till he transforms to $superhero!')
fact.substitute(alter_ego='Bruce Banner', superhero='Hulk')

'Bruce Banner is weak but wait till he transforms to Hulk!'

hero = dict(alter_ego='Peter Parker')
fact.substitute(hero)

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-244-c82f6a2ebc02> in <module>()
      1 hero = dict(alter_ego='Peter Parker')
----> 2 fact.substitute(hero)


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in substitute(*args, **kws)
    127             raise ValueError('Unrecognized named group in pattern',
    128                              self.pattern)
--> 129         return self.pattern.sub(convert, self.template)
    130 
    131     def safe_substitute(*args, **kws):


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in convert(mo)
    117             named = mo.group('named') or mo.group('braced')
    118             if named is not None:
--> 119                 val = mapping[named]
    120                 # We use this idiom instead of str() because the latter will
    121                 # fail if val is a Unicode containing non-ASCII characters.


KeyError: 'superhero'

L'esempio sopra genera un errore perché superhero non è definito. Tuttavia, prova questo...

fact.safe_substitute(hero)

'Peter Parker is weak but wait till he transforms to $superhero!'

safe_substitute() è uno dei vantaggi dell'uso dei template.

Perché così tante opzioni di formattazione delle stringhe, ti chiedi?

Be', è principalmente una questione di preferenze sintattiche. Di solito si tratta di un compromesso tra semplicità e verbosità e dipende anche dalla familiarità con sintassi esistenti. Per esempio, usare % per la formattazione delle stringhe sembrerà naturale a chi proviene dal C. I template in Python sono semplici da scrivere, mentre usare format() può essere più verboso ma offre più funzionalità.

Formatted String Literal (f-string)

Questo è un altro metodo di formattazione delle stringhe aggiunto in Python 3.6. Una formatted string literal o f-string è una stringa letterale con prefisso 'f' o 'F'. Puoi definire identificatori da usare nella tua stringa tra parentesi graffe { }.

Perché un'altra opzione di formattazione? Perché la praticità e la semplicità sono belle, ecco perché!

Dai un'occhiata agli esempi qui sotto per capire perché le f-string sono davvero il modo più semplice e pratico per formattare stringhe in Python.

alter_ego = 'Peter Parker' superhero = 'spiderman' f'{alter_ego} is weak but wait till he transforms to {superhero}!'

Nota: il codice sopra funziona solo con Python 3.6 e successivi. Per verificare la versione di Python installata, digita: python -V nel terminale. In alternativa puoi usare il modulo sys in Python. Per usarlo, fai semplicemente così:

import sys
sys.version

Le stringhe formattate sono in realtà espressioni valutate a runtime, il che significa che puoi usare qualsiasi espressione Python tra le parentesi graffe delle f-string: un altro grande vantaggio dell'uso delle f-string.

f'{alter_ego} is weak but wait till he transforms to {superhero.capitalize()}!'

Le f-string non sono già fantastiche? Ma aspetta, c'è di più... Le f-string sono anche più veloci rispetto agli altri tre metodi che hai visto prima. Questo perché sono pre-analizzate e memorizzate in bytecode efficiente per un'esecuzione più rapida.

Tira le corde giuste!

Sei arrivato alla fine del tutorial, congratulazioni! Hai visto cosa sono le stringhe, imparato lo slicing e alcune operazioni che si possono eseguire sulle stringhe. Hai anche visto diversi modi per formattarle. Ma ricorda: la chiave per padroneggiare qualsiasi tecnica è la pratica!

Le stringhe sono uno dei vari tipi di dato in Python. Dai un'occhiata al corso di DataCamp Data Types for Data Science per saperne di più su liste, dizionari, tuple e set. In questo corso potrai mettere a frutto la tua conoscenza dei tipi di dato. Lavorerai con dati sul trasporto nell'area metropolitana di Chicago per scopi di data science. Vai a vedere con i tuoi occhi...