Tutorial sulle utility in R

In questo tutorial imparerai a conoscere diverse funzioni e utility semplici e spesso usate nel linguaggio di programmazione R. Per prima cosa parleremo di alcune funzioni matematiche. Poi vedrai funzioni più legate alle strutture dati di R, come la manipolazione di liste annidate, espressioni regolari, orari e date.

Funzioni matematiche

Vediamo le seguenti celle di codice che usano diverse funzioni matematiche.

Per prima cosa definirai due vettori, cioè x e y, che comprendono sia valori positivi che negativi.

x <- c(1.1, -2.3, -4.5)
y <- c(2.4,-44, -2.2)

print(x)

[1]  1.1 -2.3 -4.5

print(y)

[1]   2.4 -44.0  -2.2

Prendiamo questi due vettori x e y:

• Calcola i valori assoluti,
• Arrotondali a zero cifre decimali,
• Somma ciascuno di essi e
• Infine fai la media dei due.

mean(c(sum(round(abs(x))),sum(round(abs(y)))))

27.5

Perché non scomporre la riga di codice sopra in piccoli pezzi e dare un’occhiata da vicino a ciascuna funzione.

• La funzione abs() considera semplicemente il valore positivo, o assoluto, degli elementi dei vettori x e y.

Ad esempio, applicando la funzione abs() a x e y, otterrai tutti valori positivi, come mostrato di seguito.

abs(x)

1. 1.1
2. 2.3
3. 4.5

abs(y)

1. 2.4
2. 44
3. 2.2

• La funzione successiva è round(). Non fa altro che arrotondare l’input. Accetta un argomento aggiuntivo, con cui puoi specificare a quante cifre decimali desideri arrotondare l’input. In generale, la funzione round() arrotonda l’input a zero cifre decimali.

Per esempio, dopo aver applicato la funzione round() ai vettori x e y, l’output sarà come quello mostrato di seguito:

round(x)

1. 1
2. -2
3. -4

round(y)

1. 2
2. -44
3. -2

• La funzione sum() calcola semplicemente la somma degli elementi di un vettore o di una matrice. Ad esempio, se passi alla funzione sum un vettore riga come argomento, verrà restituita come scalare la somma di tutti gli elementi del vettore riga.

In questo caso, i vettori x e y sono passati alla funzione sum(). Quindi R calcola semplicemente la somma degli elementi del vettore e restituisce uno scalare come output.

sum(abs(round(x)))

7

sum(abs(round(y)))

 48

• Infine, la funzione mean(), o average(), calcola la media aritmetica. Fa la media di un insieme di valori numerici, li somma e divide per il numero di termini dell’insieme.

In questo caso, l’input alla funzione mean() è un vettore riga di lunghezza due contenente i numeri 7 e 48. Quindi, la media di questi due valori sarà la somma di tali valori divisa per il numero di elementi, cioè 2.

mean(c(7,48))

27.5

È stato piuttosto semplice, no?

Passiamo ora al segmento successivo e più interessante di questo tutorial!

Funzioni per le strutture dati

Ora vediamo alcune strutture dati come liste e vettori. Diversi modi in cui puoi operare sulla struttura dati list, invertire una list e come convertire una lista in un vettore e viceversa.

La funzione seguente è una list(), o puoi dire una lista di liste, nota anche come lista annidata. Crea una lista di elementi che possono comprendere valori logici, numerici e stringhe.

Nell’esempio seguente, ci sono tre liste all’interno di una lista, cioè log, ch e int_vec. Ognuna di esse ha un tipo di dato o un oggetto R: logico, numerico e stringa/carattere.

list_define <- list(log = TRUE, ch = "hello_datacamp", int_vec = sort(rep(seq(8,2, by = -2), times = 2)))

list_define

$log

TRUE

$ch

'hello_datacamp'

$int_vec

1. 2
2. 2
3. 4
4. 4
5. 6
6. 6
7. 8
8. 8

• log è semplicemente un operatore logico, TRUE o FALSE
• ch è una stringa di caratteri hello_datacamp
• int_vec è una sequenza di valori numerici.

Dato che log e ch sono abbastanza semplici, diamo un’occhiata più da vicino a int_vec.

int_vec = sort(rep(seq(8,2, by = -2), times = 2))

int_vec

1. 2
2. 2
3. 4
4. 4
5. 6
6. 6
7. 8
8. 8

Capisci l’espressione sopra passo dopo passo.

La funzione seq produce una sequenza di numeri in ordine decrescente da 8 a 2.

La sintassi della funzione seq() è: seq(x1,x2, by = y)

I primi due argomenti x1 e x2 indicano a R l’intervallo della sequenza, cioè dove iniziare e terminare la sequenza. L’argomento by specifica l’incremento o il decremento della sequenza a ogni intervallo.

Per esempio, la riga di codice qui sotto genererà una sequenza da 100 a 200 con passo d’incremento pari a 20.

seq(100,200, by = 20)

1. 100
2. 120
3. 140
4. 160
5. 180
6. 200

Nel nostro esempio, la funzione sequence restituirà una sequenza da 8 fino a 2 (inclusi) con passo di decremento pari a 2, che restituisce un vettore di lunghezza 4.

a = seq(8,2, by = -2)

a

1. 8
2. 6
3. 4
4. 2

Ora capiamo la funzione rep.

Può ripetere l’argomento in input, solitamente un vettore o una lista, usando l’argomento times, che accetta un intero e ripete quell’input o sequenza per quel numero di volte. La funzione rep accetta due argomenti: l’input e il numero di volte in cui vuoi che l’input sia ripetuto o replicato.

Applicando la funzione rep al nostro esempio, che è un vettore di lunghezza 4, si ottiene un vettore di output di lunghezza 8.

b = rep(a, times = 2)

Se vuoi che ogni elemento del vettore o della lista venga ripetuto invece dell’intero vettore, c’è un’alternativa a times, cioè usare l’argomento each.

La differenza evidente tra l’uso di times ed each è che il modello con cui si ripetono gli elementi non è lo stesso.

rep(a, each = 2)

1. 8
2. 8
3. 6
4. 6
5. 4
6. 4
7. 2
8. 2

Dulcis in fundo, la funzione sort(). È autoesplicativa e generica, usata per ordinare molte strutture dati come un vettore o una lista. Non è limitata ai soli valori numerici, ma può essere usata anche su valori logici e caratteri. Per impostazione predefinita, ordina gli elementi in ordine crescente.

Applichiamo l’output della funzione rep alla funzione sort per arrivare all’output finale.

sort(b)

1. 2
2. 2
3. 4
4. 4
5. 6
6. 6
7. 8
8. 8

Ottimo! Sei riuscito a risolvere la lunga espressione int_vec, che si trovava dentro la lista list_define, in modo così semplice.

Inoltre, scopriamo il contenuto della lista list_define per cui userai la funzione str(). La funzione str() in R ti permette di visualizzare la struttura degli oggetti R.

str(list_define)

List of 3
 $ log    : logi TRUE
 $ ch     : chr "hello_datacamp"
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8

Vediamo alcune espressioni R interessanti:

• La funzione is può essere usata per controllare il tipo della tua struttura dati, restituisce un valore logico ed è utile quando si lavora con istruzioni condizionali.

is.list(list_define) #restituisce true se l'argomento passato è una lista.

TRUE

Invece, restituisce FALSE se viene passato un vettore, che non è una lista, come mostrato nella cella qui sotto.

is.list(c(1,2,3)) #restituisce false perché hai passato un vettore.

FALSE

• Convertire un vettore in una lista è semplicissimo in R. Ti basta usare la funzione as seguita da .list() e passare il vettore come argomento. È tutto ciò che serve per convertire un vettore in una lista.

vec_to_list <- as.list(c(1,2,3))

is.list(vec_to_list) #verificalo con is.list()

TRUE

• D’altra parte, una lista può essere “srotolata” in un vettore usando la funzione unlist. R esegue questa conversione appiattendo l’intera struttura della lista e restituendo infine un singolo vettore.

list_to_vec <- unlist(vec_to_list)

list_to_vec

1. 1
2. 2
3. 3

Similmente a is.list(), puoi usare is.vector() per verificare se l’argomento dato è un vettore oppure no.

is.vector(list_to_vec)

TRUE

Convertiamo la grande lista list_define in un vettore. Nota bene: un vettore può contenere un solo tipo di dato o oggetto R. Di conseguenza, sia i valori logici sia quelli numerici verranno convertiti in stringhe.

unlist(list_define)

log

'TRUE'

ch

'hello_datacamp'

int_vec1

'2'

int_vec2

'2'

int_vec3

'4'

int_vec4

'4'

int_vec5

'6'

int_vec6

'6'

int_vec7

'8'

int_vec8

'8'

Prima di passare all’argomento successivo, vediamo le funzioni append() e rev().

• Come suggerisce il nome, la funzione append() ti permette di aggiungere o concatenare due o più vettori o liste a un vettore o una lista esistente o nuovo.

Proviamo la funzione append() sulla lista list_define. Noterai che la lista ora conterrà 6 elementi invece di 3, poiché hai concatenato la lista con sé stessa.

str(append(list_define, list_define))

List of 6
 $ log    : logi TRUE
 $ ch     : chr "hello_datacamp"
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8
 $ log    : logi TRUE
 $ ch     : chr "hello_datacamp"
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8

• Infine, invertiamo o cambiamo l’ordine della lista list_define con l’aiuto della funzione rev() in R.

str(rev(list_define))

List of 3
 $ int_vec: num [1:8] 2 2 4 4 6 6 8 8
 $ ch     : chr "hello_datacamp"
 $ log    : logi TRUE

Espressioni regolari

Molte persone trovano le espressioni regolari un argomento complesso da imparare. Tuttavia, è un tema essenziale non solo in R ma in vari linguaggi di programmazione come Python. Molti linguaggi, incluso R, forniscono funzionalità integrate per le espressioni regolari.

Un’espressione regolare può essere usata in moltissime applicazioni, ed è utile soprattutto quando vuoi preprocessare dati testuali. È usata in vari problemi di Natural Language Processing (NLP).

È usata anche nei motori di ricerca e nei text editor.

Le espressioni regolari, note anche come regex o regexp o operatori razionali, sono una sequenza di caratteri che definisce un modello di ricerca. In genere, questi modelli di ricerca sono usati da vari algoritmi di ricerca su stringhe per trovare un pattern, oppure per trovare e sostituire il pattern, o per filtrare un pattern corrispondente.

Iniziamo questo argomento capendo l’uso delle funzioni grep() e grepl().

Per semplicità, definiamo un vettore riga animals_regex di lunghezza 5 su cui imparerai ad applicare pattern regex.

animals_regex <- c('cat','dog','cheetah','lion','mice')

Per prima cosa, capiamo la funzione grepl(). La funzione grepl() restituisce un output logico: se la stringa corrisponde al pattern, restituisce TRUE, altrimenti FALSE.

Di seguito c’è una sintassi semplice e intuitiva della funzione grepl() dove il primo argomento è il pattern che vuoi cercare mentre il secondo argomento è la stringa o l’input in cui vuoi trovare o filtrare il pattern. Puoi ignorare gli altri argomenti per ora. grepl(pattern, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE) Scopriamo quali tra i cinque animali sopra contengono una c con l’aiuto della funzione grepl().

In questo caso, stai cercando gli animali che hanno una c nel nome, il che significa direttamente che il pattern qui non è altro che la c stessa.

grepl(pattern = 'c', x = animals_regex)

1. TRUE
2. FALSE
3. TRUE
4. FALSE
5. TRUE

Dall’output sopra, puoi osservare che, dato che c’è una c in cat, cheetah e mice, viene restituito TRUE per quegli indici nel vettore animals_regex, mentre è restituito FALSE per quelli che non corrispondono al pattern c.

Troviamo ora gli elementi che iniziano con c e non solo che contengono una c nel nome.

Per farlo, ti basta usare un segno ^ (accento circonflesso) all’inizio del pattern che vuoi trovare.

grepl(pattern = '^c', x = animals_regex) #solo cat e cheetah iniziano con `c`.

1. TRUE
2. FALSE
3. TRUE
4. FALSE
5. FALSE

Quindi, dall’output sopra, puoi vedere che, poiché solo cat e cheetah iniziano con una c, solo quelle posizioni sono restituite come TRUE.

In modo analogo al segno ^, il simbolo $ può essere usato alla fine del pattern che vuoi trovare per far corrispondere gli elementi che terminano con il pattern specificato. Per trovare un animale che termina con una n, puoi semplicemente usare n seguito dal segno $.

grepl(pattern = 'n$', x = animals_regex) #solo lion termina con una `n`.

1. FALSE
2. FALSE
3. FALSE
4. TRUE
5. FALSE

Nota: Per saperne di più sulle espressioni regolari, digita semplicemente ?regex in una cella di codice di jupyter notebook e si aprirà la documentazione sulle regex. Inoltre, se vuoi approfondire le espressioni regolari, puoi consultare questa fonte, che ti fornisce uno strumento per progettare i tuoi pattern di ricerca e testarli sulle tue stringhe di input.

• In modo simile alla funzione grepl(), esiste la funzione grep(), che invece di restituire un output logico, restituisce l’indice del vettore/matrice che corrisponde al pattern dato.

La sintassi della funzione grep() è esattamente la stessa della funzione grepl() ed è: grep(pattern, x, ignore.case = FALSE, perl = FALSE, value = FALSE, fixed = FALSE, useBytes = FALSE, invert = FALSE) Prendiamo lo stesso esempio di cui sopra above ma questa volta applichiamo la funzione grep()!

grep(pattern = 'c', x = animals_regex)

1. 1
2. 3
3. 5

Come ti aspetteresti, l’output sopra restituisce gli indici degli elementi cat, cheetah e mice, e non TRUE/FALSE. E questo è più o meno tutto!

Usiamo la funzione which per confrontare le funzioni grep() e grepl(). La funzione which() restituisce semplicemente gli indici del vettore per le posizioni TRUE di un oggetto logico.

Ora, se metti insieme i pezzi, avrai capito che, poiché la funzione grepl() è in grado di restituire un oggetto logico, questo verrà semplicemente passato alla funzione which() che convertirà l’output in qualcosa di simile a ciò che ti aspetteresti dalla funzione grep().

which(grepl(pattern = 'c', x = animals_regex))

1. 1
2. 3
3. 5

Analogamente alla funzione grepl(), anche la funzione grep() sa gestire diversi tipi di pattern di espressioni regolari.

Se applichi la funzione grep() per trovare gli elementi nel vettore animals_regex che finiscono con n, ti aspetteresti un output pari a 4 dato che solo lion termina con n, come mostrato di seguito.

grep(pattern = 'n$', x = animals_regex)

4

Ben fatto!

Hai imparato alcune basi delle espressioni regolari, come filtrare gli elementi di un vettore che corrispondono a un dato pattern. Tuttavia, R non si limita al solo pattern matching. Ha un buon numero di funzioni, tra cui sub() è una di queste.

La funzione sub(), invece di filtrare il pattern corrispondente, sostituisce le corrispondenze con altre stringhe. Capciamola più a fondo!

• La funzione sub() accetta principalmente tre argomenti in input che sono:
  • pattern che desideri far corrispondere o l’espressione regolare,
  • replacement il valore che verrà inserito nell’elemento del vettore corrispondente e,
  • x il vettore di stringhe di input su cui applicherai la regex.

La sintassi è: sub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE,fixed = FALSE, useBytes = FALSE) Anche questa volta prendiamo lo stesso esempio di cui sopra per capirne il funzionamento!

sub(pattern = 'c', replacement = 'a', x = animals_regex)

1. 'aat'
2. 'dog'
3. 'aheetah'
4. 'lion'
5. 'miae'

Dall’output sopra, puoi osservare che la stringa cat diventa aat, la stringa cheetah diventa aheetah e la stringa mice diventa miae. Per questi elementi, il pattern è stato trovato con successo.

Nota anche che sub() cerca solo la prima corrispondenza nella stringa, il che significa che se ci sono due c in una stringa, solo la prima occorrenza di c sarà sostituita con a mentre la seconda rimarrà invariata.

Se vuoi comunque sostituire ogni singola corrispondenza di un pattern in una stringa, è meglio usare la funzione gsub(), che è fuori dallo scopo di questo tutorial!

Prima di passare al prossimo argomento, proviamo un’altra espressione interessante.

Questa volta userai l’operatore | (or) che cercherà di far corrispondere uno qualsiasi dei pattern definiti e, se c’è corrispondenza, lo sostituirà con -. Ricorda, dato che usi la funzione gsub(), sostituirà ogni singola corrispondenza di un pattern in una stringa.

gsub(pattern = 'c|d|l', replacement = '-', x = animals_regex) #gli animali con `c`,`d`,`l` vengono sostituiti con `-`.

1. '-at'
2. '-og'
3. '-heetah'
4. '-ion'
5. 'mi-e'

Passiamo all’ultimo argomento del tutorial di oggi, cioè Orari e Date!

Orari e date

Le informazioni su orari e date possono essere molto utili in vari scenari. Per esempio, supponiamo che tu stia lavorando a un problema di Computer Vision e voglia scoprire gli FPS (frame per secondo) a cui gira il tuo algoritmo. In un caso d’uso del genere, potresti usare l’oggetto Time per trovare la velocità di elaborazione del tuo algoritmo di computer vision. Per altri problemi specifici come le previsioni su serie temporali e gli studi di stagionalità, il potenziale di R può essere sfruttato appieno.

Per cominciare, stampiamo velocemente la data di oggi usando R con il semplice comando Sys.Date(). Qui Sys si riferisce al sistema, cioè restituisce un’approssimazione di sistema della data.

Sys.Date()

2020-02-04

Semplice, vero?

Gli orari e le date in R appartengono all’oggetto Date, o, detto altrimenti, il tipo di dato è Date. Può essere verificato usando la funzione class che hai visto nel tutorial Tipi di dati in R.

In modo simile alla funzione Date, hai la funzione time() che restituisce l’ora corrente di sistema, anzi, restituisce sia ora che data come output.

Sys.time()

[1] "2020-02-04 02:05:04 IST"

Creare oggetti Date

Hai imparato a ottenere data e ora correnti. Vediamo ora come puoi creare date per altri giorni passando una semplice stringa come argomento.

Per creare un oggetto data per il 10 maggio 1993, userai la seguente sintassi:

date_may <- as.Date('1993-05-10') #converte una stringa di caratteri in un oggetto data

date_may

1993-05-10

class(date_may)

'Date'

Un punto importante da notare è che la funzione Date di R per impostazione predefinita si aspetta che tu inserisca la data nel formato YYYY-MM-DD; se provi a scambiare anno con mese o giorno, otterrai un errore. Proviamo!

date_may <- as.Date('05-1993-10') #R segue per default il formato data ISO

Error in charToDate(x): character string is not in a standard unambiguous format
Traceback:


1. as.Date("05-1993-10")

2. as.Date.character("05-1993-10")

3. charToDate(x)

4. stop("character string is not in a standard unambiguous format")

La buona notizia è che puoi cambiare esplicitamente il formato passando l’argomento format e personalizzandolo di conseguenza.

date_may <- as.Date('05-1993-10', format = '%m-%Y-%d')

La funzione as.Date() accetterà formati di data diversi, ma alla fine li convertirà nel formato data ISO; puoi verificarlo stampando la variabile date_may.

date_may

1993-05-10

date_may <- as.Date('05-10-1993', format = '%m-%d-%Y')

date_may

1993-05-10

Aritmetica sulle date

Non sarebbe fantastico poter applicare operazioni matematiche come addizione e sottrazione agli oggetti Date in R?

Sommiamo 1 alla variabile date_may, e vedrai che mostrerà la data di un giorno dopo.

date_may + 1

1993-05-11

Ottimo, come vedi dall’output sopra, aggiungere uno ha cambiato la data dall’11 maggio 1993 al 10 maggio 1993. Analogamente, puoi sottrarre uno dalla data.

Diciamo che vuoi scoprire la differenza temporale tra la tua data di nascita e quella di un fratello maggiore.

elder_sib <- as.Date('1989-03-21')

date_may - elder_sib

Time difference of 1511 days

Conclusione

Congratulazioni per aver completato il tutorial.

Questo tutorial è stato un buon punto di partenza per chi vuole imparare diverse funzioni utili in R. Come buon esercizio, potresti voler approfondire le Espressioni Regolari, perché sono utilizzate in molte applicazioni e sono davvero uno strumento molto potente quando si tratta di pulire o preprocessare dati testuali.

Per qualsiasi domanda relativa a questo tutorial, sentiti libero di scriverla nei commenti qui sotto.

Se vuoi imparare di più su R, segui il corso Intermediate R di DataCamp e dai un’occhiata al nostro tutorial Usare le funzioni in R.