Datatyper i R med eksempel

Hva er datatypene i R?

Følgende er datatypene eller datastrukturene i R-programmering:

• Skalarer
• Vektorer (numerisk, karakter, logisk)
• matriser
• Datarammer
• lister

Den listen blander to relaterte ideer, og det å separere dem gjør resten av denne siden lettere å følge. data-type beskriver hva en enkeltverdi er – et tall, en tekstbit, en SANN eller en USANN. data struktur beskriver hvor mange verdier som holdes sammen og i hvilken form. Skalarer, vektorer, matriser, datarammer og lister er strukturer; verdiene inni dem tilhører fortsatt en av Rs grunnleggende typer.

R har ingen separat skalartype: en skalar er rett og slett en vektor med lengde én, og det er derfor så mye R-kode skrives for hele vektorer samtidig.

Grunnleggende datatyper i R

Hver verdi i R tilhører en av et lite sett med grunnleggende (atomære) typer:

• 4.5 er en desimalverdi som kalles numeriske tall.
• 4 ser ut som et helt tall, men R lagrer det fortsatt som et dobbeltall. Skriv 4L når et ekte heltall er nødvendig.
• SANN eller USANN er en boolsk verdi, kalt en logisk verdi i R.
• Verdien inni «» eller «» er tekst (en streng). Disse verdiene kalles tegn.

To ytterligere typer fullfører settet. Komplekse verdier som 3+2i inneholder en reell og en imaginær del, og råverdier inneholder byte. Begge forekommer sjelden i daglig analyse, men de er oppført i basis-R. typeof() dokumentasjon ved siden av de fire vanlige typene.

Vi kan sjekke typen til en variabel med klassefunksjonen.

Eksempel 1: Sjekk en numerisk variabel

# Declare variables of different types
# Numeric
x <- 28
class(x)

Utgang:

## [1] "numeric"

Eksempel 2: Sjekk en tegnvariabel

# String
y <- "R is Fantastic"
class(y)

Utgang:

## [1] "character"

Eksempel 3: Sjekk en logisk variabel

# Boolean
z <- TRUE
class(z)

Utgang:

## [1] "logical"

Merk at class() svarer «numerisk» for 28 selv om 28 ikke har noen desimaldel. R lagret det som en double, og bare typeof() avslører det. Den neste forskjellen som er verdt å lære er hvordan disse verdiene får navn.

Variabler i R

Variabler er en av de grunnleggende byggesteinene i R som lagrer verdier, og de er viktige for alle som jobber med datavitenskap. En variabel i R kan lagre et tall, et objekt, et statistisk resultat, en vektor, et datasett eller en modellprediksjon – i utgangspunktet alt R sender ut. Vi kan bruke den variabelen senere ved ganske enkelt å kalle navnet på variabelen.

For å deklarere en variabel i R, må vi tildele den et variabelnavn. Navnet må ikke inneholde mellomrom. Vi kan bruke _ for å koble sammen to ord.

Navn kan inneholde bokstaver, sifre, prikker og understrek, men de må starte med en bokstav eller et punktum, og reserverte ord som SANN, USANN og NULL kan ikke brukes som navn. For å legge til en verdi til variabelen, bruk <- eller =.

Her er syntaksen:

# First way to declare a variable:  use the `<-`
name_of_variable <- value
# Second way to declare a variable:  use the `=`
name_of_variable = value

På kommandolinjen kan vi skrive følgende koder for å se hva som skjer:

Eksempel 1: Tilordne en verdi og skrive den ut

# Print variable x
x <- 42
x

Utgang:

## [1] 42

Eksempel 2: Deklarer en andre variabel

y  <- 10
y

Utgang:

## [1] 10

Eksempel 3: Bruk to variabler i ett uttrykk

# We call x and y and apply a subtraction
x-y

Utgang:

## [1] 32

En variabel som inneholder flere verdier av samme type er en vektor, som er strukturen nesten alle R-funksjoner forventer.

Vektorer i R

En vektor er en endimensjonal samling der hvert element deler samme type. Vi kan lage en vektor med alle de grunnleggende R-datatypene som er lært tidligere. Den enkleste måten å bygge en vektor i R på er å bruke c()-funksjonen.

Eksempel 1: Lag en numerisk vektor

# Numerical
vec_num <- c(1, 10, 49)
vec_num

Utgang:

## [1]  1 10 49

Eksempel 2: Lag en tegnvektor

# Character 
vec_chr <- c("a", "b", "c")
vec_chr

Utgang:

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

Eksempel 3: Lag en logisk vektor

# Boolean 
vec_bool <-  c(TRUE, FALSE, TRUE)
vec_bool

Utgang:

##[1] TRUE FALSE TRUE

Hvis c() mottar en blanding av typer, feiler den ikke. Den tvinger stille hvert element opp til den mest generelle typen som er tilstede, slik at c(1, "a", TRUE) blir en tegnvektor. Vi kan også gjøre aritmetiske beregninger på vektorer i R.

Eksempel 4: Legg sammen to vektorer element for element

# Create the vectors
vect_1 <- c(1, 3, 5)
vect_2 <- c(2, 4, 6)
# Take the sum of A_vector and B_vector
sum_vect <- vect_1 + vect_2
# Print out total_vector
sum_vect

Utgang:

[1]  3  7 11

Addisjonen fungerte element for element fordi begge vektorene har samme lengde. Når lengdene er forskjellige, resirkulerer R den kortere vektoren, og gjentar dette til den matcher den lengste, og advarer bare når den lengste lengden ikke er et multiplum av den kortere.

Eksempel 5: Del de fem første elementene

I R er det mulig å dele en vektor. I noen tilfeller er vi bare interessert i de fem første elementene i en vektor. Vi kan bruke kommandoen [1:5] for å f.eks.tracverdiene 1 til 5.

# Slice the first five rows of the vector
slice_vector <- c(1,2,3,4,5,6,7,8,9,10)
slice_vector[1:5]

Utgang:

## [1] 1 2 3 4 5

Eksempel 6: Bygg et område med kolon Operator

Den korteste måten å opprette et verdiområde på er å bruke kolonoperatoren (:) mellom to tall. For eksempel, fra eksemplet ovenfor, kan vi skrive c(1:10) for å opprette en vektor med verdier fra én til ti.

# Faster way to create adjacent values
c(1:10)

Utgang:

## [1]  1  2  3  4  5  6  7  8  9 10

Fordi en vektor endrer type lydløst når den blandes, lønner det seg å vite hvordan man inspiserer og konverterer typer på forespørsel.

Slik sjekker og konverterer du datatyper i R

Tre funksjonsfamilier svarer på de tre spørsmålene som stadig vekk dukker opp: hva er dette, er dette en gitt type, og kan dette bli en annen type.

# Three different views of the same value
x <- 28
class(x)      # "numeric"  -- the class used for method dispatch
typeof(x)     # "double"   -- how R stores the value internally
mode(x)       # "numeric"  -- the older S-style mode

# Ask a yes/no question about a type
is.numeric(x)     # TRUE
is.character(x)   # FALSE

# Convert between types
as.character(x)   # "28"
as.integer("28")  # 28 stored as an integer
as.numeric("abc") # NA, with a coercion warning

To regler forklarer de fleste overraskelsene her. For det første rapporterer class() klassen som brukes for metodeforsendelse, mens typeof() rapporterer den interne lagringen, og det er derfor 28 er "numerisk" for den ene og "dobbel" for den andre. For det andre stopper ikke en konvertering som ikke kan lykkes skriptet: as.numeric("abc") returnerer NA og skriver ut en tvangsadvarsel, så stille NA-er etter en import er nesten alltid et typeproblem. Den samme logikken driver faktorer, som lagrer kategorier som heltallskoder pluss en tabell over nivåer.

Når typene er avgjort, er det operatorene som handler på dem som kommer til å gjøre det samme.

R Aritmetikk Operatorer

Vi skal først se på de grunnleggende aritmetiske operatorene i R. Følgende er de aritmetiske operatorene i R-programmering og hva de står for:

Hver av disse operatorene er vektorisert, så det samme uttrykket fungerer på en enkelt verdi eller på en hel kolonne.

Eksempel 1: Addisjon

# An addition
3 + 4

Utgang:

## [1] 7

Du kan enkelt kopiere og lime inn R-koden ovenfor i RStudio Konsoll. I denne artikkelen vises utdataene på linjer som begynner med ##. Hvis vi for eksempel skriver koden print("Guru99") konsollen skriver ut [1] "Guru99", som denne siden ville vist som ## [1] "Guru99".

## markerer en linje med utskrevet resultat, og tallet i hakeparentesen ([1]) er indeksen for den første verdien på den linjen, ikke en del av resultatet.

Setninger som begynner med # er kommentarer. Vi kan bruke # i et R-skript for å legge til et hvilket som helst notat vi ønsker, og R ignorerer det under kjøring.

Eksempel 2: Multiplikasjon

# A multiplication
3*5

Utgang:

## [1] 15

Eksempel 3: Divisjon

# A division
(5+5)/2

Utgang:

## [1] 5

Eksempel 4: Eksponentiering

# Exponentiation
2^5

Utgang:

## [1] 32

Eksempel 5: Modulo

# Modulo
28%%6

Utgang:

## [1] 4

Aritmetikk produserer tall. Den neste gruppen med operatorer produserer SANN og USANN i stedet.

R Relasjonell (Sammenligning) Operatorer

Relasjonsoperatorer sammenligner to verdier og returnerer et logisk resultat. De er operatorene som bygger betingelsene som brukes for filtrering, og de vektoriseres på nøyaktig samme måte som de aritmetiske operatorene.

a <- 10
b <- 3

a > b     # TRUE
a < b     # FALSE
a >= 10   # TRUE
a <= 3    # FALSE
a == b    # FALSE
a != b    # TRUE

# Relational operators are vectorised
scores <- c(45, 78, 90, 62)
scores >= 60   # FALSE TRUE TRUE TRUE

To vaner sparer tid her. Bruk == for sammenligning og <- for tildeling, fordi en enkel = inne i en betingelse er en vanlig nybegynnerfeil. Og unngå == på dobler: flyttallsavrunding betyr at 0.1 + 0.2 == 0.3 er USANN, så isTRUE(all.equal(0.1 + 0.2, 0.3)) er den sikre testen. Sammenligninger på sorterte datarammer følge de samme reglene.

R Logisk Operatorer

Med logiske operatorer ønsker vi å returnere verdier inne i vektoren basert på logiske betingelser. Tabellen nedenfor viser de logiske operatorene som er tilgjengelige i R.

De logiske setningene i R er pakket inn i []. Vi kan legge til så mange betingede setninger vi vil, men vi må inkludere dem i parenteser. Vi kan følge denne strukturen for å lage en betinget setning:

variable_name[(conditional_statement)]

Med variabelnavn som refererer til variabelen vi vil bruke for setningen, lager vi den logiske setningen, for eksempel variabelnavn > 0. Til slutt bruker vi hakeparenteser for å fullføre den logiske setningen. Nedenfor er et eksempel på en logisk setning.

Eksempel 1: Sammenlign alle elementene i en vektor

# Create a vector from 1 to 10
logical_vector <- c(1:10)
logical_vector>5

Utgang:

## [1]FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

I utdataene ovenfor leser R hver verdi og sammenligner den med setningen logisk_vektor>5. Hvis verdien strengt tatt er større enn fem, er betingelsen SANN, ellers USANN. R returnerer en vektor av SANN og USANN.

Eksempel 2: Behold kun elementene som samsvarer

I eksemplet nedenfor ønsker vi å f.eks.tract verdiene som bare oppfyller betingelsen 'er strengt tatt større enn fem'. For å gjøre det kan vi pakke betingelsen i hakeparenteser etterfulgt av vektoren som inneholder verdiene.

# Print value strictly above 5
logical_vector[(logical_vector>5)]

Utgang:

## [1]  6  7  8  9 10

Eksempel 3: Kombiner to betingelser

# Print 5 and 6
logical_vector <- c(1:10)
logical_vector[(logical_vector>4) & (logical_vector<7)]

Utgang:

## [1] 5 6

Eksempel 3 bruker det enkle og-tegnet & med vilje. Enkelttegnsoperatorene & og | sammenligner vektorer element for element og returnerer en vektor, som er det delmengden trenger. Dobbeltformene && og || returnerer én verdi og hører hjemme i if()- og while()-betingelsene. Siden R 4.3.0, å sende et argument som er lengre enn ett element til && eller || er en feil snarere enn en advarsel, så de to familiene er ikke lenger utskiftbare. !-operatoren negerer en betingelse, og xor() gir eksklusiv ELLER.

R-oppgave Operatorer

Tildelingsoperatorer binder en verdi til et navn. R tilbyr flere av dem enn de fleste språk, og forskjellene spiller en rolle når koden flyttes inn i funksjoner.

# Left assignment -- the idiomatic form
count <- 5

# Equals sign: works, but reserve it for function arguments
count = 5
round(3.14159, digits = 2)

# Right assignment
5 -> count

# Superassignment, used inside functions to reach an outer scope
count <<- 5

Stilguider anbefaler <- for å opprette objekter og = for å navngi argumenter i et kall, fordi de to rollene da forblir visuelt forskjellige. Bruk <<- sparsomt: det endrer et objekt utenfor den gjeldende funksjonen og gjør det vanskeligere å resonnere rundt kode. Når tildeling og typer er komfortable, er de neste trinnene importere reelle data og reshaping det med dplyr; de Oversikt over R-språket setter hele verktøykjeden i kontekst.

Spørsmål og svar