Сгенерировать все возможные булевы случаи из n булевых значений [закрыто]

Если существуют два поля, соответствующие поля являются логическими значениями.

• x_field
• y_field

Я хочу сгенерировать все случаи, которые могут возникнуть, когда есть несколько логических полей.

Например, существует всего 4 комбинации, которые могут быть созданы двумя логическими полями, как указано выше.

• x_field(истина), y_field(истина)
• x_field(истина), y_field(ложь)
• x_field(ложь), y_field(истина)
• x_field(ложь), y_field(ложь)

Если у вас есть массив с двумя полями, которые являются логическим типом, можете ли вы сгенерировать все случаи и выразить в таком виде?

# перед вычислениями ...
fields = ["x_field", "y_field"]

# после вычислений ... 
fields = [{
"x_field": True, "y_field": True,
"x_field": True, "y_field": False,
"x_field": False, "y_field": True,
"x_field": False, "y_field": False,
}]

Вот решение с использованием namedtuple и немного битовой магии:

from collections import namedtuple

def from_bit_field(obj_type: type, number):
    dict_obj = {}
    for field in obj_type._fields:
        # присвоить поле с последним битом
        dict_obj[field] = bool(number & 1)
        # перейти к следующему биту
        number >>= 1

    obj = obj_type(**dict_obj)
    return obj

def get_all_combos(*names: list[str]):
    Item = namedtuple("Item", names)

    result = []
    for number in range(2 ** len(names)):
        # числа от 0 до 2**len-1 содержат все возможные битовые комбинации
        result.append(from_bit_field(Item, number))

    return result

if __name__ == "__main__":
    print(get_all_combos("x", "y", "z"))

    # namedtuples удобны, так как позволяют вам преобразовывать их в кортежи
    print([tuple(i) for i in get_all_combos("x", "y", "z")])

Количество случаев равно 2^n, где n — это количество полей.

и предполагая, что есть синтаксическая ошибка, и результат, который вы хотите для приведенного примера, это Collection[Dict], т.е.:

# после вычислений ... 
fields = [
  {"x_field": True, "y_field": True},
  {"x_field": True, "y_field": False},
  {"x_field": False, "y_field": True},
  {"x_field": False, "y_field": False},
]

Самый простой и прямолинейный (хотя и не самый элегантный или производительный) способ подойти к этому — это перебрать все случаи и использовать то, что Python сравнивает dict с литералами, сравнивая пары ключ-значение (чтобы сократить избыточные случаи):

def allCombinations(fields : list[str]) -> list[dict[str,bool]]:
    result = []
    for f1 in fields:
        temp = result
        result = []
        if not temp: result.extend([{f1:True},{f1:False}])
        else:
            for f2 in temp:
                result.extend([{**f2,f1:True},{**f2,f1:False}])
    return result

Меня удивляет, что никто не предложил этот простой однострочник…

from itertools import product
fields = ['x', 'y', 'z']
[dict(zip(fields, values)) for values in product([True,False], repeat=len(fields))]

Вывод:

[{'x': True, 'y': True, 'z': True},
 {'x': True, 'y': True, 'z': False},
 {'x': True, 'y': False, 'z': True},
 {'x': True, 'y': False, 'z': False},
 {'x': False, 'y': True, 'z': True},
 {'x': False, 'y': True, 'z': False},
 {'x': False, 'y': False, 'z': True},
 {'x': False, 'y': False, 'z': False}]

Объяснение:

product([True,False], repeat=len(fields)) создает все 2**len(fields) комбинации значений True или False.

Затем, перебирая эти комбинации, zip(fields, values) сопоставляет каждое имя поля с его соответствующим значением.

В конце каждое такое сопоставление преобразуется в dict, и это превращается в список словарей по мере перебора всех комбинаций (через синтаксис генератора списка).

Вот один из способов решить эту задачу

# если вы используете версию python без указания типов,
# используйте `def combinations(fields):` вместо
def combinations(fields: list[str]) -> list[dict[str, bool]]:
    out = []
    for field in fields:
        partials = out
        out = []
        if partials:
            # создаем новые записи с новым полем как True или False.
            # нам нужны два списка, так как модификация списка во время
            # его перебора приводит к проблемам
            for entry in partials:
                out.append({**entry, field: True})
                out.append({**entry, field: False})
        else:
            # базовый случай для пустого списка
            out.append({field: True})
            out.append({field: False})

    return out

fields = ["x_field", "y_field"]
print(combinations(fields))

выводится

[{'x_field': True, 'y_field': True},
 {'x_field': True, 'y_field': False},
 {'x_field': False, 'y_field': True},
 {'x_field': False, 'y_field': False}]

а для входных данных ["a", "b", "c"]

[{'a': True, 'b': True, 'c': True},
 {'a': True, 'b': True, 'c': False},
 {'a': True, 'b': False, 'c': True},
 {'a': True, 'b': False, 'c': False},
 {'a': False, 'b': True, 'c': True},
 {'a': False, 'b': True, 'c': False},
 {'a': False, 'b': False, 'c': True},
 {'a': False, 'b': False, 'c': False}]