Início / coding / Perguntas / 79373782
Accepted
thothal
Asked: 2025-01-21 17:06:10 +0800 CST

Crie chamadas não avaliadas com operadores de desativação do Tidyverse

  • 772

Suponha que eu tenha a seguinte estrutura de dados:

library(dplyr)
d <- tibble(x = paste0("x", 1:3), 
            op = c("f", "g", "h"), 
            y = paste0("y", 1:3), 
            res = paste0("z", 1:3))

Quero criar uma nova coluna cmdque contenha uma chamada não avaliada que deve ficar assim:

(D <- d %>%
  mutate(cmd = list(quote(z1 <- f(x1, y1)), 
                    quote(z2 <- g(x2, y2)), 
                    quote(z3 <- h(x3, y3)))))
# # A tibble: 3 × 5
#   x     op    y     res   cmd       
#   <chr> <chr> <chr> <chr> <list>    
# 1 x1    f     y1    z1    <language>
# 2 x2    g     y2    z2    <language>
# 3 x3    h     y3    z3    <language>

mas é claro que não quero codificar essas linhas, mas queria extrair esses valores das linhas correspondentes de d, mas não tive sucesso:

d %>%
  rowwise() %>%
  mutate(cmd = list(expr(!!sym(res) <- !!sym(op)(!!sym(x), !!sym(y)))))

resulta em:

Error: object 'res' not found

Como eu alcançaria o objetivo?

O NB cmd será finalmente avaliado em um ambiente onde os argumentos e as funções são definidos, então conceitualmente algo como:

e <- list2env(list(x1 = 1, x2 = 2, x3 = 3, y1 = 2, y2 = 2, y3 = 3, 
              f = \(x, y) x + y, g = \(x, y) x - y, h = \(x, y) x * y))

eval(D$cmd[[1]], e)
e$z1
# [1] 3

5 respostas

  1. Uma possibilidade seria recorrer ao substituto:

    d %>%
  rowwise() %>%
  mutate(cmd = list(substitute(RR <- FF(XX, YY), 
                               list(RR = as.name(res), 
                                    FF = as.name(op), 
                                    XX = as.name(x), 
                                    YY = as.name(y)))))

    Mas ainda estou procurando uma solução tidyverse.

    • 4

  2. em Base R você poderia fazer:

    fn <- function(x, op, y, res){
  call("<-", as.name(res), call(op, as.name(x), as.name(y)))
}
 do.call(Map, c(fn, d))
$x1
z1 <- f(x1, y1)

$x2
z2 <- g(x2, y2)

$x3
z3 <- h(x3, y3)

    mutate(d, cmd = do.call(Map, c(fn, d)))
# A tibble: 3 × 5
  x     op    y     res   cmd         
  <chr> <chr> <chr> <chr> <named list>
1 x1    f     y1    z1    <language>  
2 x2    g     y2    z2    <language>  
3 x3    h     y3    z3    <language>
    • 4

  3. Isto é muito longo para um comentário, portanto, postando como uma resposta. Pode ser útil para pessoas que estão encontrando esta pergunta.

    Acho que você tem um problema de design. O conselho padrão parece se aplicar: não crie variáveis ​​numeradas em um ambiente. Use vetores e listas.

    e <- list2env(list(x = 1:3, 
                   y = c(2, 2, 3),
                   funs = list(f = \(x, y) x + y, 
                               g = \(x, y) x - y, 
                               h = \(x, y) x * y)
                   )
              )

e$res <- with(e, Map(\(f, x, y) f(x, y), funs, x, y))
e$res
#$f
#[1] 3
#
#$g
#[1] 0
#
#$h
#[1] 9

    Este é apenas um exemplo de uso. Você pode, é claro, subconjuntor os vetores/listas de acordo com meta-informações como em seu d. O ponto é que você não precisa construir chamadas (e certamente não chamadas para <-) e avaliá-las como você propõe.

    • 3
  4. Best Answer

    Você tem boas respostas básicas de R, então vou focar em tidyverse, que parece mudar muito. Esta pergunta de 2017 está relacionada a parte da sua pergunta (construindo uma chamada de atribuição), mas a resposta aceita sugere usar rlang::lang(), que agora está obsoleto em favor de rlang::call2(). Então, acho que a tidyverseabordagem recomendada agora seria esta:

    library(dplyr)
library(rlang)

D <- d %>%
    rowwise() %>%
    mutate(
        cmd = list(
            call2(
                `<-`, sym(res), call2(op, sym(x), sym(y))
            )
        )
    ) %>%
    ungroup()

    O que lhe dá uma cmdcoluna parecida com esta:

    D$cmd
# .Primitive("<-")(z1, f(x1, y1))

# [[2]]
# .Primitive("<-")(z2, g(x2, y2))

# [[3]]
# .Primitive("<-")(z3, h(x3, y3))

    Que avalia como desejado no ambiente da sua pergunta:

    sapply(D$cmd, \(x) eval(x, e))
# [1] 3 0 9

    E também podemos ver que isso atribui às variáveis ​​desejadas em e:

    mget(d$res, e)
# $z1
# [1] 3

# $z2
# [1] 0

# $z3
# [1] 9
    • 3

  5. Como as colunas de entrada são todas strings, parece fazer sentido usar a manipulação de strings primeiro e então converter para expressões R no final. Nesse caso, gluepode ser usado como mostrado:

    library(dplyr)
library(glue)
library(rlang)

result <- d %>%
  mutate(cmd = parse_exprs(glue("{res} <- {op}({x}, {y})") ))

identical(result, D)
## [1] TRUE

    Atualizar

    Usei parse_exprsno lugar de parse_exprcomo sugerido por @SamR eliminando rowwise.

    • 3

relate perguntas