2.1 Att skriva kod i R

R är ett tolkat språk (eng interpreted language), vilket innebär att du måste ange kommandon för att utföra operationer (exempelvis beräkningar). Att programmera eller koda innebär att man skriver kommandon. På din begäran kommer R försöka utföra dessa kommandon. Detta kapitel ger en översikt över R-språket. Du lär dig hur grundläggande operationer utförs och tolkas.

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 köra R-kommandon) för att rikta 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 utgången returnerar R värdet 10, som sitt första resultat (indikerat med [1]). Vi sparade ingen information i det här exemplet, men vi kunde ha det. Tänk på nästa exempel, där vi först sparar numret 1 till ett objekt som heter mynumber och numret 9 till ett objekt som heter your_number. Vi använder den speciella R-operatorn <- för att tilldela siffrorna till objekten. <-operatören uttalas gets. Sedan lägger vi till dessa siffror 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 din_nummer 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 upp siffrorna istället:

my_number/your_number

[1] 0.1111111

Du kan faktiskt använda R som en miniräknare, som det här exemplet visar:

(100-(10*9))/2

[1] 5

Låt oss prova ett nytt exempel där vi säger R att skriva ut alla siffror mellan 1 och 100. Detta kommer att göras med hjälp av kolon (:) operatör, som säger 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
 [19]  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36
 [37]  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53  54
 [55]  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71  72
 [73]  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89  90
 [91]  91  92  93  94  95  96  97  98  99 100

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

2.2 Ofullständiga kommandon

Om du skriver ett ofullständigt kommando och trycker på Enter, kommer R att visa +-prompten på nästa rad, vilket betyder att R väntar på att du ska skriva resten av ditt kommando. Antingen avsluta kommandot eller tryck 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 tillhandahålla vad vi vill subtrahera från nummer 5. Vi kommer att ge numret 1 och tryck på Enter, vilket ger numret 4.

> 5 -
+
+ 1
[1] 4

2.3 Avbryta kommandon

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 R lång tid att avbryta kommandot.

2.4 Error-meddelanden

Kod som inte fungerar, oavsett 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 föregås med “Fel i…” 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å det faktum att vi felstavade library som library. Rätt kommando är:

library(tidyverse)

2.5 Att kommentera kod

Det är viktigt att skriva kommentarer fortlöpande i koden. Nästan alla datorspråk låter dig skriva kommentarer med hjälp av speciella symboler. R använder hashtag-symbolen (#) för kommentarer. Allt som följer en hashtag på en rad ignoreras av R. Kommentarer tolkas alltså bara av människor, aldrig av datorn.

2.6 Varningar och meddelanden

• Varningar: Ibland kan din kod returnera en varning, vilket innebär att kommandona utfördes men något behöver din uppmärksamhet. Till exempel, om du skapar ett diagram och vissa värden saknas, då kan du få en varning som säger: Varning: Tog bort 13 rader som innehåller saknade värden. Därför informerar denna varning helt enkelt dig om att handlingen kanske inte representerar alla observationer i dina data.
• Meddelanden: Meddelanden innehåller godartad information. Till exempel, när du laddar ett paket kan du få ett meddelande som innehåller information om paketuppdateringar, version etc.

2.7 Vektorer (Vectors)

En vektor är en sekvens av dataelement av samma grundtyp. Vektorer är viktiga i R och det finns inget komplicerat med dem. Här är en vektor som innehåller siffrorna 1, 2, 3, 4 och 5. Vi skapar vektorn med funktionen c (), där c är kort för att kombinera.

c(1, 2, 3, 4, 5) 

[1] 1 2 3 4 5

Vi kunde ha sparat lite utrymme genom att använda kolonoperatören (:):

c(1:5) 

[1] 1 2 3 4 5

Och här är en vektor av karaktärsträngar.

c("David", "Maria", "Mohamed", "Singh", "Lana") 

[1] "David"   "Maria"   "Mohamed" "Singh"   "Lana"   

2.8 Objekt (Objects)

I exemplen ovan skapade vi vektorer men vi lagrade dem aldrig i vårt datorminne. För att lagra dem måste vi skapa ett R-objekt, vilket vi gör med uppdragsoperatorn <-. 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 hänvisa till lagrade data. När du använder objektnamnet i din R-kod ersätter R objektnamnet 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 my_number som ett kommando och trycker på enter.

my_number <- 100
my_number

[1] 100

2.8.1 Hur man skapar objekt i R

För att skapa ett R-objekt väljer du ett namn och använder sedan tilldelningsoperatorn <- för att skicka data till det. 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.

2.8.2 Var ser jag mina objekt i R?

Alla objekt visas i rutan Environment i RStudio, som visas i Figur 2.1. Den här rutan visar alla objekt du har skapat sedan RStudio öppnades.

2.8.3 Att namnge objekt i R

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

2.9 R är skriftlägeskänsligt (case sensitive)

R är skiftlägeskänslig, så income och Income kommer att hänvisa till olika objekt. R är faktiskt skiftlägeskänsligt hela tiden, vilket innebär att du i alla aspekter - 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 () kommer du att få ett fel.

2.10 R skriver över objekt

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 din R-miljö:

ls()

[1] "a"   "my_number"   "my_numbers"  "your_number"

2.11 Elementvis exekvering (element wise execution)

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

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

Vi kommer nu att se vad som händer när vi manipulerar detta objekt 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.

new_numbers-1

[1] 0 1 2 3 4 5

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

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

Om du använder två eller flera vektorer i en operation, R raderar vektorerna och utför en sekvens av enskilda operationer. Till exempel, när du kör new_numbers * new_numbers, R raderar de två new_numbers vektorerna 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, R kommer att upprepa den kortare vektorn tills den är så lång som den längre vektorn, och gör sedan matematiken.

a <- c(2)
b <- c(4, 4, 4, 4)
a*b

[1] 8 8 8 8

2.12 Script

Ett R-skript är helt enkelt en textfil (med filnamnstillägget .R) som innehåller alla kommandon som du vill köra. Dessa kommandon är vanligtvis i följd, vilket innebär att raderna körs en åt gången. Du kommer nästan alltid att 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 Filer> Spara som (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)

# paste() används för att sammansmälta textsträngar</em>
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 Ctrl+Retur på Windows och Cmd+Retur 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 köra om din kod när som helst och få samma resultat igen. Du kan också justera/korrigera din kod och sedan köra den igen. Tänk på situationen där du behöver köra hela analysen 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.