aa_PythonInfos

Python
Seite 1
Graf-Zeppelin-Gymnasium
Python: Zusammenfassung, Literatur
Inhaltsverzeichnis
Grundlegenden Datenstrukturen - Variablen ...........................................................................................................3
Umwandlung von Datentypen ...............................................................................................................................3
Integer ........................................................................................................................................................................3
Floats, d.h. Dezimalzahlen ......................................................................................................................................3
Decimals , beliebig, aber fest eingestellte hoch Genauigkeit .............................................................................3
Strings ........................................................................................................................................................................4
Formate für Zahlen in Strings (%-Formatierung) ...............................................................................................4
Umwandlungen von Datentypen ...........................................................................................................................5
Types ..........................................................................................................................................................................5
Sequenzen – Listen, Tupels (Arrays), ... ....................................................................................................................5
Listen ..........................................................................................................................................................................5
Tupel ..........................................................................................................................................................................6
Dictionary ..................................................................................................................................................................7
Programmstrukturen ....................................................................................................................................................8
Schleifen ....................................................................................................................................................................8
Bedingungen .............................................................................................................................................................8
Ausgabe .....................................................................................................................................................................8
Eingabe ......................................................................................................................................................................8
Funktionen ................................................................................................................................................................9
Files und I/O ............................................................................................................................................................9
Exceptions, Fehlerabfang .................................................................................................................................... 10
CAS – Rechnen mit Buchstaben......................................................................................................................... 10
Objekte in Python...................................................................................................................................................... 10
Besondere Funktionen .............................................................................................................................................. 11
Libraries....................................................................................................................................................................... 12
Import von Libraries ............................................................................................................................................ 12
Datum und Zeit ................................................................................................................................................ 12
Rechenzeit bestimmen ..................................................................................................................................... 12
NumPy Package .................................................................................................................................................... 12
PyLab Package ....................................................................................................................................................... 13
SciPy Package......................................................................................................................................................... 14
MatPlotLib Package .............................................................................................................................................. 14
Graphen von Funktionen zeichnen ............................................................................................................... 14
Turtle Grafik .......................................................................................................................................................... 17
Turtle Fenstereinstellungen ............................................................................................................................. 17
Turtle Einstellungen ......................................................................................................................................... 17
Turtle Bewegungen........................................................................................................................................... 17
Grafik Pygame ....................................................................................................................................................... 18
Fenster, Grafik .................................................................................................................................................. 18
Einfache grafische Objekte ............................................................................................................................. 18
Sprites – Kollisonserkennung ......................................................................................................................... 19
Ereignisse - events ............................................................................................................................................ 19
Zeit messen, Timer ........................................................................................................................................... 19
Weitere Grafik ....................................................................................................................................................... 20
Graphic, GUI .................................................................................................................................................... 20
Python-Installationen, IDEs .................................................................................................................................... 21
Pythonshell ............................................................................................................................................................. 21
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 1
Python
Seite 2
Graf-Zeppelin-Gymnasium
Pyscripter ................................................................................................................................................................ 21
EcPy, Eclipse mit Pydev ...................................................................................................................................... 21
Starten von Ecpy .............................................................................................................................................. 22
Hilfe Eclipse ...................................................................................................................................................... 22
Packages EcPy Python Portable 2.7.3.1 ........................................................................................................ 23
Python-Programme in exe-Files verwandeln .................................................................................................... 24
Pydev ........................................................................................................................................................................... 25
Geschichte, Hintergrundinfos ................................................................................................................................. 25
Literatur, Linksammlungen ...................................................................................................................................... 26
Lehrmaterialien zu Python ................................................................................................................................... 26
Python offizielle Dokus, Tutorials ...................................................................................................................... 28
Python Libraries, Beispiele, Einführungen....................................................................................................... 29
Jython – Python für Java ...................................................................................................................................... 30
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 2
Python
Seite 3
Graf-Zeppelin-Gymnasium
Grundlegenden Datenstrukturen - Variablen
i=1
Ganzzahl
Float
f=0.1
Gleitkommazahl
String
s="Hallo"
Zeichenkette
Liste
l=[1, 2, 3]
Veränderbare Liste mit Reihenfolge
Tupel
t=(1, 2, 3)
Unveränderbare Liste mit Reihenfolge
Integer
Dictionary d={1: "eins", 2: "zwei", 3: "drei"} Assoziatives Array
Umwandlung von Datentypen
int(2.33) liefert 2
float(3) liefert 3.0
str(53) liefert die Zahl 53 als Zeichenkette
Integer
Python rechnet automatisch mit beliebig großen Integerzahlen.
Wenn man Int-Zahlen dividiert, wird nach dem Komma abgeschnitten. Will man dies nicht, muss man sie
zuvor in eine float-Zahl verwandeln: float(i)/3
Den Rest bei der Division erhält man mit r=a%b
produkt=a*b
division=b/a
rest=b%a
Floats, d.h. Dezimalzahlen
Normale Dezimalzahlen (float) sind im wissenschaftlichen Zahlenformat abgespeichert. Sie bestehen also
aus einer Mantisse (die Nachkommastellen) mit 17 Stellen und einem Exponenten.
Alle Zahlen, die einen Punkt enthalten, werden als floats abgespeichert.
d=17. oder e=2.34
div2=round(div,2) # auf 2 Nachkommastellen runden
float(34) # erzeugt die Dezimalzahl 34.
Decimals , beliebig, aber fest eingestellte hoch Genauigkeit
Wenn man Dezimalzahlen mit mehr als 17 Nachkommastellen benötigt, geht man wie folgt vor.
Allerdings erfordert dies eine hohe Rechenleistung, die Programme werden langsamer wenn man nicht mit
Floats rechnet.
from decimal import * # Import der Bibliotheken
getcontext().prec = 60 # Einstellen der Rechengenauigkeit 60
Stellen
# Eingabe:
z1=Decimal(3)
# mit ganzen Zahlen
z2=Decimal(5)/Decimal(7)
# mit Brüchen
z3=Decimal(str(12.45))
# Dezimalzahlen
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 3
Python
Seite 4
Graf-Zeppelin-Gymnasium
z4=Decimal((0, (3, 1, 4, 1, 5), -4))
print z1, "/", z2, "/", z3, "/", z4
Strings
Die Tastatur liefert Strings, also Zeichenketten, die im PC im ASCII oder UTF8-Format gespeichert
werden, das Drücken der Return-Taste beendet die Eingabe eines String.
Strings sind unveränderbar, werden prinzipiell gleich wie listen behandelt. Allerdings kann man an ihnen
keine Veränderungen vornehmen
Str=“Test“
Str[2] # hier s, Zählung beginnt bei 0
Str[-1] # letzter Buchstabe t
Str[0:3] # = Tes
len(Str)
# Länge des Strings
Unicode String
Uni=u”Hello\u0020World” # \u0020 ist das Leerzeichen
Soll der String auf der nächsten Eingabezeile weitergehen,
schreibe am Ende der Zeile \
Eine neue Zeile in einem String erzeugt man mit \n, ein “-Zeichne
mit \“ oder \’
Funktionen für Strings:
import string
string.join()
liste = string.split(str) # in eine Liste von Worten auftrennen
liste = string.splitlines(str) # in eine Liste von Zeilen trennen
string.join(list)
print("My name is %s and weight is %d kg!" %('Zara', 21))
Triple-quoted Strings “““: Der String kann über mehrere Zeilen
gehen, darf End-Of-Line-Zeichen enthalten, also \n, man benötigt
keine \ am Ende der Zeile
Formate für Zahlen in Strings (%-Formatierung)
Soll eine Zahl in einem bestimmten Format ausgegeben werden, so schreibt man an der Stelle im String,
an der die Zahl angezeigt werden soll, ein %-Zeichen gefolgt von einem der unten angegebenen Formate.
Nach dem String kommt dann ein %() und in der Klammer steht die Zahl, die formatiert ausgegeben wird,
siehe Beispiele unten nach der Tabelle.
%s
String
%d
als ganze Zahl int
%0xd
ganze Zahl mit x stellen, Nullen davor
%x.yf
Dezimalzahl mit x Stellen insg. / y Stellen nach dem Komma
%f
Dezimalzahl mit 6 Stellen nach dem Komma
%e
Wissenschaftliches Zahlenformat mit e
%E
Wissenschaftliches Zahlenformat mit E
%g
Zahl passend wie beim GTR (e für Exponent)
%G
Zahl passend wie beim GTR (E für Exponent)
%xz
%-xz
75886473
Format z mit z Stellen, rechts aufgefüllt
Format z mit z Stellen, links aufgefüllt
W.Seyboldt (Stand: 3.3.14)
Seite 4
Python
Seite 5
Graf-Zeppelin-Gymnasium
%.yz
Format z with y Nachkommastellen
%x.yz
Format z with y Nachkommstellen der Breite x
%%
the percentage sign (%) itself
Beispiele
print “Der Geldbetrag ist %6.2f” %(geld)
print Zur Zeit t=%f s hat ein Ball die Anfangsgeschwindigkeit
v0=%.3E m/s und befindet sich in der Höhe %.2f m.
% (t, v0, y)
Umwandlungen von Datentypen
text= str(x) # x wird als String abgespeichert. 34 wird also mit
Hilfe der beiden Zeichen 3 und 4 abgepseichert.
n = int(x) # x wird zu einem int
z = float(x) # x wird als float abgespeichert.
Types
Den Type einer Variable kann man abfragen
print type(z), z
Man kann ihn umwandeln, was oft nötig ist.
n=45
z=float(n)
eingabe=raw_input("Test") # Die Eingabe liefert einen String aus
Zeichen, keine Zahl
z2=float(eingabe)
print z, "/", z2
Sequenzen – Listen, Tupels (Arrays), ...
Als Sequenzen werden Tupel (1, 2, 3) und Listen [1, 2, 3] bezeichnet. Im Gegensatz zu Dictionaries sind
Sequenzen geordnet, d.h. jedes Element hat eine eindeutige Position, ab Position 0 (Null) für das erste
Element der Liste, -1 kann für das letzte Element.gesetzt werden, z.B. (3, 4, 5)[0] liefert 3, (3, 4, 5)[-1]
liefert 5
Listen
Listen erzeugen
L = [1,5,8]
L = [1,7,“sieben“,[9,4]]
L = [9]*7 # Liste aus 7 mal dem Element 9
L=[]
# leere Liste
L = range(2,5) #=[2,3,4]
L = range(2,9,3) #=[2,5,8]
L = [x * 3 for x in range(4)]
L = [x * x for x in range(10) if x*x>25] # Quadratzahlen > 25
L1 = L[:]
# eine neue Liste wird erzeugt
L2 = [x for x in L] # zweite Art eine neue Liste zu erzeugen.
Auf Elemente zugreifen, Listen verändern
e = L[2]
# Das Element Nr.2, d.h. das dritte Element
e = L[-1]
# Das letzte Element L1=[10,“20“,“Da ist“,[1,2]]
L1[4]= “Neu“
# Ändert den Wert des fünften Elements
L2 = L
# L2 ist nun dieselbe Liste wie L
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 5
Python
Seite 6
Graf-Zeppelin-Gymnasium
Slicing von Listen:
L1 = L[:4]
# Slicing, Teillisten, bis unter Nr. 4
L1 = L[2:4]
# von Nr. 2 bis vor Nr. 4
L1 = L[-4:-2]
# vom viertletzten bis vor das zweitletzen
L1 = L[-4:]
# vom viertletzten bis zum Ende
L1 = L[3:-2]
# Von nr 3 bis zum vor das zweitletzte
L1 = L[3:10:2] # ab Elementindex 3 bis unter 10 jedes 2.
L1 = L[3::2]
# ab Elementindex 3 bis zum Ende jedes 2.
L1 = L[3::-1]
# ab Elementindex 3 bis zum Anfang jedes
# ein negativer Index dreht die Reiehenfolge um
L1 = L[::-1]
# liste wird umgedreht (wie liste.reversed())
L1 = L[1:]
# Alle Elemente ab 1
L1 = L[:]
# eine neue Liste wird erzeugt
L1 = L[4:7]= [4,6,8]
# ersetze eine Teilliste
Operatoren für Listen
L1+L2
# Verkettung von Listen
L.append(4)
# Liste mit Element verlängern
L.extend([7,8,[3,5]]) # Liste mit Liste verlängern
L.insert(2,‘neu‘)
# einfügen auf Pos 2
L.remove(“Neu“)
# Entferne das Element „Neu“
L.reverse()
# Kehrt die Reihenfolge um
L.sort()
# sortiert die Liste
L.pop(i)
# entfernt das i-te Elemente
Anz=L.count(3)
# zählt wie oft das Lement 3 vorkommt
Bool= (x in L)
# überprüft, ob x in der Liste vorkommt.
del L[n]
# Entferne das Element mit der Nr. n
L1=sorted(L)
# gibt eine neue sortierte Liste
S = sum(L)
# Summe der ´Liste
M=max(L)
# Maximum entspr. Minimum
laenge=len(L3)
# Länge der Liste
cmp(list1, list2)
Kopieren siehe http://henry.precheur.org/python/copy_list
L6 = L2[:] # eine neue Liste wird erzeugt
L6 = list(L2)
L2 = [x for x in L]
import copy
newobj = copy.copy(oldobj)
newobj = copy.deepcopy(oldobj)
# shallow copy
# deep (recursive) copy
gleiche Objekte liefern dieselbe id, verschiedene nicht
Abfrage mit id(list)
L.sort()
l.sort(reverse=True)
Tupel
Ähnlich zu Listen, aber nicht veränderbar
tuple = 'a', 'b', 'c', 'd', 'e' oder tuple = ('a', 'b', 'c', 'd',
'e')
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 6
Python
Seite 7
Graf-Zeppelin-Gymnasium
Nützlich sind gemeinsame Zuordnungen, etwa
a, b = 0, 1
a, b = b, a+b
Dictionary
Der Datentyp Dictionary (deutscher Begriff: assoziative Liste, nicht sehr gebräuchlich) ist den anderen
zusammengesetzten Datentypen ähnlich. Ein Unterschied besteht darin, dass man beliebige
unveränderbare Datentypen für die Indizes verwenden kann. Als Beispiel werden wir ein Dictionary
erzeugen um deutsche Wörter in englische Wörter zu übersetzen. Für dieses Dictionary sind die Indizes
strings.
dict={"eins":"one"}
dict["zwei"] = "two"
print(dict)
del (dict[“eins”])
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 7
Python
Seite 8
Graf-Zeppelin-Gymnasium
Programmstrukturen
Schleifen
for i in range(start, bisunter, schrittweite): # oder xrange
print i
while b>10:
b=b-1
for I in reversed(range(1,4)):
print i
# oder reversed(list):
for i,e in enumerate(mylist):
print i,e # i zeigt den Index und e zeigt das Element
break
continue
pass
#
#
#
#
beendet die Schleife
beendet die gerade aktuelle Iteration, beginnt also
den nächsten Schleifendurchlauf..
macht nichts
Bedingungen
if i>10:
print i
elif i>5:
print i
else:
print i
Ausgabe
print “Test“
Bem.: Ab python 3.0: print(“Test“)
siehe auch #Formate für Zahlen in Strings (%-Formatierung)
Eingabe
str = raw_input(„Beschreibung“)
str ist ein Ascii-String, der evtl umgewandelt werden muss, z.B.
i=int(str)
dezimal=float(str)
import easygui
easygui.msgbox(“..“)
easygui. enterbox(“..“)
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 8
Python
Seite 9
Graf-Zeppelin-Gymnasium
Funktionen
def name(ein1, ein2):
return erg
Default-Parameter siehe
Lambda-Funktionen siehe
Falls i gerade ist, ….
If (i%2)==0:
. . .
Addiere alle Elemente einer Liste li
sum=0
for i in li:
sum+=i
print sum
Zufallszahlen erzeugen
from random import *
random() # Zahl x mit 0<=x<1
Wurf=int(random()*6+1) # liefert die Würfelzahlen.
liste=[ int(random()*6+1 for i in range(100)] # 100 Würfe
Files und I/O
str = raw_input("Enter your input: ");
print("Received input is : ", str)
Mehrere Zeilen werden mit drei Anführungszeichen eingelesen
digits = """
73167176531330624919225119674426574742355349194934
71636269561882670428252483600823257530420752963450
"""
(Siehe strings01.py)
file object = open(file_name [, access_mode][, buffering])
try:
fh = open("testfile", "w")
(oder: fh = open("c:\\dir\\test.txt", "r"))
fh.write("This is my test file for exception handling!!")
except IOError:
print "Error: can\'t find file or read data"
else:
print "Written content in the file successfully"
# Open a file
fo = open("foo.txt", "wb")
fo.write( "Python is a great language.\nYeah its great!!\n");
fo = open("foo.txt", "r+")
# Close opened file
fo.close()
print f
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 9
Python
Seite 10
Graf-Zeppelin-Gymnasium
s=””
for line in f:
s+=line
for line in f:
print line.rstrip()
for line in f:
outf=output.write(line.rstrip()+’\n’
str = fo.read(10);
print "Read String is : ", str
Exceptions, Fehlerabfang
http://www.tutorialspoint.com/python/python_exceptions.htm
try:
Do you operations here;
......................
except ExceptionI:
If there is ExceptionI, then execute this block.
except ExceptionII:
If there is ExceptionII, then execute this block.
......................
else:
If there is no exception then execute this block.
CAS – Rechnen mit Buchstaben
from sympy import *
x = Symbol ('x')
y = Symbol('y')
z=(x+y)**2
print z.expand()
siehe Sympy Tutorial http://docs.sympy.org/0.7.1/tutorial.html#tutorial
und Sympy User Guide: http://docs.sympy.org/0.7.1/guide.html#guide
Objekte in Python
Eine Klasse ist eine Zusammenfassung von Variablen und Methoden, die eine logische Einheit bilden.
Man redet dann von Attributen und Methoden. Da die Klassenarchitektur möglichst an die reale Welt
angepasst sein sollte (was in der realen Welt zusammengehört, sollte auch innerhalb einer Klasse
modelliert werden) wird die Verständlichkeit des Codes gegenüber anderen Programmieransätzen wie z.B.
der prozeduralen Programmierung verbessert.
class Bruch(object):
def __init__(self, z=0, n=1):
"""Konstruktor"""
self.n = n
self.z = z
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 10
Python
Seite 11
Graf-Zeppelin-Gymnasium
self.kuerze()
return
def __str__(self):
"""Dient zur Anzeige"""
text="Bruch (%i / %i = " %(self.z, self.n)
return text
def kuerze(self):
self.euklid()
if (self.z*self.n >=0):
vz=1
else: vz=-1
...
return
Klassen enthalten keinen direkt ausführbarer Code. Man muss zuerst ein Objekt erzeugen.
b1=Bruch(216,66)
print b1
Jetzt ruft man die Methoden wie folgt auf:
b1.kuerze()
Die Adresse von b1 wird intern für self eingesetzt, d.h. b1.kuerze() = kuerze(adressseVonB1) Mit anderen
Worten: Bei jedem Objekt wird self ein anderer Wert sein, aber immer die Adresse, an der das Objekt
(Code und Daten) steht.
Besondere Funktionen
eval(str)
Will man Code, z.B. auszuwertende Funktionen, in einem über eine Eingabe eingeben, muss man den
eingegebene String normalerweise mit einem Parser bearbeiten und dann den damit erstellten Code zur
Ausführung bringen.
Die Methode eval() erleichtert dies sehr. Eval wertet einen eingegebene String als Befehl aus, führt ihn aus
und gibt das Ergebnis der Ausführung zurüück.
Die eval-Anweisung wird verwendet, um gültige Python-Ausdrücke auszuwerten, die in einem String
gespeichert sind. Unten sehen Sie wieder ein einfaches Beispiel.
exec(str)
Die exec-Anweisung wird benutzt, um Python-Anweisungen auszuführen, die in einem String oder in
einer Datei gespeichert sind. Zum Beispiel können wir zur Laufzeit einen String erzeugen, der PythonCode enthält, und diese Befehle dann mittels der exec-Anweisung ausführen. Unten sehen Sie ein
einfaches Beispiel hierfür.
eexecfile(filename)
compile(str)
siehe https://lucumr.pocoo.org/2011/2/1/exec-in-python/
Py2Exe
Erstellen von exe-Files unter Windows.
http://openbook.galileocomputing.de/python/python_kapitel_22_002.htm
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 11
Python
Seite 12
Graf-Zeppelin-Gymnasium
Libraries
Import von Libraries
import lib # Funktionen func können nun einfach mit lib.func() aufgerufen werden
import lib as l # … mit l.func()
from lib import * # aufruf mit func()
Datum und Zeit
import time
import datetime
localtime = time.localtime(time.time())
localtime = time.asctime( time.localtime(time.time()) )
siehe auch
http://docs.python.org/library/time.html
http://www.tutorialspoint.com/python/python_date_time.htm
http://pleac.sourceforge.net/pleac_python/datesandtimes.html
http://tutorial.pocoo.org/stdlib.html#datum-und-uhrzeit
Date and Time (einfacher Überblick):
http://www.tutorialspoint.com/python/python_date_time.htm
http://docs.python.org/library/datetime.html#module-datetime
http://pleac.sourceforge.net/pleac_python/datesandtimes.html
http://de.wikibooks.org/wiki/Python-Programmierung:_Time
Rechenzeit bestimmen
import time
tAnf = time.time()
# …
tEnd = time. time ()
print("Rechenzeit =", sEnd-tAnf, "s")
NumPy Package
http://www.python-kurs.eu/numpy.php
 random.uniform (low=0.0, high=1.0, size=None) # array von
gleichverteilten Zufallszahlen
 random.rand (d0, d1, ..., dn) # array von gleichverteilten
Zufallszahlen der angegebenen Dimension(en)
 arange ([start,] stop[, step]) # array gegebener Schrittweite
(ohne 'stop')
 linspace (start, stop, num[, endpoint=True ]) # array mit
linearen Abst• anden (ohne 'stop' wenn 'endpoint=False')
 sum (a [,axis=None]) # Summe über alle Werte eines array (oder
einer Achse, bei verwendung des axis parameter)
 mean (a [,axis=None]) # Mittelwert alle Werte eines array
(oder einer Achse, bei Verwendung des axis Parametera)
 histogram (a[, bins=10][, range=(down,up)][, normed=False]) #
erzeugt Histogram im gegeben Bereich
 histogram2d (x,y,[, bins=10][, normed=False])# erzeugt ein 2D
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 12
Python
Seite 13
Graf-Zeppelin-Gymnasium
Histogram der arrays.
#
a
x
r
m
Erzeugen
= array([1., 2., 5., 13., 21.]) # von einer Liste
= arange(0.,1.,0.2) # = array([ 0., 0.2, 0.4, 0.6, 0.8])
= random.rand(5,2) # von Zufallszahlen
= diag(ones(3)) # 3 x 3 Einheitsmatrix
# Auschschneiden
a[1:3] # im Breich = array([ 2., 5.])
x[:-2] # vom Ende = array([ 0., 0.2, 0.4])
13
r[:,0] # komplette erste Spalte
# Elementweise Operationen
b = a**2 # = array([ 1., 4., 25., 169., 441.])
y = sin(x) # = array([ 0., 0.199, 0.389, 0.565, 0.717])
# Dimensionsreduktion
w = mean(r,axis=0) # z.B. = array([ 0.52594254, 0.66878539])
# Matrixalgebra
A = array([ [ 1., 4.], [3., 0.] ]) # 2 x 2 dimensional
u = array([ [1.], [0.] ]) # Spaltenvektor
dot(A,u) # Matrix-multiplikation
Ainv = linalg.inv(A) # Inverse einer Matrix
dot(Ainv,A) # check: = diag(ones(2))
s,v=linalg.eig(A) # berechnet Eigenwerte und Vektoren
v1, v2 = v[:,0:1], v[:,1:2] # def. (Spalten-)Eigenvektoren
dot(A,v1) - s[0]*v1 # check: = array([[ 0.], [ 0.]])
vInv = linalg.inv(v) # Inverse der Transformationsmatrix
dot(vInv, dot(A, v)) # check: = diag(s)
PyLab Package
 plot(x,y,**kwargs)
#Zeichnen einer Funktion, z.B.
x = linspace(0.,2.*pi,100)
plot(x,sin(x))
 hist(r,bins,**kwargs)
# Zeichnet Histogramm des gegeben Ereignis-array,z.B.
hist(random.normal(size=100000),arange(-3.,3.,0.1))
 bar(left,heigt[, width=0.8,align='edge'])
# Zeichnet Bar-Plot, z.B. ein Histogramm erzeugt durch
histogram
r = random.normal(size=10000)
h,left = histogram(r,20,range=(-2.,2.),normed=True)
bar(left,h,width=left[1]-left[0])
 figure([num = None][, figsize=(8, 6)])
#Erzeugt ein neues Fenster (oder wechselt zur angegeben
Nummer)
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 13
Python
Seite 14
Graf-Zeppelin-Gymnasium
SciPy Package
Packages:
 cluster # Vector quantization / Kmeans
 fftpack # Discrete Fourier transform algorithms
 integrate # Integration routines
 interpolate # Interpolation tools
 io # Read write of vector/matrix files (also MatLab)
 lib # Lapack/Blas wrapper
 linalg # Linear algebra basics
 linsolve # Linear solvers
 maxentropy # Maximum entropy modelling tools
 misc # Various utilities that don't have another home
 ndimage # Multidimensional image processing
 odr # Orthogonal Distance Regression (ODR)
 optimize # General-purpose optimization routines
 sandbox # Tools that are not mature enough
 signal # Signal processing
 sparse # Rudimentary sparse matrix class
 special # Collection of mathematical functions
 stats # Statistical functions and tests
MatPlotLib Package
Graphen von Funktionen zeichnen
Siehe local: Plotten\easyviz.pdf im Internet: http://code.google.com/p/scitools/
Gallery mit Bildern und Code http://matplotlib.sourceforge.net/gallery.html
Doku von MathPlotlib http://matplotlib.sourceforge.net/
Beispiel für Graphen mit den wichtigsten Befehlen (siehe a_Plot01_zweiFktn.py und a_Plot02_Kreis.py)
import matplotlib.pylab as plt
# Man benötigt zwei gleich lange Listen von x- und y-Werten
x = # Liste der x-Werte
man kann sie z.B. mit np.arange(xstart, x,start, dx) erzeugen
oder mit np.linspace(a,b, anzahl) (hier ist a dabei!, ist sind
anzahl – 1 Teilintervalle.)
y = # Liste der y-Werte
man kann Funktionen von numpy aufrufen, die man auf Listen
anwenden kann.
oder [f(xi) for xi in x]
plt.plot(x, y) # Farben siehe
http://sage.math.canterbury.ac.nz/home/pub/47/cells/76/docs-0.html
plt.xlabel("x - Zeit in min")
plt.ylabel("Funktionswerte")
plt.legend(["Kurve f(x)=x**2*exp(-x**2)"])
plt.axis([0, 3, -0.05, 0.6]) # [tmin, tmax, ymin, ymax]
plt.title("Der Graph einer Funktion")
plt.show() # anzeigen und warten.
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 14
Python
Seite 15
Graf-Zeppelin-Gymnasium
savefig("tmp2.eps")
Beispiel für ein Stabdiagramm, ein box-Plot siehe (b_barPlot01.py und b_barPlot02.py )
Viele ist gleich wie oben, nur statt plt.plot wird plt.bar verwendet.
Im Beispiel wird allerdings noch mit eingeführt, dass man die Grafik in verschiedene Teile unterteilen
kann. Fig.ax= fig.add_subplot
import pylab as plt
#make a new figure
fig = plt.figure()
# make a new axis on that figure.
# Syntax: # number of rows of subplots, number of columns, and the
# which subplot.
ax = fig.add_subplot(1,1,1)
# Eingabe der Daten
x = [1,2,3,4,5]
y = [4.8,6,3,5.6, 7.3]
# Dicke und linke Position der Boxes
dicke=0.5
d2=dicke/2
xl = [i-d2 for i in x]
# add a bar plot to the axis, ax.
ax.bar(xl,y, width=dicke, facecolor="yellow", label="gelb")
ax.grid(True)
ax.set_xlim(0, 8) # wenn weggelassen, sucht er selbst
ax.set_ylim(0, 10)
ax.set_xlabel('x-Werte')
ax.set_ylabel('Anzahl')
ax.set_title('Beispiel eines Stabdiagramms')
ax.legend()
plt.show()
Beispiel für ein Histogramm. Wenn man eine Menge Daten hat, z.B. weil man 200 mal bei zwei Würfeln
die Augensumme bestimmt, kann man die Verteilung relativ einfach plotten (b_HistoPlot01.py )
Vieles ist gleich wie oben, nur statt plt.plot() bzw. plt.bar() die Methode plt.histo() verwendet.
import random as r
import matplotlib.pyplot as plt
# 200 mal die Augensumme bei zwei Würfeln bestimmen
ausum=[sum([r.randrange(1,7) for j in range(2)] ) for i in
range(200)]
dicke=0.85
d2=0.5
bins=[i+2-d2 for i in range(15)]
# bins sollte so sein, dass der Mittelwert im Bereich günstig
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 15
Python
Seite 16
Graf-Zeppelin-Gymnasium
liegt.
# die diche bestimmt dann die Breite des Streifens, der in der
Mitte des
# Intervalls gezeichnet wird.
print bins
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.grid(True)
plt.hist(ausum, bins, histtype='bar', rwidth=dicke, \
facecolor="yellow" ,alpha=0.5)
ax.set_xlim(0, 14)
ax.set_xlabel('Augensumme')
ax.set_ylabel('Anzahl')
ax.set_title('Bei zwei Wuerfeln die Augensumme bestimmen')
plt.show()
Alle Plotting Commands siehe http://matplotlib.sourceforge.net/ (dort über weitere Links beschrieben)
Beispiele von Commands
 axes Create a new axes
 axis Set or return the current axis limits
 bar make a bar chart
 colorbar add a colorbar to the current figure
 draw Force a redraw of the current figure
 errorbar make an errorbar graph
 figure create or change active figure
 ioff turn interaction mode off
 ion turn interaction mode on
 legend make an axes legend
 pie make a pie chart
 plot make a line plot
 polar make a polar plot on a PolarAxes
 show show the figures
 subplot make a subplot (numrows, numcols, axes-num)
 text add some text at location x,y to the current axes
 title add a title to the current axes
 xlabel add an xlabel to the current axes
 ylabel add a ylabel to the current axes
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 16
Python
Seite 17
Graf-Zeppelin-Gymnasium
Turtle Grafik
Die „Turtle“ ist eine programmierbare „Schildkröte“, die auf dem Boden hin- und herlaufen kann und,
falls der Zeichenstift abgesenkt ist, ihren zurückgelegten Weg aufzeichnet.
Der Ursprung ist in der Mitte des Grafikfensters
Lit: http://docs.python.org/library/turtle.html
oder http://wiki.zum.de/Turtle-Grafik
Turtle Fenstereinstellungen
clear() # Zeichenfläche löschen
done() # Wartet, bis der Benutzer das Grafikfenster schließt
tracer(x) # falls x=0=False wird ohne Verzögerung gezeichnet,
# falls x=1=True, mit Verzögerung
speed(“fastest“) # kürzeste Verzögerung beim Zeichnen,
# oder slowest, normal, slow, fast
Titel(text) # Fenstertitel
Setup(width=x, heigth=y, startx=x0, starty=y0) # Fenster
einstellen
Turtle Einstellungen
import turtle (oder from turtle import *)
reset() # Turtle aktivieren, in den Anfangszustand setzen
up() # hebe den Stift
down() # senke den Stift
color(“black“) # Stelle die Farbe ein, z.B. red
# oder #ffffff
width(t) # Strichdicke t Pixel
clear() # Zeichenfläche löschen
done() # Wartet, bis der Benutzer das Grafikfenster schließt
mainloop() # ebenso
Turtle Bewegungen
forward(x) # x Pixel vorwärts
backward(x) # x-Pixel zurück
left(y) # Biege y° nach links ab
right(y)
goto(x,y) # gehe zur Position (x,y)
circle(r) # zeichne einen Kreis mit Radius r
circle(r,y) # zeichne einen Kreisbogen mit Radius r und Winkel y
Sollen mehrere Turtle erscheinen, so kann man mit tur2=Pen() eine zweite erzeugen. Alle Eigenschaften
von ihr werden dann mit tur2.eig() angesprochen.
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 17
Python
Seite 18
Graf-Zeppelin-Gymnasium
Grafik Pygame
Pygame-Tutorial: http://pygametutorials.wikidot.com/book-event
Knappe Einführung: http://pygame.org/docs/tut/intro/intro.html
Werden die Module von Pygame verwendet, benötigt man immer folgende Zeilen Code.
import pygame
# erster Befehl im Hauptprogramm
pygame.init()
Fenster, Grafik
Ein Bildschirmfenster erstellen und anzeigen:
fenster=pygame.display.set_mode([1000,800]) # 1000 pixel in x- 800 in y-Richtung
weitere Funktionen http://pygametutorials.wikidot.com/book-display
Hintergrundfarbe
fenster.fill([r,g,b]) # f,g,b: Farbwerte zwischen 0 und 255
fenste.get_size()
fenster.get_width()
fenster.get_height()
groese=[xlen,ylen]
oberfl=pygame.Surface(groesse)
oberfl.fill(farbe)
bild=oberfl.convert() # aus Oberfläche ein Bild machen
Es gibt viele Funktionen, die auf fenster schreiben. Allerdings werden die Änderungen erst angezeigt,
wenn die Datenstrukturen aus dem Hauptspreicher auf die Grafikkarte geschrieben werden (Sande S. 187)
pygame.display.flip() # Erst jetzt werden Änderungen angezeigt
Einfache grafische Objekte
farbe=[100,150,255]
posObenLinks = [x,y]
dicke=0 # d.h. Die Liniendicke ist so dünn wie möglich
pygame.draw.circle(fenster, farbe, posObenLinks, r, dicke)
pygame.draw.rect(fenster, …) # siehe Sande S. 192
pygame.draw.lines(fenster …) # siehe Sande S. 197
pygame.set_at()
pygame.get_at()
bild=pygame.image.load(“file”) # eine Grafikdatei anzeigen
rect=bild.get_rect()
rect.left = anfangspos x
rect.top = anfangspos y
rect = rect.move(geschwindigkeit)
fenster.blit(bild, [x,y]) oder
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 18
Python
Seite 19
Graf-Zeppelin-Gymnasium
fenster.blit(bild, rect)
Etwas bewegen: Löschen / neuzeichnen / flip
Sprites – Kollisonserkennung
Sande s. 211 oder http://www.pygame.org/docs/tut/SpriteIntro.html
Eine Klasse von Objekten, die von pygame.sprite.Sprite abgeleitet ist. Jedes Sprite benötigt ein imageAttribut
Kollisionserkennung:
1. Schritt: Erzeuge Sprite-Objekte und verkette sie zu einer Gruppe
Gruppe=pygame.sprite.Group()
Gruppe.add(Sprite-objekte)
2. Schritt Kollisionserkennung
gruppe.remove(obj)
if pygame.sprite.spritecollide(obej, gruppe, False):
Vorsicht: Es wird nur eine Kollision der Rechteckumgebung des Bildes erkannt.
Ereignisse - events
for ev in pygame.event.get():
if ev.type==pygame.QUIT:
sys,exit()
elif ev.type==pygame.MOUSEDOWN:
# event.pos[0] ist x-pos
# event.pos[1] ist y-pos der Maus
Userevent:
pygame.time.set_timer(pygame.USEREVENT, zeit) # zeit in ms
for ev in pygame.event.get():
if event.type==pygame.USEREVENT:
…
Zeit messen, Timer
sprite.time.delay(zeit) # zeit ms warten
uhr.pygame.time.Clock()
uhr.tick(anz) # anz gibt an, wie oft die Uhr pro Min tickt.
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 19
Python
Seite 20
Graf-Zeppelin-Gymnasium
Weitere Grafik
Graphic, GUI
http://www.tutorialspoint.com/python/python_gui_programming.htm
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 20
Python
Seite 21
Graf-Zeppelin-Gymnasium
Python-Installationen, IDEs
Pythonshell
Wenn man mal schnell etwas rechnen will, ist die Shell ein nützliches Werkzeug. Dies gilt nicht mehr,
wenn man komplexere Dinge machen möchte. Dafür gibt es IDE‘s – Integrated Development
Environment‘s
Wir starten die Shell-Version von Python am GZG, indem wir nach P:\Freigabe gehen (z.B.
indem wir auf dem Desktop auf das Icon „Freigabe der Lehrer“ klicken und dann im Windows-Explorer
folgende Klicks durchführen:
Pstart >Informatik >“PythonShell 2.7.2“
Es öffnet sich schwarzes Fenster.
Gebe z.B. help() ein.
Beende die Python-Hilfe wieder mit strg/Z (oder Return)
PyShell auf dem Stick mit EcPy dem Ordner EcPy starten:
Klicke im Ordner EcPy\ Portable Python 2.7.2.1 auf Python-Portable.exe
Pyscripter
Wir starten Pyscripter am GZG, indem wir nach P:\Freigabe gehen (z.B. indem wir auf dem Desktop
auf das Icon „Freigabe der Lehrer“ klicken und dann im Windows-Explorer folgende Klicks durchführen:
>Pstart >Informatik >Python 2.7.2 mit Pyscripter 2.4
Die Oberfläche zeigt drei Fenster:
links: CodeExplorer (es gibt drei Reiter unten, d.h. es werden drei Inhalte angezeigt)
rechts: Das Bearbeitungsfenster (für verschiedene Dateien)
unten: den Python Interpreter (vgl. die 7 Reiter unten)
Unten, im Python Interpreter können wir normale Pythonbefehle eingeben, z.B. 34*56
Wenn der Cursor m Menu-Bereich ist, wählen wir nun >File >new >new Python module.
In die erste Zeile schreiben wir
# -*- coding: iso-8859-1 -*Den Rest löschen wir
Im Menu-Bereich wählen wir >File >save und speichern den Modul in h:\InfK1\pyprogs als prg00
Am Ende der Stunde kopieren wir dann den Ordner h:\InfK1 immer auf den Stick (oder nur die neuen
Programme in h:\InfK1\pyprogs)
Unsere Befehle (unsere Programme) schreiben wir künftig immer in das rechte Fenster
Das Programm wird ausgeführt, wenn man auf das grüne Dreieck klickt.
onlineDoku: http://www.portablepython.com/
siehe auch Wiki online
PyScripter auf dem Stick mit dem Ordner EcPy starten:
Klicke im Ordner EcPy\ Portable Python 2.7.2.1 auf PyScripter-Portable.exe
EcPy, Eclipse mit Pydev
EcPy muss auf dem Stick, zu hause auf C: oder in der Schule auf H: installiert sein, da man ansonsten
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 21
Python
Seite 22
Graf-Zeppelin-Gymnasium
nicht genügend Rechte hat. Insbesondere kann man die Version auf P:\Freigabe\Inforamtik\Ecpy nicht
starten, man kann sie aber auf den Stick kopieren und
Starten von Ecpy
Gehe nach X:\Ecpy und klicke dort auf StarteEcPy oder StarteEclipse. Benutze den
Workspace A:\Pyprogs
Da Pydev nicht vollständig portable ist, wurde die Umgebung EcPy eingerichtet. Sie besteht aus:

Eclipse Portable mit portable JavaRE, Unterordner EcPy\Portable Python 2.7.2.1

Portable Python 2.7.2.1, UnterordnerEcPy\Portable Python 2.7.2.1
 Der Workspace, der von Eclipse benutzt wird, ist Q:\EcPy\PyPrgs. Der Workspace hat bereits
Pydev mit Portable Python eingebunden.
Die Schülerprogramme sollten alle in Pakages unterhalb des Pydev-Projektes ProjA stehen. Die
Schülerprogramme (Pydev Modules) stehen alle unterhalb von ProjA\src\...
Außerdem gibt es dort ein Projekt ProjLoes, in dem Lösungsbeispiele stehen.
Bemerkung: Da Pydev nicht wirklich Portable ist, wurde Q: mit Subst dem Laufwerk X:\...\EcPy
zugeordnet.
Weitere Infos siehe Zus_EclipsePydev.doc
EcPy kann man aus dem Internet herunterladen und dann z.B. nach C:\entpacken (prinzipiell überallhin,
nur nicht auf ein Laufwerk Q – Es darf überhaupt kein Q benutzt sein, dies benötigt EcPy
Hilfe Eclipse



lokal: Allerlei\eclipse-ide.pdf
lokal: Allerlei\Python mit Eclipse.doc
lokal: Allerlei\pydev_eclipse-ide.pdf
Google App-Engine

Siehe http://www.vogella.de/articles/GoogleAppEngine/article.html
Hilfen: python3 statt python 2






75886473
http://diveintopython3.org/porting-code-to-python-3-with-2to3.html
Deutsch zu Version 3.1:
http://tutorial.pocoo.org/
http://www.ssw.uni-linz.ac.at/Teaching/Lectures/Sem/2000/Pammer/
http://python.net/~gherman/publications/tut-de/online/tut/ (von 1999)
Englisch 3.0: http://docs.python.org/dev/3.0/tutorial/
W.Seyboldt (Stand: 3.3.14)
Seite 22
Python
Seite 23
Graf-Zeppelin-Gymnasium
Packages EcPy Python Portable 2.7.3.1
Folgende Packages (oder Libraries) sind in EcPy Version 2.7.3.1 installiert (Stand: Juni2012)
siehe http://www.portablepython.com/wiki/PortablePython2.7.3.1














NumPy 1.6.1
Online: http://numpy.scipy.org/
SciPy 0.10.1
online http://www.scipy.org/
Mathplotlib 1.1.0 (siehe auch oben)
online: http://matplotlib.sourceforge.net/
PyWin32 216
Django 1.4
Pil 1.1.7
Py2Exe 0.6.9
wxPython 2.9.3.1
NetworkX 1.6
Lxml 2.3.1.
PySerial 2.5
PyOBDC 3.0.2
PyGame 1.9.1
PyGTK 2.24.2
lokal: http://www.pygtk.org/ ist dabei gewesen, früher musste man diverse man muss dazu
diverse libs installieren, siehe)


PyQt 4.9.1-1 Anleitung
Online: http://zetcode.com/tutorials/pyqt4/german/
Python enthält Pyscripter 2.5.3

TKinter (ist Standard) Anleitung
Online: http://www.pythonware.com/library/tkinter/introduction/index.htm

Turtle Grafix: (ist Standard)



75886473
Online http://docs.python.org/library/turtle.html
PythonCard Ordner von Python 2.5.4. \Lib\sitePackages\PythonCard
(und Files \Lib\Sit-Packages\wx*.* wohl nicht nötig)
online: http://pythoncard.sourceforge.net/documentation.html
siehe auch Kapitel 20 von Hello World von Sande: SandePython\Hello World Programmieren fuer Kids und andere Anfaenger Kap 17-20.pdf
Erzeuge ein Package RessourceEditor / darin dann >Import >General >File System >Next
>gehe zu Q:\PortablePython…\App\Lib\side-packages\PythonCard\Tools\resourceEditor
>Ok >Select All >Finish
Starten nun ResourceEditor.py
Es öffnen sich zwei Fenster
IPython Ordner von Python 2.5.4. \Lib\sitePackages\IPython und File
\Lib\sitePackages\ipython-0.9.1.egg-info kopiert
SWGui vereinfacht die Gestaltung grafischer Benutzeroberfläche von TKinter und ist eine Datei
im Site-Packages-Ordner …\Lib\site-packages, siehe
W.Seyboldt (Stand: 3.3.14)
Seite 23
Python
Seite 24
Graf-Zeppelin-Gymnasium




http://www.geniu.de/jml/index.php/materialien/swgui/14-download-swgui
siehe Buch Oldenbourg: Mathematische Algorithmen im Unterricht: Mathematik aktiv erleben
durch Programmieren
EasyGui (Ordner von Python 2.5.4. \Lib\EASYGui und File \Lib\easygui.* kopiert)
Handbuch lokal: EasyGuiHB\index.html
VPython (ging bei Version 2.7.2. nicht mit easy_install, das ich davor installiert habe)
Kopiere danach folgende Ordner von lib\site-Packages in die Portable Version: visual, vis,
FontTools, Polygon, ttfquery.
Ebenso Files von lib\site-Packages TTFQuer_1.0.4-pys.6.egg-info,
FontTools.pth, Polygon-2.0.2-py2.7.egg-info, site.pcy, site.pyo
Sympy (Computeralgebra) einfach von der alten Installation den Ordner \Lib/sitepackages\sympy-0.7.1-py2.7-win32.egg kopiert
online: http://docs.sympy.org/0.7.1/index.html
und http://sympy.org/en/index.html
Sypder (mathlab-ähnliche Umgebung, braucht PyQt
online: http://docs.sympy.org/0.7.1/index.html
Doku online: http://packages.python.org/spyder/
Python-Programme in exe-Files verwandeln
Es gibt zwei Arten, wie man dies tun kann: Mit Py2exe (wird aber wohl nicht mehr weiterentwickelt) und
mit Pyintaller (http://www.pyinstaller.org/), das eine lokale Installation von Python benötigt,
Python_Portable genügt nicht.
Manual:
http://www.pyinstaller.org/export/develop/project/doc/Manual.html?format=raw oder
http://www.pyinstaller.org/export/d3398dd79b68901ae1edd761f3fe0f4ff19cfb1a/project/doc/Manual.ht
ml?format=raw#windows
Vorgehensweise kurz zusammengefasst:
Voraussetzung:
1) Python 2.7 mit win32 und den benötigen Libraries ist als Installation vorhanden (z.B. c:\Python27)
2) Nicht installierte Version von Pyinstaller (z.B. c: \Pyinstaller)
Kopiere gewünsctres Python-Prg x.py nach Pyinstaller
Gehe nach Pyinstaller (cmd, cd c:\Pyinstaller)
>configure.py
> Makespec.py –-onefile –-console x.py -> erstellt Ordner x und darin x.spec
> Build.py x\x.spec ->Ergebnis steht in x\dist als x.exe
Bemerkung 1: Die Programme sind alle recht groß, da die Libraries eingebunden werden.
Bemerkung 2: Pythoncard-Programme gehen nicht, wohl aber Matplotlib-Programme.
Siehe auch http://sebsauvage.net/python/snyppets/#py2exe
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 24
Python
Seite 25
Graf-Zeppelin-Gymnasium
Pydev
Einige Tastenbefehle (siehe http://pydev.org/manual_adv_features.html // http://pydev.org/ )
Start: F9
Template Complition ctrl+Space
Quick Code Foramtter: ctr-shift+f
Finde References ctrl+shift+G
Auto-import for undefinded Variable: Ctrl+1
Surround code wirht try..cath: : ctrl+1
Geschichte, Hintergrundinfos
Die Sprache wurde Anfang der 1990er Jahre von Guido van Rossum in Amsterdam als Nachfolger für die
Programmier-Lehrsprache ABC entwickelt. Die erste Version wurde 1994 veröffentlicht.
Sie wird an Unis häufig in Naturwissenschaften verwendet, aber auch z.B. bei Google
Rossum war und ist begeistert von Monty Python’s Flying Circus (siehe
http://de.wikipedia.org/wiki/Monty_Python%E2%80%99s_Flying_Circus) . Daher kommt der Name,
keinesfalls von der Schlange gleichen Namens
gehe im Browser zu http://docs.python.org/tutorial/
Lese den kurzen Vorspann und Kapitel 1: Whetting Your Appetite
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 25
Python
Seite 26
Graf-Zeppelin-Gymnasium
Literatur, Linksammlungen
Bemerkung: Auf die lokalen Links kann man nur zugreifen, wenn man die online Version dieser Fassung
im Browser geladen hat. Link zur online-Version.
Grundlagenliteratur:
 http://www.python-kurs.eu/index.php
 http://www.michael-holzapfel.de/progs/python/python_kurz.htm
 http://www.hdm-stuttgart.de/~maucher/Python/html/Datentypen.html
 http://openbook.galileocomputing.de/python/python_kapitel_08_003.htm
 Offizielle Doku:. http://www.python.org/doc/
Tutorial http://docs.python.org/2/tutorial/
 http://www.hdm-stuttgart.de/~maucher/Python/html/Datentypen.html
 http://openbook.galileocomputing.de/python/python_kapitel_08_003.htm
 Offizielle Doku:. http://www.python.org/doc/
Tutorial http://docs.python.org/2/tutorial/
 http://openbook.galileocomputing.de/python/python_kapitel_08_003.htm#mj6d41cdafb4b9046
4f2c005027f9c91d5Datentypen
 http://www.tutorialspoint.com/python/python_strings.htm (String Formatting mit %)
http://ada.rg16.asn-wien.ac.at/~python/how2think/kap09.htm
http://docs.python.org/3.1/tutorial/datastructures.html#dictionaries
http://ada.rg16.asn-wien.ac.at/~python/how2think/kap10.htm
http://openbookproject.net//thinkCSpy/ch12.html
http://diveintopython.org/native_data_types/index.html
http://progzoo.net/wiki/Python:Read_From_a_Database
http://www.tutorialspoint.com/python/python_files_io.htm
http://tutorial.pocoo.org/inputoutput.html
Sortieren von Listen: http://wiki.python.org/moin/HowTo/Sorting
Sequenzen
 http://docs.python.org/release/2.5.4/tut/node7.html
 http://effbot.org/zone/python-list.htm
 http://www.tutorialspoint.com/python/python_lists.htm
 http://ada.rg16.asn-wien.ac.at/~python/how2think/kap08.htm
 http://effbot.org/zone/python-list.htm Überblick über die wichtigsten Strukturen
 http://henry.precheur.org/python/copy_list Kopieren von Listen [.] und list()
 http://www.physik.uzh.ch/lectures/informatik/python/python-listen.php
Lehrmaterialien zu Python
L101)Python Tutorial (aus Gaienhofen am Bodensee)
online: http://www.python-kurs.eu/index.php
TKinter: http://www.python-kurs.eu/python_tkinter.php
Weiterführende Themen http://www.python-kurs.eu/system_programmierung.php
Dies ist eine relativ kurz gefasst Einführung in Python, vielleicht eher eine Zusammenfassung.
L102)Programmieren macht Spaß
local: Allerlei\ProgrMachtSpass.html
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 26
Python
Seite 27
Graf-Zeppelin-Gymnasium
online http://www.thomas-guettler.de/vortraege/python/einfuehrung.html
L103)Sande: Programmieren für Kids (nur lokal, Buch)
SandePython\Hello World - Programmieren fuer Kids / Kap 01-05.pdf
SandePython\Hello World - Programmieren fuer Kids / Kap 06-10.pdf
SandePython\Hello World - Programmieren fuer Kids/r Kap 11-16.pdf
SandePython\Hello World - Programmieren fuer Kids / Kap 17-20.pdf
SandePython\Hello World - Programmieren fuer Kids / Kap 21-25.pdf
SandePython\Hello World - Programmieren fuer Kids / Anhang.pdf
SandePython\Hello World - Programmieren fuer Kids / Index.pdf
SandePython\Hello World - Programmieren fuer Kids / Inhalt.pdf
L104)Python for Kids
lokal Allerlei\Py4Kids.pdf
Folien lokal Allerlei\Py4KidsFolien1.ppt
online http://ada.rg16.asn-wien.ac.at/~python/
L105)Langtangen: A Primer on Scientific Programming, 2nd
lokal: Langtangen\A Primer on Scientific Programming with Python (2009).pdf
L106)Langtangen Python Scripting, 3nd
local: Langtangen \Langtangen_PythonScripting_3ndEditon.pdf
locale Zusatzdoku Langtangen_Scripting\doc.html
ab pdf-Seite 251: Tkinter
L107)Demleitner-Skript (Uni Heidelberg)
lokal: Allerlei\Demleitner_Programmierenl_skript.pdf
online http://www.cl.uni-heidelberg.de/kurs/skripte/prog1/html/index.html
Klassen http://www.cl.uni-heidelberg.de/kurs/skripte/prog1/html/page031.html
L108)SAMS Scientific Python Tools
online http://www.sam.math.ethz.ch/~hheumann/Tutorial/html/index.html
Infos zu Matplotlib, numpy
L109)Python umfassende Handbuch von Peter Kaiser, Version 2.5
lokal: pythonHB\index.htm
online: http://www.galileocomputing.de/1626?GPP=oppy
L110)A Byte of Python,
Deutsche Fassung lokal: AByteOfPython\byteofpython_120_de.pdf
Englische Fassung lokal AByteOfPython\byteofpython_120_en.pdf
Online: http://www.ibiblio.org/g2swap/byteofpython/read/index.html
Grundlegende Einführung für Anfänger
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 27
Python
Seite 28
Graf-Zeppelin-Gymnasium
L111)How to Think Like a Computer Scientist (Python)
Wie ein Informatiker denken
Deutsche Fasssung online: http://ada.rg16.asn-wien.ac.at/~python/how2think/
Englische Fassung lokal: Allerlei\thinkCSpy.pdf
Englische Fassung online: http://openbookproject.net/thinkcs/python/english2e/
Konzeptionelle Einführung ins Programmieren, Python-Version
L112)Dive into Python Version 3
lokal: DiveIntoPython3\index.html
online http://diveintopython3.org
L113)A Beginners Tutorial
online http://www.sthurlow.com/python/
L114)Google Python-Class
http://code.google.com/intl/de-DE/edu/languages/google-python-class/
L115)Einführung Python (Uni, englisch)
online: http://courses.cms.caltech.edu/cs11/material/python/
lab5. Tkinter
L116)Python on your own
online http://www.py4inf.com/
L117)Python in Cambridge
online: http://www.ucs.cam.ac.uk/docs/course-notes/unix-courses/PythonProgIntro
L118)Python Eggs
http://www.python-eggs.org/
L119)Python Programming Snyppets, quick and dirty,
http://sebsauvage.net/python/
Gui mit Tkinte http://sebsauvage.net/python/gui
Iterating: http://sebsauvage.net/python/snyppets/#iterating
Objects: http://sebsauvage.net/python/snyppets/#readable_objects
Multithreading: http://sebsauvage.net/python/snyppets/#threads_and_gui
Python offizielle Dokus, Tutorials
Vermittelt die wichtigsten Merkmale von Python
L201)http://docs.python.org
Diese Dokumentation wird angezeigt, wenn man in PyScripter auf >Help >Python Manuals
klickt.
L202)http://www.python.de/
offizielle deutsche Doku
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 28
Python
Seite 29
Graf-Zeppelin-Gymnasium
L203)http://docs.python.org/tutorial/
Offizielle Python-Tutorials
L204)http://docs.python.org/py3k/library/functions.html
Build in functions
L205)http://www.rg16.asn-wien.ac.at/~python/how2think/gex.htm
L206)http://www.tutorialspoint.com/python/
Python Libraries, Beispiele, Einführungen
L301)Python Kurs mit Einführung in Python und Tkinter
http://www.wspiegel.de/pykurs/pykurs.htm
L302)Graphische Benutzeroberflächen in Python
lokal: Allerlei\TurtleTKinter_PY-091007-Schmidt-GUIinPython.pdf
Tkinter, Turtle, GUI
L303)Grayson: Python and Tkinter Programming
lokal Allerlei\python-and-tkinter-programming.9781884777813.52496.pdf
L304)An Introduction to Tkinter mit vielen Beispielen
online http://www.pythonware.com/library/tkinter/introduction/
L305)GUI with Tkinter und wxPython
http://sebsauvage.net/python/gui/
L306)Tutorials zu PythonCard
http://pythoncard.sourceforge.net/walkthrough2.html
http://pythoncard.sourceforge.net/documentation.html
L307)Python und Statistische Methoden der Datenanalyse
Skript lokal: Allerlei\Kolanoski_Stat.pdf
Script Python lokal: Allerlei\Kolanoski_pythonForStat-1.pdf
http://www-zeuthen.desy.de/~kolanosk/smd_ss08/uebungen/pythonForStat.pdf
L308)Matplotlib
Kurze Info (auf deutsch) lokal: Allerlei\matplotlib.pdf
User Guide (englisch) lokal: Allerlei\matplotlib-users_guide_0.90.0.pdf
L309)Practical Scientific Computing in Python
lokal: Allerlei\Practical_Scientific_Computing_with_Python.pdf
L310)Python für Physiker
lokal Kurs 1: Allerlei\pythonFuerPhysiker.pdf
lokal Übungen für Kurs 1: Allerlei\PythonFürPhysiker1_Übuingen_pythonp.pdf
lokal Kurs 2: Allerlei\pythonFuerPhysiker2.pdf
lokal Übungen für Kurs 2: Allerlei\PythonFürPhysiker2_Übungen_python2p.pdf
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 29
Python
Seite 30
Graf-Zeppelin-Gymnasium
L311)Pywin32
http://docs.activestate.com/activepython/2.5/pywin32/PyWin32.HTML
L312)Python recipes
http://code.activestate.com/recipes/langs/python/
L313)Numerik mit C und Python, Vorlesung
lokal: Allerlei\Numerik_C_Python.pdf
http://www.num.uni-sb.de/iam/studium/vorlesungen/ws201112/programmierung
Jython – Python für Java
L401)Doku Jython
http://www.jython.org/currentdocs.html
L402)Kurze Einführung in Jython, Jython Turtle (deutsch)
lokal Jython\Jython_Einfuehrung-3.pdf
L403)Jyton Tutorial
online http://www.jython.de/tutorials
L404)Jython Book
http://www.jython.org/jythonbook/en/1.0/
L405)Jython Einführung in die Standard-Libraries
http://www.jython.org/docs/library/indexprogress.html
L406)PyPlotter
http://www.eckhartarnold.de/apppages/pyplotter.html
http://www.eckhartarnold.de/apppages/onlinedocs/PyPlotter_Doc/index.html
L407)Jes (Jython for Students)
http://computational-thinking-workshop.iste.wikispaces.net...
http://code.google.com/p/mediacomp-jes/
http://coweb.cc.gatech.edu/cs1315/3569
L408)Logo
http://el.media.mit.edu/logo-foundation/logo/index.html
75886473
W.Seyboldt (Stand: 3.3.14)
Seite 30