Ga naar hoofdinhoud

Hulpfuncties in R-tutorial

Leer over diverse handige functies voor het manipuleren van datastructuren, geneste lijsten, reguliere expressies en werken met tijden en datums in de programmeertaal R.
· 14 min lezen

Verken met AI

In deze tutorial leer je diverse functies en utilities kennen die eenvoudig en vaak gebruikt worden in de programmeertaal R. Eerst bespreken we enkele wiskundegerelateerde functies. Daarna kijk je naar functies die nauwer aansluiten bij R’s datastructuren, zoals het manipuleren van geneste lijsten, reguliere expressies, tijd en datums.

Wiskundige functies

Laten we naar de volgende codecellen kijken die verschillende wiskundige functies gebruiken.

Je definieert eerst twee vectoren, namelijk x en y, die zowel positieve als negatieve waarden bevatten.

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

Laten we deze twee vectoren x en y nemen en:

  • De absolute waarden ervan nemen,
  • Ze afronden op nul decimalen,
  • Ze elk optellen en
  • Tot slot het gemiddelde van beide nemen.
mean(c(sum(round(abs(x))),sum(round(abs(y)))))

27.5

Hoe zou het zijn als je de bovenstaande code in kleine stukjes opdeelt en elk onderdeel van dichtbij bekijkt?

  • De functie abs() neemt simpelweg de positieve of absolute waarde van de elementen van de vectoren x en y.

Als je bijvoorbeeld de functie abs() toepast op x en y, verwacht je alleen positieve waarden, zoals hieronder.

abs(x)
  1. 1.1
  2. 2.3
  3. 4.5
abs(y)
  1. 2.4
  2. 44
  3. 2.2
  • De volgende functie in het rijtje is round(). Die rondt de invoer af. Ze neemt een extra argument waarin je kunt aangeven op hoeveel decimalen je wilt afronden. Standaard rondt round() af op nul decimalen.

Als je bijvoorbeeld de functie round() toepast op de vectoren x en y, ziet de uitvoer er zo uit:

round(x)
  1. 1
  2. -2
  3. -4
round(y)
  1. 2
  2. -44
  3. -2
  • De functie sum() berekent eenvoudigweg de som van de elementen van een vector of matrix. Als je bijvoorbeeld een rijvector als argument doorgeeft, wordt de som van alle elementen als een scalair teruggegeven.

In dit geval worden de vectoren x en y doorgegeven aan de functie sum(). R berekent dus de som van de vector­elementen en geeft een scalair als uitvoer terug.

sum(abs(round(x)))

7
sum(abs(round(y)))

 48
  • Tot slot berekent de functie mean() of het gemiddelde() het rekenkundig gemiddelde. Ze neemt een reeks numerieke waarden, telt ze op en deelt door het aantal termen in de reeks.

In dit geval is de invoer voor de functie mean() een rijvector van lengte twee met de getallen 7 en 48. Het gemiddelde van deze twee waarden is dus de som gedeeld door het aantal elementen, namelijk 2.

mean(c(7,48))

27.5

Dat was nog steeds best eenvoudig. Toch?

Laten we nu doorgaan naar het volgende en meest interessante onderdeel van deze tutorial!

Functies voor datastructuren

Nu kijken we naar enkele datastructuren zoals lijsten en vectoren. Verschillende manieren waarop je op de datastructuur list kunt opereren, een list omkeren, en hoe je een lijst naar een vector en omgekeerd kunt omzetten.

De onderstaande functie is een list(), ofwel een lijst van lijsten, ook wel een geneste lijst genoemd. Ze maakt een lijst met elementen die logische waarden, numerieke waarden en strings kunnen bevatten.

In het onderstaande voorbeeld staan er drie lijsten in een lijst, namelijk log, ch en int_vec. Elk daarvan heeft een datatype of R-object van respectievelijk logisch, numeriek en string/character.

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 is simpelweg een logische operator, TRUE of FALSE
  • ch is een tekenreeks hello_datacamp
  • int_vec is een reeks numerieke waarden.

Aangezien log en ch vrij rechttoe rechtaan zijn, kijken we wat beter naar 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

Laten we de bovenstaande expressie stap voor stap begrijpen.

De functie seq produceert een reeks getallen in aflopende volgorde van 8 tot 2.

De syntaxis van de functie seq() is: seq(x1,x2, by = y)

De eerste twee argumenten x1 en x2 geven R het bereik van de reeks, oftewel waar de reeks start en eindigt. Het argument by specificeert de grootte van de stap (verhoging of verlaging) bij elk interval.

Bijvoorbeeld, de onderstaande regel code genereert een reeks van 100 tot 200 met een stapgrootte van 20.

seq(100,200, by = 20)
  1. 100
  2. 120
  3. 140
  4. 160
  5. 180
  6. 200

In ons voorbeeld geeft de functie seq een reeks van 8 tot en met 2 met een stap van -2, wat een vector van lengte 4 oplevert.

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

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

Laten we nu de functie rep begrijpen.

Die kan het invoerargument, meestal een vector of lijst, herhalen via het argument times, dat een geheel getal neemt en de invoer zo vaak herhaalt. De functie rep neemt twee argumenten: de invoer en het aantal keren dat je die invoer wilt herhalen of repliceren.

Toegepast op ons voorbeeld, een vector van lengte 4, levert dit een uitvoervector van lengte 8 op.

b = rep(a, times = 2)

Als je elk element van de vector of lijst afzonderlijk wilt herhalen in plaats van de volledige vector, is er een alternatief voor times, namelijk het argument each.

Het duidelijke verschil tussen times en each is dat het patroon waarin elk element voorkomt niet hetzelfde is.

rep(a, each = 2)
  1. 8
  2. 8
  3. 6
  4. 6
  5. 4
  6. 4
  7. 2
  8. 2

Last but not least: de functie sort(). Die is vanzelfsprekend en generiek, en wordt gebruikt om veel datastructuren zoals een vector of lijst te sorteren. Ze is niet beperkt tot numerieke waarden, maar kan ook op logische waarden en tekens worden gebruikt. Standaard sorteert ze in oplopende volgorde.

Laten we de uitvoer van de functie rep doorgeven aan de functie sort om de uiteindelijke uitvoer te krijgen.

sort(b)
  1. 2
  2. 2
  3. 4
  4. 4
  5. 6
  6. 6
  7. 8
  8. 8

Top! Je hebt de lange expressie int_vec binnen de lijst list_define op een heel eenvoudige manier ontrafeld.

Laten we verder de inhoud van de lijst list_define bekijken met de functie str(). De functie str() in R laat je de structuur van R-objecten zien.

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

Laten we een paar leuke R-expressies bekijken:

  • De functie is kan worden gebruikt om het type van je datastructuur te controleren. Ze geeft een logische waarde terug en is handig bij voorwaardelijke statements.
is.list(list_define) #geeft TRUE terug als het doorgegeven argument een lijst is.

TRUE

Terwijl ze FALSE teruggeeft als een vector, die geen lijst is, wordt doorgegeven, zoals hieronder.

is.list(c(1,2,3)) #geeft FALSE terug omdat je een vector hebt doorgegeven.

FALSE
  • Een vector naar een lijst omzetten is erg simpel in R. Gebruik de functie as gevolgd door .list(), en geef de vector als argument door. Meer is er niet nodig.
vec_to_list <- as.list(c(1,2,3))

is.list(vec_to_list) #controleer met is.list()

TRUE
  • Andersom kan een lijst worden uitgerold naar een vector met de functie unlist. R doet deze conversie door simpelweg de hele lijststructuur af te vlakken en uiteindelijk één vector uit te geven.
list_to_vec <- unlist(vec_to_list)

list_to_vec
  1. 1
  2. 2
  3. 3

Net als is.list() kun je is.vector() gebruiken om te controleren of het gegeven argument een vector is of niet.

is.vector(list_to_vec)

TRUE

Laten we de grote lijst list_define omzetten naar een vector. Let op: een vector kan slechts één datatype of R-object bevatten. Zowel de logische als numerieke waarden worden daarom omgezet naar strings.

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'

Voordat we naar het volgende onderwerp gaan, kijken we naar de functies append() en rev().

  • Zoals de naam al suggereert, kun je met append() twee of meer vectoren of lijsten toevoegen aan een bestaande of nieuwe vector of lijst.

Laten we de functie append() uitproberen op de lijst list_define. Je ziet dat de lijst nu uit 6 elementen bestaat in plaats van 3, omdat je dezelfde lijst aan zichzelf hebt toegevoegd.

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
  • Tot slot, laten we de volgorde van de lijst list_define omkeren met de functie 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

Reguliere expressies

Veel mensen vinden reguliere expressies een complex onderwerp om te leren. Toch is het essentieel, niet alleen in R maar in verschillende programmeertalen zoals Python. Veel talen, waaronder R, bieden ingebouwde ondersteuning voor reguliere expressies.

Reguliere expressies kunnen in talloze toepassingen worden gebruikt en zijn vooral handig bij het voorbewerken van tekstdata. Ze worden gebruikt in diverse NLP-problemen (Natural Language Processing).

Ze worden ook gebruikt in zoekmachines en teksteditors.

Reguliere expressies, ook wel regex of regexp of rationele operatoren genoemd, zijn een reeks tekens die een zoekpatroon definiëren. Over het algemeen worden deze zoekpatronen gebruikt door verschillende algoritmen voor tekenreekszoeken om een patroon te vinden, te zoeken en te vervangen, of een overeenkomstig patroon te filteren.

Laten we dit onderwerp starten met de functies grep() en grepl().

Om het simpel te houden, definiëren we een rijvector animals_regex van lengte 5 waarop je regex-patronen gaat toepassen.

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

Eerst bekijken we de functie grepl(). De functie grepl() geeft een logische uitvoer: als de string overeenkomt met het patroon, dan geeft ze TRUE terug, anders FALSE.

Hieronder staat een eenvoudige en intuïtieve syntaxis van de functie grepl() waarbij het eerste argument het patroon is dat je wilt matchen en het tweede het tekenreeks‑invoer is waarin je het patroon wilt zoeken of filteren. De rest van de argumenten kun je nu negeren. grepl(pattern, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE) Laten we met behulp van grepl() uitvinden welke van de vijf dieren een c bevatten.

In dit geval zoek je naar dieren die een c bevatten, wat direct betekent dat het patroon hier gewoon c is.

grepl(pattern = 'c', x = animals_regex)
  1. TRUE
  2. FALSE
  3. TRUE
  4. FALSE
  5. TRUE

Uit de bovenstaande uitvoer zie je dat, omdat er een c zit in cat, cheetah en mice, TRUE wordt teruggegeven voor die indexen in de vector animals_regex, terwijl FALSE werd teruggegeven voor de elementen die niet overeenkwamen met het patroon c.

Laten we nu de elementen vinden die beginnen met c en niet alleen een c ergens in de naam hebben.

Om dit te bereiken, zet je een dakje ^ aan het begin van het patroon dat je wilt vinden.

grepl(pattern = '^c', x = animals_regex) #alleen cat en cheetah beginnen met `c`.
  1. TRUE
  2. FALSE
  3. TRUE
  4. FALSE
  5. FALSE

Zoals je ziet, beginnen alleen cat en cheetah met een c, dus alleen die posities zijn TRUE.

Vergelijkbaar met het ^‑teken kan het $-teken aan het einde van het patroon worden gebruikt om elementen te matchen die eindigen op het opgegeven patroon. Om een dier te vinden dat eindigt op een n, gebruik je simpelweg n gevolgd door het $-teken.

grepl(pattern = 'n$', x = animals_regex) #alleen lion eindigt op een `n`.
  1. FALSE
  2. FALSE
  3. FALSE
  4. TRUE
  5. FALSE

Let op: Typ ?regex in een Jupyter‑notebookcel om meer te leren over reguliere expressies; de documentatie opent dan. Wil je meer leren, bekijk dan deze bron, waarmee je je zoekpatronen kunt ontwerpen en testen op je invoerstrings.

  • Net als de functie grepl() is er grep(), die in plaats van een logische uitvoer de index van de vector/matrix teruggeeft die overeenkomt met het gegeven patroon.

De syntaxis van grep() is exact hetzelfde als die van grepl() en luidt: grep(pattern, x, ignore.case = FALSE, perl = FALSE, value = FALSE, fixed = FALSE, useBytes = FALSE, invert = FALSE) Laten we hetzelfde voorbeeld als boven nemen, maar nu grep() toepassen!

grep(pattern = 'c', x = animals_regex)
  1. 1
  2. 3
  3. 5

Zoals je zou verwachten, geeft de uitvoer de index terug van de elementen cat, cheetah en mice, en niet TRUE/FALSE. En dat is het zo’n beetje!

Laten we de functie which gebruiken om grep() en grepl() te vergelijken. De functie which() geeft simpelweg de indexen van de vector terug waarvoor een logisch object TRUE is.

Als je de punten nu verbindt, begrijp je dat omdat de functie grepl() een logisch object kan teruggeven, deze eenvoudig kan worden doorgegeven aan de functie which(), die de uitvoer dan omzet naar wat je van grep() zou verwachten.

which(grepl(pattern = 'c', x = animals_regex))
  1. 1
  2. 3
  3. 5

Net als grepl() kan de functie grep() ook overweg met verschillende soorten regex‑patronen.

Als je de functie grep() toepast om de elementen in de vector animals_regex te vinden die eindigen op n, verwacht je de uitvoer 4, omdat alleen lion eindigt op n, zoals hieronder.

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

4

Goed gedaan!

Je hebt de basis van reguliere expressies geleerd, zoals het filteren van elementen uit een vector die overeenkomen met een gegeven patroon. Maar R is niet beperkt tot alleen patroonmatching. Er zijn verschillende functies, waaronder sub().

De functie sub() vervangt in plaats van te filteren de overeenkomende patronen door andere strings. Laten we dit beter begrijpen!

  • De functie sub() neemt primair drie invoerargumenten:
    • pattern dat je wilt matchen of de reguliere expressie,
    • replacement de waarde die op de overeenkomende positie in de vector komt en
    • x de invoervector waarop je de regex toepast.

De syntaxis is: sub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE,fixed = FALSE, useBytes = FALSE) Ook nu nemen we hetzelfde voorbeeld als boven om de functionaliteit te begrijpen!

sub(pattern = 'c', replacement = 'a', x = animals_regex)
  1. 'aat'
  2. 'dog'
  3. 'aheetah'
  4. 'lion'
  5. 'miae'

Uit de uitvoer zie je dat de string cat wordt vervangen door aat, cheetah door aheetah en mice door miae. Voor deze elementen werd het patroon succesvol gematcht.

Let ook op dat sub() alleen naar de eerste match in de string zoekt. Dit betekent dat als er twee c’s in een string staan, alleen het eerste voorkomen van c wordt vervangen door a, terwijl het tweede ongewijzigd blijft.

Wil je elke match van een patroon in een tekenreeks vervangen, gebruik dan beter de functie gsub(), die buiten het bereik van deze tutorial valt!

Voordat we naar het volgende onderwerp gaan, proberen we nog een interessante expressie.

Deze keer gebruik je de operator | (of), die probeert een van de gedefinieerde patronen te matchen en, als dat lukt, dit vervangt door -. Onthoud: omdat je de functie gsub() gebruikt, wordt elk voorkomen van het patroon in een string vervangen.

gsub(pattern = 'c|d|l', replacement = '-', x = animals_regex) #dieren met `c`,`d`,`l` worden vervangen door `-`.
  1. '-at'
  2. '-og'
  3. '-heetah'
  4. '-ion'
  5. 'mi-e'

Laten we naar het laatste onderwerp van vandaag gaan: Tijd en datums!

Tijd en datums

Tijd- en datuminformatie kan in allerlei scenario’s nuttig zijn. Stel dat je aan een computer vision‑probleem werkt en de FPS (frames per seconde) wilt bepalen waarmee je algoritme draait. In zo’n usecase kun je het tijdobject gebruiken om de verwerkingssnelheid van je computer vision‑algoritme te meten. Voor specifieke problemen zoals tijdreeksvoorspelling en seizoensanalyses kun je R’s potentieel volop benutten.

Om te beginnen printen we snel de datum van vandaag in R met het eenvoudige commando Sys.Date(). Sys verwijst hier naar het systeem, wat betekent dat het de systeemdatum teruggeeft.

Sys.Date()

Simpel, toch?

Tijd en datums in R behoren tot het object Date, ofwel het datatype is Date. Dat kun je verifiëren met de functie class die je leerde in de tutorial Data Types in R.

Vergelijkbaar met Date is er time(), die de huidige systeemtijd teruggeeft; in feite geeft die zowel tijd als datum terug.

Sys.time()

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

Datumobjecten maken

Je hebt geleerd hoe je de huidige datum en tijd krijgt. Laten we nu bekijken hoe je datums voor andere dagen kunt maken door simpelweg een string als argument door te geven.

Om een datumobject te maken voor 10 mei 1993, gebruik je de volgende syntaxis:

date_may <- as.Date('1993-05-10') #zet tekenreeks om naar een datumobject

date_may


class(date_may)

'Date'

Belangrijk om te weten: de functie Date in R verwacht standaard dat je de datum invoert in het formaat YYYY-MM-DD. Als je jaar met maand of dag verwisselt, resulteert dat in een fout. Laten we dat proberen!

date_may <- as.Date('05-1993-10') #R volgt standaard het ISO-datumformaat

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

Het goede nieuws is dat je het formaat expliciet kunt wijzigen door het argument format door te geven en het naar wens aan te passen.

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

De functie as.Date() accepteert verschillende datumformaten, maar converteert ze uiteindelijk terug naar het ISO-datumformaat. Dat zie je door de variabele date_may te printen.

date_may


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

date_may

Rekenen met datums

Zou het niet mooi zijn als je wiskundige bewerkingen zoals optellen en aftrekken kunt toepassen op datumobjecten in R?

Tel 1 op bij de variabele date_may, en je ziet dat er één dag later wordt weergegeven.

date_may + 1

Mooi: zoals je ziet, veranderde het optellen van één de datum van 10 mei 1993 naar 11 mei 1993. Op dezelfde manier kun je er één van aftrekken.

Stel dat je het tijdsverschil wilt weten tussen jouw en je oudere broer/zus’ geboortedatum.

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

date_may - elder_sib

Time difference of 1511 days

Conclusie

Gefeliciteerd met het afronden van de tutorial.

Deze tutorial was een goed startpunt voor beginners die graag willen leren over diverse hulpfuncties in R. Als goede oefening kun je meer leren over reguliere expressies, aangezien die in veel toepassingen worden gebruikt en een krachtig hulpmiddel zijn bij het opschonen of voorbewerken van tekstdata.

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 onze tutorial Using Functions in R.

Onderwerpen

RData Science

Gerelateerd

Meer bekijken →