Tipi di dati in R con esempio

Quali sono i tipi di dati in R?

Di seguito sono riportati i tipi di dati o strutture dati nella programmazione R:

• scalari
• Vettori (numerici, di carattere, logici)
• Matrici
• Frame di dati
• elenchi

Quell'elenco mescola due idee correlate, e separarle rende più facile seguire il resto di questa pagina. A tipo di dati descrive cosa sia un singolo valore: un numero, un pezzo di testo, un VERO o un FALSO. struttura dati Descrive quanti valori sono raggruppati e in quale forma. Scalari, vettori, matrici, data frame e liste sono strutture; i valori al loro interno appartengono comunque a uno dei tipi base di R.

R non ha un tipo scalare separato: uno scalare è semplicemente un vettore di lunghezza uno, ed è per questo che gran parte del codice R è scritto per vettori interi in una sola volta.

Tipi di dati di base in R

Ogni valore in R appartiene a uno di un piccolo insieme di tipi base (atomici):

• 4.5 è un valore decimale chiamato numerico.
• Il numero 4 sembra un numero intero, ma R lo memorizza comunque come double. Scrivi 4L quando è richiesto un numero intero vero e proprio.
• VERO o FALSO è un valore booleano, chiamato logico in R.
• Il valore racchiuso tra virgolette singole (" ") o doppie " è testo (una stringa). Questi valori sono chiamati caratteri.

Due ulteriori tipi completano l'insieme. I valori complessi come 3+2i contengono una parte reale e una immaginaria, mentre i valori raw contengono byte. Entrambi compaiono raramente nell'analisi quotidiana, ma sono elencati nel linguaggio R di base. documentazione di typeof() accanto ai quattro tipi comuni.

Possiamo verificare il tipo di una variabile con la funzione di classe.

Esempio 1: Verifica di una variabile numerica

# Declare variables of different types
# Numeric
x <- 28
class(x)

Produzione:

## [1] "numeric"

Esempio 2: Verifica di una variabile di tipo carattere

# String
y <- "R is Fantastic"
class(y)

Produzione:

## [1] "character"

Esempio 3: Verifica di una variabile logica

# Boolean
z <- TRUE
class(z)

Produzione:

## [1] "logical"

Si noti che class() restituisce "numerico" per 28 anche se 28 non ha parte decimale. R lo memorizza come double, e solo typeof() lo rivela. La prossima differenza che vale la pena imparare è come a questi valori vengono assegnati i nomi.

Variabili in R

Le variabili sono uno degli elementi costitutivi fondamentali di R per memorizzare valori e sono importanti per chiunque si occupi di data science. Una variabile in R può memorizzare un numero, un oggetto, un risultato statistico, un vettore, un dataset o una previsione di un modello: in pratica, qualsiasi cosa R produca in output. Possiamo utilizzare quella variabile in seguito semplicemente richiamandone il nome.

Per dichiarare una variabile in R, è necessario assegnarle un nome. Il nome non deve contenere spazi. Possiamo usare il carattere _ per unire due parole.

I nomi possono contenere lettere, cifre, punti e trattini bassi, ma devono iniziare con una lettera o un punto e non possono essere utilizzati come nomi parole riservate come TRUE, FALSE e NULL. Per aggiungere un valore alla variabile, utilizzare <- o =.

Ecco la sintassi:

# First way to declare a variable:  use the `<-`
name_of_variable <- value
# Second way to declare a variable:  use the `=`
name_of_variable = value

Nella riga di comando possiamo scrivere i seguenti codici per vedere cosa succede:

Esempio 1: Assegna un valore e stampalo

# Print variable x
x <- 42
x

Produzione:

## [1] 42

Esempio 2: Dichiarare una seconda variabile

y  <- 10
y

Produzione:

## [1] 10

Esempio 3: Utilizzare due variabili in un'unica espressione

# We call x and y and apply a subtraction
x-y

Produzione:

## [1] 32

Una variabile che contiene più valori dello stesso tipo è un vettore, che è la struttura prevista da quasi tutte le funzioni di R.

Vettori in R

Un vettore è una collezione unidimensionale in cui ogni elemento condivide lo stesso tipo. Possiamo creare un vettore con tutti i tipi di dati di base di R appresi in precedenza. Il modo più semplice per costruire un vettore in R è utilizzare la funzione c().

Esempio 1: Creare un vettore numerico

# Numerical
vec_num <- c(1, 10, 49)
vec_num

Produzione:

## [1]  1 10 49

Esempio 2: Creare un vettore di caratteri

# Character 
vec_chr <- c("a", "b", "c")
vec_chr

Produzione:

## [1] "a" "b" "c"

Esempio 3: Creare un vettore logico

# Boolean 
vec_bool <-  c(TRUE, FALSE, TRUE)
vec_bool

Produzione:

##[1] TRUE FALSE TRUE

Se c() riceve un mix di tipi, non fallisce. Converte silenziosamente ogni elemento al tipo più generale presente, quindi c(1, "a", TRUE) diventa un vettore di caratteri. Possiamo anche eseguire calcoli aritmetici sui vettori in R.

Esempio 4: Sommare due vettori elemento per elemento

# Create the vectors
vect_1 <- c(1, 3, 5)
vect_2 <- c(2, 4, 6)
# Take the sum of A_vector and B_vector
sum_vect <- vect_1 + vect_2
# Print out total_vector
sum_vect

Produzione:

[1]  3  7 11

L'addizione viene eseguita elemento per elemento perché entrambi i vettori hanno la stessa lunghezza. Quando le lunghezze differiscono, R ricicla il vettore più corto, ripetendolo finché non corrisponde a quello più lungo, e avvisa solo quando la lunghezza del vettore più lungo non è un multiplo di quella del vettore più corto.

Esempio 5: Sezionare i primi cinque elementi

In R è possibile sezionare un vettore. In alcune occasioni, siamo interessati solo ai primi cinque elementi di un vettore. Possiamo usare il comando [1:5] per estrarretract i valori da 1 a 5.

# Slice the first five rows of the vector
slice_vector <- c(1,2,3,4,5,6,7,8,9,10)
slice_vector[1:5]

Produzione:

## [1] 1 2 3 4 5

Esempio 6: Costruire un intervallo con i due punti Operator

Il modo più breve per creare un intervallo di valori è utilizzare l'operatore due punti (:) tra due numeri. Ad esempio, riprendendo l'esempio precedente, possiamo scrivere c(1:10) per creare un vettore di valori da uno a dieci.

# Faster way to create adjacent values
c(1:10)

Produzione:

## [1]  1  2  3  4  5  6  7  8  9 10

Poiché un vettore cambia silenziosamente tipo quando viene miscelato, è utile sapere come ispezionare e convertire i tipi su richiesta.

Come verificare e convertire i tipi di dati in R

Tre famiglie di funzioni rispondono alle tre domande che si presentano costantemente: cos'è questo, è di un determinato tipo e può trasformarsi in un altro tipo.

# Three different views of the same value
x <- 28
class(x)      # "numeric"  -- the class used for method dispatch
typeof(x)     # "double"   -- how R stores the value internally
mode(x)       # "numeric"  -- the older S-style mode

# Ask a yes/no question about a type
is.numeric(x)     # TRUE
is.character(x)   # FALSE

# Convert between types
as.character(x)   # "28"
as.integer("28")  # 28 stored as an integer
as.numeric("abc") # NA, with a coercion warning

Due regole spiegano la maggior parte delle sorprese qui. Primo, class() riporta la classe utilizzata per l'invio del metodo mentre typeof() riporta la memoria interna, motivo per cui 28 è "numeric" per uno e "double" per l'altro. Secondo, una conversione che non può avere successo non interrompe lo script: as.numeric("abc") restituisce NA e stampa un avviso di coercizione, quindi i NA silenziosi dopo un'importazione sono quasi sempre un problema di tipo. La stessa logica guida Fattoriche memorizzano le categorie come codici interi più una tabella di livelli.

Una volta definiti i tipi, il prossimo passo è quello di concentrarsi sugli operatori che agiscono su di essi.

R Aritmetica OperaTors

Innanzitutto, esamineremo gli operatori aritmetici di base in R. Di seguito sono riportati gli operatori aritmetici nella programmazione R e il loro significato:

Ciascuno di questi operatori è vettorializzato, quindi la stessa espressione funziona sia su un singolo valore che su un'intera colonna.

Esempio 1: Addizione

# An addition
3 + 4

Produzione:

## [1] 7

Puoi facilmente copiare e incollare il codice R sopra riportato nel RStudio Console. In questo articolo l'output viene mostrato sulle righe che iniziano con ##. Ad esempio, se scriviamo il codice print("Guru99") la console stampa [1] "Guru99", che questa pagina mostrerebbe come ## [1] "Guru99. "

Il simbolo ## indica una riga di output stampato e il numero tra parentesi quadre ([1]) è l'indice del primo valore su quella riga, non fa parte del risultato.

Le frasi che iniziano con # sono commenti. Possiamo usare # all'interno di uno script R per aggiungere qualsiasi nota desideriamo, e R la ignora in fase di esecuzione.

Esempio 2: Moltiplicazione

# A multiplication
3*5

Produzione:

## [1] 15

Esempio 3: Divisione

# A division
(5+5)/2

Produzione:

## [1] 5

Esempio 4: Esponenziazione

# Exponentiation
2^5

Produzione:

## [1] 32

Esempio 5: Modulo

# Modulo
28%%6

Produzione:

## [1] 4

L'aritmetica produce numeri. Il gruppo successivo di operatori produce invece i valori VERO e FALSO.

R relazionale (confronto) OperaTors

Gli operatori relazionali confrontano due valori e restituiscono un risultato logico. Sono gli operatori che definiscono le condizioni utilizzate per il filtraggio e vengono vettorializzati esattamente nello stesso modo degli operatori aritmetici.

a <- 10
b <- 3

a > b     # TRUE
a < b     # FALSE
a >= 10   # TRUE
a <= 3    # FALSE
a == b    # FALSE
a != b    # TRUE

# Relational operators are vectorised
scores <- c(45, 78, 90, 62)
scores >= 60   # FALSE TRUE TRUE TRUE

Due abitudini fanno risparmiare tempo qui. Usa == per il confronto e <- per l'assegnazione, perché un singolo = all'interno di una condizione è un errore comune dei principianti. Ed evita == sui double: l'arrotondamento in virgola mobile significa che 0.1 + 0.2 == 0.3 è FALSO, quindi isTRUE(all.equal(0.1 + 0.2, 0.3)) è il test sicuro. I confronti su frame di dati ordinati seguire le stesse regole.

R Logico OperaTors

Con gli operatori logici, vogliamo restituire i valori all'interno del vettore in base a condizioni logiche. La tabella seguente elenca gli operatori logici disponibili in R.

In R, le istruzioni logiche sono racchiuse tra parentesi quadre []. Possiamo aggiungere tutte le istruzioni condizionali che vogliamo, ma dobbiamo includerle tra parentesi. Possiamo seguire questa struttura per creare un'istruzione condizionale:

variable_name[(conditional_statement)]

Dove `variable_name` si riferisce alla variabile che vogliamo utilizzare nell'istruzione, creiamo l'istruzione logica, ad esempio `variable_name > 0`. Infine, utilizziamo le parentesi quadre per completare l'istruzione logica. Di seguito è riportato un esempio di istruzione logica.

Esempio 1: Confronta ogni elemento di un vettore

# Create a vector from 1 to 10
logical_vector <- c(1:10)
logical_vector>5

Produzione:

## [1]FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

Nell'output sopra riportato, R legge ciascun valore e lo confronta con l'affermazione logical_vector>5. Se il valore è strettamente maggiore di cinque, la condizione è VERA, altrimenti FALSA. R restituisce un vettore contenente i valori VERI e FALSI.

Esempio 2: Mantieni solo gli elementi che corrispondono

Nell'esempio seguente, vogliamo estraci valori che soddisfano solo la condizione 'è strettamente maggiore di cinque'. Per fare ciò, possiamo racchiudere la condizione tra parentesi quadre preceduta dal vettore contenente i valori.

# Print value strictly above 5
logical_vector[(logical_vector>5)]

Produzione:

## [1]  6  7  8  9 10

Esempio 3: Combinare due condizioni

# Print 5 and 6
logical_vector <- c(1:10)
logical_vector[(logical_vector>4) & (logical_vector<7)]

Produzione:

## [1] 5 6

L'esempio 3 utilizza la singola e commerciale & di proposito. Gli operatori a singolo carattere & e | confrontano i vettori elemento per elemento e restituiscono un vettore, che è ciò di cui ha bisogno il sottoinsieme. Le forme doppie && e || restituiscono un valore e appartengono alle condizioni if() e while(). Poiché R 4.3.0Passare un argomento più lungo di un elemento a && o || è un errore anziché un avviso, quindi le due famiglie non sono più intercambiabili. L'operatore ! nega una condizione e xor() restituisce l'OR esclusivo.

Assegnazione R OperaTors

Gli operatori di assegnazione associano un valore a un nome. R ne offre più della maggior parte dei linguaggi e le differenze contano una volta che il codice si sposta in funzioni.

# Left assignment -- the idiomatic form
count <- 5

# Equals sign: works, but reserve it for function arguments
count = 5
round(3.14159, digits = 2)

# Right assignment
5 -> count

# Superassignment, used inside functions to reach an outer scope
count <<- 5

Le guide di stile raccomandano <- per creare oggetti e = per nominare gli argomenti all'interno di una chiamata, perché in questo modo i due ruoli rimangono visivamente distinti. Usare <<- con parsimonia: modifica un oggetto al di fuori della funzione corrente e rende il codice più difficile da comprendere. Una volta acquisita familiarità con l'assegnazione e i tipi, i passi successivi sono importazione di dati reali e Reshaping con dplyr; il Panoramica del linguaggio R Mette in prospettiva l'intera catena di strumenti.

DOMANDE FREQUENTI