Frage von Wepster, 22

Python 3.5 - Rechenoperationen die man mit 2 ganzen Zahlen machen kann, außer add, sub, div, mult, für Programmiersprache Python?

Ich programmiere gerade einen Taschenrechner, aus Spaß und habe erst gelernt wie man sowas in Python schreibt. Die Ergebnisse will ich erweitern.

Ich habe dazu eine Code benutzt der für Python 2 geschrieben wurde, in Python 3.5 umgebaut...so dass die Summe zweier Zahlen gleich alle angegebenen Rechenpoperationen mit einmal ausgibt, ohne die Operation zu bestimmen (das war vorher so geschrieben, dass man es eingeben musste).

Diese Ergebnisse will ich erweitern, stehe aber gerade auf dem Schlauch was ich noch berechnen kann und nicht zu kompliziert ist.

Zum Beispiel die Quersumme mehrstelliger Zahlen oder sowas.... Auch wichtig die Übersicht, ich weiß nicht wie man Umbruch oder Zeilen programmiert.

Der jetzige Rechner sieht so aus, und ist aus einer anderen gf-Frage entstanden - https://www.gutefrage.net/frage/python-taschenrechner :

print("""
      =6=4=1=7=9=0=2=5=3==================================
                       =Taschenrechner=
      =====================================0=1=1=0=1=0=0=1
Dieser Rechner addiert, subtrahiert, multipliziert und dividert auf einmal deine im folgenden angegebenen Zahlen
    """)

num1 = int(input("Gib die erste Zahl ein: "))
num2 = int(input("Gib die zweite Zahl ein: "))

summe1=num1+num2
summe2=num1-num2
summe3=num1*num2
summe4=num1/num2

print(num1, " + ", num2)
print("Ergebnis von Addition:", summe1)
print(num1, " - ", num2)
print("Ergebnis von Subtraktion:", summe2)
print(num1, " / ", num2)
print("Ergebnis von Division:", summe4)
print(num1, " * ", num2)
print("Ergebnis von Multiplikation:", summe3)

Danke.

Antwort
von ralphdieter, 15

Weitere zweistellige Operationen sind z.B.:

  • x mod y — x%y (Modulo, Restklasse)
  • x^y — x**y (Potenz)
  • log_x y — math.log(y,x) (Logarithmus)
  • ggT(x,y) — math.gcd(x,y) (größter gemeinsamer Teiler)
  • kgV(x,y) — x·y/gcd(x, y) (kleinstes gemeinsames Vielfache)
  • arithmetisches, geometrisches und harmonisches Mittel: (x+y)/2, √xy, 1/(1/x+1/y)
  • (x y) — https://de.wikipedia.org/wiki/Binomialkoeffizient
  • hypot(x,y) — √(x²+y²) (Basis des rechtwinkligen Dreiecks mit den Katheten x und y)

Zur Ausgabe:

  • Das Zeichen '\n' ist ein Zeilenumbruch: "Erstens\nZweitens" wird auf zwei Zeilen ausgegeben.
  • print( ..., end='') hängt keinen Zeilenumbruch an. Das nächste print() wird in der gleichen Zeile weiter schreiben.

Kommentar von ceevee ,

Du bist C/C++-Programmierer, oder? :) Die Zeilenumbrüche kann man in Python sehr viel einfacher so machen:

print(num1, " + ", num2),
print("Ergebnis von Addition:", summe1),
print(num1, " - ", num2),
print("Ergebnis von Subtraktion:", summe2),
print(num1, " / ", num2),
print("Ergebnis von Division:", summe4),
print(num1, " * ", num2),
print("Ergebnis von Multiplikation:", summe3),

Man beachte das Komma am Ende jeder Zeile. ;)

Außerdem sollte der Fragesteller noch überprüfen, was sein Programm ausgibt, wenn num2 = 0 ist und da ggf. reagieren. Ähnliche Probleme gäbe es beispielsweise auch beim Logarithmus mit negativen Zahlen. 

Ansonsten ist die Antwort aber ziemlich vollständig.

Kommentar von ralphdieter ,

Ähm, das mit dem Komma war damals in Python 2.

In Python 3 wurde print in eine Funktion gewandelt. Dein Vorschlag ist zwar syntaktisch korrekt, erzeugt aber nur das Tupel (None,) und gibt als Nebeneffekt einen Text mit Zeilenende aus. None ist dabei der Rückgabewert von print().

Kommentar von ralphdieter ,

Fehlerprüfung ist eine sehr gute Idee. Das fängt aber schon bei der Eingabe und deren Umwandlung zu int an.

Allerdings scheint der Fragesteller gerade mit Python anzufangen. Da muss man dieses Fass nicht auch noch aufmachen...

Kommentar von Wepster ,

Dass mit dem Komma geht nicht. Das "\n" muss ich noch testen. Wenn man "\n" in einen string schreibt gehts.

Probier ich mal so lange bis es hübsch aussieht.


print(num1, " + ", num2)
print("Ergebnis von Addition:", summe1, "\n")
Kommentar von Wepster ,

optimiert und aufgeräumt. Hast du Beispiele für die Verwendung der anderen Module bitte?

num1 = int(input("Gib die erste Zahl ein: "))
num2 = int(input("Gib die zweite Zahl ein: "))
summe1=num1+num2
print(num1, " + ", num2, "=", summe1, "\n", "___", "\n" )
Kommentar von Wepster ,

Kleiner "\n" fehler.....So habe noch weiter gemacht, mit 3 Beispielen von RalphyBoy:


import math

print("""
=6=4=1=7=9=0=2=5=3==================================
=Automatischer Taschenrechner=
=====================================0=1=1=0=1=0=0=1
Dieser Rechner addiert, subtrahiert, multipliziert, dividert \n
errechnet die Potenz der ersten Zahl durch die zweite Zahl (Potenz / x^y) \n
dividiert die erste Zahl durch die zweite Zahl mit Rest (Modulo / a=b*c+r) \n
errechnet den größten gemeinsamen Teiler \n
den kleinsten gemeinsamen Vielfachen \n
auf einmal, mit deinen im folgenden anzugebenen Zahlen
""")

num1 = int(input("Gib die erste Zahl ein: "))
num2 = int(input("Gib die zweite Zahl (ist auch Potenz etc.) ein: "))

summe1=num1+num2
summe2=num1-num2
summe3=num1*num2
summe4=num1/num2
summe5=num1**num2 #Potenz x hoch y
summe6=num1%num2 #Dividion mit Rest (Modulo)
summe7=math.gcd(num1, num2) # größter gemeinsamer Teiler von x und y
summe8=num1*num2/math.gcd(num1, num2) # kleinestes gemeinsames Vielfaches von x und y

print(num1, " + ", num2, "=", summe1, "\n", "___", "\n" )
print(num1, " - ", num2, "=", summe2, "\n", "___", "\n" )
print(num1, " * ", num2, "=", summe3, "\n", "___", "\n" )
print(num1, " / ", num2, "=", summe4, "\n", "___", "\n" )
print(num1, " mit Potenz ", num2, "=", summe5, "\n", "___", "\n" )
print(num1, " / ", num2, "=", summe4, "+ Rest", summe6, "\n", "___", "\n" )
print(num1, " und ", num2, " sind beide durch ", summe7, "teilbar \n", "___", "\n" )
print(num1, " * ", num2, "=", summe3, "/", summe7, "=", summe8, "\n", "___", "\n" )


Kommentar von ralphdieter ,

1. Ich bereue schon fast, das '\n' erwähnt zu haben. print() hängt sowieso einen Zeilenvorschub hinten dran. Wenn also jede ausgegebene Zeile ein eigenes print() hat, ist '\n' unnötig.

Und für längere Texte eignet sich ein String mit drei Anführungszeichen viel besser, weil man da die Zeilenumbrüche schon im Quelltext sieht. Das '\n' ist nur in wenigen Fällen praktischer:

int(input("Gib die erste Zahl ein\n(zwischen -999 und 999): " ))

macht das selbe wie

int(input("""Gib die erste Zahl ein
(zwischen -999 und 999): """ ))

Ich finde die obere Form lesbarer. Aber statt

print(num1," + ",num2,"=",summe1,"\n___\n" )

würde ich lieber so was lesen:

print(num1," + ",num2,"=",summe1)
print("___")
print()

Da sieht man sofort, dass drei Zeilen ausgegeben werden.

Kommentar von ralphdieter ,

2. Berechnung der übrigen Funktionen:

  • arithmetisches Mittel: (x+y)/2
  • geometrisches Mittel: √xy ⇒ math.sqrt(x*y)
  • harmonisches Mittel: 1/(1/x+1/y)
  • Binominalkoeffizient: (x y) — eigentlich schreibt man die Werte übereinander und spricht das dann "x über y" aus. Dies ist eine der ganz wenigen nützlichen Funktionen, die in Python nicht dabei sind :( So könntest Du es selbst berechnen:
z = functools.reduce(operator.mul, xrange(x-y+1,x+1)) /
functools.reduce(operator.mul, xrange(1,r+1))

Das ist aber eher für "Fortgeschrittene" :-)

  • hypot(x,y): √(x²+y²) ⇒ math.sqrt(x*x+y*y)
Kommentar von ralphdieter ,

3. Statt noch weitere Funktionen einzubauen, rate ich Dir, den Code besser zu strukturieren. Dafür eignet sich Dein Rechner ganz prima.

Schreibe ein zweites Modul binop.py (im gleichen Verzeichnis), das die Berechnungen als Klassen enthält. Die könnten so aussehen:

class Addition:
"Zwei Zahlen addieren."

def __init(self, x, y):
"Objekt initialisieren:"
self.x = x
self.y = y

def __str__(self):
"Addition als Text darstellen"
return str(x) + "+" + str(y)

def result(self):
"Ergebnis berechnen"
return x+y

Die anderen Operatoren (Subtraktion, ...) gehen jetzt wie Brezeln backen. Mach Dir nichts daraus, wenn Du nur die Hälfte verstehst. Du hast noch eine steile Lernkurve vor Dir. (An meinem Vorschlag kann man noch hundert Sachen verbessern, aber eins nach dem anderen...)

Dein Hauptprogramm wird nun viel übersichtlicher:

# Begrüßung und einlesen von num1, num2

operatoren = [ binop.Addition(num1,num2)
, binop.Subtraktion(num1,num2)
, # und alle anderen
 ]

for op in operatoren:
print(op, "=", op.result())

Der Vorteil dieser Modularisierung wird vielleicht deutlicher, wenn Du einen neuen Operator hinzufügst. Aber sonnenklar wird es spätestens, wenn Du dich um die Fehlerbehandlung kümmerst:

Im Moment bricht Dein Rechner beim ersten Fehler mit einem Stacktrace ab. So könntest Du das verbessern:

for op in operatoren:
try:
print(op, "=", op.result())
except Exception, ex:
print(op, "Fehler: ", ex)

In Deiner Originalversion wäre diese Verbesserung viel aufwendiger und mit viel Schreibarbeit verbunden. Sobald Dein Kopf wieder frei für Neues ist, kannst Du das ja mal ausprobieren...

Kommentar von ralphdieter ,

Errata:

Ich habe die obigen Code-Beispiele nicht getestet. Also wird hie und da ein Fehler drin sein. Einen habe ich schon gefunden:

Am Ende von Kommentar 2:  xrange(1,y+1)

Keine passende Antwort gefunden?

Fragen Sie die Community