« vorheriger Beitrag  · nächster Beitrag »

09.04.09 · 16:15 Uhr

Wissenschaftliches Arbeiten mit Python und PyLab II: Bunte Bildchen mit matplotlib

Kategorie: Naturwissenschaften  ·  Kommentare: 10

Nachdem es in Teil 1 erstmal etwas allgemeines Bla zu Python gab, wollen wir uns heute SciPy & Co. zuwenden. Bzw. muss ich jetzt genauer sein, denn eigentlich geht es um PyLab, das vereint die wissenschaftliche Bibliothek SciPy, dazugehörend NumPy zur Arbeit mit Arrays, matplotlib zum Grafiken erzeugen und eine Erweiterung zu IPython, um dynamisch mit einer Python-Konsole zu arbeiten. PyLab ist noch im Entstehen, aber die Teilpakete sind alle weit entwickelt und (im Vergleich zu den meisten anderen Bibliotheken) gut dokumentiert. Es kann noch ein wenig zu Namensverwirrungen um die Module kommen, aber in neueren Installationen sollte sich durch

from pylab import *

alles notwendige importieren lassen, um mit allen Funktionen zu arbeiten.

Heute wenden wir uns einem der wichtigsten Themen beim Erstellen wissenschaftlicher Texte zu: den bunten Bildchen. Wenn man mal die Bildchen erzeugt hat, hat man meist schon den Großteil der Datenauswertung geschafft, gut, man muss dann noch dazuschreiben was man sieht und die Fehler wegdiskutieren und so ;) Schauen wir uns vier einfache Beispiele an, denn mit matplotlib lassen sich unschlagbar schnell einfache Plots erzeugen. Als erstes erstellen wir ein Histogramm, dann eine Punkt- und einen Linienplot und schließlich noch einen Kontourplot.

1. Histogramm

Nehmen wir also an, wir haben einen Haufen Zahlenwerte und interessieren uns, wie diese verteilt sind. Dazu können wir ein Histogramm erzeugen, das zählt die Werte in eine gegebene Anzahl Kistchen ein ("bins"). Ok, wir bereiten erstmal eine Liste mit allen Zahlenwerten vor. Dazu kann man ein numpy-Array nehmen, muss man aber nicht, eine einfache Liste tut es. Sagen wir mal, wir haben eine Datei daten.txt in der pro Zeile ein Wert steht. Dann laden wir diese und speichern sie in eine Liste:

from pylab import *

datenList = [] # leere Liste
f = open("daten.txt")
for line in f:
    line = line.rstrip() 
    datenList.append(float(line))

rstrip entfernt leere Zeichen am Anfang und Ende sowie Zeilenumbrüche. So, jetzt erzeugen wir ein Histogram aus der Liste mit 10 bins:

hist(datenList,10)
show()

Das wars? Ja, das wars. Es öffnet sich ein Betrachterfenster mit dem Histogramm, aus dem man es auch abspeichern kann. Mit savefig(fname) statt show kann man es auch unter dem Dateinamen fname abspeichern. Das Grafikformat wird dabei aus der Dateinamen-Endung erkannt. Und so könnte ein Histogramm aussehen:

2. Punktwolke

Die häufigsten Daten sollten Funktionswerte sein, also (x,y)-Werte. Sagen wir also, wir haben eine Datei mit einem Haufen unabhängiger Ergebnisse, z.B. von einem Haufen Simulationsläufe mit jeweils leicht unterschiedlichen Bedingungen. Diese wollen wir einlesen und als Punkte darstellen. Dann könnte das z.B. so aussehen:

from pylab import *

xList = [] # leere Liste
yList = []

f = open("daten.txt")

for line in f:
    line = line.rstrip() 
    parts = line.split()
    xList.append(float(parts[0]))
    yList.append(float(parts[1]))

plot(xList,yList, 'ro')
axis([0,10,0,1])
show()

Unsere Datei listet in jeder Zeile einen x und y-Wert mit Leerzeichen getrennt. split teilt einen String auf, ohne Angabe in Klammer automatisch am Leerezeichen. Man könnte z.B. auch an einem Strich trennen mit split('-'). Man erhält eine Liste mit den Stringteilen ohne die Trennzeichen. Also hier ist parts[0] der x- und parts[1] der y-Wert. Die stecken wir in zwei Listen und die wiederum in plot(...). Der dritte Parameter zu plot sorgt für rote Punkte. Eine Liste der möglichen Angaben hier findet sich in der Dokumentation zu plot. Schließlich sorgt axis dafür, von wo nach wo die x- und y-Achse gehen sollen, damit auch alle Punkte gut zu sehen sind. So könnte der Plot aussehen:

3. Linienplot

Ohne Formatangabe als dritter Parameter würde automatisch eine Linie gezeichnet. Wir wollen jetzt aus zwei Datensätzen einen Plot mit zwei Linien zeichnen. Auch das ist ganz einfach.

from pylab import *

def readXYDataFromFile(filename):
    xList = []
    yList = []

    f = open(filename)

    for line in f:
        line = line.rstrip() 
        parts = line.split()
        xList.append(float(parts[0]))
        yList.append(float(parts[1]))

    return (xList,yList)

(xListA, yListA) = readXYDataFromFile("linie1.txt")
(xListB, yListB) = readXYDataFromFile("linie2.txt")

plot(xListA, yListA, label="blau")
plot(xListB, yListB, 'm-.', linewidth=3., label="magenta")
legend()

show()

Das Einlesen habe ich jetzt in eine Funktion ausgelagert, um es nicht doppelt schreiben zu müssen. Man sieht, wenn man einfach zweimal hintereinander plot aufruft, werden mit dem show() beide Plots in ein Bild gezeichnet. Mit label lässt sich ein Name festlegen, der später für legend verwendet wird. Der zweite plot soll sich unterscheiden, deswegen habe ich ihm nochmal ein Format mitgegeben, *'m-.' für magenta Strichpunkt-Linie, und auch noch die Liniendicke hochgesetzt. So sieht es dann aus:

4. Kontourplot

Und schließlich will ich noch - ganz kurz - den Kontourplot zeigen. Die Voraussetzung dazu ist, das man durch x- und y-Koordinaten die Punkte eines Gitters angibt und dann auf jedem Gitterpunkt einen Wert hat. Diese Werte stellt man farblich codiert da, und der Kontourplot ist eine interpolierte Darstellung die für die ganze Fläche durch Farbbereiche den Werteverlauf kennzeichnet.

from pylab import *

N = 20
x = linspace(.0, 1.0, N)
y = linspace(.0, 1.0, N)

X, Y = meshgrid(x, y)

Z = sin(X+0.2) - 2*cos(Y*1.2)

contourf(X, Y, Z)
colorbar()

show()

Auch hier wieder nur ein ganz einfaches Beispiel um das Prinzip zu zeigen, in der Dokumentation finden sich wieder umfangreichere Beispiele. Zunächst brauchen wir jetzt numpy-Funktionen. linspace erzeugt eine Liste von 20 Werten im Bereich zwischen 0 und 1. So haben wir die x- und y-Aufteilung unseres Gitters. Gut, dass es auch meshgrid gibt, das dann dafür die 400 Gitterpunkt koordiniert... Als Werte hab ich einfach eine Funktion zusammengestöpselt. Python mit PyLab ist clever genug, um automatisch das richtige herauszuwerfen, wenn man die Listen X und Y in die Funktion steckt, nämlich ein 20x20-Feld. Und wieder ist das Plotten simpel! contourf erzeugt den gefüllten Kontourplot, will man nur Höhenlinien, verwendet man contour. Man übergibt die Gitterkoordinaten in X, Y und das Wertefeld in Z. Schließlich ruft man noch colorbar auf, um den Farbbalken mit dem Wertebereich anzeigen zu lassen. Fertig!

Viele weitere, schönere Beispiele finden sich übrigens z.B. hier. Die Möglichkeiten sind unerschöpflich, und wer noch mehr braucht als diese Arten (z.B. komplizierteres 3D), kann sich z.B. auch mal MayaVi anschauen.

 

Autor: Jörg· 10 Kommentare· Permalink· Trackback-URL

Tags: informatik· matplotlob· programmierung· pylab· python· scipy