Andmetüübid R-is koos näitega

Mis on R-i andmetüübid?

Järgmised on R-programmeerimise andmetüübid või andmestruktuurid:

• Skalaarid
• Vektorid (numbrilised, märgilised, loogilised)
• maatriksid
• Andmeraamid
• Nimekirjad

See nimekiri segab kahte omavahel seotud ideed ja nende eraldamine muudab ülejäänud lehe jälgimise lihtsamaks. andmetüüp kirjeldab, mis on üksik väärtus – arv, tekstiosa, TÕENE või VÄÄR. andmete struktuur kirjeldab, kui palju väärtusi koos hoitakse ja millisel kujul. Skalaarid, vektorid, maatriksid, andmeraamid ja loendid on struktuurid; nende sees olevad väärtused kuuluvad ikkagi ühte R-i põhitüüpi.

R-il puudub eraldi skalaaritüüp: skalaar on lihtsalt ühe pikkune vektor, mistõttu kirjutatakse nii palju R-koodi korraga tervete vektorite jaoks.

Põhilised andmetüübid R-is

Iga R väärtus kuulub ühte väikesest hulgast põhilistest (aatomi)tüüpidest:

• 4.5 on kümnendsüsteemi väärtus, mida nimetatakse numbriteks.
• 4 näeb välja nagu täisarv, aga R salvestab selle ikkagi kahekordse arvuna. Kirjuta 4L, kui on vaja tõelist täisarvu.
• TRUE või FALSE on Boole'i ​​väärtus, mida R-is nimetatakse loogikaväärtuseks.
• ” ” või ' ” sees olev väärtus on tekst (string). Neid väärtusi nimetatakse tähemärkideks.

Komplekti täiendavad veel kaks tüüpi. Komplekssed väärtused, näiteks 3+2i, sisaldavad reaalset ja imaginaarosa ning toorväärtused sisaldavad baite. Mõlemad esinevad igapäevases analüüsis harva, kuid need on loetletud baas-R-is. typeof() dokumentatsioon nelja levinuma tüübi kõrval.

Muutuja tüüpi saame kontrollida klassifunktsiooniga.

Näide 1: Numbrilise muutuja kontrollimine

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

Väljund:

## [1] "numeric"

Näide 2: Märkimuutuja kontrollimine

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

Väljund:

## [1] "character"

Näide 3: Loogilise muutuja kontrollimine

# Boolean
z <- TRUE
class(z)

Väljund:

## [1] "logical"

Pane tähele, et class() vastab väärtusele 28 numbrilise vastuse, kuigi 28-l pole kümnendosa. R salvestas selle topeltarvuna ja ainult typeof() näitab seda. Järgmine õppimist väärt erinevus on see, kuidas need väärtused nimed saavad.

Muutujad R-is

Muutujad on R-i üks põhilisi ehitusplokke, mis salvestab väärtusi, ja need on olulised kõigile, kes tegelevad andmeteaduse tööga. R-i muutuja saab salvestada arvu, objekti, statistilise tulemuse, vektori, andmestiku või mudeli ennustuse – põhimõtteliselt kõike, mida R väljastab. Saame seda muutujat hiljem kasutada lihtsalt muutuja nime kutsudes.

Muutuja deklareerimiseks R-is peame määrama muutujale nime. Nimi ei tohi sisaldada tühikut. Kahe sõna ühendamiseks võime kasutada sümbolit _.

Nimed võivad sisaldada tähti, numbreid, punkte ja alakriipse, kuid need peavad algama tähe või punktiga ning reserveeritud sõnu, näiteks TRUE, FALSE ja NULL, ei saa nimedena kasutada. Muutujale väärtuse lisamiseks kasutage <- või =.

Siin on süntaks:

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

Käsureale saame kirjutada järgmised koodid, et näha, mis juhtub:

Näide 1: Määrake väärtus ja printige see välja

# Print variable x
x <- 42
x

Väljund:

## [1] 42

Näide 2: Teise muutuja deklareerimine

y  <- 10
y

Väljund:

## [1] 10

Näide 3: Kasutage ühes avaldises kahte muutujat

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

Väljund:

## [1] 32

Muutuja, mis sisaldab mitut sama tüüpi väärtust, on vektor ja see on struktuur, mida peaaegu iga R-funktsioon ootab.

Vektorid R-is

Vektor on ühemõõtmeline kogum, milles iga element on sama tüüpi. Me saame luua vektori, kasutades kõiki varem õpitud R-i põhilisi andmetüüpe. Lihtsaim viis vektori loomiseks R-is on kasutada funktsiooni c().

Näide 1: Numbrilise vektori loomine

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

Väljund:

## [1]  1 10 49

Näide 2: Loo märgivektor

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

Väljund:

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

Näide 3: Loo loogiline vektor

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

Väljund:

##[1] TRUE FALSE TRUE

Kui c() saab mitut tüüpi, siis see ei ebaõnnestu. See sunnib vaikselt iga elemendi ülespoole kõige üldisema olemasoleva tüübini, nii et c(1, "a", TRUE) muutub märkvektoriks. Samuti saame R-is vektoritega aritmeetilisi arvutusi teha.

Näide 4: Kahe vektori liitmine elemendi haaval

# 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

Väljund:

[1]  3  7 11

Liitmine toimus element elemendi haaval, kuna mõlemal vektoril on sama pikkus. Kui pikkused erinevad, siis R taaskasutab lühemat vektorit, korrates seda seni, kuni see vastab pikemale vektorile, ja hoiatab ainult siis, kui pikem pikkus ei ole lühema vektori kordne.

Näide 5: Viige esimesed viis elementi viiludeks

R-is on võimalik vektorit tükeldada. Mõnel juhul oleme huvitatud ainult vektori esimesest viiest elemendist. Saame kasutada käsku [1:5], et seda välja tuua.tract väärtused 1 kuni 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]

Väljund:

## [1] 1 2 3 4 5

Näide 6: Vahemiku loomine kooloniga Operator

Lühim viis väärtuste vahemiku loomiseks on kasutada kahe arvu vahel koolonoperaatorit (:). Näiteks ülaltoodud näite põhjal saame kirjutada c(1:10), et luua väärtuste vektor ühest kümneni.

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

Väljund:

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

Kuna vektor muudab segamisel vaikselt tüüpi, tasub teada, kuidas tüüpe nõudmisel kontrollida ja teisendada.

Kuidas R-is andmetüüpe kontrollida ja teisendada

Kolm funktsioonide perekonda vastavad kolmele pidevalt kerkivale küsimusele: mis see on, kas see on antud tüüp ja kas sellest saab teine ​​tüüp.

# 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

Enamiku üllatusi selgitavad siin kaks reeglit. Esiteks, class() annab teada meetodi lähetamiseks kasutatud klassist, samas kui typeof() annab teada sisemisest salvestusruumist, mistõttu on 28 ühe jaoks "numbriline" ja teise jaoks "topelt". Teiseks, ebaõnnestunud teisendus ei peata skripti: as.numeric("abc") tagastab NA ja kuvab sunnihoiatuse, seega on vaiksed NA-d pärast importi peaaegu alati tüübiprobleem. Sama loogika juhib tegurid, mis salvestavad kategooriaid täisarvukoodidena koos tasemete tabeliga.

Kui tüübid on paika pandud, on järgmisena operaatorid, kes nende alusel tegutsevad.

R Aritmeetika Operatorse

Esmalt vaatame R-i põhilisi aritmeetilisi operaatoreid. Järgnevalt on toodud R-programmeerimise aritmeetilised operaatorid ja nende tähised:

Kõik need operaatorid on vektoriseeritud, seega sama avaldis töötab nii üksiku väärtuse kui ka terve veeru puhul.

Näide 1: Liitmine

# An addition
3 + 4

Väljund:

## [1] 7

Saate ülaltoodud R-koodi hõlpsalt kopeerida ja kleepida RStuudio Konsool. Selles artiklis kuvatakse väljund ridadel, mis algavad ##-ga. Näiteks kui kirjutame koodi print("Guru99") konsool kuvab [1] "Guru99", mida see leht kuvaks kujul ## [1] "Guru99 ".

## tähistab prinditud väljundi rida ja nurksulgudes olev number ([1]) on selle rea esimese väärtuse indeks, mitte tulemuse osa.

#-märgiga algavad laused on kommentaarid. R-skripti sees saame #-märgi abil lisada mis tahes märkuse ja R ignoreerib seda käitusajal.

Näide 2: Korrutamine

# A multiplication
3*5

Väljund:

## [1] 15

Näide 3: Jagamine

# A division
(5+5)/2

Väljund:

## [1] 5

Näide 4: Astmestamine

# Exponentiation
2^5

Väljund:

## [1] 32

Näide 5: Modulo

# Modulo
28%%6

Väljund:

## [1] 4

Aritmeetika annab tulemuseks arvud. Järgmine operaatorite rühm annab tulemuseks hoopis TÕENE ja VÄÄR.

R Relatsiooniline (võrdlus) Operatorse

Relatsioonioperaatorid võrdlevad kahte väärtust ja tagastavad loogilise tulemuse. Need on operaatorid, mis loovad filtreerimiseks kasutatavad tingimused ja neid vektoriseeritakse täpselt samamoodi nagu aritmeetilisi operaatoreid.

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

Siin säästavad aega kaks harjumust. Kasuta võrdlemiseks == ja omistamiseks <-, sest ühe = olemasolu tingimuse sees on algajate seas tavaline viga. Ja väldi == kahekordsete arvude puhul: ujukomaümardamine tähendab, et 0.1 + 0.2 == 0.3 on VÄÄR, seega on isTRUE(all.equal(0.1 + 0.2, 0.3)) turvaline test. Võrdlused sorteeritud andmeraamid järgige samu reegleid.

R Loogiline Operatorse

Loogiliste operaatorite abil tahame tagastada vektori sees olevaid väärtusi loogiliste tingimuste põhjal. Allolev tabel loetleb R-is saadaolevad loogilised operaatorid.

R-i loogikalaused on keeratud [] sisse. Me võime lisada nii palju tingimuslauseid kui soovime, aga need tuleb panna sulgudesse. Tingimuslause loomiseks võime järgida seda struktuuri:

variable_name[(conditional_statement)]

Kui muutuja_nimi viitab muutujale, mida soovime lauses kasutada, loome loogilise lause, näiteks muutuja_nimi > 0. Lõpuks kasutame loogilise lause lõpetamiseks nurksulge. Allpool on toodud näide loogilisest lausest.

Näide 1: Võrrelge vektori kõiki elemente

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

Väljund:

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

Ülaltoodud väljundis loeb R iga väärtuse ja võrdleb seda lausega loogiline_veektor>5. Kui väärtus on rangelt suurem kui viis, siis on tingimus TÕENE, vastasel juhul VÄÄR. R tagastab vektori, mis koosneb TÕENE ja VÄÄR väärtustest.

Näide 2: Säilita ainult sobivad elemendid

Allolevas näites tahame uuridatract väärtused, mis vastavad ainult tingimusele „on rangelt suurem kui viis“. Selleks võime tingimuse panna nurksulgudesse, millele eelneb väärtusi sisaldav vektor.

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

Väljund:

## [1]  6  7  8  9 10

Näide 3: Kahe tingimuse kombineerimine

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

Väljund:

## [1] 5 6

Näites 3 kasutatakse üksikut ampersandi & sihilikult. Ühemärgilised operaatorid & ja | võrdlevad vektoreid element elemendi haaval ja tagastavad vektori, mida alamhulk vajab. Topeltvormid && ja || tagastavad ühe väärtuse ja kuuluvad if() ja while() tingimustesse. Kuna R 4.3.0Kui && või || edastada ühest elemendist pikem argument, on see pigem viga kui hoiatus, seega ei ole need kaks perekonda enam omavahel asendatavad. ! operaator tühistab tingimuse ja xor() annab välistava VÕI operaatori.

R-ülesanne Operatorse

Omistusoperaatorid seovad väärtuse nimega. R pakub neid rohkem kui enamik keeli ja erinevused muutuvad oluliseks, kui kood liigub ... funktsioonid.

# 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

Stiilijuhendid soovitavad objektide loomiseks <- ja argumentide nimetamiseks =, kuna need kaks rolli jäävad siis visuaalselt eristatavaks. Kasutage <<- harva: see muudab objekti väljaspool praegust funktsiooni ja raskendab koodi arutlemist. Kui omistamine ja tüübid on mugavad, on järgmised sammud reaalsete andmete importimine ja reshaping see koos dplyr; R-keele ülevaade paneb kogu tööriistaketi konteksti.

KKK