R Language
Vektoren erstellen

Zahlenfolge

Verwenden Sie die : Operatorsequenzen von Zahlen zu erzeugen, wie zum Beispiel für den Einsatz in Vektorisierung größere Brocken des Codes:

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

Dies funktioniert in beide Richtungen

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

und sogar mit Fließkommazahlen

1.25:5
# [1] 1.25 2.25 3.25 4.25

oder Negative

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

seq ()

seq ist eine flexiblere Funktion als der : Bediener ermöglicht zu spezifizieren Schritte außer 1.

Die Funktion erstellt eine Sequenz vom start (Standardeinstellung ist 1) bis zum Ende, einschließlich dieser Nummer.

Sie können nur den Endparameter ( to ) angeben

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

Ebenso wie der Start

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

Und zum Schluss der Schritt ( 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 kann optional auf die (gleichmäßig beabstandeten) Schritte schließen, wenn alternativ die gewünschte Länge des Ausgangs ( length.out ) geliefert wird

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

Wenn die Sequenz die gleiche Länge wie ein anderer Vektor haben muss, können Sie die along.with als Abkürzung 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

Es gibt zwei nützliche vereinfachte Funktionen in der seq Familie: seq_along , seq_len und seq.int . seq_along Funktionen seq_along und seq_len konstruieren die natürlichen seq_len von 1 bis N, wobei N durch das Funktionsargument, die Länge eines Vektors oder einer Liste mit seq_along und das Ganzzahlargument mit seq_len .

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

Beachten Sie, dass seq_along die Indizes eines vorhandenen Objekts zurückgibt.

# 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 ist das gleiche wie seq , das für alte Kompatibilität beibehalten wurde.

Es gibt auch eine alte sequence , die einen Vektor von Sequenzen aus einem nicht negativen Argumente erzeugt.

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

Vektoren

Vektoren in R können verschiedene Typen haben (z. B. Ganzzahl, logisch, Zeichen). Die allgemeinste Art, einen Vektor zu definieren, ist die Verwendung des Funktionsvektors 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.

In R sind die Abkürzungsfunktionen jedoch allgemein beliebter.

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

Das Erstellen von Vektoren mit anderen Werten als den Standardwerten ist ebenfalls möglich. Oft wird dazu die Funktion c() verwendet. Das c steht für kombinieren oder verketten.

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.

Hierbei ist zu beachten, dass R eine ganze Zahl (zB 1) als Ganzzahlvektor der Größe Eins interpretiert. Gleiches gilt für Numerik (zB 1.1), Logische (zB T oder F) oder Zeichen (zB 'a'). Daher kombinieren Sie im Wesentlichen Vektoren, die wiederum Vektoren sind.

Achten Sie darauf, dass Sie immer ähnliche Vektoren kombinieren müssen. Andernfalls versucht R, die Vektoren in Vektoren desselben Typs zu konvertieren.

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

Das Finden von Elementen in Vektoren kann mit dem Operator [ werden.

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'

Dies kann auch zum Ändern von Werten verwendet werden

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

Schließlich kann mit dem Operator : (kurz für die Funktion seq() ) schnell ein Zahlenvektor erstellt werden.

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

Dies kann auch verwendet werden, um Vektoren zu subsetieren (von einfachen zu komplexeren Subsets).

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"

Benannte Vektoren erstellen

Der benannte Vektor kann auf verschiedene Arten erstellt werden. Mit c :

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

was in ... resultiert:

> xc
a b c d 
5 6 7 8

mit list :

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

was in ... resultiert:

> xl
$a
[1] 5

$b
[1] 6

$c
[1] 7

$d
[1] 8

Mit der Funktion setNames können zwei Vektoren gleicher Länge verwendet werden, um einen benannten Vektor zu erstellen:

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

xy <- setNames(x, y)

was zu einem benannten Integer-Vektor führt:

> xy
a b c d 
5 6 7 8

Wie zu sehen ist, ergibt dies das gleiche Ergebnis wie die c Methode.

Sie können auch die names Funktion verwenden, um dasselbe Ergebnis zu erhalten:

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

Mit einem solchen Vektor ist es auch möglich, Elemente nach Namen auszuwählen:

> xy["c"]
c 
7 

Dieses Merkmal ermöglicht die Verwendung eines solchen benannten Vektors als Nachschlagvektor / -tabelle, um die Werte mit den Werten eines anderen Vektors oder einer anderen Spalte im Datenrahmen abzugleichen. Betrachten Sie den folgenden Datenrahmen:

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

> mydf
  let
1   c
2   a
3   b
4   d

Angenommen, Sie möchten eine neue Variable mit dem Namen num mit den korrekten Werten aus xy in den Zeilen im mydf Datenrahmen erstellen. Mit der match Funktion können die entsprechenden Werte von xy ausgewählt werden:

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

was in ... resultiert:

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

Erweitern eines Vektors mit der Funktion rep ()

Die Funktion rep kann verwendet werden, um einen Vektor ziemlich flexibel zu wiederholen.

# 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

Jedes Argument ist besonders nützlich für die Erweiterung eines Statistikvektors von Beobachtungs- / Experimentaleinheiten in einen Vektorvektor mit wiederholten Beobachtungen dieser Einheiten.

# 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

rep Bezug auf die Erweiterung einer solchen Datenstruktur besonders interessant, da die Erweiterung eines Vektors zu einem unsymmetrischen Feld erreicht werden kann, indem das Längenargument durch einen Vektor ersetzt wird, der die Anzahl der Wiederholungen jedes Elements im Vektor festlegt:

# 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

Dies sollte die Möglichkeit aufzeigen, dass eine externe Funktion das zweite Argument von rep , um dynamisch einen Vektor zu konstruieren, der sich entsprechend den Daten ausdehnt.

Wie bei seq sind schnellere, vereinfachte Versionen von rep rep_len und rep.int . Dadurch werden einige Attribute rep , die von rep beibehalten werden. rep kann es in Situationen, in denen Geschwindigkeit von Belang ist und zusätzliche Aspekte des wiederholten Vektors nicht erforderlich sind, am nützlichsten sein.

# 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

Vektoren von eingebauten Konstanten: Folgen von Buchstaben und Monatsnamen

R hat eine Reihe von eingebauten Konstanten. Folgende Konstanten stehen zur Verfügung:

• LETTERS : die 26 Großbuchstaben des römischen Alphabets
• letters : die 26 Kleinbuchstaben des römischen Alphabets
• month.abb : Die aus drei Buchstaben bestehenden Abkürzungen für die englischen Monatsnamen
• month.name : die englischen Namen für die Monate des Jahres
• pi : das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser

Aus den Buchstaben und Monatskonstanten können Vektoren erstellt werden.

1) Buchstabenfolgen:

> 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) Sequenzen von Monatsabkürzungen oder Monatsnamen:

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