Python 3

Python 3#

Python wurde von Guido van Rossum am Centrum Wiskunde & Informatica (CWI) in den Niederlanden entwickelt (erste Version 1991)
Der Name bezieht sich auf die englische Komikergruppe Monty Python

Warum genau Python:

Es ist eigentlich egal, welche Programmiersprache man lernt, wichtig sind die grundlegenden Konzepte, die überall sehr ähnlich sind!
Python ist sehr flexibel, wird aktiv weiterentwickelt und erlaubt einen einfachen Einstieg.
Python ist eine high-level Sprache, die oft verwendet wird, um low-level Code (in C, C++, …) auszuführen und einfacher zu bedienen.

Vorteile von Python:

Einfacher Einstieg, leicht zu lernen und zu lesen
Bibliotheken (Erweiterungen) für beinahe alle denkbaren Anwendungen (große Community)
Kostenlos und Quelloffen
Python ist portabel und nicht vom jeweiligen Betriebssystem abhängig

Nachteile von Python:

Python ist langsam im Vergleich zu anderen Sprachen wie C, C++,… und daher für Anwendungen, die rechenintensiv sind, nicht direkt geeignet (Dieser Nachteil wird oft durch Verwendung von Bibliotheken relativiert)

Python erleichtert das Programmieren und opfert dafür ein wenig Performance#

Motivation von Python: “Computers are cheap, programmers are expensive”

Programmieren für MathematikerInnen#

Das ist kein Programmierkurs der Informatik!
Wenig Softwaredesign
Wenig Debugging
Wenige Algorithmen

Literatur & Ressourcen#

“Automate the Boring Stuff with Python” von Al Sweigart (kostenlos online verfügbar unter https://automatetheboringstuff.com/)
“Python 3” von Johannes Ernesti und Peter Kaiser (sehr umfassend)
“Python Dokumentation” (https://docs.python.org/3/)
“Programmier Forum” (https://stackoverflow.com/)
“Python Tutor” (https://pythontutor.com/) - Visualisierung von Python Code

Programm#

Wikipedia: Ein Computerprogramm, oder kurz Programm, ist eine Folge von Anweisungen, die den Regeln einer Programmiersprache genügen, um auf einem Computer eine bestimmte Funktionalität, Aufgaben- oder Problemstellung bearbeiten oder lösen zu können.
Anweisungen sind Definitionen und Instruktionen
- Definition: z.B. \(x = 3\) oder \(f: x\mapsto x^2\)
- Instruktion: “tue etwas”, z.B. berechne \(f(x)\), suche ein Wort in einem Text, berechne den Wert eines Integrals
Python wird als eine interpretierte Programmiersprache betrachtet. Das bedeutet (vereinfacht gesagt), dass die Programmanweisung zum Zeitpunkt der Ausführung in elementaren Computercode übersetzt wird. Diese Aufgabe übernimmt der sogenannte Interpreter. Im Gegensatz dazu werden kompilierte Programmiersprachen (wie C, C++, Java) vor der Ausführung im Ganzen übersetzt.

Wie verwendet man Python?#

Installation von Python3#

Python ist ein Programm, das auf Ihrem Computer installiert werden muss.

Windows:

Laden Sie den Installer von https://www.python.org/downloads/ herunter
- Verwenden Sie den “Download Python 3.x.x” Button
- Alternativ können Sie auch den Microsoft Store verwenden
Starten Sie den Installer und wählen Sie “Add Python 3.x to PATH” und “Install Now”
Überprüfen Sie die Installation, indem Sie in der Kommandozeile (Windows-Taste + CMD eingeben + Enter) python --version eingeben

MacOS:

Laden Sie den Installer von https://www.python.org/downloads/ herunter
- Verwenden Sie den “Download Python 3.x.x” Button
- Alternativ können Sie auch Homebrew verwenden (https://brew.sh/)
Starten Sie den Installer und folgen Sie den Anweisungen
Überprüfen Sie die Installation, indem Sie in im Terminal python3 --version eingeben

Linux:

Python ist auf den meisten Linux Distributionen bereits vorinstalliert
Überprüfen Sie die Installation, indem Sie in im Terminal python3 --version eingeben
Falls Python nicht installiert ist, können Sie es über den Paketmanager Ihrer Distribution installieren
- Ubuntu/Debian: sudo apt-get install python3

Installation einer Entwicklungsumgebung (IDE = Integrated Development Environment)#

Um Python Programme zu schreiben braucht man nur einen Texteditor.

Entwicklungsumgebungen sind spezielle Texteditoren, die viele nützliche Funktionen bieten, die das Programmieren erleichtern.
- Syntaxhervorhebung: z.B. Schlüsselwörter werden farbig dargestellt
- Autovervollständigung: Vorschläge für Codevervollständigung
- KI-Unterstützung: z.B. Github Co-Pilot (mehr dazu später)

Es gibt viele verschiedene Entwicklungsumgebungen. Wir werden in dieser Vorlesung Visual Studio Code (VSCode) verwenden.

VSCode ist kostenlos und Open Source
VSCode ist sehr flexibel und kann durch Erweiterungen an die eigenen Bedürfnisse angepasst werden
VSCode ist plattformübergreifend (Windows, MacOS, Linux)

VSCode#

Installation von VSCode#

Laden Sie den Installer von https://code.visualstudio.com/download für Ihr Betriebssystem herunter
Starten Sie den Installer und folgen Sie den Anweisungen
Starten Sie VSCode und installieren Sie die Python Erweiterung
- Klicken Sie auf das Erweiterungssymbol links in der Seitenleiste
- Suchen Sie nach “Python” und installieren Sie die Erweiterung von Microsoft

Bedienung von VSCode#

VSCode arbeitet in Ordnern (Folders)
- Öffnen Sie einen Ordner in VSCode über File -> Open Folder...
  - Zum Beispiel macht es Sinn, für jede Übung einen eigenen Ordner zu erstellen, etwa EPROG_2025/Uebung_1
- Es ist gute Programmierpraxis, für jedes Projekt eine virtuelle Umgebung zu erstellen (Virtual Environments). Alle Änderungen und Pakete, die Sie installieren, werden nur in dieser Umgebung vorgenommen und beeinflussen nicht andere Projekte.
  - Eine einfach Möglichkeit ist venv, das mit Python mitgeliefert wird
  - Drücken Sie Strg+Shift+P und suchen Sie nach “Python: Create Environment”
  - Wählen Sie “venv” und und wählen Sie eine Python Version (z.B. Python 3.x.x)
  - Im Ordner wird ein neuer Unterordner .venv erstellt, der die virtuelle Umgebung enthält (dieser Ordner ist versteckt und kann ignoriert werden)
  - Aktivieren Sie die Umgebung, indem Sie in der Kommandozeile source .venv/bin/activate (Linux/MacOS) oder .venv\Scripts\activate (Windows) eingeben
    - Normalerweise sollte VSCode die Umgebung automatisch erkennen und aktivieren, wenn Sie eine Python Datei öffnen
- Erstellen Sie eine neue Datei über File -> New File mit der Endung .py, z.B. hello.py
  - Den Dateinamen können Sie frei wählen, die Endung .py ist wichtig, damit VSCode erkennt, dass es sich um eine Python Datei handelt
  - Scheiben Sie ein einfaches Programm in die Datei, z.B.
```
print("Hello, World!")
```
  - Speichern Sie die Datei über File -> Save oder Strg+S
- Um das Programm auszuführen, können Sie entweder:
  - Das Play Symbol oben rechts in der Datei klicken
  - Oder die Datei im Terminal ausführen, indem Sie python3 <dateiname>.py eingeben (z.B. python hello.py)
  - Oder in die Datei rechtsklicken und “Run Python File in Terminal” wählen
- In allen Fällen wird das Programm im Terminal unten in VSCode ausgeführt und die Ausgabe angezeigt
- Sie können in einem Ordner beliebig viele Python Dateien erstellen und ausführen

Grundlegende Befehle#

Textausgabe mit `print`#

Der print Befehl erlaubt es, Text am Bildschirm auszugeben. Der Text steht dabei immer in Anführungszeichen. Es können mehrere Texte gleichzeitig ausgegeben werden, welche mit dem Symbol getrennt werden können, das dem optionalen Argument sep übergeben wird.

print("Hello World!")
print("Das", "ist", "1", "Test")
print("Das", "ist", "1", "Test", sep="-")

Hello World!
Das ist 1 Test
Das-ist-1-Test

Das end Schlüsselwort spezifiziert, wie die Zeile beendet wird. Standardmäßig kommt ein Zeilenumbruch mit “\n”.

print("Hello World", end="\n")
print("Das", "ist", "1", "Test")

print("Hello World", end="")
print("Das", "ist", "1", "Test")

Hello World
Das ist 1 Test
Hello WorldDas ist 1 Test

Arithmetische Operationen#

Python beherrscht die üblichen Rechenregeln and versteht Klammersetzung

4+3

5*6+3

(6-4)/10

0.2

Das ist verträglich mit print

print("2/3 =", 2/3)

2/3 = 0.6666666666666666

Besonderheiten:

Dezimalpunkt (statt Komma, wie im Deutschen oft üblich)
Potenzierung mit ** und ganzzahlige Division mit //
Divisionsrest mit % (Modulo Operation)
Absolutbetrag mit abs()

print("Pi is approximately", 3.14)

Pi is approximately 3.14

3**2

4**0.5

2.0

13//2

13%2

abs(-5)

Variablen in Python#

Variablen in Python haben im Unterschied zur Mathematik (oder manchen anderen Programmiersprachen) immer einen fixen Wert. Zum Beispiel statt \(x\in \mathbb{R}\) muss man konkret \(x=3.14\) angeben. Dieser Wert kann allerdings beliebig oft geändert werden

x = 3.14
print("Pi is approximately", x)
x = 3
print("Pi is roughly", x)
y = 2*x + 5
print("y =", y)

Pi is approximately 3.14
Pi is roughly 3
y = 11

Variablennamen dürfen (fast) beliebig gewählt werden

es dürfen Buchstaben, Zahlen und Unterstriche vorkommen (aber z.B. keine Leerzeichen)
das erste Zeichen darf keine Zahl sein (z.B. 2pac ist verboten)

Die folgenden Schlüsselwörter sind für Python Befehle reserviert und dürfen daher nicht verwendet werden

  False, def, if, raise, None, del, import, return, True, elif, in, try, and, else, is, while, as, except, lambda,
  with, assert, finally, nonlocal, yield, break, for, not, class, from, or, continue, global, pass

Konvention: Man verwendet den sogenannten ‘snake case’, indem man alles klein schreibt und Leerzeichen durch Unterstriche _ ersetzt
- z.B. first_name oder integral_value
- Wichtig: Variablennamen sollten erklären, wofür die Variable verwendet wird (hilft später bei der Fehlersuche und beim Verstehen von Code)

Variablen können mit dem Befehl input auch von der Tastatur eingelesen werden. Achtung: es wird nicht überprüft, ob tatsächlich das Gewünschte eingegeben wird!

age = input("Enter your age: ")
first_name = input("Enter your first name: ")
last_name = input("Enter your last name: ")
print(first_name, last_name, "is", age, "years old.")

Michael Feischl is 99 years old.

Formatierte Ausgabe mit `format`#

Hier ist es oft schöner, die Ausgabe zu formatieren: Mit {:x.yf} kann man im Text Platzhalter einfügen, die dann mit format befüllt werden. Hier gibt x die minimale Gesamtanzahl der Stellen (inklusive Dezimalpunkt) und y die Anzahl der Nachkommastellen an. Beides oder y kann man weglassen.

x = 2/3
print("2/3 = {:4.2f}".format(x))
print("2/3 = {:5.3f}".format(x))
print("2/3 = {:6.3f}".format(x))
print("2/3 = {:.3f}".format(x))
print("2/3 = {:f}".format(x))

2/3 = 0.67
2/3 = 0.667
2/3 =  0.667
2/3 = 0.667
2/3 = 0.666667

Das funkioniert auch mit mehreren Platzhaltern

print("2/3 is approximately {:.2f}, or more precisely {:.5f}".format(2/3,2/3))

2/3 is approximately 0.67, or more precisely 0.66667

Kurzschreibweise: Statt .format(...) kann man auch f-Strings verwenden: f"..." und Platzhalter in geschweifte Klammern setzen.

x = 2/3
y = 3.14159
print(f"{x:4.2f} ist kleiner als {y}")

0.67 ist kleiner als 3.14159

Sonderzeichen: Will man ein Anführungszeichen oder einen Backslash am Bildschirm ausgeben, muss man diesen mit einem Backslash maskieren. Beispiel: \" für ein Anführungszeichen und \\ für einen Backslash.

Achtung: Will man in f-Strings geschungene Klammern in { oder } ausgeben, muss man doppelte Klammern verwenden: {{ oder }}.
- In normalen Strings (ohne f) ist das nicht notwendig.
Anstelle der Anführungszeichen, kann man auch einfache Anführungszeichen verwenden, z.B. print('Hello "World"').

pi = 3.14159
print(f"{pi:.2f} wird auch als \"Kreiszahl\" bezeichnet.")
print(f'{pi:.2f} wird auch als "Kreiszahl" bezeichnet.')
print("Ich fühle mich \\o/")
print(f"Die Menge der geraden Zahlen ist {{2,4,6,8,...}} und pi ist ungefähr {pi:.2f}.")

3.14 wird auch als "Kreiszahl" bezeichnet.
3.14 wird auch als "Kreiszahl" bezeichnet.
Ich fühle mich \o/
Die Menge der geraden Zahlen ist {2,4,6,8,...} und pi ist ungefähr 3.14.

Bemerkung: Kommentare in Python#

Kommentare in Python beginnen mit # und gehen bis zum Ende der Zeile. Kommentare werden vom Interpreter ignoriert und dienen dazu, den Code zu dokumentieren und verständlicher zu machen (siehe auch weiter unten im Kapitel “Kommentare im Code”).

x=4 # Kommentar: Weist der Variable x den Wert 4 zu

Einfache Datentypen in Python#

Da im Computer alles in Bits gespeichert wird (0 oder 1), muss man festlegen, wie verschiedene Folgen von Bits interpretiert werden sollen. Diese Festlegung nennt man Datentyp. Einige der wichtigsten einfachen Datentypen in Python sind:

int: Ganze Zahlen (beliebig groß, nur durch den Speicher begrenzt)
float: Gleitkommazahlen (ca. 15-17 signifikante Stellen)
complex: Komplexe Zahlen (z.B. 3 + 4j). Hier ersetzt j die imaginäre Einheit \(i\), die in der Mathematik üblich ist
str: Zeichenketten (Strings), z.B. "Hallo Welt!"

In Python bestimmt man den Datentyp einer Variable einfach durch die Definition. Im Beispiel unten ist:

x vom Typ float (für Dezimalzahlen),
y vom Typ int (für ganze Zahlen ‘Integer’),
c vom Typ complex (für komplexe Zahlen, j ersetzt die imaginäre Einheit \(i\))
und name vom Datentyp str (für Text ‘String’ = Zeichenkette).

Das kann man mit dem Befehl type überprüfen.

x = 3.14
y = 10
c = 3 + 4j
name = "Peter"
print(type(x),type(y),type(c),type(name))

<class 'float'> <class 'int'> <class 'complex'> <class 'str'>

Datentypen `int` und `float`#

Im Kapitel ‘Zahldarstellung am Computer’ werden wir dazu noch mehr lernen. Jetzt reicht es zu wissen, dass Rechnungen mit float immer (kleine) Rundungsfehler haben können, wohingegen Rechnungen mit int exakt sind.

Bei float kann man die 0 vor oder nach dem Dezimalpunkt weglassen (z.B. .5 statt 0.5 oder 2. statt 2.0)
Bei Rechnungen mit verschiedenen Zahldatentypen wird das Ergebnis immer im mächtigeren Datentyp berechnet!

x = 2
y = 3.14
print(x*y, type(x),type(y),type(x*y))
x = 2/3
y = 3
print(x*y, type(x),type(y),type(x*y))
x = 1j 
print(x**2, type(x),type(x**2))

6.28 <class 'int'> <class 'float'> <class 'float'>
2.0 <class 'float'> <class 'int'> <class 'float'>
(-1+0j) <class 'complex'> <class 'complex'>

Große und kleine Zahlen: Große und kleine Zahlen können mit e für den Exponenten dargestellt werden, z.B. 1.5e3 für \(1.5 \cdot 10^3 = 1500\) und 2.5e-4 für \(2.5 \cdot 10^{-4} = 0.00025\).

x  = 1e3 
print(x)
y = 5e-4
print(y)

1000.0
0.0005

Python wählt für die Ausgabe von float automatisch eine geeignete Darstellung (normal oder wissenschaftlich) und rundet dabei gegebenenfalls. Mit f-Strings oder format kann die Darstellung jedoch angepasst werden.

print(f"x = {x:.2e}")
print(f"y = {y:.4f}")

x = 1.00e+03
y = 0.0005

Datentyp `complex`#

Für complex gibt es noch die Befehle

conjugate(): rechnet die konjugierte Zahl aus, also \(a+ib\) wird zu \(a-ib\)
imag, real: liefern den imaginären und realen Teil der Zahl (als float Zahl)
abs(): liefert den Betrag der komplexen Zahl (Länge des Vektors im komplexen Zahlenraum)

x = 4 + 3j
print(x,x.conjugate(),x.imag, x.real, abs(x))

(4+3j) (4-3j) 3.0 4.0 5.0

Datentyp `str`#

Strings kann man addieren und es gibt die Befehle

lower(): alles in Kleinbuchstaben
upper(): alles in Großbuchstaben
swapcase(): wechselt zwischen Klein- und Großbuchstaben
split(): zerlegt einen Text in durch Leerzeichen getrennte Teile (durch ein optionales Argument kann angegeben werden, an welcher Teilzeichenfolge die Trennung erfolgen soll)
replace(): ersetzt Teile eines Strings durch einen anderen String
strip(): entfernt Leerzeichen am Anfang und Ende des Strings sowie Zeilenumbrüche

first_name = "Peter"
last_name = "Parker"
print(first_name + " " + last_name)
print(3*first_name)

print(first_name.lower())
print(first_name.upper())
print(first_name.swapcase())
print("This is a test".split())
print("This is a test".split(" a "))
print("This is a test".replace("is","was"))
print("This is a test".replace(" is ", " was "))

Peter Parker
PeterPeterPeter
peter
PETER
pETER
['This', 'is', 'a', 'test']
['This is', 'test']
Thwas was a test
This was a test

Umwandeln von Datentypen#

Man kann Datentypen ineinander umwandeln. Dabei geht manchmal Information verloren, z.B.

x = 3.14
y = int(x)
print(x,y,type(x),type(y))
z = float(y)
print(z,type(z))

number = "3.14"
x = float(number)
print(number, type(number), x, type(x))

14 3 <class 'float'> <class 'int'>
0 <class 'float'>
14 <class 'str'> 3.14 <class 'float'>

Achtung, der von input() eingelesene Wert ist immer ein String str und muss bei Zahlen daher erst umgewandelt werden.

x = input("Enter a number: ")
print(x, type(x))
y = float(x)
print("x^2 =", y**2)

10 <class 'str'>
x^2 = 100.0

Überprüfen von Datentypen mit `isinstance`#

Mit isinstance(var, type) kann überprüft werden, ob var vom Typ type ist

print(isinstance(3.14, float))
print(isinstance(3, int))
print(isinstance("Hello", str))
print(isinstance(3+4j, complex))
print(isinstance(3.14, int))

True
True
True
True
False

Achtung: in Python ist 3.0 nicht dasselbe wie 3

3.0 ist ein float
3 ist ein int

print(isinstance(3.0, int))
print(isinstance(3, int))

False
True

Datentyp `None`#

None ist ein spezieller Datentyp, der verwendet wird, um das Fehlen eines Wertes zu kennzeichnen
None ist nützlich, um anzuzeigen, dass eine Variable noch nicht initialisiert wurde oder dass eine Funktion keinen Wert zurückgibt
None ist nicht dasselbe wie 0, False oder ein leerer String ""

x = None
print(x)

None

Zuweisungsoperator `=`#

Achtung das Zeichen = ist eine Zuweisung und kein Vergleich

Zuweisung immer von rechts nach links
x = 1 gibt der Variable x den Wert 1
x = y gibt der Variable x den Wert von y. Insbesondere haben danach x und y den selben Wert (Vertauschen von Werten funktioniert mit Hilfsvariable)

x = 1
y = 2
print(x, y)
tmp = x
x = y
y = tmp
print(x, y)
x = y
print(x, y)

2
1
1

Selbstzuweisung mit Arithmetik: Der Zuweisungsoperator kann mit den arithmetischen Operationen +, -, *, **, /, // kombiniert werden um Platz zu sparen

x = 1
y = x + 2
x += 2
print(x, y)
x *= 3
print(x)
x **= 2
print(x)
name = "Peter"
name += " Parker"
print(name)

3 3
9
81
Peter Parker

Mehrfachzuweisung: Der Zuweisungsoperator kann mehrere Variablen gleichzeitig zuweisen. Dies kann man verwenden, um zwei Variablen ohne Hilfsvariable zu vertauschen.

x, y = 1, 2
print("x=", x, ", y=", y)
x, y = y, x
print("x=", x, ", y=", y)

x= 1 , y= 2
x= 2 , y= 1

Zeilenumbruch in Python Code#

Wenn eine Codezeile zu lang wird, kann man in Python meistens einfach in der nächsten Zeile weiterschreiben.

Python erkennt automatisch, dass die Anweisung noch nicht abgeschlossen ist.
Man kann auch Klammern verwenden, falls ansonsten nicht klar ist, dass die Anweisung noch nicht abgeschlossen ist.
Eine alte und nicht mehr so häufig verwendete Möglichkeit ist der Backslash \ am Ende der Zeile, der anzeigt, dass die Anweisung in der nächsten Zeile fortgesetzt wird. Ein Fehler wird angezeigt, wenn der Zusammenhang von zwei Zeilen nicht eindeutig gekennzeichnet wurde.

result = (1 + 2 + 3 +
            4 + 5 + 6)
result = 1 + 2 + 3 + \
            4 + 5 + 6
result = 1 + 2 + 3 +
            4 + 5 + 6

  Cell In[34], line 5
    result = 1 + 2 + 3 +
                        ^
SyntaxError: invalid syntax

Fehler#

Es gibt verschiedene Arten von Fehlern:

Syntaxfehler#

Syntax bezeichnet den Wortschatz und die Grammatik einer Programmiersprache.
Ein Syntaxfehler tritt auf, wenn die Syntaxregeln verletzt werden.
Beispiele:
- Falsche Einrückung
- Fehlende Klammern
- Falsche Verwendung von Schlüsselwörtern
Der Interpreter meldet Syntaxfehler sofort beim Einlesen des Programms.

print("Hello World"

  Cell In[148], line 1
    print("Hello World"
                       ^
SyntaxError: incomplete input

iput("Enter your age: ")

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[149], line 1
----> 1 iput("Enter your age: ")

NameError: name 'iput' is not defined

Laufzeitfehler#

Ein Laufzeitfehler tritt während der Programmausführung auf.
Oft gibt es keine Fehlermeldung.
Das Programm strürzt einfach ab oder verhält sich unerwartet.
Beispiele:
- Division durch Null
- Zugriff auf nicht existierende Dateien
- Zugriff auf nicht definierte Variablen
- Falscher Datentyp (z.B. String statt Zahl)
Laufzeitfehler sind oft schwer zu finden und lassen sich nur durch sorgfältiges Testen vermeiden und beheben.

a = 10
b = 0
result = a / b 

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[150], line 3
      1 a = 10
      2 b = 0
----> 3 result = a / b 

ZeroDivisionError: division by zero

Module in Python#

Python hat eine große Anzahl an eingebauten Modulen, die viele nützliche Funktionen bereitstellen.
Module sind Sammlungen von Funktionen und Variablen, die in einer Datei gespeichert sind.
Module können mit dem Befehl import eingebunden werden.
Um eine Funktion aus dem Modul zu verwenden muss der Modulname vorangestellt werden, z.B. math.sqrt(4) um die Quadratwurzel zu berechnen.
Man kann einzelene Funktionen oder Variablen mit from ... import ... importieren. Dann kann man sie ohne den Modulnamen verwenden.
Man neue Namen für Module oder Funktionen mit as vergeben.

Einfache Beispiele sind das math Modul für mathematische Funktionen und Konstanten, das random Modul für Zufallszahlen, oder das time Modul für Zeitfunktionen. Wir werden später noch weitere Module kennenlernen.

import math
from math import sqrt, pi
import random as rnd
from time import time 

print("Squareroot of 16 =", sqrt(16))
print("Value of pi =", pi)
print("Cosine of pi =", math.cos(pi))
print("Random number between zero and one =", rnd.random())
print("Current time in seconds since 01.01.1970 =", time())

Squareroot of 16 = 4.0
Value of pi = 3.141592653589793
Cosine of pi = -1.0
Random number between zero and one = 0.4176393876046519
Current time in seconds since 01.01.1970 = 1759394739.209932

Beim Einbinden von Modulen wird standardmäßig der gesamte Code des Moduls ausgeführt. Das kann unnötige Resourcen verbrauchen. Um dies zu vermeiden sollten man möglichst nur die benötigten Funktionen importieren.

Wir listen einige wichtige Funktionen des Moduls math auf:

math.sqrt(x): Quadratwurzel von x
math.exp(x): Exponentialfunktion \(e^x\)
math.log(x[, base]): Logarithmus von x zur Basis base (Standard: natürlicher Logarithmus)
math.sin(x), math.cos(x), math.tan(x): trigonometrische Funktionen (Winkel in Bogenmaß)
math.asin(x), math.acos(x), math.atan(x): Arkusfunktionen (Winkel in Bogenmaß)
math.sinh(x), math.cosh(x), math.tanh(x): hyperbolische Funktionen
math.pi: die Kreiszahl \(\pi \approx 3.141592653589795\)
math.e: die Eulersche Zahl \(e \approx 2.718281828459045\)

Weitere wichtige Funktionen des Moduls random sind:

random.random(): Zufallszahl im Intervall [0.0, 1.0)
random.randint(a, b): Zufallszahl im Intervall [a, b] (inklusive a und b)
random.uniform(a, b): Zufallsinteger im Intervall [a, b) (inklusive a, aber exklusive b)
random.choice(seq): zufälliges Element aus der Sequenz seq (z.B. Liste oder String -> siehe später)