Datatyper i R med exempel

Vilka är datatyperna i R?

Följande är datatyperna eller datastrukturerna i R-programmering:

• Skalärer
• Vektorer (numeriska, tecken, logiska)
• matriser
• Dataramar
• listor

Den listan blandar två relaterade idéer, och att separera dem gör resten av sidan lättare att följa. data typ beskriver vad ett enskilt värde är – ett tal, en textbit, ett SANT eller ett FALSKT. datastruktur beskriver hur många värden som hålls samman och i vilken form. Skalärer, vektorer, matriser, dataramar och listor är strukturer; värdena inuti dem tillhör fortfarande en av R:s grundläggande typer.

R har ingen separat skalärtyp: en skalär är helt enkelt en vektor med längden ett, vilket är anledningen till att så mycket R-kod skrivs för hela vektorer samtidigt.

Grundläggande datatyper i R

Varje värde i R tillhör en av en liten uppsättning grundläggande (atomära) typer:

• 4.5 är ett decimaltal som kallas numeriskt.
• 4 ser ut som ett heltal, men R lagrar det fortfarande som en dubbel. Skriv 4L när ett sant heltal krävs.
• SANT eller FALSKT är ett booleskt värde, kallat ett logiskt värde i R.
• Värdet inuti ” ” eller ' ' är text (en sträng). Dessa värden kallas tecken.

Två ytterligare typer kompletterar uppsättningen. Komplexa värden som 3+2i innehåller en reell och en imaginär del, och råvärden innehåller byte. Båda förekommer sällan i daglig analys, men de listas i bas-R. typeof() dokumentation tillsammans med de fyra vanliga typerna.

Vi kan kontrollera typen av en variabel med klassfunktionen.

Exempel 1: Kontrollera en numerisk variabel

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

Produktion:

## [1] "numeric"

Exempel 2: Kontrollera en teckenvariabel

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

Produktion:

## [1] "character"

Exempel 3: Kontrollera en logisk variabel

# Boolean
z <- TRUE
class(z)

Produktion:

## [1] "logical"

Observera att class() svarar "numeriskt" för 28 trots att 28 inte har någon decimaldel. R lagrade det som en double, och endast typeof() visar det. Nästa skillnad som är värd att lära sig är hur dessa värden får namn.

Variabler i R

Variabler är en av de grundläggande byggstenarna i R som lagrar värden, och de är viktiga för alla som arbetar med data science. En variabel i R kan lagra ett tal, ett objekt, ett statistiskt resultat, en vektor, en datauppsättning eller en modellprediktion – i princip allt som R matar ut. Vi kan använda variabeln senare genom att helt enkelt anropa variabelns namn.

För att deklarera en variabel i R måste vi tilldela den ett variabelnamn. Namnet får inte innehålla mellanslag. Vi kan använda _ för att förena två ord.

Namn kan innehålla bokstäver, siffror, punkter och understreck, men de måste börja med en bokstav eller en punkt, och reserverade ord som SANT, FALSKT och NULL kan inte användas som namn. För att lägga till ett värde till variabeln, använd <- eller =.

Här är syntaxen:

# 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å kommandoraden kan vi skriva följande koder för att se vad som händer:

Exempel 1: Tilldela ett värde och skriv ut det

# Print variable x
x <- 42
x

Produktion:

## [1] 42

Exempel 2: Deklarera en andra variabel

y  <- 10
y

Produktion:

## [1] 10

Exempel 3: Använd två variabler i ett uttryck

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

Produktion:

## [1] 32

En variabel som innehåller flera värden av samma typ är en vektor, vilket är den struktur som nästan alla R-funktioner förväntar sig.

Vektorer i R

En vektor är en endimensionell samling där varje element delar samma typ. Vi kan skapa en vektor med alla grundläggande R-datatyper som vi lärt oss tidigare. Det enklaste sättet att bygga en vektor i R är att använda funktionen c().

Exempel 1: Skapa en numerisk vektor

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

Produktion:

## [1]  1 10 49

Exempel 2: Skapa en teckenvektor

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

Produktion:

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

Exempel 3: Skapa en logisk vektor

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

Produktion:

##[1] TRUE FALSE TRUE

Om c() tar emot en blandning av typer, misslyckas den inte. Den tvingar tyst varje element upp till den mest generella typen som finns, så c(1, "a", TRUE) blir en teckenvektor. Vi kan också göra aritmetiska beräkningar på vektorer i R.

Exempel 4: Addera två vektorer element för 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

Produktion:

[1]  3  7 11

Additionen fungerade element för element eftersom båda vektorerna har samma längd. När längderna skiljer sig åt, återanvänder R den kortare vektorn och upprepar det tills den matchar den längre, och varnar endast när den längre längden inte är en multipel av den kortare.

Exempel 5: Dela upp de första fem elementen

I R är det möjligt att skiva en vektor. I vissa fall är vi bara intresserade av de första fem elementen i en vektor. Vi kan använda kommandot [1:5] för att t.ex.tracvärdena 1 till 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]

Produktion:

## [1] 1 2 3 4 5

Exempel 6: Bygg ett intervall med kolon Operator

Det kortaste sättet att skapa ett värdeintervall är att använda kolonoperatorn (:) mellan två tal. Till exempel, från exemplet ovan kan vi skriva c(1:10) för att skapa en vektor med värden från ett till tio.

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

Produktion:

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

Eftersom en vektor tyst ändrar typ när den blandas, lönar det sig att veta hur man inspekterar och konverterar typer på begäran.

Hur man kontrollerar och konverterar datatyper i R

Tre funktionsfamiljer besvarar de tre frågor som ständigt dyker upp: vad är detta, är detta en given typ, och kan detta bli en annan typ.

# 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

Två regler förklarar de flesta överraskningarna här. För det första rapporterar class() klassen som används för metodavsändning medan typeof() rapporterar den interna lagringen, vilket är anledningen till att 28 är "numerisk" för den ena och "dubbel" för den andra. För det andra stoppar inte en konvertering som inte lyckas skriptet: as.numeric("abc") returnerar NA och skriver ut en tvångsvarning, så tysta NA:er efter en import är nästan alltid ett typproblem. Samma logik driver faktorer, som lagrar kategorier som heltalskoder plus en tabell över nivåer.

När typerna är avgjorda är det nästa steg med operatorerna som agerar på dem.

R Aritmetik Operatorer

Vi ska först se de grundläggande aritmetiska operatorerna i R. Följande är de aritmetiska operatorerna i R-programmering och vad de står för:

Var och en av dessa operatorer är vektoriserade, så samma uttryck fungerar på ett enda värde eller på en hel kolumn.

Exempel 1: Addition

# An addition
3 + 4

Produktion:

## [1] 7

Du kan enkelt kopiera och klistra in ovanstående R-kod i RStudio Konsol. I den här artikeln visas utdata på rader som börjar med ##. Om vi ​​till exempel skriver koden print("Guru99") konsolen skriver ut [1] "Guru99", vilket den här sidan skulle visa som ## [1] "Guru99. "

## markerar en rad med utskriven utgång, och siffran inom hakparentesen ([1]) är indexet för det första värdet på den raden, inte en del av resultatet.

Meningar som börjar med # är kommentarer. Vi kan använda # i ett R-skript för att lägga till vilken anteckning vi vill, och R ignorerar det vid körning.

Exempel 2: Multiplikation

# A multiplication
3*5

Produktion:

## [1] 15

Exempel 3: Division

# A division
(5+5)/2

Produktion:

## [1] 5

Exempel 4: Exponentiering

# Exponentiation
2^5

Produktion:

## [1] 32

Exempel 5: Modulo

# Modulo
28%%6

Produktion:

## [1] 4

Aritmetik producerar tal. Nästa grupp operatorer producerar istället SANT och FALSKT.

R Relationell (Jämförelse) Operatorer

Relationsoperatorer jämför två värden och returnerar ett logiskt resultat. Det är operatorerna som bygger villkoren som används för filtrering, och de vektoriseras på exakt samma sätt som de aritmetiska operatorerna.

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

Två vanor sparar tid här. Använd == för jämförelse och <- för tilldelning, eftersom ett enkelt = inuti ett villkor är ett vanligt nybörjarfel. Och undvik == på dubblar: flyttal med avrundning innebär att 0.1 + 0.2 == 0.3 är FALSKT, så isTRUE(all.equal(0.1 + 0.2, 0.3)) är det säkra testet. Jämförelser på sorterade dataramar följa samma regler.

R Logisk Operatorer

Med logiska operatorer vill vi returnera värden inom vektorn baserat på logiska villkor. Tabellen nedan listar de logiska operatorer som finns tillgängliga i R.

De logiska satserna i R är inramade inom []. Vi kan lägga till så många villkorssatser som vi vill, men vi måste inkludera dem inom parenteser. Vi kan följa denna struktur för att skapa en villkorssats:

variable_name[(conditional_statement)]

Med variabelnamn som hänvisar till den variabel vi vill använda för satsen skapar vi den logiska satsen, till exempel variabelnamn > 0. Slutligen använder vi hakparenteser för att slutföra den logiska satsen. Nedan följer ett exempel på en logisk sats.

Exempel 1: Jämför alla element i en vektor

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

Produktion:

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

I utdata ovan läser R varje värde och jämför det med uttrycket logical_vector>5. Om värdet är strikt större än fem, är villkoret SANT, annars FALSKT. R returnerar vektorerna SANT och FALSKT.

Exempel 2: Behåll endast de element som matchar

I exemplet nedan vill vi t.ex.tracde värden som bara uppfyller villkoret 'är strikt större än fem'. För att göra det kan vi omge villkoret med hakparenteser föregångna av vektorn som innehåller värdena.

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

Produktion:

## [1]  6  7  8  9 10

Exempel 3: Kombinera två villkor

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

Produktion:

## [1] 5 6

Exempel 3 använder avsiktligt det enkla et-tecknet &. Enteckensoperatorerna & och | jämför vektorer element för element och returnerar en vektor, vilket är vad delmängder behöver. Dubbelformerna && och || returnerar ett värde och hör hemma i if()- och while()-villkoren. Eftersom R 4.3.0, att skicka ett argument som är längre än ett element till && eller || är ett fel snarare än en varning, så de två familjerna är inte längre utbytbara. !-operatorn negerar ett villkor, och xor() ger exklusiv ELLER.

R-uppgift Operatorer

Tilldelningsoperatorer binder ett värde till ett namn. R erbjuder fler av dem än de flesta språk, och skillnaderna spelar roll när koden flyttas in funktioner.

# 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 rekommenderar <- för att skapa objekt och = för att namnge argument inuti ett anrop, eftersom de två rollerna då förblir visuellt åtskilda. Använd <<- sparsamt: det ändrar ett objekt utanför den aktuella funktionen och gör det svårare att resonera kring koden. När tilldelning och typer är bekväma är nästa steg importera verkliga data och reshaping det med dplyr; Den Översikt över R-språket sätter hela verktygskedjan i ett sammanhang.

Vanliga frågor