Einstieg ins Programmieren

Der Begriff „Digitalisierung“ wirkt bereits ermüdend, welches unteranderem an der Breite der Interpretationen liegt. Deshalb eine Eingrenzung wie Digitalisierung im Kontext von diesem Kurs verstanden wird:

Mit Gutenbergs Buchdruck im Jahre 1450 erfolgte ein wesentlicher Schritt zur Steigerung der Effizienz in der Verbreitung von Informationen, Voraussetzung war aber eine gemeinsame Sprache, bzw. entstand in den nachfolgenden Jahrhunderten das Bedürfnis einer klaren Sprache in einem grösseren Raum. Weitere Technologisierung brachten Maschinen welche die Arbeiten von Menschen übernahmen und diese nun neuen Aufgaben nachgehen konnten, wie z.B. Wissenschaft. Je wirksamer die technischen Hilfsmittel wurden, desto umfangreicher mussten diese Hilfsmittel, bzw. Maschinen parametrisiert werden. Als Beispiel hierfür sind Schalter, Taster, Drehrad früher und heute ein Touchdisplay.

Mit dem Aufkommen des Computers wurde das Parametrieren, d.h. die Übergabe von Informationen an eine Maschine wesentlich mächtiger und umfangreicher. Funktionen und Abläufe konnten definiert und später beliebig verändert werden. Der Einsatz wurde flexibler und umfassender. Mit ein und derselben Maschine (Computer) konnte eine Vielzahl von Aufgaben gelöst werden, wodurch die Kosten durch die Masse der Computer gesenkt werden konnten. Die Unterhaltung vom Menschen zur Maschine erfolgt durch Code, welches als Programmiersprache bezeichnet wird. Für diese Art von Kommunikation gibt es unterschiedliche Begriffe wie codieren, programmieren, modellieren, simulieren, kurz um, ein Gespräch zwischen Menschen und Computern. Die Ausdrucksform war in der Vergangenheit derart stark eingeschränkt , dass diese Sprache langjähriges Erlernen benötigte. D.h. Maschinen erfordern eine präzise Sprache, welche durch ein IT-Studium erlernt werden musste. Mit der Weiterentwicklung der Rechenperformance konnte die Sprachkomplexität reduzierten werden. Die Kommunikation mit Maschinen vereinfacht sich und wird einem breiten Teil der Menschen zugänglich. Diese Entwicklung wird hier als Digitalisierung verstanden und das Generieren von Code steht im Zentrum, als Schlüsselkompetenz. Beherrschen von Microsoft Office ist keine digitale Kompetenz ebenso die Bedienung eines Apps auf einem Tablet ist dem digitalen Konsum zuzuordnen oder als spezifisches Werkzeug in einer Anwendung.

Einstieg in Python

Welche Programmiersprache soll ich lernen? Eine Frage die oft am Anfang steht, weil dahinter viel Aufwand steckt um sich eine Sprache anzueignen. Klar gibt es Sprachen die in Mode sind und wieder verschwinden, das ist nicht was wir suchen. Es soll eine Sprache sein, die Bestand hat, so wie das Alphabet, am besten über viele Jahrzehnte. Dies ist bei Sprachen gegeben, welche in sich konsistent sind und einer verständlichen inneren Logik folgen. Dies trifft auf Python zu. Unabhängig welches Lehrbuch oder online-Tutorial zu Python, es finden sich immer dieselben Attribute: Eleganz, Einfachheit und mächtig zugleich. Aus der Erfahrung zeigt sich das die Sprache auch Spass macht, vor allem deshalb, weil sehr früh Wirksamkeit erreicht wird. Jedoch gilt auch hier üben, üben, üben, aber immer locker bleiben.  

Eigenschaften von Python

  • Die Einfachheit ermöglicht ein schnelles Prototyping von komplexen Anwendungen. Im letzten Jahrzehnt wurde Python auch zu einem soliden Werkzeug für Industrieanwendungen, da sich aufwändige Programme einfacher mit Python lösen, d.h. auch mit weniger Code und dies bedeutet auch weniger Fehler und weniger Wartungsaufwand.
  • Python entwickelte sich zur zentralen Programmiersprache bei Datenwissenschaften.
  • Die PSF-Lizenz (Python Software Foundation) ermöglicht einen freien Einsatz von Python in freien und kommerziellen Anwendungen, ohne Offenlegung des Codes. Gerade deshalb wird eine starke openSource-Community ermöglicht, wie z.B. Django, weshalb Python bei grossen Web-Anwendungen eingesetzt wird.

Nun starten wir. Bevor wir die ersten Code-Zeilen schreiben, installieren wir Python. Hierfür verwenden wir die Konsole...

Konsole. Aber welche?

Wenn wir mit dem Computer arbeiten, so navigieren wir über eine Oberfläche oder Desktop da dies die Bedienung vereinfacht und inzwischen die übliche Form des Umgangs mit dem Computer ist. Dies ändert sich beim Codieren. Wir werden Befehle direkt auf dem Betriebssystem ausführen (Linux, Windows oder macOS) über die Konsole. Nach der Python-Installation führen wir Python-Kommandos ebenfalls in einer Konsole aus. Um dies zu unterscheiden verwenden wir folgende Begriffe:

Die Konsole für das Betriebssystem nennen wir nicht "Konsole", sondern um Verwechslungen zu vermeiden nennen wir es Systemterminal oder kurz Terminal. Das Terminal wird wie folgt geöffnet:

  • Windows: durch Windows-Taster und "cmd"-Eingabe geöffnet. Mit Rechtsklick auf den oberen Rahmen kann die Schrift und Ansicht verändert werden. Unter Windows wird das Terminal auch Kommandozeileninterpreter, Eingabeaufforderung oder DOS-Box gennant.
  • Raspberry: Symbol rechts oben "Terminal"

Für Python-Code verwenden wir den Begriff Pythonkonsole oder kurz Konsol. In der Literatur findet man auch "Python-Shell" oder «interaktiver Modus». Die Konsole wird geöffnet indem zuerst das Terminal geöffnet wird und anschliessend "python" eingegeben wird mit Enter.

Windows Linux Bedeutung
cd name cd name Wechselt in das Verzeichnis oder den Pfad mit name
cd.. cd .. Wechselt ins obere Verzeichnis
cd\ cd / Wechselt in das oberste Verzeichnis (z.B. c:)
dir ls Zeigt den Inhalt eines Ordners an
cls clear Leert das Terminal
where dateiname whereis dateiname zeigt den Pfad an, wo dateiname abgelegt ist
whoami whoami zeigt den eingeloggten Username an

Installation

Der schnellste Weg um Python zu installieren ist über die Anaconda-Plattform, welches Python mit den wichtigsten Paketen (Libaries) enthält, sowie die Entwicklungsumgebung "Spyder" als Editor um Script-Files zu erstellen. (Internetsuche "anaconda python") Bei der Installation beachten das "Add Anaconda to my PATH enviroment variable" angekreuzt wird. Somit kann über das Command-Window python.exe in jedem Verzeichnis gestartet werden. Die Systemumgebungsvariabel (enviroment variable) kann auch nachträglich erweitert werden um den VERZEICHNISNAMEN, wo python.exe abgelegt ist (z.B. C:\Anaconda3) durch folgenden Befehlt im Command-Window:

path=%path%;VERZEICHNISNAMEN

Bei Python gibt es grundsätzlich zwei Version: die 2.x und die 3.x. Natürlich verwenden wir die Neue Version! Die 2.x ist aber nach wie vor sehr verbreitet.

Pakete: Zusätzliche Pakete können über das Kommando-Window (cmd) mit dem Befehl conda install <Paketname> installieren, wobei <Paketname> durch den Namen des Pakets. Anconda enthält jedoch alle, für uns notwendigen Pakete.

Wichtig! Aktualisiere das System mit dem Pakte Manager conda. Dieser organisiert das System und installiert die aktuellsten im System kompatiblen Pakete.

conda update --all

Lets start

Nun starten wir die Entwicklungsumgebung "Spyder" für Python (windowstaste dann Spyder eingeben oder bei Mac nach "Spyder" suchen). Das müsste dann so aussehen:

Starten von Spyder und Befehl in Konsole eingeben

Wie bei allem was mit Computer zu tun hat, geben wir nach dem Starten von "Spyder" in die Konsole (IPython console) ein Befehl ein. Die Konsole ist auch unser Python-Interpreter. Gib folgendes ein:

In [2]:
print('Hello World!')
Hello World!

Es wird der String ausgegeben. Ein String ist gekennzeichnet durch "doppeltes Hochkomma" oder 'einfaches Hochkomma', was gleichbedeutend ist. Bei drei Hochkommas kann der Text über mehrere Zeilen geschrieben werden und im Text können Hochkommas verwendet werden.

In [43]:
a = 12
In [44]:
print(a * 3 + abs(-0.2))
36.2

String und der Veriabelinhalt können als Text ausgegeben werden. Hierzu eignet sich der f-String (Formated string literals). Dabei wird vor dem Hochkomma ein f geschrieben. Die Position der Zahl im Text wird mit geschweiften Klammern und dem Variablennamen angegeben. Es kann zusätzlich die Formatierung definiert werden Die Variabel wird mit Gesamtanzahlstellen (z.B. 10 inkl. Komma und Nachkommastellen), die Nachkommastellen (z.B. 1) und Zeichen (f=float, %=Prozent, e=Exponent Notation, b=binär, x=Hexadezimal, d=Dezimal Integer, s=String):

In [59]:
print(f'Der Inhalt der Variabel ist {a:10.1f} und ist im Text eingebettet')
Der Inhalt der Variabel ist       12.0 und ist im Text eingebettet

Die Variablen können auch in einem eigenen Fenster dargestellt werden, dem "Variable explorer". Dieser wird wie folgt geöffnet:

Variablen über Variable Explorer anzeigen

Tutorial 1 - Übung 1: Mathematische Funktionen in Python

Nun werden einige mathematische Funktionen vorgestellt. Zuerst die Division:

In [4]:
35/4
Out[4]:
8.75

So wird eine Ganzzahl-Division ausgeführt:

In [5]:
35//4
Out[5]:
8

Hier die Modulo-Funktion oder auch "Rest" genannt:

In [6]:
35 % 3
Out[6]:
2

Potenziert wird in Python mit **

In [7]:
2**3
Out[7]:
8

Im gleichen Stil kann auch so die Kubik-Wurzel geschrieben werden:

In [8]:
27**(1/3)
Out[8]:
3.0

Im Folgenden werden zwei Variablen definiert und geprüft ob sie gleich sind. Jede Zeile wird einzel eingegeben und mit Enter abgeschlossen:

In [9]:
a = 5
b = 6
a == b
Out[9]:
False
In [10]:
a != b
Out[10]:
True

Logik-Operatoren sind

"&" für bitweises UND,

"|" für bitweises ODER und

"~" für bitweises NICHT.

Energierechnungen basieren in der Regel auf Zeitreihen, z.B. Strahlungswerte über einen Tag im Intervall von 15 min. Python bietet hier "Liste". Eine Liste beginnt und endet mit eckigen Klammern [].

In [11]:
H = [0, 10, 120, 230, 430, 500, 510,]

Tutorial 1 - Übung 2: Bibliotheken importieren

Mit Anaconda sind bereits die wichtigsten Bibliotheken installiert. Wir verwenden zum Rechnen die "numpy" Bibliothek. Um sie anwenden zu können, müssen wir zuerst die Bibliothek importieren. Dies erfolgt mit 'import numpy'. Numpy ist eine Bibliothek mit vielen numerischen Funktionen, wie z.B. die Absolut-Funktion abs(). Wenn die Funktion aufgerufen wird, so muss zuerst der Bibliotheksname dann Punkt und dann der Funktionsnamen angeben werden wie z.B. "numpy.abs(-3)". Da dies etwas lang ist, importieren wir wie folgt "import numpy as np", dann müssen wir später nur "np.abs(-3)" angeben.

In [12]:
import numpy as np

Nach Eingabe sieht man nichts auf der Konsole. Mit dir(Bibliotheksname) können alle Funktionen (aber auch Klassen und Variablen) der importierten Bibliothek aufgelistet werden. Die importierten Bibliotheken sind nun aktive bis Spyder wieder geschlossen wird.

Liste ermöglicht auch unterschiedliche Typen wie String, Zahlen, usw.. Wir werden aber vektoriell rechnen, was ebenfalls durch numpy unterstützt wird, jeodoch müssen wir die Liste (nur mit Zahlen) in ein "numpy-Array" umwandeln. Dies geht so:

In [13]:
Hn = np.array(H)
In [14]:
Hn.shape
Out[14]:
(7,)

"shape" gibt die Form der Matrix an, d.h. Anzahl Zeilen und Anzahl Spalten. Hier haben wir einen eindimensionalen Array.

Indexierung

Wie wir gelernt haben, wird eine Liste mit eckigen Klammern erzeugt. Werden eckige Klammern nach dem Variablennamen einer Liste oder eines Numpy-Array gesetzt, kann man auf die Elemente zugriefen. Man nennt dies "Indexierung", welches ein sehr mächtiges Werkzeug in Python ist. Die Indexierung beginnt bei 0 nicht bei 1, d.h. das erste Element ist Hn[0] ! Im Folgeden werden Befehle eingegeben und anschliessen mit Kommentar erklärt. Der Kommentar wir mit Doppelkreuz # angegeben. Eingabe des Kommentar ist nicht erforderlich, sondern hier nur als Erklärung.

In [15]:
Hn[3] # das ist das vierte Element
Out[15]:
230
In [16]:
Hn[-1] # Das ist das letzte Element
Out[16]:
510
In [17]:
Hn[3:5] # Hier von Index 3 (viertes Element) bis und mit Index 4, ohne Index Fünf.
Out[17]:
array([230, 430])
In [18]:
Hn[3:-2]  # auch hier wird zweitletzter Index nicht mit genommen
Out[18]:
array([230, 430])
In [19]:
Hn[3:-1]  # hier wird bis zum zweitletzten Element übernommen, ohne den letzten Index
Out[19]:
array([230, 430, 500])
In [20]:
Hn[3:]  # Hier wird bis und mit letztem Element übernommen
Out[20]:
array([230, 430, 500, 510])

Tutorial 1 - Übung 3: Ausführbare Programme, bzw. Skript-Files

Die Befehle können wir in ein File schreiben und als Skript laufen lassen. Das File wird mit der Dateierweiterung ".py" gespeichert. Das die Endung im Dateimanager sichtbar wird muss unter Ansicht die Dateinamenerweiterung (filename extension) eingeblendet werden . Beachte dass, das Skript-File nicht durch die Firewall geht, d.h. beim Versenden, das Skript-File von .py auf .txt umgenennen.

Den Inhalt des Files schreiben wir im linken Fenster bei "Spyder", genannt "Editor". Im Folgenden importieren wir Numpy und die Bibliothek zum Erstellen von Diagrammen "Matplotlib" oder genauer gesagt aus der Hauptbibliothek "Matplotlib" importieren wir die Bibliothek "pyplot", worin die Diagramm Befehle sind. Wir definieren wieder einen Array und stellen diesen als Diagramm dar. Nachdem wir das Script-File erstellt und gespeichert haben, können wir dies mit der grünen Dreiecks-Taste oben links "laufen" lassen, oder wir drücken die F5-Taste.

In [21]:
### importieren von Bibliotheken
import matplotlib.pyplot as plt
import numpy as np

H = [0, 10, 120, 230, 430, 500, 510, 460, 310, 190, 80, 1,]
Hn = np.array(H)

### Ausgabe
plt.plot(Hn, 'r--')
plt.ylabel('Strahlung [W/m2]')
plt.title('Tagesverlauf Globalstrahlung')
plt.show()

Das Diagramm wird mit "plot" generiert. Mit 'r--' wird die Linienfarbe und Linienart angegeben. Mit "label" wird der Name der Kennlinie angegeben, welcher nachfolgend über "legend" dargestellt wird. Der Befehl "grid" zeichnet die Hilfslinien ins Diagramm.

Nun erzeugen wir einen Zeit-Array von 6 bis 19 Uhr. Der Zeitarray sollte gleich viele Elemente haben wie der Strahlungs-Array Hn. Die Länge des Strahlungs-Arry finden wir mit Hn.size heraus. Um einen Numpy-Array zu erzeugen verwenden wir die Funktion linspace(start,stop, AnzahlElemente).

Du kannst das bestehende Skript-File mit den folgenden Aufgaben abändern und ausprobieren. Es ist nicht notwendig für jede Übung ein eigenes Skript-File zu erstellen und speichern.

In [25]:
### importieren von Bibliotheken
import matplotlib.pyplot as plt
import numpy as np

H = [0, 10, 120, 230, 430, 500, 510, 460, 310, 190, 80, 1,]
Hn = np.array(H)
tn = np.linspace(6, 19, Hn.size)

### Ausgabe
plt.plot(tn, Hn, color=(0.66, 0.33, 0), linewidth=3, label = 'Strahlung')
plt.xlabel('Zeit')
plt.ylabel('Strahlung [W/m2]')
plt.grid()
plt.legend(loc='upper left')
plt.show()

Die Linienfarbe kann auch als RGB-Wert in Dezimal color=(0.66, 0.33, 0) oder in Hex angegeben werden, durch color = #aa5500. Ebenso die Stärke der Linie über "linewidth".

Tutorial 1 - Übung 4: Wichtige Details...

In [26]:
# -*- coding: utf-8 -*-
"""
Es empfiehlt sich am Anfang kurz zu beschreiben was das Skript macht...
24.2.2017, Markstaler
"""

### importieren von Bibliotheken
import matplotlib.pyplot as plt
import numpy as np


### Berechnung
grad = np.linspace(0,360,200)  # [°]
amp  = np.sin(grad/180*3.1415) # [1]

### Ausgabe
fig = plt.figure(1, figsize=(5,3))
plt.plot(grad,amp, 'b-')
plt.xlabel('Grad')
plt.ylabel('Sinus')
plt.title('Sinusfuntion über Grad äöüß')
plt.grid(which='both', linestyle='--')
plt.show()

Nun sind da einige neue Funktionalitäten. In der ersten Zeile steht " # -- coding: utf-8 -- ". Bei Python können "magische" Kommandozeilen angegeben werden, sodass der Python-Interpreter den richtigen Zeichensatz verwendet. Standardmässig ist der ASCII-Satz vorgesehe, bei welchem die Umlaute und ß nicht enthalten sind. Dies führt zu einer Fehlermeldung (es lohnt sich dies auszuprobieren). Um die Kodierungsproblematik zu lösen, geben wir in der ersten Zeile an, dass der UTF-8-Code verwendet werden soll.

Anschliessend kommt ein Kommentar über mehrere Zeilen durch drei Hochkommas zur Dokumentation, was das Skript macht. Anschliessend werden Bibliotheken importiert und eine Sinuskurve berechnet. Die Sinus-Funktion bei Numpy erfordert die Eingabe im Bogenmass (Radiant), wir verwenden jedoch das Gradmass. Deshalb die Umrechnung.

Mit "fig = plt.figure(1, figsize=(5,3))" erzeugen wir ein Figure-Objekt mit Angabe der Grösse des Diagramms.

Wenn wir das Script-File unter "sinus.py" abspeichern, so können wir das Programm wie folgt startet. Wir öffnen das Kommando-Window (Windowstaste+cmd) und wechseln in das Verzeichnis, wo "sinus.py" abgelegt ist. Wir geben in das Kommando-Window "python sinus.py" ein.

Das Programm bleibt so lange offen, bis das Fenster wieder geschlossen wird.

Tutorial 1 - Übung 5: Einrücken !

Weitere wichtige Elemente beim Programmieren sind Möglichkeiten zur Steuerung des Programmflusses. Dies sind "for/if/elif/else" oder "while" mit "break" oder "continue". Sind diese Funktionen bekannt, einfach anwenden, Python ist hier intuitiv.

Wen for/if/elif/else nicht bekannt sind, dann unbedingt in einem Python-Buch oder online-Kurs nachlesen oder ein online-video ansehen. Im Buch A Byte of Python ist dies im folgendem Kapitel Control Flow.

Wichtig bei Python ist, das Einrücken. Dies wird am Beispiel einer for-Schleife erklärt, da sie für Energierechnungen notwendig ist, um einzelne Teilschritte zu berechnen. Die Folgenden Zeilen können im Skript-File eingegeben werden.

In [27]:
liste = [2,3,4]
for i in liste:
    print(i)
print('nun ist die for-Schleife zu Ende...')
print('...und es wird im Code fortgefahren')
2
3
4
nun ist die for-Schleife zu Ende...
...und es wird im Code fortgefahren

Alles innerhalb der for-Schleife wird bei jedem Durchlauf bearbeitet. Was zu for-Schleife gehört und was nach der for-Schleife kommt, erkennt python durch das Einrücken. Eingerückter Code gehört zur for-Schleife. Ist der Code nichtmehr eingerückt so weiss Python dass die Schleife Zuende ist. Die for-Schleife führt Code-Sequenzen aus, wie hier "print(i)". i repräsentiert die einzelnen Elemente der "liste".

Nun möchten wir gezielt nacheinander auf die einzelnen Elemente zugreifen. Hierfür verwenden wir range(5), dies erzeugt ein Array mit 5 Elementen beginnend bei Null, oder range(len(a)) erzeugt ein Array mit gleichviel Elemente wie a (len ermittelt die Länge eines Arrays).

In [28]:
a = [5, 6, 7]
b = np.zeros(len(a))
for i in range(len(a)):
    b[i] = a[i]*3
    print(i)
print(b)
0
1
2
[15. 18. 21.]

Wir haben mit a einen Array definiert und möchten einen neuen Array b berechnen. Hierfür greifen wir auf ein Element in a zu durch a[i] und weisen dieses berechnete Element dem Array b[i] zu. Die Variabel i ist dabei unsere Zählvariabel beginnend beim Nullten Element.

Aber for ist noch flexibler:

In [29]:
for s in ['Wahnsinn', 'was', 'mit', 'Python', 'alles', 'geht!']:
    print(s)
Wahnsinn
was
mit
Python
alles
geht!

Kopieren in Python

Stellt man sich einen Array als Kasten mit Schubladen vor, so lägen die Zahlenwerte in den einzelnen Schubladen. Als Beispiel ein Kasten mit Namen k und den Zahlen 1, 2, 3, 4, 5.

In [30]:
k = np.array((1, 2, 3, 4, 5))

Nun ist "k" nicht der Kasten, sondern das "Schildchen" wo auf den Standort des Kasten zeigt. Wir machen nun eine Kopie "a" von "k" und weisen dem letzen Element/Schublade den Wert 99 zu und sehen was passiert:

In [31]:
a = k
a[-1] = 9
print('a: ' + str(a))
print('k: ' + str(k))
a: [1 2 3 4 9]
k: [1 2 3 4 9]

Nun geben wir "k" aus und sehen dass auch dort das letzte Element geändert wurde! Dies liegt daran das wir nicht den "Kasten" kopiert haben, sondern das "Schildchen". Die Änderung haben wir aber beim Kasten gemacht, d.h. beide Schildchen zeigen auf den selben Kansten.

Um eine richtige Kopie zu machen, führen wir folgendes aus:

In [32]:
a = k.copy()
a[-1] = 6
print('a: ' + str(a))
print('k: ' + str(k))
a: [1 2 3 4 6]
k: [1 2 3 4 9]

Hilfe

Zu den einzelnen Funktionen ist ein Hilfetext hinterlegt, welcher durch "help()" aufgerufen werden kann. Probiere mal "help(np.sqrt)".

Für allgemeine Hilfe zu Python verwendet man am Besten die Internetsuchmaschine und stellt die Frage. Es finden sich Reference-Manuals, Lernvideos, Forumseinträge, usw.

Beim Programmieren unterstütz der Editor die Fehlersuche durch Fehlermeldungen:

In [33]:
a = np.linspace(1,10,5)
b = np.linspace(1,10,10)
c = a + b
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_13608\2328192245.py in <module>
      1 a = np.linspace(1,10,5)
      2 b = np.linspace(1,10,10)
----> 3 c = a + b

ValueError: operands could not be broadcast together with shapes (5,) (10,) 

Unklar sind die Fehlermeldung wenn ungleichviel Klammern geöffnet und geschlossen werden. Hier wird der Fehler bei der nachfolgenden Zeile angezeigt, welches verwirrend ist.

In [34]:
b = (a + (2*a + 1)+ (3*a + 2)
c = a + b
  File "C:\Users\markus.markstaler\AppData\Local\Temp\ipykernel_13608\703640148.py", line 2
    c = a + b
    ^
SyntaxError: invalid syntax

Der zeite Fall von unklarer Fehlermeldung tritt bei Umlauten auf, kann aber durch die "magischen Kommandozeilen" gelöst werden (siehe weiter oben im Text).

a = 10 # [m] Breite b = 2 # [m] Höhe c = 2a + 2b # [m] Umfang

Wenn du hier angekommen bist, dann ist eine Pause verdient. Gratulation! Der Einstieg in eine neue Sprache hast du sehr gut gemacht. Super.

Die drei grossen Schritte waren:

  • Indexierung
  • Einrücken
  • Hilfe übers Internet anstatt Reference-Manuals

Komplizierte Sachen in Python

In der nächsten Zeit, in diesem Kurs, möchte man unterschiedliche Funktionen codieren, beim welchem zu Beginn nicht klar ist, wie dies gelöst werden kann. Wie geht man vor? Auch hier über die Internetsuche; das Problem mit Stichworten beschreiben und Lösungen in Foren oder Tutorials finden. Diese Code-Blöcke ausprobieren und erst wenns funktioniert, kann man versuchen den Code zu verstehen. Im Folgenden zwei Funktionen welche wir im Kurs benötigen und als Code-Blöcke kopieren und anwenden werden. Es ist nicht notwendig den Code zu verstehen.

3D Plot

Variieren wir nicht einen Parameter, sondern einen zweiten Parameter, so lässt sich das Ergebnis als 3D-Plot darstellen. Dies wird über die Funktion "plot_surface" realisiert. Für die Farbdarstellung importieren wir cm (colormap). Im folgendem Beispiel wird "cm.Blues" verwendet. Es wird "LinearLocator, FormatStrFormatter" für die Achsenformatierung importiert. Beim untenstehenden Code wird eine Beispiel-Funktion gewählt, welche ein Eintdruck vermitteln soll was mit 3D-Plot möglich ist.

In [35]:
# -*- coding: utf-8 -*-
"""
Beispiel für ein 3D-Plot. Speichere das Skript ab als 3dplot.py und rufe die Datei 
über das Terminal (Windostaste>cmd) auf mit "python 3dplot.py". Es öffnet sich ein Fenster
mit dem 3D-Plot.
"""
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter

xArray=np.linspace(-2, 2,  90)
yArray=np.linspace(-2, 2, 110)

### Initialisierung, d.h. es werden Array mit Nullen (zeros) erzeugt
zMatrix = np.zeros((yArray.size, xArray.size))

for x in range(xArray.size):
    a = xArray[x]
    for y in range(yArray.size):
        b = yArray[y]
#…Berechnungscode….Anfang
        berechneteDaten = 500*a*b*np.exp(-a**2-b**2)
#…Berechnungscode….Ende

        zMatrix[y,x]= berechneteDaten            
    
fig, ax = plt.subplots(subplot_kw={"projection": "3d"}, figsize=(8,4))
X, Y = np.meshgrid(xArray, yArray)
surf = ax.plot_surface(X, Y, zMatrix, \
                       rstride=1, cstride=1,\
                       cmap=cm.Blues, linewidth=0.2)
ax.set_xlabel('xArray')
ax.set_ylabel('yArray')
ax.set_zlabel('z-Achse')
ax.zaxis.set_major_locator(LinearLocator(5)) # Definiert Anzahl Teilstriche
ax.zaxis.set_major_formatter(FormatStrFormatter('%.f')) # Formatierung Zahl
fig.colorbar(surf, shrink=0.5, aspect=5)
ax.view_init(azim=29, elev=29)
plt.show()

Alternativ kann auch "Contour" als Plot verwendet werden:

In [36]:
fig = plt.figure(3, figsize=(8,6))
X, Y = np.meshgrid(xArray, yArray)
CS = plt.contour(X, Y, zMatrix, 15) # 15 Linien
plt.clabel(CS, inline=1, fontsize=10, fmt='%.f')
plt.title('Fantasiebeispiel einer Funktion')
plt.xlabel('x Achse')
plt.ylabel('y Achse')
plt.grid(which='both', linestyle='--')
plt.show()

Funktionen in Python

Für die Sonnenstandsberechnung benötigen wir trigonometrische Funktionen (Sinus, Kosinus,...). Diese Funktionen sind in der numpy Bibliothek enthalten, jedoch rechnen diese mit Radiant und wir werden mit Grad rechnen. Um nicht jedesmal umrechnen zu müssen, bauen wir uns unsere eigene Funktionen mit Grad:

In [37]:
def sin(arg):
    y = np.sin(np.deg2rad(arg))
    return y

"def" zeigt an, dass wir eine Funktion definieren mit dem frei wählbarem Namen "sin(arg)". Mit den Variablennamen in Klammer definieren wir wieviel Variablen der Funktion übergeben werden. Anschliessend folgt der Code, welcher die Funktion ausführt. Am Ende definieren wir den Wert welcher zurück gegeben wird mit "return". Versuche dies im Editor und gib die Funktion ein. Teste anschliessend "sin(45)".

Lambda-Operator

Mit "def" zur Funktionsdefinition ist uns geholfen, jedoch benötigen wir 3 Zeilen Code um dies zu definieren. Dies geht in einer Zeile mit dem Lambda-Operator. Der Aufbau ist wie folgt am Beispiel $y = {b}^{e}$ als Funktion y = hoch(b,e) beschrieben.

In [38]:
hoch = lambda b, e : b ** e
In [39]:
hoch(2,3)
Out[39]:
8

Zuerst kommt der Funktionsname "hoch", und nach dem Istgleichzeichen das Kommandoh lambda. Nun weiss Python das hoch eine Funktion ist. Es folgen die Argumente getrennt duch Komma, anschliessend ein Doppelpunkt und der Ausdruck für die Berechnung. Vorteil des Lambda-Operator ist eine kompakte Schreibweise, es wird nur eine Zeile Code benötigt.

Für die Sonnenstandsberechnung benötigen wir angesprochen Trigonometrische Funktionen (Sinus, Kosinus,...), welche mit dem Lambda-Operator wie folgt aussehen:

In [40]:
cos  = lambda arg : np.cos(np.deg2rad(arg))
sin  = lambda arg : np.sin(np.deg2rad(arg))
acos = lambda arg : np.rad2deg(np.arccos(arg))
asin = lambda arg : np.rad2deg(np.arcsin(arg))

Markus Markstaler 09.09.2022

In [ ]: