Arrayerstellung#
In den Grundlagen zur Arrayserstellung haben Sie bereits einige Möglichkeiten kennengelernt, um Arrays zu erzeugen. Insbesondere Methoden zur manuellen Arrayerstellung, Erstellung von Vektoren mit gleichmäßigen Abständen und Arrayerstellung mit Hilfe von Funktionen.
In diesem Kapitel sollen Sie die gelernten Aspekte wiederholen, um diese elementaren Operationen zu festigen und im nächten Kapitel zu vertiefen.
Wiederholung Arrayerstellung#
Aufgabe 1.1
Erstellen Sie einen Vektor mit dem Namen \(x\) mit den Elementen \(2\), \(\sin(\pi)\) und \(\sqrt{36}\).
# Ihr Code
Hinweis
Verwenden Sie die Funktion \(\texttt{np.array}\) und eckige Klammern (\(\texttt{[]}\)), um den Vektor zu erstellen. Die verwendeten Funktionen und Werte könne Sie mittels \(\texttt{np.sin}\), \(\texttt{np.pi}\) und \(\texttt{np.sqrt}\) ausdrücken. Vergessen Sie nicht, die notwendigen Pakete zu importieren.
Lösung
import numpy as np
x = np.array([2, np.sin(np.pi), np.sqrt(36)])
print(x)
Aufgabe 1.2
Erstellen Sie eine Matrix mit dem Namen \(A\) und diesen Werten:
# Ihr Code
Hinweis
Verwenden Sie die Funktion \(\texttt{np.array}\) und eckige Klammern (\(\texttt{[[],[]]}\)), um die Matrix zu erstellen
Lösung
A = np.array([[1 2 3 4],[5 6 7 8]])
print(A)
Aufgabe 1.3
Erstellen Sie den Vektor \(\texttt{x_absteigend}\) mit den Werten
mit Hilfe von in NumPy enthaltenen Funktionen.
# Ihr Code
Hinweis
Nutzen Sie die Funktion \(\texttt{np.arange(startwert, endwert, abstand)}\).
Lösung
x_absteigend = np.arange(55, 37, 3)
print(x_absteigend)
Aufgabe 1.4
Erstellen Sie den Vektor \(\texttt{x_pi}\), welcher bei \(-\pi\) startet und bei \(3\pi\) endet. Der Vektor soll \(50\) Elemente enthalten und der Abstand zwischen zwei benachbarten Einträgen soll konstant sein.
# Ihr Code
Hinweis
Nutzen Sie die Funktion \(\texttt{np.linspace(startwert, endwert, anzahl_elemente)}\).
Lösung
x_pi = np.linspace(-np.pi, 3*np.pi, 50)
print(x_pi)
Arrayerstellung mittels Funktionen#
Um Matrizen mit gewisser Struktur zu erzeugen, haben Sie bereits einige Methoden kennengelernt, zum Beispiel \(\texttt{np.zeros()}\) und \(\texttt{np.ones()}\). In der Numerik benötigen wir häufig die Einhheitsmatrix sowie Diagonal- und Dreieckmatrizen. Auch für solche Matrizen stellt NumPy entsprechende Funktionen zur Erstellung bereit. Wir beginnen mit der Einheitsmatrix. Mit \(\texttt{np.eye(n)}\) erstellt man eine \(n\)-dimensionale Einheitsmatrix.
Aufgabe 2.1
Erstellen Sie die \((4 \times 4)\) Matrix \(\texttt{A_nur5}\), bei der jeder Eintrag die Zahl \(5\) ist. Berechnen Sie anschließend mit Hilfe der erstellten Matrix \(\texttt{A_nur5}\), die Matrix \(\texttt{A_nur45}\), bei der alle Einträge \(5\) sind außer die Diagonaleinträge. Diese enthalten den Wert \(4\).
# Ihr Code
Hinweis
Verwenden Sie die Funktion \(\texttt{np.ones([zeilen, spalten])}\) und multiplizieren Sie die Matrix mit dem passenden Faktor. Nutzen Sie anschließend \(\texttt{np.eye(dimension)}\), um von jedem Diagonaleintrag \(1\) abzuziehen.
Lösung
A_nur5 = 5*np.ones([4,4])
A_nur45 = A_nur5 - np.eye(4)
print(A_nur45)
Nun schauen wir uns Diagonalmatrizen an. Diese können Sie in NumPy mit dem Befehl \(\texttt{np.diag}\) erzeugen. Der Code \(\texttt{np.diag([1, 2, 3])}\) erstellt eine \((3 \times 3)\) Diagonalmatrix, mit den Einträgen \(1\), \(2\) und \(3\) auf der Diagonalen.
A = np.diag([1, 2, 3])
print(A)
Aufgabe 2.2
Erstellen Sie die Matrix \(\texttt{A_diagonal}\) mit den Werten:
# Ihr Code
Lösung
A_diagonal = np.diag([12, -3, 3, 0])
print(A_diagonal)
Zudem gibt es Methoden obere und untere Dreiecksmatrizen zu erzeugen. Die Funktion \(\texttt{np.tri(n)}\) erstellt eine \(n\)-dimensionale untere Dreiecksmatrix mit \(1\) auf und unterhalb der Diagonalen. Der Ausdruck \(\texttt{np.triu(A)}\) transformiert eine quadratische Matrix \(A\) in eine obere Dreiecksmatrix, indem er alle Einträge unterhalb der Diagonalen auf \(0\) setzt. Analog transformiert die Funktion \(\texttt{np.tril(A)}\) die quadratische Matrix \(A\) in eine untere Dreiecksmatrix.
# Matrix aus A3.1
A = 5*np.ones([4,4]) - np.eye(4)
# löscht alle Einträge oberhalb der Diagonalen
A_untere_dreieck = np.tril(A)
print(A_untere_dreieck)
Aufgabe 2.3
Erstellen Sie die Matrix \(\texttt{A_kein_dreieck}\) mit den Werten:
Nutzen Sie dabei die Summe zweier Dreiecksmatrizen.
# Ihr Code
Hinweis
Verwenden Sie \(\texttt{np.tri}\), um eine untere Dreiecksmatrix zu erstellen, und \(\texttt{np.ones}\) sowie \(\texttt{np.triu}\), um eine obere Dreiecksmatrix zu erstellen.
Lösung
A_tri = np.tri(3)
A_obere_dreieck = np.triu(2*np.ones(3))
A_kein_dreieck = A_tri + A_obere_dreieck
print(A_kein_dreieck)
Neben Funktionen, die strukturierte Matrizen erzeugen, gibt es auch Funktionen, die Matrizen mit zufälligen Einträgen erstellen. Eine solche Funktion haben Sie bereits bei den Grundlagen zur Arrayserstellung kennen gelernt: \(\texttt{np.random.rand}\). Diese Funktion generiert gleichverteilte Zufallszahlen im Intervall \([0,1]\). Zudem existiert die Funktion \(\texttt{np.random.randn}\), welche standardnormalverteilte Zufallszahlen erzeugt. Zum Beispiel der Ausdruck \(\texttt{np.random.randn(3,2)}\) erstellt eine \((3 \times 2)\) Matrix mit standardnormalverteilten Einträgen.
Aufgabe 2.4
Erstellen Sie eine \((200 \times 200)\) Matrix \(\texttt{A_uniform}\), die zufällig gleichverteilte Einträge zwischen \(0\) und \(1\) annimmt, sowie eine \((200 \times 200)\) Matrix \(\texttt{A_normal}\), die standardnormalverteilte Zufallszahlen beinhaltet. Vergleichen Sie die maximalen Einträge beider Matrizen.
# Ihr Code
Hinweis
Verwenden Sie die Funktionen \(\texttt{np.random.rand}\) und \(\texttt{np.random.randn}\), um die Matrizen zu erzeugen. Nutzen Sie anschließend \(\texttt{.max()}\), um den maximalen Wert zu extrahieren.
Lösung
A_uniform = np.random.rand(200,200)
A_normal = np.random.randn(200,200)
print('Der maximale Wert der uniform verteilten Matrix ist', A_uniform.max(),'und der der gleichverteilten ist', A_normal.max(),'.')
# Beobachtung: Der gleichverteilte maximale Wert ist nahe bei 1, der normalverteilte deutlich über 1.
Für manche Anwendung möchte man zufällige ganze Zahlen erzeugen. Auch dafür bietet NumPy eine Funktion: die Funktion \(\texttt{np.random.randint}\), welche 3 Eingabeparameter hat:
Die Funktion gibt nun ein Array der Größe \(\texttt{size}\) aus, welche gleichmäßig verteilte ganze Zahlen aus dem Intervall \([\texttt{min_wert},\texttt{max_wert})\) als Einträge besitzt. Der Ausdruck \(\texttt{np.random.randint(0, 10, (2,3))}\) erzeugt eine \((2 \times 3)\) Matrix, die nur ganze Zahlen zwischen \(0\) und \(9\) annimmt. Beachten Sie auch hier wieder, dass die obere Grenze, die man angibt nicht angenommen wird.
A_randint = np.random.randint(0, 10, (2,3))
print(A_randint)
Aufgabe 2.5
Erstellen Sie eine \((200 \times 200)\) Matrix \(\texttt{A_ganzzahlig}\), die zufällige ganzzahlige Einträge zwischen \(-3\) und \(4\) annimmt. Betrachten Sie anschließend den maximalen Wert der Matrix.
# Ihr Code
Lösung
A_ganzzahlig = np.random.randint(-3,5,(200,200))
print('Der maximale Wert der gleichverteilten, ganzzahligen Matrix ist', A_ganzzahlig.max(),'.')
Möchten Sie Zahlen innerhalb des Intervalls \([\texttt{min_wert},\texttt{max_wert})\) erzeugen, die nicht zwingend ganzzahlig sind, können Sie auf die bereits bekannte Funktion \(\texttt{np.random.rand}\) zurückgreifen. Dabei müssen die so erzeugten Zufallszahlen geeignet skaliert werden. Dies erreichen sie mit Hilfe der Tansformation
Der Code \(\texttt{4 + (12 - 4) * np.random.rand(3,2)}\) erzeugt eine \((3 \times 2)\) Matrix, die beliebige rationale Zahlen zwischen \(4\) und \(12\) annimmt.
# erzeugt 3 x 2 Matrix mit beliebigen rationalen Zahlen zwischen 4 und 12
A_rational = 4 + (12 - 4) * np.random.rand(3,2)
print(A_rational)
Aufgabe 2.6
Erstellen Sie eine \((200 \times 200)\) Matrix \(\texttt{A_nicht_ganzzahlig}\), die zufällige rationale Einträge zwischen \(-3\) und \(4\) annimmt. Betrachten Sie anschließend den maximalen Wert der Matrix.
# Ihr Code
Hinweis
Verwenden Sie die Funktion \(\texttt{np.random.rand}\) und skalieren Sie diese geeignet, um die Matrix zu erzeugen. Nutzen Sie anschließend \(\texttt{.max()}\), um den maximalen Wert zu extrahieren.
Lösung
A_nicht_ganzzahlig = - 3 + 7 * np.random.rand(200,200)
print('Der maximale Wert der gleichverteilten, rationalen Matrix ist', A_nicht_ganzzahlig.max(),'.')
Nach einem ähnlichen Vorgehen können Sie normalverteilte Zufallszahlen mit Erwartungsert \(\texttt{nu}\) und Standardabweichung \(\texttt{sigma}\) generieren. Dazu verwenden wir erneut \(\texttt{np.random.randn}\) und skalieren mit der folgenden Transformation:
Der Code \(\texttt{-1 + 3 * np.random.randn(3,2)}\) erzeugt eine \((3 \times 2)\) Matrix, die normalverteilte Zahlen mit Erwartungswert \(-1\) und Standardabweichung \(3\) annimmt.
# erzeugt 2 x 3 Matrix mit normalverteilte Zahlen zwischen mit Erwartungswert -1 und Standardabweichung 3
A_normal_skaliert = -1 + 3 * np.random.randn(3,2)
print(A_normal_skaliert)
Aufgabe 2.7
Erstellen Sie eine \((200 \times 200)\) Matrix \(\texttt{A_normal2}\), die standardnormalverteilte Zufallszahlen mit Erwartungswert \(2\) uns Standardabweichung \(0.5\) annimmt. Betrachten Sie anschließend den maximalen Wert der Matrix.
# Ihr Code
Lösung
A_normal2 = 2 + 0.5 * np.random.randn(200,200)
print('Der maximale Wert der gleichverteilten, rationalen Matrix ist', A_normal2.max(),'.')
Übersicht der Matrix- und Vektor-Funktionen#
Abschließend möchten wir Ihnen noch eine grobe Übersicht über die Funktionen zum Erzeugen von Matrizen und Vektoren geben. Dabei haben wir die Liste um ein paar nützliche Befehle erweitert, die wir in diesem Kurs nicht explizit verwenden, die aber durchaus von Nutzen sein können.
Erstellen von Vektoren#
Funktion |
Beschreibung |
Beispiel |
|---|---|---|
\(\texttt{np.arange(start, stop, step)}\) |
Erzeugt Werte von \(\texttt{start}\) bis \(\texttt{stop}\) mit einer Schrittweite von \(\texttt{step}\). |
\(\texttt{np.arange(0, 5, 1)}\) \(\rightarrow \begin{bmatrix} 0. & 1. & 2. &. 3. & 4. \end{bmatrix}\) |
\(\texttt{np.linspace(start, stop, num)}\) |
Erzeugt gleichmäßig verteilte Zahlen zwischen \(\texttt{start}\) und \(\texttt{stop}\). |
\(\texttt{np.linspace(0, 1, 5)}\) \(\rightarrow \begin{bmatrix} 0. & 0.25 & 0.5 & 0.75 & 1. \end{bmatrix}\) |
\(\texttt{np.logspace(start, stop, num)}\) |
Erzeugt logarithmisch verteilte Zahlen zwischen \(\texttt{10^\text{start}}\) und \(\texttt{10^\text{stop}}\) |
\(\texttt{np.logspace(0, 2, 5)}\) \(\rightarrow \begin{bmatrix} 1. & 3.162 & 10. & 31.62 & 100. \end{bmatrix}\) |
Erstellung von strukturierten Matrizen
Funktion |
Beschreibung |
Beispiel |
|---|---|---|
\(\texttt{np.zeros(shape)}\) |
Erstellt eine Matrix der Form \(\texttt{shape}\), die nur Nullen enthält. |
\(\texttt{np.zeros((2,3))}\) \(\rightarrow \begin{bmatrix} 0. & 0. & 0. \\ 0. & 0. & 0. \end{bmatrix}\) |
\(\texttt{np.ones(shape)}\) |
Erstellt eine Matrix der Form \(\texttt{shape}\), die nur Einsen enthält. |
\(\texttt{np.ones((2,3))}\) \(\rightarrow \begin{bmatrix} 1. & 1. & 1. \\ 1. & 1. & 1. \end{bmatrix}\) |
\(\texttt{np.full(shape, w)}\) |
Erstellt eine Matrix, die mit einem angegebenen Wert \(\texttt{w}\) gefüllt ist. |
\(\texttt{np.full((2,3), 7)}\) \(\rightarrow \begin{bmatrix} 7 & 7 & 7 \\ 7 & 7 & 7 \end{bmatrix}\) |
\(\texttt{np.eye(N)}\) |
Erstellt eine Identitätsmatrix der Größe \(\texttt{N}\). |
\(\texttt{np.eye(3)}\) \(\rightarrow \begin{bmatrix} 1. & 0. & 0. \\ 0. & 1. & 0. \\ 0. & 0. & 1. \end{bmatrix}\) |
\(\texttt{np.diag(v)}\) |
Erstellt eine diagonale Matrix mit den Elementen von \(\texttt{v}\). |
\(\texttt{np.diag([1, 2, 3])}\) \(\rightarrow \begin{bmatrix} 1 & 0 & 0 \\ 0 & 2 & 0 \\ 0 & 0 & 3 \end{bmatrix}\) |
\(\texttt{np.tri(N)}\) |
Erstellt eine untere Dreiecksmatrix der Größe \(\texttt{N}\) mit Einsen unterhalb der Diagonalen. |
\(\texttt{np.tri(3)}\) \(\rightarrow \begin{bmatrix} 1. & 0. & 0. \\ 1. & 1. & 0. \\ 1. & 1. & 1. \end{bmatrix}\) |
\(\texttt{np.triu(A)}\) |
Erstellt eine obere Dreiecksmatrix, indem alle Werte unter der Diagonalen von \(\texttt{A}\) auf Null gesetzt werden. |
\(\texttt{np.triu([[1,2,3],[4,5,6],[7,8,9]])}\) \(\rightarrow \begin{bmatrix} 1 & 2 & 3 \\ 0 & 5 & 6 \\ 0 & 0 & 9 \end{bmatrix}\) |
\(\texttt{np.tril(A)}\) |
Erstellt eine untere Dreiecksmatrix, indem alle Werte oberhalb der Diagonalen von \(\texttt{A}\) auf Null gesetzt werden. |
\(\texttt{np.tril([[1,2,3],[4,5,6],[7,8,9]])}\) \(\rightarrow \begin{bmatrix} 1 & 0 & 0 \\ 4 & 5 & 0 \\ 7 & 8 & 9 \end{bmatrix}\) |
Erstellung von Zufallsmatrizen#
Funktion |
Beschreibung |
Beispiel |
|---|---|---|
\(\texttt{np.random.rand(d0,d1)}\) |
Erzeugt eine \((d0 \times d1)\) Matrix mit Zufallswerten gleichmäßig verteilt zwischen 0 und 1. |
\(\texttt{np.random.rand(2,3)}\) |
\(\texttt{np.random.randn(d0,d1)}\) |
Erzeugt eine \((d0 \times d1)\) Matrix mit Zufallswerten aus einer Standardnormalverteilung. |
\(\texttt{np.random.randn(2,3)}\) |
\(\texttt{np.random.randint(l,h,size)}\) |
Erzeugt eine Matrix der Form \(\texttt{size}\) mit ganzzahligen Zufallswerten zwischen \(\texttt{l}\) und \(\texttt{h}\). |
\(\texttt{np.random.randint(0,10,(2,3))}\) |
\(\texttt{np.random.choice(v,size)}\) |
Erzeugt eine Matrix der Form \(\texttt{size}\) mit Einträgen zufällig aus dem Array \(\texttt{v}\). |
\(\texttt{np.random.choice([1,2,3,4],(2,3))}\) |