Seite 1 von 1
Wahrheitstabelle über funktion
Verfasst: Dienstag 11. August 2020, 15:32
von 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()
Re: Wahrheitstabelle über funktion
Verfasst: Dienstag 11. August 2020, 18:52
von 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
Re: Wahrheitstabelle über funktion
Verfasst: Mittwoch 12. August 2020, 17:13
von 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
Re: Wahrheitstabelle über funktion
Verfasst: Freitag 14. August 2020, 08:10
von 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.
Re: Wahrheitstabelle über funktion
Verfasst: Donnerstag 20. August 2020, 12:22
von 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)]
Re: Wahrheitstabelle über funktion
Verfasst: Donnerstag 20. August 2020, 15:13
von ThomasL
Der Fehler liegt in dieser Zeile:
Du rufst jedesmal Verknuepfung(True, True) auf und bekommst daher immer "falsch".
Re: Wahrheitstabelle über funktion
Verfasst: Donnerstag 20. August 2020, 15:15
von 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()
Re: Wahrheitstabelle über funktion
Verfasst: Samstag 22. August 2020, 09:28
von 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