Início / coding / Perguntas / 78918585
Accepted
Andi
Asked: 2024-08-27 19:11:45 +0800 CST

Contar os mesmos números consecutivos na coluna da lista no dataframe polars

  • 772

Tenho pl.DataFrameuma coluna que compreende listas com inteiros. Preciso afirmar que cada inteiro consecutivo está aparecendo duas vezes em uma fileira no máximo.

Por exemplo, uma lista contendo [1,1,0,-1,1]estaria OK, já que o número 1 aparece no máximo duas vezes seguidas (os dois primeiros elementos, seguidos por um zero).

Esta lista deve levar a uma afirmação falha: [1,1,1,0,-1]o número 1aparece três vezes seguidas.

Aqui está um exemplo de brinquedo, onde isso row2deve levar a uma afirmação falha.

import polars as pl

row1 = [0, 1, -1, -1, 1, 1, -1, 0]
row2 = [1, -1, -1, -1, 0, 0, 1, -1]
df = pl.DataFrame({"list": [row1, row2]})
print(f"row1: {row1}")
print(f"row2: {row2}")
print(df)


row1: [0, 1, -1, -1, 1, 1, -1, 0]
row2: [1, -1, -1, -1, 0, 0, 1, -1]
shape: (2, 1)
┌───────────────┐
│ list          │
│ ---           │
│ list[i64]     │
╞═══════════════╡
│ [0, 1, … 0]   │
│ [1, -1, … -1] │
└───────────────┘
python

3 respostas

  1. Best Answer

    O seguinte poderia ser usado.

    1. Execute a codificação de comprimento de execução da lista usando pl.Expr.rle. Isso produz uma lista de structs. Cada struct contém um valor de lista (único) e o comprimento de execução correspondente.

    2. Verifique se o comprimento máximo de execução na lista é no máximo 2.

    3. Certifique-se de que o resultado seja do tipo boolselecionando o primeiro (e único) elemento na lista resultante (usando pl.Expr.list.first).

    df.with_columns(
    ok=pl.col("list").list.eval(
        pl.element().rle().struct.field("len").max() <= 2
    ).list.first()
)

    shape: (2, 2)
┌──────────────────────────────┬───────┐
│ list                         ┆ ok    │
│ ---                          ┆ ---   │
│ list[i64]                    ┆ bool  │
╞══════════════════════════════╪═══════╡
│ [0, 1, -1, -1, 1, 1, -1, 0]  ┆ true  │
│ [1, -1, -1, -1, 0, 0, 1, -1] ┆ false │
└──────────────────────────────┴───────┘

    Fazer tudo isso em um pl.Expr.list.evalpode ser evitado explodindo a lista. Então, uma função de janela ( pl.Expr.over) é necessária para garantir que o máximo seja computado separadamente para cada lista.

    max_run_length = pl.col("list").explode().rle().struct.field("len").max().over(pl.int_range(pl.len()))
df.with_columns(passed=max_run_length <= 2)

    O resultado será o mesmo.

    • 5

  2. Você certamente precisa de um método para verificar os números consecutivamente e filtrar o Dataframe a partir daí.

    Algo como:

    def check_consecutive_repeats(list):
    count = 1
    prev = list[0]
    
    for i in range(1, len(list)):
        if list[i] == prev:
            count += 1
            if count > 2:
                return False
        else:
            count = 1
            prev = list[i]
    
    return True

    Isso iterará pela lista e verificará se um determinado caractere se repete mais de 2 vezes; se sim, retornará Falso.

    A partir daí você pode decidir o que fazer com a lista que falhou.

    Você também pode encontrar outras soluções aqui .

    • 0

  3. Usando map_elementscom um gerador e curto-circuito:

    N = 2

df.with_columns(
    valid=pl.col('list').map_elements(
        lambda x: all(
            any(x[i] != x[i+1:i+N+1]) for i in range(len(x)-N+1)
        ), return_dtype=pl.Boolean
    )
)

    Saída:

    ┌───────────────┬───────┐
│ list          ┆ valid │
│ ---           ┆ ---   │
│ list[i64]     ┆ bool  │
╞═══════════════╪═══════╡
│ [0, 1, … 0]   ┆ true  │
│ [1, -1, … -1] ┆ false │
└───────────────┴───────┘
    • 0

relate perguntas