SCHNELL SEIN WIE NUMPY

Flow-Chart Flow-Chart

Numpy ist ein Python Module und der defacto Standard für das numerische Rechnen in Python. Mit numpy kann man sehr effektiv und vorallem sehr schnell mit numerischen Daten rechnen. Dies wird vor allem deutlich, wenn man mit großen Daten arbeitet, weshalb numpy ein Basisbestandteil der Data Science in Python ist.

Instalation:

  • VM:

    1. Terminal öffnen
    2. sudo apt install python-numpy in die Konsole eingeben und Passwort eingeben. sudo steht für super-user do und ist nötig um die nötigen Rechte für die ausführung von apt install python-numpy zu bekommen (über das Passwort). apt ist auf Linux Mint der Packetmanager, ein Programm welches Packete herunterlädt, installiert und verwaltet. Mit der Option install und dem Argument python-numpy wird das numpy Packet installiert.
    3. fertig :)

  • Linux:

    1. Auf Debian/Ubuntu/Mint siehe VM (ggf. heißt das Paket dann aber python3-numpy). Sonst entweder über vorhandenen Packetmanager installieren oder mit pip, dazu einfach pip install numpy in die Konsole eingeben (dazu muss pip installiert sein)

  • MacOS & Windows:

    1. Terminal/CMD öffnen
    2. Mit pip sollte man mypy instalieren können: pip install numpy eingeben in Terminal/CMD. Dazu muss pip auf ihrem Rechner installiert sein.
    3. Fall dies nicht funktioniert hat, selbst recherchieren oder Tutor fragen. Oder einfach die VM nutzen und sich im Vorkurs, die AlPro und im Praktikum OOSE ganz viel Arbeit sparen! :)

Aufgabe

Diese Aufgabe dient nur der Einführung von numpy und ist für den Vorkurs ansich nicht relevant. An dieser Aufgabe sollen einige Vorteile von numpy ersichtlich werden.

Erstmal eine grobe Einleitung zum Umgang mit numpy:

Nach dem installieren muss numpy included werden, es ist dabei sehr gewöhnlich numpy als np zu includen:

import numpy as np

Der meist verwendete Typ in numpy sind ndarrays, Objekte dieser Klasse nennt man oft numpy-arrays. Man erstellt ein numpy-array ganz einfach in dem man der Funktion np.array eine python-liste mit dem gewünschten Elementen übergibt.

import numpy as np

python_list = [1, 2, 3]
np_array = np.array(python_array)
print(np_array)

# Output: [1 2 3]

Die Elemente sollten im Idealfalls gleich sein, sonst versucht numpy diese auf den kleinstne gemeinsamen Nenner zu casten (upcasting):

import numpy as np

np_array = np.array([1, 2, 3.2])

print(np_array)

# Gibt den Typ der Elemente
print(np_array.dtype)

# Elemente wurden auf float upgecastet

# Output: [1.  2.  3.2]
#         float64

Auf Elemente lässt sich ganz einfach per Index zugreifen:

import numpy as np

np_array = np.array([1, 2, 42])
print(np_array[2])

# Output: 42

numpy-arrays haben viele Attribute:

import numpy as np

np_array = np.array([1, 2, 3])

print(np_array)

# Dimension des Arrays (mehr dimensionale Arrays sind möglich, siehe 2)
dim = np_array.ndim

# Länge des Arrays entlang der Dimensionen, vor allem bei mehrdimensionalen Arrays wichtig
length = np_array.shape

# Anzahl Elemente im Array. Bei eindimenionsalen Arrays ist diese gleich der Länge
size = np_array.size

# Typ der Elemente im Array
type_of_elements = np_array.dtype

print(f"Dimension: {dim}\nLänge: {length}\nAnz. Elemente: {size}\nTyp der Elemente: {type_of_elements}")

# Output:
# [1  2  3]
# Dimension: 1
# Länge: (3,)
# Anz. Elemente: 3
# Typ der Elemente: int64

und natürlich viele Operatoren, hier die Basics:

import numpy as np

np_array_1 = np.array([1, 2, 3])
np_array_2 = np.array([2, 3, 3])

# Komponentennweise Addition:
print(np_array_1 + np_array_2)

# Komponentennweise Subtraktion:
print(np_array_1 - np_array_2)

# Negatives Array bilden
print(-np_array_1)

# Komponentennweise Multiplkation
print(np_array_1 * np_array_2)

# Komponentennweise Devision
print(np_array_1 / np_array_2)

# Komponentennweise Modularrechnung
print(np_array_1 % np_array_2)

# Output:   [3 5 6]
#           [-1 -1  0]
#           [-1 -2 -3]
#           [2 6 9]
#           [0.5        0.66666667 1.        ]
#           [1 2 0]
1.

Wir wollen erstmal simpel anfangen: Erstellen Sie eine Funktion, welche einen Integer n bekommt und ein numpy-array zurückgibt, welches n zufällige Elemente enthält, mit der Bedingung, dass die Summe aller Einträge 42 ergibt.

Dazu können Sie die Funktion random aus dem random Modul nutzen, welche ein zufällige Zahl zwischen 0 und 1 zurückgibt

from random import random

print(random())
2.

Eines der größten Vorteile von numpy ist die Perfomance. numpy braucht weniger Speicher, Zeit und Energie für Berechnungen (Umweltfreundlicher :o). Dies wird vor allem deutlich, wenn man mit mehrdimensionalen Arrays arbeitet.

Nun zu der Aufgabe:

Erstellen Sie eine Funktion, welche

  • zwei Interger n und m bekommt und eine list erstellt mit n-lists welche jeweils m zufällige Einträge enthalten. Die Funktion soll dann den Durschnitt über alle Einträge berechnen.
  • dasselbe tut, jedoch nur mit numpy-arrays arbeitet statt lists. Dazu können Sie den praktischen Konstruktur nutzen, den numpy zu Verfügung stellt sowie die numpys sum() Funktion:
import numpy as np

numpy_array_mit_drei_random_numpy_arrays_mit_jeweils_drei_einträgen = np.random.random((3, 3))

print(numpy_array_mit_drei_random_numpy_arrays_mit_jeweils_drei_einträgen)

summe = np.sum(numpy_array_mit_drei_random_numpy_arrays_mit_jeweils_drei_einträgen)

print(summe)

# Output: [[0.54744889 0.02900172 0.95388247]
#          [0.25985545 0.98758495 0.74089727]
#          [0.58834673 0.07858967 0.19683383]]
#         4.3824409905538095

Messen Sie schließlich wie lange es dauert, die beiden Funktionen jeweils bei gleichen Parametern, auszuführen. Dafür können Sie die Funktion time aus dem time Modul nutzen:

from time import time

# Gibt die Zeit in Sekunden seit dem ersten Januar 1970 zurück
zeit_vor_coole_funktion = time()

coole_funktion()

zeit_für_coole_funktion = time() - zeit_vor_coole_funktion

Tun Sie dies für verschieden Parameter unterschiedlicher Größenordnungen.

Flow-Chart Flow-Chart