Att programmera i R

Hur man kodar i R

R är ett tolkat språk, vilket innebär att du måste ange kommandon skrivna på R-språket för att utföra operationer på dina data. Att skriva sådana kommandon kallas koda eller programmera.

Det finns en grundläggande skillnad mellan tolkade språk och programvara som erbjuder en GUI (ett gränssnitt där man kan klicka sig fram, som i exempelvis SPSS, Excel etc). Mjukvara som Excel och SPSS kan tyckas bekväma eftersom du kan använda musen för att utföra de flesta uppgifter. Men eftersom det är svårt att hålla reda på alla klick och val man gör, så blir det närmast omöjligt att reproducera resultaten. Dessutom är valmöjligheterna ytterst begränsade i alla dessa program. Genom att skriva kod, rad för rad, kan du kontinuerligt bedöma vad du har skrivit, hur det tolkas och även gå tillbaka, ändra och justera programmet. Ett tolkat språk är mer eller mindre obligatoriskt att skapa reproducerbara och korrekta rapporter och studier.

Grunderna i programmering i R

Detta kapitel ger en översikt över språket R. Du kommer att lära dig hur grundläggande operationer utförs och tolkas. Oroa dig inte om du aldrig har programmerat tidigare, du lär dig allt du behöver veta.

Dataanalys innebär att du använder datorns minne och matematiska funktioner för att lagra data, manipulera data och utföra beräkningar. Datorer är komplicerade. R är enkelt. Så du lär dig bara grunderna i hur R fungerar med din dator. I grund och botten kommer du att berätta för R (genom att utföra R-kommandon) för att styra din dator för att utföra operationer. Här är en mycket enkel operation, där vi kommer att be datorn att lägga till siffrorna 1+9.

1+9
## [1] 10

Som du ser ovan i utmatningen returnerar R värdet 10, som dess första resultat (indicated by [1]). Vi sparade inte någon information i det här exemplet, men vi kunde ha det. Tänk på nästa exempel, där vi först sparar nummer 1 till ett objekt som heter my_number och numret 9 till ett objekt som heter your_number. Vi använder den speciella R-operatören <- för att tilldela numren till objekten. Operatören  <-  uttalas ’får’. Sedan lägger vi till dessa nummer och får samma resultat som ovan:

my_number <- 1

your_number <- 9

my_number + your_number
## [1] 10

I det andra exemplet har vi sparat värdet 1 till våra datorer minne. Detta gjordes genom att tilldela 1 till ett R-objekt, som vi namngav my_number. Så my_number är ett R-objekt. Du kan komma åt objektet när som helst eftersom det sparas i datorns minne.

Vad skulle hända om du multiplicerade your_number med 10? Låt oss försöka:

10*your_number
## [1] 90

Resultatet är 90. R har sparat numret 9 i datorns minne och multiplicerar nu det numret med 10, vilket ger 90. Låt oss dela siffrorna istället:

my_number/your_number
## [1] 0.1111111

Du kan faktiskt använda R som miniräknare, vilket detta exempel visar:

(100-(10*9))/2
## [1] 5

Låt oss prova ett nytt exempel där vi säger R att skriva ut alla nummer mellan 1 och 100. Detta kommer att göras med hjälp av kolonoperatören (:), som talar om R att skapa en sekvens av heltal från 1 till 100:

1:100
##   [1]   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17
##  [18]  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34
##  [35]  35  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51
##  [52]  52  53  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68
##  [69]  69  70  71  72  73  74  75  76  77  78  79  80  81  82  83  84  85
##  [86]  86  87  88  89  90  91  92  93  94  95  96  97  98  99 100

Du kommer att märka att det första numret på varje rad är placerat inom parentes ([1][18][35][52][69][86]). Dessa siffror är bara indikatorer som talar om vilket värde linjen börjar med. Så den andra raden börjar med 18:e värdet i serien. Du kan oftast ignorera siffrorna som visas inom parentes.

Ofullständiga kommandon

Om du skriver ett ofullständigt kommando och trycker på Enter, visar R  + prompten på nästa rad, vilket innebär att R väntar på att du ska skriva resten av kommandot. Antingen avsluta kommandot eller tryck på Escape för att börja om. I exemplet nedan skriver vi 5- på första raden och trycker på Enter. R visar + prompten på nästa rad så att vi kan ge vad vi vill subtrahera från nummer 5. Vi kommer att tillhandahålla nummer 1 och tryck på Enter, vilket ger numret 4.

> 5 -
+
+ 1
[1] 4

Avbryta kommandon i R

Vissa R-kommandon kan ta lång tid att köra. Du kan avbryta ett kommando när det väl har börjat genom att trycka på ctrl + c. Observera att det också kan ta lång tid att avbryta kommandot.

Felmeddelanden

Kod som inte fungerar, av någon anledning, kommer att returnera fel. Ett fel betyder helt enkelt att R inte kan tolka kommandot. Fel måste åtgärdas genom att korrigera koden. De flesta fel beror på enkla programmeringsstavfel, men de kan säkert vara mer komplexa. Fel inleds med “Error in…” följt av en förklaring som kan, eller kanske inte, vara till hjälp för att åtgärda felet. Vi kommer nu att skriva in ett kommando med ett stavfel:

librar(tidyverse)
Error in librar(tidyverse) : could not find function "librar"

Felet beror på att vi felstavade library som librar. Det korrekta kommandot är:

library(tidyverse)

Kommentera kod i R

Det är viktigt att skriva kommentarer medan du skriver R-kod. Praktiskt taget alla datorspråk gör att du kan skriva kommentarer med hjälp av speciella symboler. R använder hashtagg-symbolen (#) för kommentarer. Det betyder att allt som följer en hashtag på en rad inte kommer att tolkas. Du bör alltid skriva kommentarer och anteckningar så att du kan påminna dig själv varför och hur du gjorde saker. R kommer aldrig att tolka dina kommentarer. Hashtaggen kallas kommentarsymbolen i R.

For the remainder of the book, I’ll use hashtags to display the output of R code. I’ll use a single hashtag to add my own comments and a double hashtag, ##, to display the results of code. I’ll avoid showing >s and [1]s unless I want you to look at them.

För resten av boken använder jag hashtags för att visa utmatningen av R-koden. Jag använder en enda hashtag för att lägga till mina egna kommentarer och en dubbel hashtag, ##, för att visa resultatet av koden. Jag ska undvika att visa > och [1] om jag inte vill att du tittar på dem.

Varningar och meddelanden

  • Varningar: Ibland kan din kod returnera en varning, vilket innebär att kommandona exekverades men något behöver din uppmärksamhet. Om du till exempel skapar ett diagram och vissa värden saknas kan du få en varning som säger:  Warning: Removed 13 rows containing missing values. Därför informerar denna varning dig helt enkelt att diagrammet kanske inte representerar alla observationer i dina data.
  • Meddelanden: Meddelanden innehåller godartad information. När du till exempel läser in ett paket kan du få ett meddelande som innehåller information om paketuppdateringar, version etc.

Vektorer

En vektor är en sekvens av dataelement av samma grundläggande typ. Vektorer är viktiga i R och det finns inget komplicerat om dem. Här är en vektor som innehåller siffrorna 1, 2, 3, 4 och 5. Vi kommer att skapa vektorn med hjälp av funktionen c(), där c är förkortning för combine.

c(1, 2, 3, 4, 5) 
## [1] 1 2 3 4 5

Vi kunde ha sparat lite utrymme genom att använda kolonoperatorn (:):

c(1:5) 
## [1] 1 2 3 4 5

Och här är en vektor av teckensträngar.

c("David", "Maria", "Mohamed", "Singh", "Lana") 
## [1] "David"   "Maria"   "Mohamed" "Singh"   "Lana"

Objekt

I exemplen ovan skapade vi vektorer men vi lagrade dem aldrig i våra datorer minne. För att lagra dem måste vi skapa ett R-objekt, som vi gör med hjälp av uppdragsoperatören <-. Vi kommer nu att skapa ett objekt som heter my_numbers:

my_numbers <- c(1, 2, 3, 4, 5) 

Vi har nu ett R-objekt (my_numbers) som vi kan använda och manipulera igen. Vad är ett R-objekt? Bara ett namn som du kan använda för att referera till lagrade data. När du använder objektets namn i R-koden ersätter R objektets namn med de data som lagras i objektet. Tänk på exemplet nedan, där vi lagrar numret 100 i ett objekt som heter __my_number_ och sedan skriver vi min_number som ett kommando och trycker på enter.

a <- 100
a
## [1] 100

Hur man skapar ett R-objekt

Om du vill skapa ett R-objekt väljer du ett namn och använder sedan uppdragsoperatorn <- för att skicka data till den. Denna kombination ser ut som en pil,  <-.  R kommer att göra ett objekt som innehåller allt på höger sida av <- operatören. Om du vill se vad som lagras i ett objekt skriver du helt enkelt namnet på objektet och Enter.

Var kan jag se mina objekt i R?

Alla objekt visas i rutan Environment i RStudio, som visas i figur @ref (fig:miljö). I den här rutan visas alla objekt som du har skapat sedan RStudio öppnades.

RStudio Environment visar dina R-objekt.

Namnge ett R-objekt

Du kan namnge ett objekt i R nästan vad du vill, men det finns några regler. Först kan ett namn inte börja med ett nummer. För det andra, ett namn kan inte använda vissa speciella symboler, som ^!$@+-/, eller *:

TillåtnaEj tillåtna
a1per
b$
FOO^dia
my_var5th
.day!bad
my.object?var

R är skiftlägeskänsligt (case sensitive)

R är skiftlägeskänslig, så income and Income kommer att hänvisa till olika objekt. R är faktiskt skiftlägeskänslig hela, vilket innebär att du i varje aspekt – oavsett om du hänvisar till objekt eller använder funktioner – måste respektera skiftlägeskänslighet. Om du försöker använda funktionen  survival() genom att skriva Survival() får du ett fel.

R overwrites objects

Om du skapar ett objekt och i ett senare skede skriver över information i det objektet, kommer R inte som för behörighet. Tänk på detta när du skapar och namnger objekt. Exemplet nedan visar hur vi skriver över objektet my_number:

my_number <- 100
my_number <- 999
my_number
## [1] 999

Du kan använda funktionen ls()för att skriva ut alla objekt som för närvarande är lagrade i R-miljön:

ls()
## [1] "a"           "my_number"   "my_numbers"  "your_number"

R använder ’element-wise execution’

Låt oss skapa en ny vektor som heter new_numbers:

new_numbers <- c(1, 2, 3, 4, 5, 6)

Vi får nu se vad som händer när vi manipulerar det här objektet på olika sätt.

new_numbers/2
## [1] 0.5 1.0 1.5 2.0 2.5 3.0

Som ni kan se (ovan) R har delat varje element med 2.

Nästa test:

new_numbers-1
## [1] 0 1 2 3 4 5

Som du kan se (ovan) R har subtraherat 1 från varje element.

Så, när du manipulerar en vektor eller ett objekt, utför R samma åtgärd för varje element som vektorn.

Om du använder två eller flera vektorer i en operation, radar R upp vektorerna och utför en sekvens av enskilda operationer. När du till exempel kör new_numbers * new_numbers, radar R upp de två vektorerna new_numbers och multiplicerar sedan det första elementet i vektor 1 med det första elementet i vektor 2. R multiplicerar sedan det andra elementet i vektor 1 med det andra elementet i vektor 2, och så vidare, tills varje element har multiplicerats. Resultatet blir en ny vektor med samma längd som de två första, som visas nedan:

new_numbers*new_numbers
## [1]  1  4  9 16 25 36

Om du ger R två vektorer med olika längder, kommer R att upprepa den kortare vektorn tills den är lika lång som den längre vektorn, och sedan göra matematiken.

a <- c(2)
b <- c(4, 4, 4, 4)
a*b
## [1] 8 8 8 8

R skript

Ett R-skript är helt enkelt en textfil (med tillägget .R) som innehåller alla kommandon som du vill köra. Dessa kommandon är vanligtvis på varandra följande, vilket innebär att raderna exekveras en åt gången. Du kommer nästan alltid skriva din R-kod i längre skript. För att skapa ett nytt R-skript går du till huvudmenyn i RStudio och väljer Filer Ny fil R Script. Detta öppnar en ny textfil som du sedan kan spara via Files Save as (filändelsen är .R). Här är ett exempel på ett kort R-skript:

my_numbers <- c(1, 1, 1, 1)

your_numbers <- c(2, 2, 2, 2)

our_numbers <- my_numbers+your_numbers

our_mean <- mean(our_numbers)

# The paste() function merges a character string the object containing the mean value
paste("The mean of my numbers is: ", our_mean)
## [1] "The mean of my numbers is:  3"

Du kan köra dessa rader en i taget genom att markera varje rad och trycka på knappen Run (eller tryck på Ctrl+Retur på Windows och Cmd+Return på Mac). Du kan också markera alla linjer och köra dem samtidigt när du trycker på knappen Run.

Skript gör ditt arbete reproducerbart. De gör det möjligt för dig att göra om din kod när som helst och få samma resultat igen. Du kan också justera/korrigera koden och sedan köra den igen. Tänk på platsen där du behöver köra om hela din analys genom att utesluta män från studien; detta kan göras genom att justera en rad eller två och sedan köra om skriptet igen.

5/5 (2 Reviews)