Survey Design Funktionsoversigt

1. Script eller Notebook?

I vælger selv, om I vil arbejde i scripts eller Notebook-filer, når I koder i R.

Scripts hedder filnavn.R og Notebooks hedder filnavn.Rmd, som står for R Markdown.

Forskellen på de to er, at scripts som udgangspunkt antager, at man skriver kode, imens Notebook antager, at man skriver tekst, hvis ikke man angiver noget andet.

Derfor bruger vi # i scripts til at skrive noter, imens vi bruger ‘chunks’ i Notebook til at skrive felter med kode. Chunks er angivet med {r}

# Det her er et chunk

Tastaturgenvejen til at lave chunks er Ctrl + Alt + I på Windows og Cmd + Option + I på Mac.

Det smarte ved Notebooks er, at vi kan få vist vores output under koden, imens scripts kun viser outputtet i Consolen. Derudover laver Notebooks automatisk en html.fil, så man kan dele sin kode med andre, uden at de skal åbne R. Det her er fx en html-fil fra en Notebook :)

Til gengæld er scripts mere simple og kan derfor virke mere overskuelige at bruge, især hvis man skal lave mange beregninger.

2. Hvad kan vi arbejde med i R?

2.1 Beregninger og tekst

R kan bruge matematiske tegn til at lave beregninger. Vi kan køre koden med tastaturgenvejen Ctrl + Enter på Windows eller Cmd + Enter på Mac.

5+5

[1] 10

Vi kan også bruge R til at skrive tekst:

"Jeg elsker Survey Design"

[1] "Jeg elsker Survey Design"

2.2 Logiske tegn

R kan også bruge logiske tegn til at fortælle, om noget er TRUE (sandt) eller FALSE (falsk).

< og > sammenligner tal

== undersøger, om to værdier er ens

<= betyder mindre end eller lig med

>= betyder større end eller lig med

!= betyder ikke lige med

# Er 4 fx større end 3?
4 > 3

[1] TRUE

# Og er 5 det samme som 4?
5 == 4

[1] FALSE

2.3 Gemme og bruge objekter

En vigtig forskel mellem R og en almindelig lommeregner er, at R kan gemme værdier.

Det gør vi med assignment operatoren <-, der ‘assigner’ værdier til et objekt. Tastaturgenvejen er Alt + - på Windows eller Option + -

Når man gemmer værdier, kan man bruge dem igen senere. De objekter, vi har gemt, kan vi se i vores Environment.

Vi kan fx gemme beregningen fra tidligere.

# Her beregner R `5 + 5` og gemmer resultatet `10` i objektet `my_number`
my_number <- 5+5
my_number

[1] 10

Vi kan også gemme tekst som et objekt:

my_text <- "Her kan du skrive hvad som helst!"
my_text

[1] "Her kan du skrive hvad som helst!"

Vi kan bruge gemte objekter i nye beregninger:

my_second_number <- my_number + 3
my_second_number

[1] 13

my_third_number <- my_second_number - my_number
my_third_number

[1] 3

my_number gemmer tallet 10

my_second_number gemmer tallet 13 (10 + 3)

my_third_number er derfor 13 - 10 = 3

Kort sagt: vi bruger objekter til at gemme værdier under et navn, så vi kan bruge den igen senere.

3. Funktioner, pakker og argumenter

3.1 Funktioner

Funktioner er kommandoer i R, der udfører en bestemt handling. Forskellige funktioner kan bruges til forskellige ting.

# Vi kan fx bruge funktionen `sqrt()` til at finde kvadratroden af en værdi:
sqrt(5+5)

[1] 3.162278

Funktioner skrives altid med parenteser funktion(). Det, vi skriver inde i parentesen, er inputtet til funktionen.

3.2 Argumenter

Mange funktioner kan tilpasses ved hjælp af argumenter.

Argumenter fortæller funktionen, hvordan den skal udføre sin opgave og hvad den skal arbejde med.

Vi kan fx bruge pakken cowsay til at få forskellige dyr til at sige noget med funktionen say:

say(what = "Jeg elsker at kode i R",
by = "cat")

Her er what og by argumenter:

what bestemmer, hvad der skal siges.

by bestemmer, hvem der skal sige det.

Vi kan også bruge objekter, vi allerede har gemt, som input i et argument, fx objektet my_text fra tidligere:

say(what = my_text,
by = "fish")

help() og ?

Vi kan undersøge en funktion med ?, hvis vi er i tvivl om, hvilke argumenter funktionen har eller hvad de forskellige argumenter gør.

Fx kan vi skrive ?say og få informationer om, hvad vi kan skrive af input i funktionen.

3.3 Pakker

R indeholder mange funktioner i sig selv, men man kan få adgang til flere funktioner ved at installere og loade pakker.

En pakke er en samling af funktioner og andet indhold, som andre R-brugere har lavet.

Hvis vi skal bruge pakken cowsay, skal vi først installere den med funktionen install.packages():

install.packages("cowsay")

Når pakken er installeret, skal den indlæses med funktionen library(), før vi kan bruge dens funktioner:

library(cowsay)

Vi behøver kun at installere pakker én gang, men vi skal bruge library() til at indlæse dem hver gang, vi starter en ny R-session.

3.4 Pacman

Vi kan bruge pakken pacman til at installere og indlæse pakker på samme tid med funktionen p_load. Det kræver, at vi først har installeret pacman.

p_load svarer altså til at køre install_packages() og library() i én kommando.

pacman::p_load("cowsay")

3.5 Mapper og filstier

Når vi arbejder med data i R, skal vi ofte fortælle R, hvor en fil ligger. Det gør vi med filstier (file pahts). En filsti fortæller R, hvor den skal lede efter en bestemt fil eller mappe.

dir()

Funktionen dir() kan bruges til at se indholdet af den mappe, vi arbejder fra.

# Fx kan vi bruge dir() til at se, hvad der ligger i den mappe, vi befinder os i:
dir("UV1")

[1] "Exercise 1"                  "Exercise 2"                  "R notebook eksempel.nb.html" "R notebook eksempel.Rmd"     "R script eksempel.R"        

# Eller i en anden vilkårlig mappe, vi gerne vil undersøge:
dir("UV1/Exercise 1")

[1] "week_1_intro_solutions.R" "week_1_intro.R"          

getwd()

Funktionen getwd() kan bruges til at se, hvilken mappe vi arbejder fra. Det er her, R starter, når vi bruger relative filstier.

En relativ filsti beskriver, hvor en fil eller mappe ligge i forhold til den mappe, R arbejder ud fra.

Hvis vores working directory er hunt_01_Trash_Metal, og der i den mappe ligger undermappen Overkill, hvori filen Elimination.csv ligger, vil den relative filsti til Elimination.csv være:

"Overkill/Elimination.csv"

../ og ../../

Når vi arbejder med relative filstier, kan vi bruge .. til at vise indholdet af en mappe, der ligger et led ude i vores sti. Dvs. vi beder R om at gå ud af den nuværende mappe og en mappe tilbage.

Hvis vi befinder os i mappen Overkill, der ligger i hunt_01_Trash_Metal, kan vi vise indholdet af hunt_01_Trash_Metal ved at skrive:

dir("../")

Hvis vi vil gå ud af to mapper, kan vi skrive dir("../../"). Så beder vi R om at gå ud af den nuværende mappe og derefter ud af den næste - altså to mapper tilbage i stien.

3.6 Opsummering

dir() viser indholdet af en mappe

dir("../") viser, hvad der ligger i mappen uden for vores projektmappe

dir("../../") viser, hvad der ligger to mapper ude

getwd() viser, hvor vores relative filsti starter (dvs. vores nuværende working directory)

help() og ? åbner dokumentationen for en funktion

install.packages installerer en pakke

library() indlæser en installeret pakke

4. Vektorer

4.1 Hvad er en vektor?

En vektor er et objekt, der indeholder flere værdier i en bestemt rækkefølge. Det kan være tal, tekst eller logiske værdier. Dvs. vektorer er en måde at gemme lister af værdier i R. Når vi arbejder med variable i et datasæt, er en variabel det samme som en vektor.

Vi laver vektorer med combine-funktionen c():

# Vektorer kan indeholde tal
my_vector <- c(1, 29, 13, 2)
my_vector

[1]  1 29 13  2

# og tekst
my_text_vector <- c("Apple", "Banana", "Pear")
my_text_vector

[1] "Apple"  "Banana" "Pear"  

Hver værdi i en vektor har en bestemt position. Dvs. rækkefølgen af værdier i en vektor altid er den samme - nr. 1, 2, 3 osv…

Vi kan udvælge bestemte værdier fra en vektor med [] og : til at vælge et interval af værdier i vektoren:

my_vector[1] # giver os den første værdi i rækken

[1] 1

my_vector[2] # giver os den anden værdi i rækken

[1] 29

my_vector[1:3] # giver os første til tredje værdi i vektoren

[1]  1 29 13

4.2 Beregninger med vektorer

En af fordelene ved vektorer er, at vi kan lave beregninger på hele vektoren, dvs. alle værdier, på én gang.

# Fx kan vi lægge 2 til hver værdi i vektoren
my_vector + 2

[1]  3 31 15  4

Vi kan også bruge funktioner på hele vektoren, fx:

sum(my_vector) # summen af værdierne

[1] 45

mean(my_vector) # gennemsnittet af værdierne

[1] 11.25

min(my_vector) # den mindste værdi i vektoren

[1] 1

max(my_vector) # den største værdi

[1] 29

range(my_vector) # den største og mindste værdi

[1]  1 29

Det kan være brugbart, hvis vi har mange værdier i en vektor - fx et surveyspørgsmål med mange svar.

5. Dataframes

Når vi skal indlæse data, kan vi bruge forskellige funktioner afhængigt af, hvilken type fil vores datasæt er. Fx kan read_csv() bruges til at indlæse .csv-filer, imens read_excel() lader os indlæse en Excel-fil.

# Vi bruger assignment operatoren `<-` til at gemme det importerede datasæt i et objekt
my_data <- read.csv("navn_på_datasæt.csv")

Når vi arbejder med tabulære data (data frames), er hver kolonne en vektor. Vi kan bruge $ til at udvælge en bestemt kolonne i et datasættet.

Hvis vi har dataframen 'my_data' og vil vælge vektoren V1, ser det sådan her ud:

my_data$V1

Udover kolonner består dataframes også af rækker. Vi kan bruge [] til at udvælge bestemte rækker og kolonner, ligesom når vi arbejder med vektorer:

my_data[4,3] # R viser række 4, kolonne 3 i vores dataframe
my_data[4, ] # R viser hele række 4 i vores dataframe
my_data[ ,3] # R viser hele kolonne 3 i vores dataframe
my_data[, "variabel_navn"] # R viser hele kolonnen for en given variabel

Husk, at rækkefølgen altid er [række, kolonne].

5.1 Betingelser

Vi kan også udvælge bestemte værdier eller rækker i en vektor eller dataframe med logiske betingelser.

Koden vil kun give os de værdier i vektoren, hvor betingelsen er TRUE.

# Koden vil fx kun give os de værdier i vektoren, hvor betingelsen er `TRUE`. Dvs. at R her kun beholder de værdier i vekoren, der er mindre end 25:
my_vector[my_vector < 25]

[1]  1 13  2

Vi kan gøre det samme på dataframes.

# Her beholder R kun de værdier i dataframen, der er mindre end 70:
my_data[my_data$variabel_navn < 70, ]

6. tidyverse

R er et open-source program, og vi bruger derfor alle mulige pakker lavet af andre brugere, når vi koder.

tidyverse er en samling af pakker, der deler “kodefilosofi”, som gør det lettere at bruge dem sammen. Pakkerne gør det mere overskueligt at arbejde data.

Pipes %>%

Når man skriver kode i R, er det meget almindeligt at bruge babushka-struktur med parenteser i parenteser, hvilket hurtigt kan blive uoverskueligt. Det kalder man ‘nesting’.

# Eksempel på 'nested' kode i babushka-struktur med parenteser i parenteser:
sqrt(abs(sum(c(-1,-2,-3))))

[1] 2.44949

Pipes (%>%) giver os mulighed for at skrive kode mere effektivt ved at sætte flere trin af kode sammen i en letlæselig rækkefølge. Helt kort kan hver pipe forstås som et “and then…” eller “og så gør vi sådan her… og så gør vi sådan her…”.

Pipes tager altså et objekt eller et output på venstre side og “piper” det videre som et argument til en funktion på højre side af pipen.

# Samme kode med pipe-funktionen:
c(-1, -2, -3) %>% sum() %>% abs() %>% sqrt()

[1] 2.44949

Tastaturgenvejen til at lave en %>% er Ctrl + Shift + M på Windows og Cmd + Shift + M på Mac.

# Man kan også lave linjeskift for at gøre koden endnu mere letlæselig:
c(-1,-2,-3) %>%
sum() %>%
abs() %>%
sqrt()

[1] 2.44949

filter()

Funktionen filter() fra tidyverse gør det muligt at udvælge rækker i et datasæt, der opfylder en bestemt betingelse. Vi kan altså bruge filter() til kun at se observationer, der er relevante for os.

# Her beholder R kun de rækker, hvor værdierne af `variabel_navn` er større end 70:
my_data %>%
filter(variabel_navn > 70)

pull()

Funktionen pull() henter en bestemt kolonne ud af et datasæt og giver os en vektor med værdierne fra kolonnen.

# Her henter R alle værdierne fra kolonnen `variabel_navn`.
my_data %>%
pull(variabel_navn)

head()

Funktionen head() bruges til hurtigt at få et overblik over et datasæt ved at vise de første rækker. Det er især nyttigt, når man lige har importeret et datasæt og vil se, hvordan data ser ud.

my_data %>%
head()

summarize()

Funktionen summarize() bruges til at lave beregninger, der opsummerer data. Det kan fx være et gennemsnit, minimum eller maksimum af værdierne i vores datasæt.

my_data %>%
summarize()