Wie ihr ja vielleicht schon wisst, versuche ich seit einer Weile, Programmieren zu lernen. Und wie tut man das am Besten? Man programmiert was. Also habe ich mich vor einer Woche oder so hingesetzt und an mein erstes (für meine Maßstäbe) größeres Skript gewagt. Nebenbei gesagt tut es etwas, das (wahrscheinlich deutlich anders gelöst) standardmäßig in entsprechenden Libraries implementiert ist, aber ich habe es mir eben als kleine Herausforderung ausgesucht.
Okay, ich will euch nicht weiter auf die Folter spannen: Mein Skript definiert eine mathematische Gleichung. Der User kann sie dann umformen, wie in der Schule, nur dass es eben automatisch geht. Einfach "+5" oder so eintippen, das Skript formt die Gleichung automatisch um und zeigt sie an.
So zumindest der Plan (*hust*). Bislang kann das Skript Addition, Subtraktion und Multiplikation, und zwar von Integers und floats. Nicht von Variablen, was das Skript noch ziemlich nutzlos macht, aber genau deshalb dachte ich, etwas Hilfe wäre nicht schlecht. Ich hatte z.B. mit Objektorientierung bis zu diesem Skript nie etwas zu tun, und ich muss sagen, dass mein Einstieg doch etwas holprig verläuft.
Also, über Kritik und den Blickwinkel eines erfahrenen Programmierers würde ich mich sehr freuen
Hier mal der Code:
Code: Alles auswählen
class object:
def __init__(self, vorzeichen, multiplikator, basis, exponent, teiler):
self.vorzeichen = vorzeichen
self.multiplikator = multiplikator
self.basis = basis
self.exponent = exponent
self.teiler = teiler
def solve(self):
if type(self.basis) == str:
self.multiplikator = (self.vorzeichen * self.multiplikator) / self.teiler
self.vorzeichen = 1
self.teiler = 1
else:
self.basis = (self.vorzeichen * self.multiplikator * self.basis**self.exponent) / self.teiler
self.vorzeichen = 1
self.multiplikator = 1
self.exponent = 1
self.teiler = 1
def rechnen_mal(self, multiplikator):
if multiplikator == self.basis:
self.exponent += 1
else:
self.multiplikator *= multiplikator
def rechnen_geteilt(self, divisor):
if divisor == self.basis:
self.basis = 1
self.teiler = 1
else:
self.teiler *= divisor
def rechnen_potenz(self, exponent):
self.exponent *= exponent
# ---------------------------------------------------------
def multiply(gleichung, multiplikator):
for term in gleichung:
for objekt in term:
objekt.rechnen_mal(multiplikator)
def divide(gleichung, divisor):
for term in gleichung:
for objekt in term:
objekt.rechnen_geteilt(divisor)
def rais(gleichung, exponent):
for term in gleichung:
for objekt in term:
objekt.rechnen_potenz(exponent)
def addsubtract(gleichung, summand):
gleichung[0].append(object(1, 1, summand, 1, 1))
gleichung[1].append(object(1, 1, summand, 1, 1))
# ---------------------------------------------------------
def unify(term, objekt1, objekt2):
if (type(objekt1.basis) == int or type(objekt1.basis) == float) and\
(type(objekt2.basis) == int or type(objekt2.basis) == float):
objekt1.solve()
objekt2.solve()
objekt1.basis += objekt2.basis
term.remove(objekt2)
elif type(objekt1.basis) == str and objekt2.basis == objekt1.basis and objekt2.exponent == objekt1.exponent:
objekt1.solve()
objekt2.solve()
objekt1.multiplikator += objekt2.multiplikator
term.remove(objekt2)
else:
pass # In diesem Fall haben beide Objekte keine Gemeinsamkeiten
# ---------------------------------------------------------
def allsolve(gleichung):
for term in gleichung:
for objekt in term:
objekt.solve()
def termunify(term): # termunify() sortiert die Objekte eines Terms nach Zahlen und Variablen, cleart den Term vorübergehend.
# durch ein komplexes System werden einzelne Variablengruppen vereint. Daran beteiligt sind die Listen
# 'variablen' und 'term_auslagerung_vars_temp'.
# Am Ende jedes Schrittes wird der Ursprungsterm wieder durch die vereinigten Objekte
# erweitert.
term_auslagerung_0 = []
term_auslagerung_vars = []
term_auslagerung_vars_temp = []
variablen = []
for i in term: # For-Schleife sortiert Objekte mit variablen als Basis aus, Zahlen kommen in eine Liste, Variablen in eine andere.
if type(i.basis) == int or type(i.basis) == float:
term_auslagerung_0.append(i)
else:
term_auslagerung_vars.append(i)
term.clear() # Ursprünglicher Term wird vorerst geleert. Nachdem alle anderen Listen vereinigt sind, kehren vereinigte Objekte zurück in den Term.
for i in term_auslagerung_vars: # "variablen" ist die Liste aller vorkommenden Variablen.
if i.basis not in variablen:
variablen.append(i.basis)
# --------------------------------------------------------------------
for i in variablen: # for-schleife angelt Objekte mit Basis i und packt sie in ...temp-Liste.
for o in term_auslagerung_vars:
if o.basis == i:
term_auslagerung_vars_temp.append(o)
while len(term_auslagerung_vars_temp) > 1: # temp-Liste wird vereinigt
unify(term_auslagerung_vars_temp, term_auslagerung_vars_temp[0], term_auslagerung_vars_temp[1])
term.append(term_auslagerung_vars_temp[
0]) # vereinigte Objekte aus temp-liste werden in den ursprünglichen Term verschoben
term_auslagerung_vars_temp.clear() # temp- liste wird für die nächste Variable geleert.
while len(term_auslagerung_0) > 1:
unify(term_auslagerung_0, term_auslagerung_0[0], term_auslagerung_0[1])
term.append(term_auslagerung_0[0])
def allunify(gleichung):
for termm in gleichung:
termunify(termm)
print ('Allsolve und Allunify erfolgreich definiert!')
# ---------------------------------------------------------
# INITIALISIERUNG
term0 = []
term1 = []
gleichung0 = [term0, term1]
term0.append(object(1, 5, 'a', 2, 1))
term0.append(object(1, 5, 'b', 1, 1))
term0.append(object(1, 1, 10, 1, 1))
term1.append(object(1, 3, 'a', 1, 1))
term1.append(object(1, 1, 5, 1, 1))
term1.append(object(1, 1, 15, 1, 1))
print ('Erfolgreich initialisiert!')
# ---------------------------------------------------------
# USER INTERFACE
# todo - Rechenart Division funktioniert nicht.
while True:
allsolve(gleichung0)
allunify(gleichung0)
darstellung_term0 = ''
for objekt in gleichung0[0]:
if type(objekt.basis) == str:
darstellung_term0 += '(' + str(objekt.multiplikator) + str(objekt.basis) + ')' + ' + '
else:
darstellung_term0 += '(' + str(objekt.basis) + ')' + ' + '
darstellung_term0 = darstellung_term0[:-3]
darstellung_term1 = ''
for objekt in gleichung0[1]:
if type(objekt.basis) == str:
darstellung_term1 += '(' + str(objekt.multiplikator) + objekt.basis + ')' + ' + '
else:
darstellung_term1 += '(' + str(objekt.basis) + ')' + ' + '
darstellung_term1 = darstellung_term1[:-3]
print('GLEICHUNG:')
print(darstellung_term0 + ' = ' + darstellung_term1 + '\n')
user_input = input()
if user_input[0] == '+':
addsubtract(gleichung0, float(user_input[1:]))
elif user_input[0] == '-':
addsubtract(gleichung0, -(float(user_input[1:])))
elif user_input[0] == '*':
multiply(gleichung0, (float(user_input[1:]))) # todo - multiplizieren: Eventuelle Klammern eliminieren beim Einlesen!
elif user_input[0] == '/':
pass
