FUN 내에서 lapply 인덱스 이름에 액세스

lapply () 함수에서 목록 색인 이름을 얻는 방법이 있습니까?

n = names(mylist)
lapply(mylist, function(list.elem) { cat("What is the name of this list element?\n" })

내가 물었다 전에 는 lapply ()에서 인덱스 이름을 유지하기 위해 가능하다면 반환 목록 있지만, 사용자 정의 함수 내에서 각 요소의 이름을 가져올 수있는 쉬운 방법이 있는지 나는 아직 모른다. 이름 자체에서 lapply를 호출하지 않으려 고합니다. 함수 매개 변수에서 이름을 얻습니다.

불행히도, lapply전달한 벡터의 요소 만 제공합니다. 일반적인 해결 방법은 벡터 자체 대신 벡터의 이름이나 인덱스를 전달하는 것입니다.

그러나 항상 함수에 추가 인수를 전달할 수 있으므로 다음과 같이 작동합니다.

x <- list(a=11,b=12,c=13) # Changed to list to address concerns in commments
lapply(seq_along(x), function(y, n, i) { paste(n[[i]], y[[i]]) }, y=x, n=names(x))

여기에서는 lapply의 색인을 사용 x하지만 x의 이름 과을 (를 ) 전달 x합니다. 보시다시피, 함수 인수의 순서는 무엇이든 가능 lapply합니다. "요소"(여기서 색인)를 추가 인수 중 지정 되지 않은 첫 번째 인수로 전달 합니다. 이 경우, y및을 지정 n하므로 i왼쪽 만 남습니다.

다음을 생성합니다.

[[1]]
[1] "a 11"

[[2]]
[1] "b 12"

[[3]]
[1] "c 13"

UPDATE 간단한 예를 들어, 동일한 결과 :

lapply(seq_along(x), function(i) paste(names(x)[[i]], x[[i]]))

여기서 함수는 "전역"변수를 사용 x하고 각 호출에서 이름을 추출합니다.

이것은 기본적으로 Tommy와 동일한 해결 방법을 사용하지만 Map()을 사용하면 목록 구성 요소의 이름을 저장하는 전역 변수에 액세스 할 필요가 없습니다.

> x <- list(a=11, b=12, c=13)
> Map(function(x, i) paste(i, x), x, names(x))
$a
[1] "a 11"

$b
[1] "b 12"

$c
[1] "c 13

또는 원하는 경우 mapply()

> mapply(function(x, i) paste(i, x), x, names(x))
     a      b      c 
"a 11" "b 12" "c 13"

R 버전 3.2 업데이트

면책 조항 : 이것은 해킹 트릭이며 다음 릴리스에서 작동을 멈출 수 있습니다.

다음을 사용하여 색인을 얻을 수 있습니다.

> lapply(list(a=10,b=20), function(x){parent.frame()$i[]})
$a
[1] 1

$b
[1] 2

참고 :는 (의 평가 프레임에있는 ) []기호에 더 많은 참조가있을 수 있다고 생각하도록 R을 속이기 때문에 지연이 발생합니다. 그게 없으면, R은 구분 사본을 보관하지 않습니다 :ilapplyi

> lapply(list(a=10,b=20), function(x){parent.frame()$i})
$a
[1] 2

$b
[1] 2

function(x){parent.frame()$i+0}또는 같은 다른 이국적인 트릭을 사용할 수 있습니다 function(x){--parent.frame()$i}.

성능 영향

강제 복제는 성능 손실을 유발합니까? 예! 벤치 마크는 다음과 같습니다.

> x <- as.list(seq_len(1e6))

> system.time( y <- lapply(x, function(x){parent.frame()$i[]}) )
user system elapsed
2.38 0.00 2.37
> system.time( y <- lapply(x, function(x){parent.frame()$i[]}) )
user system elapsed
2.45 0.00 2.45
> system.time( y <- lapply(x, function(x){parent.frame()$i[]}) )
user system elapsed
2.41 0.00 2.41
> y[[2]]
[1] 2

> system.time( y <- lapply(x, function(x){parent.frame()$i}) )
user system elapsed
1.92 0.00 1.93
> system.time( y <- lapply(x, function(x){parent.frame()$i}) )
user system elapsed
2.07 0.00 2.09
> system.time( y <- lapply(x, function(x){parent.frame()$i}) )
user system elapsed
1.89 0.00 1.89
> y[[2]]
[1] 1000000

결론

이 답변은 당신이 이것을 사용해서는 안된다는 것을 보여줍니다 ... Tommy와 같은 다른 솔루션을 찾고 코드가 더 읽기 쉽고 향후 릴리스와 더 호환되면 핵심 팀이 열심히 노력한 최적화를 잃을 위험이 있습니다. 나타나게 하다!

더 이상 작동하지 않는 이전 버전의 트릭 :

> lapply(list(a=10,b=10,c=10), function(x)substitute(x)[[3]])

결과:

$a
[1] 1

$b
[1] 2

$c
[1] 3

설명 : lapply형태의 호출을 만들고 FUN(X[[1L]], ...), FUN(X[[2L]], ...)그것을 통과 인수가 그래서 등 X[[i]]어디 i루프의 현재 인덱스입니다. 평가 하기 전에 이것을 얻는다면 (즉, 우리가 사용한다면 substitute) 평가되지 않은 expression을 얻는다 X[[i]]. [[인수 X(기호)와 i(정수)를 가진 함수 호출 입니다. 따라서이 substitute(x)[[3]]정수를 정확하게 반환합니다.

색인이 있으면 먼저 다음과 같이 저장하면 이름에 간단하게 액세스 할 수 있습니다.

L <- list(a=10,b=10,c=10)
n <- names(L)
lapply(L, function(x)n[substitute(x)[[3]]])

결과:

$a
[1] "a"

$b
[1] "b"

$c
[1] "c"

또는 이 두 번째 트릭을 사용하십시오 : :-)

lapply(list(a=10,b=10,c=10), function(x)names(eval(sys.call(1)[[2]]))[substitute(x)[[3]]])

(결과는 같습니다).

설명 2 :를 sys.call(1)리턴 lapply(...)하므로 sys.call(1)[[2]]에 대한 목록 인수로 사용되는 표현식 lapply입니다. 이것을 전달하면 액세스 할 수 eval있는 합법적 인 개체 를 만듭니다 names. 까다 롭지 만 작동합니다.

보너스 : 이름을 얻는 두 번째 방법 :

lapply(list(a=10,b=10,c=10), function(x)eval.parent(quote(names(X)))[substitute(x)[[3]]])

주 X의 부모 프레임에서 유효한 개체입니다 FUN, 참고 문헌 목록의 인수는 lapply, 그래서 우리는 그것을 얻을 수 있습니다 eval.parent.

나는 같은 문제를 여러 번 겪었습니다 ... 다른 방법을 사용하기 시작했습니다 ...을 사용하는 대신을 사용 lapply하기 시작했습니다mapply

n = names(mylist)
mapply(function(list.elem, names) { }, list.elem = mylist, names = n)

패키지 imap()에서 사용해 볼 수 purrr있습니다.

설명서에서 :

x에 이름이 있으면 imap (x, ...)은 map2 (x, names (x), ...)의 약자이며, 그렇지 않은 경우에는 map2 (x, seq_along (x), ...)입니다.

따라서 다음과 같이 사용할 수 있습니다.

library(purrr)
myList <- list(a=11,b=12,c=13) 
imap(myList, function(x, y) paste(x, y))

다음과 같은 결과가 나타납니다.

$a
[1] "11 a"

$b
[1] "12 b"

$c
[1] "13 c"

이름을 반복하십시오.

sapply(names(mylist), function(n) { 
    doSomething(mylist[[n]])
    cat(n, '\n')
}

Tommy의 대답은 명명 된 벡터에 적용되지만 목록에 관심이 있다는 아이디어를 얻었습니다. 마치 호출 환경에서 "x"를 참조하고 있기 때문에 마치 끝 마무리 한 것처럼 보입니다. 이 함수는 함수에 전달 된 매개 변수 만 사용하므로 전달 된 오브젝트 이름에 대한 가정은 없습니다.

x <- list(a=11,b=12,c=13)
lapply(x, function(z) { attributes(deparse(substitute(z)))$names  } )
#--------
$a
NULL

$b
NULL

$c
NULL
#--------
 names( lapply(x, function(z) { attributes(deparse(substitute(z)))$names  } ))
#[1] "a" "b" "c"
 what_is_my_name <- function(ZZZ) return(deparse(substitute(ZZZ)))
 what_is_my_name(X)
#[1] "X"
what_is_my_name(ZZZ=this)
#[1] "this"
 exists("this")
#[1] FALSE

내 대답은 Tommy와 caracals와 같은 방향으로 진행되지만 목록을 추가 객체로 저장하지 않아도됩니다.

lapply(seq(3), function(i, y=list(a=14,b=15,c=16)) { paste(names(y)[[i]], y[[i]]) })

결과:

[[1]]
[1] "a 14"

[[2]]
[1] "b 15"

[[3]]
[1] "c 16"

이것은리스트를 FUN에 대한 명명 된 인수로 제공합니다 (랩핑 대신). lapply는 목록의 요소 만 반복해야합니다 (목록의 길이를 변경할 때 첫 번째 인수를 lapply로 변경하도록주의하십시오).

참고 : 추가 인수로 랩을 직접 제공하는 것도 가능합니다.

lapply(seq(3), function(i, y) { paste(names(y)[[i]], y[[i]]) }, y=list(a=14,b=15,c=16))

@caracals와 @Tommy는 모두 좋은 솔루션이며 이는 list´s 및 data.frame´s 를 포함하는 예 입니다.
rA는 list의 list의와 data.frame의은 ( dput(r[[1]]말에).

names(r)
[1] "todos"  "random"
r[[1]][1]
$F0
$F0$rst1
   algo  rst  prec  rorac prPo pos
1  Mean 56.4 0.450 25.872 91.2 239
6  gbm1 41.8 0.438 22.595 77.4 239
4  GAM2 37.2 0.512 43.256 50.0 172
7  gbm2 36.8 0.422 18.039 85.4 239
11 ran2 35.0 0.442 23.810 61.5 239
2  nai1 29.8 0.544 52.281 33.1 172
5  GAM3 28.8 0.403 12.743 94.6 239
3  GAM1 21.8 0.405 13.374 68.2 239
10 ran1 19.4 0.406 13.566 59.8 239
9  svm2 14.0 0.385  7.692 76.2 239
8  svm1  0.8 0.359  0.471 71.1 239

$F0$rst5
   algo  rst  prec  rorac prPo pos
1  Mean 52.4 0.441 23.604 92.9 239
7  gbm2 46.4 0.440 23.200 83.7 239
6  gbm1 31.2 0.416 16.421 79.5 239
5  GAM3 28.8 0.403 12.743 94.6 239
4  GAM2 28.2 0.481 34.815 47.1 172
11 ran2 26.6 0.422 18.095 61.5 239
2  nai1 23.6 0.519 45.385 30.2 172
3  GAM1 20.6 0.398 11.381 75.7 239
9  svm2 14.4 0.386  8.182 73.6 239
10 ran1 14.0 0.390  9.091 64.4 239
8  svm1  6.2 0.370  3.584 72.4 239

목표는 unlist모든 목록에 있으며, 일련 list의 이름을 사건으로 식별하기위한 열로 표시합니다.

r=unlist(unlist(r,F),F)
names(r)
[1] "todos.F0.rst1"  "todos.F0.rst5"  "todos.T0.rst1"  "todos.T0.rst5"  "random.F0.rst1" "random.F0.rst5"
[7] "random.T0.rst1" "random.T0.rst5"

´s가 아닌 목록을 나열 해제하십시오 data.frame.

ra=Reduce(rbind,Map(function(x,y) cbind(case=x,y),names(r),r))

Map일련의 이름을 열로 넣습니다. Reduce모든 data.frames에 가입하십시오 .

head(ra)
            case algo  rst  prec  rorac prPo pos
1  todos.F0.rst1 Mean 56.4 0.450 25.872 91.2 239
6  todos.F0.rst1 gbm1 41.8 0.438 22.595 77.4 239
4  todos.F0.rst1 GAM2 37.2 0.512 43.256 50.0 172
7  todos.F0.rst1 gbm2 36.8 0.422 18.039 85.4 239
11 todos.F0.rst1 ran2 35.0 0.442 23.810 61.5 239
2  todos.F0.rst1 nai1 29.8 0.544 52.281 33.1 172

PS r[[1]]:

    structure(list(F0 = structure(list(rst1 = structure(list(algo = c("Mean", 
    "gbm1", "GAM2", "gbm2", "ran2", "nai1", "GAM3", "GAM1", "ran1", 
    "svm2", "svm1"), rst = c(56.4, 41.8, 37.2, 36.8, 35, 29.8, 28.8, 
    21.8, 19.4, 14, 0.8), prec = c(0.45, 0.438, 0.512, 0.422, 0.442, 
    0.544, 0.403, 0.405, 0.406, 0.385, 0.359), rorac = c(25.872, 
    22.595, 43.256, 18.039, 23.81, 52.281, 12.743, 13.374, 13.566, 
    7.692, 0.471), prPo = c(91.2, 77.4, 50, 85.4, 61.5, 33.1, 94.6, 
    68.2, 59.8, 76.2, 71.1), pos = c(239L, 239L, 172L, 239L, 239L, 
    172L, 239L, 239L, 239L, 239L, 239L)), .Names = c("algo", "rst", 
    "prec", "rorac", "prPo", "pos"), row.names = c(1L, 6L, 4L, 7L, 
    11L, 2L, 5L, 3L, 10L, 9L, 8L), class = "data.frame"), rst5 = structure(list(
        algo = c("Mean", "gbm2", "gbm1", "GAM3", "GAM2", "ran2", 
        "nai1", "GAM1", "svm2", "ran1", "svm1"), rst = c(52.4, 46.4, 
        31.2, 28.8, 28.2, 26.6, 23.6, 20.6, 14.4, 14, 6.2), prec = c(0.441, 
        0.44, 0.416, 0.403, 0.481, 0.422, 0.519, 0.398, 0.386, 0.39, 
        0.37), rorac = c(23.604, 23.2, 16.421, 12.743, 34.815, 18.095, 
        45.385, 11.381, 8.182, 9.091, 3.584), prPo = c(92.9, 83.7, 
        79.5, 94.6, 47.1, 61.5, 30.2, 75.7, 73.6, 64.4, 72.4), pos = c(239L, 
        239L, 239L, 239L, 172L, 239L, 172L, 239L, 239L, 239L, 239L
        )), .Names = c("algo", "rst", "prec", "rorac", "prPo", "pos"
    ), row.names = c(1L, 7L, 6L, 5L, 4L, 11L, 2L, 3L, 9L, 10L, 8L
    ), class = "data.frame")), .Names = c("rst1", "rst5")), T0 = structure(list(
        rst1 = structure(list(algo = c("Mean", "ran1", "GAM1", "GAM2", 
        "gbm1", "svm1", "nai1", "gbm2", "svm2", "ran2"), rst = c(22.6, 
        19.4, 13.6, 10.2, 9.6, 8, 5.6, 3.4, -0.4, -0.6), prec = c(0.478, 
        0.452, 0.5, 0.421, 0.423, 0.833, 0.429, 0.373, 0.355, 0.356
        ), rorac = c(33.731, 26.575, 40, 17.895, 18.462, 133.333, 
        20, 4.533, -0.526, -0.368), prPo = c(34.4, 52.1, 24.3, 40.7, 
        37.1, 3.1, 14.4, 53.6, 54.3, 116.4), pos = c(195L, 140L, 
        140L, 140L, 140L, 195L, 195L, 140L, 140L, 140L)), .Names = c("algo", 
        "rst", "prec", "rorac", "prPo", "pos"), row.names = c(1L, 
        9L, 3L, 4L, 5L, 7L, 2L, 6L, 8L, 10L), class = "data.frame"), 
        rst5 = structure(list(algo = c("gbm1", "ran1", "Mean", "GAM1", 
        "GAM2", "svm1", "nai1", "svm2", "gbm2", "ran2"), rst = c(17.6, 
        16.4, 15, 12.8, 9, 6.2, 5.8, -2.6, -3, -9.2), prec = c(0.466, 
        0.434, 0.435, 0.5, 0.41, 0.8, 0.44, 0.346, 0.345, 0.337), 
            rorac = c(30.345, 21.579, 21.739, 40, 14.754, 124, 23.2, 
            -3.21, -3.448, -5.542), prPo = c(41.4, 54.3, 35.4, 22.9, 
            43.6, 2.6, 12.8, 57.9, 62.1, 118.6), pos = c(140L, 140L, 
            195L, 140L, 140L, 195L, 195L, 140L, 140L, 140L)), .Names = c("algo", 
        "rst", "prec", "rorac", "prPo", "pos"), row.names = c(5L, 
        9L, 1L, 3L, 4L, 7L, 2L, 8L, 6L, 10L), class = "data.frame")), .Names = c("rst1", 
    "rst5"))), .Names = c("F0", "T0"))

각 요소의 길이를 계산한다고 가정 해 봅시다.

mylist <- list(a=1:4,b=2:9,c=10:20)
mylist

$a
[1] 1 2 3 4

$b
[1] 2 3 4 5 6 7 8 9

$c
 [1] 10 11 12 13 14 15 16 17 18 19 20

목표가 결과 요소에 레이블을 지정하는 것이라면 lapply(mylist,length)아래 또는 아래가 작동합니다.

sapply(mylist,length,USE.NAMES=T)

 a  b  c 
 4  8 11 

함수 내에서 레이블을 사용하는 것이 목적이라면 mapply()두 객체를 반복하여 유용합니다. 리스트 요소와리스트 이름

fun <- function(x,y) paste0(length(x),"_",y)
mapply(fun,mylist,names(mylist))

     a      b      c 
 "4_a"  "8_b" "11_c" 

@ ferdinand-kraft는 우리에게 훌륭한 트릭을 주었고 문서화되지 않았고 성능 오버 헤드 때문에 사용해서는 안된다고 말합니다.

첫 번째 요점을 많이 논할 수는 없지만 오버 헤드가 거의 문제가되지 않는다는 점에 유의하고 싶습니다.

활성 함수를 정의하여 복잡한 표현을 호출 할 필요는 parent.frame()$i[]없지만 .i(), 기본 및 purr 기능 (그리고 아마도 대부분의 다른 기능) 에서도.n() 작동해야하는 이름에 액세스 할 것입니다.

.i <- function() parent.frame(2)$i[]
# looks for X OR .x to handle base and purrr functionals
.n <- function() {
  env <- parent.frame(2)
  names(c(env$X,env$.x))[env$i[]]
}

sapply(cars, function(x) paste(.n(), .i()))
#>     speed      dist 
#> "speed 1"  "dist 2"

이제 다른 접근 방식을 사용하여 벡터 항목을 인덱스에 붙여 넣는 간단한 함수를 벤치마킹합시다 (이 작업은 물론 벡터화 할 수 paste(vec, seq_along(vec))있지만 여기서는 중요하지 않습니다).

벤치마킹 함수와 플로팅 함수를 정의하고 아래에 결과를 플로팅합니다.

library(purrr)
library(ggplot2)
benchmark_fun <- function(n){
  vec <- sample(letters,n, replace = TRUE)
  mb <- microbenchmark::microbenchmark(unit="ms",
                                      lapply(vec, function(x)  paste(x, .i())),
                                      map(vec, function(x) paste(x, .i())),
                                      lapply(seq_along(vec), function(x)  paste(vec[[x]], x)),
                                      mapply(function(x,y) paste(x, y), vec, seq_along(vec), SIMPLIFY = FALSE),
                                      imap(vec, function(x,y)  paste(x, y)))
  cbind(summary(mb)[c("expr","mean")], n = n)
}

benchmark_plot <- function(data, title){
  ggplot(data, aes(n, mean, col = expr)) + 
    geom_line() +
    ylab("mean time in ms") +
    ggtitle(title) +
    theme(legend.position = "bottom",legend.direction = "vertical")
}

plot_data <- map_dfr(2^(0:15), benchmark_fun)
benchmark_plot(plot_data[plot_data$n <= 100,], "simplest call for low n")

benchmark_plot(plot_data,"simplest call for higher n")

^{reprex 패키지 (v0.3.0)에 의해 2019-11-15에 작성 됨}

첫 번째 차트의 시작 부분에있는 하락은 우연입니다. 무시하십시오.

우리는 선택한 답변이 실제로 더 빠르며 적절한 반복 횟수에 대해 .i()솔루션이 실제로 더 느리다는 것을 알았습니다. 선택한 답변에 비해 오버 헤드는을 사용하는 오버 헤드의 약 3 배 purrr::imap()이며 30k 반복의 경우 약 25ms입니다. 그래서 1000 반복 당 약 1ms, 백만 당 1 초를 잃습니다. 제 생각에는 편의를위한 작은 비용입니다.

나만의 커스텀 lapply함수를 작성하십시오

lapply2 <- function(X, FUN){
  if( length(formals(FUN)) == 1 ){
    # No index passed - use normal lapply
    R = lapply(X, FUN)
  }else{
    # Index passed
    R = lapply(seq_along(X), FUN=function(i){
      FUN(X[[i]], i)
    })
  }

  # Set names
  names(R) = names(X)
  return(R)
}

그런 다음 다음과 같이 사용하십시오.

lapply2(letters, function(x, i) paste(x, i))