Jak poprawnie używać list w R?

Jeśli chodzi o Twoje pytania, pozwól mi zająć się nimi w kolejności i podać kilka przykładów:

1) lista jest zwracana, jeśli i kiedy Instrukcja return dodaje ją. Consider

 R> retList <- function() return(list(1,2,3,4)); class(retList())
 [1] "list"
 R> notList <- function() return(c(1,2,3,4)); class(notList())
 [1] "numeric"
 R> 

2) nazwy po prostu nie są ustawione:

R> retList <- function() return(list(1,2,3,4)); names(retList())
NULL
R> 

3) nie zwracają tego samego. Twój przykład daje

R> x <- list(1,2,3,4)
R> x[1]
[[1]]
[1] 1
R> x[[1]]
[1] 1

Gdzie x[1] zwraca pierwszy element x -- który jest taki sam jak x. Każdy Skalar jest wektorem długości jedynki. Z drugiej strony x[[1]] zwraca pierwszy element listy.

4) W końcu te dwa elementy różnią się między sobą, tworząc odpowiednio listę zawierającą cztery Skalary i listę z jednym elementem (który jest wektorem czterech elementów).

Wystarczy wziąć podzbiór twoich pytań:

Ten artykuł na temat indeksowania porusza kwestię różnicy między [] i [[]].

W skrócie [[]] wybiera pojedynczy element z listy i [] zwraca listę wybranych elementów. W twoim przykładzie x = list(1, 2, 3, 4)' Pozycja 1 jest pojedynczą liczbą całkowitą, ale x[[1]] zwraca pojedynczą liczbę 1, A x[1] zwraca listę z tylko jedną wartością.

> x = list(1, 2, 3, 4)
> x[1]
[[1]]
[1] 1

> x[[1]]
[1] 1

Jednym z powodów, dla których listy działają tak, jak one (uporządkowane), jest zaspokojenie potrzeby uporządkowanego kontenera, który może zawierać dowolny typ w dowolnym węźle, czego wektory nie robią. Listy są ponownie używane do różnych celów w R, w tym tworząc bazę data.frame, która jest listą wektorów dowolnego typu (ale tej samej długości).

Dlaczego te dwa wyrażenia nie zwracają tego samego wyniku?

x = list(1, 2, 3, 4); x2 = list(1:4)

Aby dodać do odpowiedzi @ Shane, jeśli chcesz uzyskać taki sam wynik, try:

x3 = as.list(1:4)

, który wymusza wektor 1:4 na listę.

Aby dodać jeszcze jeden punkt do tego:

R ma strukturę danych równoważną dict Pythona w hash pakiecie . Możesz przeczytać o tym w ten wpis na blogu z grupy Open Data . Oto prosty przykład:

> library(hash)
> h <- hash( keys=c('foo','bar','baz'), values=1:3 )
> h[c('foo','bar')]
<hash> containing 2 key-value pairs.
  bar : 2
  foo : 1

Pod względem użyteczności, Klasa hash jest bardzo podobna do listy. Ale wydajność jest lepsza dla dużych zbiorów danych.

Mówisz:

Dla innego, listy mogą być zwracane z funkcji, mimo że nigdy przekazane na liście, gdy zadzwoniłeś do funkcja, a mimo to funkcja nie zawiera konstruktora listy, np.,

x = strsplit(LETTERS[1:10], "") # passing in an object of type 'character'
class(x)
# => 'list'

I chyba sugerujesz, że to jest problem(?). Jestem tutaj, aby powiedzieć, dlaczego to nie problem : -). Twój przykład jest nieco prosty, ponieważ kiedy wykonujesz podział łańcuchów, masz listę z elementami o długości 1 elementu, więc wiesz że x[[1]] jest tym samym co unlist(x)[1]. Ale co, jeśli wynik strsplit zwróci wyniki o różnej długości w każdym pojemniku. Po prostu zwrócenie wektora (a listy) w ogóle nie zadziała.

Na przykład:

stuff <- c("You, me, and dupree",  "You me, and dupree",
           "He ran away, but not very far, and not very fast")
x <- strsplit(stuff, ",")
xx <- unlist(strsplit(stuff, ","))

W pierwszym przypadku (x : który zwraca listę), możesz określić, jaka była druga "część" trzeciego łańcucha, np.: x[[3]][2]. Jak możesz zrobić to samo używając xx Teraz, gdy wyniki zostały "rozwikłane" (unlist-ed)?

x = list(1, 2, 3, 4)
x2 = list(1:4)
all.equal(x,x2)

Nie jest tym samym, ponieważ 1: 4 jest tym samym co c (1,2,3,4). Jeśli chcesz, żeby były takie same to:

x = list(c(1,2,3,4))
x2 = list(1:4)
all.equal(x,x2)

Odnośnie wektorów i koncepcji hash/array z innych języków:

1. Wektory są atomami R. np. rpois(1e4,5) (5 liczb losowych), numeric(55) (Długość-55 wektorów zerowych nad podwójnymi) i character(12) (12 pustych ciągów), wszystkie są "podstawowe".

2. Albo listy, albo wektory mogą mieć names.

   > n = numeric(10)
   > n
    [1] 0 0 0 0 0 0 0 0 0 0
   > names(n)
   NULL
   > names(n) = LETTERS[1:10]
   > n
   A B C D E F G H I J 
   0 0 0 0 0 0 0 0 0 0
   

3. Wektory wymagają, aby wszystko było tego samego typu danych. Zobacz to:

   > i = integer(5)
   > v = c(n,i)
   > v
   A B C D E F G H I J           
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
   > class(v)
   [1] "numeric"
   > i = complex(5)
   > v = c(n,i)
   > class(v)
   [1] "complex"
   > v
      A    B    C    D    E    F    G    H    I    J                          
   0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i 0+0i
   

4. Listy mogą zawierać różne typy danych, co widać w inne odpowiedzi i samo pytanie OP.

Widziałem języki (ruby, javascript), w których "tablice" mogą zawierać zmienne typy danych, ale na przykład w C++ "tablice" muszą być tymi samymi typami danych. Jeśli masz numeric(1e6) znasz jego rozmiar i położenie każdego elementu a priori; jeśli rzecz może zawierać "Flying Purple People Eaters" w jakimś nieznanym kawałku, to musisz dokładnie przeanalizować rzeczy, aby poznać podstawowe fakty na temat tego, co się dzieje. to.

Niektóre standardowe operacje R mają również większy sens, gdy typ jest gwarantowany. Na przykład cumsum(1:9) ma sens, podczas gdy cumsum(list(1,2,3,4,5,'a',6,7,8,9)) nie ma, bez gwarancji, że typ będzie podwójny.

Listy mogą być zwracane z funkcji, nawet jeśli nigdy nie trafiłeś na Listę po wywołaniu funkcji

Funkcje zwracają różne typy danych, niż są wprowadzane przez cały czas. plot zwraca fabułę mimo nie bierze fabuły jako wkładu. Arg zwraca numeric, mimo że przyjmuje complex. Itd.

(a co do strsplit: kod źródłowy to tutaj .)

Jeśli to pomoże, mam tendencję do wyobrażania "list" w R jako "rekordów"w innych językach pre-OO:

• nie przyjmują żadnych założeń co do nadrzędnego typu (a raczej rodzaju wszystkich możliwych rekordów o dowolnej arytmetyce i nazwach pól jest dostępny).
• ich pola mogą być anonimowe (wtedy uzyskujesz do nich dostęp według ścisłego porządku definicji).

Nazwa "rekord" koliduje ze standardowym znaczeniem "rekordów" (aka rows) w języku bazodanowym i być może dlatego ich nazwa zasugerował: as lists (of fields)

Alhough to dość stare pytanie muszę powiedzieć, że dotyka dokładnie wiedzy, której brakowało mi podczas pierwszych kroków w R - czyli jak wyrazić dane w dłoni jako obiekt w R lub jak wybrać z istniejących obiektów. Nie jest łatwo początkującemu R myśleć "w pudełku R" od samego początku.

Więc sam zacząłem używać kul poniżej, które pomogły mi wiele dowiedzieć się, jaki obiekt użyć do jakich danych, i zasadniczo wyobrazić sobie rzeczywiste użycie świata.

Choć ja nie podanie dokładnych odpowiedzi na pytanie krótki tekst poniżej może pomóc czytelnikowi, który dopiero zaczął od R i zadaje pytania.

• Wektor atomowy ... Nazwałem to "sekwencją" dla siebie, bez kierunku, po prostu sekwencją tych samych typów. [ podzbiory.
• Wektor ... Sekwencja o jednym kierunku od 2D, [ podzbiorów.
• Matrix ... zbiór wektorów o tej samej długości tworzących wiersze lub kolumny, [ podzbiory według wierszy i kolumn lub według sekwencji.
• Tablice ... matryce warstwowe tworzące 3D
• Dataframe ... tabela 2D jak w Excelu, gdzie mogę sortować, dodawać lub usuwać wiersze lub kolumny lub tworzyć arit. operacje z nimi, dopiero po pewnym czasie naprawdę uznałem, że dataframe jest sprytną implementacją list, Gdzie mogę podzlecić za pomocą [ przez wiersze i kolumny, ale nawet za pomocą [[.
• lista ... aby pomóc sobie pomyślałem o liście od tree structure gdzie [i] wybiera i zwraca całe gałęzie, a [[i]] zwraca element z gałęzi. A ponieważ jest to tree like structure, można nawet użyć index sequence do adresowania każdego pojedynczego liścia na bardzo złożonym list za pomocą jego [[index_vector]]. Listy mogą być proste lub bardzo złożone i mogą łączyć ze sobą różne typy obiektów w jedną.

Więc dla lists możesz skończyć z więcej sposobów, jak wybrać leaf w zależności od sytuacji, jak w poniższym przykładzie.

l <- list("aaa",5,list(1:3),LETTERS[1:4],matrix(1:9,3,3))
l[[c(5,4)]] # selects 4 from matrix using [[index_vector]] in list
l[[5]][4] # selects 4 from matrix using sequential index in matrix
l[[5]][1,2] # selects 4 from matrix using row and column in matrix

Dlaczego te dwa różne operatory, [ ] i [[ ]], zwracają ten sam wynik?

x = list(1, 2, 3, 4)

1. [ ] zapewnia operację ustawienia podrzędnego. Ogólnie podzbiór dowolnego obiektu będzie miał ten sam typ co oryginalny obiekt. Dlatego x[1] zawiera listę. Podobnie x[1:2] jest podzbiorem oryginalnej listy, dlatego jest to lista. Ex.

   x[1:2]
   
   [[1]] [1] 1
   
   [[2]] [1] 2
   

2. [[ ]] służy do wyodrębniania elementu z listy. x[[1]] jest poprawna i wyodrębnij pierwszy element z listy. x[[1:2]] is not valid as [[ ]] nie zapewnia ustawienia podrzędnego, takiego jak [ ].

    x[[2]] [1] 2 
   
   > x[[2:3]] Error in x[[2:3]] : subscript out of bounds