Le stringhe R in breve

Le stringhe sono una struttura di dati basilare in R, usata per rap­pre­sen­ta­re sequenze di caratteri e singole lettere. A dif­fe­ren­za di altri linguaggi di pro­gram­ma­zio­ne, in R non è previsto un tipo di dati chiamato string: le stringhe fanno parte del tipo di dati R character.

Cosa sono le stringhe R?

Che tu abbia appena iniziato a imparare a pro­gram­ma­re oppure lavori con diversi linguaggi di pro­gram­ma­zio­ne già da molto tempo, non fa dif­fe­ren­za: neanche le pro­gram­ma­tri­ci e i pro­gram­ma­to­ri più esperti possono fare a meno delle stringhe.

Le stringhe sono una struttura di dati all’interno del lin­guag­gio di pro­gram­ma­zio­ne R. In sostanza, le stringhe non sono altro che sequenze di caratteri, che nella maggior parte dei linguaggi (e quindi anche nella pro­gram­ma­zio­ne in R) sono indicate con vir­go­let­te singole o doppie. Nor­mal­men­te sono usate per salvare nei programmi in­for­ma­zio­ni non numeriche ed ela­bo­rar­le.

Come si crea una stringa in R?

In R è possibile creare una stringa molto fa­cil­men­te con una sola riga di codice. All’ini­zia­liz­za­zio­ne della tua stringa R puoi scegliere se uti­liz­za­re le vir­go­let­te singole o doppie:

# Stringa con virgolette doppie
string1 <- "Ciao mondo!"
# Stringa con virgolette singole
string2 <- 'Ciao mondo!'

Mo­di­fi­ca­re le stringhe in R: le funzioni in breve

R mette a di­spo­si­zio­ne dei pro­gram­ma­to­ri e delle pro­gram­ma­tri­ci una serie di funzioni di base per lavorare con le stringhe, che possono essere usate per eseguire diverse ope­ra­zio­ni sulle sequenze di caratteri. Di seguito le più im­por­tan­ti ope­ra­zio­ni con le stringhe R:

• substr(): estrae una sot­to­strin­ga da una stringa R
• paste(): concatena le stringhe
• tolower() / toupper(): converte tutti i caratteri di una stringa in lettere maiuscole o minuscole
• strsplit(): divide una stringa R in base al se­pa­ra­to­re indicato
• trimws(): rimuove gli spazi all’inizio e alla fine di una stringa
• gsub(): so­sti­tui­sce il modello in una stringa con una sequenza di caratteri passata
• nchar(): determina la lunghezza di una stringa in R

Se hai già di­me­sti­chez­za con altri linguaggi di pro­gram­ma­zio­ne, dovresti conoscere già gran parte delle funzioni. Ad esempio ci sono molte so­mi­glian­ze con le stringhe in Python.

substr()

La funzione substr() permette di estrarre sot­to­strin­ghe da una stringa R. A questo scopo si passa la stringa alla funzione come primo parametro, come secondo e terzo parametro l’indice di inizio e di fine della stringa parziale de­si­de­ra­ta. Tieni presente che, a dif­fe­ren­za di molti altri linguaggi, l’in­di­ciz­za­zio­ne delle stringhe R inizia con 1.

string <- "Ciao mondo"
print(substr(string, start=7, stop=10))

L’esempio di codice sopra re­sti­tui­sce sullo schermo "mondo".

paste()

La funzione paste() in R è inoltre usata per con­ca­te­na­re due o più stringhe. Tieni presente che + non è un operatore R per la con­ca­te­na­zio­ne delle stringhe, in quanto l’addizione è definita solo su tipi di dati numerici.

string <- "Ciao"
string2 <- "mondo"
print(paste(string+ string2))

Chiamando paste() si con­ca­te­na­no le due stringhe R, pro­du­cen­do l’output seguente: "Ciao mondo".

tolower() / toupper()

Le funzioni tolower() e toupper() per­met­to­no di con­ver­ti­re tutti i caratteri di una stringa in minuscolo o maiuscolo. Entrambe le funzioni si aspettano come parametro la stringa con cui devono lavorare e re­sti­tui­sco­no una nuova stringa.

string <- "Ciao mondo"
print(tolower(string))
print(toupper(string))

Come previsto, il programma sopra re­sti­tui­sce sullo schermo "ciao mondo" e "CIAO MONDO". Le funzioni tolower() o toupper() sono pratiche so­prat­tut­to per elaborare input che di­stin­guo­no tra maiuscole e minuscole.

strsplit()

Le pro­gram­ma­tri­ci e i pro­gram­ma­to­ri esperti avranno si­cu­ra­men­te già in­con­tra­to la funzione strsplit() in R almeno una volta in un altro lin­guag­gio. Anche Python ha una funzione chiamata split(). Come parametri strsplit() si aspetta la stringa che si desidera dividere in sot­to­strin­ghe con un se­pa­ra­to­re e il se­pa­ra­to­re da usare per la divisione. In presenza di una sola stringa parziale, la chiamata di funzione re­sti­tui­rà quindi una lista con­te­nen­te questa sot­to­strin­ga.

string <- "Ciao mondo"
print(strsplit(string, " "))

L’output del codice sopra è il seguente:

[[1]]
[1] "Ciao" "mondo"

Si ottiene così una lista con due stringhe, in quanto lo spazio nella stringa ori­gi­na­ria è stato usato come se­pa­ra­to­re.

trimws()

Con la funzione trimws() è possibile rimuovere gli spazi prima e dopo la stringa in R, il che può essere utile so­prat­tut­to durante l’ela­bo­ra­zio­ne degli input degli utenti per rimuovere gli spazi in­de­si­de­ra­ti e inseriti inav­ver­ti­ta­men­te.

string <- "   Ciao mondo   "
print(trimws(string))

La sezione di codice re­sti­tui­sce "Ciao mondo" senza spazi all’inizio e alla fine della stringa.

gsub()

In R è possibile rea­liz­za­re un’altra ope­ra­zio­ne sulle stringhe con la funzione gsub(), che come primo parametro richiede la sot­to­strin­ga da so­sti­tui­re. Come secondo parametro si indica la sequenza di caratteri con cui devono essere so­sti­tui­te le oc­cor­ren­ze della sot­to­strin­ga. Il terzo parametro è la stringa a cui si riferisce la so­sti­tu­zio­ne.

string <- "Ciao mondo"
print(gsub("mondo", "User", string))

Ora nell’output della stringa definita nel codice non si salutano più tutti, ma soltanto un utente, perché l’output del parametro è "Ciao mondo".

nchar()

Una delle fun­zio­na­li­tà standard più im­por­tan­ti per le stringhe è fornita dalla funzione nchar(), che re­sti­tui­sce la lunghezza della stringa in R.

string <- "Ciao mondo"
print(nchar(string))

Non farti con­fon­de­re dal comando R length(), che in­tui­ti­va­men­te potrebbe sembrare avere un’altra funzione: in R, length() è uti­liz­za­to per de­ter­mi­na­re il numero di elementi in un oggetto, pertanto non re­sti­tui­sce la lunghezza della stringa in R!

Caratteri di controllo e sequenze di escape

Se vuoi mo­di­fi­ca­re il flusso di testo all’interno della tua stringa R, ad esempio con in­ter­ru­zio­ni di riga o ta­bu­la­zio­ni, devi ricorrere ai caratteri di controllo. Si tratta di una forma pre­de­fi­ni­ta di sequenze di escape spesso uti­liz­za­te per strut­tu­ra­re l’output di testo.

Anche caratteri par­ti­co­la­ri come le vir­go­let­te, che nor­mal­men­te nella sintassi R sarebbero in­ter­pre­ta­ti come inizio o fine di una stringa, possono essere generati con sequenze di escape all’interno di stringhe. Le sequenze di escape sono indicate da una barra ro­ve­scia­ta iniziale. Di seguito trovi i caratteri di controllo e le sequenze di escape più im­por­tan­ti in R:

• \n: newline/in­ter­ru­zio­ne di riga
• \t: ta­bu­la­zio­ne
• \: barra ro­ve­scia­ta
• ": vir­go­let­te doppie
• ': vir­go­let­te singole