All perguntas(coding)

Digamos que eu tenha:

data = {
    'id': ['a', 'a', 'a', 'b', 'b', 'b', 'b'],
    'd': [1,2,3,0,1,2,3],
    'sales': [5,1,3,4,1,2,3],
}

Gostaria de adicionar uma coluna com uma média móvel com tamanho de janela 2, com min_periods=2, sobre'id'

Em Polars, eu posso fazer:

import polars as pl

df = pl.DataFrame(data)
df.with_columns(sales_rolling = pl.col('sales').rolling_mean(2).over('id'))

shape: (7, 4)
┌─────┬─────┬───────┬───────────────┐
│ id  ┆ d   ┆ sales ┆ sales_rolling │
│ --- ┆ --- ┆ ---   ┆ ---           │
│ str ┆ i64 ┆ i64   ┆ f64           │
╞═════╪═════╪═══════╪═══════════════╡
│ a   ┆ 1   ┆ 5     ┆ null          │
│ a   ┆ 2   ┆ 1     ┆ 3.0           │
│ a   ┆ 3   ┆ 3     ┆ 2.0           │
│ b   ┆ 0   ┆ 4     ┆ null          │
│ b   ┆ 1   ┆ 1     ┆ 2.5           │
│ b   ┆ 2   ┆ 2     ┆ 1.5           │
│ b   ┆ 3   ┆ 3     ┆ 2.5           │
└─────┴─────┴───────┴───────────────┘

Qual é o equivalente do DuckDB? Eu tentei

import duckdb

duckdb.sql("""
    select
        *,
        mean(sales) over (
            partition by id 
            order by d
            range between 1 preceding and 0 following
        ) as sales_rolling 
    from df
""").sort('id', 'd')

mas pegue

┌─────────┬───────┬───────┬───────────────┐
│   id    │   d   │ sales │ sales_rolling │
│ varchar │ int64 │ int64 │    double     │
├─────────┼───────┼───────┼───────────────┤
│ a       │     1 │     5 │           5.0 │
│ a       │     2 │     1 │           3.0 │
│ a       │     3 │     3 │           2.0 │
│ b       │     0 │     4 │           4.0 │
│ b       │     1 │     1 │           2.5 │
│ b       │     2 │     2 │           1.5 │
│ b       │     3 │     3 │           2.5 │
└─────────┴───────┴───────┴───────────────┘

Isso é muito próximo, mas o duckdb ainda calcula a média móvel quando há apenas um único valor na janela. Como posso replicar o min_periods=2comportamento (padrão) do Polars?

Hoje tive que fazer uma função assim

data1 %>%
  summarise(
   ab1 = fn(a1, b1),
   ab2 = fn(a2, b2), 
   ab3 = fn(a3, b3) 
  )
# imagine if there are 100 of them

Se fnfosse uma função de argumento único eu poderia ter feito

data1 %>%
  summarise(across(starts_with("a", fn)))

Mas infelizmente, minha função precisa de duas colunas como entradas. Existe uma maneira de fazer isso de forma mais elegante?

Sou novo no Blazor e estou tentando descobrir como o Blazor renderiza componentes em tags HTML. Se eu usar um componente simples como este:

<InputText @bind-Value="testvalue" id="sample-textbox"></InputText>

@code {
    public string testvalue = "abc123";
}

Então executo meu aplicativo, abro as ferramentas de desenvolvimento e o HTML resultante é este:

<input id="sample-textbox" _bl_e4f3714a-7294-49f4-9c79-90762626ed41="">

Qual é o propósito de _bl_e4f3714a-7294-49f4-9c79-90762626ed41?

Estou pesquisando em uma base de código contendo milhares de ocorrências de foo in list(bar), por exemplo:

• como uma expressão booleana:

if foo in list(bar) or ...:
   ...

• em um loop for:

for foo in list(bar):
    ...

• em uma expressão geradora:

",".join(str(foo) for foo in list(bar))

Existe um cenário (como uma versão dada do Python, um comportamento conhecido com um verificador de tipos, etc...) onde foo in list(bar)não é apenas uma versão de foo in bar? O que estou esquecendo aqui?

Em R, é possível obter o caminho completo e o nome do arquivo (no Windows) de um arquivo copiado para a área de transferência?

O pano de fundo é que tenho vários arquivos grandes do Excel contendo dados que gostaria de processar em R. O sistema de arquivos é relativamente desestruturado, então obter os caminhos/nomes de arquivo desses arquivos programaticamente não é realmente uma opção. Não quero abrir os arquivos do Excel para copiar e colar dados em Rnenhum dos dois, porque abrir Excels grandes leva muito tempo. Então, estou procurando uma opção onde eu possa navegar até um arquivo usando o explorador de arquivos, copiar o arquivo para a área de transferência e, em seguida, ler o conteúdo do arquivo em R, o que eu poderia configurar se eu pudesse extrair o nome do arquivo e o caminho.

Ambos utils::readClipboard()e clipr::read_clip()retornam NULLse um arquivo for copiado para a área de transferência.

Estou gerando um gráfico e tentando descobrir como suprimir apenas um rótulo de marca de verificação (não a marca, apenas o rótulo).

Aqui está um exemplo de código:

x1 <- seq(0, 100, by = 1)
y1 <- runif(n = 100, min = 1, max = 10)
library(rando)
labe <- r_Letters(nchar = 1, n = 100)

test_dat <- as.data.frame(cbind(x1, y1, labe))
test_dat$x1 <- as.numeric(test_dat$x1)
test_dat$y1 <- as.numeric(test_dat$y1)

library(ggplot2)
library(ggrepel)
g <- ggplot(data = test_dat, aes(x = x1, y = y1))
g <- g + geom_line()
g <- g + geom_point()
g <- g + expand_limits(x = c(-10, 110), y = c(0, 10))
g <- g + scale_x_continuous(breaks = scales::pretty_breaks(n = 25))
g <- g + scale_y_continuous(breaks = scales::pretty_breaks(n = 5))
g <- g + geom_label_repel(data = test_dat, aes(x = x1, y = y1, label = labe), 
                         size = 2.0, color = "blue", box.padding = unit(0.5, "lines"), 
                         point.padding = unit(0, "lines"))
g

No meu conjunto de dados real, quando uso geom_label_repel para rotular meus pontos (um subconjunto dos meus dados reais; fiquei preguiçoso no meu exemplo), precisei estender o intervalo do gráfico (daí, expand_limits). Todas as marcas de escala estão onde eu gostaria, mas a da extrema esquerda (-15 no meu exemplo) não é física e eu gostaria de remover apenas essa.

Posso descobrir como suprimir todas as marcas de seleção e todos os rótulos, mas não é isso que estou procurando. Quero deixar as marcas de seleção como estão, mas apenas remover o rótulo daquela que está mais à esquerda.

Alguma ideia?

Estou vendo uma peculiaridade na ctable()função do pacote summarytools do R e estou tentando ver se estou esquecendo de algo aqui.

A vinheta de introdução do ctable afirma que "Os operadores de pipe do magrittr (%>%, %$%) e pipeR (%>>%) são totalmente suportados; o nativo |> introduzido no R 4.0 também é suportado."

Usar o pipe nativo funciona conforme o esperado para as funções freq()e descr().

No entanto, estou tendo problemas com o pipe nativo para ctable(). Se eu usar o pipe nativo, recebo um Error: object 'ObjectName' not foundwhere ObjectName é uma das variáveis ​​na ctable()função. Não funciona com o pipe magrittr regular. No entanto, ctable()funciona se eu alternar para o pipe de exposição magrittr %$%. Não encontrei nenhuma diferença se eu adicionar as especificações de argumento x= e y=.

Outra peculiaridade nessa bagunça é que ctable()funciona com um pipe nativo SE eu reduzir o quadro de dados selecionando apenas as duas colunas que eu quero para o ctable(). No entanto, eu tenho que remover os nomes das colunas do ctable()nesse caso, senão eu recebo um erro; além disso, os nomes das colunas que imprimem nos resultados parecem horríveis e não são úteis.

Estou esquecendo de algo aqui? Não deveria ctable()funcionar da mesma forma freq()ou descr()ao usar o pipe nativo ou o pipe magrittr regular?

Para aqueles curiosos sobre o motivo pelo qual meus exemplos têm o as.factor(), até onde eu sei, ctable()ainda tem o problema do PrettyNum ao usar valores numéricos -- veja o Github de Dominic Comtois e esta postagem do SO .

Exemplos reproduzíveis

# setup
library(summarytools)
library(magrittr)
library(dplyr)
data("mtcars")

# these work just fine as expected
freq(mtcars$cyl)
mtcars |> freq(cyl)
mtcars |> descr(qsec)
mtcars |> subset(select=c(qsec, hp)) |> descr()

# ctable not working with the native pipe or regular magrittr pipe
mtcars |>
  mutate(cyl = as.factor(cyl), gear = as.factor(gear)) |> 
  # mutate(cyl = as.factor(cyl), gear = as.factor(gear)) %>%
  ctable(cyl, gear)

# ctable works with the exposion pipe
mtcars |>
  mutate(cyl = as.factor(cyl), gear = as.factor(gear)) %$%
  ctable(cyl, gear)

# ctable works with native pipe if also selecting to only the columns for ctable, but output looks off
mtcars |>
  mutate(cyl = as.factor(cyl), gear = as.factor(gear)) |> 
  select(cyl, gear) |> 
  # ctable(cyl, gear)  # gives error
  ctable()  # no error

Estudei recentemente os conceitos genéricos em Typescript. Tenho um problema em entender "Por que as funções contravariância com seus parâmetros?" . Eu sei que:

1. Covarianceé se T extends U( Té atribuível a U), é verdade que G<T> extends G<U>( G<T>também é atribuível a G<U>)

2. Contravarianceé se T extends U, é certo concluir que G<U> extends G<T>(agora G<U>é atribuível a G<T>).

antes de fazer a pergunta neste fórum, li as seguintes postagens. No entanto, ainda tenho dificuldade em entender por que as funções no Typescript são contravariantes em seus parâmetros :

• Por que o tipo de acesso indexado usando genéricos resulta em interseção?
• O que são covariância e contravariância?
• Diferença entre Variância, Covariância, Contravariância, Bivariância e Invariância em TypeScript
• Covariância e Contravariância em TypeScript

Vejo que não apenas funções são contravariantes com seus parâmetros em TypeScript, mas algumas outras linguagens também são verdadeiras.

Sinto-me tão frustrado por aceitar isso sem descobrir por que é verdade. Você poderia me ajudar a explicar ou se eu estiver faltando conhecimento relacionado, por favor me diga o que é.

Tenho um gerador que não usa send()valores. Devo digitar send_valuecomo Anyou None?

import typing as t

def pi_generator() -> t.Generator[int, ???, None]:
    pi = "3141592"
    for digit in pi:
        yield int(digit)

pi_gen = pi_generator()
next(pi_gen)  # 3
pi_gen.send('foo')  # 1
pi_gen.send(pi_gen)  # 4

Razões que vejo para Any:

• O gerador funciona perfeitamente bem com send()qualquer tipo, então se alguém tiver um motivo para usar .send(1)este gerador, está tudo bem.
• Os tipos de argumentos dos métodos devem ser gerais e .send(x: Any)são mais gerais que .send(x: None).

Razões que vejo para None:

• Os tipos de retorno devem ser específicos, e "Gerador que nunca usa envio" é um tipo mais específico do que "Qualquer tipo de gerador".
• Se alguém estiver usando .send()esse gerador, é provável que não esteja entendendo o que ele faz e a dica de tipo deve informá-lo.

Exemplo TS Playground

Código de exemplo

type Base = {
  name: string
}

type ExtA = {
  address: string
}

type ExtB = {
  streetName: string;
}

function handler<T extends Base>(input: T): T {return input}
/** how do I build an object up? */


let payload = {
  name: "Aaron"
}
const addA = <T extends Base>(payload: T): T & ExtA => {
  return {
    ...payload,
    type: "a",
    address: "123 Fake St"
  }
}
const addB = <T extends Base>(payload: T): T & ExtB => {
  return {
    ...payload,
    type: "b",
    streetName: "Main"
  }
}

payload = addA(payload)
payload = addB(payload)

// type should be Base & ExtA & ExtB but it isn't
const wrongType = handler(payload)
//    ^?

Estou esperando payloadmudar o tipo conforme ele passa pelas minhas funções de manipulação addA, addBmas não está. Como faço para que o TS entenda que o tipo dessa variável deve estar mudando?