Wird auch erklärt.nightm4r3^ hat geschrieben:Also bzw. wie da die reihen und spalten eingeteilt sind.
Bruchrechner
- Hyperion
- Moderator
- Beiträge: 7478
- Registriert: Freitag 4. August 2006, 14:56
- Wohnort: Hamburg
- Kontaktdaten:
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
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
-
- User
- Beiträge: 83
- Registriert: Montag 11. Februar 2008, 15:43
- Kontaktdaten:
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.
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.
Allerdings solltest Du nicht mit der GUI beginnen, sondern mit der Logik. Also erst einmal das Bruchrechnen implementieren und testen.
Nimm den GRID Geometry Maganger, damit ist es ganz einfach.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.
Oder: http://sourceforge.net/project/showfile ... p_id=24918
guck mal hier...
-
- User
- Beiträge: 83
- Registriert: Montag 11. Februar 2008, 15:43
- Kontaktdaten:
funktionen.py
hauptprogramm.py
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.
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.
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
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
- Moderator
- Beiträge: 7478
- Registriert: Freitag 4. August 2006, 14:56
- Wohnort: Hamburg
- Kontaktdaten:
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!
So, das ist natürlich so noch nicht wirklich schön, aber ein Denkansatz!
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