Gegevenstypen in R met voorbeeld

Wat zijn de gegevenstypen in R?

Hieronder staan ​​de gegevenstypen of gegevensstructuren in R-programmering:

• scalaires
• Vectoren (numeriek, karakter, logisch)
• matrices
• Gegevensframes
• lijsten

Die lijst combineert twee verwante ideeën, en door ze te scheiden wordt de rest van deze pagina gemakkelijker te volgen. data type beschrijft wat een enkele waarde is: een getal, een stuk tekst, WAAR of ONWAAR. data structuur Beschrijft hoe veel waarden bij elkaar worden gehouden en in welke vorm. Scalaire waarden, vectoren, matrices, dataframes en lijsten zijn structuren; de waarden erin behoren nog steeds tot een van de basistypen van R.

R kent geen apart scalair type: een scalair is simpelweg een vector met lengte één, vandaar dat veel R-code in één keer voor hele vectoren wordt geschreven.

Basisgegevenstypen in R

Elke waarde in R behoort tot een kleine set van basis (atomaire) gegevenstypen:

• 4.5 is een decimale waarde, een getal dat numeriek wordt genoemd.
• 4 lijkt een geheel getal, maar R slaat het nog steeds op als een double. Schrijf 4L wanneer een echt geheel getal vereist is.
• WAAR of ONWAAR is een Booleaanse waarde, in R een logische waarde genoemd.
• De waarde tussen ” ” of ' ' is tekst (een tekenreeks). Deze waarden worden tekens genoemd.

Twee andere typen maken de set compleet. Complexe waarden zoals 3+2i bevatten een reëel en een imaginair deel, en ruwe waarden bevatten bytes. Beide komen zelden voor in de dagelijkse analyse, maar ze staan ​​wel vermeld in de basis-R. typeof() documentatie naast de vier meest voorkomende typen.

We kunnen het type van een variabele controleren met behulp van de klassefunctie.

Voorbeeld 1: Een numerieke variabele controleren

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

Output:

## [1] "numeric"

Voorbeeld 2: Een tekenvariabele controleren

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

Output:

## [1] "character"

Voorbeeld 3: Een logische variabele controleren

# Boolean
z <- TRUE
class(z)

Output:

## [1] "logical"

Merk op dat class() "numeric" retourneert voor 28, ook al heeft 28 geen decimaal. R heeft het opgeslagen als een double, en alleen typeof() onthult dat. Het volgende verschil dat de moeite waard is om te leren, is hoe die waarden namen krijgen.

Variabelen in R

Variabelen zijn een van de basisbouwstenen in R waarmee waarden worden opgeslagen, en ze zijn belangrijk voor iedereen die zich bezighoudt met data science. Een variabele in R kan een getal, een object, een statistisch resultaat, een vector, een dataset of een modelvoorspelling opslaan – in principe alles wat R uitvoert. We kunnen die variabele later gebruiken door simpelweg de naam van de variabele aan te roepen.

Om een ​​variabele in R te declareren, moeten we een variabelenaam toewijzen. De naam mag geen spaties bevatten. We kunnen een underscore (_) gebruiken om twee woorden te verbinden.

Namen mogen letters, cijfers, punten en underscores bevatten, maar ze moeten beginnen met een letter of een punt. Gereserveerde woorden zoals TRUE, FALSE en NULL mogen niet als naam worden gebruikt. Om een ​​waarde aan de variabele toe te voegen, gebruikt u <- of =.

Hier is de syntaxis:

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

In de opdrachtregel kunnen we de volgende codes schrijven om te zien wat er gebeurt:

Voorbeeld 1: Een waarde toewijzen en afdrukken

# Print variable x
x <- 42
x

Output:

## [1] 42

Voorbeeld 2: Een tweede variabele declareren

y  <- 10
y

Output:

## [1] 10

Voorbeeld 3: Twee variabelen gebruiken in één uitdrukking

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

Output:

## [1] 32

Een variabele die meerdere waarden van hetzelfde type bevat, is een vector, en dat is de structuur die bijna elke R-functie verwacht.

Vectoren in R

Een vector is een eendimensionale verzameling waarin elk element hetzelfde gegevenstype heeft. We kunnen een vector maken met alle basisgegevenstypen van R die we eerder hebben geleerd. De eenvoudigste manier om een ​​vector in R te maken is met behulp van de functie c().

Voorbeeld 1: Een numerieke vector maken

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

Output:

## [1]  1 10 49

Voorbeeld 2: Een tekenvector maken

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

Output:

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

Voorbeeld 3: Een logische vector maken

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

Output:

##[1] TRUE FALSE TRUE

Als c() een mix van typen ontvangt, mislukt de functie niet. Elk element wordt stilzwijgend geconverteerd naar het meest algemene type dat aanwezig is, waardoor c(1, "a", TRUE) een tekenreeksvector wordt. We kunnen in R ook rekenkundige bewerkingen uitvoeren op vectoren.

Voorbeeld 4: Twee vectoren element voor element optellen

# 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

De optelling werkte element voor element omdat beide vectoren dezelfde lengte hebben. Wanneer de lengtes verschillen, hergebruikt R de kortere vector en herhaalt deze totdat deze overeenkomt met de langere vector. Er wordt alleen een waarschuwing gegeven als de langere vector geen veelvoud is van de kortere vector.

Voorbeeld 5: Snijd de eerste vijf elementen

In R is het mogelijk om een ​​vector te selecteren. Soms zijn we alleen geïnteresseerd in de eerste vijf elementen van een vector. We kunnen de opdracht [1:5] gebruiken om dit te doen.tract de waarden 1 tot en met 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

Voorbeeld 6: Een bereik maken met de dubbele punt Operator

De kortste manier om een ​​reeks waarden te creëren is door de dubbele punt (:) tussen twee getallen te gebruiken. In het bovenstaande voorbeeld kunnen we bijvoorbeeld c(1:10) schrijven om een ​​vector met waarden van één tot tien te maken.

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

Output:

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

Omdat een vector ongemerkt van type verandert wanneer deze wordt gemengd, is het nuttig om te weten hoe je typen kunt inspecteren en converteren wanneer nodig.

Hoe controleer en converteer je gegevenstypen in R?

Drie families van functies geven antwoord op de drie vragen die steeds terugkomen: wat is dit, is dit een bepaald type, en kan dit een ander type worden.

# 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

Twee regels verklaren de meeste verrassingen hier. Ten eerste rapporteert `class()` de klasse die wordt gebruikt voor het aanroepen van methoden, terwijl `typeof()` de interne opslag rapporteert. Daarom is 28 voor de ene functie "numeriek" en voor de andere "double". Ten tweede stopt een mislukte conversie het script niet: `as.numeric("abc")` retourneert NA en geeft een waarschuwing voor typeconversie weer. Stille NA's na een import duiden dus bijna altijd op een typeprobleem. Dezelfde logica is van toepassing. factoren, die categorieën opslaan als integer codes plus een tabel met niveaus.

Nu de typen vastgesteld zijn, komen de operators die ermee werken aan de beurt.

R Rekenkunde Operaverdraaid

We beginnen met de basisrekenkundige operatoren in R. Hieronder volgen de rekenkundige operatoren in R-programmering en waar ze voor staan:

Elk van deze operatoren is gevectoriseerd, waardoor dezelfde expressie werkt op een enkele waarde of op een hele kolom.

Voorbeeld 1: Optellen

# An addition
3 + 4

Output:

## [1] 7

Je kunt de bovenstaande R-code eenvoudig kopiëren en plakken in de RStudio Console. In dit artikel wordt de uitvoer weergegeven op regels die beginnen met ##. Als we bijvoorbeeld de code print(" schrijven, dan is dat de console.Guru99") print de console [1] "Guru99", wat op deze pagina zou worden weergegeven als ## [1] "Guru99".

De ## markeert een regel in de afgedrukte uitvoer, en het getal tussen vierkante haken ([1]) is de index van de eerste waarde op die regel, niet van het resultaat.

Zinnen die met een # beginnen, zijn opmerkingen. We kunnen # in een R-script gebruiken om elke gewenste opmerking toe te voegen, en R negeert deze tijdens de uitvoering.

Voorbeeld 2: Vermenigvuldiging

# A multiplication
3*5

Output:

## [1] 15

Voorbeeld 3: Delen

# A division
(5+5)/2

Output:

## [1] 5

Voorbeeld 4: Machtsverheffing

# Exponentiation
2^5

Output:

## [1] 32

Voorbeeld 5: Modulo

# Modulo
28%%6

Output:

## [1] 4

Rekenkundige bewerkingen produceren getallen. De volgende groep bewerkingen produceert in plaats daarvan WAAR en ONWAAR.

R Relationeel (Vergelijking) Operaverdraaid

Relationele operatoren vergelijken twee waarden en geven een logisch resultaat terug. Het zijn de operatoren die de voorwaarden voor filtering opbouwen en ze worden op exact dezelfde manier gevectoriseerd als de rekenkundige operatoren.

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

Twee gewoontes besparen hier tijd. Gebruik == voor vergelijkingen en <- voor toewijzingen, omdat een enkele = binnen een voorwaarde een veelgemaakte beginnersfout is. Vermijd ook == op doubles: afronding met drijvende-komma getallen betekent dat 0.1 + 0.2 == 0.3 ONWAAR is, dus isTRUE(all.equal(0.1 + 0.2, 0.3)) is de veilige test. Vergelijkingen op gesorteerde dataframes Volg dezelfde regels.

R Logisch Operaverdraaid

Met logische operatoren willen we waarden in een vector retourneren op basis van logische voorwaarden. De onderstaande tabel geeft een overzicht van de logische operatoren die beschikbaar zijn in R.

Logische beweringen in R worden tussen vierkante haken geplaatst []. We kunnen zoveel voorwaardelijke beweringen toevoegen als we willen, maar we moeten ze wel tussen haakjes zetten. We kunnen deze structuur gebruiken om een ​​voorwaardelijke bewering te maken:

variable_name[(conditional_statement)]

Met `variable_name` als verwijzing naar de variabele die we voor de bewering willen gebruiken, maken we de logische bewering, bijvoorbeeld `variable_name > 0`. Tot slot gebruiken we vierkante haken om de logische bewering af te ronden. Hieronder staat een voorbeeld van een logische bewering.

Voorbeeld 1: Vergelijk elk element van een vector

# 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

In de bovenstaande uitvoer leest R elke waarde en vergelijkt deze met de bewering logical_vector>5. Als de waarde strikt groter is dan vijf, is de voorwaarde WAAR, anders ONWAAR. R retourneert een vector met WAAR en ONWAAR.

Voorbeeld 2: Behoud alleen de elementen die overeenkomen

In het onderstaande voorbeeld willen we ...tract de waarden die alleen voldoen aan de voorwaarde 'is strikt groter dan vijf'. Daarvoor kunnen we de voorwaarde tussen vierkante haken plaatsen, voorafgegaan door de vector met de waarden.

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

Output:

## [1]  6  7  8  9 10

Voorbeeld 3: Twee voorwaarden combineren

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

Output:

## [1] 5 6

In voorbeeld 3 wordt het enkele ampersand-teken & opzettelijk gebruikt. De operatoren & en |, die uit één teken bestaan, vergelijken vectoren element voor element en retourneren een vector, wat nodig is voor het selecteren van een subset. De dubbele vormen && en || retourneren één waarde en horen thuis in if()- en while()-voorwaarden. Omdat R 4.3.0Het doorgeven van een argument dat langer is dan één element aan && of || is een fout in plaats van een waarschuwing, dus de twee operatorfamilies zijn niet langer uitwisselbaar. De operator ! ontkent een voorwaarde en xor() geeft een exclusieve OF.

R-opdracht Operaverdraaid

Toewijzingsoperatoren koppelen een waarde aan een naam. R biedt er meer dan de meeste programmeertalen, en de verschillen zijn belangrijk zodra de code in de praktijk wordt toegepast. functies.

# 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

Stijlrichtlijnen bevelen <- aan voor het aanmaken van objecten en = voor het benoemen van argumenten binnen een functieaanroep, omdat de twee rollen dan visueel van elkaar onderscheiden blijven. Gebruik <<- spaarzaam: het wijzigt een object buiten de huidige functie en maakt de code moeilijker te begrijpen. Zodra toewijzing en typen vertrouwd zijn, zijn de volgende stappen: het importeren van echte gegevens en Reshaping het met dplyr; de Overzicht van de programmeertaal R plaatst de hele gereedschapsketen in de juiste context.

Veelgestelde vragen