R Language
Variabelen

Variabelen, gegevensstructuren en basisbewerkingen

In R worden gegevensobjecten gemanipuleerd met behulp van benoemde gegevensstructuren. De namen van de objecten kunnen "variabelen" worden genoemd, hoewel die term geen specifieke betekenis heeft in de officiële R-documentatie. R-namen zijn hoofdlettergevoelig en kunnen alfanumerieke tekens ( az , Az , 0-9 ), de punt / punt ( . ) En het onderstrepingsteken ( _ ) bevatten. Om namen voor de gegevensstructuren te maken, moeten we de volgende regels volgen:

• Namen die beginnen met een cijfer of een onderstrepingsteken (bijv. 1a ), of namen die geldige numerieke uitdrukkingen (bijv. .11 ) zijn, of namen met streepjes ('-') of spaties kunnen alleen worden gebruikt als ze worden aangehaald: `1a` en `.11` . De namen worden afgedrukt met backticks:

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

• Alle andere combinaties van alfanumerieke tekens, punten en onderstrepingstekens kunnen vrij worden gebruikt, waarbij verwijzing met of zonder backticks naar hetzelfde object verwijst.

• Namen die beginnen met . worden beschouwd als systeemnamen en zijn niet altijd zichtbaar met de ls() -functie.

Er is geen beperking op het aantal tekens in de naam van een variabele.

Enkele voorbeelden van geldige objectnamen zijn: foobar , foo.bar , foo_bar , .foobar

In R worden variabelen toegewezen waarden met behulp van de infix-toewijzingsoperator <- . De operator = kan ook worden gebruikt voor het toewijzen van waarden aan variabelen, maar het juiste gebruik is voor het koppelen van waarden aan parameternamen in functie-aanroepen. Houd er rekening mee dat het weglaten van spaties rond operators verwarring bij gebruikers kan veroorzaken. De uitdrukking a<-1 wordt ontleed als toewijzing ( a <- 1 ) in plaats van als een logische vergelijking ( a < -1 ).

> foo <- 42
> fooEquals = 43

Dus foo krijgt de waarde 42 toegewezen. Als u foo binnen de console typt, wordt 42 , terwijl fooEquals wordt uitgevoerd als uitvoer 43 .

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

De volgende opdracht wijst een waarde toe aan de variabele met de naam x en drukt de waarde tegelijkertijd af:

> (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.

Het is ook mogelijk om toewijzingen aan variabelen te maken met -> .

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

Soorten gegevensstructuren

Er zijn geen scalaire gegevenstypen in R. Vectoren van lengte één gedragen zich als scalaren.

• Vectoren: Atoomvectoren moeten een reeks objecten van dezelfde klasse zijn: een reeks getallen of een reeks logische tekens of een reeks tekens. v <- c(2, 3, 7, 10) , v2 <- c("a", "b", "c") zijn beide vectoren.
• Matrices: een matrix van cijfers, logische tekens of tekens. a <- matrix(data = c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), nrow = 4, ncol = 3, byrow = F) . Net als vectoren moet matrix worden gemaakt van elementen van dezelfde klasse. Om elementen uit een matrix te extraheren, moeten rijen en kolommen worden opgegeven: a[1,2] geeft [1] 5 dat is het element op de eerste rij, tweede kolom.
• Lijsten: aaneenschakeling van verschillende elementen 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) ) . Elementen uit een lijst extraheren kan op naam (als de lijst een naam heeft) of op index. In het gegeven voorbeeld verkrijgt mylist$results en mylist[[6]] hetzelfde element. Waarschuwing: als je mylist[6] probeert, geeft R je geen foutmelding, maar haalt het het resultaat op als een lijst. Hoewel mylist[[6]][2] is toegestaan (het geeft je 19), geeft mylist[6][2] je een foutmelding.
• data.frame: object met kolommen die even lang zijn, maar (mogelijk) verschillende typen. Het zijn geen matrices. 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)) . Kolommen kunnen worden gelezen door naam exam$matr , exam[, 'matr'] of door index exam[1] , exam[,1] . Rijen kunnen ook worden gelezen door exam['rowname', ] of exam['rowname', ] exam[1,] . Dataframes zijn eigenlijk alleen lijsten met een bepaalde structuur (rownames-attribuut en componenten van gelijke lengte)

Algemene operaties en een aantal waarschuwingsadviezen

Standaardbewerkingen worden element voor element uitgevoerd. Zie ?Syntax voor de regels van operatorprioriteit. De meeste operators (en mogelijk andere functies in base R) hebben recyclingregels die argumenten van ongelijke lengte toestaan. Gezien deze objecten:

Voorbeeld objecten

> 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))

Sommige vectorbewerkingen

> 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

Enkele vectorbewerking Waarschuwingen!

> 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 somt op wat het kan en hergebruikt vervolgens de kortere vector om de lege plekken in te vullen ... De waarschuwing werd alleen gegeven omdat de twee vectoren lengtes hebben die niet precies veelvouden zijn. c + f # geen enkele waarschuwing.

Enkele Matrix-bewerkingen Waarschuwing!

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

Om een matrixvermenigvuldiging te gebruiken: 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

"Privé" variabelen

Een voorlooppunt in een naam van een variabele of functie in R wordt meestal gebruikt om aan te geven dat de variabele of functie bedoeld is om te worden verborgen.

Dus, het verklaren van de volgende variabelen

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

En dan zal het gebruik van de ls functie om objecten weer te geven alleen het eerste object tonen.

> ls()
[1] "foo"

Als echter all.names = TRUE wordt doorgegeven aan de functie, wordt de variabele 'private' weergegeven

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