Gegevenstypen in R

Voordat we beginnen met de introductie en meer leren over de verschillende gegevenstypen in R, zetten we snel de R-omgeving op, zowel in de Terminal als in Jupyter Notebook.

Het volgende commando is voor macOS en zal R op je terminal installeren.

brew install r --build-from-source

Om te controleren of de installatie is gelukt, typ je gewoon R (hoofdletter) in de terminal en ga je een R-sessie in, zoals hieronder getoond.

Voor installatie op andere besturingssystemen kun je deze tutorial bekijken.

Laten we nu de programmeertaal R als kernel toevoegen aan Jupyter Notebook. Zorg dat Jupyter Notebook al op je systeem is geïnstalleerd.

Ga naar je terminal, open de R-sessie en voer de onderstaande twee commando's in. Daarmee voeg je de R-kernel toe aan je Jupyter Notebook.

install.packages('IRkernel')
IRkernel::installspec()

Zodra de bovenstaande twee commando's succesvol zijn uitgevoerd, start je Jupyter vanuit de terminal en open je een notebook met de R-kernel, zoals hieronder:

Nu ben je helemaal klaar om je eerste R-code te schrijven in Jupyter Notebook.

Introductie

Om R optimaal te benutten, is het heel belangrijk om de verschillende gegevenstypen en gegevensstructuren in R te kennen en te begrijpen, en hoe ze werken. Ze spelen een sleutelrol in vrijwel alle problemen, en zeker wanneer je werkt aan machine learning-problemen, die erg datacentraal zijn.

In een programmeertaal hebben we doorgaans variabelen nodig om informatie op te slaan, zoals een integer, tekenreeks, drijvendekomma, boolean, enz. Het type van de variabele is puur gebaseerd op welk soort informatie deze bevat. Als er een integer aan is toegekend, dan heeft de variabele het gegevenstype int. Variabelen zijn simpelweg gereserveerde geheugenlocaties waar waarden worden opgeslagen. Zodra je een variabele aanmaakt, wordt er geheugenruimte voor gereserveerd.

Afhankelijk van het gegevenstype van een variabele zal er door het besturingssysteem geheugen worden toegewezen. In R-programmering reserveert een variabele die een integer bevat bijvoorbeeld 4 bytes geheugen en 1 byte voor een teken.

In programmeertalen als C, C++ en Java worden variabelen gedeclareerd met een gegevenstype; in Python en R zijn variabelen echter objecten. Objecten zijn gegevensstructuren met enkele attributen en methoden die op die attributen worden toegepast.

Er zijn verschillende soorten R-objecten of gegevensstructuren die in deze tutorial worden besproken, zoals:

• Vectoren

• Lijsten

• Matrices

• Arrays

• Factoren

• Dataframes

Laten we eerst enkele basistypen begrijpen waarop de R-objecten zijn gebouwd, zoals Numeric, Integer, Character, Factor en Logical.

• Numeric: Getallen die een decimale waarde hebben of van nature een breuk zijn, hebben het gegevenstype numeric.

num <- 1.2
print(num)

[1] 1.2

Je kunt het gegevenstype van a controleren met het keyword class().

class(num)

'numeric'

• Integer: Getallen zonder decimale waarden hebben een gegevenstype integer. Om een integer- gegevenstype te maken, gebruik je expliciet as.integer() en geef je de variabele door als argument.

int <- as.integer(2.2)
print(int)

[1] 2

class(int)

'integer'

• Character: Zoals de naam suggereert, kan het een letter of een combinatie van letters zijn, tussen aanhalingstekens, die door R als een character-gegevenstype wordt beschouwd. Het kunnen letters of cijfers zijn.

char <- "datacamp"
print(char)

[1] "datacamp"

class(char)

'character'

char <- "12345"
print(char)

[1] "12345"

class(char)

'character'

• Logical: Een variabele die een waarde True of False kan hebben, zoals een boolean, wordt een logical-variabele genoemd.

log_true <- TRUE
print(log_true)

[1] TRUE

class(log_true)

'logical'

log_false <- FALSE
print(log_false)

[1] FALSE

class(log_false)

'logical'

• Factor: Dit is een gegevenstype dat wordt gebruikt om te verwijzen naar kwalitatieve relaties zoals kleuren, goed & slecht, cursus- of filmbeoordelingen, enz. Ze zijn nuttig in statistische modellering.

Om dit te bereiken, maak je gebruik van de functie c(), die een (eendimensionale) vector retourneert door alle elementen te combineren.

fac <- factor(c("good", "bad", "ugly","good", "bad", "ugly"))

print(fac)

[1] good bad  ugly good bad  ugly
Levels: bad good ugly

class(fac)

'factor'

De factor fac heeft drie levels: good, bad en ugly. Je kunt dit controleren met het keyword levels, en het type van levels is character.

levels(fac)

1. 'bad'
2. 'good'
3. 'ugly'

nlevels(fac)

3

class(levels(fac))

'character'

Voordat we verdergaan, bekijken we een paar belangrijke tips die handig kunnen zijn!

• Onthoud altijd dat de programmeertaal R hoofdlettergevoelig is. Alle objecten die hierboven zijn gedefinieerd, moeten op dezelfde manier worden gebruikt, of dat nu met hoofdletters of kleine letters is, zoals in het onderstaande voorbeeld.

Num

Error in eval(expr, envir, enclos): object 'Num' not found
Traceback:

• In R kun je alle variabelen of objecten die je in de werkomgeving hebt gedefinieerd controleren met het keyword ls(), zoals hieronder weergegeven.

ls()

1. 'char'
2. 'int'
3. 'num'

Lijsten

In tegenstelling tot vectoren kan een lijst elementen van verschillende gegevenstypen bevatten en staat ze vaak bekend als een geordende collectie waarden. Ze kan vectoren, functies, matrices en zelfs weer een andere lijst (geneste lijst) bevatten.

Lijsten in R zijn één-gebaseerd geïndexeerd, d.w.z. de index begint bij één.

Laten we het concept van lijsten begrijpen met een snel voorbeeld dat drie verschillende gegevenstypen in één lijst opslaat.

lis1 <- 1:5  # Integer Vector
lis1

1. 1
2. 2
3. 3
4. 4
5. 5

lis2 <- factor(1:5)  # Factor Vector
lis2

1. 1
2. 2
3. 3
4. 4
5. 5

lis3 <- letters[1:5]  # Character Vector
lis3

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

combined_list <- list(lis1, lis2, lis3)

combined_list

1. 1. 1
   2. 2
   3. 3
   4. 4
   5. 5
   1. 1
   2. 2
   3. 3
   4. 4
   5. 5
2. Niveaus:

   1. '1'
   2. '2'
   3. '3'
   4. '4'
   5. '5'
   1. 'a'
   2. 'b'
   3. 'c'
   4. 'd'
   5. 'e'

Laten we elk van de vectoren in de lijst afzonderlijk benaderen. Hiervoor gebruik je dubbele vierkante haken, omdat de drie vectoren op hetzelfde niveau in de lijst staan. python combined_list[[1]]

1. 1
2. 2
3. 3
4. 4
5. 5

python combined_list[[2]]

1. 1
2. 2
3. 3
4. 4
5. 5

combined_list[[3]]

1. 'a'
2. 'b'
3. 'c'
4. 'd'
5. 'e'

Laten we nu proberen het vijfde element uit de derde vector te benaderen; dat geeft de letter e.

combined_list[[3]][5]

'e'

Tot slot proberen we de lijst te flattenen. Belangrijk om te onthouden: omdat combined_list een combinatie is van character- en numeric-typen, krijgt het character-type voorrang en wordt het gegevenstype van de volledige lijst character.

flat_list <- unlist(combined_list)

class(flat_list)

'character'

flat_list

1. '1'
2. '2'
3. '3'
4. '4'
5. '5'
6. '1'
7. '2'
8. '3'
9. '4'
10. '5'
11. 'a'
12. 'b'
13. 'c'
14. 'd'
15. 'e'

length(flat_list)

15

Vectoren

Vectoren zijn objecten die worden gebruikt om meerdere waarden van hetzelfde gegevenstype op te slaan. Een vector kan niet zowel integers als tekens combineren. Als je bijvoorbeeld de totaalscore van 100 studenten wilt opslaan, maak je in plaats van 100 verschillende variabelen een vector van lengte 100 die alle cijfers bevat.

Een vector kan worden gemaakt met de functie c(), die alle elementen combineert en een eendimensionale array retourneert.

Laten we een vector marks maken met gegevens van vijf studenten van het type numeric.

marks <- c(88,65,90,40,65)

class(marks)

'numeric'

Laten we de lengte van de vector controleren; die zou het aantal elementen erin moeten teruggeven.

length(marks)

5

Laten we nu proberen een specifiek element op zijn index te benaderen.

marks[4]

40

marks[5]

65

marks[6] #returns NA since there is no sixth element in the vector

<NA>

• Slicing: Net als in Python kun je het concept van slicing ook in R toepassen.

  Laten we met slicing de elementen van de tweede tot en met de vijfde benaderen.

marks[2:5]

1. 65
2. 90
3. 40
4. 65

Laten we nu een character-vector maken; dat lijkt op het maken van een numerieke vector.

char_vector <- c("a", "b", "c")
print(char_vector)

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

class(char_vector)

'character'

length(char_vector)

3

char_vector[1:3]

1. 'a'
2. 'b'
3. 'c'

Als we een vector maken die zowel numerieke als character-waarden bevat, worden de numerieke waarden geconverteerd naar het gegevenstype character.

char_num_vec <- c(1,2, "a")

char_num_vec

1. '1'
2. '2'
3. 'a'

class(char_num_vec)

'character'

Laten we een vector met 1024 numerieke waarden maken met behulp van het slicing-concept.

vec <- c(1:1024)

Probeer nu het middelste en het laatste element te benaderen. Daarvoor gebruik je de functie length.

vec[length(vec)]

1024

vec[length(vec)/2]

512

• Hoe maak je een vector van oneven getallen?

Om een vector van oneven getallen te maken, kun je de functie seq gebruiken, die drie parameters aanneemt: begin, einde en stapgrootte.

seq(1,10, by = 2)

1. 1
2. 3
3. 5
4. 7
5. 9

Matrix

Net als een vector wordt een matrix gebruikt om informatie van hetzelfde gegevenstype op te slaan. In tegenstelling tot vectoren kunnen matrices echter tweedimensionale informatie bevatten.

De syntax om een matrix te definiëren is:

M <- matrix(vector, nrow=r, ncol=c, byrow=FALSE, dimnames=list(char_vector_rownames, char_vector_colnames))

byrow=TRUE geeft aan dat de matrix per rij moet worden gevuld. byrow=FALSE geeft aan dat de matrix per kolom moet worden gevuld (de standaard).

Laten we snel een matrix M definiëren met vorm $2\times3$.

M = matrix( c('AI','ML','DL','Tensorflow','Pytorch','Keras'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

     [,1]         [,2]      [,3]   
[1,] "AI"         "ML"      "DL"   
[2,] "Tensorflow" "Pytorch" "Keras"

Laten we het slicing-concept gebruiken en elementen uit een rij en kolom ophalen.

M[1:2,1:2] #the first dimension selects both rows while the second dimension will select
#elements from 1st and 2nd column

DataFrame

In tegenstelling tot een matrix zijn dataframes een algemenere vorm van een matrix. Ze bevatten gegevens in tabelvorm. De gegevens in het dataframe kunnen over verschillende kolommen zijn verdeeld met verschillende gegevenstypen. De eerste kolom kan een character zijn, terwijl de tweede kolom een integer kan zijn en de derde kolom logical.

De variabelen of features staan kolomsgewijs, ook wel een header genoemd, terwijl de observaties in de rijen staan, met als eerste element de naam van de rij, gevolgd door de daadwerkelijke gegevens, ook wel data rows genoemd.

Een DataFrame kan worden gemaakt met de functie data.frame().

Dataframes worden veel gebruikt bij het inlezen van kommagescheiden bestanden (CSV) en tekstbestanden. Het gebruik is niet beperkt tot het inlezen van data; je kunt ze ook gebruiken voor machine learning-problemen, vooral bij numerieke data. Dataframes zijn nuttig om data te begrijpen, te wranglen, te plotten en te visualiseren.

Laten we een dummy-dataset maken en enkele dataframe-specifieke functies leren.

dataset <- data.frame(
   Person = c("Aditya", "Ayush","Akshay"),
   Age = c(26, 26, 27),
   Weight = c(81,85, 90),
   Height = c(6,5.8,6.2),
   Salary = c(50000, 80000, 100000)
)

print(dataset)

  Person Age Weight Height Salary
1 Aditya  26     81    6.0  5e+04
2  Ayush  26     85    5.8  8e+04
3 Akshay  27     90    6.2  1e+05

class(dataset)

'data.frame'

nrow(dataset) # this will give you the number of rows that are there in the dataset dataframe

3

ncol(dataset) # this will give you the number of columns that are there in the dataset dataframe

5

df1 = rbind(dataset, dataset) # a row bind which will append the arguments in row fashion.

df1

df2 = cbind(dataset, dataset) # a column bind which will append the arguments in column fashion.

df2

Laten we de functie head bekijken, die erg handig is als je miljoenen records hebt en je alleen de eerste paar rijen van je data wilt zien. Op dezelfde manier geeft de functie tail de laatste paar rijen van je data weer.

head(df1,3) # here only three rows will be printed

str(dataset) #this returns the individual class or data type information for each column.

'data.frame':    3 obs. of  5 variables:
 $ Person: Factor w/ 3 levels "Aditya","Akshay",..: 1 3 2
 $ Age   : num  26 26 27
 $ Weight: num  81 85 90
 $ Height: num  6 5.8 6.2
 $ Salary: num  5e+04 8e+04 1e+05

Nu bekijken we de functie summary(), die handig is als je de statistieken van je dataset wilt begrijpen. Zoals hieronder getoond, verdeelt deze je gegevens in drie kwartielen, op basis waarvan je een idee krijgt van de verdeling van je data. Ook laat het zien of er missende waarden in je dataset zitten.

summary(dataset)

    Person       Age            Weight          Height        Salary      
 Aditya:1   Min.   :26.00   Min.   :81.00   Min.   :5.8   Min.   : 50000  
 Akshay:1   1st Qu.:26.00   1st Qu.:83.00   1st Qu.:5.9   1st Qu.: 65000  
 Ayush :1   Median :26.00   Median :85.00   Median :6.0   Median : 80000  
            Mean   :26.33   Mean   :85.33   Mean   :6.0   Mean   : 76667  
            3rd Qu.:26.50   3rd Qu.:87.50   3rd Qu.:6.1   3rd Qu.: 90000  
            Max.   :27.00   Max.   :90.00   Max.   :6.2   Max.   :100000  

Conclusie

Gefeliciteerd met het afronden van de tutorial.

Deze tutorial was een goed startpunt voor beginners die nieuwsgierig zijn naar de programmeertaal R. Als goede oefening kun je gerust meer helperfuncties bekijken die bij elk gegevenstype horen.

Er blijft veel informatie over R onbesproken, zoals Conditionals en Control Flow in R, Utilities in R en het meest spannende: Machine Learning met R. Dit komt aan bod in toekomstige tutorials, dus blijf op de hoogte!

Stel gerust vragen over deze tutorial in de reacties hieronder.

Wil je meer leren over R? Volg dan DataCamp's cursus Intermediate R en bekijk de tutorial Introduction to Data frames in R.