Einführung in Arrays in R
Wie wir wissen, sind Arrays die Objekte, die zwei oder mehr als zweidimensionale Daten speichern können. In R hat Array dasselbe Konzept, das mit der Funktion array () erstellt wird. Hier werden Daten in Formularmatrizen, Zeilen und Spalten gespeichert. Um auf ein bestimmtes Element aus dem Array zuzugreifen, müssen Sie den Zeilenindex, den Spaltenindex und die Matrixebene angeben.
Matrizen, die häufig in R verwendet werden, sind spezielle Arten von 2D-Arrays.
Bildliche Darstellung: Vektor, Matrix, Array
- Ein dimensionales Array, das als Vektor bezeichnet wird.
- Zweidimensionales Array, das als Matrix bezeichnet wird.
Syntax:
Hier ist die Syntax des Arrays:
Array_NAME <- array (data, dim = (row_Size, column_Size, matrices, dimnames)
- data - Daten sind ein Eingabevektor, der dem Array zugeführt wird.
- Matrizen - Dies bezieht sich auf die Dimensionalität von Matrizen. Array in R können mehrdimensionale Matrizen sein.
- row_Size - row_Size gibt die Anzahl der Zeilen an, aus denen ein Array bestehen wird.
- column_Size - column_Size gibt die Anzahl der Spalten an, aus denen ein Array bestehen wird.
- dimnames - Dieses Feld dient zum Ändern der Standardnamen von Zeilen und Spalten gemäß den Wünschen / Vorlieben des Benutzers.
Eigenschaften:
- Es ist homogen. Dies bedeutet, dass derselbe Datentyp gespeichert werden kann.
- Es speichert Daten in zusammenhängendem Speicher
- Auf Array-Elemente kann durch Kenntnis der Indexnummer zugegriffen werden.
Wie erstelle ich ein Array in R?
Nachfolgend finden Sie verschiedene Szenarien zum Erstellen eines Arrays in r:
Szenario 1:
Erstellen wir ein Array mit 3 × 4 Matrizen. Hier werden 3 Zeilen und 4 Spalten sein, Matrizen werden eins sein. Lassen Sie uns als erste Schritte dimnames = NULL beibehalten (dies ist ein Standardwert, wenn nichts angegeben ist).
Dies ist eine eindimensionale Matrix
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 1)))
Ausgabe:
Um zu überprüfen, ob das endgültig erstellte Array erstellt wurde oder nicht.
Sobald das Array erstellt wurde:
Ergebnis
Die Funktion „Klasse“ kann Ihnen dabei helfen.
Klasse (Ergebnis)
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 1)))
Result <- array(c(vector1, vector2), dim = c(3, 4, 1))
class(Result)
Ausgabe:
Um das Produkt der Dimension des Arrays zu überprüfen, kann die Funktion length verwendet werden.
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 1)))
Result <- array(c(vector1, vector2), dim = c(3, 4, 1))
length(Result)
Ausgabe:
Szenario 2:
Lassen Sie uns das gleiche Array erstellen, das 3 × 4-Matrizen wäre. Auch hier wird 3 eine Zeile und 4 Spalten sein, aber Matrizen werden zwei sein. Behalten wir dimnames = NULL bei (dies ist ein Standardwert, wenn nichts angegeben ist).
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
print(array(c(vector1, vector2), dim = c(3, 4, 2)))
Ausgabe:
Szenario 3:
Lassen Sie uns das gleiche Array erstellen, das 3 × 4-Matrizen wäre. Auch hier sind 3 Zeilen und 4 Spalten, aber Matrizen sind zwei. Schauen wir uns die Werte an, die Dimnames zugewiesen sind.
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names ))
Ausgabe:
Jetzt sind wir gut darin, ein Array beliebiger Dimensionalität zu erstellen. Konzentrieren wir uns nun auf den Zugriff auf ein Element in einem Array.
Wie erstelle ich ein Access Elements-Array in R?
Nachfolgend finden Sie verschiedene Zugriffselemente zum Erstellen eines Arrays in r:
Szenario 1:
Nehmen wir an, wir haben das gleiche Array in R:
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
Ausgabe:
Jetzt müssen wir auf die dritte Zeile und die dritte Spalte der zweiten Matrize im Array zugreifen.
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(3, 3, 2)
Ausgabe:
Um dies zusammenzufassen, werden eckige Klammern verwendet, um einen Index zu bezeichnen. Um den Index in Arrays anzugeben, stehen vier Auswahlmöglichkeiten zur Verfügung: positive Ganzzahlen, negative Ganzzahlen, logische Werte, Elementnamen
Szenario 2:
Man muss auf eine gesamte Matrix des 1. Arrays zugreifen:
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1)
Ausgabe:
Unterschiedlicher Array-Betrieb mit Beispielen
In diesem Abschnitt erhalten Sie einen Überblick über verschiedene Operationen, die an Arrays ausgeführt werden, um verschiedene Ergebnisse zu erzielen.
1. Addition & Subtraktion:
Mehrdimensionale Matrix muss in die eindimensionale Matrix konvertiert werden, um addiert oder subtrahiert zu werden.
- Zusatz:
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) print(result(,, 1) + result(,, 2))
Ausgabe:
- Subtraktion:
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) print(result(,, 1) - result(,, 2))
Ausgabe:
2. Berechnungen für das Array-Element
Ein Funktionsname apply () hilft beim Anwenden von Operationen auf Array-Elemente.
Syntax:
apply(x, margin, fun)
Hier ist x ein Array, der Rand bezieht sich entweder auf Zeilen oder Spalten.
- MARGIN = 1 für zeilenweisen Betrieb
- MARGIN = 2 für spaltenweisen Betrieb
- MARGIN = c (1, 2) für beide.
Spaß ist die Funktion, die auf Elemente im Array des Datenrahmens angewendet wird. Dies können die Standardfunktionen sein, die Teil von R oder benutzerdefinierten Funktionen sind (benutzerdefiniert).
Beispiel 1:
Zeilenweise R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) apply(result(,, 1), 1, sum)
Ausgabe:
Spaltenweise - R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) apply(result(,, 1), 2, sum)
Ausgabe:
Dies ergibt eine Ausgabe in Vektorform, die die Summe der einzelnen Spalten enthält. Hier ist "Summe" die Standard-R-Funktion.
Beispiel 2:
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) apply(result(,, 1), 1, function(x) x+10)
Ausgabe:
Dies ergibt die Ausgabe derselben Dimension. Hier ist zu beachten, dass wir benutzerdefinierte Funktionen angewendet haben. Diese Funktion ist beim Lösen von Problemen in der Praxis sehr nützlich und leistungsstark. Die angewendete Funktion ist auch Basis für andere komplexe Funktionen wie lapply (), rapply () usw.
3. Suchen Sie nach Array
Prüfen Sie, ob das Objekt ein Array ist oder nicht. Der Funktionsname is.array () ist eine einfache Funktion, mit der Sie dies tun können. Die Ausgabe erfolgt in den Begriffen True oder False
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
result(,, 1) result(,, 2) is.array(result)
Ausgabe:
4. Überprüfen Sie die Größe des Arrays
Die Kenntnis der Dimensionalität, einer Reihe von Zeilen und Spalten des Arrays hilft beim Schneiden und Schneiden von Daten. Hier sind einige Funktionen, um dies zu tun: dim, nrow, ncol
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
result <- array(c(vector1, vector2), dim = c(3, 4, 2))
print(result)
dim(result)
nrow(result)
ncol(result)
Ausgabe:
5. Überprüfen Sie die Namen der Zeilen und Spalten
Um die Namen von Zeilen, Spalten und Dimensionsnamen eines Arrays zu kennen. Unten sehen Sie die gezeigte Implementierung.
R-Code:
vector1 <- c(2, 18, 30)
vector2 <- c(10, 14, 17, 13, 11, 15, 22, 11, 33)
column.names <- c("COL1", "COL2", "COL3", "COL4")
row.names <- c("ROW1", "ROW2", "ROW3")
matrix.names <- c("Matrix1", "Matrix2")
result <- array(c(vector1, vector2), dim = c(3, 4, 2), dimnames = list(row.names, column.names,
matrix.names))
rownames(result)
colnames(result)
dimnames(result)
Ausgabe:
Fazit:
Das Durchgehen des obigen Inhalts hätte Ihnen ein klares Verständnis der Arrays in R gegeben. R ist eine statistische Sprache, und Arrays sind häufig verwendete Datenobjekte. Das bedeutet, dass das Arbeiten mit verschiedenen Operationen wie Addieren, Subtrahieren, Anwenden usw. mit einem Array in einer beliebigen Anwendung für Sie jetzt ein Kinderspiel ist.
Empfohlene Artikel
Dies war ein Leitfaden für Array in R. Hier wird eine Einführung in Arrays in R, Eigenschaften von R, das Erstellen eines Arrays in R und einige Beispielbeispiele beschrieben. Sie können auch unsere anderen Artikelvorschläge durchgehen, um mehr zu erfahren -
- Installieren Sie R
- VBA-Arrays
- Datentypen in MATLAB
- VBA ArrayList
- Arrays in PHP