R Language
Skapa vektorer

Antalet i följd

Använd : operatören för att skapa sekvenser med siffror, till exempel för användning i vektorisering av större bitar av din kod:

x <- 1:5
x
## [1] 1 2 3 4 5

Detta fungerar båda vägarna

10:4
# [1] 10  9  8  7  6  5  4

och även med flytande punktnummer

1.25:5
# [1] 1.25 2.25 3.25 4.25

eller negativ

-4:4
#[1] -4 -3 -2 -1  0  1  2  3  4

seq ()

seq är en mer flexibel funktion än : operatören som tillåter att ange andra steg än 1.

Funktionen skapar en sekvens från start (standard är 1) till slutet inklusive numret.

Du kan bara ange slutet ( to ) -parametern

seq(5)
# [1] 1 2 3 4 5

Samt början

seq(2, 5) # or seq(from=2, to=5)
# [1] 2 3 4 5

Och slutligen steget ( by )

seq(2, 5, 0.5) # or seq(from=2, to=5, by=0.5)
# [1] 2.0 2.5 3.0 3.5 4.0 4.5 5.0

seq kan valfritt dra slutsatsen (jämnt fördelade) steg när alternativt den önskade längden på utgången ( length.out ) tillhandahålls

seq(2,5, length.out = 10)
# [1] 2.0 2.3 2.6 2.9 3.2 3.5 3.8 4.1 4.4 4.7 5.0

Om sekvensen måste ha samma längd som en annan vektor kan vi använda along.with som en kortfattning för length.out = length(x)

x = 1:8
seq(2,5,along.with = x)
# [1] 2.000000 2.428571 2.857143 3.285714 3.714286 4.142857 4.571429 5.000000

Det finns två användbara förenklade funktioner i seq familjen: seq_along , seq_len och seq.int . seq_along och seq_len funktioner konstruerar de naturliga (räknande) siffrorna från 1 till N där N bestäms av funktionsargumentet, längden på en vektor eller lista med seq_along och seq_len med seq_len .

seq_along(x)
# [1] 1 2 3 4 5 6 7 8

Observera att seq_along returnerar index för ett befintligt objekt.

# counting numbers 1 through 10
seq_len(10)
[1]  1  2  3  4  5  6  7  8  9 10
# indices of existing vector (or list) with seq_along
letters[1:10]
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j"
seq_along(letters[1:10])
[1]  1  2  3  4  5  6  7  8  9 10

seq.int är samma som seq upprätthålls för forntida kompatibilitet.

Det finns också en gammal funktion sequence som skapar en vektor av sekvenser från en icke negativ argument.

sequence(4)
# [1] 1 2 3 4
sequence(c(3, 2))
# [1] 1 2 3 1 2
sequence(c(3, 2, 5))
# [1] 1 2 3 1 2 1 2 3 4 5

vektorer

Vektorer i R kan ha olika typer (t.ex. heltal, logisk, karaktär). Det mest allmänna sättet att definiera en vektor är att använda funktionsvektorn vector() .

vector('integer',2) # creates a vector of integers of size 2.
vector('character',2) # creates a vector of characters of size 2.
vector('logical',2) # creates a vector of logicals of size 2.

Men i R är korthetsfunktionerna i allmänhet mer populära.

integer(2) # is the same as vector('integer',2) and creates an integer vector with two elements
character(2) # is the same as vector('integer',2) and creates an character vector with two elements
logical(2) # is the same as vector('logical',2) and creates an logical vector with two elements

Det är också möjligt att skapa vektorer med andra värden än standardvärdena. Ofta används funktionen c() för detta. C är förkortning för kombinerad eller sammanlänkad.

c(1, 2) # creates a integer vector of two elements: 1 and 2.
c('a', 'b') # creates a character vector of two elements: a and b.
c(T,F) # creates a logical vector of two elements: TRUE and FALSE.

Viktigt att notera här är att R tolkar alla heltal (t.ex. 1) som en heltalvektor i storlek ett. Samma sak gäller numerik (t.ex. 1.1), logik (t.ex. T eller F) eller tecken (t.ex. 'a'). Därför kombinerar du i huvudsak vektorer, som i sin tur är vektorer.

Var uppmärksam på att du alltid måste kombinera liknande vektorer. Annars kommer R att försöka konvertera vektorerna i vektorer av samma typ.

c(1,1.1,'a',T) # all types (integer, numeric, character and logical) are converted to the 'lowest' type which is character.

Hitta element i vektorer kan göras med [ operatören.

vec_int <- c(1,2,3)
vec_char <- c('a','b','c')
vec_int[2] # accessing the second element will return 2
vec_char[2] # accessing the second element will return 'b'

Detta kan också användas för att ändra värden

vec_int[2] <- 5 # change the second value from 2 to 5
vec_int # returns [1] 1 5 3

Slutligen : operatören (kort för funktionen seq() kan) användas för att snabbt skapa en vektor av tal.

vec_int <- 1:10
vec_int # returns [1] 1 2 3 4 5 6 7 8 9 10

Detta kan också användas för att dela upp vektorer (från enkla till mer komplexa delmängder)

vec_char <- c('a','b','c','d','e')
vec_char[2:4] # returns [1] "b" "c" "d"
vec_char[c(1,3,5)] # returns [1] "a" "c" "e"

Skapa namngivna vektorer

Namngivna vektorer kan skapas på flera sätt. Med c :

xc <- c('a' = 5, 'b' = 6, 'c' = 7, 'd' = 8)

vilket resulterar i:

> xc
a b c d 
5 6 7 8

med list :

xl <- list('a' = 5, 'b' = 6, 'c' = 7, 'd' = 8)

vilket resulterar i:

> xl
$a
[1] 5

$b
[1] 6

$c
[1] 7

$d
[1] 8

Med funktionen setNames kan två vektorer med samma längd användas för att skapa en namngivna vektor:

x <- 5:8
y <- letters[1:4]

xy <- setNames(x, y)

vilket resulterar i en namngiven heltalvektor:

> xy
a b c d 
5 6 7 8

Som framgår ger detta samma resultat som c metoden.

Du kan också använda names att få samma resultat:

xy <- 5:8
names(xy) <- letters[1:4]

Med en sådan vektor är det också möjligt att välja element efter namn:

> xy["c"]
c 
7 

Denna funktion gör det möjligt att använda en sådan benämnd vektor som en uppslagningsvektor / tabell för att matcha värdena till värden för en annan vektor eller kolumn i dataframe. Med tanke på följande dataframe:

mydf <- data.frame(let = c('c','a','b','d'))

> mydf
  let
1   c
2   a
3   b
4   d

Anta att du vill skapa en ny variabel i mydf dataframe som heter num med korrekta värden från xy i raderna. Med hjälp av match kan lämpliga värden från xy väljas:

mydf$num <- xy[match(mydf$let, names(xy))]

vilket resulterar i:

> mydf
  let num
1   c   7
2   a   5
3   b   6
4   d   8

Expandera en vektor med funktionen rep ()

rep funktionen kan användas för att upprepa en vektor på ett ganska flexibelt sätt.

# repeat counting numbers, 1 through 5 twice
rep(1:5, 2)
[1] 1 2 3 4 5 1 2 3 4 5

# repeat vector with incomplete recycling
rep(1:5, 2, length.out=7)
[1] 1 2 3 4 5 1 2

Varje argument är särskilt användbart för att utvidga en vektor med statistik över observations / experimentella enheter till en vektor av data.frame med upprepade observationer av dessa enheter.

# same except repeat each integer next to each other
rep(1:5, each=2)
[1] 1 1 2 2 3 3 4 4 5 5

En trevlig egenskap hos rep när det gäller att involvera expansion till en sådan datastruktur är att expansion av en vektor till en obalanserad panel kan åstadkommas genom att ersätta längdargumentet med en vektor som dikterar antalet gånger för att upprepa varje element i vektorn:

# automated length repetition
rep(1:5, 1:5)
 [1] 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
# hand-fed repetition length vector
rep(1:5, c(1,1,1,2,2))
[1] 1 2 3 4 4 5 5

Detta bör avslöja möjligheten att tillåta en extern funktion att mata det andra argumentet för rep för att dynamiskt konstruera en vektor som expanderar enligt data.

Som med seq är snabbare, förenklade versioner av rep rep_len och rep.int . Dessa släpper några attribut som rep upprätthåller och så kan vara mest användbara i situationer där hastighet är ett problem och ytterligare aspekter av den upprepade vektorn är onödiga.

# repeat counting numbers, 1 through 5 twice
rep.int(1:5, 2)
[1] 1 2 3 4 5 1 2 3 4 5

# repeat vector with incomplete recycling
rep_len(1:5, length.out=7)
[1] 1 2 3 4 5 1 2

Vektorer från inbyggda konstanter: Sekvenser av bokstäver och månadsnamn

R har ett antal inbyggda konstanter. Följande konstanter är tillgängliga:

• LETTERS : de 26 stora bokstäverna i det romerska alfabetet
• letters : de 26 små bokstäverna i det romerska alfabetet
• month.abb : month.abb med tre bokstäver för de engelska månadens namn
• month.name : de engelska namnen för årets månader
• pi : förhållandet mellan cirkelns omkrets och dess diameter

Från bokstäver och månadskonstanter kan vektorer skapas.

1) Sekvenser av bokstäver:

> letters
[1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v" "w" "x" "y" "z"

> LETTERS[7:9]
[1] "G" "H" "I"

> letters[c(1,5,3,2,4)]
[1] "a" "e" "c" "b" "d"

2) Sekvenser av månadsförkortningar eller månadsnamn:

> month.abb
 [1] "Jan" "Feb" "Mar" "Apr" "May" "Jun" "Jul" "Aug" "Sep" "Oct" "Nov" "Dec"

> month.name[1:4]
[1] "January"  "February" "March"    "April"   

> month.abb[c(3,6,9,12)]
[1] "Mar" "Jun" "Sep" "Dec"