dataframe - Der Unterschied zwischen Klammer [ ] und doppelte Klammer [[ ]] für den Zugriff auf die Elemente einer Liste oder dataframe

299

R Language Definition ist nützlich für die Beantwortung dieser Art von Fragen:
- http://cran.r-project.org/doc/manuals/R-lang.html#Indexing
R hat drei grundlegende Indizierung Operatoren mit syntax dargestellt durch die folgenden Beispiele
```
    x[i]
    x[i, j]
    x[[i]]
    x[[i, j]]
    x$a
    x$"a"
```
Für Vektoren und Matrizen die [[ Formen werden selten verwendet, obwohl Sie einige geringfügige semantische Unterschiede aus der [ form (z.B. es fällt keine Namen oder dimnames-Attribut, und das partial matching wird für Charakter-Indizes). Bei der Indizierung von multi-dimensionalen Strukturen mit einem einzigen index, x[[i]] oder x[i] zurück ith sequenzielle element x.

Für Listen, die man im Allgemeinen verwendet [[ wählen Sie ein einzelnes element, in der Erwägung, dass [ gibt eine Liste der ausgewählten Elemente.

Die [[ form ermöglicht es, nur ein einziges element ausgewählt werden unter Verwendung der integer-oder character-Indizes, in der Erwägung, dass [ ermöglicht die Indizierung von Vektoren. Beachten Sie aber, dass für eine Liste, kann der index ein Vektor und jedes element des Vektors angewendet, die wiederum auf die Liste der ausgewählten Komponente, die die ausgewählte Komponente, die Komponente, und so weiter. Das Ergebnis ist immer noch ein einzelnes element.
- Was ist der Grund hinter der Verwendung von [[ vs [ zu index mit einer einzigen Zahl vs Vektor? Warum nicht einfach [ für beide? Ich denke, Sie können das [[, um wieder einen einzigen Eintrag, und [ einen index gibt eine Liste der Länge 1,...aber warum nicht nur machen Sie [ return einen einzigen Eintrag mit index, statt eine Liste? Warum könnte Sie schon immer einmal eine Länge-1 Liste zurückgegeben?
- bei der Programmierung können Sie ein Vektor der unbestimmten Länge, die Sie für die Indizierung verwenden möchten. Mit [ immer wieder ein Liste bedeutet, dass Sie erhalten die gleiche Ausgabe Klasse für x[v] unabhängig von der Länge des v. Man könnte beispielsweise wollen lapply über eine Teilmenge einer Liste: lapply(x[v], fun). Wenn [ fallen würde die Liste für Vektoren der Länge ein, dies würde einen Fehler zurück, wenn v hat die Länge eins.
InformationsquelleAutor ars
163

Die signifikanten Unterschiede zwischen den beiden Methoden sind in die Klasse der Objekte, auf die Sie zurückkehren, wenn Sie für die Extraktion und ob Sie akzeptieren können, eine Reihe von Werten, oder nur ein einzelner Wert bei der Zuweisung.

Berücksichtigen Sie bei der Daten-Extraktion auf der folgenden Liste:
```
foo <- list( str='R', vec=c(1,2,3), bool=TRUE )
```
Sagen, wir möchten zum extrahieren der gespeicherten Wert von bool von foo und verwenden Sie es innerhalb einer if() - Anweisung. Dies veranschaulichen die Unterschiede zwischen die Rückgabewerte von [] und [[]] wenn Sie verwendet werden, um Daten zu extrahieren. Die [] - Methode gibt Objekte der Klasse Liste (oder Daten.frame, wenn foo war ein Daten.frame), während der [[]] - Methode gibt Objekte, deren Klasse wird bestimmt durch den Typ Ihrer Werte.

So, mit der [] Methode führt die folgenden:
```
if( foo[ 'bool' ] ){ print("Hi!") }
Error in if (foo["bool"]) { : argument is not interpretable as logical

class( foo[ 'bool' ] )
[1] "list"
```
Dies ist, weil die [] Methode zurückgegeben wird eine Liste, und die Liste ist nicht gültig-Objekt übergeben, direkt in ein if() - Anweisung. In diesem Fall müssen wir mit [[]] da wird es wieder das "Nackte" Objekt, gespeichert in 'bool', die über die entsprechende Klasse:
```
if( foo[[ 'bool' ]] ){ print("Hi!") }
[1] "Hi!"

class( foo[[ 'bool' ]] )
[1] "logical"
```
Der zweite Unterschied ist, dass die [] operator kann verwendet werden, um den Zugriff auf eine Bereich von slots in einer Liste oder der Spalten in einem data frame, während die [[]] operator ist beschränkt auf den Zugriff auf eine single Schlitz oder Spalte. Betrachten wir den Fall von Wert-Zuweisung mit Hilfe einer zweiten Liste bar():
```
bar <- list( mat=matrix(0,nrow=2,ncol=2), rand=rnorm(1) )
```
Sagen, wir wollen, überschreiben die letzten zwei slots foo mit den Angaben in bar. Wenn wir versuchen, die [[]] operator, dies ist, was passiert:
```
foo[[ 2:3 ]] <- bar
Error in foo[[2:3]] <- bar : 
more elements supplied than there are to replace
```
Dies ist, weil [[]] beschränkt sich auf den Zugriff auf ein einzelnes element. Wir müssen []:
```
foo[ 2:3 ] <- bar
print( foo )

$str
[1] "R"

$vec
     [,1] [,2]
[1,]    0    0
[2,]    0    0

$bool
[1] -0.6291121
```
Beachten Sie, dass die Zuordnung erfolgreich war, werden die slots in foo behielten Ihre ursprünglichen Namen.

InformationsquelleAutor Sharpie
105

Doppelte Klammern greift auf eine Liste element, während eine einzelne Klammer gibt Ihnen eine Liste mit einem einzigen element.
```
lst <- list('one','two','three')

a <- lst[1]
class(a)
## returns "list"

a <- lst[[1]]
class(a)
## returns "character"
```
InformationsquelleAutor medriscoll

[] extrahiert eine Liste [[]] extrahiert Elemente innerhalb der Liste

alist <- list(c("a", "b", "c"), c(1,2,3,4), c(8e6, 5.2e9, -9.3e7))

str(alist[[1]])
 chr [1:3] "a" "b" "c"

str(alist[1])
List of 1
 $ : chr [1:3] "a" "b" "c"

str(alist[[1]][1])
 chr "a"

InformationsquelleAutor

45

Von Hadley Wickham:

Mein (scheiß sucht) Modifikation zeigen, mit tidyverse /purrr:
- Cool! Sie haben einige von Grace Hopper einer!
InformationsquelleAutor jzadra
18

Nur hinzufügen, dass hier [[ auch ausgestattet für rekursive Indizierung.

Dies war angedeutet in der Antwort von @JijoMatthew aber nicht erforscht.

Wie bereits in ?"[[" syntax wie x[[y]], wo length(y) > 1 interpretiert werden als:
```
x[[ y[1] ]][[ y[2] ]][[ y[3] ]] ... [[ y[length(y)] ]]
```
Beachten Sie, dass diese nicht ändern, was sollten die wichtigsten mitnehmen auf den Unterschied zwischen [ und [[ -- nämlich, dass der ehemalige wird verwendet für subsetting, und die letztere wird verwendet für extrahieren einzelnen Listen-Elemente.

Beispielsweise
```
x <- list(list(list(1), 2), list(list(list(3), 4), 5), 6)
x
# [[1]]
# [[1]][[1]]
# [[1]][[1]][[1]]
# [1] 1
#
# [[1]][[2]]
# [1] 2
#
# [[2]]
# [[2]][[1]]
# [[2]][[1]][[1]]
# [[2]][[1]][[1]][[1]]
# [1] 3
#
# [[2]][[1]][[2]]
# [1] 4
#
# [[2]][[2]]
# [1] 5
#
# [[3]]
# [1] 6
```
Erhalten den Wert 3, die wir tun können:
```
x[[c(2, 1, 1, 1)]]
# [1] 3
```
Zurück zu @JijoMatthew die Antwort von oben, erinnern r:
```
r <- list(1:10, foo=1, far=2)
```
Insbesondere, das erklärt die Fehler, die wir neigen dazu zu bekommen, wenn mis-mit [[, nämlich:
```
r[[1:3]]
```
Fehler in r[[1:3]] : rekursive Indizierung ist fehlgeschlagen auf Stufe 2

Da dieser code eigentlich versucht zu bewerten r[[1]][[2]][[3]], und die Verschachtelung der r Stoppt bei Stufe eins, den Versuch zu extrahieren, die durch die rekursive Indizierung fehlgeschlagen bei [[2]], d.h., auf der Ebene 2.

Fehler in r[[c("foo", "far")]] : subscript out of bounds

Hier R war auf der Suche nach r[["foo"]][["far"]], die nicht vorhanden ist, so erhalten wir die subscript out of bounds error.

Wäre es wahrscheinlich ein bisschen mehr hilfreich/konsistent, wenn diese beiden Fehler gab die gleiche Meldung.
- Hallo Micheal, sir, können wir mit [[]] für mehrere Indizierung??
InformationsquelleAutor MichaelChirico
13

Beide sind Arten unterteilen.
Die einzige Klammer zurück, die eine Teilmenge der Liste, die in sich selbst eine Liste. dh:Es kann oder kann nicht enthalten, die mehr als ein Element.
Auf der anderen Seite einen doppelten Bügel und zurückkehren wird nur ein einzelnes element aus der Liste.

-Einzelne bracket wird uns eine Liste. Wir können auch eine einzige Klammer, wenn wir zurückkehren wollen mehrere Elemente aus der Liste.
betrachten Sie die folgende Liste:-
```
>r<-list(c(1:10),foo=1,far=2);
```
Nun bitte beachten Sie die Art der Liste wird zurückgegeben, wenn ich versuche, um es anzuzeigen.
Ich geben Sie r ein und drücken Sie die EINGABETASTE
```
>r

#the result is:-

[[1]]

 [1]  1  2  3  4  5  6  7  8  9 10

$foo

[1] 1

$far

[1] 2
```
Nun wir werden sehen, die Magie der einzigen Klammer:-
```
>r[c(1,2,3)]

#the above command will return a list with all three elements of the actual list r as below

[[1]]

 [1]  1  2  3  4  5  6  7  8  9 10

$foo

[1] 1


$far

[1] 2
```
das ist genau das gleiche, wie wenn wir versucht, die Anzeige mit dem Wert von r auf dem Bildschirm, was bedeutet, dass die Verwendung einzelner Klammer hat wieder eine Liste, wo bei index 1 haben wir einen Vektor aus 10 Elementen, dann haben wir zwei weitere Elemente mit Namen foo und weit.
Wir dürfen auch Sie wählen, um einen einzelnen index oder element-Namen als Eingabe für die einzelne Klammer.
eg:
```
> r[1]

[[1]]

 [1]  1  2  3  4  5  6  7  8  9 10
```
In diesem Beispiel Gaben wir einem index "1" ein und bekam eine Liste mit einem element(das ist ein array mit 10 zahlen)
```
> r[2]

$foo

[1] 1
```
Im Beispiel oben haben wir gab ein index "2" ein und bekam eine Liste mit einem element
```
> r["foo"];

$foo

[1] 1
```
In diesem Beispiel übergeben Sie den Namen eines Elements und im Gegenzug eine Liste zurückgegeben wurde mit einem element.

Man kann auch einen Vektor der element-Namen wie:-
```
> x<-c("foo","far")

> r[x];

$foo

[1] 1

$far
[1] 2
```
In diesem Beispiel passierten wir einen Vektor mit zwei-element-Namen "foo" und "weit"

Im Gegenzug bekamen wir eine Liste mit zwei Elementen.

In kurze einzelne bracket wird immer wieder Sie eine weitere Liste mit der Anzahl der Elemente gleich der Anzahl der Elemente oder der Anzahl der Indizes, die Sie übergeben, in der eine einzige Halterung.

Im Gegensatz dazu, eine Doppel-Halterung wird immer wieder nur ein element.
Vor der Umstellung auf die doppelte Klammer ein Hinweis im Auge behalten werden.
NOTE:THE MAJOR DIFFERENCE BETWEEN THE TWO IS THAT SINGLE BRACKET RETURNS YOU A LIST WITH AS MANY ELEMENTS AS YOU WISH WHILE A DOUBLE BRACKET WILL NEVER RETURN A LIST. RATHER A DOUBLE BRACKET WILL RETURN ONLY A SINGLE ELEMENT FROM THE LIST.

Werde ich die Website ein paar Beispiele. Bitte halten Sie eine Notiz, die Worte in Fett-und kommen zurück, um es, nachdem Sie fertig sind mit den folgenden Beispielen:

Doppel-Halterung bringen Sie den tatsächlichen Wert im index.(Es wird NICHT zurückgeben einer Liste)
```
  > r[[1]]

     [1]  1  2  3  4  5  6  7  8  9 10


  >r[["foo"]]

    [1] 1
```
für Doppel-Klammern, wenn wir versuchen uns mehr als ein Element, indem ein Vektor wird zu einem Fehler führen, nur weil es wurde nicht gebaut, um gerecht zu werden zu müssen, aber nur, um ein einzelnes element zurückgeben.

Betrachten Sie die folgenden
```
> r[[c(1:3)]]
Error in r[[c(1:3)]] : recursive indexing failed at level 2
> r[[c(1,2,3)]]
Error in r[[c(1, 2, 3)]] : recursive indexing failed at level 2
> r[[c("foo","far")]]
Error in r[[c("foo", "far")]] : subscript out of bounds
```
- Downvoted weil "die übergabe eines Vektor - ... führt zu einem Fehler, nur weil es wurde nicht gebaut, um gerecht zu werden zu müssen" ist falsch, siehe meine neue Antwort.
- Downvoted, da macht es starke Forderungen wie "WÄHREND EINER DOPPELTEN KLAMMER WIRD NIE wieder EINE LISTE". Es ist nicht wahr - wenn wir haben ein Objekt, Liste, Listen, doppelte Halterung wird die Rückkehr einer anderen Liste.
InformationsquelleAutor Jijo Mathew
12

Um zu helfen Neulinge navigieren Sie durch die manuelle Nebel, es könnte hilfreich sein, um zu sehen, die [[ ... ]] notation als einstürzenden Funktion - in anderen Worten, es ist, wenn Sie nur wollen, um die 'Daten' von einer benannten Vektor, Liste oder Datenrahmen. Es ist gut, dies zu tun, wenn Sie Daten verwenden möchten, die von diesen Objekten für die Berechnungen. Diese einfachen Beispiele verdeutlichen.
```
(x <- c(x=1, y=2)); x[1]; x[[1]]
(x <- list(x=1, y=2, z=3)); x[1]; x[[1]]
(x <- data.frame(x=1, y=2, z=3)); x[1]; x[[1]]
```
Also aus dem Dritten Beispiel:
```
> 2 * x[1]
  x
1 2
> 2 * x[[1]]
[1] 2
```
- Als Neuling fand ich es hilfreich, in der 3 assignments an x (mit "<" -") ersetzen, x=1 mit w=1 zur Vermeidung von Verwechslungen mit dem x, das ist das Ziel von "<-"
InformationsquelleAutor Redfoot
11

Als terminologische, [[ Betreiber Auszüge das element aus einer Liste in der Erwägung, dass [ Betreiber übernimmt Teilmenge einer Liste.

InformationsquelleAutor submartingale
7

Für einen weiteren konkreten Anwendungsfall, verwenden Sie doppelte eckige Klammern, wenn Sie möchten, wählen Sie einen Daten-frame, erstellt von der split() Funktion. Wenn Sie nicht wissen, split() Gruppen eine Liste/Daten-frame in Teilmengen, basierend auf einem Schlüsselfeld. Es ist nützlich, wenn Sie arbeiten wollen, auf mehrere Gruppen, Grundstück, usw.
```
> class(data)
[1] "data.frame"

> dsplit<-split(data, data$id)
> class(dsplit)
[1] "list"

> class(dsplit['ID-1'])
[1] "list"

> class(dsplit[['ID-1']])
[1] "data.frame"
```
InformationsquelleAutor Peter
0

Zusätzlich:

Folgenden die L I N K der A N S W E R hier.

Hier ist ein kleines Beispiel, Adressierung der folgende Punkt:

x[i, j] vs x[[i, j]]
```
df1   <- data.frame(a = 1:3)
df1$b <- list(4:5, 6:7, 8:9)

df1[[1,2]]
df1[1,2]

str(df1[[1,2]])
str(df1[1,2])
```
InformationsquelleAutor Andre Elrico
-1

Entnehmen Sie bitte den unten ausführliche Erklärung.

Habe ich verwendet, Built-in data Frames in R, genannt mtcars.
```
> mtcars 
               mpg cyl disp  hp drat   wt ... 
Mazda RX4     21.0   6  160 110 3.90 2.62 ... 
Mazda RX4 Wag 21.0   6  160 110 3.90 2.88 ... 
Datsun 710    22.8   4  108  93 3.85 2.32 ... 
           ............
```
Der obersten Zeile der Tabelle nennt die Kopfzeile enthält den Namen der Spalten. Jede horizontale Linie danach kennzeichnet eine Daten-Zeile, die beginnt mit den Namen der Zeile, und dann Folgen die eigentlichen Daten.
Jedes Daten-Mitglied eine Zeile, die heißt eine Zelle.

einzelne eckige Klammer "[] " - operator

Abrufen von Daten in einer Zelle, wir würden geben Sie Ihre Zeilen-und Spaltenkoordinaten in der einzelne eckige Klammer "[] " - operator. Die zwei Koordinaten durch ein Komma getrennt werden. In anderen Worten, die Koordinaten beginnen mit der Zeile position, gefolgt von einem Komma und endet mit der Spalte position. Die Reihenfolge ist wichtig.

Eg 1:- Hier wird der Wert der Zelle aus der ersten Zeile, zweiten Spalte der mtcars.
```
> mtcars[1, 2] 
[1] 6
```
Eg 2:- Darüber hinaus können wir die Zeilen-und Spalten-Namen anstelle der numerischen Koordinaten.
```
> mtcars["Mazda RX4", "cyl"] 
[1] 6 
```
Doppelten eckigen Klammern "[[]] " - operator

Wir auf einen Daten-frame-Spalte mit den doppelten eckigen Klammern "[[]] " - operator.

Eg 1:- abrufen der neunten Spalte Vektor der integrierten Datensatz mtcars, wir schreiben mtcars[[9]].

mtcars[[9]]
[1] 1 1 1 0 0 0 0 0 0 0 0 ...

Eg 2: Wir abrufen können, die gleiche Spalten-Vektor durch seinen Namen.

mtcars[["bin"]]
[1] 1 1 1 0 0 0 0 0 0 0 0 ...

InformationsquelleAutor Prasan Karunarathna

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

einzelne eckige Klammer "[] " - operator

Doppelten eckigen Klammern "[[]] " - operator