R'de Listeler Nasıl Doğru Kullanılır?

Kısa arka plan: Yaygın kullanımdaki birçok (en çok?) Çağdaş programlama dili, en azından bir avuç ADT'ye sahiptir (özellikle soyut veri türleri),

• string (karakterlerden oluşan bir dizi)

• liste (sıralı değerler koleksiyonu) ve

• harita tabanlı tür (anahtarları değerlerle eşleyen sıralanmamış bir dizi)

R programlama dilinde, ilk ikisi sırasıyla characterve olarak uygulanır vector.

R öğrenmeye başladığımda, neredeyse en başından itibaren iki şey açıktı: listR'deki en önemli veri türü (çünkü R'nin ana sınıfı olduğu data.frame) ve ikincisi, en azından nasıl çalıştıklarını anlayamadım, en azından kodumda doğru kullanmak için yeterince iyi değil.

Bir kere, R'nin listveri türünün ADT haritasının ( dictionaryPython'da, NSMutableDictionaryObjective C'de, hashPerl ve Ruby'de, object literalJavascript'te vb.) Doğrudan bir uygulaması olduğu görülüyordu .

Örneğin, bunları bir Python sözlüğünde yaptığınız gibi, anahtar / değer çiftlerini bir kurucuya (Python'da dictolmayan list) ileterek oluşturursunuz :

x = list("ev1"=10, "ev2"=15, "rv"="Group 1")

R Listesinin öğelerine tıpkı bir Python sözlüğünde olduğu gibi erişirsiniz, örn x['ev1']. Benzer şekilde, yalnızca 'anahtarları' veya yalnızca 'değerleri' şu yollarla alabilirsiniz :

names(x)    # fetch just the 'keys' of an R list
# [1] "ev1" "ev2" "rv"

unlist(x)   # fetch just the 'values' of an R list
#   ev1       ev2        rv 
#  "10"      "15" "Group 1" 

x = list("a"=6, "b"=9, "c"=3)  

sum(unlist(x))
# [1] 18

fakat R listler de vardır aksine (dil Zaten öğrendiğim arasından) diğer harita tipi ADTS. Tahminimce bu, S için ilk spesifikasyonun bir sonucudur, yani sıfırdan bir veri / istatistik DSL [alana özgü dil] tasarlama niyetidir.

listyaygın kullanımda R'ler ve diğer dillerdeki haritalama türleri arasındaki üç önemli fark (ör. Python, Perl, JavaScript):

ilk olarak , listR'deki s değerleri, değerler anahtarlanmış olsa bile, tıpkı vektörler gibi sıralı bir koleksiyondur (yani, anahtarlar sadece sıralı tamsayılar değil, herhangi bir yıkanabilir değer olabilir). Neredeyse her zaman, diğer dillerde eşleme veri türü sıralı değildir .

ikinci olarak , listişlevi listçağırdığınızda hiçbir zaman geçmeseniz bile işlevlerden döndürülebilir ve döndüren işlev listbir (açık) listyapıcı içermese de (Tabii ki, bunu pratikte döndürülen sonucun çağrısında kaydırılması unlist):

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

class(x)                            # returns 'list', not a vector of length 2
# [1] list

R'lerin üçüncü bir tuhaf özelliği list: başka bir ADT'nin üyesi olabileceği görülmüyor ve bunu yapmaya çalışırsanız birincil kapsayıcı a'ya zorlanıyor list. Örneğin,

x = c(0.5, 0.8, 0.23, list(0.5, 0.2, 0.9), recursive=TRUE)

class(x)
# [1] list

buradaki amacım dili veya nasıl belgelendiğini eleştirmek değil; aynı şekilde, listveri yapısı veya nasıl davrandığı ile ilgili yanlış bir şey olduğunu da söylemiyorum . Sonra tüm düzeltmek için nasıl onlar benim kodu doğru kullanmak böylece nasıl çalıştığını anlamaktır.

İşte daha iyi anlamak istediğim şeyler:

• Bir işlev çağrısının ne zaman geri döneceğini belirleyen kurallar nelerdir list(örneğin strsplityukarıda belirtilen ifade)?

• Açık bir şekilde list(örneğin list(10,20,30,40)) ad atamazsam , varsayılan adlar 1 ile başlayan sıralı tamsayılar mıdır? (Sanırım, ama cevabın evet olduğundan emin değilim, aksi takdirde bu tür listbir çağrıyı olmayan bir vektöre zorlayamazdık unlist.)

• Neden bu iki farklı operatörler, do []ve [[]]geri dönmek aynı sonucu?

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

  her iki ifade de "1" döndürür:

  x[1]

  x[[1]]

• neden bu iki ifade aynı sonucu vermiyor ?

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

  x2 = list(1:4)

Lütfen beni R Belgelerine yöneltmeyin ( ?list, R-intro) - Dikkatle okudum ve yukarıda okuduğum soruların türünü cevaplamama yardımcı olmuyor.

(son olarak, yakın zamanda öğrendim ve bir S4 sınıfı aracılığıyla geleneksel harita tipi davranışı hashuygulayan bir R Paketi (CRAN'da mevcut) kullanmaya başladım; kesinlikle bu Paketi tavsiye edebilirim.)

Sorunuzun son kısmını ele almak için, çünkü bu gerçekten a listve vectorR arasındaki farkı gösteriyor :

Bu iki ifade neden aynı sonucu vermiyor?

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

Liste, her öğe olarak başka bir sınıf içerebilir. Böylece, ilk öğenin bir karakter vektörü, ikincisinin bir veri çerçevesi vb. Olduğu bir listeniz olabilir. Bu durumda, iki farklı liste oluşturdunuz. xher biri uzunluk 1 olan dört x2vektör içerir.

> length(x[[1]])
[1] 1
> length(x2[[1]])
[1] 4

Yani bunlar tamamen farklı listeler.

R listeleri, her dizin değerinin herhangi bir nesneyle ilişkilendirilebilmesi için karma harita veri yapısına çok benzer . 3 farklı sınıf (bir işlev dahil) içeren listeye basit bir örnek:

> complicated.list <- list("a"=1:4, "b"=1:3, "c"=matrix(1:4, nrow=2), "d"=search)
> lapply(complicated.list, class)
$a
[1] "integer"
$b
[1] "integer"
$c
[1] "matrix"
$d
[1] "function"

Son elemanın arama fonksiyonu olduğu göz önüne alındığında, şöyle diyebilirim:

> complicated.list[["d"]]()
[1] ".GlobalEnv" ...

Bununla ilgili son bir yorum olarak: a'nın data.framegerçekten bir liste olduğuna dikkat edilmelidir ( data.framebelgelerden):

Veri çerçevesi, "" data.frame "sınıfı verildiğinde, benzersiz satır adlarına sahip aynı sayıda satıra sahip değişkenlerin listesidir.

Bu nedenle a'daki sütunlar data.framefarklı veri türlerine sahip olabilirken, bir matristeki sütunlar olamaz. Örnek olarak, burada sayı ve karakter içeren bir matris oluşturmaya çalışıyorum:

> a <- 1:4
> class(a)
[1] "integer"
> b <- c("a","b","c","d")
> d <- cbind(a, b)
> d
 a   b  
[1,] "1" "a"
[2,] "2" "b"
[3,] "3" "c"
[4,] "4" "d"
> class(d[,1])
[1] "character"

İkinci sütunda karakterler olduğundan, ilk sütundaki veri türünü nasıl sayısal olarak değiştiremediğimi unutmayın:

> d[,1] <- as.numeric(d[,1])
> class(d[,1])
[1] "character"

Sorularınızla ilgili olarak, bunları sırasıyla ele alalım ve bazı örnekler vereyim:

1 ) return ifadesi eklerse ve eklediğinde bir liste döndürülür. Düşünmek

 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 ) İsimler basitçe ayarlanmamıştır:

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

3 ) Aynı şeyi geri getirmezler. Örneğiniz

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

burada - x[1]öğesinin xaynı olan ilk öğesini döndürür x. Her skaler bir uzunluk vektörüdür. Öte yandan x[[1]]listenin ilk öğesini döndürür.

4 ) Son olarak, ikisi, sırasıyla, dört skaler içeren bir liste ve tek bir öğeye sahip (dört öğeden oluşan bir vektör olan) bir liste oluşturdukları arasında farklıdır.

Sorularınızın bir alt kümesini almak için:

İndeksleme ile ilgili bu makale[] ve arasındaki fark sorununu ele almaktadır [[]].

Kısacası [[]] bir listeden tek bir öğe seçer []ve seçilen öğelerin bir listesini döndürür. Örneğin, x = list(1, 2, 3, 4)'öğe 1 tek bir tamsayıdır, ancak x[[1]]tek bir 1 x[1]döndürür ve yalnızca bir değere sahip bir liste döndürür.

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

> x[[1]]
[1] 1

Listelerin yaptıkları gibi (sıralı) çalışmasının bir nedeni, herhangi bir düğümde herhangi bir tür içerebilen, vektörlerin yapmadığı sıralı bir kapsayıcı ihtiyacını ele almaktır. Listeler, data.framerastgele tipte (ancak aynı uzunlukta) vektörlerin bir listesi olan a'nın tabanını oluşturmak da dahil olmak üzere R'de çeşitli amaçlar için yeniden kullanılır .

Bu iki ifade neden aynı sonucu vermiyor?

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

@ Shane'in cevabına eklemek için aynı sonucu almak istiyorsanız şunu deneyin:

x3 = as.list(1:4)

Hangi vektör 1:4bir listeye zorlar .

Buna bir puan daha eklemek için:

R , hashpaketteki Python diksiyonuna eşdeğer bir veri yapısına sahiptir . Bu veriyi Open Data Group'tan okuyabilirsiniz . İşte basit bir örnek:

> 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

Kullanılabilirlik açısından, hashsınıf bir listeye çok benzer. Ancak büyük veri kümeleri için performans daha iyidir.

Diyorsun:

Bir diğeri için, işlevi çağırdığınızda bir Listeye hiç geçmediyseniz ve işlev bir List yapıcısı içermese bile listeler işlevlerden döndürülebilir, örn.

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

Ve sanırım bunun bir sorun olduğunu öneriyorsun (?). Neden bir sorun olmadığını söylemek için burdayım :-). Örneğiniz biraz basittir, çünkü string-split yaptığınızda, 1 eleman uzunluğunda elemanlar içeren bir listeniz olur, böylece x[[1]]bunun aynı olduğunu bilirsiniz unlist(x)[1]. Ama ya strsplither bir kutuda farklı uzunlukta döndürülen sonuçların sonucu ne olur . Bir vektörü (listeye karşı) döndürmek hiç bir işe yaramaz.

Örneğin:

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

(İlk durumda x: listesini döndürür), sen 3 dizesinin 2 "bölümü" ne örnek söyleyebilir: x[[3]][2]. xxSonuçların "çözülmediği" ( unlist-ed) olduğu için şimdi bunu nasıl yapabilirsiniz ?

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

aynı değildir çünkü 1: 4 c (1,2,3,4) ile aynıdır. Aynı olmalarını istiyorsanız:

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

Bu çok eski bir soru, ama yeni bir cevabın, bence hiç kimse OP'deki bazı endişeleri doğrudan ele almadığı için biraz değer katabileceğini düşünüyorum.

Kabul edilen cevapların önerdiklerine rağmen list, R'deki nesneler karma haritalar değildir . Eğer python ile bir paralel yapmak istiyorsanız list, sanırım python lists (veya tupleaslında).

Çoğu R nesnesinin dahili olarak nasıl saklandığını açıklamak daha iyidir (R nesnesinin C tipi SEXP). Temel olarak üç bölümden oluşurlar:

• nesnenin R tipini, uzunluğunu ve diğer bazı meta verileri bildiren bir başlık;
• standart C yığınına ayrılmış bir dizi olan veri bölümü (bitişik bellek bloğu);
• diğer R nesnelerine adlandırılmış bağlantılı işaretçiler listesi olan öznitelikler (veya NULLnesnenin öznitelikleri yoksa).

Dahili bir bakış açısından, örneğin a listve numericvektör arasında çok az fark vardır . Depoladıkları değerler sadece farklı. İki nesneyi daha önce tarif ettiğimiz paradigmaya ayıralım:

x <- runif(10)
y <- list(runif(10), runif(3))

Şunun için x:

• Başlık, türün numeric( REALSXPC tarafında), uzunluğun 10 ve diğer şeyler olduğunu söyleyecektir .
• Veri bölümü 10 doubledeğer içeren bir dizi olacaktır .
• NULLNesnede herhangi bir özellik olmadığından nitelikler şunlardır .

Şunun için y:

• Üstbilgi, türün list( VECSXPC tarafında), uzunluğun 2 ve diğer şeyler olduğunu söyleyecektir .
• Veri bölümü, sırasıyla runif(10)ve ile elde edilen değere işaret eden iki SEXP tipine 2 işaretçi içeren bir dizi runif(3)olacaktır.
• Öznitelikler NULL, olduğu gibi x.

Bu nedenle, bir numericvektör ile a arasındaki tek fark list, numericveri kısmının doubledeğerlerden yapılmış olması list, veri kısmı için ise diğer R nesnelerine bir işaretçi dizisidir.

İsimlere ne olur? İsimler, bir nesneye atayabileceğiniz özelliklerden sadece birkaçıdır. Aşağıdaki nesneyi görelim:

z <- list(a=1:3, b=LETTERS)

• Üstbilgi, türün list( VECSXPC tarafında), uzunluğun 2 ve diğer şeyler olduğunu söyleyecektir .
• Veri bölümü, sırasıyla 1:3ve ile elde edilen değere işaret eden iki SEXP tipine 2 işaretçi içeren bir dizi LETTERSolacaktır.
• Öznitelikler artık mevcuttur ve değeri namesolan bir characterR nesnesi olan bir bileşendir c("a","b").

R seviyesinden, bir nesnenin attributesişleviyle özniteliklerini alabilirsiniz .

R'deki bir karma haritanın tipik anahtar / değer çifti sadece bir yanılsamadır. Dediğinde:

z[["a"]]

olan budur:

• [[alt kümesi fonksiyonu olarak adlandırılır;
• ( "a") işlevinin bağımsız değişkeni tiptedir character, bu nedenle yönteme namesnesnenin niteliğinden (varsa) bu değeri araması istenir z;
• eğer namesniteliği yoktur, NULLdöndürülür;
• varsa, "a"değer içinde aranır. Eğer "a"nesnenin bir isim değil, NULLdöndürülür;
• mevcutsa, pozisyon belirlenir (örnekte 1). Böylece listenin ilk elemanı döndürülür, yani z[[1]].

Anahtar / değer çifti araması oldukça dolaylıdır ve her zaman konumsaldır. Ayrıca, akılda tutulması gereken:

• karma haritalarda, bir anahtarın sahip olması gereken tek sınır, yıkanabilir olması gerektiğidir . namesR'de dizeler ( charactervektörler) olmalıdır;

• karma haritalarda iki özdeş anahtarınız olamaz. R'de, namestekrarlanan değerlere sahip bir nesneye atayabilirsiniz . Örneğin:

  names(y) <- c("same", "same")

  R'de mükemmel şekilde geçerlidir. Denediğinizde y[["same"]]ilk değer alınır. Bu noktada nedenini bilmelisin.

Sonuç olarak, bir nesneye keyfi nitelikler verebilme yeteneği, dış bakış açısından farklı bir şeyin görünümünü verir. Ancak listR'ler hiçbir şekilde karma haritalar değildir.

Vektörler ve diğer dillerden karma / dizi kavramı ile ilgili:

1. Vektörler R'nin atomlarıdır. Örn., rpois(1e4,5)(5 rastgele sayı), numeric(55)(çiftler üzerinde uzunluk-55 sıfır vektör) ve character(12)(12 boş dizge) hepsi "temel" dir.

2. Listeler veya vektörler olabilir 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. Vektörler, her şeyin aynı veri türünde olmasını gerektirir. Şunu izle:

   > 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. Listeler, diğer yanıtlarda ve OP'nin sorusunun kendisinde görüldüğü gibi, farklı veri türleri içerebilir.

"Diziler" değişken veri türleri içerebilir, ancak örneğin C ++ "diziler" hepsi aynı veri türü olmalıdır dilleri (yakut, javascript) gördüm. Bu bir hız / verimlilik şey olduğuna inanıyorum: eğer bir numeric(1e6)var ise boyutunu ve her öğenin konumunu bir önsel biliyorum ; şey "Flying Purple People Eaters"bilinmeyen bir dilimde içeriyorsa , o zaman temel gerçekleri bilmek için bir şeyler ayrıştırmanız gerekir.

Bazı standart R işlemleri de tip garanti edildiğinde daha mantıklıdır. Örneğin , tipin çift olduğu garanti edilmeden cumsum(1:9)mantıklı cumsum(list(1,2,3,4,5,'a',6,7,8,9))değildir.

İkinci sorunuza gelince:

İşlevi çağırdığınızda bir Listeye hiç geçmemenize rağmen listeler işlevlerden döndürülebilir

İşlevler her zaman girilenden farklı veri türleri döndürür. plotgirdi olarak bir çizim almasa bile bir çizim döndürür. kabul ettiği halde Arggeri döner numerica complex. Vb.

(Ve gelince strsplit: kaynak kodu burada .)

Bu oldukça eski bir soru olmasına rağmen, R'deki ilk adımlarda tam olarak eksik olduğum bilgiye dokunduğumu söylemeliyim - yani elimdeki verileri R'de nesne olarak nasıl ifade edeceğimizi veya mevcut nesnelerden nasıl seçileceğini. Bir R aceminin en başından itibaren "R kutusunda" düşünmesi kolay değildir.

Bu yüzden kendim aşağıdaki koltuk değneklerini kullanmaya başladım, bu da hangi veriler için hangi nesneyi kullanacağımı bulmamı ve temelde gerçek dünya kullanımını hayal etmemi sağladı.

Soruya kesin cevaplar vermeme rağmen, aşağıdaki kısa metin R ile yeni başlayan ve benzer sorular soran okuyucuya yardımcı olabilir.

• Atom vektörü ... O "diziyi" kendim için söyledim, yön yok, sadece aynı tür diziler. [alt kümeleri.
• Vector ... 2D, [alt kümelerden bir yönde sıra .
• Matris ... satırlar veya sütunlar, [satırlar ve sütunlar veya dizi ile alt kümeler oluşturan aynı uzunlukta vektör grupları.
• Diziler ... 3D oluşturan katmanlı matrisler
• Dataframe ... excel'de olduğu gibi 2 boyutlu bir tablo, burada satırları veya sütunları sıralayabilir, ekleyebilir veya kaldırabilir veya arit yapabilirim. Onlarla işlemler, ancak bir süre sonra veri çerçevesinin satırlar ve sütunlar kullanarak, hatta kullanarak listalt küme oluşturabildiğim akıllıca bir uygulama olduğunu gerçekten fark ettim .[[[
• Liste ... kendi çıkarıma ben itibariyle listesi hakkında düşünce tree structurenereye [i]i seçer ve döndürüyor bütün dalları ve [[i]]daldan döner öğe. O olduğu için tree like structure, hatta bir kullanabilirsiniz index sequenceçok karmaşık üzerinde her yaprak ele almak listonun kullanarak [[index_vector]]. Listeler basit veya çok karmaşık olabilir ve çeşitli nesne türlerini bir araya getirebilir.

Böylece , aşağıdaki örnekte olduğu gibi listsbir leafduruma bağlı olarak nasıl seçileceği daha fazla yolla sonuçlanabilir .

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

Bu düşünce tarzı bana çok yardımcı oldu.

Eğer yardımcı olursa, R'deki "listeler" i diğer OO öncesi dillerde "kayıt" olarak kavrama eğilimindeyim:

• kapsayıcı bir tür hakkında herhangi bir varsayımda bulunmazlar (veya herhangi bir arity ve alan adının tüm olası kayıtlarının türü mevcuttur).
• alanları anonim olabilir (daha sonra bunlara katı tanım sıralaması ile erişebilirsiniz).

"Kayıt" adı, veritabanı boyutunda standart "kayıtlar" (diğer adıyla satırlar) anlamıyla çelişir ve bu yüzden isimlerinin kendisini önerdiği gibi olabilir: listeler (alanların) olarak.

neden bu iki farklı operatörler, do [ ]ve [[ ]]aynı sonuç döndürmek?

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

1. [ ]alt ayar işlemi sağlar. Genelde, herhangi bir nesnenin alt kümesi, orijinal nesne ile aynı tipte olacaktır. Bu nedenle, x[1] bir liste sağlar. Benzer şekilde x[1:2]orijinal listenin bir alt kümesidir, bu nedenle bir listedir. Ör.

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

2. [[ ]]listeden bir eleman çıkarmak içindir. x[[1]]geçerlidir ve ilk öğeyi listeden ayıklayın. gibi alt ayar sağlamadığı için x[[1:2]]geçerli [[ ]]değil [ ].

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