Datatyper i R med eksempel

Hvad er datatyperne i R?

Følgende er datatyperne eller datastrukturerne i R-programmering:

• Skalarer
• Vektorer (numerisk, karakter, logisk)
• Matricer
• Datarammer
• Lister

Den liste blander to relaterede idéer, og ved at adskille dem bliver resten af ​​siden lettere at følge. datatype beskriver, hvad en enkelt værdi er — et tal, et stykke tekst, en SAND eller en FALSK. En datastruktur beskriver, hvor mange værdier der holdes sammen, og i hvilken form. Skalarer, vektorer, matricer, datarammer og lister er strukturer; værdierne i dem tilhører stadig en af ​​R's grundtyper.

R har ingen separat skalartype: en skalar er simpelthen en vektor med længden én, hvilket er grunden til, at så meget R-kode skrives for hele vektorer på én gang.

Grundlæggende datatyper i R

Enhver værdi i R tilhører en af ​​et lille sæt af grundlæggende (atomare) typer:

• 4.5 er en decimalværdi kaldet numerisk.
• 4 ligner et helt tal, men R gemmer det stadig som et dobbelttal. Skriv 4L, når et ægte heltal er påkrævet.
• SAND eller FALSK er en boolsk værdi, kaldet en logisk værdi i R.
• Værdien i " " eller ' ' er tekst (en streng). Disse værdier kaldes tegn.

To yderligere typer fuldender sættet. Komplekse værdier som 3+2i indeholder en reel og en imaginær del, og rå værdier indeholder bytes. Begge optræder sjældent i daglig analyse, men de er angivet i basis-R. typeof() dokumentation sammen med de fire almindelige typer.

Vi kan kontrollere typen af ​​en variabel med klassefunktionen.

Eksempel 1: Tjek en numerisk variabel

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

Output:

## [1] "numeric"

Eksempel 2: Tjek en tegnvariabel

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

Output:

## [1] "character"

Eksempel 3: Tjek en logisk variabel

# Boolean
z <- TRUE
class(z)

Output:

## [1] "logical"

Bemærk at class() svarer "numerisk" for 28, selvom 28 ikke har nogen decimaldel. R gemte det som en double, og kun typeof() afslører det. Den næste forskel, der er værd at lære, er, hvordan disse værdier får navne.

Variabler i R

Variabler er en af ​​de grundlæggende byggesten i R, der lagrer værdier, og de er vigtige for alle, der arbejder med datalogi. En variabel i R kan lagre et tal, et objekt, et statistisk resultat, en vektor, et datasæt eller en modelforudsigelse – stort set alt, hvad R udskriver. Vi kan bruge den variabel senere ved blot at kalde navnet på variablen.

For at deklarere en variabel i R, skal vi tildele den et variabelnavn. Navnet må ikke indeholde mellemrum. Vi kan bruge _ til at forbinde to ord.

Navne kan indeholde bogstaver, cifre, prikker og understregninger, men de skal starte med et bogstav eller et punktum, og reserverede ord som TRUE, FALSE og NULL kan ikke bruges som navne. For at tilføje en værdi til variablen skal du bruge <- 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 at se, hvad der sker:

Eksempel 1: Tildel en værdi og udskriv den

# Print variable x
x <- 42
x

Output:

## [1] 42

Eksempel 2: Deklarer en anden variabel

y  <- 10
y

Output:

## [1] 10

Eksempel 3: Brug to variabler i ét udtryk

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

Output:

## [1] 32

En variabel, der indeholder flere værdier af samme type, er en vektor, som er den struktur, som næsten alle R-funktioner forventer.

Vektorer i R

En vektor er en endimensionel samling, hvor hvert element deler den samme type. Vi kan oprette en vektor med alle de grundlæggende R-datatyper, som vi har lært tidligere. Den enkleste måde at opbygge en vektor i R på er at bruge c()-funktionen.

Eksempel 1: Opret en numerisk vektor

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

Output:

## [1]  1 10 49

Eksempel 2: Opret en tegnvektor

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

Output:

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

Eksempel 3: Opret en logisk vektor

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

Output:

##[1] TRUE FALSE TRUE

Hvis c() modtager en blanding af typer, fejler den ikke. Den tvinger stille og roligt hvert element op til den mest generelle type, der findes, så c(1, "a", TRUE) bliver en tegnvektor. Vi kan også udføre aritmetiske beregninger på vektorer i R.

Eksempel 4: Læg to vektorer element for element sammen

# 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

Output:

[1]  3  7 11

Additionen fungerede element for element, fordi begge vektorer har samme længde. Når længderne er forskellige, genbruger R den kortere vektor, gentager den, indtil den matcher den længste, og advarer kun, når den længere længde ikke er et multiplum af den kortere.

Eksempel 5: Opdel de første fem elementer

I R er det muligt at skære en vektor. I nogle tilfælde er vi kun interesserede i de første fem elementer i en vektor. Vi kan bruge kommandoen [1:5] til at f.eks.tracværdierne 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]

Output:

## [1] 1 2 3 4 5

Eksempel 6: Opbyg et interval med kolon OperaTor

Den korteste måde at oprette et værdiinterval på er at bruge kolonoperatoren (:) mellem to tal. For eksempel kan vi fra ovenstående eksempel skrive c(1:10) for at oprette en vektor af værdier fra et til ti.

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

Output:

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

Fordi en vektor lydløst ændrer type, når den blandes, er det en god idé at vide, hvordan man inspicerer og konverterer typer efter behov.

Sådan kontrollerer og konverterer du datatyper i R

Tre funktionsfamilier besvarer de tre spørgsmål, der konstant dukker op: hvad er dette, er dette en given type, og kan dette blive til en anden 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 overraskelser her. For det første rapporterer class() den klasse, der bruges til metodeafsendelse, mens typeof() rapporterer den interne lagring, hvilket er grunden til, at 28 er "numerisk" for den ene og "dobbelt" for den anden. For det andet stopper en konvertering, der ikke kan lykkes, ikke scriptet: as.numeric("abc") returnerer NA og udskriver en tvangsadvarsel, så tavse NA'er efter en import er næsten altid et typeproblem. Den samme logik driver faktorer, som gemmer kategorier som heltalskoder plus en tabel over niveauer.

Når typerne er afgjort, er det de næste operatorer, der handler på dem.

R Aritmetik Operatorer

Vi vil først se på de grundlæggende aritmetiske operatorer i R. Følgende er de aritmetiske operatorer i R-programmering og hvad de står for:

Hver af disse operatorer er vektoriseret, så det samme udtryk fungerer på en enkelt værdi eller på en hel kolonne.

Eksempel 1: Addition

# An addition
3 + 4

Output:

## [1] 7

Du kan nemt kopiere og indsætte ovenstående R-kode i RStudio Konsol. I denne artikel vises outputtet på linjer, der starter med ##. Hvis vi f.eks. skriver koden print("Guru99") konsollen udskriver [1] "Guru99", som denne side ville vise som ## [1] "Guru99".

## markerer en linje med udskrevet output, og tallet i den firkantede parentes ([1]) er indekset for den første værdi på den linje, ikke en del af resultatet.

Sætninger, der starter med #, er kommentarer. Vi kan bruge # i et R-script til at tilføje en hvilken som helst note, og R ignorerer det under kørsel.

Eksempel 2: Multiplikation

# A multiplication
3*5

Output:

## [1] 15

Eksempel 3: Division

# A division
(5+5)/2

Output:

## [1] 5

Eksempel 4: Eksponentiering

# Exponentiation
2^5

Output:

## [1] 32

Eksempel 5: Modulo

# Modulo
28%%6

Output:

## [1] 4

Aritmetik producerer tal. Den næste gruppe operatorer producerer i stedet SAND og FALSK.

R Relationel (Sammenligning) Operatorer

Relationsoperatorer sammenligner to værdier og returnerer et logisk resultat. Det er de operatorer, der opbygger de betingelser, der bruges til filtrering, og de vektoriseres på præcis samme måde som de aritmetiske operatorer.

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. Brug == til sammenligning og <- til tildeling, fordi en enkelt = i en betingelse er en almindelig begynderfejl. Og undgå == på doubles: flydende-komma-afrunding betyder, at 0.1 + 0.2 == 0.3 er FALSK, så isTRUE(all.equal(0.1 + 0.2, 0.3)) er den sikre test. Sammenligninger på sorterede datarammer følge de samme regler.

R Logisk Operatorer

Med logiske operatorer ønsker vi at returnere værdier inden for vektoren baseret på logiske betingelser. Tabellen nedenfor viser de logiske operatorer, der er tilgængelige i R.

De logiske udsagn i R er pakket ind i []. Vi kan tilføje så mange betingede udsagn, som vi ønsker, men vi skal inkludere dem i parenteser. Vi kan følge denne struktur for at oprette en betinget udsagn:

variable_name[(conditional_statement)]

Med variable_name som refererer til den variabel, vi vil bruge til sætningen, opretter vi den logiske sætning, for eksempel variable_name > 0. Til sidst bruger vi de firkantede parenteser til at færdiggøre den logiske sætning. Nedenfor er et eksempel på en logisk sætning.

Eksempel 1: Sammenlign alle elementer i en vektor

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

Output:

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

I outputtet ovenfor læser R hver værdi og sammenligner den med sætningen logical_vector>5. Hvis værdien er strengt taget større end fem, er betingelsen SAND, ellers FALSK. R returnerer en vektor af SAND og FALSK.

Eksempel 2: Behold kun de elementer, der matcher

I eksemplet nedenfor ønsker vi at f.eks.tracde værdier, der kun opfylder betingelsen 'er strengt taget større end fem'. For at gøre dette kan vi omslutte betingelsen i firkantede parenteser efterfulgt af vektoren, der indeholder værdierne.

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

Output:

## [1]  6  7  8  9 10

Eksempel 3: Kombinér to betingelser

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

Output:

## [1] 5 6

Eksempel 3 bruger det enkelte og-tegnet & med vilje. Enkelttegnsoperatorerne & og | sammenligner vektorer element for element og returnerer en vektor, hvilket er, hvad delmængder har brug for. Dobbeltformerne && og || returnerer én værdi og hører hjemme i if()- og while()-betingelserne. Da R 4.3.0, at sende et argument, der er længere end ét element, til && eller || er en fejl snarere end en advarsel, så de to familier er ikke længere udskiftelige. !-operatoren negerer en betingelse, og xor() giver eksklusiv ELLER.

R-tildeling Operatorer

Tildelingsoperatorer binder en værdi til et navn. R tilbyder flere af dem end de fleste sprog, og forskellene betyder noget, når koden flyttes ind i 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 anbefaler <- til oprettelse af objekter og = til navngivning af argumenter i et kald, fordi de to roller så forbliver visuelt adskilte. Brug <<- sparsomt: det ændrer et objekt uden for den aktuelle funktion og gør det sværere at ræsonnere om kode. Når tildeling og typer er komfortable, er de næste trin: import af reelle data og reshaping det med dplyr; det Oversigt over R-sproget sætter hele værktøjskæden i kontekst.

Ofte Stillede Spørgsmål