R Language
Tworzenie wektorów

Sekwencja liczb

Użyj : operatorowi tworzyć sekwencje liczb, takich jak do zastosowania w Wektoryzacja większe kawałki kodu:

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

Działa to w obie strony

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

a nawet z liczbami zmiennoprzecinkowymi

1.25:5
# [1] 1.25 2.25 3.25 4.25

lub negatywy

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

seq ()

seq jest bardziej elastyczną funkcją niż operator : pozwalający na określenie kroków innych niż 1.

Funkcja tworzy sekwencję od start (domyślnie jest to 1) do końca, w tym ten numer.

Możesz podać tylko parametr końca ( to )

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

Jak również początek

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

I wreszcie krok ( 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 może opcjonalnie wnioskować o (równomiernie rozmieszczonych) krokach, gdy alternatywnie dostarczana jest żądana długość wyjścia ( length.out )

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

Jeśli sekwencja musi mieć tę samą długość co inny wektor, możemy użyć wzdłuż. along.with jako skrót dla 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

W rodzinie seq istnieją dwie przydatne funkcje uproszczone: seq_along , seq_len i seq.int . seq_along i seq_len konstruują liczby naturalne (zliczające) od 1 do N, gdzie N jest określone przez argument funkcji, długość wektora lub listy za pomocą seq_along oraz argument liczby całkowitej za pomocą seq_len .

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

Zauważ, że seq_along zwraca indeksy istniejącego obiektu.

# 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 jest taki sam jak seq utrzymywany dla starożytnej kompatybilności.

Istnieje również stara sequence funkcji sequence która tworzy wektor sekwencji na podstawie argumentu nieujemnego.

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

Wektory

Wektory w R mogą mieć różne typy (np. Liczba całkowita, logiczna, znak). Najbardziej ogólnym sposobem definiowania wektora jest użycie vector() funkcji 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.

Jednak w R funkcje skrótów są na ogół bardziej popularne.

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

Możliwe jest również tworzenie wektorów z wartościami innymi niż wartości domyślne. Często służy do tego funkcja c() . C jest skrótem od kombinacji lub konkatenacji.

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.

Należy tutaj zauważyć, że R interpretuje dowolną liczbę całkowitą (np. 1) jako wektor liczb całkowitych o rozmiarze jeden. To samo dotyczy liczb (np. 1.1), logiki (np. T lub F) lub znaków (np. „A”). Dlatego w istocie łączycie wektory, które z kolei są wektorami.

Zwróć uwagę, że zawsze musisz łączyć podobne wektory. W przeciwnym razie R spróbuje przekonwertować wektory na wektory tego samego typu.

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

Znalezienie elementów w wektorach można wykonać za pomocą [ operatora.

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'

Można to również wykorzystać do zmiany wartości

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

Wreszcie, operator : (skrót od funkcji seq() ) może być użyty do szybkiego utworzenia wektora liczb.

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

Można to również wykorzystać do podzbioru wektorów (od łatwych do bardziej złożonych podzbiorów)

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"

Tworzenie nazwanych wektorów

Nazwany wektor można utworzyć na kilka sposobów. Z c :

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

Co skutkuje w:

> xc
a b c d 
5 6 7 8

z list :

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

Co skutkuje w:

> xl
$a
[1] 5

$b
[1] 6

$c
[1] 7

$d
[1] 8

Dzięki funkcji setNames dwóch wektorów o tej samej długości do utworzenia nazwanego wektora:

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

xy <- setNames(x, y)

co powoduje nazwany wektor liczb całkowitych:

> xy
a b c d 
5 6 7 8

Jak można zobaczyć, daje to taki sam wynik jak metoda c .

Możesz także użyć funkcji names aby uzyskać ten sam wynik:

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

W przypadku takiego wektora możliwe jest również wybieranie elementów według nazwy:

> xy["c"]
c 
7 

Ta funkcja umożliwia użycie takiego nazwanego wektora jako wektora / tabeli przeglądowej w celu dopasowania wartości do wartości innego wektora lub kolumny w ramce danych. Biorąc pod uwagę następującą ramkę danych:

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

> mydf
  let
1   c
2   a
3   b
4   d

Załóżmy, że chcesz utworzyć nową zmienną w mydf mydf o nazwie num z poprawnymi wartościami xy w wierszach. Za pomocą funkcji match wybrać odpowiednie wartości z xy :

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

Co skutkuje w:

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

Rozwijanie wektora za pomocą funkcji rep ()

Funkcji rep można użyć do powtórzenia wektora w dość elastyczny sposób.

# 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

Każdy argument jest szczególnie przydatny do rozszerzenia wektora statystyki jednostek obserwacyjnych / eksperymentalnych na wektor danych. Ramka z powtarzanymi obserwacjami tych jednostek.

# 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

Przyjemną cechą rep dotyczącą włączenia ekspansji do takiej struktury danych jest to, że ekspansję wektora do niezrównoważonego panelu można osiągnąć poprzez zastąpienie argumentu długości wektorem, który określa liczbę powtórzeń każdego elementu w wektorze:

# 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

Powinno to ujawnić możliwość zezwolenia funkcji zewnętrznej na podanie drugiego argumentu rep w celu dynamicznego skonstruowania wektora, który rozwija się zgodnie z danymi.

Podobnie jak w przypadku seq , szybsze, uproszczone wersje rep są rep_len i rep.int . Pozbywają się one niektórych atrybutów, które zachowuje rep a więc mogą być najbardziej przydatne w sytuacjach, w których liczy się szybkość, a dodatkowe aspekty powtarzanego wektora są niepotrzebne.

# 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

Wektory z wbudowanych stałych: Sekwencje liter i nazw miesięcy

R ma wiele wbudowanych stałych. Dostępne są następujące stałe:

• LETTERS : 26 wielkich liter alfabetu rzymskiego
• letters : 26 małych liter alfabetu rzymskiego
• month.abb : trzyliterowe skróty angielskich nazw miesięcy
• month.name : angielskie nazwy miesięcy w roku
• pi : stosunek obwodu koła do jego średnicy

Ze stałych liter i miesięcy można tworzyć wektory.

1) Sekwencje liter:

> 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) Sekwencje skrótów miesięcy lub nazw miesięcy:

> 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"