Python construye una tabla de verdad creciente dinámica

Question

Mi pregunta es simple: "¿cómo construir una tabla de verdad de crecimiento dinámico en python de una manera elegante?"

para n = 3

for p in False, True: 
    for q in False, True: 
     for r in False, True: 
      print '|{0} | {1} | {2} |'.format(int(p),int(q), int(r)) 

para n = 4

for p in False, True: 
    for q in False, True: 
     for r in False, True: 
      for s in False, True: 
       print '|{0} | {1} | {2} | {3}'.format(int(p),int(q), int(r), int(s)) 

me gustaría tener una función que toma n como parámetro y se acumula la mesa, no es necesario para imprimir la tabla, devolver una estructura de datos que representa la tabla también está bien.

Answer 1

Uso itertools.product():

table = list(itertools.product([False, True], repeat=n)) 

Resultado para n = 3:

[(False, False, False), 
(False, False, True), 
(False, True, False), 
(False, True, True), 
(True, False, False), 
(True, False, True), 
(True, True, False), 
(True, True, True)] 

Answer 2

Para consultar el módulo itertools

In [7]: [i for i in itertools.product([0,1], repeat=3)] 
Out[7]: 
[(0, 0, 0), 
(0, 0, 1), 
(0, 1, 0), 
(0, 1, 1), 
(1, 0, 0), 
(1, 0, 1), 
(1, 1, 0), 
(1, 1, 1)] 

Answer 3

itertools es realmente el camino a seguir como se ha señalado por todos Pero si realmente desea ver los aspectos prácticos del algoritmo requerido para esto, debe buscar recursive descent. Así es como funcionaría en su caso:

def tablize(n, truths=[]): 
    if not n: 
     print truths 
    else: 
     for i in [True, False]: 
      tablize(n-1, truths+[i]) 

Probado, trabajando

Esperanza esto ayuda

Answer 4

Las listas por comprensión son, por supuesto, más Pythonic.

def truthtable (n): 
    if n < 1: 
    return [[]] 
    subtable = truthtable(n-1) 
    return [ row + [v] for row in subtable for v in [0,1] ] 

Resultados, indentadas para clairity:

truthtable(1) 
[ [0], 
    [1] ] 

truthtable(3) 
[ [0, 0, 0], 
    [0, 0, 1], 
    [0, 1, 0], 
    [0, 1, 1], 
    [1, 0, 0], 
    [1, 0, 1], 
    [1, 1, 0], 
    [1, 1, 1] ] 

Como una función de generador con yield:

def truthtable (n): 
    if n < 1: 
    yield [] 
    return 
    subtable = truthtable(n-1) 
    for row in subtable: 
    for v in [0,1]: 
     yield row + [v] 

también simplemente cambiando el retorno de una matriz de comprensión para una expresión generador hace que el retorno tipo equivalente a la función de generador de la versión yield:

def truthtable (n): 
    if n < 1: 
    return [[]] 
    subtable = truthtable(n-1) 
    return (row + [v] for row in subtable for v in [0,1]) 

Answer 5

el retorno de una estructura de datos que representa la tabla está muy bien

... en ese caso range(2 ** n) es todo lo que necesita. Cada número en el rango representa una fila en la tabla de verdad. El i th bit de la representación binaria del número k es 1 si y solo si la variable i th es verdadera en la kª fila de la tabla.

Si desea una tabla real que puede utilizar:

[ [ ((row >> bit_index) & 1) == 1 for bit_index in range(n)] 
    for bit_index in range(2 ** n) ] 

Answer 6

que aquí le gusta primas 1-liners?

>>> truthtable = lambda n: [[(v>>i)&1 for i in range(n-1,-1,-1)] for v in range(1<<n)] if n>0 else [[]] 

100% testedos y trabajados.
(no se puede copiar/pegar el resultado, o el código anterior, porque estoy en un teléfono para Internet)