All perguntas(coding)

import polars as pl

df = pl.DataFrame(
    {
        'Letter': ['A', 'A', 'B', 'B', 'B', 'C', 'C', 'D','D','E'],
        'Value': [1, 2, 3, 4, 5, 6, 7, 8, 9,10]
    }
)

Quero agrupar Lettere coletar seus correspondentes Valueem uma lista.

Pergunta relacionada ao Pandas: Como agrupar linhas do dataframe em uma lista no pandas groupby

Eu sei que o código do pandas não funcionará aqui:

df.group_by('a')['b'].apply(list)

TypeError: 'GroupBy' object is not subscriptable

A saída será:

| A      ┆ [1, 2]    │
│ B      ┆ [3, 4, 5] │
│ C      ┆ [6, 7]    │
│ D      ┆ [8, 9]    │
│ E      ┆ [10]      |

Eu tenho um dataframe do pandas, por exemplo

df_dupl = pd.DataFrame({
    'EVENT_TIME': ['00:01', '00:01', '00:01', '00:03', '00:03', '00:03', '00:06', '00:06', '00:06', '00:08', '00:08', '00:10', '00:10', '00:11', '00:11', '00:13', '00:13', '00:13'],
    'UNIQUE_ID': [123, 123, 123, 125, 125, 125, 123, 123, 123, 127, 127, 123, 123, 123, 123, 123, 123, 123],
    'Value1': ['A', 'B', 'A', 'A', 'B', 'A', 'A', 'B', 'A', 'A', 'B', 'A', 'B', 'C', 'B', 'A', 'B', 'A'],
    'Value2': [0.3, 0.2, 0.2, 0.1, 1.3, 0.2, 0.3, 0.2, 0.2, 0.1, 1.3, 0.3, 0.2, 0.3, 0.2, 0.3, 0.2, 0.2]
})

Quero remover as sequências de linhas que possuem os mesmos valores das linhas anteriores (por EVENT_TIME) com o mesmo UNIQUE_ID. Para o exemplo o resultado deve ficar assim:

df = pd.DataFrame({
    'EVENT_TIME': ['00:01', '00:01', '00:01', '00:03', '00:03', '00:03', '00:08', '00:08', '00:10', '00:10', '00:11', '00:11', '00:13', '00:13', '00:13'],
    'UNIQUE_ID': [123, 123, 123, 125, 125, 125, 127, 127, 123, 123, 123, 123, 123, 123, 123],
    'Value1': ['A', 'B', 'A', 'A', 'B', 'A', 'A', 'B', 'A', 'B', 'C', 'B', 'A', 'B', 'A'],
    'Value2': [0.3, 0.2, 0.2, 0.1, 1.3, 0.2, 0.1, 1.3, 0.3, 0.2, 0.3, 0.2, 0.3, 0.2, 0.2]
}).

As linhas com horário 00:06 devem ser removidas, pois o subdataframe anterior com UNIQUE_ID 123 (horário 00:01) é idêntico. Por outro lado, as linhas com horário 00:13 devem permanecer - elas também são idênticas às linhas com horário 00:01, mas existem outras linhas com UNIQUE_ID 123 entre elas. A principal coisa é que quero comparar todos os sub-dataframes, não linhas únicas.

Posso alcançar o resultado desejado usando a seguinte função, mas é bastante lenta.

def del_dupl_gr(df):
    out = []
    for x in df['UNIQUE_ID'].unique():
        prev_df = pd.DataFrame()
        for y in df[df['UNIQUE_ID'] == x]['EVENT_TIME'].unique():
            test_df = df[(df['UNIQUE_ID'] == x) & (df['EVENT_TIME'] == y)]
            if not test_df.iloc[:, 2:].reset_index(drop=True).equals(prev_df.iloc[:, 2:].reset_index(drop=True)):
                out.append(test_df)
                prev_df = test_df
    return pd.concat(out).sort_index().reset_index(drop=True)

O dataframe real é bastante grande (mais de um milhão de linhas) e esse loop leva muito tempo. Tenho certeza de que deve haver uma maneira adequada (ou pelo menos mais rápida) de fazer isso.

Resultados

Obrigado por todas as respostas enviadas. Eu comparei a velocidade deles. Em alguns casos, editei ligeiramente os métodos para produzir exatamente os mesmos resultados. Portanto, em todos os métodos sort_values ​​adicionei kind='stable' para garantir que a ordem seja preservada e no final adicionei .reset_index(drop=True).

Estou tentando combinar independentemente do caso.

regexp:RegExp pattern = re `(ax|test)is$`;

Deve corresponder ao eixo ou ao eixo.

Sou novo em reagir a arquivos ".jsx", agora posso executar deve buildtestar.

Tenho uma dúvida sobre como o navegador executa arquivos ".js". Se o projeto for build, então o navegador está executando o arquivo ".js", o que eu entendo porque o navegador pode executar o arquivo ".js".

mas durante dev, quando verifico a fonte do aplicativo no modo de desenvolvimento do navegador, ele mostra que no arquivo html existe um arquivo ".jsx"!

Então, como isso é possível? um navegador pode executar o arquivo ".jsx"? ou durante o modo dev, o servidor de desenvolvimento (como npm ou vite) está fazendo algo secreto? o navegador mostra o código-fonte como ".jsx", mas na verdade está executando outros arquivos (ocultos por npm ou vite)?

Ao clonar o repositório Qristal e tentar construir a imagem Docker com docker/Dockerfile, qual é a configuração apropriada para $QB_DIRisso está na linha 27 do Dockerfile:

WORKDIR $QB_DIR

Usando funções tidyverse, pretendo criar uma nova coluna de dados que some a soma cumulativa na primeira coluna, mas use incrementos não maiores que incr.

Isso poderia começar com df

incr <- 1.5
df <- data.frame(a = c(6,0,0,2.5,0,0))
df
    a
1 6.0
2 0.0
3 0.0
4 2.5
5 0.0
6 0.0

em seguida, crie uma nova coluna busando incr:

    a   b
1 6.0 1.5
2 0.0 1.5
3 0.0 1.5
4 2.5 1.5
5 0.0 1.5
6 0.0 1.0

Encontrei tidyr::uncount()e parecia uma função que poderia funcionar, mas preciso usar incrementos não inteiros. Geralmente tento transformar e usar funções vetorizadas e pensei um pouco para executá-las rowwise(), mas a maioria das minhas ideias requer iteração.

Do comentário abaixo: Se as analogias forem úteis, pense nisso como downloads em fila. A coluna amostra que você pressiona para baixar 6 MB no tempo 1, 0 MB para os tempos 2 e 3, depois pressiona para baixar 2,5 MB no tempo 4. Sua conexão, no entanto, só pode baixar na velocidade de incr. Então, se incrfor 1,5, a coluna bmostra o que realmente foi baixado. Você usa totalmente essa velocidade de conexão a cada período até baixar o resíduo final ( 1.0) no tempo 6.

Para destacar melhor a dimensionalidade, aqui está outro df:

incr <- 1.5
df <- data.frame(a = rep(0,100),b=rep(0,100))
df$a[c(30,33,38)] = c(6,2.5,1)
df[30:39,]
     a b
30 6.0 0
31 0.0 0
32 0.0 0
33 2.5 0
34 0.0 0
35 0.0 0
36 0.0 0
37 0.0 0
38 1.0 0
39 0.0 0

com uma saída desejada

     a   b
30 6.0 1.5
31 0.0 1.5
32 0.0 1.5
33 2.5 1.5
34 0.0 1.5
35 0.0 1.0
36 0.0 0.0
37 0.0 0.0
38 1.0 1.0
39 0.0 0.0

Estou implementando serialização json e desserialização de carimbos de data/hora com nlohmann::json. Depois de transformar std::chrono::time_pointpara mm/dd/yy hh:mm:sso estilo data-hora (de acordo com nossos requisitos, deve ser legível por humanos), naturalmente estou perdendo algumas informações, portanto, meu critério para a igualdade dos pontos no tempo após a desserialização é "diferente em não mais que um segundo".

Tudo estava funcionando bem na minha máquina local com o gcc 11.4.0, mas falhou no servidor de produção com o gcc 8.5.0.

Código mínimo para reproduzir o exemplo ao vivo do problema em godbolt :

#include <iostream>
#include <iomanip>
#include <chrono>
#include <string>

int main() {
    // serialization
    auto ts = std::chrono::system_clock::now();
    auto timeS_t = std::chrono::system_clock::to_time_t(ts);
    std::ostringstream outStream;
    outStream << std::put_time(std::localtime(&timeS_t), "%x %X");
    std::string tsStr = outStream.str();

    // deserialization
    std::istringstream ss(tsStr);
    std::tm t = {};
    ss >> std::get_time(&t, "%x %X");
    auto parsedTs = std::chrono::system_clock::from_time_t(std::mktime(&t));

    // difference in seconds
    int secDiff = std::chrono::duration_cast<std::chrono::seconds>(ts - parsedTs).count();

    // just debug prints
    std::cout << secDiff << std::endl;
    std::time_t ttp1 = std::chrono::system_clock::to_time_t(ts);
    std::time_t ttp2 = std::chrono::system_clock::to_time_t(parsedTs);
    std::cout << "ts1: " << std::ctime(&ttp1);
    std::cout << "ts2: " << std::ctime(&ttp2);

    // my equality criterion
    if (std::abs(secDiff) > 1) {
        std::cout << "FAIL\n";
    }
}

Com o compilador mais recente, obtenho resultados iguais, por exemplo

ts1: Thu Feb 22 16:06:25 2024
ts2: Thu Feb 22 16:06:25 2024

mas com o antigo vejo a diferença nos pontos no tempo em exatamente 100 anos:

ts1: Thu Feb 22 16:06:17 2024
ts2: Fri Feb 22 16:06:17 1924

Acho que pode ter algo a ver com std::localtime(&timeS_t)a rotina de serialização, mas não encontrei a função "reversa" para o desserializador. O que posso mudar para ter um comportamento consistente?

Para me familiarizar com Rust, decidi escrever um filtro bloom que é apoiado por um arquivo BitVec. Parte disso incluirá um savemétodo que serializa toda a estrutura usando serde e a grava em um arquivo. Infelizmente, recebo um erro do compilador ao derivar a Serializecaracterística:

use bitvec::vec::BitVec;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
pub struct BloomFilter {
    n: u64,  // items added
    m: u32,  // slice size
    k: u32,  // number of slices
    buf: BitVec,  // buffer
    state: [u8; 8],  // random state
}

error[E0277]: the trait bound `BitVec: Serialize` is not satisfied
    --> src/bloom.rs:12:10
     |
12   | #[derive(Serialize, Deserialize)]
     |          ^^^^^^^^^ the trait `Serialize` is not implemented for `BitVec`
...
17   |     buf: BitVec,  // buffer
     |     --- required by a bound introduced by this call

Minhas Cargo.tomldependências relevantes:

[dependencies]
bitvec = "1.0.1"
serde = { version = "1.0.196", features = ["derive"] }

Isso me parece estranho, já que os documentos do bitvec 1.0.1 mencionam Serialize(e Deserialize) como uma das características implementadas. Estou cometendo algum erro óbvio aqui?

Vamos ter um polars df:

df = pl.DataFrame(
    {
    'date': ['2022-01-01', '2022-01-02', '2022-01-07', '2022-01-17', '2022-03-02', '2022-06-05', '2022-06-07', '2022-07-02'],
    'col1': [4, 4, 2, 2, 2, 3, 2, 1],
    'col2': [1, 2, 3, 4, 1, 3, 3, 4],
    'col3': [2, 3, 4, 4, 3, 2, 2, 1]
    }
)

O df é classificado por data. Gostaria de criar uma coluna que me desse uma contagem de todas as linhas anteriores (data inferior) com todas as 3 colunas tendo um valor maior ou igual ao valor da linha atual. Ou em outras palavras:

Count rows
    where row_index < current_row_index &
          col1[row_index] >= col1[current_row_index] &
          col2[row_index] >= col2[current_row_index] &
          col3[row_index] >= col3[current_row_index]
)

O resultado deve ficar assim:

Eu tentei várias combinações de ,,,, etc. shift, mas não consegui descobrir. Também não consegui encontrar uma pergunta semelhante o suficiente para adotar sua resposta com êxito. Existe uma maneira de conseguir isso usando Polars? Agradeço antecipadamente.qeoverwhencum_count

O novo <=>operador torna a escrita de código mais conveniente e pode economizar algum desempenho se o algoritmo de comparação não for trivial, porque não precisa ser repetido duas vezes para obter a ordem completa.

Ou pelo menos pensei assim quando soube disso. Porém, quando tento usar na prática, em um switchdepoimento, não funciona.

Este código não compila:

#include <iostream>

void compare_values(int x, int y)
{
    switch (x <=> y)
    {
    case std::strong_ordering::less:
        std::cout << "is less\n";
        break;
    case std::strong_ordering::greater:
        std::cout << "is greater\n";
        break;
    case std::strong_ordering::equal:
        std::cout << "is equal\n";
        break;
    }
}

O compilador mostra um erro sugerindo que o valor retornado por <=>não pode ser usado em a switch:

<source>: In function 'void compare_values(int, int)':
<source>:5:15: error: switch quantity not an integer
    5 |     switch (x <=> y)
      |             ~~^~~~~
Compiler returned: 1

( exemplo ao vivo )

Eu acho que usar o operador de nave espacial no switch é um caso de uso bastante básico, óbvio e comum, então provavelmente existe algum truque para fazê-lo funcionar. Eu não consigo entender, no entanto.

Como posso corrigir esse código?