Bruchrechner

Leonidas · Montag 10. März 2008, 20:38

nightm4r3^ hat geschrieben:Also bzw. wie da die reihen und spalten eingeteilt sind.

Hyperion · Montag 10. März 2008, 20:55

Mal kurz offtopic: Nach kurzem Suchen nach den bisherigen Posts vom Autor erkennt man schnell, dass es sich mit an Sicherheit grezender Wahrscheinlichkeit um Hausaufgaben handeln wird!

Wobei mir nicht klar ist, wie man nach so vielen anderen Sachen immer noch keinen blassen Schimmer von so was hat?

Naja, wenn man sich vor allem um GUIs kümmert, bleiben die Grundlagen natürlich auf der Strecke

nightm4r3^ · Dienstag 11. März 2008, 08:07

NEIN es sind KEINE Hausaufgaben zum letzten mal. Aber das ist ja jetzt auch egal. Ich bekomm es auf jeden Fall immer noch net hin, die entry Felder nebeneinander zu setzten.

Hyperion · Dienstag 11. März 2008, 10:37

Wie wärs, wenn Du zunächst mal die dem eigentlichen Rechner anfingest? Das ist doch das eigentlich interessante! Eine GUI drum herum basteln ist dabei doch Nebensache ...

BlackJack · Dienstag 11. März 2008, 10:38

Was meinst Du mit nebeneinander? In dem Beispiel was Du gezeigt hast, sind die doch erst einmal übereinander für einen Bruch. Das würde ich auch für die GUI so als Widget in einer eigenen Klasse modellieren.

Allerdings solltest Du nicht mit der GUI beginnen, sondern mit der Logik. Also erst einmal das Bruchrechnen implementieren und testen.

meneliel · Dienstag 11. März 2008, 14:04

nightm4r3^ hat geschrieben:NEIN es sind KEINE Hausaufgaben zum letzten mal. Aber das ist ja jetzt auch egal. Ich bekomm es auf jeden Fall immer noch net hin, die entry Felder nebeneinander zu setzten.

Nimm den GRID Geometry Maganger, damit ist es ganz einfach.

Oder: http://sourceforge.net/project/showfile ... p_id=24918
guck mal hier...

nightm4r3^ · Mittwoch 12. März 2008, 17:08

funktionen.py

Code: Alles auswählen

# -*- coding: cp1252 -*-
#####################################################################
#Definition des ggT:


def ggt(m, n):
    r=m%n
    while r!=0:
        m=n
        n=r
        r=m%n
    return n

#####################################################################
#Definition aller Teiler:
def teiler(a):
    Liste=[]
    x=a+1
    for i in range (1,x):
        if a%i==0:
            Liste=Liste+[i]
    return Liste



#####################################################################
#Definition aller gemeinsamen Teiler zweier Zahlen:
def teiler2(a, b):
    Liste=[]
    if a>=b:
        x=b+1
        for i in range (1,x):
            if a%i==0 and b%i==0:
                    Liste=Liste+[i]
        return Liste
    else:
        x=a+1
        for i in range (1,x):
            if b%i==0 and a%i==0:
                    Liste=Liste+[i]
        return Liste


#####################################################################
#Definition des kgV:
def kgv(m, n):
    v=m*n
    r=m%n
    while r!=0:
        m=n
        n=r
        r=m%n
    k=v/n
    return k

#####################################################################
#Definition der Quersumme:
def Quersumme(a):
    quersumme=sum([int(p) for p in str(a)])
    print quersumme
    
#####################################################################
#Definition Brüche addieren:
def bruchrechneradd(z1,n1,z2,n2):
    z3=z1*n2+z2*n1
    n3=n1*n2
    ggt2=ggt(z3, n3)
    z3=z3/ggt2
    n3=n3/ggt2
    print z3
    print n3
    laenge=len(str(z3))
    laenge2=len(str(n3))
    print laenge
    print laenge2
    
     

            
#####################################################################
#Definition Brüche subtrahieren:
def bruchrechnersub(z1,n1,z2,n2):
    z3=z1*n2-z2*n1
    n3=n1*n2
    ggt2=ggt(z3, n3)
    z3=z3/ggt2
    n3=n3/ggt2
    print z3
    print n3
    laenge=len(str(z3))
    laenge2=len(str(n3))
    print laenge
    print laenge2    
    

#####################################################################
#Definition Brüche multiplizieren:
def bruchrechnermulti(z1,n1,z2,n2):
    z3=z1*z2
    n3=n1*n2
    ggt2=ggt(z2, n3)
    z3=z3/ggt2
    n3=n3/ggt2
    print z3
    print n3
    laenge=len(str(z3))
    laenge2=len(str(n3))
    print laenge
    print laenge2    


#####################################################################
#Definition Brüche dividieren:
def bruchrechnerdivi(z1,n1,z2,n2):
      n3=z2
      z3=n2
      z4=z1*z3
      n4=n1*n3
      z4=z3/ggt2
      n4=n3/ggt2
      print z4
      print n4
      laenge=len(str(z4))
      laenge2=len(str(n4))
      print laenge
      print laenge2

hauptprogramm.py

Code: Alles auswählen

#####################################################################
#Hauptprogramm
import Tkinter as tk
from funktionen import *

#################################################

#Aufgabe 1
def aufgabe1():
#Nebenfenster
    fenster2=tk.Toplevel()
    fenster2.geometry('400x300')
#Label im Nebenfenster
    fenster2.label=tk.Label(fenster2,text='ggT berechnen', font=('Verdana',16,'bold'))
    fenster2.label.pack()
#2.Label im Nebenfenster
    fenster2.label2=tk.Label(fenster2,text='Bitte geben Sie die erste Zahl ein')
    fenster2.label2.pack()
#Entry Feld 1
    m=tk.Entry(fenster2)
    m.get()
    m.pack()
#3.Label im Nebenfenster
    fenster2.label3=tk.Label(fenster2,text='Bitte geben Sie die zweite Zahl ein')
    fenster2.label3.pack()
#Entry Feld 2
    n=tk.Entry(fenster2)
    n.get()
    n.pack()
#GGT Ausgabe
    def do_ggt():
        fensterggt=tk.Toplevel()
        fensterggt.geometry('60x60')
        fensterggt.label=tk.Label(fensterggt, text=ggt(int(m.get()), int(n.get())))
        fensterggt.label.pack()

#Button erstellen
    fenster2.button=tk.Button(fenster2,text='Bestätigen',
                           command=do_ggt)
    fenster2.button.pack()
    
#Fenster anzeigen
    fenster2.mainloop()


#################################################
    
def aufgabe2():
#Nebenfenster
    fenster3=tk.Toplevel()
    fenster3.geometry('400x300')
#Label im Nebenfenster
    fenster3.label=tk.Label(fenster3,text='alle Teiler einer Zahl berechnen', font=('Verdana',16,'bold'))
    fenster3.label.pack()
#2.Label im Nebenfenster
    fenster3.label2=tk.Label(fenster3,text='Bitte geben Sie die Zahl ein')
    fenster3.label2.pack()
#Entry Feld 
    a=tk.Entry(fenster3)
    a.pack()
#TEILER Ausgabe
    def do_teiler():
        fensterteiler=tk.Toplevel()
        fensterteiler.geometry('60x60')
        fensterteiler.label=tk.Label(fensterteiler, text=teiler(int(a.get())))
        fensterteiler.label.pack()

#Button erstellen
    fenster3.button=tk.Button(fenster3,text='Bestätigen',
                           command=do_teiler)
    fenster3.button.pack()
#Fenster anzeigen
    fenster3.mainloop()


##################################################
def aufgabe3():
#Nebenfenster
    fenster4=tk.Toplevel()
    fenster4.geometry('400x300')
#Label im Nebenfenster
    fenster4.label=tk.Label(fenster4,text='alle Teiler zweier Zahlen berechnen', font=('Verdana',16,'bold'))
    fenster4.label.pack()
#2.Label im Nebenfenster
    fenster4.label2=tk.Label(fenster4,text='Bitte geben Sie die erste Zahl ein')
    fenster4.label2.pack()
#Entry Feld 1
    a=tk.Entry(fenster4)
    a.get()
    a.pack()
#3.Label im Nebenfenster
    fenster4.label3=tk.Label(fenster4,text='Bitte geben Sie die zweite Zahl ein')
    fenster4.label3.pack()
#Entry Feld 2
    b=tk.Entry(fenster4)
    b.get()
    b.pack()
#GGT Ausgabe
    def do_teiler2():
        fensterteiler2=tk.Toplevel()
        fensterteiler2.geometry('60x60')
        fensterteiler2.label=tk.Label(fensterteiler2, text=teiler2(int(a.get()), int(b.get())))
        fensterteiler2.label.pack()

#Button erstellen
    fenster4.button=tk.Button(fenster4,text='Bestätigen',
                           command=do_teiler2)
    fenster4.button.pack()
    
#Fenster anzeigen
    fenster4.mainloop()


##################################################

def aufgabe4():
#Nebenfenster
    fenster5=tk.Toplevel()
    fenster5.geometry('400x300')
#Label im Nebenfenster
    fenster5.label=tk.Label(fenster5,text='kgV berechnen', font=('Verdana',16,'bold'))
    fenster5.label.pack()
#2.Label im Nebenfenster
    fenster5.label2=tk.Label(fenster5,text='Bitte geben Sie die erste Zahl ein')
    fenster5.label2.pack()
#Entry Feld 1
    a=tk.Entry(fenster5)
    a.get()
    a.pack()
#3.Label im Nebenfenster
    fenster5.label3=tk.Label(fenster5,text='Bitte geben Sie die zweite Zahl ein')
    fenster5.label3.pack()
#Entry Feld 2
    b=tk.Entry(fenster5)
    b.get()
    b.pack()
#GGT Ausgabe
    def do_kgv():
        fensterkgv=tk.Toplevel()
        fensterkgv.geometry('60x60')
        fensterkgv.label=tk.Label(fensterkgv, text=kgv(int(a.get()), int(b.get())))
        fensterkgv.label.pack()

#Button erstellen
    fenster5.button=tk.Button(fenster5,text='Bestätigen',
                           command=do_kgv)
    fenster5.button.pack()
    
#Fenster anzeigen
    fenster5.mainloop()

##################################################

def aufgabe5():
#Nebenfenster
    fenster6=tk.Toplevel()
    fenster6.geometry('400x300')
#Label im Nebenfenster
    fenster6.label=tk.Label(fenster6,text='Brüche addieren', font=('Verdana',16,'bold'))
    fenster6.label.pack()
#2.Label im Nebenfenster
    fenster6.label2=tk.Label(fenster6,text='Bitte geben Sie die erste Zahl ein')
    fenster6.label2.pack()
#Entry Feld 1
    z1=tk.Entry(fenster6)
    z1.grid(row=3,column=1)
    z1.get()
    z1.pack()
#Entry Feld 2
    n1=tk.Entry(fenster6)
    n1.grid(row=4,column=1)
    n1.get()
    n1.pack()
#Entry Feld 3
    z2=tk.Entry(fenster6)
    z2.grid(row=3, column=40, rowspan=2)
    z2.get() 
    z2.pack()
#Entry Feld 4
    n2=tk.Entry(fenster6)
    n2.grid(row=4, column=40, rowspan=2)
    n2.get()
    n2.pack()
#GGT Ausgabe
    def do_bra():
        fensterbra=tk.Toplevel()
        fensterbra.geometry('60x60')
        fensterbra.label=tk.Label(fensterbra, text=bruchrechneradd(int(z1.get()), int(n1.get()), int(z2.get()), int(n2.get())))
        fensterbra.label.pack()

#Button erstellen
    fenster6.button=tk.Button(fenster6,text='Bestätigen',
                           command=do_bra)
    fenster6.button.pack()
    
#Fenster anzeigen
    fenster6.mainloop()


##################################################

fenster=tk.Tk(className='Rechner')
fenster.geometry('400x300')
fenster.label=tk.Label(fenster,text='Bitte treffen Sie Ihre Auswahl', font=('Verdana',16,'bold'))
fenster.label.pack()
fenster.button=tk.Button(fenster,text='ggT berechnen',
                      command=aufgabe1)
fenster.button.pack()

fenster.button2=tk.Button(fenster,text='kgV berechnen',
                         command=aufgabe4)
fenster.button2.pack()

fenster.button3=tk.Button(fenster,text='alle Teiler einer Zahl berechnen',
                      command=aufgabe2)
fenster.button3.pack()

fenster.button4=tk.Button(fenster,text='alle Teiler zweier Zahlen berechnen',
                         command=aufgabe3)
fenster.button4.pack()

fenster.button5=tk.Button(fenster,text='Brüche addieren',
                          command=aufgabe5)
fenster.button5.pack()

fenster.mainloop()

Bitte jetzt net über Sternchenimporte und sonstiges reden. Hier ist mein Programm bis jetzt. Und jetzt hätte ich gern die 4 Felder fürs Brüche addieren jeweils 2 untereinander. Halt immer Zähler und Nenner.

audax · Mittwoch 12. März 2008, 19:54

Dieser Programmcode ist schmerzhaft.

Du möchtest OOP lernen, wirklich wirklich wirklich!

Btw:
Wenn du Sternchenimport einer eigenen Bilbiothek machst....waurm schreibst du nicht einfach alles in eine Datei?

Und schau dir das hier an:
http://de.wikipedia.org/wiki/MVC

Hyperion · Donnerstag 13. März 2008, 15:12

Ist aber nett, dass Du dein eigenes Projekt in Aufgaben unterteilst

Ansonsten: Versuch mal wirklich zu lernen, was Klassen sind und wie man damit arbeitet! Man kann damit viele Probleme so elegant lösen ...

Nur mal so als Denkanstoß: Ein Bruch ist doch quasi schon per se ein eigener Datentyp!

Code: Alles auswählen

class Bruch:
    def __init__(self, zaehler, nenner):
        self.zaehler = zaehler
        self.nenner = nenner

So, das ist natürlich so noch nicht wirklich schön, aber ein Denkansatz!