Início / coding / Perguntas / 77977777
Accepted
FreelanceConsultant
Asked: 2024-02-12 01:49:56 +0800 CST

Como particionar um dicionário em Python?

  • 772

Muitas linguagens fornecem uma biblioteca padrão que fornece um tipo de dicionário ou mapa de árvore binária. Muitas dessas implementações de estruturas de dados fornecem uma função para dividir a estrutura de dados em um par de estruturas de dados com base em alguma condição.

Isso é conhecido como operação de partição. Rust chama isso de "separação". Os tipos C++ maptêm operação de "limite inferior" e "limite superior" para comparação com chaves. A biblioteca padrão também fornece uma operação de "partição" que existe no std::algorithm.

Não consigo ver uma maneira ideomática de fazer isso em Python. Consegui criar uma maneira manual de fazer isso, mas não gosto muito desse código, porque ele não divide um dictem duas partes, mas divide uma parte e depois divide outra parte, resultando em código frágil (e duplicado).

map = {
   ...
}

map_part_1 = {
    key: value for key, value in map.items() if <condition>
}

map_part_2 = {
    key: value for key, value in map.items() if not <condition>
}

Não é ótimo, certo? Existe uma maneira melhor?

python

3 respostas

  1. Best Answer

    Apenas um auxiliar mais curto (do que o da sua resposta) que avalia a condição apenas uma vez para cada item:

    def dict_partition(input: dict, condition: Callable[[Any, Any], bool]) -> tuple[dict, dict]:
    dicts = ({}, {})
    for key, value in input.items():
        dicts[condition(key, value)][key] = value
    return dicts

    Se você quiser manter a ordem do primeiro dict sendo o dicionário de condições avaliadas verdadeiras, e o segundo dicionário sendo o dicionário de condições avaliadas falsas, substitua return dictspor return dicts[::-1].

    Experimente isso online!

    • 2

  2. Não estou convencido de que esta seja a melhor abordagem. Funciona, mas requer a escrita de uma função auxiliar.

    def dict_partition(input: dict, condition: Callable[[Any, Any], bool]) -> tuple[dict, dict]:

    dict_1 = {
        key: value
            for key, value in input.items()
                if condition(key, value)
    }

    dict_2 = {
        key: value
            for key, value in input.items()
                if not condition(key, value)
    }

    return (dict_1, dict_2)

    Que seria então usado com a lambda, assim:

    (dict_1, dict_2) = \
    dict_partition(map, lambda key, value: key < 3)

    Este caso de teste demonstra que funciona.

    from .dict_partition import dict_partition

def test_dict_partition():

    input = {
        1: 'one',
        2: 'two',
        3: 'three',
        4: 'four',
        5: 'five'
    }

    (dict_1, dict_2) = dict_partition(input, lambda key, value: key < 3)

    dict_1_expected = {
        1: 'one',
        2: 'two'
    }

    dict_2_expected = {
        3: 'three',
        4: 'four',
        5: 'five'
    }

    assert dict_1 == dict_1_expected, 'dict_1 fail test case'
    assert dict_2 == dict_2_expected, 'dict_2 fail test case'

    Mas talvez exista alguma solução melhor que não exija que escrevamos nossa própria função auxiliar para fazer isso?

    • 1

  3. Talvez esteja faltando alguma coisa, mas você pode fazer isso em um loop:

    def dict_partition(dct, condition):
    d1, d2 = {}, {}
    for k, v in dct.items():
        if condition(v):
            d1[k] = v
        else:
            d2[k] = v
    return d1, d2


dct = {"a": 1, "b": 2, "c": 3, "d": 4}
print(dict_partition(dct, lambda x: x > 2))

    Impressões:

    ({'c': 3, 'd': 4}, {'a': 1, 'b': 2})

    Se quiser modificar o dicionário de entrada, você pode usar dict.pop:

    dct1 = {"a": 1, "b": 2, "c": 3, "d": 4}
dct2 = {k: dct1.pop(k) for k in [*dct1] if dct1[k] > 2}

print(dct1)
print(dct2)

    {'a': 1, 'b': 2}
{'c': 3, 'd': 4}
    • 1

relate perguntas