Das deutsche Python-Forum

Guten Morgen ich bin nach fast 20 Jahren Pause auf python gestossen und arbeite an einem Programm für den Amateurfunk.
Hier soll u.a geprüft werden, ob mit dem Rufzeichen an diesem Tag schon gearbeitet wurde.
Das Programm läuft prima unter python. Jetzt mit Tkinter habe ich Probleme mit mainloop().
Zum Test habe ich mehrere breakpoints [ wait = str(input("w0")) eingebaut.

pse help
tks


--------------------------------

from Tkinter import *
#import time
#datum=time.strftime("%Y.%m.%d")
import datetime
utc = datetime.datetime.utcnow()
qtime = utc.strftime("%H.%M")
datum = utc.strftime("%Y.%m.%d")

wait = str(input("w0"))

def show_entry_fields():
print("call: %s\nqsa: %s\nqrk: %s\nop: %s\nex: %s\nqra: %s\nqssm: %s\n " % (e1.get(), e2.get(), e3.get(), e4.get(), e5.get(), e6.get(), v.get()))


###provisor calltest ##
def test_call(call):
ok =raw_input("? j/n = ")
return (ok)

def save_entry_fields():

logein = datum+" "+qtime+" "+call+" "+qssm+" "+qsa+" "+qrk+" "+op+" "+excall+" "+qra+" "+pkt+"\n"
fobj_out = open("calllineok.txt","a")
fobj_out.write(logein)
fobj_out.close()
ok = " " # call vorhanden test j/n
# return()


#def declare_entry_fields():
## call= e1.get(), qsa= e2.get(), qrk= e3.get(), op= e4.get(), ex= e5.get(), qra= e6.get(), qssm =start
###

# Erzeugung des Fensters
mrdFenster = Tk()
mrdFenster.title("MRD")
mrdFenster.geometry("600x400")
w = Label(mrdFenster, text="QSO-Menu",fg ="red",font = "Helvetica 16 bold").grid(row=0,column=3)
#w.pack()

ok = " " #= j/n wenn callprüfung nicht doppel
# wird bei jedem Durchgang gelöscht


Label(mrdFenster, text="call ").grid(row=1, sticky=E)
Label(mrdFenster, text="qsa ").grid(row=2, sticky=E,pady=10)

e1 = Entry(mrdFenster)
e2 = Entry(mrdFenster)

e1.grid(row=1,column=1)

x = Label(mrdFenster, text="pse insert NEW call!", bg="red", fg="white").grid(row=0,column=1, sticky=W) #pack()


e2.grid(row=2,column=1)
e2.insert(1,"5")


Label(mrdFenster, text="qrk ").grid(row=3, sticky=E)
Label(mrdFenster, text="op ").grid(row=4, sticky=E, pady=10)


e3 = Entry(mrdFenster)
e4 = Entry(mrdFenster)

e3.grid(row=3,column=1)
e4.grid(row=4,column=1)
e3.insert(1,"5")


Label(mrdFenster, text="excall ").grid(row=5, sticky=E)
Label(mrdFenster, text="qra ").grid(row=6, stick=E,pady=10)

e5 = Entry(mrdFenster)
e6 = Entry(mrdFenster)

e5.grid(row=5,column=1)
e6.grid(row=6,column=1)


########
#
v = IntVar()
start= 80
v.set(start) # enthält das zuletzt gewählte Band

band = [
("80m",80),
("40m",40),
("30m",30),
("20m",20),
("15m",15)
]

def ShowChoice():
print v.get()

Label(mrdFenster,
text="""Band:""",
justify = LEFT,
padx = 20).grid(row=1,column=2)

r = 0
for txt, val in band:
Radiobutton(mrdFenster,
text=txt,
padx = 20,
variable=v,
command=ShowChoice,
value=val).grid(row=r+2,column=2,sticky=W)
r = r + 1


####
Button(mrdFenster, text="show", command=show_entry_fields).grid(row=10, column=1,sticky=W,pady=4)




execfile("punkteadd.py")

pktext="Points = "+str(gespkt)+" -- QSO = "+str(qso)
tmtext="date = "+str(datum)+" UTC = "+str(qtime)
5
#datetext "UTC = "+str(datum)+" "+str(qtime)

x = Label(mrdFenster, text=pktext , bg="white", fg="red").grid(row=10,column=3, sticky=W)
x = Label(mrdFenster, text=tmtext , bg="white", fg="blue").grid(row=11,column=3, sticky=W)


#e1.insert(1,"df3gu") # hier ist call = e1 vorbesetzt
call = e1.get()
print("**call:", call, e1.get(),gespkt, qso) ####neu ###
cl=len(call)
print("len cl= ",cl)

wait = str(input("w1")) ####zwangsstop###################

while cl <1:
x = Label(mrdFenster, text="pse insert new call!", bg="red", fg="white").grid(row=0,column=1, sticky=W)
#Button(mrdFenster, text="show", command=show_entry_fields).grid(row=10, column=1,sticky=W,pady=4)
call = e1.get()
cl=len(call)
wait = str(input("w2"))
print ("newcall cl: " ,call, cl)


x = Label(mrdFenster, text="dann schaun wir mal ", bg="blue", fg="white").grid(row=0,column=1, sticky=W)
print("**call:", call, e1.get())

# der "test_call(call)" simuliert einen grösseren Programmteil (kommt später dazu)
#der prüft ob das Rufzeichen (call) schon vorhanden ist. kehrt bei ja mit "j"
#zurück
ok =test_call(call) # test ob call schon da input mit call - zurück mit j/n


print("ok= ", ok)
wait = str(input("w3"))

if ok == "j":
x = Label(mrdFenster, text="den hatten wir schon mal ", bg="white", fg="blue").grid(row=0,column=1, sticky=W)
e1.delete(0,END)
#
# hier abbruch zu w9 und neuer Durchgang via mainloop()
# müsste dann wieder ab while erneut getest werden !!!!!
#
else:
x = Label(mrdFenster, text=" weiter get's ", bg="blue", fg="white").grid(row=0,column=1, sticky=W)

wait = str(input("w4"))

###Button(mrdFenster, text="show", command=show_entry_fields).grid(row=10, column=1,sticky=W,pady=4)
wait = str(input("w5"))
Button(mrdFenster, text="save", command=save_entry_fields).grid(row=12, column=1,sticky=W,pady=4)
wait = str(input("w6"))

call=str(e1.get())
qsa= str(e2.get())
qrk= str(e3.get())
op = str(e4.get())
excall = str(e5.get())
qra = str(e6.get())
qssm = str(v.get())
start = v.get() #= v.set() Band = immer nach der letzten Einstelung

pkt = str(1)

#start = qssm #'=v.set()
#Button(mrdFenster, text="show", command=show_entry_fields).grid(row=10, column=1,sticky=W,pady=4)

print (" alles =:", call, qsa, qrk, op, excall, qra, qssm, pkt)
print (start)
wait = str(input("w7"))
#hier wegspeichern#

#Button(mrdFenster, text="save", command=save_entry_fields).grid(row=12, column=1,sticky=W,pady=4)

##jetzt ress button save!!


wait = str(input("w9"))

mrdFenster.mainloop()

wait = str(input("w10"))

@marconisahib: GUI-Programmierung funktioniert nicht so linear wie ein Konsolenprogramm mit `raw_input()` und ``print``. Man erstellt erst die GUI, verbindet dann die gewünschten Ereignisse wie das drücken von Schaltflächen mit Rückruffunktionen, und ruft am Ende des Hauptprogramms die GUI-Hauptschleife auf. Alles andere passiert dann erst in den Rückruffunktionen wenn die Ereignisse eintreten. Beispielsweise das der Benutzer auf eine Schaltfläche klickt.

Davon unabhängig ist das ganze Programm *sehr* unübersichtlich.

Vermeide Sternchen-Importe. Aus `Tkinter` kippst Du so ca. 190 Namen in Dein Modul, von denen nur ein Bruchteil tatsächlich verwendet wird.

Auf Modulebene gehört nur Code der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst.

Alles was eine Funktion oder Methode ausser Konstanten benötigt, sollte als Argument übergeben werden. Wenn man auf magische Weise irgendwelche Variablen aus der Umgebung nimmt, ist das Programm sehr schwer nachvollziehbar und die Funktionen/Methoden schlecht bis gar nicht isoliert testbar oder wiederverwendbar.

Bei GUI-Programmierung kommt man bei jedem nicht-trivialen Programm um objektorientierte Programmierung nicht herum, denn man braucht ja irgendwie den Zustand des Programms über Aufrufe der Rückruffunktionen hinweg.

sri, ich weiss nicht, wie man von mc den Quellcode mit allen Einrückungen kopieren kann.

@marconisahib: Da gibt's im vollständigen Editor die Schaltfläche „Python“ um den ausgewählten Quelltext in [ Python ]-Tags zu setzen. Dann werden die Einrückungen hier im Forum korrekt angezeigt.

Danke für Eure Hinweise.
Ich muss jetzt erst einmal "tief Luft" holen und alles neu nachlesen.

mni tks