Skip to content
Snippets Groups Projects
Commit 87c88aef authored by Malte Woidt's avatar Malte Woidt
Browse files

Upload New File

parents
No related branches found
No related tags found
No related merge requests found
%% Cell type:markdown id:2686acb8-0a4f-4035-bf03-ba58c86eeb6b tags:
### **Einführung Jupyter-Notebooks**
Für die Übung ??? verwenden wir die Programmierumgebung Jupyter-Notebook. Dieses Notebook bietet eine kurze Einführung in Jupyter und erklärt das Bedienungskonzept
%% Cell type:markdown id:3fba5bde-edf2-445d-962f-d9ac1ae87505 tags:
# **"Lernthema"**
Im Verlauf der Übung wird Jupyter-Notebooks sowohl als Lehrmaterial als auch als Umgebung zur Bearbeitung der Übungsaufgaben genutzt. In diesem Dokument erklären wir euch, wie und wieso man Jupyter-Notebooks zum Programmieren in Python einsetzt. An Ende dieser Eunheut sollt ihr:
* ""
* ""
* ""
### **Einordnung in Notebook Kontext**
Einordnung bezüglich der
* "übergeordneten Themen"
* "anderen Notebooks"
* "Lernziele des Notebooks" (spezifisch mit Bibliotheken und Code Verweisen)
### **Vorkenntnisse**
* "keine"
%% Cell type:markdown id:59fffdd0-6428-471c-8dd6-ac7faf9cfef7 tags:
# **Was sind Jupyter-Notebooks**
Das Jupyter-Projekt bietet eine Reihe von Tools zur interaktiven Verwendung von Programmiersprachen als Webanwendung im Browser an. Die Idee ist dabei, dass das Programm nicht auf dem eigenen PC, sondern auf einem Server läuft. Auch die Beispiele in diesem Notebook werden nicht auf eurem PC ausgeführt, sondern auf einem Server des Rechenzentrums. Alles was zur Benutzung benötigt wird ist also ein Webbrowser
Jupyter-Notebooks ist eine einfache Programmierumgebung als Browseranwendung, die es erlaubt strukturierten Text (Text, Bilder, Tabellen, Formeln, Inhaltsverzeichnis, etc.) mit ausführbarem Programmcode zu vermischen und die Ausgabe des Programmcodes gleich im Browser anzuzeigen. Das ist beispielsweise in diesem Notebook illustriert. Das Notebook selbst ist dabei in Zellen strukturiert, dazu mehr im nächsten Abschnitt (oder der nächsten Zelle).
Jupyter-Notebooks wird vor allem für interaktive Nutzung von Python eingesetzt. Z.B. für die Analyse von Daten und das Erstellen von Diagrammen und weniger für die Programmierung ganzer Programme. Prinzipiell ist allerdings beides möglich
Ein weiterer großer Vorteil von Jupyter-Notebooks ist, dass ihr damit auch auf eurem eigenen PC arbeiten könnt, falls ihr nicht auf den Servern des GITZ arbeiten wollt. Das kann sinnvoll sein, wenn ihr zum Beispiel keine Internetverbindung habt, oder euch der Server zu langsam ist, oder ihr unabhängig der Übung selbst etwas programmieren wollt. Die Installation ist relativ einfach, wir haben euch ***hier*** eine Anleitung erstellt. Damit habt ihr so zusagen genau die gleiche Umgebung wie auf dem GITZ-Server auf eurem eigenen PC, nur eben viel kleiner und nur für die lokale Benutzung durch einen Benutzer gedacht.
%% Cell type:markdown id:0bbed02a-276b-4240-9948-f4c19c6bc854 tags:
# **Wie benutzt man Jupyter-Notebooks**
Das Notebook-Bedienkonzept gibt es auch in anderen Programmierumgebungen (z.B. Wolfram Mathematica). Das Notebook ist eine Datei bzw. ein Dokument. Dieses Dokument ist in untereinanderliegende Zellen aufgeteilt, wie z.B. dieses Dokument. Wenn ihr zum Beispiel mit der linken Maustaste einmal auf diesen Text klickt, seht ihr einen Rahmen. Das ist die Zelle, in der diese Text steht. Es gibt verschiedene Zelltypen. Zum einen Textzellen, das ist eine Zelle wie diese hier. Zum Anderen gibt es Code-Zellen, dass ist Python Programmcode, der ausgeführt werden kann.
**Der modale Editor**
Jupyter-Notebooks ist ein sogenannter modaler Editor. Er kenn zwei Modi
* den Edit Mode zum Bearbeiten einer Zelle
* den Command Mode um Die Struktur der Dokumentes zu verändern
Momentan befindet ihr euch im Command Mode. Direkt unter dieser Textzelle befindet sich eine Codezelle mit dem Inhalt "3+5". Wenn ihr mit der linken Maustauste auf die Zelle klickt, befindet ihr euch im Edit mode. Ihr könnt den Inhalt der Zelle beliebig verändern. Die Codezellen Erkennt man an den Eckigen Klammern am linken Rand. Ihr verlasst den Editmode, indem ihr links neben die Zelle klickt oder Escape drückt. Die Zelle ist jetzt wieder grau hinterlegt, aber noch ausgewählt. Ihr könnt den Programmcode in dieser Zelle ausführen, indem ihr Shift+Enter drückt. In der Eckigen klammer steht dann eine Zahl. Das ist einfach ein Zähler, der mitzählt, wie viel Codezellen ihr schon ausgeführt habt und gibt die Reihenfolge der Ausführung an. Das kann wichtig sein, wie weiter unten beschrieben. Damit habt ihr euer erstes Programm ausgeführt, auch wen dessen Ausgabe etwas vorhersehbar war.
Eine letzte besonderheit bieten die Textzellen. Wenn ihr einmal auf eine Textzelle klickt, dann wird sie nur ausgewählt, ihr bleibt aber im Command Mode. Mit einem Doppelklick kommt ihr in den Editmode. Das Probiert ihr am besten nicht mit dieser Zelle aus. Ihr seht dann den Quelltext der Zelle (Die Auszeichnungssprache heißt Markdown, die ihr vielleicht aus Internetforen o.ä. schon kennt). Wenn ihr den Editmode wieder verlasst ist die Zelle weiterhin grau unterlegt und zeigt den Quelltext an. Mit Shift-Enter könnt ihr die Textzelle quasi ausführen. Das Ergebnis ist dann der formatierte Text
Die Wichtigsten Kommandos als Kurzrefferenz:
Um in den Edit Mode zu gelangen auf eine Zelle klicken (Bei formatiert angezeigten Textzellen doppelklick)
Um in den Command Mode zu kommen Esc drücken oder links neben die Zelle klicken
Im Command Mode:
* y: Macht die aktuelle Zelle zur Code-Zelle
* m: Nacht die aktuelle Zelle zur Text-Zelle
* a: Fügt eine Zelle über der aktuellen Zelle ein
* b: Fügt eine Zelle unter der aktuellen Zelle ein
* d-d: Zweimal d drücken löscht die Zelle. Kann durch ctrl-z rückgängig gemacht werden, bzw über das Menü Edit->Undo Delete Cells)
Im Edit Mode:
* Esc: Wechselt in den Command Mode
* tab : Autoverfollständigung (Funktioniert beim Programmieren in etwa so wie die Autoverfollständigung von Worten auf eurem Handy)
Ansonsten funktionieren die gängigen Tastenkombinationen wie ctrl-c, ctrl-x, ctrl-v und ctrl-z für Kopieren, Ausschneiden, Einfügen und Rückgängig machen
* shift-enter: unabhängig vom Modus
* Code Zelle: Der gesamte Programmcode in der Zelle wird ausgeführt
* Text Zelle: Der Text wird formatiert angezeigt (und ist dann nicht mehr grau hinterlegt)
Alle Aktionen sind auch über das Menü am oberen Ende des Notebooks zugänglich
%% Cell type:code id:abcaec09-8492-4d8b-85f5-58d51bc64a56 tags:
``` python
3+5
```
%% Cell type:markdown id:feb4741a-faa6-4438-974f-77f1b66d43f6 tags:
# **Ein paar Besonderheiten der Notebooks**
Die Notebooks haben zwei Besonderheiten, die man im Hinterkopf behalten sollte. Der Code in den Zellen wird nie automatisch ausgeführt, sondern erst, wenn shift-enter bzw. der entsprechende Knopf im Menü gedrückt wird. Das gilt sowohl wenn ein Notebook geöffnet wird, als auch wenn der Programmcode modifiziert wird. Die Nächste Zelle enthält Programmcode, der eine zufällige Zahl ausgibt. unter der Zelle siehst du bereits ein Ergebnis (0.1290...). Das wurde nicht beim öffnen des Notebooks erstellt sondern ist das Ergebnis, das ich beim erstellen dieses Notebooks erhalten habe. Die ausgabe der Zellen werden sozusagen als Vorschau mit dem Notebook zusammen gespeichert. Wenn du die Zelle ausführst erhälst du jedesmal ein neues, zufälliges Ergebnis
%% Cell type:code id:dd3c833d-d0b9-40d8-9b49-b6b25d9b3675 tags:
``` python
from random import*
random()
```
%% Output
0.8129827011701761
%% Cell type:markdown id:558d9f97-6c85-455a-b95e-c75e397eec80 tags:
Die Zahlen in den Eckigen Klammern links neben den Code Zellen geben an, in welcher Reihenfolge sie Ausgeführt wurden. Das ist wichtig, da nicht jede Zelle ein abgeschlossenes Programm für sich ist. Viel mehr wird der Programmcode ausgeführt und der Python-Interpreter wartet auf weitere Eingaben. Die nächsten zwei Zellen sollen das verdeutlichen. Auch ohne Programmierkenntnisse ist hoffentlich verständlich was passiert. Wenn du die erste Zelle und dann die zweite Zelle ausführst, dann funktioniert die zweite Zelle. Versuchst du die zweite Zelle ein zweites mal auszuführen, ohne die erste erneut ausgeführt zu haben, erhälst du eine Fehlermeldung. Du kannst das in diesem Notebook einfach ausprobieren
%% Cell type:code id:f0fd320a-ff4f-441f-bdec-00ff957735fc tags:
``` python
x=7 #Erzeugt eine Variable mit dem Namen x, in der der Wert 7 gespeichert wird
print(x) #gibt den Wert der Variable x aus
```
%% Cell type:code id:9660af8f-2afc-43c1-9cd8-726b8236217d tags:
``` python
print(x) #gibt den Wert der Variable x aus
del(x) #löscht die Variable x
```
%% Cell type:markdown id:07620b12-7782-47d6-ab54-22047d341b2f tags:
Die erste Zelle erzeugt eine Variable mit dem Namen x, die in der zweiten Zelle ausgegeben wird. Das ist möglich, da eine Zelle kein abgeschlossenes Programm ist. Eine Zelle findet den Zustand also so vor, wie ihn die letzte ausgeführte Zelle hinterlassen hat. In der zweiten Zelle wird die Variable x anschließend gelöscht. Versucht man jetzt die zweite Zelle auszuführen oder führt man die zweite Zelle vor der ersten Zelle aus, dann gibt es einen Fehler, da die Variable in keinem der beiden Fälle bekannt ist. D.h. die Reihenfolge, in der die Zellen ausgeführt werden ist nicht egal und entspricht nicht zwingend der Reihenfolge im Notebook, da die Zellen immer manuell ausgeführt werden!
%% Cell type:markdown id:d4a8a8af-2871-4148-9ee4-a9dcae61512a tags:
# **Aufgaben**
* Probiere in diesem Dokument einfach aus Zellen einzufügen, Zellen zu löschen oder zu editieren. Du befindest dich gerade in deiner eigenen, privaten Kopie unseres Dokuments und kannst damit machen, was du willst
* Da es in diesem Notebook noch nicht um das Programmieren an sich geht, ist es ein bisschen langweilig. Um dir zu beweisen, dass man mit Jupyter-Notebooks auch mehr kann als Zahlen auszugeben, kannst du die nächsten zwei Codezellen ausführen
Was du siehst ist ein Lorenz-Attraktor. Das ist anschaulich beschrieben der Weg eines Partikels, das sich mit der Konvektionsströmung einer Flüssigkeit zwischen einer Warmen und einer Kalten platte bewegt in einer vereinfachten physikalischen Modellierung.
Das erste Beispiel ist eine statische Darstellung, beim zweiten Beispiel können die Parameter der zugrundeliegenden Differentialgleichung interaktiv mit den Reglern angepasst werden
%% Cell type:code id:9a7785ba-ace4-4675-a211-be73f22f0553 tags:
``` python
import numpy as np
from scipy.integrate import solve_ivp
import matplotlib.pyplot as plt
WIDTH, HEIGHT, DPI = 1000, 750, 100
# Lorenz paramters and initial conditions.
sigma, beta, rho = 10, 2.667, 28
u0, v0, w0 = 0, 1, 1.05
# Maximum time point and total number of time points.
tmax, n = 100, 10000
def lorenz(t, X, sigma, beta, rho):
"""The Lorenz equations."""
u, v, w = X
up = -sigma*(u - v)
vp = rho*u - v - u*w
wp = -beta*w + u*v
return up, vp, wp
# Integrate the Lorenz equations.
soln = solve_ivp(lorenz, (0, tmax), (u0, v0, w0), args=(sigma, beta, rho),
dense_output=True)
# Interpolate solution onto the time grid, t.
t = np.linspace(0, tmax, n)
x, y, z = soln.sol(t)
# Plot the Lorenz attractor using a Matplotlib 3D projection.
fig = plt.figure(facecolor='k', figsize=(WIDTH/DPI, HEIGHT/DPI))
ax = fig.gca(projection='3d')
ax.set_facecolor('k')
fig.subplots_adjust(left=0, right=1, bottom=0, top=1)
# Make the line multi-coloured by plotting it in segments of length s which
# change in colour across the whole time series.
s = 10
cmap = plt.cm.winter
for i in range(0,n-s,s):
ax.plot(x[i:i+s+1], y[i:i+s+1], z[i:i+s+1], color=cmap(i/n), alpha=0.4)
# Remove all the axis clutter, leaving just the curve.
ax.set_axis_off()
```
%% Cell type:code id:5d5375e8-66e2-4acb-ba3c-963e846fe7d8 tags:
``` python
import numpy as np
from matplotlib import pyplot as plt
from scipy import integrate
from ipywidgets import interactive, fixed
def solve_lorenz(sigma=10.0, beta=8./3, rho=28.0):
"""Plot a solution to the Lorenz differential equations."""
max_time = 4.0
N = 30
fig = plt.figure(1)
ax = fig.add_axes([0, 0, 1, 1], projection='3d')
ax.axis('off')
# prepare the axes limits
ax.set_xlim((-25, 25))
ax.set_ylim((-35, 35))
ax.set_zlim((5, 55))
def lorenz_deriv(x_y_z, t0, sigma=sigma, beta=beta, rho=rho):
"""Compute the time-derivative of a Lorenz system."""
x, y, z = x_y_z
return [sigma * (y - x), x * (rho - z) - y, x * y - beta * z]
# Choose random starting points, uniformly distributed from -15 to 15
np.random.seed(1)
x0 = -15 + 30 * np.random.random((N, 3))
# Solve for the trajectories
t = np.linspace(0, max_time, int(250*max_time))
x_t = np.asarray([integrate.odeint(lorenz_deriv, x0i, t)
for x0i in x0])
# choose a different color for each trajectory
colors = plt.cm.viridis(np.linspace(0, 1, N))
for i in range(N):
x, y, z = x_t[i,:,:].T
lines = ax.plot(x, y, z, '-', c=colors[i])
plt.setp(lines, linewidth=2)
angle = 104
ax.view_init(30, angle)
plt.show()
return t, x_t
w=interactive(solve_lorenz,sigma=(0.0,50.0),rho=(0.0,50.0))
w
```
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment