Как использовать функцию многоточия R при написании собственной функции?


186

Язык R имеет изящную функцию для определения функций, которые могут принимать переменное число аргументов. Например, функция data.frameпринимает любое количество аргументов, и каждый аргумент становится данными для столбца в результирующей таблице данных. Пример использования:

> data.frame(letters=c("a", "b", "c"), numbers=c(1,2,3), notes=c("do", "re", "mi"))
  letters numbers notes
1       a       1    do
2       b       2    re
3       c       3    mi

Подпись функции включает многоточие, например:

function (..., row.names = NULL, check.rows = FALSE, check.names = TRUE, 
    stringsAsFactors = default.stringsAsFactors()) 
{
    [FUNCTION DEFINITION HERE]
}

Я хотел бы написать функцию, которая делает нечто подобное, принимая несколько значений и объединяя их в одно возвращаемое значение (а также выполняя некоторую другую обработку). Чтобы сделать это, мне нужно выяснить, как «распаковать» ...аргументы функции внутри функции. Я не знаю, как это сделать. Соответствующая строка в определении функции data.frameis object <- as.list(substitute(list(...)))[-1L], которую я не могу понять.

Итак, как я могу преобразовать многоточие из подписи функции, например, в список?

Чтобы быть более конкретным, как я могу написать get_list_from_ellipsisв коде ниже?

my_ellipsis_function(...) {
    input_list <- get_list_from_ellipsis(...)
    output_list <- lapply(X=input_list, FUN=do_something_interesting)
    return(output_list)
}

my_ellipsis_function(a=1:10,b=11:20,c=21:30)

редактировать

Кажется, есть два возможных способа сделать это. Они есть as.list(substitute(list(...)))[-1L]и list(...). Однако эти двое не делают одно и то же. (Различия см. В примерах ответов.) Кто-нибудь может сказать мне, какова практическая разница между ними, и какую мне следует использовать?

Ответы:


113

Я читаю ответы и комментарии, и вижу, что некоторые вещи не были упомянуты:

  1. data.frameиспользует list(...)версию. Фрагмент кода:

    object <- as.list(substitute(list(...)))[-1L]
    mrn <- is.null(row.names)
    x <- list(...)

    objectxиспользуется для создания магии с именами столбцов, но используется для создания финала data.frame.
    Для использования неоцененного ...аргумента посмотрите write.csvкод, где match.callиспользуется.

  2. По мере того как вы пишете в комментарии результат в ответе Дирка не является списком списков. Является ли список длиной 4, какие элементы являются languageтипом. Первый объект представляет собой symbol- list, второе выражение 1:10и так далее. Это объясняет, почему [-1L]это необходимо: он удаляет ожидаемые symbolиз предоставленных аргументов в ...(потому что это всегда список).
    Поскольку Дирк заявляет, substituteвозвращает "дерево разбора неоцененное выражение".
    Когда вы вызываете, my_ellipsis_function(a=1:10,b=11:20,c=21:30)то ...«создает» список аргументов: list(a=1:10,b=11:20,c=21:30)и substituteсоставляет список из четырех элементов:

    List of 4
    $  : symbol list
    $ a: language 1:10
    $ b: language 11:20
    $ c: language 21:30

    У первого элемента нет имени, и это [[1]]в ответе Дирка. Я достигаю этого результата, используя:

    my_ellipsis_function <- function(...) {
      input_list <- as.list(substitute(list(...)))
      str(input_list)
      NULL
    }
    my_ellipsis_function(a=1:10,b=11:20,c=21:30)
  3. Как и выше, мы можем использовать, strчтобы проверить, какие объекты находятся в функции.

    my_ellipsis_function <- function(...) {
        input_list <- list(...)
        output_list <- lapply(X=input_list, function(x) {str(x);summary(x)})
        return(output_list)
    }
    my_ellipsis_function(a=1:10,b=11:20,c=21:30)
     int [1:10] 1 2 3 4 5 6 7 8 9 10
     int [1:10] 11 12 13 14 15 16 17 18 19 20
     int [1:10] 21 22 23 24 25 26 27 28 29 30
    $a
       Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
       1.00    3.25    5.50    5.50    7.75   10.00 
    $b
       Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
       11.0    13.2    15.5    15.5    17.8    20.0 
    $c
       Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
       21.0    23.2    25.5    25.5    27.8    30.0 

    Все нормально. Давайте посмотрим substituteверсию:

       my_ellipsis_function <- function(...) {
           input_list <- as.list(substitute(list(...)))
           output_list <- lapply(X=input_list, function(x) {str(x);summary(x)})
           return(output_list)
       }
       my_ellipsis_function(a=1:10,b=11:20,c=21:30)
        symbol list
        language 1:10
        language 11:20
        language 21:30
       [[1]]
       Length  Class   Mode 
            1   name   name 
       $a
       Length  Class   Mode 
            3   call   call 
       $b
       Length  Class   Mode 
            3   call   call 
       $c
       Length  Class   Mode 
            3   call   call 

    Это не то, что нам было нужно. Вам понадобятся дополнительные уловки, чтобы иметь дело с такими объектами (как в write.csv).

Если вы хотите использовать, ...то вы должны использовать его, как в ответе Шейна list(...).


38

Вы можете преобразовать многоточие в список с помощью list(), а затем выполнить над ним операции:

> test.func <- function(...) { lapply(list(...), class) }
> test.func(a="b", b=1)
$a
[1] "character"

$b
[1] "numeric"

Так что ваша get_list_from_ellipsisфункция не более чем list.

Допустимый вариант использования для этого - в случаях, когда вы хотите передать неизвестное число объектов для работы (как в вашем примере c()или data.frame()). Однако не рекомендуется использовать, ...когда вы заранее знаете каждый параметр, так как это добавляет некоторую двусмысленность и усложняет строку аргумента (и делает подпись функции неясной для любого другого пользователя). Список аргументов является важной частью документации для пользователей функций.

В противном случае это также полезно для случаев, когда вы хотите передать параметры подфункции, не раскрывая их все в своих аргументах функции. Это можно отметить в документации по функции.


Я знаю об использовании многоточия в качестве прохода для аргументов подфункций, но среди примитивов R также распространено использование многоточия способом, который я описал. На самом деле, как listи cработа функции таким образом, но оба примитивы, так что я не могу легко проверять их исходный код , чтобы понять , как они работают.
Райан К. Томпсон

rbind.data.frameиспользуйте этот способ.
Марек

5
Если этого list(...)достаточно, почему встроенные R, например, data.frameиспользуют as.list(substitute(list(...)))[-1L]вместо этого более длинную форму ?
Райан С. Томпсон

1
Поскольку я не творил data.frame, я не знаю ответа на этот вопрос (хотя я уверен, что для этого есть все основания). Я использую list()для этой цели в своих собственных пакетах и ​​еще не столкнулся с проблемой с ним.
Шейн

34

Просто добавить к ответам Шейна и Дирка: интересно сравнить

get_list_from_ellipsis1 <- function(...)
{
  list(...)
}
get_list_from_ellipsis1(a = 1:10, b = 2:20) # returns a list of integer vectors

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

$b
 [1]  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

с участием

get_list_from_ellipsis2 <- function(...)
{
  as.list(substitute(list(...)))[-1L]
}
get_list_from_ellipsis2(a = 1:10, b = 2:20) # returns a list of calls

$a
1:10

$b
2:20

В любом случае, любая версия кажется подходящей для ваших целей my_ellipsis_function, хотя первая явно проще.


15

Вы уже дали половину ответа. Рассматривать

R> my_ellipsis_function <- function(...) {
+   input_list <- as.list(substitute(list(...)))
+ }
R> print(my_ellipsis_function(a=1:10, b=2:20))
[[1]]
list

$a
1:10

$b
11:20

R> 

Так что взял два аргумента aи bиз вызова и преобразовал его в список. Разве это не то, что вы просили?


2
Не совсем то, что я хочу. Это на самом деле, кажется, возвращает список списков. Обратите внимание [[1]]. Кроме того, я хотел бы знать, как as.list(substitute(list(...)))работает волшебное заклинание .
Райан К. Томпсон

2
Внутреннее list(...)создает listобъект на основе аргументов. Затем substitute()создает дерево разбора для неоцененного выражения; см. справку для этой функции. А также хороший продвинутый текст на R (или S). Это не тривиальные вещи.
Дирк Эддельбюттель

Хорошо, как насчет [[-1L]]части (из моего вопроса)? Не должно ли это быть [[1]]?
Райан К. Томпсон

3
Вы должны прочитать об индексации. Минус означает «исключить», то есть print(c(1:3)[-1])будет печатать только 2 и 3. Это Lновый способ убедиться, что он заканчивается как целое число, это много сделано в источниках R.
Дирк Эддельбюттель

7
Мне не нужно читать на индексацию, но мне действительно нужно обратить более пристальное внимание на выход команд , которые показывают. Разница между [[1]]и $aиндексами заставила меня думать, что были задействованы вложенные списки. Но теперь я вижу, что вы на самом деле получаете список, который мне нужен, но с дополнительным элементом впереди. Так что тогда [-1L]имеет смысл. В любом случае, откуда этот дополнительный первый элемент? И есть ли причина, по которой я должен использовать это вместо простого list(...)?
Райан К. Томпсон

6

Это работает как ожидалось. Ниже приведен интерактивный сеанс:

> talk <- function(func, msg, ...){
+     func(msg, ...);
+ }
> talk(cat, c("this", "is", "a","message."), sep=":")
this:is:a:message.
> 

То же самое, за исключением аргумента по умолчанию:

> talk <- function(func, msg=c("Hello","World!"), ...){
+     func(msg, ...);
+ }
> talk(cat,sep=":")
Hello:World!
> talk(cat,sep=",", fill=1)
Hello,
World!
>

Как вы можете видеть, вы можете использовать это для передачи «дополнительных» аргументов функции внутри вашей функции, если значения по умолчанию не те, которые вы хотите в конкретном случае.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.