GUI Programmierung mit Python

Transkript

1 GUI Programmierung mit Python 1

2 Inhaltsverzeichnis 1. Grundlagen der Objektorientierten Programmierung (OOP) Klassen und Objekte Kapselung Vererbung Erste Oberflächen Hallo Welt! Basisprogramm Dekorative Verfeinerungen Programmende Eigenschaftsänderungen zur Laufzeit Benutzereingaben - Steuerelementvariablen Farbmischer Layout Eine Farbe Rot Ein Mischlabel Zeichnen mit Python Canvas Noch ein Nikolaus Farbwahl Kreise und Kreisbögen Dreiecke Vierecke Polygone Texte Bewegung Der springende Punkt Ein Spiel Basics Leinwand Der Ball Bewegung für den Ball Einfache Bewegung Hin und wieder zurück Irgendwo hin Ein Prallbrett Bewegung mit den Maustasten Treffer feststellen

3 3.2.7 Quelltext Literatur

4 1. Grundlagen der Objektorientierten Programmierung (OOP) Vor der objektorientierten Programmierung wurden Programme von oben nach unten abgearbeitet. Wollte man an eine bereits abgearbeitete Stelle oder musste eine Stelle im Quelltext übersprungen werden, dann gab es Befehle, mit denen man an diese Sprünge bewerkstelligen konnte. Diese Art der Programmierung war unübersichtlich und fehleranfällig. Insbesondere war ein Programmierer, der das Programm nicht entwickelt hatte, kaum in der Lage, sich schnell in das Programm einzuarbeiten. Mit der objektorientierten Programmierung gab es dann einige Veränderungen. Die OOP wird durch drei Grundelemente bestimmt: Klassen und Objekte Kapselung Vererbung 1.1. Klassen und Objekte Jedes Programm, das man benutzt, besteht aus Klassen mit Objekten. Den Klassen und ihren Objekten sind bestimmte Attribute (Eigenschaften) und bestimmte Methoden (Veränderungsmöglichkeiten) zugeordnet. Ein Beispiel aus der analogen Welt: das Pferd. PFERD Geschlecht Größe Farbe traben schreiten galoppieren Dies ist die Klassenkarte. Sie beschreibt alle Eigenschaften aller Mitglieder dieser Klasse und alle Methoden aller Klassenmitglieder. Falbe: PFERD Geschlecht: männlich Größe: 2,00m Farbe: falb traben schreiten galoppieren Schimmel: PFERD Geschlecht: männlich Größe: 2,00m Farbe: weiß traben schreiten galoppieren Aus der Klasse werden Objekte abgeleitet. Im Gegensatz zur Klasse besitzen hier die Eigenschaften Werte. Grundsätzlich lassen sich unendlich viele Objekte von einer Klasse ableiten. Allerdings besitzen sie nur die Attribute und Methoden der Klasse, aus der sie stammen. Klassen in Python werden über die Module bereitgestellt, lassen sich aber mit dem class-befehl auch direkt erstellen. class meineklasse(object): pass Nun gibt es eine Klasse meineklasse, die allerdings, festgelegt durch pass, leer ist. 4

5 Methoden innerhalb einer Klasse sind eigentlich nichts anderes als Funktionen, die als ersten Parameter den Bezug zur Klasse beinhalten. # Definition der Klasse Baum class Baum: wachstum = 0 def wachstumstempo(self, wert): self.wachstum += wert def ausgabe(self): print ("Wachstum:", self.wachstum) Der Parameter self verweist auf die Klasse Baum. Diese Klasse kann man nun auch nutzen: # Definition der Klasse Baum class Baum: wachstum = 0 def wachstumstempo(self, wert): self.wachstum += wert def ausgabe(self): print ("Wachstum:", self.wachstum) # Eigenschaft # Methode # Methode # Eigenschaft # Methode # Methode # Objekte der Klasse Baum erzeugen eiche = Baum() ulme = Baum() # Objektmethoden eiche.ausgabe() eiche.wachstumstempo(200) eiche.ausgabe() #Ursprungswert anzeigen #neuen Wert hinzufügen #neuen Wert anzeigen lassen # Objekt betrachten ulme.ausgabe() #vgl. Theis: Einstieg in Python Die Ausgabe sähe so aus: Wachstum: 0 Wachstum: 200 Wachstum: 0 In komplexeren Programmen werden Objekte initialisiert, d.h. ihnen werden von vornherein bestimmte Attribute zugewiesen, deren Wert bei Programmstart festgelegt wird, damit das Programm korrekt startet. 5

6 Das obige Beispiel verändert sich dadurch etwas. # Definition der Klasse Baum class Baum: def init (self,wachstum): #Objekt initialisieren, Parameter nennen self.wachsen = wachstum #der klasseeigenen Variablen den Wert des Parameters Wachstum geben def wachstumstempo(self, wert): # Methode mit einem Parameter self.wachsen += wert # Variable wachsen wird um Wert des Parameters verändert, d.h. self.wachsen=self.wachsen+wert def ausgabe(self): # Methode print ("Wachstum:", self.wachsen) # Objekte der Klasse Baum erzeugen eiche = Baum(0) #Wert aller Parameter muss in der Klammer stehen ulme = Baum(1) # Objektmethoden eiche.ausgabe() eiche.wachstumstempo(200) eiche.ausgabe() # Objekt betrachten ulme.ausgabe() Bei der Initialisierung wird festgelegt, dass alle Objekte der Klasse Baum einen Parameter wachstum haben. Dieser muss, wenn ein Objekt, z.b. eiche oder ulme, erstellt wird, auch mit einem Wert versehen werden Kapselung (oop_kapselung.py) Objekte besitzen, wie bereits gesagt, nur die Attribute und Methoden, die ihre Klasse bereitstellt. Auf Eigenschaften kann nur mit Hilfe der korrekten Methoden zugegriffen werden. Dieses Konzept innerhalb der Objektorientierung nennt man Kapselung. Anders formuliert: Pferde können nicht fliegen. Dies zwingt zu sauberer Programmierung und Nutzung der für eine Aufgabe passenden Objekte. Bislang sind die Daten in unserem Beispiel nicht gekapselt, d.h. theoretisch kann von außen auf sie zugegriffen werden. Möglich wäre also dies: # Definition der Klasse Baum class Baum: 6

7 def init (self,wachstum): self.wachsen = wachstum def wachstumstempo(self, wert): self.wachsen += wert def ausgabe(self): print ("Wachstum:", self.wachsen) # Objekte der Klasse Baum erzeugen eiche = Baum(0) ulme = Baum(1) eiche.wachsen=100 # Objektmethoden eiche.ausgabe() eiche.wachstumstempo(200) eiche.ausgabe() # Objekt betrachten ulme.ausgabe() In der fett gedruckten Zeile wird auf den Wert des Attributs zugegriffen. Dies ermöglicht Manipulationen und ist nicht gewollt. Deshalb gibt es die Möglichkeit, Attribute mittels Unterstrich als protected oder doppeltem Unterstrich private zu deklarieren, um sie zu schützen. Attribut Kapselung wachsen Public auch von außen les- und schreibbar _wachsen Protected von außen les- und schreibbar, aber dies ist unerwünscht wachsen Private nicht von außen les- und schreibbar Aufgabe: 1. Erstelle ein Programm mit verschiedenen Klassen und Objekten. 2. Wende die Datenkapselung an und teste ihre Auswirkungen! 7

8 1.3. Vererbung Die OOP und übrigens auch das wirkliche Leben kennen Ober- und Unterklassen. Dabei gilt: Unterklassen erhalten von der Oberklasse alle Attribute und Methoden. Das Beispiel aus der analogen Welt: An nebenstehendem Schema wird deutlich, dass die Klasse PFERD offensichtlich eine Reihe von Attributen und Methoden von übergeordneten Klassen geerbt hat, z. B. Atmung, Knochen etc. In Python lassen sich dann auch neue Klassen und Objekte generieren, die Attribute und Methoden aus zwei Oberklassen enthalten. Dies nennt man Mehrfachvererbung. In Python hieße das z. B. class Baum(Algen, Moose). Darüber können Klassen auch Methoden erben, die ihnen eigentlich nicht zugedacht wären: Class Pferde(saeugetiere, voegel) In Python können Pferde fliegen. Aufgabe: Erstelle eine Übersicht zu Ober- und Unterklassen im Fahrzeugbereich. 8

9 2. Erste Oberflächen Moderne Programme verarbeiten zwar Programmtext, sobald sie aber auch Nutzereingaben einschließen, werden sie mit einer grafischen Benutzeroberfläche versehen, damit die Nutzer nicht nur vor einer Textkonsole sitzen müssen. Python stellt dafür das Modul tkinter (Tool Kit Interface) bereit, das, ähnlich wie z.b. turtle, über den entsprechenden Befehl importiert werden muss. from tkinter import * Hiermit werden alle Klassen des Moduls mit ihren Attributen und Methoden bereitgestellt. TKinter bietet die folgenden Widgets (Fensterkomponenten): Klasse Beschreibung Tk Hauptfenster einer Applikation mit Knöpfen zum lkonisieren, Vergrößern und Schließen Label Feld mit vorgegebenem Text oder Bild Button Schaltfläche Canvas Vektorgrafiken Checkbutton Quadratisches Feld für Mehrfachauswahl (m aus n) Entry Einfaches Eingabefeld für Texte Frame Rechteckiger Bereich (»Oberfläche«), in den man andere Widgets platzieren kann Listbox Liste von Auswahlfeldern (Einfach- und Mehrfachauswahl) Menu Darstellung von Toplevel-, Pulldown- und Popup-Menüs Photoimage Bild (GIF oder PPM /PGM) Radiobutton Rundes Feld für Einfachauswahl (1 aus n) Scale Waagrechte oder senkrechte Schieberegler Scrollbar Scrollleiste, die z.b. in Listbox-, Text- oder Canvas-Widgets eingebaut werden kann, um die Darstellung umfangreicher Inhalte zu ermöglichen Text Textfeld, in dem mehrzeilige formatierte Texte bearbeitet werden können (M. Weigend: Python GE-PACKT. Mitp, Heidelberg 2013, 5. Aufl., S. 458f) 9

10 2.1. Hallo Welt! Der Klassiker ist natürlich das altbekannte Hallo Welt! Basisprogramm Zunächst wird das Modul tkinter importiert. Die Benutzeroberfläche des späteren Programms erhält die Bezeichnung fenster. Der sog. Packer packt daher die Bezeichnung - das Objekt auf die Oberfläche. from tkinter import * fenster=tk() lbl1=label(fenster,text="hallo Welt!") lbl1.pack() Tipp Objekte sollten, ebenso wie Variablen und Funktionen, so benannt werden, dass sie problemlos zugeordnet werden. So erhalten Label z.b. den Vorsatz lbl, Buttons ein btn etc. In komplexeren Programmen ist dies für erfolgreiches Arbeiten unerlässlich Dekorative Verfeinerungen Natürlich ist dies nur ein Anfang. Hier wird das Label weiter gestaltet. Die Kommentare erläutern die einzelnen Befehle. Der Backslash wird in Python genutzt, um lange Programmzeilen mit einem Zeilenumbruch zu versehen, ohne dass sie als getrennte Befehlsfolgen interpretiert werden. from tkinter import * fenster=tk() lbl1=label(fenster, #Festlegung des Eltern-Elements \ text="hallo Welt!", #Festlegung des Textes auf dem Label\ bg="yellow", #Hintergrundfarbe(background)\ bd=5, #Randstärke(border)\ relief=groove, #Randform\ fg="red", #Schriftfarbe (foreground)\ font=('verdana',25,'bold'), #Schrift(-art, -größe, -stil)\ padx=10, #Innenabstand in x-richtung\ pady=10, #Innenabstand in y-richtung\ height=2, #Höhe in Textzeilen(nur Elemente mit Text)\ width=12) #Breite in Pixel\ lbl1.pack() #Positionierung auf dem Fenster\ fenster.mainloop() #Endlosschleife für Useraktionen\ 10

11 Das ist das Ergebnis des obigen Quelltextes. Die Standard Optionen der tkinter- Widgets sind: Option Erklärung activebackground Hintergrundfarbe, wenn das Widget aktiv ist (z.b. wenn Button»gedrückt«wird) activeforeground Vordergrundfarbe, wenn das Widget aktiv ist anchor Mögliche Werte: CENTER, E, N, W, S, NE, NW, SE, SW Immer wenn ein Widget kleiner ist als der Platz, der für es vorgesehen ist (Zelle), wird mit diesem Attribut die Platzierung in der Zelle durch»himmelsrichtungen«festgelegt. Default ist meist CENTER (in der Mitte), NE: rechte obere Ecke, N: mittig an der oberen Seite, E: mittig an der rechten Seite usw. bd, borderwidth Breite des Rahmens des Widgets, z.b. "lc" oder 10 bg, background Hintergrundfarbe Bitmap Name einer Standard-Bitmap, die auf dem Widget zu sehen sein soll Cursor Name eines Standard-Cursors, der über dem Widget verwendet wird (X_cursor,,...) default Voreingestellt ist NORMAL. Mit dem Wert DISABLED wird das Widget deaktiviert. disabledforeground Vordergrundfarbe (Textfarbe), falls das Widget deaktiviert ist fg, foreground Vordergrundfarbe (Textfarbe) font Front-Deskriptor für den verwendeten Schrifttyp (Font) height Höhe des Widgets (senkrecht), z.b. "lc" oder 100. Bei Elementen mit Text in Zeilen, sonst in Pixeln angegeben. image Name eines Bildes (Image-Objekt), das auf dem Widget (z.b. Button) zu sehen ist justify Ausrichtung von Textzeilen auf dem Widget: CENTER: zentriert LEFT, RIGHT: links- oder rechtsbündig padx Leerer Raum rechts und links vom Widget oder Text, z.b. "0.5c" oder 10 pady Leerer Raum über und unter dem Widget oder Text, z.b. "lc" oder 10 relief Form des Rahmens: SUNKEN, RAISED, GROOVE, RIDGE, FLAT text Beschriftung des Widgets (z.b. Button oder Label) textvariable Ein Objekt der Klasse StringVar, das den (variablen) Text enthält, der auf dem Widget (z.b. Button oder Label) erscheint underline Default ist -1. Wenn die Zahl nicht negativ ist, gibt sie die Nummer des Zeichens an, das unterstrichen sein soll. width Breite des Widgets (horizontal), z.b. "3c" oder 100 xscrollcommand Wenn das Widget scrollbar ist, wird die set( )-Methode des horizontalen Scrollbar-Objektes angegeben. yscrollcommand Wenn das Canvas scrollbar ist, wird die set( )-Methode des vertikalen Scrollbar-Objektes angegeben. 11

12 Der Packer bietet die Möglichkeit, die von ihm gepackten Objekte zu positionieren bzw. Eigenschaften mit Wirkung auf die Position festzulegen. Die wichtigsten Optionen für den Packer Option Erklärung anchor Mögliche Werte: CENTER, E, N, NE, NW, S, SE, SW, W. Widget wird in eine Ecke oder mittig an einer Seite der Zelle platziert, entsprechend der angegebenen»himmelsrichtung«(z.b. NE = Nordost = rechts oben). expand expand=0: Die Größe des Widgets ändert sich nicht, wenn das Anwendungsfenster vergrößert wird. expand=1: Die Größe des Widgets passt sich an, wenn das Anwendungsfenster vergrößert wird. fill fi 11=X: Das Widget wird in waagrechter Richtung (»x-achse«) soweit mit leerem Raum gefüllt, dass sich seine Ausmaße der Größe des Masters anpassen. fill=y: Das Widget wird in senkrechter Richtung (»y-achse«) an die Größe des Masters angepasst. fill=both: Das Widget passt sich in beiden Richtungen dem Master an. fill=none: Das Widget behält seine Größe unabhängig von den Ausmaßen des Masters. padx Die Zelle wird rechts und links vom Widget in der angegebenen Länge mit leerem Raum gefüllt. Die Option padx=10 bewirkt z.b., dass die Zelle rechts und links um zehn Pixel verbreitert wird. pady side Die Zelle wird oberhalb und unterhalb des Widgets mit leerem Raum gefüllt. LEFT: Das Widget wird an den linken Rand des Masters gesetzt. RIGHT: Das Widget wird an den rechten Rand des Masters gesetzt. TOP: Das Widget wird nach oben gesetzt. BOTTOM: Das Widget wird nach unten gesetzt. Bei komplexeren Benutzungsoberflächen sind an einigen Stellen Widgets nebeneinander und an anderen Stellen untereinander angeordnet. In diesem Fall verwendet man Frames. Für die Planung eines Layouts mit dem Packer kann man den Entwurf durch gerade Schnitte so weit zerlegen, bis jede zusammenhängende Gruppe von Widgets einheitlich orientiert ist. Das heißt, die Widgets der Gruppe sind entweder von rechts nach links oder von oben nach unten aufgereiht. Für jede Gruppe, die aus mehr als einem Widget besteht, erzeugen Sie einen Frame, dem die enthaltenen Widgets als Slaves zugewiesen werden. (in: M. Weigend: Python 3. Mitp, Heidelberg 2013, 5. Aufl., S. 462) 12

13 Programmende Um ein Programm zu beenden, reicht es zwar, das Fenster zu schließen. Aber auch ein Button wäre schön. Mit dem Befehl meinbutton=button(fenster, text="ende") meinbutton.pack() wird ein Button in das Fenster gelegt. Aufgabe: 1. Gestalte Button und Label passend. 2. Positioniere beide mit Hilfe des Packers. Allerdings ist eine Nutzung noch nicht möglich. Dafür muss dem Button noch Befehlstext zugewiesen werden. Dazu wird zunächst eine Funktion erstellt, die das Hauptfenster beendet. def ende(): fenster.destroy() #Beendet das Hauptfenster Dann wird diese Funktion im Button als Parameter verankert. meinbutton=button(fenster, text="ende",command=ende) Aufgabe: Ergänze das Programm entsprechend. Hinweis Farben in Tkinter Zwei Standardfarben sind black und white. Dazwischen liegen Grautöne. gray ist ein mittleres Grau. Es gibt aber 101 feine Abstufungen von schwarzem Grau, gray0, bis zu weißem Grau, gray100. color("red") ergibt ein strahlendes Rot color("red1") entspricht color("red ") color("red2") etwas dunkler color("red3") noch etwas dunkler color("red4") ziemlich dunkel Farbtabelle aller Farbnamen Snow LightCyan tan LightBlue Seashell PaleTurquoise chocolate LightCyan AntiqueWhite CadetBlue firebrick PaleTurquoise Bisque turquoise brown LightBlue Peach Puff cyan salmon SkyBlue NavajoWhite DarkSlateGray LightSalmon IndianRed LemonChiffon aquamarine orange sienna cornsilk DarkSeaGreen DarkOrange burlywood ivory SeaGreen coral wheat honeydew PaleGreen tomato gold LavenderBlush SpringGreen OrangeRed DarkOrchid MistyRose green red purple azure chartreuse DeepPink Medium Purple 13

14 SlateBlue OliveDrab HotPink Thistle RoyalBlue DarkOliveGreen pink magenta blue khaki LightPink plum DodgerBlue LightGoldenrod PaleVioletRed MediumOrchid SteelBlue LightYellow maroon DarkGoldenrod DeepSkyBlue yellow VioletRed RosyBrown LightSkyBlue goldenrod orchid LightSteelBlue SlateGray Eigenschaftsänderungen zur Laufzeit Bislang kann man sich das Fenster ansehen, aber nichts machen, außer das Fenster zu schließen. Aber natürlich können Attribute auch verändert werden. Die Veränderungen werden zunächst in eine Funktion gelegt und dann über den command-befehl in den Button-Parametern aufgerufen. def labeltext(): lbl1.config(fg="red4",font=('verdana',15,'bold'),\ text="schöne neue Welt", width=0) btn_neutext=button(fenster, text="neuer Text",command=labeltext) Tipp Es ist sinnvoll, seinen Quelltext zu ordnen, um den Überblick zu behalten. Zuerst müssen die Module importiert werden, die man benötigt, dann wird das Fenster initialisiert. Anschließend sollten die Funktionen erstellt werden. Die Objekte werden für die erste Verwendung erstellt. Die Objekte werden dann über den Packer auf dem Fenster platziert werden. Am Schluss wird das Fenster auf permanente Aktivität gestellt. from tkinter import * fenster=tk() #Meine Funktionen def ende(): fenster.destroy() #meine Objekte btn_ende=button(fenster, text="ende",command=ende) #Ins Fenster damit! btn_ende.pack(anchor=s,padx=10, pady=10,expand=0,side=right) #Immer auf Eingaben warten fenster.mainloop() Aufgabe: 1. Gestalte das Label selbst. 2. Integriere einen weiteren Button, der den Schließen-Button mit neuer Aufschrift anderen Farben etc. versieht. 14

15 Benutzereingaben - Steuerelementvariablen Natürlich sind auch hier Benutzereingaben möglich. Dazu wird die Klasse entry genutzt, die ein Eingabefeld bereitstellt. Der Inhalt des Text-Attributs kann über sog. Kontroll- oder Steuerelementvariablen genutzt werden. Python stellt in Tkinter drei Variablentypen bereit: DoubleVar() - eine Gleitkommazahl, Standardwert: 0.0. IntVar() - eine Ganzzahl, Standardwert: 0.0 StringVar() - ein String, als Standard leer: Laden des Tkinter-Moduls und initialisieren des Festers. Um das Text-Attribut auszulesen, muss zunächst eine entsprechende Steuerelementvariable initialisiert werden. In den Parametern des Objekts, das den Text enthält, z.b. einem Eingabefeld, wird über das Signalwort Textvariable festgelegt, dass die Steuerelementvariable den Inhalt des Textattributs erhalten soll. Das Übergeben der Textvariablen wird in eine Funktion gelegt. from tkinter import * fenster=tk() eingabetext=stringvar() eingabe_01=entry(fenster,textvariable=ei ngabetext) def labeltext(): lbl1.config(textvariable=eingabetext) Ein Label mit der Aufschrift Hallo Welt! wird generiert. Die Objekte werden auf das Hauptfenster gelegt. Die Funktion mit der Übergabe der Variablen an das Label wird aufgerufen. lbl1=label(fenster,text="hallo Welt!") eingabe_01.pack() lbl1.pack() labeltext() #Immer auf Eingaben warten fenster.mainloop() Ergebnis: 15

16 Aufgabe Erweitere dein Programm, so dass ein Klick auf einen Button den Text eines Labels ändert Farbmischer Layout Ziel dieses Abschnittes ist es, einen Farbmischer mit grafischer Oberfläche zu erstellen, das Farben über Schieberegler einstellt, die Farbwerte anzeigt und die Mischfarbe mit ihrem Hexadezimalwert anzeigt Frames (farbmischer_01.py) Hier reicht es nicht mehr, Objekte auf dem Fenster zu platzieren. Vielmehr müssen diese über Frames angeordnet werden. Dazu wird das Fenster in einzelne Frames aufgeteilt, die auch verschachtelt sein können. Ein Weg besteht darin, das Fenster in Frames zu teilen. In diesem Beispiel hätte das Fenster vier Frames, die übereinander liegen. Der Quelltext ist für alle drei Frames ähnlich. Hier am Beispiel des Fußbereichs mit dem Ende-Button. 16

17 Die Ende-Funktion wird erstellt. Das Fuss-Label wird erstellt inkl. Text- und Randformatierung. Der Ende-Button wird im Frame fuss erstellt. Das Frame wird auf das Fenster gepackt. Es soll sich auf die gesamte Fensterbreite ausdehnen und 10px Außenabstand haben. Der Button wird rechts auf das Frame gepackt. def ende(): fenster.destroy() fuss=labelframe(fenster,text="farbmischer",width=900,height=50,\ borderwidth=6,font=('verdana',15,'bold')) btn_ende=button(fuss, text="ende", command=ende,\ font=('verdana',15,'bold')) fuss.pack(fill=x, padx=10,pady=10) btn_ende.pack(anchor=e,padx=10,pady=10,expand=0,side=right) Hinweis Untergeordnete Elemente erhalten als ersten Parameter in der Klammer den Namen des übergeordneten Elements, des sog. Masters. Bei komplexeren Programmen sollte dies auch in einem Schema dargestellt werden Strukturschema Für den Überblick ist ein Strukturschema sinnvoll, das die Nehmen und Über- und Unterordnungen enthält. Dieses Beispiel enthält nur die Objektnamen und den Parameter, der das übergeordnete Element benennt, Fenster fenster=tk() titel=labelframe( fenster) farben=labelfra me(fenster) mischfarbe=lab elframe(fenster) fuss=labelfram e(fenster) btn_ende= Button(fuss) 17

18 Grids Neben Frames bieten Grids eine gute Möglichkeit zur Layoutgestaltung. Hierbei wird über eine Tabelle festgelegt, wie viele Zeilen und Spalten ein Element haben kann. Die einzelnen Objekte werden dann entsprechenden Spalten zugewiesen und die Zellen passen sich in der Größe den Objekten an. So legt der Nachsatz.grid(column=1,row=1) fest, dass das Objekt sich auf Zeile 1 in Süalte 1 befindet. Dies kann beliebig erweitert werden. lbl_red=label(fenster,height=10,width=20,bg='grey55').grid(colu mn=1,row=1) Typische Grid-Layouts wären z.b. Taschenrechner Pack Der Packer ist der älteste und einfachste Layoutmanager in Python. Er legt alle Elemente auf eine Ebene. Er wurde unter bereits vorgestellt und wird im Folgenden verwendet. Der Farbmischer besteht aus drei Scrollbars (Scale) und vier Labeln (Label) sowie einem Button (Button) zum Schließen des Programms. Diese werden mittels Pack auf der Oberfläche angeordnet. lbl_red.pack(anchor=w, side=left) skala_rot.pack(anchor=w, side=left) lbl_green.pack(anchor=w, side=left) skala_green.pack(anchor=w, side=left) lbl_blue.pack(anchor=w, side=left) skala_blue.pack(anchor=w, side=left) lbl_mix.pack(anchor=w, side=left) btn_ende.pack(anchor=s, side=bottom,padx=10,pady=10,expand=0) Hier werden die Labels und Scrollbars nebeneinander auf die Oberfläche gelegt. Die südliche Ausrichtung des Schließen-Buttons bewirkt, dass dieser unten im Fenster liegt Eine Farbe Rot Nach dem Import des tkinter-moduls, dem generieren des Fensters und der Änderung des Fenstertitels wird der Schließen-Button konfiguriert. from tkinter import * fenster=tk() fenster.title('farbmischer') def ende(): fenster.destroy() btn_ende=button(fenster,command=ende,text='ende') Die ende-funktion ist bereits bekannt. Sie schließt beim Aufruf das aktive Fenster. Nun werden das Label für die rote Farbe und die Scrollbar für die rote Farbe generiert. 18

19 lbl_red=label(fenster,height=10,width=20,bg='grey55')\ skala_rot=scale(fenster, length=150,width=25, \ orient=vertical, from_=1,to=255,\ command=farbanzeige,variable=r_wert) Der Parameter command ruft eine Funktion auf, die für die Übergabe des Scrollwertes genutzt werden wird. Scrollbars können den Scrollwert zurückgeben. Der Parameter variable generiert eine Steuerelementvariable, die diesen Scrollwert der Scrollbar enthält. Über r_wert=intvar() r_wert.set(200) wird die Scrollwert-Variable als Integer-Variable initiiert und mit einem Startwert von 200 versehen. Die Funktion get() erfasst dann die Werte der Scrollbar. r_str=str(r_wert.get()) Exkurs: Werte konvertieren Scrollbars geben Integer-Werte zurück. Diese müssen, damit sie als Farbangabe genutzt werden, in Hexadezimal-Werte umgeformt werden. Die Funktion hex(x) leistet dies und gibt einen entsprechenden String zurück. Allerdings birgt diese Umwandlung ein paar Probleme, denn für die Farbangabe im Label werden zweistellige Hexadezimalwerte für jeden der drei Farbbereiche Rot, Grün und Blau benötigt. Es muss also sichergestellt werden, dass auch wirklich so konvertiert wird. In der Konsole ergibt >>> hex(9) '0x9' Das vorangestellte 0x ist das Hexadezimal-Kennzeichen, der eigentliche Hexadezimalwert ist also 9. Es muss also dafür gesorgt werden, dass das Hexadezimal-Kennzeichen verschwindet und der Wert zweistellig wird, also ggf. eine Null vorangestellt wird. Über die Methode replace kann man in den drei Argumenten festlegen, welches Element eines Strings ersetzt werden soll, wodurch es ersetzt werden soll und wie oft diese Ersetzung in einem String vorgenommen werden soll. Beispiel >>> a='otto' >>> a=a.replace('o','mo',1) >>> print(a) Motto >>> Der Befehl len(x) gibt die Länge eines Strings zurück. >>> len(a) 5 >>> So ergibt sich für die Umwandlung der Steuerelementvariablen folgender Quelltext: r_str=str(r_wert.get()) r=int(r_str) print(r) #Farbwerte in Hex-Werte umrechnen r_hex=hex(r) 19

20 #Das HEX-Zeichen (0x) entfernen r_hex=r_hex.replace('0x','',1) #korrekte Länge der Hex-Werte herstellen if len(r_hex)<2: r_hex='0'+r_hex Der print-befehl dient nur der Kontrolle. Die Bedingung am Schluss prüft die Länge und fügt eine Null hinzu, falls nötig. Nun wird der Hexadezimalwert in eine neue Variable integriert und zur Kontrolle auf der Konsole angezeigt. Fir RGB-Abfolge bleibt dabei auch bei der Aneinanderreihung der Hexadezimalwerte erhalten. farbe_red='#'+r_hex+'00'+'00' print('#'+r_hex+'00'+'00') lbl_red['bg']='#'+r_hex+'00'+'00' Jetzt kann das Ganze in eine Funktion gelegt werden. Der Parameter self sorgt, dass die Funktion immer wieder aufgerufen wird, damit Änderungen der Farbwerte auch erfasst werden. Die Funktion wird durch das Bewegen der Scrollbar aufgerufen, muss also nicht gesondert im Programmtext aufgerufen werden. def farbanzeige(self): # Die Farbwerte festlegen r_str=str(r_wert.get()) r=int(r_str) print(r) #Farbwerte in Hex-Werte umrechnen r_hex=hex(r) #Das HEX-Zeichen (0x) entfernen r_hex=r_hex.replace('0x','',1) #korrekte Länge der Hex-Werte herstellen if len(r_hex)<2: r_hex='0'+r_hex Aufgabe: #neue Variable für den Farbwert festlegen farbe_red='#'+r_hex+'00'+'00' print('#'+r_hex+'00'+'00') lbl_red['bg']='#'+r_hex+'00'+'00' 1. Jetzt sollte ein erster Test möglich sein. Teste das Programm! 2. Ergänze das Programm um die Quelltexte für die Farben Grün und Blau. 20

21 Ein Mischlabel Ohne die Mischfarbe zu sehen, ist ein Farbmischer nicht sehr hilfreich. Das Problem dabei ist, dass die Variablen, die zur Farbgestaltung von den Scrollbars übergeben werden, nur lokal in der Funktion vorhanden sind. Exkurs Lokal Global Funktionen nutzen Variablen. Werden diese in der Funktion erstellt, dann sind sie außerhalb der Funktion nicht nutzbar. Wurden die Variablen im Hauptquelltext erstellt, kann die Funktion sie zwar nutzen, aber nicht umschreiben. Dieses Feature sichert ungewolltes Verhalten von Programmen ab, muss aber manchmal übergangen werden. Versucht man, eine lokale Variable global zu nutzen, gibt dies eine Fehlermeldung. >>> def test(): a=22 print(a) >>> test() 22 #lokale Variable lokal genutzt >>> print(a) Traceback (most recent call last): File "<pyshell#31>", line 1, in <module> print(a) NameError: name 'a' is not defined >>> Dementsprechend muss eine Variable global verfügbar, d.h. auf überschreibbar gemacht werden. Möglich macht dies der Befehl global, gefolgt vom Variablennamen. Die Variable kann allerdings nicht lokal generiert und dann übergeben werden. Um sie zu nutzen, muss sie also einmalig global erstellt und mit einem fiktiven Wert versehen werden. >>> def test(): global a a=22 print(a) #macht eine lokale Variable global >>> a=10 #Variable wird einmalig erstellt >>> print(a) 10 >>> test() 22 >>> print(a) 22 >>> Für den Farbmischer bedeutet dies, dass die Variablen für Rot, Grün, Blau und die Mischfarbe global erstellt werden müssen. fenster.title('farbmischer') r_hex='00' 21

22 g_hex='00' b_hex='00' farbe_mix='000000' Dann beginnt die Funktion für die rote Farbanzeige mit der globalen Deklaration. def farbanzeige_red(self): global r_hex Noch zeigt das Mischlabel aber keine Farben, Dazu muss dem Label permanent die korrekte Hintergrundfarbe übergeben werden. Am einfachsten erfolgt dies durch eine Funktion in der Funktion für die Farbe Rot. Die Funktion legt die Variable farbe_mix als global fest und erstellt den kompletten Hexadezimalwert aus den drei Farbwerten für Rot, Grün und Blau. Die print-anweisung dient wieder der Kontrolle und schließlich werden dem Label die Hintergrundfarbe und ein Text mit dem Hexadezimalwert übergeben. def farbanzeige_mix(): global farbe_mix farbe_mix='#'+r_hex+g_hex+b_hex print('mixfarbe '+'#'+r_hex+g_hex+b_hex) lbl_mix['bg']='#'+r_hex+g_hex+b_hex lbl_mix['text']='#'+r_hex+g_hex+b_hex farbanzeige_mix() Aufgabe 1. Gestalte den Farbmischer für alle drei Farben. 22

23 2.4. Zeichnen mit Python Canvas Natürlich lassen sich mit Python auch Elemente auf der Programmoberfläche zeichnen. Nötig ist dazu eine Zeichenfläche (Canvas). Zunächst sind die Standartelemente des Skripts zu erstellen. Die Zeichenfläche wird dann über z_flaeche=canvas(fenster, width=900, height=900) erstellt. Aufgabe: Erstelle ein Programmfenster mit einem Schließen-Button und einer Zeichenfläche in der Größe 900x Noch ein Nikolaus Auf der Zeichenfläche kann nun gezeichnet werden. Dabei wird ein Koordinatensystem genutzt. Der Nullpunkt liegt links oben, die Maximalwerte für x und y rechts unten. Linien werden über den folgenden Befehl kreiert: z_flaeche.create_line(0,0,900,900) Die ersten beiden ersten Parameter geben den x - und y Wert des Startpunktes, die beiden anderen den des Endpunktes an. Aufgabe: 1. Erstelle eine Linie, die diagonal von links oben nach rechts unten die Zeichenfläche durchteilt. 2. Zeichne das Haus des Nikolaus in der richtigen Reihenfolge. 3. Ergänze die Linien um die Argumente width= und fill= für Linienbreite und Linienfarbe. Nutze als Farbe die Farbnamen, also Blue, Red etc. 23

24 Farbwahl Der Nutzer kann auch selbst Farben wählen. Dazu dient die Funktion colorchooser in tkinter. Sie ruft ein Farbwahlfenster aus. Die Funktion colorchooser.askcolor() gibt einen Tupel zurück, der aus zwei Teilen besteht. Teil eins ist ein Tupel, der die drei RGB- Farbwerte enthält, der zweite Teil ist ein String, der den Hexadezimalwert enthält. Beispiel: print(colorchooser.askcolor()) ergibt also (( , 0.0, ), '#fb0006') Rot Green Blue Hex Dementsprechend kann man eine Variable mit dem Hex-Wert dieses Tupels füllen und damit die Farbe des Hauses festlegen: farbe=colorchooser.askcolor() z_flaeche.create_line(200,800,400,800,width=7, fill=farbe[1]) Die in eckige Klammern gibt an, dass der zweite Wert des Tupels, in dem ja mit Null beginnend gezählt wird, für die Farbangabe genutzt werden soll. Aufgabe: Gestalte das Haus so um, dass der Nutzer die Farbe selbst wählen kann Kreise und Kreisbögen Kreise und Kreisbögen sind ebenso möglich. Sie werden als Element innerhalb eines Quadrats angesehen. Das bedeutet, dass bei der Koordinatenangabe ein Quadrat angenommen wird, dessen Koordinaten angegeben werden und in dem dann der Kreisbogen bzw. der Kreis liegt. Dementsprechend werden in den Argumenten zunächst die x- und y-werte des Rechtecks angegeben, dann die Koordinaten der rechten unteren Ecke des Rechtecks, anschließend die Gradzahl, bei der negative oder positive Werte erlaubt sind, und der Stil, der das Aussehen des Kreisbogens festlegt. Für nebenstehendes Bild hieße dies: z_flaeche.create_arc(100,100,500,500,extent=359, style=arc,width=3) z_flaeche.create_rectangle(100,100,500,500,width=3) 24

25 Mögliche Stile der Kreisbögen sind ARC Kreisbogen CHORD Kreisbogen mit Sehne PIESLICE - Tortenstück Kreise und Kreisbögen mit den Stilen PIESLICE und CHORD können gefüllt und mit einer Linienfarbe versehen werden: z_flaeche.create_arc(100,100,500,500,extent=359, style=pieslice,width=3, outline='red',fill='blue') Hinweis Hier wird offensichtlich, was aufmerksamen Lesern bereits aufgefallen ist: Kreise mit 360 werden als 0 -Kreise interpretiert. Entweder man beschränkt sich auf 359 oder man zeichnet zwei Kreisbögen mit je 180 und demselben Mittelpunkt, einen in positive, einen in negative Richtung. Die Richtung wird über eine positive oder negative Gradzahl festgelegt Dreiecke Vierecke Polygone Im Prinzip sind dies für tkinter immer die gleichen Elemente, nur mit verschiedenen Argumenten. Für Rechtecke gibt es zwar den Sonderfall create_rectangle(x1,y1,x2,y2), der aber eigentlich nur der Erleichterung für Programmierer dient. Polygone werden über ihre Eckpunkte definiert. Also ein Dreieck: z_flaeche.create_polygon(50,50,300,50,300,300,\ fill='green', outline='red') Und ein Rechteck: z_flaeche.create_polygon(50,50,300,50,300,300,50,300,\ fill='green', outline='red') Und ein Fünfeck: z_flaeche.create_polygon(100,50,200,50,300,300,250,400,50,300,\ fill='green', outline='red') und so weiter Texte Texte lassen sich ebenso einbinden. Der erste Parameter gibt dabei die Position des umschließenden Rechtecks wieder. Dann folgt der Text, die Fülldfarbe und die Angaben zur Schrift, also Schriftart, Schriftgröße und Schriftstil. z_flaeche.create_text(300,200,text='kaa ist auch ein Python!',\ fill='red', font=('arial',30,'bold')) Schriftstile: bold fett italic - kursiv 25

26 underline unterstrichen overstrike durchgestrichen Aufgabe: Generiere ein Gesicht. Gib dem Gesicht einen Namen. (zeichnen_07.py) Bewegung Bewegung ist auch mit Python möglich. Über die Methode move(id,x,y) kann ein Objekt in jede beliebige Richtung bewegt werden. Die id wird dabei in der Reihenfolge festgelegt, in der die Zeichnungen erstellt werden, beginnend mit 1. z_flaeche.create_polygon(10,10,10,60,50,35) z_flaeche.create_polygon(30,80,30,120,40,85) for x in range (0,60): z_flaeche.move(1,5,0) z_flaeche.update() time.sleep(0.5) for x in range (0,60): z_flaeche.move(2,5,0) z_flaeche.update() time.sleep(0.5) In diesem Skript werden nach den hier weggelassenen Standardelementen, also Fenster und Ende- Button, zwei Polygone erstellt, die dann nacheinander von links nach rechts bewegt werden. Welches Polygon als erstes bewegt wird, hängt von der Reihenfolge im Quelltext ab. Der Befehl time.sleep(0.5) sorgt dafür, dass die Bewegung immer wieder unterbrochen wird, denn sonst wäre nur das Ergebnis des Programmverlaufs zu sehen. 26

27 Der springende Punkt. Etwas Anderes ist es, wenn der Benutzer eingreifen soll. Dafür werden sog. Events genutzt. Ein Event, also ein Ereignis, kann ein Mausklick sein oder ein Tastendruck. Eventtypen sind z. B.: Button ButtonRelease MouseWheel Enter KeyPress KeyRelease Leave Maustaste gedrückt Maustaste losgelassen Mausrad bewegt Mauscursor in sichtbarem Bereich des Objekts Tastendruck Taste losgelassen Maustaste wird aus dem Objekt herausgezogen Eine kleine Auswahl an Tastatur-Attribute der Eventtypen. keysym keysym_num BackSpac Control_ Delete Down End Escape Fl F Left Next Return Right space 32 Up Das Tastensymbol (keysym) ist ein String, die Tastensymbolnummer eine ganze Zahl. Tipp Das folgende Skript zeigt Tastensymbole und nummern der betätigten Tasten an: from tkinter import * def out(event): print(event.keysym, " \ t", event.keysym_num) window = Tk( ) window. bind_all("<any-keypress>", out) window.mainloop( ) (M. Weigend: Python GE-PACKT, S, 548) Events können modifiziert werden, z.b.: Modifizierer Erklärung Alt Alt-Taste gedrückt Any Generalisierung (Any-Key-Press = irgendeine Taste gedrückt) Double zwei Ereignisse kurz hintereinander Double-Button-3 = Doppelklick mit rechter Maustaste Triple drei Ereignisse kurz hintereinander Control Strg-Taste gedrückt Shift Umschalttaste gedrückt 27

28 Das Ereignis muss zunächst in einer Funktion mit dem Argument event erstellt werden. def springpunkt(event): if event.keysym == 'Up': z_flaeche.move(1,0,-5) elif event.keysym == 'Down': z_flaeche.move(1,0,5) elif event.keysym == 'Left': z_flaeche.move(1,-5,0) else: z_flaeche.move(1,5,0) Hier wird die Event-Funktion erstellt und dann mit einer Abfolge von Bedingungen geprüft, welche Taste gedrückt wurde. Anschließend muss das Ereignis noch aufgerufen werden. Über die Methode bind_all werden die Ereignisse für alle Objekte der Applikation an den Eventhandler, also hier einen Tastendruck, gebunden. In der Klammer folgt der sog. Event-Pattern. Er ist folgendermaßen aufgebaut: <[Modifizierer-] Typ [-Qualifizierer]> Double-Keypress-Return In diesem Beispiel würde auf ein Doppeltes Drücken der Enter-Taste gewartet. Um den Punkt in Bewegung zu bringen, ergibt sich folgender Quelltext: z_flaeche.bind_all('<keypress-up>',springpunkt) z_flaeche.bind_all('<keypress-down>',springpunkt) z_flaeche.bind_all('<keypress-left>',springpunkt) z_flaeche.bind_all('<keypress-right>',springpunkt) Am Ende der Bindung wird die Funktion aufgerufen, die bei Eintreten des Ereignisses erfolgen soll. Aufgaben 1. Erstelle das Programm mit dem springenden Punkt. 2. Integriere für ein weiteres Objekt eine Steuerung mit Buchstabentasten. 28

29 3. Ein Spiel 3.1. Basics Nun soll ein ganz einfaches Spiel erzeugt werden, dass einen Ball auf einer Fläche hüpfen lässt. Hierfür sind einige Vorarbeiten nötig Leinwand Zunächst wird die Leinwand erzeugt. Dabei werden neben Tkinter die Module time und random importiert, die im Verlauf des Spiels noch gebraucht werden. Zusätzlich erhält das Fenster Festlegungen zur Gestaltung des Rands. from tkinter import * import random import time fenster=tk() fenster.title('pingpong') fenster.resizable(0,0) #Fenster nicht veränderlich fenster.wm_attributes('-topmost',1) #Fenster immer ganz vorn z_flaeche=canvas(fenster,width=500,height=400, \ bd=0,highlightthickness=0) #Zeichenfläche ohne Rahmen z_flaeche.pack() fenster.update() Der Ball Der Ball wird zunächst als Klasse erstellt. Über class Klassenname wird ein Name vergeben, dann folgt der Inhalt der Klassen. In einer Klasse werden Methoden definiert, die ein Objekt dieser Klasse haben kann. Diese Definition erfolgt in Form von Funktionen innerhalb der Klasse. class Spielball: #Die Klasse für den Spielball def init (self,z_flaeche,color): #Initialisierung mit #den dazugehörigen Parametern des Balls self.z_flaeche=z_flaeche self.ball_id=z_flaeche.create_oval(10,10,25,25,fill=color) #Id des gezeichneten Objekts erfassen self.z_flaeche.move(self.ball_id,245,100) #Objekt mit Hilfe der ID bewegen def bewegen(self): pass #leeres Schlüsselwort, #Platzhalter für spätere Eingaben 29

30 Achtung Die init-anweisung hat je zwei Unterstriche vor und nach init. Damit das Programm startet, also den Ball zeigt und sich immer wieder aktualisiert, wird eine sog. Hauptschleife eingefügt. Sie kontrolliert das Programm. while 1: fenster.update_idletasks() # Alle anstehenden Events abarbeiten fenster.update() time.sleep(0.01) #Bildaufbau für 1 hundertstel Sekunde pausieren lassen 3.2. Bewegung für den Ball Einfache Bewegung Um den Ball zu bewegen wird zunächst die bisher leere Methode bewegen mit Inhalt gefüllt: def bewegen(self): self.z_flaeche.move(self.ball_id,0,-1) #den Ball nach oben schweben lassen. Damit diese Bewegung auch ausgeführt wird, muss das Objekt mit dieser Methode aufgerufen werden. Dazu wird die Hauptschleife entsprechend ergänzt: while 1: ball.bewegen() #Schweben starten fenster.update_idletasks() # Alle anstehenden Events abarbeiten fenster.update() time.sleep(0.01) #Bildaufbau für 1 hundertstel Sekunde pausieren lassen 30

31 Hin und wieder zurück Damit der Ball die Fläche nicht verlässt, müssen die x und y - Position des Balls ausgelesen und die Größe der Leinwand erfasst werden, um dann zu erfassen, ob sich der Ball noch innerhalb des Spielfeldes bewegt. Der Klasse Spielball werden deshalb für diese drei Werte drei Variablen hinzugefügt. self.x=0 self.y=-1 self.z_flaeche_height=self.z_flaeche.winfo_height() # Höhe der Fläche über winfo_height auslesen und #in eine Variable legen In die Bewegen-Methode werden nun Bedingungen eingefügt, die die Position des Balls erfassen. Außerdem wird die Positionierung des Balls auf die beiden o.g. Variablen umgestellt. def bewegen(self): self.z_flaeche.move(self.ball_id,self.x,self.y) #den Ball nach oben schweben lassen. pos=self.z_flaeche.coords(self.ball_id) #Ball-Position über coords erfassen, #gibt x und y - Wert als Liste mit 4 Werten zurück if pos[1]<=0.0: self.y=1 if pos[3]>= self.z_flaeche_height: self.y=-1 print(self.z_flaeche.coords(self.ball_id)) #Position des Balls in der Konsole anzeigen Die Print-Funktion an dieser Stelle dient der Kontrolle. Sie gibt in der Konsole die Werte aus, die mit der coords-funktion ausgelesen wurden Irgendwo hin Nun soll der Ball variabel werden. Dafür binden wir einen kleinen Zufall ein. Zunächst wird eine Variable erstellt, die sechs Werte in einer Liste enthält. Dann wird die Abfolge der Listenelemente durcheinandergewirbelt. Der x-wert des Balls erhält den ersten Wert in der starts-variablen. starts=[-3,-2,-1,1,2,3] # Variable starts enthält eine Liste random.shuffle(starts) #der Inhalt von starts wird gemischt self.x=starts[0] # x erhält den ersten Wert in der Liste, #die starts enthält self.y=--3 #Ball wird schneller Nun brauchen wir aber auch die Breite der Leinwand, also 31

32 self.z_flaeche_width=self.z_flaeche.winfo_width() Außerdem muss die bewegen-funktion um die Bedingungen für die Breite ergänzt werden. if pos[0]<=0: self.x=3 if pos[2] >= self.z_flaeche_width: self.x= Ein Prallbrett Nun muss der Ball im Spielfeld gehalten werden und wenn er unten auftrifft, soll der Spieler verlieren. Zunächst benötigen wir also ein Prallbrett, von dem der Ball abprallen kann. Es wird ebenso erstellt wie der Kreis, nur natürlich als rectangle. class prallbrett: def init (self,z_flaeche,color): self.z_flaeche=z_flaeche self.prall_id=z_flaeche.create_rectangle(0,0,100,10,fill=color) self.z_flaeche.move(self.prall_id,200,300) def bewegen(self): # keine Namenskollision, da einer andern #Klasse zugeordnet Pass #leerer Platzhalter Nun muss das Prallbrett als Objekt erstellt und in die Hauptschleife integriert werden: prallbr=prallbrett(z_flaeche,'blue') while 1: ball.bewegen() prallbr.bewegen() Jetzt sieht man das Brett Bewegung mit den Maustasten Über Tastaturereignisse wird nun das Prallbrett bewegt. Da sich das Brett nur innerhalb der Leinwand bewegen darf, muss auch die Leinwandbreite erfasst werden. Dieser Wert muss auch in dieser Klasse wieder erfasst werden, da eine Übergabe des Werts aus einer andern Klasse nicht möglich ist. class Prallbrett: def init (self,z_flaeche,color): self.z_flaeche=z_flaeche 32

33 self.prall_id=z_flaeche.create_rectangle(0,0,100,10,fill=color) self.z_flaeche.move(self.prall_id,200,300) self.x=0 self.z_flaeche_width=self.z_flaeche.winfo_width() self.z_flaeche.bind_all('<keypress-\ Left>',self.nach_links) self.z_flaeche.bind_all('<keypress-\ Right>',self.nach_rechts) def bewegen(self): # keine Namenskollision, da einer andern Klasse zugeordnet self.z_flaeche.move(self.prall_id,self.x,0) pos=self.z_flaeche.coords(self.prall_id) if pos[0]<=0: self.x=1 if pos[2]>= self.z_flaeche_width: self.x=0 def nach_links(self,event): self.x=-2 def nach_rechts(self,event): self.x=2 Die Methoden nach_links und nach_rechts werden die x-werte des Prallbretts verändern. Die Bewegung erfolgt analog der des Balls, aber nur in der x-achse. Die Y-Werte werden grundsätzlich auf null gesetzt. Nun sollten Ball und Prellbrett über die Fläche pendeln Treffer feststellen Damit das Prallbrett vom Ball erfasst wird, muss es als Parameter in die Initialisierung der Klasse Spielball geschrieben werden. Außerdem muss das Prallbrett als Objektvariable gespeichert werden. Die ersten Zeilen der Klasse Spielball sehen dann so aus: class Spielball: #Die Klasse für den Spielball def init (self,z_flaeche,prallbrett,color): #Initialisierung mit den dazugehörigen Parametern des Balls self.z_flaeche=z_flaeche self.prallbrett=prallbrett: Nun muss erfasst werden, ob denn der Ball das Brett getroffen hat. 33

34 Der Quellcode sieht so aus: def treffer(self,pos): # der Parameter pos macht die Variable #aus der bewegen-methode nutzbar prallbrett_pos=self.z_flaeche.coords(self.prallbrett.prall_id) if pos[2] >=prallbrett_pos[0] and pos[0] <= prallbrett_pos[2]: if pos[3] >= prallbrett_pos[1] and pos[3] <= prallbrett_pos[3]: return True return False Zunächst wird die Methode definiert. Der Parameter pos macht die Variable aus der bewegen- Methode hier nutzbar. Dann wird die Position des Prallbretts erfasst. Die If-Bedingung ist zunächst etwas verwirrend. Zur Erklärung: Der Ball hat vier Werte, die seine Position beschreiben pos[0] x-wert links oben pos[1] y-wert links oben pos[2] x-wert rechts unten pos[3] y-wert rechts unten Das Prallbrett hat diese vier Werte auch: prallbrett_pos[0] prallbrett_pos[1] prallbrett_pos[2] prallbrett_pos[3] x-wert links oben y-wert links oben x-wert rechts unten y-wert rechts unten 34

35 In der Bedingungsschleife wird zunächst der Vergleich der x-positionen vorgenommen. Dann wird der Vergleich der y-positionen vorgenommen, aber nur, wenn die Bedingungen der umschließenden Bedingung wahr sind. Dass hier Ober- und Unterseite des Balls und des Prallbretts mit and verkoppelt geprüft werden, liegt daran, dass bei der Bewegung in Dreierschritten, die das Programm vorsieht, das Prallbrett durchschritten sein könnte, bevor dies vom Programm bemerkt wird. Nun kann diese Methode in der bewegen Methode aufgerufen werden. Dies geschieht, nachdem die y-werte in der bewegen-methode geprüft wurden. Die Änderung der y-variablen i einen negativen Wert bewirkt, dass der Ball die Flugrichtung umdreht. def bewegen(self): self.z_flaeche.move(self.ball_id,self.x,self.y) #den Ball nach oben schweben lassen. pos=self.z_flaeche.coords(self.ball_id) #Ball-Position über coords erfassen, gibt x und y - Wert als Liste mit 4 Werten zurück if pos[1]<=0.0: 35

36 self.y=1 if pos[3]>= self.z_flaeche_height: self.y=-1 if self.treffer(pos) == True: self.y=-3 if pos[0]<=0: self.x=3 if pos[2] >= self.z_flaeche_width: self.x= Quelltext Hier der gesamte Quelltext ohne Kommentare: from tkinter import * import random import time class Spielball: def init (self,z_flaeche,prallbrett,color): self.z_flaeche=z_flaeche self.prallbrett=prallbrett self.ball_id=z_flaeche.create_oval(10,10,25,25,fill=color) self.z_flaeche.move(self.ball_id,245,100) starts=[-3,-2,-1,1,2,3] random.shuffle(starts) self.x=starts[0] self.y=--3 self.z_flaeche_height=self.z_flaeche.winfo_height() self.z_flaeche_width=self.z_flaeche.winfo_width() def bewegen(self): self.z_flaeche.move(self.ball_id,self.x,self.y) pos=self.z_flaeche.coords(self.ball_id) if pos[1]<=0.0: self.y=1 if pos[3]>= self.z_flaeche_height: self.y=-1 if self.treffer(pos) == True: self.y=-3 if pos[0]<=0: self.x=3 if pos[2] >= self.z_flaeche_width: self.x=-3 print(self.z_flaeche.coords(self.ball_id)) def treffer(self,pos): prallbrett_pos=self.z_flaeche.coords(self.prallbrett.prall_id) 36

37 if pos[2] >=prallbrett_pos[0] and pos[0] <= prallbrett_pos[2]: if pos[3] >= prallbrett_pos[1] and pos[3] <= prallbrett_pos[3]: return True return False class prallbrett: def init (self,z_flaeche,color): self.z_flaeche=z_flaeche self.prall_id=z_flaeche.create_rectangle(0,0,100,10,fill=color) self.z_flaeche.move(self.prall_id,200,300) self.x=0 self.z_flaeche_width=self.z_flaeche.winfo_width() self.z_flaeche.bind_all('<keypress- Left>',self.nach_links) self.z_flaeche.bind_all('<keypress- Right>',self.nach_rechts) def bewegen(self): self.z_flaeche.move(self.prall_id,self.x,0) pos=self.z_flaeche.coords(self.prall_id) if pos[0]<=0: self.x=1 if pos[2]>= self.z_flaeche_width: self.x=0 def nach_links(self,event): self.x=-4 def nach_rechts(self,event): self.x=4 fenster=tk() fenster.title('pingpong') fenster.resizable(0,0) fenster.wm_attributes('-topmost',1) z_flaeche=canvas(fenster,width=500,height=400, bd=0,highlightthickness=0) z_flaeche.pack() fenster.update() prallbrett=prallbrett(z_flaeche,'blue') ball=spielball(z_flaeche,prallbrett,'red') while 1: ball.bewegen() prallbrett.bewegen() fenster.update_idletasks() fenster.update() time.sleep(0.01) 37

38 6. Literatur J. Ernesti / P. Kaiser: Python 3. Das umfassende Handbuch. Galileo Computing, Bonn 2012, 3. Aufl. T. Theis: Einstieg in Python. Galileo Computing, Bonn 2014, 4. Aufl. M. Weigend: Python 3. Mitp, Heidelberg 2013, 5. Aufl. M. Weigend: Python GE-PACKT. Mitp, Heidelberg 2013, 5. Aufl. B. Klein: Einführung in Python. Hanser Verlag, München 2013 J. Briggs: Python kinderleicht. dpunkt.verlag, Heidelberg 2013 G. Lingl: Python für Kids. Bhv, Heidelberg, 2010, 4. Auflage W. u. C. Sande: Hello World. Hanser Verlag, München