Objektorientiertes Programmieren Label und Button

[Sconine]

Und wieder ein Programm zum überarbeiten.

Code: Alles auswählen

import Tkinter

root=Tkinter.Tk()

def output():

    """prints name and matnr to console"""

    print 'Mustermann, 12772'

# create 2 labels and 2 buttons

label0 = Tkinter.Label(text='Mustermann')
label1 = Tkinter.Label(text='12772')
button0 = Tkinter.Button(text='Quit', command=quit)
button1 = Tkinter.Button(text='Output', command=output)


# arrange widgets on 2x2 grid

label0.grid(row=0, column=0)
label1.grid(row=0, column=1)
button0.grid(row=1, column=0)
button1.grid(row=1, column=1)


root.mainloop()

[Zap]

Und wieder ein Programm zum überarbeiten.

Was erwartest du jetzt? Eine überarbeitete Version?

[jerch]

Bitte überarbeiten, bin irgendwie unzufrieden damit:

Code: Alles auswählen

print "Hello world!"

Schusterst Du jetzt das Forum mit Aufgaben aus einer Übungsserie voll? Ganz abgesehen davon, daß Du in der Überschrift was von objektorientiert schreibst und Dein Code außer dem Benutzen von Objekten nix damit zu tun hat.
Zum Lernen von OOP waren Deine anderen Bsp. besser geeignet, die Übungserie macht wohl Rückschritte...

[EyDu]

Ich finde deinen Code etwas umständlich und unübersichtlich, daher mal ein Gegenvorschlag:

Code: Alles auswählen

from Tkinter import *

r = Tk();

class x:
  def Opt():
    print('Mustermann, 12772'); #prints "Mustermann, 1277"
  
  def Q():
      pass;

list = [(Label,"Mustermann"),(Label,"12772"),(Button,"Quit",x().Q),(Button,"Output",x().Opt)];
[list[i][0](**dict(zip(("text","command"),list[i][1:]))).grid(row=(i&2)>>1,column=i&1)for i in range(len(list))];

r.mainloop(); 

[Sconine]

Hab es schon bemerkt, dass die Überschrift nichts mit dem Programm zu tun hat. Leider zu spät.

Überarbeiten ist wohl blöd ausgedrückt. Ich find es nur wahnsnnig, dass man ein Programm unterschiedlich schreiben kann und es trotzdem dasselbe macht. Ich kann nicht so gut mit Python umgehen.

[Sconine]

@ EyDu: Bei dem Programm "Quadrat" hast du gesagt, dass man *-Importe nicht unbedingt verwenden sollte, da es unübersichtlich ist und zu Fehlern führen kann. Ist es bei einigen Programmen doch zum Vorteil *-Importe zu verwenden?
Ist es denn richtig, dass z.B. bei turtle import * alle -hmm... jetzt Fehlen mir wieder die Begriffe- "Befehle" aufgerufen werden, die turtle beinhaltet. Also, dass man nicht vor jedem "Befehl" der von turtle kommt mit turtle. aufrufen muss?

[EyDu]

Du solltest mein Programm wirklich NICHT als Verbesserung oder gutes Beispiel sehen. Negativbeispiel wäre die passende Beschreibung. Dein erste Post war einfach so offen, da wollte ich auch mal eine Überarbeitung liefern.

[jerch]

Überarbeiten ist wohl blöd ausgedrückt. Ich find es nur wahnsnnig, dass man ein Programm unterschiedlich schreiben kann und es trotzdem dasselbe macht. Ich kann nicht so gut mit Python umgehen.

Die Quahl der Wahl? Gerade das macht doch den Reiz aus, gäbe es nur einen Weg nach Rom, könnte man eine Maschine da hinfahren lassen und die meisten Programmierer wären arbeitslos (vorallem wohl aus Interessenmangel).
Und keine Angst, Sicherheit in einer Sprache lernst Du mit dem Sprechen (also Code Schreiben) und hin und wieder Nachfragen (z.B. hier), Feinheiten und Kniffe mit dem Lesen von Quelltext.

Beim Programmieren gehts letztendlich eher darum, den richtigen Blick auf die Problemstellungen zu entwickeln (analytisch algorithmisches Denken oder wie man das auch immer nennen möchte), dafür ist die Sprache unerheblich. Die Crux ist halt, das es zum Erlernen des Verständnisses einer Semantik bedarf, und hier kommen dann Paradigmen und die Sprachen (Sem&Syntax) ins Spiel. So kann ein guter Programmierer relativ leicht zwischen paradigmatisch nahestehenden Sprachen umschalten, da Syntaxunzulänglichkeiten schnell nachgeschlagen sind, während der "große" Blick erhalten bleibt.

Langer Rede kurzer Sinn: Machen Machen Machen

zu den *-Importen:
* importiert alles, was im Modul auf der "obersten Ebene" deklariert ist und mappt es in die "oberste Ebene" Deines Skriptes (__main__ für das Hauptskript). Und da Programmierer eher unbegabt sind, was die Namensvergabe für Bezeichner angeht (ok, sprechende Namen gibts nicht so viele), sind Kollisionen vorprogrammiert.

[Sconine]

Habe ich denn wenigstens den *-Import richtig verstanden?

Man muss ja hier richtig aufpassen, was man schreibt. Sorry, wenn das erste Post "plump" herübergekommen ist.

Programmierung ist echt nicht mein Ding, deshalb freue ich mich über jede kleine Hilfestellung.

[EyDu]

Wenn du den *-Import so verstanden hast, dass alle globalen Namen aus dem importierten Modul jetzt auch in dem importierenden Modul auftauchen, dann ja. Aber die einfachste Regel lautet: mache keine *-Importe. Niemals.

[numerix]

Ist es denn richtig, dass z.B. bei turtle import * alle -hmm... jetzt Fehlen mir wieder die Begriffe- "Befehle" aufgerufen werden, die turtle beinhaltet. Also, dass man nicht vor jedem "Befehl" der von turtle kommt mit turtle. aufrufen muss?

Frage an sich ist ja schon beantwortet.

Ergänzend dazu: Bei (x)turtle wird häufig der Sternimport verwendet, weil sich der Quelltext einfacher liest, wenn die turtle mit vielen einzelnen Anweisungen über den Bildschirm bewegt wird. Das gilt in besonderer Weise für turtle-Experimente in einer interaktiven Sitzung. Für sowas ist der Stern praktisch.

[Sconine]

Ich habe im Internet folgendes Programm gefunden (Kommentare stammen von mir um zu sehen was ich verstehe und was nicht, Mustermann und 12772 stammen von mir):

Code: Alles auswählen

from Tkinter import *  

#Klasse App wird definiert
class App:  


   
  #Die Buttons werden beschrieben
  def __init__(self,master): 

      #???
      frame=Frame(master) 

      #???
      frame.pack() 

      #Ein Button bekommt den Namen 'Quit' und das ist in rot geschrieben
      #bedeutet command, dass der Befehl von dem Button ausgefürt werden soll?
      #also dass nach dem Betätigen des Buttons das Programm beendet werden soll.
      self.button=Button(frame,text='Quit', fg='red', command=frame.quit) 

      #Quit-Button auf der linken Seite???
      self.button.pack(side=LEFT)  

      #Der andere Button wird beschrieben
      #Wenn der Button betätigt wird, erscheint Mustermann, 12772, da es bei say_hi
      #beschrieben wird.
      self.hi_there=Button(frame,text='Output',command=self.say_hi) 

      #Output-Button auch auf der linken Seite???
      self.hi_there.pack(side=LEFT)  


   
  #say_hi wird definiert, damit nach Betätigung des Output-Buttons
  #der oben definiert wurde, Mustermann und 12772 erscheint
  def say_hi(self):
    
      #Mustermann und 12772 werden rausgegeben
      print 'Mustermann, 12772!'   


root=Tk() 

app=App(root) 

root.mainloop() 

Es wird wieder *-Import benutzt und auf einer anderen Seite steht sogar, dass es damit einfacher sein soll.

Wenn ich jetzt kein *-Import benutze muss doch vor jedem Wort, dass unten in der Liste steht Tkinter. geschrieben werden?


Es tut mir leid, dass alles ein wenig länger bei mir dauert.
Vielen Dank für eure Mühe!

[EyDu]

*-Importe sind nur auf den ersten Blick einfacher. Die Probleme die sich daraus ergeben sind aber umso komplexer.

Das mit dem "Tkinter." Davorschreiben hast du richtig verstanden. Wenn dir das zu lang ist, dann kannst du auch "import Tkinter as tk" machen, dann reicht ein "tk.". Das steht aber auch alles im Tutorial.

Viel Code solltest du übrigens auslagern. Und wenn du das Programm schon irgendwo gefunden hast, dann hätte auch ein Link auf die Seite genügt und keine Kopie. Es wäre gut, wenn du deinen Post noch mindestens so weit anpassen würdest, dass das letzte Stück Code nicht über den rechten Rand läuft (max. 79 Zeichen pro Zeile).

[jerch]

Kurzer Blick ins Tutorial und tätsächlich ist die Import-Sache da nicht besonders einsteigerfreundlich geschrieben (http://docs.python.org/tutorial/modules.html). Für *-Importe sollte vllt. auf die Kollisionsgefahr hingewiesen werden, "import .. as .." hab ich da auf die Schnelle garnicht finden können.

[Sconine]

Entschuldiege wegen des langen Codes.

Ich hab mich schon gewundert, dass die Seite bei mir so komisch aussieht. Wie kann ich das denn jetzt ändern?

[jerch]

@Sconine:
Nimm ihn doch einfach wieder raus, er zeigt nämlich nicht das, was er vorgibt zu zeigen (Du hast uns da ein "from Tkinter import *" unterschlagen).

[Sconine]

Oh man, nu bin ich raus.

Es muss doch vor:
- Button
- Pack
- App
- Frame
- root

tk. stehen. Was ist denn mit der Groß- unnd Kleinschreibung? Brauch ich nur vor den "großen" tk. schreiben oder auch vor den "kleinen"?

Was für eine blöde Frage. Sorry.

Sind denn meine "Kommentare" soweit ok, oder habe ich alles falsch verstanden?

[Sconine]

Ach ja, ich habe bestimmt ein tk. irgendwo vergessen oder einen Fehler bei der Groß und Kleinschreibung.

Ich verstehe es mit dem App und app nicht, sowie mit tk und Tk.

Code: Alles auswählen

import Tkinter as tk

#Klasse App wird definiert
class App():  
   
  #Die Buttons werden beschrieben
  def __init__(self,master): 

      #???
      frame = tk.Frame(master) 

      #???
      frame.pack() 

      #Ein Button bekommt den Namen 'Quit' und das ist in rot geschrieben
      #bedeutet command, dass der Befehl von dem Button ausgefürt werden soll?
      #also dass nach dem Betätigen des Buttons das Programm beendet werden soll.
      self.button=tk.Button(frame,text='Quit', fg='red', command=frame.quit) 

      #Quit-Button auf der linken Seite???
      self.button.pack(side=LEFT)  

      #Der andere Button wird beschrieben
      #Wenn der Button betätigt wird, erscheint Mustermann, 12772, da es bei
      #output beschrieben wird.
      self.output=tk.Button(frame,text='Output',command=self.output) 

      #Output-Button auch auf der linken Seite???
      self.output.pack(side=LEFT)
   
  #output wird definiert, damit nach Betätigung des Output-Buttons,
  #der oben definiert wurde, Mustermann und 12772 erscheint
  def output(self):
    
      #Mustermann und 12772 werden rausgegeben
      print 'Mustermann, 12772!'   

tk.root = Tk()

Tk.app = App(root) 

root.mainloop() 

[numerix]

Lies doch mal diesen Grundlagenartikel zu Tkinter: http://www.ferg.org/thinking_in_tkinter ... grams.html

Nimm dir Zeit dafür, arbeite die Beispiele durch und lass dein Programm erstmal beiseite.

[jerch]

Ok vllt. hilft Dir kleines sinnfreies Bsp. auf die Sprünge:
haustiere.py

Code: Alles auswählen

from haustier import Haustier
TIERE_DAHEIM = 0

def tier_anschaffen():
    pass

class Hund(Haustier):
    def bellen(self):
        print "WauWau"

Jetzt zu den verschied. Importmöglichkeiten

Code: Alles auswählen

>>> import haustiere
>>> print dir()
['__builtins__', '__doc__', '__name__', '__package__', 'haustiere']
>>> print dir(haustiere)
['Haustier', 'Hund', 'TIERE_DAHEIM', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'tier_anschaffen']
>>> haustier.Hund()
<haustiere.Hund instance at ...>

Code: Alles auswählen

>>> from haustiere import *
>>> print dir()
['Haustier', 'Hund', 'TIERE_DAHEIM', '__builtins__', '__doc__', '__name__', '__package__', 'tier_anschaffen']
>>> Hund()
<haustiere.Hund instance at ...>

Code: Alles auswählen

>>> import haustiere as ht
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'ht']
>>> dir(ht)
['Haustier', 'Hund', 'TIERE_DAHEIM', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'tier_anschaffen']
>>> ht.Hund()
<haustiere.Hund instance at ...>

Code: Alles auswählen

>> import haustiere as DER_NAME_ist_Schall_und_rauch
>>> dir()
['DER_NAME_ist_Schall_und_rauch', '__builtins__', '__doc__', '__name__', '__package__']
>>> dir(DER_NAME_ist_Schall_und_rauch)
['Haustier', 'Hund', 'TIERE_DAHEIM', '__builtins__', '__doc__', '__file__', '__name__', '__package__', 'tier_anschaffen']
>>> DER_NAME_ist_Schall_und_rauch.Hund()
<haustiere.Hund instance at ...>

Code: Alles auswählen

>>> from haustiere import Hund
>>> dir()
['Hund', '__builtins__', '__doc__', '__name__', '__package__']
>>> Hund()
<haustiere.Hund instance at ...>