R Language
Datenrahmen

Syntax

• data.frame (..., row.names = NULL, check.rows = FALSE, check.names = TRUE, stringsAsFactors = default.stringsAsFactors ())

• as.data.frame (x, row.names = NULL, optional = FALSE, ...) # generische Funktion

• as.data.frame (x, ..., stringsAsFactors = default.stringsAsFactors ()) # S3-Methode für Klasse 'Zeichen'

• as.data.frame (x, row.names = NULL, optional = FALSE, ..., stringsAsFactors = default.stringsAsFactors ()) # S3-Methode für Klasse 'Matrix'

• is.data.frame (x)

Erstellen Sie ein leeres data.frame

Ein Datenrahmen ist eine besondere Art von Liste: sie ist rechteckig . Jedes Element (Spalte) der Liste hat dieselbe Länge und jede Zeile hat einen "Zeilennamen". Jede Spalte hat ihre eigene Klasse, aber die Klasse einer Spalte kann sich von der Klasse einer anderen Spalte unterscheiden (im Gegensatz zu einer Matrix, bei der alle Elemente dieselbe Klasse haben müssen).

Ein data.frame kann grundsätzlich keine Zeilen und keine Spalten haben:

> structure(list(character()), class = "data.frame")
NULL
<0 rows> (or 0-length row.names)

Das ist aber ungewöhnlich. Es ist üblicher, dass ein data.frame viele Spalten und viele Zeilen hat. Hier ist ein Datenrahmen mit drei Zeilen und zwei Spalten ( a ist numerische Klasse und b ist Zeichenklasse):

> structure(list(a = 1:3, b = letters[1:3]), class = "data.frame")
[1] a b
<0 rows> (or 0-length row.names)

Damit der data.frame gedruckt werden kann, müssen wir einige Zeilennamen angeben. Hier verwenden wir nur die Zahlen 1: 3:

> structure(list(a = 1:3, b = letters[1:3]), class = "data.frame", row.names = 1:3)
  a b
1 1 a
2 2 b
3 3 c

Jetzt wird es offensichtlich, dass wir einen Datenrahmen mit 3 Zeilen und 2 Spalten haben. Sie können dies mit nrow() , ncol() und dim() überprüfen:

> x <- structure(list(a = numeric(3), b = character(3)), class = "data.frame", row.names = 1:3)
> nrow(x)
[1] 3
> ncol(x)
[1] 2
> dim(x)
[1] 3 2

R bietet zwei weitere Funktionen (neben structure() ), mit denen ein data.frame erstellt werden kann. Die erste heißt intuitiv data.frame() . Es überprüft, ob die von Ihnen angegebenen Spaltennamen gültig sind, dass die Listenelemente alle die gleiche Länge haben, und liefert einige automatisch generierte Zeilennamen. Das bedeutet, dass die Ausgabe von data.frame() jetzt immer genau das ist, was Sie erwarten:

> str(data.frame("a a a" = numeric(3), "b-b-b" = character(3)))
'data.frame':   3 obs. of  2 variables:
 $ a.a.a: num  0 0 0
 $ b.b.b: Factor w/ 1 level "": 1 1 1

Die andere Funktion heißt as.data.frame() . Dies kann verwendet werden, um ein Objekt, das kein data.frame ist, zu einem data.frame zu zwingen, indem es durch data.frame() . Als Beispiel betrachten wir eine Matrix:

> m <- matrix(letters[1:9], nrow = 3)
> m
     [,1] [,2] [,3]
[1,] "a"  "d"  "g" 
[2,] "b"  "e"  "h" 
[3,] "c"  "f"  "i" 

Und das Ergebnis:

> as.data.frame(m)
  V1 V2 V3
1  a  d  g
2  b  e  h
3  c  f  i
> str(as.data.frame(m))
'data.frame':   3 obs. of  3 variables:
 $ V1: Factor w/ 3 levels "a","b","c": 1 2 3
 $ V2: Factor w/ 3 levels "d","e","f": 1 2 3
 $ V3: Factor w/ 3 levels "g","h","i": 1 2 3

Zeilen und Spalten aus einem Datenrahmen subetting

Syntax für Zeilen und Spalten zuzugreifen: [ , [[ und $

In diesem Thema wird die am häufigsten verwendete Syntax für den Zugriff auf bestimmte Zeilen und Spalten eines Datenrahmens behandelt. Diese sind

• Wie eine matrix mit data[rows, columns] Klammern data[rows, columns]
  • Verwenden Sie Zeilen- und Spaltennummern
  • Spalten- (und Zeilen-) Namen verwenden
• Wie eine list :
  • Mit einfachen Klammern data[columns] , um einen Datenrahmen zu erhalten
  • Mit doppelten Klammern data[[one_column]] erhalten Sie einen Vektor
• Mit $ für eine einzelne Spalte data$column_name

Wir werden den eingebauten mtcars - mtcars zur Veranschaulichung verwenden.

Wie eine Matrix: data[rows, columns]

Mit numerischen Indizes

Mithilfe der integrierten mtcars können Zeilen und Spalten mit [] mtcars mit einem Komma extrahiert werden. Indizes vor dem Komma sind Zeilen:

# get the first row
mtcars[1, ]
# get the first five rows
mtcars[1:5, ]

Ähnlich sind nach dem Komma Spalten:

# get the first column
mtcars[, 1]
# get the first, third and fifth columns:
mtcars[, c(1, 3, 5)]

Wie oben gezeigt, werden alle Zeilen ausgewählt, wenn entweder Zeilen oder Spalten leer bleiben. mtcars[1, ] gibt die erste Zeile mit allen Spalten an.

Mit Spaltennamen (und Zeilennamen)

Dies ist bisher identisch mit dem Zugriff auf Zeilen und Spalten von Matrizen. Bei data.frame s ist es meistens vorzuziehen, einen Spaltennamen für einen Spaltenindex zu verwenden. Dies geschieht durch die Verwendung eines character mit dem Spaltennamen anstelle von numeric mit einer Spaltennummer:

# get the mpg column
mtcars[, "mpg"]
# get the mpg, cyl, and disp columns
mtcars[, c("mpg", "cyl", "disp")]

Obwohl weniger üblich, können auch Zeilennamen verwendet werden:

mtcars["Mazda Rx4", ]

Zeilen und Spalten zusammen

Die Zeilen- und Spaltenargumente können zusammen verwendet werden:

# first four rows of the mpg column
mtcars[1:4, "mpg"]

# 2nd and 5th row of the mpg, cyl, and disp columns
mtcars[c(2, 5), c("mpg", "cyl", "disp")]

Eine Warnung zu den Abmessungen:

Wenn Sie mit diesen Methoden mehrere Spalten extrahieren, erhalten Sie einen Datenrahmen zurück. Wenn Sie jedoch eine einzelne Spalte extrahieren, wird unter den Standardoptionen ein Vektor und kein Datenrahmen angezeigt.

## multiple columns returns a data frame
class(mtcars[, c("mpg", "cyl")])
# [1] "data.frame"
## single column returns a vector
class(mtcars[, "mpg"])
# [1] "numeric"

Es gibt zwei Möglichkeiten, dies zu umgehen. Eine besteht darin, den Datenrahmen als Liste zu behandeln (siehe unten), die andere besteht darin, das Argument drop = FALSE hinzuzufügen. Dies weist R an, "die nicht verwendeten Dimensionen nicht zu löschen":

class(mtcars[, "mpg", drop = FALSE])
# [1] "data.frame"

Beachten Sie, dass Matrizen auf dieselbe Weise funktionieren. Standardmäßig ist eine einzelne Spalte oder Zeile ein Vektor. Wenn Sie drop = FALSE angeben drop = FALSE können Sie sie als einspaltige oder einzeilige Matrix beibehalten.

Wie eine Liste

Datenframes sind im Wesentlichen list , dh sie sind eine Liste von Spaltenvektoren (die alle dieselbe Länge haben müssen). Listen können mit einfachen Klammern [ für eine Unterliste oder mit doppelten Klammern [[ für ein einzelnes Element] Teilmengen sein.

Mit Klammern data[columns]

Wenn Sie einfache Klammern und keine Kommas verwenden, erhalten Sie die Spalte zurück, da Datenrahmen Spaltenlisten sind.

mtcars["mpg"]
mtcars[c("mpg", "cyl", "disp")]
my_columns <- c("mpg", "cyl", "hp")
mtcars[my_columns]

Der Unterschied zwischen data[columns] und data[, columns] besteht darin, dass bei der Behandlung von data.frame als list (kein Komma in Klammern) das zurückgegebene Objekt ein data.frame . Wenn Sie den data.frame mit einem Komma wie eine matrix behandeln, wird beim Auswählen einer einzelnen Spalte ein Vektor zurückgegeben. Wenn Sie jedoch mehrere Spalten auswählen, wird ein data.frame .

## When selecting a single column
## like a list will return a data frame
class(mtcars["mpg"])
# [1] "data.frame"
## like a matrix will return a vector
class(mtcars[, "mpg"])
# [1] "numeric"

Mit doppelten Klammern data[[one_column]]

Um eine einzelne Spalte als Vektor zu extrahieren, wenn Sie Ihren data.frame als list , können Sie doppelte Klammern [[ . Dies funktioniert nur für eine einzelne Spalte.

# extract a single column by name as a vector 
mtcars[["mpg"]]

# extract a single column by name as a data frame (as above)
mtcars["mpg"]

Mit $ auf Spalten zugreifen

Eine einzelne Spalte kann mit der magischen Verknüpfung $ extrahiert werden, ohne einen in Anführungszeichen gesetzten Spaltennamen zu verwenden:

# get the column "mpg"
mtcars$mpg

Spalten, auf die mit $ zugegriffen wird, sind immer Vektoren und keine Datenrahmen.

Nachteile von $ für den Zugriff auf Spalten

Das $ kann eine bequeme Verknüpfung sein, insbesondere wenn Sie in einer Umgebung arbeiten (z. B. RStudio), die in diesem Fall den Spaltennamen automatisch vervollständigt. $ Hat jedoch auch Nachteile: Es verwendet eine nicht standardmäßige Bewertung , um die Notwendigkeit von Anführungszeichen zu vermeiden. Dies bedeutet, dass es nicht funktioniert, wenn der Spaltenname in einer Variablen gespeichert ist.

my_column <- "mpg"
# the below will not work
mtcars$my_column
# but these will work
mtcars[, my_column]  # vector
mtcars[my_column]    # one-column data frame
mtcars[[my_column]]  # vector

Aufgrund dieser Bedenken wird $ am besten in interaktiven R-Sitzungen verwendet, wenn die Spaltennamen konstant sind. Für den programmatischen Gebrauch, beispielsweise beim Schreiben einer verallgemeinerbaren Funktion, die für verschiedene Datensätze mit unterschiedlichen Spaltennamen verwendet wird, sollte $ vermieden werden.

Beachten Sie außerdem, dass das Standardverhalten darin besteht, partiellen Abgleich nur beim Extrahieren von rekursiven Objekten (außer Umgebungen) mit $

# give you the values of "mpg" column 
# as "mtcars" has only one column having name starting with "m"
mtcars$m 
# will give you "NULL" 
# as "mtcars" has more than one columns having name starting with "d"
mtcars$d

Erweiterte Indexierung: Negative und logische Indizes

Wenn wir die Option haben, Zahlen für einen Index zu verwenden, können wir auch negative Zahlen verwenden, um bestimmte Indizes wegzulassen, oder einen booleschen (logischen) Vektor, um genau anzugeben, welche Elemente beibehalten werden sollen.

Negative Indizes lassen Elemente aus

mtcars[1, ]   # first row
mtcars[ -1, ] # everything but the first row
mtcars[-(1:10), ] # everything except the first 10 rows

Logische Vektoren zeigen bestimmte Elemente an, die beibehalten werden sollen

Wir können eine Bedingung wie < , um einen logischen Vektor zu generieren und nur die Zeilen zu extrahieren, die die Bedingung erfüllen:

# logical vector indicating TRUE when a row has mpg less than 15
# FALSE when a row has mpg >= 15
test <- mtcars$mpg < 15 

# extract these rows from the data frame 
mtcars[test, ]

Wir können den Schritt des Speicherns der Zwischenvariablen auch umgehen

# extract all columns for rows where the value of cyl is 4.
mtcars[mtcars$cyl == 4, ]
# extract the cyl, mpg, and hp columns where the value of cyl is 4
mtcars[mtcars$cyl == 4, c("cyl", "mpg", "hp")]

Komfortfunktionen zum Bearbeiten von data.frames

Einige praktische Funktionen zum Bearbeiten von data.frames sind subset() , transform() , with() und within() .

Teilmenge

Mit der Funktion subset() können Sie einen data.frame bequemer data.frame (subset funktioniert auch mit anderen Klassen):

subset(mtcars, subset = cyl == 6, select = c("mpg", "hp"))
                mpg  hp
Mazda RX4      21.0 110
Mazda RX4 Wag  21.0 110
Hornet 4 Drive 21.4 110
Valiant        18.1 105
Merc 280       19.2 123
Merc 280C      17.8 123
Ferrari Dino   19.7 175

Im obigen Code fragen wir nur nach den Zeilen, in denen cyl == 6 und nach den Spalten mpg und hp . Sie können dasselbe Ergebnis erzielen, indem Sie [] mit dem folgenden Code verwenden:

mtcars[mtcars$cyl == 6, c("mpg", "hp")]

verwandeln

Die Funktion transform() ist eine praktische Funktion zum Ändern von Spalten in einem data.frame . Im folgenden Code wird dem mtcars data.frame beispielsweise eine weitere Spalte mit dem Namen mpg2 mit dem Ergebnis von mpg^2 data.frame :

mtcars <- transform(mtcars, mpg2 = mpg^2)

mit und innerhalb

Sowohl with() als auch within() Sie Ausdrücke in der Umgebung von data.frame auswerten. data.frame ermöglicht eine etwas sauberere Syntax und erspart Ihnen die Verwendung von $ oder [] .

Wenn Sie beispielsweise mehrere Spalten im airquality data.frame erstellen, ändern und / oder entfernen data.frame :

aq <- within(airquality, {     
    lOzone <- log(Ozone) # creates new column
    Month <- factor(month.abb[Month]) # changes Month Column
    cTemp <- round((Temp - 32) * 5/9, 1) # creates new column
    S.cT <- Solar.R / cTemp  # creates new column
    rm(Day, Temp) # removes columns
})

Einführung

Datenrahmen sind wahrscheinlich die Datenstruktur, die Sie in Ihren Analysen am häufigsten verwenden. Ein Datenrahmen ist eine spezielle Art von Liste, in der Vektoren gleicher Länge unterschiedlicher Klassen gespeichert sind. Sie erstellen Datenrahmen mit der Funktion data.frame . Das folgende Beispiel zeigt dies, indem ein numerischer und ein Zeichenvektor in einem Datenrahmen kombiniert werden. Es nutzt den : Operator, der einen Vektor erstellen alle Zahlen von 1 bis 3.

df1 <- data.frame(x = 1:3, y = c("a", "b", "c"))
df1
##   x y
## 1 1 a
## 2 2 b
## 3 3 c
class(df1)
## [1] "data.frame"

Datenrahmenobjekte werden nicht mit Anführungszeichen gedruckt, sodass die Klasse der Spalten nicht immer offensichtlich ist.

df2 <- data.frame(x = c("1", "2", "3"), y = c("a", "b", "c"))
df2
##   x y
## 1 1 a
## 2 2 b
## 3 3 c

Ohne weitere Untersuchung können die "x" -Spalten in df1 und df2 nicht unterschieden werden. Mit der str Funktion können Objekte detaillierter als Klassen beschrieben werden.

str(df1)
## 'data.frame':    3 obs. of  2 variables:
##  $ x: int  1 2 3
##  $ y: Factor w/ 3 levels "a","b","c": 1 2 3
str(df2)
## 'data.frame':    3 obs. of  2 variables:
##  $ x: Factor w/ 3 levels "1","2","3": 1 2 3
##  $ y: Factor w/ 3 levels "a","b","c": 1 2 3

Hier sehen Sie , dass df1 a data.frame und hat 3 Beobachtungen von 2 Variablen „x“ und „y“ . Dann wird Ihnen gesagt, dass "x" den Datentyp Integer hat (nicht wichtig für diese Klasse, aber für unsere Zwecke verhält es sich wie eine Zahl) und "y" ist ein Faktor mit drei Ebenen (eine andere Datenklasse, über die wir nicht sprechen). Es ist wichtig zu beachten, dass Datenrahmen standardmäßig Zeichen zu Faktoren zwingen. Das Standardverhalten kann mit dem Parameter stringsAsFactors geändert werden:

df3 <- data.frame(x = 1:3, y = c("a", "b", "c"), stringsAsFactors = FALSE)
str(df3)
## 'data.frame':    3 obs. of  2 variables:
##  $ x: int  1 2 3
##  $ y: chr  "a" "b" "c"

Jetzt ist die Spalte "y" ein Zeichen. Wie oben erwähnt, muss jede "Spalte" eines Datenrahmens dieselbe Länge haben. Der Versuch, ein data.frame aus Vektoren mit unterschiedlichen Längen zu erstellen, führt zu einem Fehler. (Führen Sie data.frame(x = 1:3, y = 1:4) , um den resultierenden Fehler data.frame(x = 1:3, y = 1:4) .)

Als Testfälle für Datenrahmen werden einige Daten standardmäßig von R bereitgestellt. Eine davon ist Iris, die wie folgt geladen wird:

mydataframe <- iris
str(mydataframe)

Konvertieren Sie mit do.call in einer Liste gespeicherte Daten in einen einzelnen Datenrahmen

Wenn Sie Ihre Daten in einer Liste gespeichert haben und diese Liste in einen do.call konvertieren möchten, können Sie dies mit der do.call Funktion do.call . Es ist jedoch wichtig, dass alle Listenelemente die gleiche Länge haben, um ein unbeabsichtigtes Wiederverwenden von Werten zu verhindern.

dataList  <- list(1:3,4:6,7:9)  
dataList
# [[1]]
# [1] 1 2 3
#
# [[2]]
# [1] 4 5 6
#
# [[3]]
# [1] 7 8 9

dataframe <- data.frame(do.call(rbind, dataList))
dataframe
#   X1 X2 X3
# 1  1  2  3
# 2  4  5  6
# 3  7  8  9 

Es funktioniert auch, wenn Ihre Liste selbst aus Datenrahmen besteht.

dataframeList  <- list(data.frame(a = 1:2, b = 1:2, c = 1:2), 
                       data.frame(a = 3:4, b = 3:4, c = 3:4))
dataframeList
# [[1]]
#   a b c
# 1 1 1 1
# 2 2 2 2

# [[2]]
#   a b c
# 1 3 3 3
# 2 4 4 4

dataframe      <- do.call(rbind, dataframeList)
dataframe
#   a b c
# 1 1 1 1
# 2 2 2 2
# 3 3 3 3
# 4 4 4 4

Konvertieren Sie alle Spalten eines data.frame in eine Zeichenklasse

Eine übliche Aufgabe besteht darin, alle Spalten eines data.frames zur Erleichterung der Bearbeitung in eine Zeichenklasse zu konvertieren, z. B. beim Senden von data.frames an ein RDBMS oder beim Zusammenführen von data.frames, die Faktoren enthalten, bei denen die Ebenen zwischen den eingegebenen data.frames variieren können .

Die beste Zeit dafür ist, wenn die Daten eingelesen werden. Fast alle Eingabemethoden, die Datenrahmen erstellen, verfügen über stringsAsFactors die auf FALSE .

Wenn die Daten bereits erstellt wurden, können Faktorspalten wie unten dargestellt in Zeichenspalten konvertiert werden.

bob <- data.frame(jobs = c("scientist", "analyst"), 
                  pay  = c(160000, 100000), age = c(30, 25))
str(bob)

'data.frame':    2 obs. of  3 variables:
 $ jobs: Factor w/ 2 levels "analyst","scientist": 2 1
 $ pay : num  160000 100000
 $ age : num  30 25

# Convert *all columns* to character
bob[] <- lapply(bob, as.character)
str(bob)

    'data.frame':    2 obs. of  3 variables:
 $ jobs: chr  "scientist" "analyst"
 $ pay : chr  "160000" "1e+05"
 $ age : chr  "30" "25"

# Convert only factor columns to character
bob[] <- lapply(bob, function(x) {
    if is.factor(x) x <- as.character(x)
    return(x)
})

Zeilen nach Spaltenwerten unterteilen

Integrierte Funktionen können rows mit columns , die die Bedingungen erfüllen.

df <- data.frame(item = c(1:10),
                 price_Elasticity = c(-0.57667, 0.03205, -0.04904, 0.10342, 0.04029, 
                                       0.0742, 0.1669, 0.0313, 0.22204, 0.06158),
                 total_Margin = c(-145062, 98671, 20576, -56382, 207623, 43463, 1235, 
                                   34521, 146553, -74516))

So finden Sie rows mit price_Elasticity > 0 :

df[df$price_Elasticity > 0, ]

   item price_Elasticity total_Margin
2     2          0.03205        98671
4     4          0.10342       -56382
5     5          0.04029       207623
6     6          0.07420        43463
7     7          0.16690         1235
8     8          0.03130        34521
9     9          0.22204       146553
10   10          0.06158       -74516

Teilmenge basierend auf price_Elasticity > 0 und total_Margin > 0 :

df[df$price_Elasticity > 0 & df$total_Margin > 0, ]

  item price_Elasticity total_Margin
2    2          0.03205        98671
5    5          0.04029       207623
6    6          0.07420        43463
7    7          0.16690         1235
8    8          0.03130        34521
9    9          0.22204       146553