1 Numerical Methods in Extraterrestrial Physics - Introduction toPython III

2 Control Flow Tools II

2.1 Funktionen

Abseits der bereits besprochenen eingebauten Funktionen in Python (http://docs.python.org/library/functions.html) konnen ebenso eigene Algorithmen und Berechnungen in Funktionen ausgelagert werden.Mittels der funktionalen Programmierung konnen oft verwendete Code Bausteine so auf einfache Art und Weisemehrfach ausgefuhrt werden, was insbesondere die Struktur und damit die Lesbarkeit des Python Codes erhoht.Das Definieren einer Funktion erfolgt mittels des keywords def gefolgt von einem frei gewahlten Funktionsna-men und einer Liste von zu ubergebenen Parameters in runden Klammern. Die Funktion selbst enthalt einebeliebige Reihe an (eingeruckten!) Ausdrucken und gibt (optional) eine Variable mittels des return keywordszuruck.

Syntax der Definition:

def function_name(args): # Definiert Funktion ’function_name ’statement1statement2...return expression # expression wird zurueck gegeben

Eine definierte Funktion lasst sich aufrufen mit folgender Syntax.

Syntax der des Funktionsaufrufs:

var = function_name(args)

Die zuruckgebene Variable des return keywords wird hier in die Variable var gespeichert. Es folgt ein einfachesBeispiel fur eine Definition und den Aufruf einer Funktion

>>>def multiply(a,b): # Definiert die Funktion ’multiply ’ mit den Argumenten a,b>>> result=a*b # Das Produkt von a und b wird berechnet>>> return result # Das Ergebnis wird zurueck gegeben>>>c=multiply (2,4)>>>print c8#Beachte:#Der Typ der Rueckgabe von multiply haengt von den Typen der Argumente a,b ab.>>>d=multiply(2,"vier")>>>print dviervier

2.1.1 Default Argumente

In Python ist es moglich eine Funktionen mit einer variablen Anzahl an Argumenten aufzurufen. Dabei verwen-det man bei der Definition der Funktion sogenannte Default Argument Values, d.h. einige Argumente werdenauf einen Standardwert gesetzt.

# Beachte: Die Verwendung des return keywords ist optional!>>> def function_name(arg1 , arg2 , arg3 = "Default 3", arg4 = "Default 4")>>> print arg1 , arg2 , arg3 , arg4

# Da fuer die ersten beiden Argumente kein Defaultwert gesetzt ist ,# muessen diese zwingend uebergeben werden beim Aufruf>>> function_name("Arg1", "Arg2")Arg1 , Arg2 , Default 3, Default 4

# Die Uebergabe von Default Argumenten ist hingegen optional und kann# in beliebiger Reihenfolge geschehen.>>> function_name("Arg1", "Arg2", arg4 = "Arg4", arg3 = "Arg3")Arg1 , Arg2 , Arg3 , Arg4

2.2 Variablen Scope und Namespaces

Fur die Verwendung von Funktionen ist es wichtig das Konzept von Pythons Variablen Scope (”Reichweite”) zuverstehen. Unter dem Scope einer Variable versteht man die Reichweite unter welcher die Variable im Python

1

Code verfugbar ist. Der Name der Variable wird dabei im sogenannten Namespace abgelegt, der die VariablenNamen mit den zugehorigen Python Objekten verknupft.

Jedes Skript verfugt dabei uber einen gobalen und einer variablen Anzahl an lokalen Namespaces, welchedem globalen untergordnet sind. Der globale Namespace ist hierbei immer erreichbar, wahrend die Lokalen nureingeschrankt, d.h. in den zugehorigen Funktionen, Klassen, oder Methoden, , verfugbar sind.

>>> print var1NameError: name ’var1’ is not defined

>>> var1 = "foo" #Variable var1 wird dem globalen Namespace hinzugefuegt>>> print var1foo

Eine Variable ist also erst erreichbar nachdem sie dem aktuellen Namespace hinzugefugt wurde. Variablen konnenauch aus externen Skripten oder Modulen mittels des bereits vorgestellten import keywords dem aktuellenNamensraum hinzugefugt werden.

>>> print piNameError: name ’pi’ is not defined>>> from numpy import pi>>> print pi3.14159...

Ein Beispiel fur einen lokalen Namespace ist die Funktions Definition:

>>> var1 = "foo">>> def func_name ():>>> var2 = "bar">>> print "Innerhalb:", var1 , var2>>> func_name ()Innerhalb: foo bar>>> print var1foo>>> print var2NameError: name ’var1’ is not defined

Eine Variable, die in einem lokalen Namespace erzeugt wurde, ist also auch nur in diesem erreichbar. D.h. derScope der Variable beschrankt sich ausschliesslich auf den zugehorigen Raum in der sie definiert wurde. Wie indem Beispiel oben zusehen, ist der globale Namespace jedoch uberall erreichbar.

Lokale Namespaces sind wie auch Funktionen selbst endlos verschachtelbar. Fur Namespaces gilt dabei diesimple Regel, dass lokale Namespaces alle Variablen Namen ubergeordneter Namespaces enthalten. Namespacesenthalten jedoch keine Namen untergeordneter Namensraume. Hier ein kleines Beispiel:

>>> var1 = "foo">>> def func1 ():>>> var2 = "bar">>> def func2 ():>>> var3 = "spam">>> print "In func2:", var1 , var2 , var3

func2()>>> print "In func1:", var1 , var2 , var3>>> func1()In func2: foo bar spamIn func1: foo barNameError: name ’var3’ is not defined>>> print var1foo>>> print var2NameError: ...>>> print var3NameError: ...

2.3 Variablen Scope und Namespaces - Mini-Ubung

>>> L = [0, 1, 2]>>> def func1 ():>>> L = ["foo", 1, 2]>>> def func2 ():>>> L[1] = "bar">>> def func3(arg):>>> arg [3] = "spam">>> func1()>>> func2()>>> func3(L)>>> print L

2

• Untersuchen Sie den oben stehenden Code und machen sie eine Vorhersage uber den Inhalt von L amEnde des Skriptes (Stichwort: ”Mutable Objects”). Besprechen Sie das Ergebnis mit Ihrem Ubungsleiter.

3 Matplotlib

Matplotlib ist das komplementare Plotting-Interface zu den wissenschaftlichen Python-Bibliotheken Numpy undSciPy. Matplotlib bietet den Vorteil, dass es als Modul fr Python implementiert ist, also man die komplettenSprachfeatures von Python bei der Erstellung der Plots (so natrlich auch NumPy und SciPy) nutzen kann. DieBenutzung von Matplotlib ist sehr simpel, wobei Dank der Objektorientierung auch eine effiziente Erweiterungvon Matplotlib Routinen moglich ist. Zudem ist die Benutzung der meisten Plot-Routinen stark an die Semantikvon MATLAB angelehnt, um dessen Benutzern einen leichten Einstieg zu ermoglichen. Daher ist die Motivationdieses Handouts eine Einfhrung in die wichtigsten Funktionen zu bieten, mit denen sich die haufigst auftreten-den Plot-Problemstellungen losen lassen.

3.1 Erzeugung des Matplotlib Plot Fensters

Vor dem eigentlichen Plotten muss zunachst die Matplotlib Plot Figur und eine zugehorige Achse erzeugtwerden. Als Figur bezeichnet man hierbei das Plot Fenster und die Achse beschreibt den Rahmen innerhalbdieses Fensters, welcher spater den Plot enthalt.

import pylabFigure = pylab.figure ()Ax = Figure.gca()

3.2 Ein einfacher Plot

Matplotlib bietet eine Vielzahl von Plot Funktionen. Der Befehl Ax.plot() ist dabei der grundlegendste Befehlzum Plotten von Daten. Als Argument muss dabei immer mindestens eine Liste von x- und y-Werten ubergebenwerden (siehe Abbildung 1).

x = arange (10)y = x**2Ax.plot(x, y)

3.2.1 Argument von Ax.plot()

Ax.plot() erlaubt daruber hinaus eine Vielzahl optionaler Argumente zu ubergeben, die es einem ermoglichendie grafische Ausgabe des Plots zu modifizieren.

x = arange (10)y = x**2Ax.plot(x, y, arg = var , arg = var , ...)

arg steht dabei fur eines der unten aufgefuhrten Argumente und var fur den entsprechenden Wert:

• color: ’red’, ’blue’, ’green’, ... (Linienfarbe)

• linewidth: 1, 2, 3, 4, ... (Linienbreite)

• linestyle: ’solid’, ’dashed’, ’-.’, ... (Linienstil)

• label: ’Name’ (Datenbezeichnung)

• marker: ’*’, ’o’, ’x’, ... (Datenpunktstil)

• alpha: 0.1, 0.35, 1.0, ... (Transparenz)

• drawstyle: ’Default’, ’steps-pre", ’steps-mid’ (Plotstil)

Fur eine vollstandige Liste der moglichen Argumente ruft einfach die Hilfe des Ax.plot() Befehls auf.

help(Ax.plot)

3

3.3 Achsenparameter

Mittels der Achsenparameter kann man das grundlegende Aussehen des Plot Rahmens beeinflussen, d.h. mankann Beschriftungen hinzufugen, den Plotbereich festlegen, oder auf eine logarithmische Skala wechseln. Es gibteine sehr große Menge an einstellbaren Parametern, deswegen hier nur eine kleine Auswahl der Wichtigsten:

Ax.set_xlabel("X Beschriftung") # Beschriftung der x-AchseAx.set_ylabel("Y Beschriftung", fontsize = 3) # Beschriftung der y-Achse

# inklusive eines optionalem ArgumentesAx.set_xlim (-3,15) # Plotbereich der x-AchseAx.legend () # Erzeugt die Plot LegendeAx.set_yscale("log") # Wechselt zu einer logarithmischen Darstellung der y-WerteAx.set_yticks ([2,4,5,6]) # Setzt explizite Tick Markierung auf der y-Achse

Fur eine vollstandige Liste aller Parameter, durchstobert die Hilfe des Achsen Objektes (Ax). Fur die konkreteSuche eines Parameters, fragt am besten Google c©, z.B. ”Matplotlib Achsenbeschriftung”(siehe Abbildung 2).

3.4 Weiterfuhrende Plot Befehle

Zusatzlich zu dem grundlegenden Ax.plot() Befehl bietet Matplotlib eine große Menge weiterer Plot Befehlezum Darstellen von Daten. Diese teilen sich dabei einen Großteil der ublichen Argumente des Ax.plot() Befehls,konnen u.U. jedoch auch andere Argumente benotigen bzw. zulassen (Siehe Abbildung 3).

3.4.1 Befehl Ax.fill between()

Erzeugt eine ausgefullte Flache zwischen zweier Datenkurven und benotigt zwingend zwei Argumente fur diey-Werte

Ax.fill_between(x, y**2, y**2 + 10, alpha = 0.5)

3.4.2 Befehl Ax.scatter()

Erzeugt einen sogenannten Scatter Plot und benotigt hierbei die gleichen Argumente wie Ax.plot().

x = random_sample (1000)*10. #Erzeugt 100 Zufallszahlen zwischen 0 und 10y = random_sample (1000)*100 #Erzeugt 100 Zufallszahlen zwischen 0 und 100Ax.scatter(x,y,s=10,color = "black") # Argument s beeinflusst die Groesse der Marker

3.4.3 Befehl Ax.hist()

Erzeugt ein Histogramm der Daten und stell dieses dar. Benotigt als Argument hierfur nur eine Liste derMessgroßen x.

x = normal(loc=3, size =200) #Erzeugt 200 normalverteilte Zufallszahlen um 3Ax.hist(x, bins=10, alpha =0.5) # Aufloesung des Histograms

0 1 2 3 4 5 6 7 8 90

10

20

30

40

50

60

70

80

90

Abbildung 1: Einfacher Plot.

0 5 10 15x-Achse

100

101

102

x-Ac

hse

Daten

Abbildung 2: Einfacher Plot mitgesetzten Plot- und Achsenpara-metern.

0 2 4 6 8 100

20

40

60

80

100Ax.fill_between()Ax.hist()Ax.scatter()

Abbildung 3: Plot derAx.fill between(),

Ax.scatter(), Ax.hist()

Befehle.

4

4 Matplotlib - Fortgeschrittene Techniken

Matplotlib bietet eine Vielzahl fortgeschrittener Techniken zur Darstellung wissenschaftlicher Daten. Dazugehoren, u.a., 3D Hohenprofile, Farbkontur Darstellungen, Multi-Achsen Plots, 2D/3D Animation, InterkativePlot Elemente. Einige der gebrauchlichsten Techniken stellen wir im Folgenden mittels einiger Beispiele vor.

4.1 Erzeugung eines Multi-Achsen Plots

Zur Erzeugung eines Multi-Achsen Plots, d.h. eine Matplotlib Figure mit mehreren Achsenobjekten, gibt es 2Moglichkeiten.

4.1.1 Erstellen der Achsen von Hand

Mit dieser Methode hat man die volle Kontrolle uber Große und Position der erzeugten Achsen. Die Positionwird dabei mittels der ersten beiden Eintrage des Argumentes ubergeben, wahrend die beiden letzten Eintragedie Breite und Hohe der Achse angeben.

Figure = pylab.figure ()Ax1 = axes ([0.1 , 0.1, 0.8, 0.8]) # Erzeugung der ersten AchseAx2 = axes ([0.2 , 0.2, 0.3, 0.3]) # Erzeugung der zweiten AchseAx1.plot(sin(arange (0,2*pi ,0.01)))Ax2.plot(cos(arange (0,2*pi ,0.01)))

Sowohl die Position als auch die Große beziehen sich dabei auf die relative Große der Figure, d.h.

Ax1 = axes ([0.5 , 0., 0.2, 0.6]) #[X-Position , Y-Position , Breite , Hoehe]

erzeugt eine Achse mit einer Breite und Hohe von 20% bzw. 60% der Figure Große, wobei die untere linke Eckeder Achse bei einer Breite und Hohe der Figure von 50% bzw. 0% liegt.

4.1.2 Automatisierte Achsenerzeugung

Mit dem Befehl Figure.add subplot(Nx, Ny, i), wobei Nx und Ny die Anzahl der Achsen in x- und y-Richtungsind und i die aktuelle Achsennummer, lasst sich einfach ein komplettes Gitter aus Achsen in die aktuelle Figureeinbinden.

Figure = pylab.figure ()for i in range (6):

ax = Figure.add_subplot (3,2,i) # Erzeugt Achse i in einem (3x2)-Achsen Gitterax.plot(arange (10)**i)ax.set_title("Plots %s"%i) # Erzeuge einen Titel fuer die Achse

Um die Abstande der einzelnen Achsen festzulegen benutzt man schlicht den Befehl

pylab.subplots_adjust(hspace=0, wspace =0)

Dabei beschreibt wspace und hspace den horizontalen bzw. vertikalen Abstand der Achsen zueinander. Dieresultierende Achsenanordnung der o.g. beschriebenen Befehle findet ihr in Figur 4 und 5.

4.2 Farbkontur und Konturlinien Darstellung

Um Daten Z als Funktion der Großen X und Y darzustellen, werden ublicherweise,

• Konturlinien (Ax.contour(*args))

• Farbkonturen (Ax.pcolormesh(*args))

• 3D Hohenprofile benutzt (Ax.plot surface(*args))

benutzt. Letztere sind fur eine wissenschaftlich signifikante Darstellung jedoch wenig geeignet, da 3D Darstel-lungen auf dem Papier oder im PDF auf dem Bildschirm schwierig abzulesen sind. Wir beschranken uns deshalbauf die beiden ersten Moglichkeiten zur Darstellung 3-dimensionaler Datensatze.

5

0 100 200 300 400 500 600 7001.0

0.5

0.0

0.5

1.0

0 100 200 300 400 500 600 7001.0

0.5

0.0

0.5

1.0

Abbildung 4: Achsen von Handerstellt.

0 1 2 3 4 5 6 7 8 90102030405060 Plot 1

0 1 2 3 4 5 6 7 8 90102030405060 Plot 2

0 1 2 3 4 5 6 7 8 90102030405060 Plot 3

0 1 2 3 4 5 6 7 8 90102030405060 Plot 4

0 1 2 3 4 5 6 7 8 90102030405060 Plot 5

0 1 2 3 4 5 6 7 8 90102030405060 Plot 6

Abbildung 5: Achsen mitFigure.add subplot(*arg)

erstellt.

4.3 Erzeugung eines 3D Datensatzes

Zuerst erzeugen wir aus numpy’s Zufallszahlen Funktionen einen 3D Datensatz, um ihn spater als Beispielverwenden zu konnen

from numpy.random import normalfrom numpy import append , histogram2d , arange

# Erzeugung von Normal verteilten x- ZufallswertenxValues = append(normal (15, 2, size=1e6),normal (20, 5, size=1e6))# Erzeugung von Normal verteilten y- ZufallswertenyValues = append(normal (10, 3, size=1e6),normal (15, 2, size=1e6))# 2D Histogramm von x und y.Histogram , xedges , yedges = histogram2d(xValues , yValues , bins=( arange (10 ,30,0.2), arange (0 ,20 ,0.2)))

Da contour, contourf und pcolormesh ein Histogramm benotigen, das in der 1-ten Dimension die y- und inder 2-ten Dimension die x-Werte enthalt, mussen wir das Histogramm noch transponieren:

Histogram = Histogram.T # Vertauscht die 1-te und 2-te Dimension des Histogramms

4.4 Die Ax.contour(*args) und Ax.contourf(*args) Befehle

Ax.contour(*args) und Ax.contourf(*args) stellen einen 3D Datensatz mittels Isokonturlinien bzw. Isokon-turflachen dar. Beide Befehle haben eine ahnliche Syntax und optionale Argumente.

Der Ax.contour(*args) Befehl

Um den oben erzeugten 3D Datensatz mit Isokonturlinien zu plotten benutzt man die folgende Syntax

Figure = pylab.figure ()Ax = Figure.gca()# Erzeugt die IsokonturlinienContour = Ax.contour(xedges [:-1], yedges [:-1], Histogram.T)

Zudem lassen sich Beschriftungen der Isokonturlinien mit folgendem Befehl erzeugen:

# Erzeugt die Beschriftung fuer die IsokonturlinienAx.clabel(Contour , fontsize = 9, fmt="%i")

Der resultierende Plot ist in Figure 6 zu sehen.

6

Der Ax.contourf(*args) Befehl

Um den oben erzeugten 3D Datensatz mit Isokonturflachen zu plotten benutzt man die folgende Syntax

Figure = pylab.figure(figsize =(4 ,4))Ax = Figure.gca()# Definiert eine sogenannte Colorbar in der den einzelnen Hoehenlevels eine Farbe zugeordnet wirdhotmap = pylab.cm.get_cmap("hot")# Erzeugt die Isokonturflaechen mit definierten Hoehenlevels und FarbenContour = Ax.contourf(xedges [:-1], yedges [:-1], Histogram.T, cmap=hotmap , levels=arange (0 ,1200 ,200))# Erzeugt die Colorbar fuer die Kontur "Contour"cb = Figure.colorbar(Contour)

Der resultierende Plot ist in Figure 7 zu sehen.

4.4.1 Argumente und Syntax von Ax.contour(*args) und Ax.contourf(*args)

Die beiden Befehle erfordern die Ubergabe 3er Wertepaare an Daten gefolgt von optionalen Argumenten.

Ax.contour(X, Y, Z, *arg=var)

X und Y sind dabei die X- bzw. Y-Werte des Histogramms Z. Dabei steht arg fur eines der unten aufgefuhrtenArgumente und var fur den entsprechenden Wert:

• levels: Liste von Intensitatswerten (bestimmt fure welche Intensitaten in Z Hohenlinen dargestellt wer-den)

• colors: Liste von Farbwerten (Bestimmt die Farben der Isokonturen)

• cmap: Colorbar Object (Hiermit kann eine Colorbar ubergeben werden, welche die Farbe der Isokonturenbestimmt)

• linewidth: 1, 2, 3, 4, ... (Linienbreite, nur Ax.contour(*arg))

• linestyle: ’solid’, ’dashed’, ’-.’, ... (Linienstil, nur Ax.contour(*arg))

• alpha: 0.1, 0.35, 1.0, ... (Transparenz)

Fur eine vollstandige Liste der moglichen Argumente ruft einfach die Hilfe des Ax.contour(*arg) Befehls auf.

4.5 Der Ax.pcolormesh(*args) Befehl

Der Ax.pcolormesh(*args) ist einer der gebrauchlichsten Befehle zur Darstellung von 3D Daten. Die Syntaxund Argumente sind dabei sehr ahnlich zu den o.g. Befehlen

Ax.pcolormesh(X, Y, Z, *arg=var)

X und Y sind dabei die X- bzw. Y-Werte des Histogramms Z. Fur das Beispiel des 3D Datensatzes sieht eintypischer Aufruf wie folgt aus:

Figure = pylab.figure ()Ax = Figure.gca()# Definieren einer Colorbarjetmap = pylab.cm.get_cmap("jet")# Setzte alle Werte unterhalb eines Grenzwertes auf die Farbe "weiss"jetmap.set_under("white")# Erzeuge die Farbkontur mit der Colormap "jetmap" und dem unteren Grenzwert 0.1Ax.pcolormesh(xedges , yedges , Histogram.T, cmap=jetmap , vmin =0.1)

Der Unterschied zu Ax.contourf(*arg) besteht darin, dass den unterschiedlichen Intensitaten ein kontinu-ierlicher Farbverlauf zugeordnet wird. Der Farbverlauf wird dabei uber die Colorbar gesteuert.

# Hinzufuegen von Iso Konturlinieren mit BeschriftungContour = Ax.contour(xedges [:-1], yedges [:-1], Histogram.T, cmap=hotmap)Contour = Ax.clabel(Contour , fontsize = 9, fmt="%i")

Wie man an dem Beispiel sieht, lasst sich der Ax.pcolormesh(*args) auch mit den Isokonturlinieren kombi-nieren. Der resultierende Plot ist in Figure 8 gezeigt.

7

10 15 20 250

5

10

15

150

300

450600

75090

0

Abbildung 6: DerAx.contour(*arg) Befehl.

10 15 20 250

5

10

15

0

200

400

600

800

1000

Abbildung 7: DerAx.contourf(*arg) Befehl.

10 15 20 250

5

10

15

150

300

450600

75090

0

0

150

300

450

600

750

900

1050

Inte

nsity

Abbildung 8: Eine Kombinationaus den Ax.contour(*arg) undAx.pcolormesh(*arg) Befehlen.

4.6 Der Figure.colorbar(*args) Befehl

Die Erzeugung einer Colorbar, d.h. einer Sub-Achse in der man die dargestellte Intensitat einer Farbe zuordnenkann, scheint zunachst etwas umstandlich.

# Zuerst waehlt man eine der vielen vorgefertigten Farbverlaeufe aus matplotlibjetmap = pylab.cm.get_cmap("jet")# Danach erzeugt man seinen Farbkonturplot mit dem gewaehlten Farbverlauf .# Wichtig ist hierbei , dass der erzeugte Plot in einer Variable (hier ’Mesh ’)# gespeichert werden mussMesh = Ax.pcolormesh(xedges , yedges , Histogram.T, cmap=jetmap , vmin =0.1)# Danach erzeugt man die Colorbar mit dem Befehl:cb = Figure.colorbar(Mesh)# Beschriftung der Colorbarcb.set_label("Intensity")

Diese Syntax ist in komplizierten Plots mit mehreren Achsen jedoch von Vorteil und geht einem nach einigerZeit in Fleisch und Blut uber.

Argumente von Figure.colorbar(*args)

Die Colorbar erfordert zwingend die Ubergabe eines sogenannten mappable objektes, welches von den BefehlenAx.pcolormesh(*arg) und Ax.contourf()(*arg) zuruckgegeben wird.

Figure.colorbar(mappable , *arg=var)

• orientation: "vertical", "horizontal" (Orientierung der Colorbar)

• ax: Achsen Object (Bestimmt die Achse in der die Colorbar dargestellt wird)

• pad: float [0:1] (Abstand der Colorbar zur Achse)

• ticks: Liste von floats (Definiert die Ticks der Colorbar)

Fur eine vollstandige Liste der moglichen Argumente ruft einfach die Hilfe des Ax.contour(*arg) Befehlsauf. Einige Beispiele an unterschiedlichen Colorbars ist in Figures 9 und 10 gezeigt. Weitere Beispiele fur dieVerwendung von Matplotlib finden sich unter.

• http://matplotlib.org/gallery.html

• http://matplotlib.org/

8

10 15 20 25 300

5

10

15

20

0 150 300 450 600 750 900 1050Intensity

Abbildung 9: HorizontaleColorbar mit der Colormap

’Paired’.

10 15 20 25 300

5

10

15

20

0

600

1000

Inte

nsity

Abbildung 10: Vertikale, ge-schrumpfte Colorbar mit derColormap ’gist rainbow’ undgesetzten ticks.

9

5 Ubungen

1. Schreiben Sie eine Funktion, welche die Temperatur Daten der Datei ’temperatur.dat’ als Funktion derLange und Breite (Spalte 1 und 2) histogrammiert. Implementieren Sie fur die Funktion einen Parameter,der bestimmt fur welchen Monat (Spalte 3 bis 15) die Daten eingelesen werden.

2. Visualisieren Sie die Temperatur Daten mittels pcolormesh wie im Beispiel von Abb. 11 zu sehen.

3. Optional: Laden sie die Daten fur die Kustenlinien aus der Datei ’kuestenlinien.dat’ ein und plottensie diese zu den Temperatur Daten. Einzelne Kusten und Inseln in der Datei sind uber das Zeichen”<”getrennt.

Abbildung 11: Beispiel

10