R Language
variabili

Variabili, strutture dati e operazioni di base

In R, gli oggetti dati vengono manipolati utilizzando strutture dati con nome. I nomi degli oggetti potrebbero essere chiamati "variabili" sebbene quel termine non abbia un significato specifico nella documentazione ufficiale di R. I nomi R sono case sensitive e possono contenere caratteri alfanumerici ( az , Az , 0-9 ), il punto / punto ( . ) E il carattere di sottolineatura ( _ ). Per creare nomi per le strutture dati, dobbiamo seguire le seguenti regole:

• I nomi che iniziano con una cifra o un trattino basso (es. 1a ), o nomi che sono espressioni numeriche valide (es. .11 ), o nomi con trattini ('-') o spazi possono essere usati solo quando sono quotati: `1a` e `.11` . I nomi verranno stampati con i backtick:

   list( '.11' ="a")
   #$`.11`
   #[1] "a"
  

• Tutte le altre combinazioni di caratteri alfanumerici, punti e caratteri di sottolineatura possono essere utilizzati liberamente, dove il riferimento con o senza apici invoca lo stesso oggetto.

• Nomi che iniziano con . sono considerati nomi di sistema e non sono sempre visibili utilizzando la funzione ls() .

Non ci sono restrizioni sul numero di caratteri nel nome di una variabile.

Alcuni esempi di nomi di oggetti validi sono: foobar , foo.bar , foo_bar , .foobar

In R, le variabili vengono assegnate ai valori usando l'operatore di assegnazione infissi <- . L'operatore = può anche essere usato per assegnare valori alle variabili, tuttavia il suo uso corretto è per associare valori con nomi di parametri nelle chiamate di funzione. Nota che omettere gli spazi intorno agli operatori può creare confusione per gli utenti. L'espressione a<-1 viene analizzata come assegnazione ( a <- 1 ) anziché come confronto logico ( a < -1 ).

> foo <- 42
> fooEquals = 43

Quindi a foo viene assegnato il valore di 42 . Digitando foo all'interno della console verrà emesso 42 , mentre digitando fooEquals uscirà 43 .

> foo
[1] 42
> fooEquals
[1] 43

Il seguente comando assegna un valore alla variabile denominata x e stampa simultaneamente il valore:

> (x <- 5) 
[1] 5
# actually two function calls: first one to `<-`; second one to the `()`-function
> is.function(`(`)
[1] TRUE  # Often used in R help page examples for its side-effect of printing.

È anche possibile effettuare assegnazioni a variabili usando -> .

> 5 -> x
> x
[1] 5
> 

Tipi di strutture dati

Non ci sono tipi di dati scalari in R. I vettori di lunghezza-uno agiscono come scalari.

• Vettori: i vettori atomici devono essere sequenze di oggetti della stessa classe: una sequenza di numeri o una sequenza di logici o una sequenza di caratteri. v <- c(2, 3, 7, 10) , v2 <- c("a", "b", "c") sono entrambi i vettori.
• Matrici: una matrice di numeri, logica o caratteri. a <- matrix(data = c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), nrow = 4, ncol = 3, byrow = F) . Come i vettori, la matrice deve essere composta da elementi della stessa classe. Per estrarre elementi da una matrice righe e colonne devono essere specificati: a[1,2] restituisce [1] 5 che è l'elemento sulla prima riga, seconda colonna.
• Elenchi: concatenazione di diversi elementi mylist <- list (course = 'stat', date = '04/07/2009', num_isc = 7, num_cons = 6, num_mat = as.character(c(45020, 45679, 46789, 43126, 42345, 47568, 45674)), results = c(30, 19, 29, NA, 25, 26 ,27) ) . Estrarre elementi da un elenco può essere fatto per nome (se l'elenco è chiamato) o per indice. Nell'esempio dato mylist$results e mylist[[6]] ottiene lo stesso elemento. Attenzione: se provi la mylist[6] , R non ti darà un errore, ma estrae il risultato come una lista. Mentre mylist[[6]][2] è permesso (ti dà 19), mylist[6][2] ti dà un errore.
• data.frame: oggetto con colonne che sono vettori di uguale lunghezza, ma (possibilmente) tipi diversi. Non sono matrici. exam <- data.frame(matr = as.character(c(45020, 45679, 46789, 43126, 42345, 47568, 45674)), res_S = c(30, 19, 29, NA, 25, 26, 27), res_O = c(3, 3, 1, NA, 3, 2, NA), res_TOT = c(30,22,30,NA,28,28,27)) . Le colonne possono essere lette per nome exam$matr , exam[, 'matr'] o per exam[1] indice exam[1] , exam[,1] . Le righe possono anche essere lette con l' exam['rowname', ] nome exam['rowname', ] o con l' exam[1,] indice exam[1,] . I dataframes sono in realtà solo elenchi con una particolare struttura (attributi rownames e componenti di uguale lunghezza)

Operazioni comuni e alcuni consigli di prudenza

Le operazioni di default sono eseguite elemento per elemento. Vedi ?Syntax per le regole di precedenza degli operatori. La maggior parte degli operatori (e altre funzioni nella base R) hanno regole di riciclaggio che consentono argomenti di lunghezza non uguale. Dati questi oggetti:

Oggetti di esempio

> a <- 1
> b <- 2
> c <- c(2,3,4)
> d <- c(10,10,10)
> e <- c(1,2,3,4)
> f <- 1:6
> W <- cbind(1:4,5:8,9:12)
> Z <- rbind(rep(0,3),1:3,rep(10,3),c(4,7,1))

Alcune operazioni vettoriali

> a+b # scalar + scalar
[1] 3
> c+d # vector + vector
[1] 12 13 14
> a*b # scalar * scalar 
[1] 2
> c*d # vector * vector (componentwise!)
[1] 20 30 40
> c+a # vector + scalar
[1] 3 4 5
> c^2 # 
[1]  4  9 16
> exp(c) 
[1]  7.389056 20.085537 54.598150

Alcuni avvisi di operazione vettoriale!

> c+e # warning but.. no errors, since recycling is assumed to be desired.
[1] 3 5 7 6
Warning message:
In c + e : longer object length is not a multiple of shorter object length

R somma ciò che può e quindi riutilizza il vettore più corto per riempire gli spazi vuoti ... L'avvertimento è stato dato solo perché i due vettori hanno lunghezze che non sono esattamente multipli. c + f # nessun avviso di sorta.

Alcune operazioni con la matrice Avvertenza!

> Z+W # matrix + matrix #(componentwise)
> Z*W # matrix* matrix#(Standard product is always componentwise)

Per utilizzare una matrice moltiplicare: V% *% W

> W + a # matrix+ scalar is still componentwise
     [,1] [,2] [,3]
[1,]    2    6   10
[2,]    3    7   11
[3,]    4    8   12
[4,]    5    9   13

> W + c # matrix + vector... : no warnings and R does the operation in a column-wise manner
     [,1] [,2] [,3]
[1,]    3    8   13
[2,]    5   10   12
[3,]    7    9   14
[4,]    6   11   16

Variabili "private"

Un punto iniziale in un nome di una variabile o funzione in R è comunemente usato per indicare che la variabile o funzione è pensata per essere nascosta.

Quindi, dichiarando le seguenti variabili

> foo <- 'foo'
> .foo <- 'bar'

E poi usando la funzione ls per elencare oggetti mostrerà solo il primo oggetto.

> ls()
[1] "foo"

Tuttavia, passando all.names = TRUE alla funzione mostrerà la variabile 'private'

> ls(all.names = TRUE)
[1] ".foo"          "foo"