Commit 1d255b32 authored by Jochen Schulz's avatar Jochen Schulz
Browse files

initialer commit von jupyter-book mit Daten aus pycourse

parent bfc9881c
_build
.ipynb
# Book settings
title: Mathematisch orientiertes Programmieren
author: Jochen Schulz
logo: logo.jpg
# Information about where the book exists on the web
repository:
url : https://gitlab.gwdg.de/nam/mop
latex:
latex_documents:
targetname: book.tex
# ######################################## ###############################################
# Interact link settings
launch_buttons:
notebook_interface : "classic"
- file: src/einleitung
numbered: true
- part: Prelude
chapters:
- file: src/Linux_und_Terminals/lecture
- part: Basis Python
chapters:
- file: src/Allgemeines/lecture
- file: src/Container/lecture
- file: src/Funktionen/lecture
- file: src/Kontrollstrukturen/lecture
- file: src/Module_Laden/lecture
- file: src/Module_Management_und_Erzeugung/lecture
- file: src/Iteratoren_Generatoren/lecture
- file: src/Itertools/lecture
- file: src/Rekursion/lecture
- file: src/Docstrings/lecture
- file: src/Scope/lecture
- file: src/Dekoratoren/lecture
- file: src/Strings/lecture
- part: Wissenschaftliches Rechnen
chapters:
- file: src/Numpy/lecture
- file: src/Lineare_Algebra/lecture
- file: src/Visualisierung_mit_Holoviews/lecture
- file: src/Pandas/lecture
- file: src/Andere_Visualisierungen/lecture
- file: src/Symbolisches_Rechnen/lecture
- file: src/Gleichungen/lecture
- file: src/Differentation_Integration/lecture
- file: src/Numerische_Differentation_Integration/lecture
- file: src/Interpolation/lecture
- file: src/Nichtlineare_Gleichungen/lecture
- file: src/Wahrscheinlichkeitsrechnung/lecture
- part: Fortgeschritten
chapters:
- file: src/Objektorientierung/lecture
- file: src/Exceptions/lecture
- file: src/Performance/lecture
- file: src/Parallelisierung/lecture
- file: src/Streams/lecture
- part: Tools
chapters:
- file: src/Git/lecture
logo.jpg

411 KB

# Allgemeines
## Aufgabe 1
In der Vorlesung haben Sie die `print`-Funktion kennengelernt.
- Lassen Sie sich den Typ der Funktion auf dem Bildschirm ausgeben, ohne sie auszuwerten.
- Übergeben Sie ihr ein beliebiges Argument und lassen Sie sich den Typ der ausgewerteten Funktion auf dem Bildschirm ausgeben.
- Lassen Sie sich wiederum dessen Typ auf dem Bildschirm ausgeben.
``` {code-cell}
type(print)
```
``` {code-cell}
type(print('hi'))
```
``` {code-cell}
type(type(print('hi')))
```
## Aufgabe 2
Initialisieren Sie die Variablen a, b und c mit 3 Zahlenwerten und prüfen Sie anschließend mithilfe boolscher Operatoren, ob diese aufsteigend sortiert sind.
*Hinweis*: Verwenden Sie logische Verknüpfungen, wie `and` und/oder `or`.
``` {code-cell}
a = 2
b = 4
c = 6
```
``` {code-cell}
a < b and b < c
```
---
jupytext:
text_representation:
extension: .md
format_name: myst
kernelspec:
display_name: Python 3
language: python
name: python3
---
# Allgemeines
## Python
[![](http://imgs.xkcd.com/comics/python.png)](http://xkcd.com/353/)
### Python 3
Wir verwenden in diesem Kurs Python 3. Das ältere Python 2 ist z.T. auch noch in Gebrauch und unterscheidet sich leider in einigen subtilen Punkten; sofern es keinen guten Grund gibt, sollte man darauf achten, **immer** Python 3 zu verwenden.
## Befehle
Python-Programme sind eine Liste von **Befehlen** (**Statements**), die der Computer sequentiell auszuführen hat. Mögliche Befehle lassen sich (unvollständig) unterteilen in:
- Einfache Befehle:
- Zuweisungen (s.u.)
- Ausdrücke (s.u.)
- Kontroll-Fluss-Befehle (`return`, `continue`, ...)
- ...
Einfache Befehle werden üblicherweise in einer einzelnen Zeile geschrieben.
- Zusammengesetzte Befehle:
- Funktionsdefinitionen (`def`)
- Konditionale (`if`)
- Schleifen (`for`, `while`)
- Objekt-Klassen-Definitionen (`class`)
- ...
## Ausdrücke
Ausdrücke bestehen aus **Werten**, **Variablen** und aus **Operatoren**, die diese kombinieren, z.B.:
```{code-cell} python3
2 + 3
```
oder, als trivialstes Beispiel,
```{code-cell} python3
42
```
Ausdrücke haben selbst einen **Wert**; Ausdrücke, die als Befehl oder Teil von Befehlen auftreten, werden **ausgewertet**, d.h. so lange gemäß einer Reihe von Regeln reduziert, bis ein Wert übrig bleibt.
**Hinweis:** Ist im Jupyter-Notebook der **letzte Befehl** einer Zelle ein Ausdruck, so wird der Wert des Ausdrucks automatisch angezeigt. Außerhalb des Notebooks muss man für Ausgabe die `print` Funktion verwenden (s.u.).
### Kommentare
Jeglicher Text in den Code-Kästen wird generell als Code interpretiert und ausgeführt. Will man dort aber *Kommentare* hinzufügen, die nicht interpretiert werden sollen, geht das mit dem Sonderzeichen `#`: Jeglicher Text, der nach diesem Zeichen kommt, wird nicht interpretiert oder ausgeführt. Er wird dann auch farblich leicht grau markiert.
```{code-cell} python3
2 + 3 # Wir rechnen was aus
```
### Funktionen
Neben einfachen arithmetischen Operatoren können Ausdrücke Funktionen oder Funktionsaufrufe enthalten.
Python-Funktionen sind ähnlich wie Funktionen (Abbildungen) im mathematischen Sinn.
Die Syntax für Funktionsaufrufe ist
```{code-block}
funktionsname(argument1, argument2, ...)
```
Beim Aufruf kann die Funktion zu einem *Wert* *ausgewertet* werden, das heißt, es wird ein bestimmter Wert zurückgegeben.
Es ist jedoch auch möglich, dass es keinen Rückgabewert gibt, wie zum Beispiel bei der print-Funktion (siehe unten).
*Beispiel*:
Mathematisch hat $\abs(-1)$ den **Wert** $1$.
So wird auch
```{code-cell} python3
abs(-1)
```
zu `1` **ausgewertet** (`abs` ist die Betrags-Funktion).
Python-Funktionen können zusätzlich einen **Effekt** haben:
```{code-cell} python3
print(10)
```
- hat keinen **Wert** (bzw. hat den speziellen Wert `None`).
- hat den **Effekt**, dass `10` auf dem Bildschirm ausgegeben wird.
`print` gibt immer sein Argument auf dem Bildschirm aus.
**Achtung Ausgabe:** Was bei `print` passiert ist, ist etwas anderes als bei
```{code-cell} python3
10
```
Dabei wird das Objekt, welches die `10` enthält, implizit ausgegeben, wenn sie in der letzten Zeile in einem Code-Kasten steht.
Die Form der Ausgabe kann sich dabei unterscheiden. Im Allgemeinen ist die Ausgabe implizit über die
letzte Zeile "schöner" lesbar.
## Variablen und Zuweisungen
- Alle Werte in Python sind **Objekte** (später mehr dazu), die in irgendeiner geeigneten Form im Arbeitsspeicher liegen.
- **Variablen** sind Namen/Bezeichner, mit denen diese Objekte referenziert werden können.
- Zulässige Variablennamen
- bestehen aus Groß- und Kleinbuchstaben `A-Z` und `a-z`, Ziffern `0-9` und Unterstrichen `_`,
- unterscheiden zwischen Groß- und Kleinschreibung,
- sollten keine Umlaute oder sonstige Sonderzeichen enthalten,
- dürfen nicht mit einer Ziffer beginnen.
- Außerdem gibt es eine Reihe von *Schlüsselworten* (`while`, `if`, `for`, ...), die reserviert sind und nicht verwendet werden dürfen, da sie sonst nicht mehr in ihrer ursprünglichen Form verwendet werden könnten.
- Zuweisungen haben die Form
```{code-block}
Bezeichner = Ausdruck
```
Der Ausdruck wird ausgewertet, und das Resultat wird dem Bezeichner zugewiesen.
- Tritt in späteren Ausdrücken derselbe `Bezeichner` auf, wird er effektiv durch den **Wert** ersetzt. Dabei wird der `Ausdruck` **nicht** noch einmal ausgewertet. Insbesondere treten *Effekte* des Ausdrucks nur einmal auf, nämlich zum Zeitpunkt der Zuweisung.
```{code-cell} python3
a = 3 + 5
print(a)
```
```{code-cell} python3
b = a
print(b)
```
`a` und `b` referenzieren nun dasselbe Objekt: die Zahl mit dem Wert `8`.
Nur die rechte Seite einer Zuweisung kann ein Ausdruck sein. Python löst auf diese Weise keine Gleichungen:
```{code-cell}
:tags: ["raises-exception"]
2 * a = 4
```
## Objekte und Typen (Klassen)
- Alle Werte in Python sind **Objekte**.
- Objekte haben einen **Typ** bzw. eine **Klasse**.
- Der Typ eines Objekts determiniert
- wie das Objekt im Speicher abgelegt wird und
- welche Operationen mit dem Objekt durchgeführt werden können.
- Die `type()`-Funktion gibt den Typ (die Klasse) eines Objektes zurück.
```{code-cell} python3
type(10)
```
In Python haben nur Objekte (Werte) einen Typ, Variablen jedoch nicht.
Die Variablen sind nur die Namen bzw. Referenz des Objektes.
```{code-cell} python3
a = 10
type(a)
```
```{code-cell} python3
a = False
type(a)
```
### Objekt-Methoden und -Attribute
Ein Objekt kann selbst wieder Variablen (**Objekt-Attribute**) und Funktionen (**Objekt-Methoden**) besitzen.
Es gilt i.A. die Regel, dass ein Objekt alle auf sich selbst anwendbaren Funktionen kennt. Nur einige Methoden sind als *globale* Funktionen benutzbar (wie z.B. `type` oder `print`).
Objekt-Methoden werden durch das Objekt, gefolgt von einem Punkt, gefolgt von dem Methodennamen aufgerufen:
```{code-block}
objekt.methode()
```
Was der Methodenaufruf tut, hängt nicht nur von den Argumenten, sondern auch vom Objekt selbst ab. Insbesondere können Methoden das Objekt ändern (s.u. für Beispiele).
Objekt-Attribute werden durch das Objekt, gefolgt von einem Punkt, gefolgt von dem Variablen-/Attributnamen aufgerufen:
```{code-block}
objekt.variable
```
## Elementare Datentypen
### Zahlen
#### Ganze Zahlen (int)
Ganze Zahlen haben den Typ `int`
```{code-cell} python3
1 + 3
```
```{code-cell} python3
-1 * 9
```
```{code-cell} python3
2 ** 3
```
Ganze Zahlen können beliebig groß sein, solange genug Arbeitsspeicher vorhanden ist:
```{code-cell} python3
2 ** 1000
```
Division ergibt immer eine Fließkomma-Zahl (s.u.):
```{code-cell} python3
9 / 3
```
Ganzzahlige Divison (rundet immer ab):
```{code-cell} python3
9 // 3
```
```{code-cell} python3
10 // 3
```
```{code-cell} python3
-10 // 3
```
Modulo-Divison ("Rest"):
```{code-cell} python3
10 % 3
```
```{code-cell} python3
-10 % 3
```
`n % m` liegt immer zwischen `0` und `m-1`.
#### Fließkomma-Zahlen (float)
Fließkomma-Zahlen sind Zahlen mit begrenzter Genauigkeit; nur eine beschränkte Anzahl
an signifikanten Stellen kann gespeichert werden (meist 53 Bits). Diese haben
den Typ `float`.
Die Eingabe von `float` geschieht implizit durch die Angabe eines Punktes für die Nachkomma-Stellen.
```{code-cell} python3
type(3.0)
```
```{code-cell} python3
type(3.)
```
Durch die begrenzte Genauigkeit können Rundungs-Fehler auftreten:
```{code-cell} python3
3 * 0.1
```
Hier vergleichen wir zwei Zahlen mit `==` und das ergibt `True` (wahr), jedoch ist für uns
offensichtlich dies nicht der Fall.
```{code-cell} python3
0.1 == 0.10000000000000001
```
#### Komplexe Zahlen (complex)
Komplexe Zahlen können entweder über die Nutzung von dem komplexen $i$
```{code-block}
1j
```
erzeugt werden oder über die Funktion
```{code-block}
complex(real,imag)
```
```{code-cell} python3
type(3 + 4j)
```
```{code-cell} python3
type(complex(3, 4))
```
```{code-cell} python3
1j ** 2
```
Real- und Imaginär-Teil bekommen wir über eine Objekt-Variable `objekt.real` bzw. `objekt.imag`.
```{code-cell} python3
a = 3 + 4j
a.real
```
```{code-cell} python3
a.imag
```
```{code-cell} python3
abs(a)
```
Komplex konjugiert erhalten wir über die Objekt-Methode `conjugate()`
```{code-cell} python3
a.conjugate()
```
#### Zeichenketten (`str`)
Strings werden mit einfachen `'` oder doppelten `"` Anführungszeichen gekennzeichnet.
```{code-cell} python3
s = "Hello world!"
s
```
```{code-cell} python3
type(s)
```
Strings können beliebige Sonderzeichen enthalten:
```{code-cell} python3
print('äóßø¶œ®')
```
Mehrere Strings direkt hintereinander werden zusammengefügt, was manchmal bei sehr langen Zeilen nützlich sein kann:
```{code-cell} python3
print("Lorem ipsum dolor sit amet, consetetur sadipscing elitr, "
"sed diam nonumy eirmod tempor invidunt ut labore et dolore "
"magna aliquyam erat, sed diam voluptua.")
```
Mehrzeilige Strings können auch mit drei `"` oder `'` geschrieben werden:
```{code-cell} python3
print("""Ein String
der über mehrere Zeilen
geht und Zeilenumbrüche
direkt enthält.
""")
```
Der Backslash `\` hat in den meisten Strings eine Sonderbedeutung als sogenannter "escape character" (siehe auch Vorlesung 01). Er leitet diverse Sonderzeichen ein, z.B.
- einen Zeilenumbruch `\n`
- Anführungszeichen im String selbst `\'`, `\"`
- einen Backslash `\\`
- ...
```{code-cell} python3
print("Ein String, der ein Anführungszeichen \", einen Zeilenumbruch\nund einen Backslash \\ enthält.")
```
### Formatierungen (`.format()` und f-strings)
Die `.format`-Methode erlaubt es, allgemeinere Formatierung beliebiger Werte als Strings durchzuführen. Eine kurze Einführung:
```{code-cell} python3
a = 3.1415
b = 22
c = 7
print('Pi ist ungefähr {}. Eine andere Näherung ist {}/{}.'.format(a, b, c))
```
Dabei wird `{}` jeweils durch das n-te Argument der format-Funktion ersetzt.
Dasselbe kann man durch sogenannte *f-strings* erreichen, bei denen man direkt
Variablen und Ausdrücke in die Platzhalter schreiben kann:
```{code-cell} python3
print(f'Pi ist ungefähr {a}. Eine andere Näherung ist {b}/{c}.')
```
Hierbei sorgt das `f` direkt vor dem String dafür, dass dieser anders
interpretiert wird, eben so, dass die format-Sprache benutzt werden kann.
### Wahrheitswerte (`bool`) und Vergleiche
Wahrheitswerte (Booleans) repräsentieren Wahr/Falsch-Werte und haben den Typ `bool`:
```{code-block}
True
False
```
```{code-cell} python3
type(False)
```
Booleans sind z.B. das Ergebnis von Vergleichs-Operationen
```{code-block}
==
<=, =>
<, >
!=
```
Gleichheit
```{code-cell} python3
1 == 2
```
Kleiner/Größer
```{code-cell} python3
1 < 2, 1 > 2
```
Kleiner Gleich/ Größer Gleich
```{code-cell} python3
2 <= 4, 2 >= 4
```
Ungleich
```{code-cell} python3
2 != 3
```
#### Logische Verknüpfungen
<a id="logisch"></a>
- `and`: logische Konjunktion
- `or`: logische Disjunktion
- `not`: logische Negation
- `^`: exklusive logische Disjunktion
```{code-cell} python3
True and False
```
```{code-cell} python3
True or False
```
```{code-cell} python3
not True
```
```{code-cell} python3
True ^ True
```
#### `=` vs. `==`
Zuweisungen (`=`) und Gleichheits-Test (`==`) sind fundamental unterschiedlich!
```{code-cell} python3
a = 2
a
```
```{code-cell} python3
a == 1
a
```
```{code-cell}
2 * a == 4
```
## Vervollständigung
Wie bereits in dem Abschnitt über Unix-Shells erwähnt, gibt es hier auch Vervollständigung von Befehlen und Variablen.
Auch hier funktioniert das mit der `TAB` Taste.
*Beispiele*
`pr+TAB` zeigt alle Befehle und Variablen an, die mit `pr` anfangen
<!-- TODO
```{figure}
pr
```
-->
Insbesondere ist das nützlich, um die Objekt-Methoden/-Variablen eines Objektes zu bekommen.
Erzeugen wir einen String und schauen, was für Eigenschaften das Objekt besitzt.
```{code-cell} python3
a = "Hallo"
```
```{code-cell} python3
a.upper()
```
`a.+TAB` zeigt uns alle möglichen Methoden und Variablen an, die diesem Objekt-Typ zugehörig sind.