Comment utiliser R points de suspension en fonction lors de l'écriture de votre propre fonction?

Le langage R est une fonctionnalité utile pour définir des fonctions qui peuvent prendre un nombre variable d'arguments. Par exemple, la fonction data.frame prend un nombre quelconque d'arguments, et chaque argument devient les données d'une colonne dans la table de données. Exemple d'utilisation:

> 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

La fonction de signature comprend les points de suspension, comme ceci:

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

Je voudrais écrire une fonction qui fait la même chose, en prenant plusieurs valeurs et de les regrouper en une seule valeur de retour (ainsi que d'autres de traitement). Pour ce faire, j'ai besoin de comprendre comment faire pour "décompresser" le ... de les arguments de la fonction au sein de la fonction. Je ne sais pas comment faire. La ligne correspondante dans la définition de la fonction de data.frame est object <- as.list(substitute(list(...)))[-1L], que je ne peux pas donner un sens.

Alors, comment puis-je convertir le bouton de sélection de la fonction de signature, par exemple, dans une liste?

Pour être plus précis, comment puis-je écrire get_list_from_ellipsis dans le code ci-dessous?

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)

Modifier

Il semble qu'il y a deux façons de le faire. Ils sont as.list(substitute(list(...)))[-1L] et list(...). Cependant, ces deux ne fait pas exactement la même chose. (Pour les différences, voir les exemples dans les réponses.) Quelqu'un peut-il me dire quelle est la différence concrète entre eux, et avec qui je devrais utiliser?

InformationsquelleAutor Ryan C. Thompson | 2010-06-16
  1. 110

    J'ai lu les réponses et les commentaires et je vois que quelques choses n'ont pas été mentionnés:

    1. data.frame utilise list(...) version. Fragment de code:

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

      object est utilisé pour faire de la magie avec les noms de colonnes, mais x est utilisé pour créer final data.frame.

      Pour l'utilisation de non évaluée ... argument regarder write.csv code où match.call est utilisé.

    2. Comme vous l'écrivez en commentaire suite à Dirk réponse n'est pas une liste de listes. Est une liste de longueur 4, les éléments qui sont language type. Premier objet est un symbol - list, la seconde est l'expression 1:10 et ainsi de suite. Ce qui expliquerait pourquoi [-1L] est nécessaire: il supprime devrait symbol d'arguments fournis dans ... (car il est toujours dans une liste).

      Comme Dirk états substitute renvoie "arbre d'analyse de la non évaluée expression".

      Lorsque vous appelez my_ellipsis_function(a=1:10,b=11:20,c=21:30) puis ... "crée" une liste d'arguments: list(a=1:10,b=11:20,c=21:30) et substitute faire une liste de quatre éléments:

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

      Premier élément n'ont pas de nom et c'est [[1]] Dirk réponse. Je parvenir les résultats à l'aide:

      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. Comme ci-dessus, nous pouvons utiliser str de vérifier ce que les objets sont dans une fonction.

      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

      C'est ok. Permet de voir substitute version:

         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

      N'est pas ce dont nous avions besoin. Vous aurez besoin de plus d'astuces pour faire face à ces types d'objets (comme dans write.csv).

    Si vous souhaitez utiliser ... alors vous devriez l'utiliser comme Shane réponse, par list(...).

    InformationsquelleAutor Marek
  2. 37

    Vous pouvez convertir les points de suspension dans une liste avec list() et effectuez vos opérations:

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

$b
[1] "numeric"

    De sorte que votre get_list_from_ellipsis fonction est rien de plus que list.

    Valide d'un cas d'utilisation de ce est dans le cas où vous souhaitez passer dans un nombre indéterminé d'objets pour l'opération (comme dans votre exemple de c() ou data.frame()). Ce n'est pas une bonne idée d'utiliser le ... quand vous savez que chaque paramètre à l'avance, cependant, car il ajoute une certaine ambiguïté, et d'autre complication de la chaîne d'argument (et fait de la signature de la fonction claire pour tout autre utilisateur). La liste d'arguments est une pièce importante de la documentation de la fonction des utilisateurs.

    Sinon, il est également utile pour les cas où vous souhaitez passer des paramètres à un sous-fonction sans s'exposer à tous dans vos propres arguments de la fonction. Cette information peut être indiquée dans la documentation des fonctions.

    • Je sais que sur l'utilisation des points de suspension comme pour les arguments de subfunctions, mais c'est aussi une pratique courante chez les R primitives à utiliser les points de suspension dans la façon dont je l'ai décrit. En fait, le list et c fonctions fonctionnent de cette façon, mais les deux sont primitives, donc je ne peux pas facilement inspecter le code source pour comprendre comment ils fonctionnent.
    • rbind.data.frame utiliser de cette façon.
    • Si list(...) est suffisante, pourquoi faire R les builtins comme data.frame utiliser la forme longue as.list(substitute(list(...)))[-1L] à la place?
    • Comme je n'ai pas créer data.frame, je ne connais pas la réponse à ça (cela dit, je suis sûr qu'il y a est une bonne raison pour cela). J'utilise list() à cet effet dans mes paquets et n'avons pas encore rencontré un problème avec elle.
    InformationsquelleAutor Shane
  3. 31

    Juste pour ajouter à Shane et Dirk réponses: il est intéressant de comparer

    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

    avec

    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

    Comme il est, soit la version s'affiche adaptés à vos besoins dans my_ellipsis_function, si le premier est clairement plus simple.

    InformationsquelleAutor Richie Cotton
  4. 14

    Vous a donné la moitié de la réponse déjà. Envisager

    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>

    Si cela a pris deux arguments a et b à partir de l'appel et l'a converti en une liste. N'était-ce pas ce que vous avez demandé?

    • Pas tout à fait ce que je veux. Qui semble renvoyer une liste de listes. Avis de la [[1]]. Aussi, je voudrais savoir comment l'incantation magique as.list(substitute(list(...))) œuvres.
    • L'intérieur list(...) crée un list objet basé sur les arguments. Puis substitute() crée l'arbre d'analyse pour les non évaluée expression; consultez l'aide de cette fonction. Ainsi qu'un bon de texte avancé sur R (ou S). Ce n'est pas anodin des trucs.
    • Ok, quel est le [[-1L]] partie (à partir de ma question)? Ne devrait-elle pas être [[1]]?
    • Vous avez besoin de lire sur l'indexation. Le signe moins signifie "exclure", c'est à dire print(c(1:3)[-1]) imprime 2 et 3 seulement. Le L est d'un nouveau genre pour que cela se termine comme un entier, cela se fait beaucoup dans la R sources.
    • Je n'ai pas besoin de lire sur l'indexation, mais je ne besoin de payer plus d'attention à la sortie des commandes que vous montrez. La différence entre les [[1]] et la $a indices m'a fait penser que des listes imbriquées ont été impliqués. Mais maintenant je vois que ce que vous obtenez est la liste que je veux, mais avec un élément supplémentaire à l'avant. Alors la [-1L] de sens. Où est-ce que supplémentaires premier élément de venir, de toute façon? Et est-il une raison je devrais utiliser ce lieu de simplement list(...)?
    InformationsquelleAutor Dirk Eddelbuettel
  5. 5

    Cela fonctionne comme prévu.
    La suite est une session interactive:

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

    Même, sauf avec un argument par défaut:

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

    Comme vous pouvez le voir, vous pouvez l'utiliser pour passer des "extra" les arguments d'une fonction au sein de votre fonction si les valeurs par défaut ne sont pas ce que vous voulez dans un cas particulier.

    InformationsquelleAutor Overloaded_Operator