Wahrheitstabelle über funktion

[alfi-techno]

Ich möchte eine Wahrheitstabelle für den Ausdruck not(A or B) ausgeben. Die Verknüpfung soll über verknuepfung() erfolgen, die zwei boolesche Werte als Argument erhält und das Ergebnis der Verknüpfung als Zeichenkette zurückliefert. Zurückgegeben werden sollen entweder „wahr“ oder „falsch“. Die Ausgabe der Tabelle soll außerhalb der Funktion erfolgen.

Hier meine erste Version, welche die Vorraussetzungen noch nicht erfüllt:

def f( a, b ):
return not (a or b)
def main():
print( " a b | f" )
print( "-----------+---------" )
for a in [ 0, 1 ]:
for b in [ 0, 1 ]:
print( "%3d%3d |%3d" %
( a, b,
f( a, b ) ) )
main()

[noisefloor]

Hallo,

bitte in Zukunft den Code in eine Codeblock setzen, damit a) der Code lesbar ist und b) die Einrückungen erhalten bleiben - was bei Python ja essentiell ist. Den Codeblock bekommst du, wenn du im Editor auf die </> Schaltfläche klickst.

Ansonsten fehlt bei deinem Post die Frage... oder erwartest du implizit, dass jetzt jemand den Code hier so postest, wie du es gerne hättest?

Wenn deine Funktion f einen String zurück liefern soll, dann musst du das so programmieren. Im Moment wird ja ein Bool'scher Wert zurück geliefert. Dazu kannst du eine Fallunterscheidung einbauen, auf deren Ergebnis basierend dann "falsch" oder "wahr" zurück geliefert wird.
String-Formatierung mit % ist der gaaanz alte Weg bzw. der Weg, der schon länger veraltet ist. Ab Python 3.6 nimmt man f-Strings, ansonsten die `format`-Methode von Strings.

Gruß, noisefloor

[ThomasL]

Vorausgesetzt du benutzt ein Python >= 3.6 bekommst du deine gewünschte Ausgabe so:

Code: Alles auswählen

def f(a, b):
    return not (a or b)

def main():
    print( " a b | f" )
    print( "-----+--------" )
    for a in [ 0, 1 ]:
        for b in [ 0, 1 ]:
            print(f" {a} {b} | {f(a, b)}")

main()

a b | f
-----+--------
0 0 | True
0 1 | False
1 0 | False
1 1 | False

[DeaD_EyE]

Code: Alles auswählen

import operator
from itertools import product


op = {
    "|": operator.or_,
    "&": operator.and_,
    "^": operator.xor
}

def truth_table(symbol):
    ab_iterator = product(*[range(2)] * 2)
    for a, b in ab_iterator:
        print(f"{a} {symbol} {b} | {op[symbol](a, b)}")

Funktioniert ab Python 3.6
Wenn man den Format-String wegmacht, dann auch mit 3.5.

Der einzige Unterschied ist, dass ich verschachtelte Schleifen mit der Funktion product verhindere und ein mapping nach Funktionen aus dem operator Modoul verwende.

[KitKat3]

Ich habe eine Frage zu selbiger Problematik.
Meine Abfrage gibt mir noch nicht die richtige "Lösung" aus für den Fall, dass beide Werte "nicht" wahr sind.
Leider finde ich hier nicht den Fehler. Kann mir jemand diesbezüglich behilflich sein?
Der Code sieht wie folgt aus:

Code: Alles auswählen

[def verknuepfung (a, b):            
    if not (a or b) == 0:
        return "falsch"
    else:
        return "wahr"
    
#die Ausgabe
def ausgabe(a, b):
    print ("a b result")
    for a in liste_a:
        for b in liste_b:
            print (a, b, verknuepfung (liste_a, liste_b))
   
#Erstellen von zwei Listen
liste_a = [0, 1]
liste_b = [0, 1]

# Aufruf der Funktion
verknuepfung (liste_a, liste_b)

#Aufruf der Ausgabe
ausgabe (liste_a, liste_b)]

[ThomasL]

Der Fehler liegt in dieser Zeile:

Code: Alles auswählen

print(a, b, verknuepfung(liste_a, liste_b))

Du rufst jedesmal Verknuepfung(True, True) auf und bekommst daher immer "falsch".

[Jankie]

Code: Alles auswählen

def ausgabe(a, b):
    print ("a b result")
    for a in liste_a:
        for b in liste_b:
            print (a, b, verknuepfung (liste_a, liste_b))

Du nimmst in der Funktion die Variablen a und b als Parameter entgegen, aber überschreibst die in der for Schleife wieder und nutzt die als Laufvariable. Kann mir nicht vorstellen dass das so gewollt ist.

Code: Alles auswählen

def verknuepfung(a, b):            
    return not (a or b)

def ausgabe(liste_a, liste_b):
    print("a b result")
    for a in liste_a:
        for b in liste_b:
            print(a, b, verknuepfung(a, b))

def main():
    liste_a = [0, 1]
    liste_b = [0, 1]
    ausgabe(liste_a, liste_b)


if __name__ == '__main__':
    main()

Es würde auch eine Liste reichen, da die ja beide den gleichen Inhalt haben und diese an die Funktion zu übergeben, dann musst zu mit zwei Schlefien durch die gleiche Liste laufen, also so:

Code: Alles auswählen

def verknuepfung (a, b):            
    return not (a or b)

def ausgabe(werte):
    print ("a b result")
    for a in werte:
        for b in werte:
            print (a, b, verknuepfung(a, b))

def main():
    werte = [0, 1]
    ausgabe(werte)

if __name__ == '__main__':
    main()

[DeaD_EyE]

Bezüglich der Erweiterbarkeit, wenn man die richtigen Datenstrukturen verwendet:

Code: Alles auswählen

import operator
from itertools import product


op = {
    "|": operator.or_,
    "&": operator.and_,
    "^": operator.xor,
    "#": lambda x, y: int(not (x or y)),
}

def truth_table(symbol):
    ab_iterator = product(*[range(2)] * 2)
    for a, b in ab_iterator:
        print(f"{a} {symbol} {b} | {op[symbol](a, b)}")


for symbol in op:
    truth_table(symbol)
    print()

0 | 0 | 0
0 | 1 | 1
1 | 0 | 1
1 | 1 | 1

0 & 0 | 0
0 & 1 | 0
1 & 0 | 0
1 & 1 | 1

0 ^ 0 | 0
0 ^ 1 | 1
1 ^ 0 | 1
1 ^ 1 | 0

0 # 0 | 1
0 # 1 | 0
1 # 0 | 0
1 # 1 | 0

Und noch eine weitere Funktion für mehr als zwei Faktoren:

Code: Alles auswählen

from functools import reduce


def multi_truth_table(symbol, inputs):
    iterator = product(*[range(2)] * inputs)
    for values in iterator:
        result = reduce(op[symbol], values)
        values = f" {symbol} ".join(map(str, values))
        print(f"{values} => {result}")

In [24]: multi_truth_table("^", 4)
0 ^ 0 ^ 0 ^ 0 => 0
0 ^ 0 ^ 0 ^ 1 => 1
0 ^ 0 ^ 1 ^ 0 => 1
0 ^ 0 ^ 1 ^ 1 => 0
0 ^ 1 ^ 0 ^ 0 => 1
0 ^ 1 ^ 0 ^ 1 => 0
0 ^ 1 ^ 1 ^ 0 => 0
0 ^ 1 ^ 1 ^ 1 => 1
1 ^ 0 ^ 0 ^ 0 => 1
1 ^ 0 ^ 0 ^ 1 => 0
1 ^ 0 ^ 1 ^ 0 => 0
1 ^ 0 ^ 1 ^ 1 => 1
1 ^ 1 ^ 0 ^ 0 => 0
1 ^ 1 ^ 0 ^ 1 => 1
1 ^ 1 ^ 1 ^ 0 => 1
1 ^ 1 ^ 1 ^ 1 => 0