In diesem Bereich wird Material bereitgestellt.

Codesnippets

Codesnippets

Einführungen

Peter Kaiser und Johannes Ernesti: Python. Das umfassende Handbuch - Aktuell zu Python 2.5. 2008. (OpenBook) ISBN 3-8362-1110-9
Gut geschriebene Einführung mit sehr guten Erläuterungen. Dank einer klaren Strukturierung behält man immer den Überblick!

C.H.Swaroop A Byte of Python
Deutsche Übersetzung des Einführungskurses

Python Kurs mit Einführung in Python und Tkinter Python Kurs

Bernd Klein: Allgemeine Einführung in Python plus weiterführende Themen Python-kurs.eu

Code einstellen

In der Wikiversity kann man Python-Code einstellen und dabei das Syntax-Highlighting verwenden (Info zur Erweiterung).

print "Hallo Welt!"

Um das Syntax-Highlighting zu nutzen, fügt man den Code zwischen <syntaxhighlight lang=python> und </syntaxhighlight> ein.

Programmablaufplan

Siehe in der Wikipedia unter Programmablaufplan.

Tastatureingaben

Mit dem Befehl raw_input() könnt ihr euch eine Eingabe geben lassen. Raw_input liefert eine Zeichenkette.

a = raw_input("Eingabeaufforderung: ")
print a

Turtle

Ein einfaches Turtle Programm - Achtung ab Python 2.6 ist turtle stark überarbeitet -> dann gehen auch Abkürzungen der befehle. Die Programme hier gehen alle auch mit Python 2.5

#!/usr/bin/python
from turtle import *

reset()
forward(10)
right(90)
forward(10)

done()

Turtle reagiert auf Clicks mit der eigenen funktion onscreenklick() und reagiert auf tasteneingaben mit onkey()

hier ein Beispiel, das alles vermischt

#!/usr/bin/python
from xturtle import *

reset()

def klick(x,y):
  print x,y
  print pos()
  forward( x - pos()[0] )
  left(90)
  forward( y - pos()[1] )
  left(-90)

def vor():
  forward(10)

def links():
  left(10)

listen()
onclick(klick)
onkey( vor, "Up")
onkey( links, "Left")

forward(100)
done()

ACHTUNG: Dieses Programm funktioniert nur in Python2.6 oder mit xturtle.

Das Spaghettimonster

Das malt ein zufälliges Spaghettimonster, noch ohne Augen

from turtle import *
import random 

reset()

speed("fastest")
tracer(False)
#pensize(10) #das geht erst ab python 2.6

def arm():
    up()    
    goto(0,0)
    down()
    for i in range(1,11):
        l = random.randint(20,50)
        w = random.randint(-45,45)
        #write(l)
        forward(l)
        left(w)
  
        #print "i: ", i , " l:", l, " w:", w



for i in range(1,100):
    arm()

tracer(True)
done()

Turtle ist einfach nur eine TKinter canvas

hier ein Beispiel, das alles vermischt ;-)

#!/usr/bin/python
# -*- coding: utf-8 -*-
from turtle import *
import turtle
from Tkinter import *

reset()
forward(10)
right(90)
forward(10)

c = turtle._canvas
root = turtle._root

c.create_line(0, 0, 200, 100)
c.create_line(0, 100, 200, 0, fill="red", dash=(4, 4))
c.create_rectangle(50, 25, 150, 75, fill="blue")
c.create_oval(0,150,150,300, fill="blue")

def click(): print "hi"
b = Button(root, text ="los", command = click)
b.pack()

def mouseMove(event):  print event.x, event.y
c.bind('<Motion>',mouseMove)

done() #fuer insider - ruft turtle._root.mainloop() auf

Turtle aus Python 2.6

In Python 2.6 ist das Turtlemodul stark verbessert wurden. Z.B. kann man die Liniendicke verändern.

ich habe das turtle Modul aus Python2.6 herausgeholt und hier als xturtle.py hochgeladen. Kopiert die xturtle.py einfach in das Verzeichnis, in dem auch euer Programm steht und beginnt es mit "from xturtle import *". Viel spass.

xturtle.py [1]

Mehr als eine Turtle

#!/usr/bin/python
# -*- coding: utf-8 -*-
from xturtle import *

t2 = Turtle()
t2.penup()
t2.forward(100)

backward(100)

done()

Frohe Weihnachten

Mal was zum Gehirnwindiungen entwirren. Das was hier ist etwas komplizierter und wenn ihr es verstanden habt seid Ihr auf dem "nächsten Level" der Erkentniss ;-).

Die Schneeflocke besteht aus 3 Koch-Kurven, die hier beschrieben sind http://de.wikipedia.org/wiki/Koch-Kurve. Hier (http://en.wikipedia.org/wiki/Koch_snowflake) gibts noch mehr Bilder.

from turtle import *
 
#speed("fastest")
kuerzeste_kante = 5.0  #Probier hier mal 100.0 aus


#die eigentliche rekursive Funktion
def strich( l ):
    
    #sind die striche noch so lang das sich rekursion lohnt?
    if l >= kuerzeste_kante:
        #neue strichlaenge berechnen
        l2 = l / 3.0 
        
        strich(l2)    # Hier malen wir anstelle einer l langen Linie 
        left(60)      # die zickzacklinie aus 4 Strichen der jeweiligen
        strich(l2)    # Länge l2 = l /3
        right(120)    #
        strich(l2)    #
        left(60)      #      /\
        strich(l2)    # ____/ \____
        
    else:
        forward(l) #rekursion lohnt nicht, wir malen einfach eine linie


#nach oben rechts gehen
up()
goto(-250,200)
down()


# ein dreieck aus dem magischen strich() malen:
strich(500.0)    #
right(120)       #    -----
strich(500.0)    #    \   /
right(120)       #     \ /
strich(500.0)    #      .

done()

Tkinter

Tkinter ist eine Bibliothek um grafische Benutzeroberflächen zu programmieren.

Button - Widget

Buttons brauchen einen Text, und eine Funktion, die aufgerufen werden soll - hier ist es click_1().

#!/usr/bin/python
from Tkinter import *

def click_1():
    print "click_1"

master = Tk()

b = Button(master, text ="los", command = click_1)
b.pack()

mainloop()

Canvas - Widget

Auf eine Canvas könnt ihr frei zeichnen. Die Canvas kann Linien, Kreise, Bitmaps zeichen.

#!/usr/bin/python
from Tkinter import *

master = Tk()

c = Canvas(master, width=500, height=500)
c.pack()

c.create_line(0, 0, 200, 100)
c.create_line(0, 100, 200, 0, fill="red", dash=(4, 4))
c.create_rectangle(50, 25, 150, 75, fill="blue")
c.create_oval(0,150,150,300, fill="blue")

mainloop()

Alle "Elemente" (Linien, Rechtecke, Ovale, ..) könnt ihr einzeln auf der Canvas verändern. Die ceate...()-Methoden geben eine "Element-Nummer" (Handle, type int) zurück. Der move()-Methode wird einfach die Nummer des Elementes mitgegeben, das bewegt werden soll.

#!/usr/bin/python
from Tkinter import *

master = Tk()

c = Canvas(master, width=500, height=500)
c.pack()

o1= c.create_oval(0,0,10,10, fill="blue")
o2 = c.create_oval(0,0,10,10, fill="red")

c.move(o1,10,10)
c.coords(o2,50,10,60,20)

mainloop()

Aufgabe1: Lasse das move() und coords() nur ausführen, wenn ein Button gedrückt wird. Aufgabe2: Schreibe ein Programm mit 4 Buttons, dass den Blauen Kreis beliebig über die Canvas laufen lässt.

ach ja mit c.delete( i ) könnt ihr das Element i von der Canvas c entfernen.

After() - Etwas warten

Jedes Widget hat einen Kurzzeitwecker - after(), der funktioniert ähnlich wie ein Button - wenn er losgeht ruft er eine Funktion auf.

#!/usr/bin/python
from Tkinter import *

def ani():
    c.move(o1,10,10)

master = Tk()

c = Canvas(master, width=500, height=500)
c.pack()

o1= c.create_oval(0,0,10,10, fill="blue")

#nach 10 Sekunden "klingelt" der Wecker von c und ruft die Funktion ani auf
c.after(10000, ani)

mainloop()

Aufgabe: lass die blauen Punkt weiter laufen

Events

Tkinter basiert auf Events - ein klick auf ein widget löst ein Event in dem Widget aus. Ihr könnt sagen, welche Funktion bei einem Event aufgerufen werden soll.

#!/usr/bin/python
from Tkinter import *

def click_1( event ):
    c.create_oval(event.x-5, event.y-5, event.x+5, event.y+5)
    print "click_1"
    
master = Tk()

c = Canvas(master, width=500, height=500)
c.pack()

c.bind ( "<Button-1>", click_1 )

mainloop()

Aufgabe: Mache grüne Kreise mit der rechen Maustaste.
Aufagbe2: Mache einen oder mehrere Farbwählbuttons an den Rand.

Maus-Bewegung - Motion Events

#!/usr/bin/python
from Tkinter import *

root = Tk()

def mouseMove(event):
        print event.x, event.y

root.bind('<Motion>',mouseMove)
root.mainloop()

Was erfährt die Callback Funktion vom Event

Dieses kleine Programm gibt den gesamten Inhalt des "event"-Objektes aus, das die Callback-Funktion übermittelt bekommt. Ersetzt die Eventbeschreibung 'a' durch euer lieblings Event.

#!/usr/bin/python
from Tkinter import *

root = Tk()

def callback(event):
        print event.__doc__
        print vars(event)

root.bind('a',callback) # hier 'a' durch euer event ersetzen
root.mainloop()

Welche Events kann man binden?

Sicher wollt ihr wissen, welche Events man binden kann. Hier eine kleine Tabelle.

Event-Beschreibung	Bedeutung
'a' 'b' .. 'z'	Die Buchstabentasten a-z
'<Return>'	Enter Taste
'<Cancel>'	ESC-Taste
'<BackSpace>'	Rück-Taste
'<Tab>'	TAB-Taste
'<Shift_L>'	Irgendeine Shift-Taste
'<Control_L>'	Irgendeine STRG-Taste
'<Alt_L>'	Irgendeine Alt-Taste
'<Pause>'
'<Caps_Lock>'
'<Escape>'
'<Prior>'	Bild Hoch
'<Next>'	Bild Runter
'<End>'
'<Home>'
'<Left>'
'<Up>'
'<Right>'
'<Down>'
'<Print>'
'<Insert>'
'<Delete>'
'<F1>' .. '<F12>'
'<Num_Lock>'
'<Scroll_Lock>'
'<Key>'	irgendeine Taste
'<Motion>'	Maus Bewegung
'<Button-1>'	Maus Taste Links
'<Button-2>'	Maus Taste Mitte
'<Button-3>'	Maus Taste Rechts
'<B1-Motion>'	Maus bewegt sich während Button-1 gedrückt
'<Enter>' '<Leave>'	Maus geht bzw. verlässt das aktuelle Widget

Canvas.move() und Canvas.find_overlapping()

Das Programm macht schon mehr - schaue es dir genau an und versuche es zu verstehen, lass es auch laufen und sieh dir die Ausgaben (print) an. Neu ist hier Canvas.find_overlapping() und Canvas.move().

#!/usr/bin/python
# -*- coding: utf-8 -*-

from Tkinter import *
import random

def click( event ):
    print 
    
    x = event.x
    y = event.y
    print "Click auf", x, y
    item_liste = c.find_overlapping(x-4, y-4, x+4,y+4) #suche im 9x9-Rechteck um x,y nach items ACHTUNG, man muss eine linie treffen, das innere des kreises zaehlt nicht
    
    print "habe die items", item_liste, "gefunden"
    
    if item_liste == () : # wir haben wohl nichts gefunden -> dann machen wir halt ein neues
       print "mache neuen kreis"
       c.create_oval(x-5, y-5, x+5, y+5)
       return
    
    item = item_liste[0]
    dx = random.randint(-50,50)
    dy = random.randint(-50,50)
    print "verschiebe item", item, "um", dx, dy
    c.move( item , dx , dy ) 
    


master = Tk()
c = Canvas(master, width=500, height=500)
c.pack()
c.bind ( "<Button-1>", click)
mainloop()

Aufgabe: Lasse die Punkte rot werden beim anklicken.

Checkbutton und Radiobutton

#!/usr/bin/python
from Tkinter import *

master = Tk()

def callback():
    print master.winfo_x(), master.winfo_y()
    
    # var auslesen
    normale_var = var.get()
    print "normale_var: ", normale_var
    
    #var2 auslesen
    normale_var2 = var2.get()
    print "normale_var2: ", normale_var2


#######################
# Checkbutton
var = IntVar()
c = Checkbutton(master, text="DEIN TEXT HIER", variable=var)
c.pack()


############################
# BUTTON
b = Button(master, text="OK", command=callback)
b.pack()


#######################
# Radiobutton
var2 = IntVar()
r1=Radiobutton(master, text="One", variable=var2, value=1)
r1.pack()
r2=Radiobutton(master, text="Two", variable=var2, value=2)
r2.pack()


mainloop()

MySQL

Habe mal MYSQL auf den server installiert, Clemans hatte die geniale Idee auch phpMyAdmin zu installieren - damit kann man die wichtigsten administrationsaufgaben machen.

pypMyAdmin

Damit kan man den SQl server adminisrieren, phpMyAdmin ist in Php geschreiben - administriert aber jeden SQL server http://192.168.0.101/phpmyadmin/index.php

nutzername: root pwd: muss man halt wissen