Python-NumPy-Array-Tutorial

What is a Python Numpy Array?

In der Einleitung hast du gelesen, dass NumPy-Arrays ein bisschen wie Python-Listen sind — und gleichzeitig grundlegend anders. Für alle, die neu im Thema sind: Klären wir, was sie genau sind und wofür sie gut sind.

Wie der Name andeutet, ist ein NumPy-Array die zentrale Datenstruktur der numpy-Bibliothek. Der Bibliotheksname steht für „Numeric Python“ oder „Numerical Python“.

Anders ausgedrückt: NumPy ist die Kernbibliothek für wissenschaftliches Rechnen in Python. Sie enthält eine Sammlung von Tools und Techniken, mit denen sich mathematische Modelle aus Wissenschaft und Ingenieurwesen lösen lassen.

Eines dieser Tools ist ein performantes, mehrdimensionales Array-Objekt — eine mächtige Datenstruktur für effiziente Berechnungen mit Arrays und Matrizen. Für diese Arrays stehen zahlreiche hochstufige mathematische Funktionen bereit, die auf Matrizen und Arrays operieren.

Aber was ist ein Array?

Wenn du dir die Ausgabe einiger Arrays ansiehst, kannst du sie als Raster mit Werten gleichen Typs verstehen:

import numpy as np
# Define a 1D array
my_array = np.array([[1, 2, 3, 4],
                     [5, 6, 7, 8]],
                    dtype=np.int64)
# Define a 2D array
my_2d_array = np.array([[1, 2, 3, 4],
                        [5, 6, 7, 8]],
                       dtype=np.int64)
# Define a 3D array
my_3d_array = np.array([[[1, 2, 3, 4],
                         [5, 6, 7, 8]],
                        [[1, 2, 3, 4],
                         [9, 10, 11, 12]]],
                       dtype=np.int64)
# Print the 1D array
print("Printing my_array:")
print(my_array)
# Print the 2D array
print("Printing my_2d_array:")
print(my_2d_array)
# Print the 3D array
print("Printing my_3d_array:")
print(my_3d_array)

Im obigen Beispiel sind die Daten Ganzzahlen. Das Array hält und repräsentiert solche regulären Daten in strukturierter Form.

Strukturell betrachtet ist ein Array im Kern jedoch nur eine Sammlung von Zeigern. Es ist eine Kombination aus Speicheradresse, Datentyp, Form (Shape) und Strides:

• Der Datenzeiger gibt die Speicheradresse des ersten Bytes im Array an.
• Der Datentyp bzw. dtype beschreibt, welche Art von Elementen das Array enthält.
• Die Shape gibt die Form bzw. Dimensionen des Arrays an.
• Die Strides sind die Anzahl an Bytes, die im Speicher übersprungen werden müssen, um zum nächsten Element zu gelangen. Sind deine Strides beispielsweise (10, 1), dann gehst du ein Byte weiter zur nächsten Spalte und 10 Bytes zur gleichen Position in der nächsten Zeile.

Mit anderen Worten: Ein Array enthält Informationen über die Rohdaten, wie ein Element gefunden wird und wie es zu interpretieren ist.

Genug Theorie. Probieren wir es aus:

Du kannst das leicht testen, indem du die Attribute eines NumPy-Arrays inspizierst:

import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print out memory address
print(my_2d_array.data)

# Print out the shape of `my_array`
print(my_2d_array.shape)

# Print out the data type of `my_array`
print(my_2d_array.dtype)

# Print out the stride of `my_array`
print(my_2d_array.strides)

Jetzt erhältst du deutlich mehr Informationen: Zum Beispiel ist der ausgegebene Datentyp „int64“. Das bedeutet auch, dass das Array im Speicher 64 Bytes belegt (jedes Integer braucht 8 Bytes und es gibt 8 Integer). Die Strides sagen uns, dass 8 Bytes (ein Wert) zur nächsten Spalte übersprungen werden, aber 32 Bytes (4 Werte) zur gleichen Position in der nächsten Zeile. Entsprechend sind die Strides (32, 8).

Wenn du den Datentyp auf int32 setzt, lautet das zurückgegebene Stride-Tupel (16, 4). Du wanderst weiterhin einen Wert zur nächsten Spalte und vier Werte zur nächsten Zeile. Der einzige Unterschied: Jeder Integer belegt nun 4 statt 8 Bytes.

Das obige Array ist — wie der Name nahelegt — zweidimensional: Es gibt Zeilen und Spalten. Die Zeilen bilden „Achse 0“, die Spalten „Achse 1“. Die Achsnummer steigt mit der Dimensionalität: In 3D-Arrays, wie im vorigen Codebeispiel, kommt „Achse 2“ hinzu. Diese Achsen spielen erst ab 2D-Arrays eine Rolle — bei 1D-Arrays braucht man sie nicht.

Die Achsen sind später nützlich, wenn du die Form deiner NumPy-Arrays veränderst.

How to Install Numpy

Bevor du NumPy-Arrays selbst ausprobierst, stelle sicher, dass NumPy lokal installiert ist (vorausgesetzt, du arbeitest auf deinem Rechner). Wenn Python bereits installiert ist, kannst du diesen Abschnitt überspringen :)

Für die Einrichtung gibt es zwei gängige Wege: über Python-Wheels oder über die Anaconda-Python-Distribution.

pip install pip --upgrade
pip --version

pip install numpy-<version>-<architecture>.whl

pip install numpy-1.20.3-cp39-cp39-win_amd64.whl

import numpy

How to Make NumPy Arrays

Nachdem deine Umgebung steht, geht’s ans Eingemachte. Im obigen Code hast du bereits erste Array-Beispiele gesehen, konntest aber noch nicht praktisch arbeiten, solange NumPy nicht installiert war. Jetzt probieren wir aus, was nötig ist, um die Codebeispiele selbst auszuführen.

Ein numpy-Array erstellst du mit der Funktion np.array(). Übergebe eine Liste und optional einen Datentyp. Eine Übersicht möglicher Datentypen findest du in diesem Guide oder auf DataCamps NumPy-Cheat Sheet.

Du musst dir als Neueinsteiger die NumPy-Datentypen nicht merken, aber du solltest wissen, mit welchen Daten du arbeitest. Datentypen helfen dir, die Speicherung im Speicher und auf der Festplatte besser zu steuern. Gerade bei großen Datenmengen lohnt es sich, den Speichertyp im Griff zu haben.

Vergiss nicht: Um np.array() zu nutzen, muss die numpy-Bibliothek in deiner Umgebung importiert sein.

NumPy folgt einer Import-Konvention: Importiere es als np. So verstehen andere Pythonistas deinen Code leichter.

Im folgenden Beispiel erzeugst du das Array my_array, mit dem du oben schon gearbeitet hast:

import numpy as np

# Make the array `my_array`
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_array`
print(my_array)

Wenn du mehr darüber wissen willst, wie man Listen erstellt, sieh dir unser Python-Listen-Tutorial an.

Manchmal weißt du noch nicht, welche Daten ins Array sollen, oder du möchtest Daten aus einer anderen Quelle in ein numpy-Array laden. Dann nutzt du Platzhalterfunktionen oder lädst Textdaten in Arrays.

Wie das geht, zeigen die nächsten Abschnitte.

import numpy as np

# Create an array of ones
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()

# Create an array of zeros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()

# Create an array with random values
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()

# Create an empty array
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()

# Create a full array
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()

# Create an array of evenly-spaced values
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()

# Create an array of evenly-spaced values
np.linspace(0,2,9)

# This is your data in the text file
# Value1  Value2  Value3
# 0.2536  0.1008  0.3857
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  0.5929
# 0.1781  0.3049  0.8928
# 0.6253  0.3486  0.8791

# Import your data
x, y, z = np.loadtxt('data.txt',
                    skiprows=1,
                    unpack=True)

# Your data in the text file
# Value1  Value2  Value3
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  MISSING
# 0.1781  0.3049  0.8928
# MISSING 0.5801  0.2038
# 0.5993  0.4357  0.7410

my_array2 = np.genfromtxt('data2.txt',
                      skip_header=1,
                      filling_values=-999)

import numpy as np
x = np.arange(0.0,5.0,1.0)
np.savetxt('test.out', x, delimiter=',')

import numpy as np

# Create a numpy array with shape (2,4) and dtype int64
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the number of dimensions of `my_array`
print("Number of dimensions of my_array:")
print(my_array.ndim)
print()

# Print the number of elements in `my_array`
print("Number of elements in my_array:")
print(my_array.size)
print()

# Print information about the memory layout of `my_array`
print("Information about the memory layout of my_array:")
print(my_array.flags)
print()

# Print the length of one array element in bytes
print("Length of one array element in bytes:")
print(my_array.itemsize)
print()

# Print the total consumed bytes by `my_array`'s elements
print("Total consumed bytes by my_array's elements:")
print(my_array.nbytes)
print()

import numpy as np
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the length of `my_array`
print(len(my_array))

# Change the data type of `my_array`
my_array.astype(float)

How NumPy Broadcasting Works

Bevor wir tiefer einsteigen, klären wir kurz Broadcasting: Es ist der Mechanismus, mit dem NumPy bei arithmetischen Operationen mit Arrays unterschiedlicher Form arbeiten kann.

Die folgende Infografik zeigt Broadcasting in Aktion: 

Source

In der Praxis hast du oft ein größeres und ein kleineres Array. Idealerweise willst du das kleinere mehrfach verwenden, um eine Operation (Addition, Multiplikation etc.) auf dem größeren Array auszuführen.

Dafür nutzt du Broadcasting.

Es gibt ein paar Regeln — keine Sorge, sie sind simpel:

• Erstens müssen die Dimensionen kompatibel sein. Zwei Dimensionen sind kompatibel, wenn sie gleich sind. Beispiel:

# Import the NumPy library and give it an alias of `np`
import numpy as np

# Initialize a 3x4 array of ones and assign it to the variable `x`
x = np.ones((3,4))

# Print the shape of the array `x`
print("Shape of x:", x.shape)

# Initialize a 3x4 array of random numbers between 0 and 1 and assign it to the variable `y`
y = np.random.random((3,4))

# Print the shape of the array `y`
print("Shape of y:", y.shape)

# Add the arrays `x` and `y` element-wise and print the resulting array
z = x + y
print("Result of x + y:\n", z)

# Print the shape of the resulting array
print("Shape of x + y:", z.shape)

• Zweitens sind Dimensionen kompatibel, wenn eine davon 1 ist:

# Import the NumPy library and give it an alias of `np`
import numpy as np

# Initialize a 3x4 array of ones and assign it to the variable `x`
x = np.ones((3,4))

# Print the shape of the array `x`
print("Shape of x:", x.shape)

# Initialize a 3x4 array of random numbers between 0 and 1 and assign it to the variable `y`
y = np.random.random((3,4))

# Print the shape of the array `y`
print("Shape of y:", y.shape)

# Add the arrays `x` and `y` element-wise and print the resulting array
z = x + y
print("Result of x + y:\n", z)

# Print the shape of the resulting array
print("Shape of x + y:", z.shape)

Sind die Dimensionen nicht kompatibel, erhältst du eine ValueError.

Tipp: Prüfe auch die Größe des Ergebnis-Arrays nach der Berechnung. Es gilt: Entlang jeder Dimension entspricht sie dem Maximum der Eingabe-Arrays.

Anders gesagt: Das Ergebnis von x−y hat die Shape (3,4), wenn y die Shape (4,) und x (3,4) hat. Entlang jeder Achse wird das Maximum der Eingabegrößen verwendet.

• Drittens: Arrays können nur gemeinsam gebroadcastet werden, wenn sie in allen Dimensionen kompatibel sind. Beispiel:

# Import `numpy` as `np`
import numpy as np

# Initialize `x` and `y`
x = np.ones((3,4))
y = np.random.random((5,1,4))

# Add `x` and `y`
z = x + y

Obwohl x und y unterschiedliche Dimensionen haben, lassen sie sich addieren.

Sie sind in allen Dimensionen kompatibel:

• Array x hat die Dimensionen 3 × 4,
• Array y hat die Dimensionen 5 × 1 × 4.

Da Dimensionen auch kompatibel sind, wenn eine davon 1 ist, sind diese Arrays gute Kandidaten fürs Broadcasting.

In der Dimension, in der y die Größe 1 hat und das andere Array größer ist (hier 3), verhält sich das erste Array so, als würde es entlang dieser Dimension „kopiert“.

Die Shape des Ergebnis-Arrays ist wieder das Maximum entlang jeder Dimension von x und y: (5, 3, 4).

Kurz: Für Broadcasting kommt es auf Shape und Dimensionen deiner Arrays an.

Aber was, wenn die Dimensionen nicht kompatibel sind?

Dann passt du dein Array an — wie, siehst du in einem der nächsten Abschnitte.

How do Array Mathematics Work?

Broadcasting ist praktisch für arithmetische Operationen. Hier lernst du Funktionen kennen, mit denen du Mathematik auf Arrays anwendest.

Natürlich kannst du einfach +, -, *, / oder % verwenden, um Arrays zu addieren, zu subtrahieren, zu multiplizieren, zu dividieren oder den Rest zu berechnen. NumPy bietet dafür auch Funktionsäquivalente: np.add(), np.subtract(), np.multiply(), np.divide() und np.remainder().

Exponentiation und Quadratwurzeln gelingen mit np.exp() bzw. np.sqrt(). Sinus und Kosinus berechnest du mit np.sin() und np.cos(). Außerdem gibt es np.log() für den natürlichen Logarithmus und dot() für das Skalarprodukt.

Probier es im folgenden Code aus.

Tipp: Schau dir vorher die geladenen Arrays an!

# Import `numpy` as `np`
import numpy as np
x = np.array([[1, 2, 3], [3, 4, 5]])
y = np.array([6,7,8])

# Add `x` and `y`
z = np.add(x,y)
print("Addition of x and y:\n", z)

# Subtract `x` and `y`
z = np.subtract(x,y)
print("Subtraction of y from x:\n", z)

# Multiply `x` and `y`
z = np.multiply(x,y)
print("Element-wise multiplication of x and y:\n", z)

Erinnerst du dich an die Broadcasting-Regeln? Prüfe in deiner IPython-Shell Dimensionen und Shapes von x und y.

Es gibt noch mehr.

Hier eine kleine Auswahl an Aggregatfunktionen:

Neben diesen Funktionen kannst du Array-Elemente vergleichen. Um Gleichheit zu prüfen, verwendest du ==. Für kleiner/größer nutzt du < bzw. >.

Außerdem kannst du ganze Arrays vergleichen: np.array_equal() prüft, ob zwei Arrays identisch sind.

Und du kannst logische Operationen anwenden: np.logical_or(), np.logical_not() und np.logical_and() — analog zu OR, NOT und AND.

Teste es:

# Import `numpy` as `np`
import numpy as np
# Initialize arrays
a = np.array([1, 1, 0, 0], dtype=bool)
b = np.array([1, 0, 1, 0], dtype=bool)

# `a` AND `b` 
np.logical_and(a, b)

# `a` OR `b`
np.logical_or(a, b)

# `a` NOT `b`
np.logical_not(a,b)

How to Subset, Slice, and Index Arrays

Neben mathematischen Operationen willst du oft nur Teile eines Arrays oder bestimmte Elemente weiterverwenden. Dann brauchst du Subsetting, Slicing und Indexing.

Diese Operationen ähneln denen auf Python-Listen. Für Details siehe das Python-Listen-Tutorial.

Wenn dir das noch nichts sagt, helfen zwei Grundregeln:

• Du verwendest eckige Klammern [] als Indexoperator, und
• in der Regel übergibst du Ganzzahlen — oder Doppelpunkte : bzw. Kombinationen aus : und Ganzzahlen, um Elemente/Zeilen/Spalten auszuwählen.

Subsetting

Am besten klappt das Verständnis über Beispiele:

import numpy as np

# Initialize 1D array
my_array = np.array([1,2,3,4])

# Print subsets
print(my_array[1])

import numpy as np

# Initialize 2D array
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print subsets
print(my_2d_array[1][2])
print(my_2d_array[1,2])

import numpy as np

# Initialize 3D array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Print subset
print(my_3d_array[1,1,2])

Slicing

Ein Stück weiter geht das Slicing. Hier arbeitest du mit Zeilen und Spalten — also „Regionen“ statt einzelner „Positionen“.

Gemeint ist Folgendes:

import numpy as np

# Initialize 1D array
my_array = np.array([1,2,3,4])

# Print subsets
print(my_array[0:2])

import numpy as np

# Initialize 2D array
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print subsets
print(my_2d_array[0:2,1])

import numpy as np

# Initialize 3D array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Print subset
print(my_3d_array[1,...])

Im Kern gilt:

a[start:end] # items start through the end (but the end is not included!)
a[start:]    # items start through the rest of the array
a[:end]      # items from the beginning through the end (but the end is not included!)

In den Beispielen werden die Arrays jeweils separat initialisiert und Teilbereiche separat ausgegeben. my_array, my_2d_array und my_3d_array sind die 1D-, 2D- und 3D-Varianten; die Auswahl erfolgt per Indexnotation.

Im ersten Beispiel wählen wir per Slicing die Elemente mit Index 0 und 1 aus my_array. Im zweiten Beispiel nehmen wir die Elemente der Zeilen 0 und 1, Spalte 1 von my_2d_array. Im dritten Beispiel wählt die ...-Notation alle Elemente entlang der ersten beiden Dimensionen und das zweite Element entlang der dritten Dimension von my_3d_array.

Indexing

Beim Indexing unterscheidet NumPy zwischen booleschem und erweitertem („fancy“) Indexing.

Zuerst das boolesche Indexing: Statt über Positionsindizes wählst du Werte, die eine Bedingung erfüllen.

Im Code sieht das so aus:

import numpy as np
my_array = np.array([1,2,3,4])
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Try out a simple example
print(my_array[my_array<2])

# Specify a condition
bigger_than_3 = (my_3d_array >= 3)

# Use the condition to index our 3d array
print(my_3d_array[bigger_than_3])

Für Bedingungen kannst du auch die logischen Operatoren | (OR) und & (AND) kombinieren. Die obige Bedingung ließe sich z. B. als bigger_than_3 = (my_3d_array > 3) | (my_3d_array == 3) schreiben.

Mit den geladenen Arrays sind die Möglichkeiten begrenzt — mit Arrays, die z. B. Namen enthalten, sind sie nahezu endlos.

Fancy Indexing bedeutet, dass du eine Liste oder ein Array von Ganzzahlen übergibst, um die Reihenfolge der auszuwählenden Zeilen aus dem Originalarray festzulegen.

Noch abstrakt?

Dann probiere es hier:

import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Select elements at (1,0), (0,1), (1,2) and (0,0)
print(my_2d_array[[1, 0, 1, 0],[0, 1, 2, 0]])

# Select a subset of the rows and columns
print(my_2d_array[[1, 0, 1, 0]][:,[0,1,2,0]])

Die zweite Anweisung wirkt auf den ersten Blick verwirrend. Zerlegen wir sie:

• Führst du nur my_2d_array[[1,0,1,0]] aus, erhältst du:

array([[5, 6, 7, 8],
   [1, 2, 3, 4],
   [5, 6, 7, 8],
   [1, 2, 3, 4]])

• Der zweite Teil [:,[0,1,2,0]] sagt: Behalte alle Zeilen, aber ordne die Spalten neu. Zeige die Spalten 0, 1 und 2 in dieser Reihenfolge und wiederhole Spalte 0 als letzte Spalte statt Spalte 3. Ergebnis:

array([[5, 6, 7, 5],
   [1, 2, 3, 1],
   [5, 6, 7, 5],
   [1, 2, 3, 1]])

Damit hat Fancy Indexing seinen Schrecken verloren.

How to Ask for Help

Kleines Intermezzo: Du kannst dir jederzeit Informationen zu Modulen, Funktionen oder Klassen holen — besonders am Anfang ist NumPy umfangreich.

Hilfe zu bekommen ist einfach.

Nutze die speziellen Hilfsfunktionen von numpy:

• lookfor() durchsucht Docstrings nach Stichwörtern. Ideal für den Einstieg — aber Vorsicht: Bei unspezifischen Suchanfragen musst du viele Treffer sichten.
• info() liefert schnelle Erklärungen und Codebeispiele zu Funktionen, Klassen oder Modulen. Wenn du durch Ausprobieren lernst, ist das perfekt. Du musst nur wissen, in welchem Modul sich ein Attribut oder eine Funktion befindet. Sieh dir das Beispiel an.

Beide Funktionen haben Vor- und Nachteile. Probiere sie aus:

import numpy as np

# Look up info on `mean` with `np.lookfor()` 
print(np.lookfor("mean"))

# Get info on data types with `np.info()`
np.info(np.ndarray.dtype)

Beachte: Du musst wissen, dass dtype ein Attribut von ndarray ist. Und vergiss nicht, np voranzustellen — sonst bekommst du einen Fehler wie:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'ndarray' is not defined

Jetzt weißt du, wie du Hilfe bekommst. Als Nächstes: Array-Manipulation.

Nicht, dass du das nicht alleine schaffen würdest — im Gegenteil!

Aber manche Funktionen werfen Fragen auf: Was unterscheidet Resizing von Reshaping?

Und worin liegt der Unterschied zwischen horizontalem und vertikalem Stapeln?

Im nächsten Abschnitt klären wir das. Und wenn du unsicher bist: Nutze die Hilfsfunktionen, um schnell Klarheit zu bekommen.

How to Manipulate Arrays

Neben mathematischen Operationen ist vor allem wichtig, Arrays zu manipulieren — damit Berechnungen und Broadcasting funktionieren.

Hier sind die gängigsten Operationen.

import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array`
print(my_2d_array)

# Transpose `my_2d_array`
print(np.transpose(my_2d_array))

# Or use `T` to transpose `my_2d_array`
print(my_2d_array.T)

import numpy as np
my_array = np.array([1,2,3,4])

# Print `my_2d_array
print(my_array)

# Transpose `my_2d_array
print(np.transpose(my_array))

# Or use `T` to transpose `my_2d_array
print(my_array.T)

import numpy as np
x = np.ones((3,4))

# Print the shape of `x`
print(x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x`
print(x)

import numpy as np

# Initialize array with shape (3,4) containing all ones
x = np.ones((3,4))

# Print the shape of `x`
print("Shape of x:", x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x` before and after resizing
print("Array before transposing:\n", x)
print("Shape of array before transposing:", x.shape)

# Transpose `x`
x = x.T

# Print out `x` after transposing
print("Array after transposing:\n", x)
print("Shape of array after transposing:", x.shape)

Shape of x: (3, 4)
Array before transposing:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
Shape of array before transposing: (6, 4)
Array after transposing:
 [[1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]]
Shape of array after transposing: (4, 6)

import numpy as np

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

# Print `my_array` before appending
print("my_array before appending:", my_array)

# Append a 1D array to `my_array`
new_array = np.append(my_array, [7, 8, 9, 10])

# Print `new_array`
print("new_array:", new_array)

# Print `my_array` after appending
print("my_array after appending:", my_array)

my_array before appending: [1 2 3 4]
new_array: [ 1  2  3  4  7  8  9 10]
my_array after appending: [1 2 3 4]

import numpy as np

my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array` before appending
print("my_2d_array before appending:\n", my_2d_array)

# Append an extra column to `my_2d_array`
new_2d_array = np.append(my_2d_array, [[7], [8]], axis=1)

# Print `new_2d_array`
print("new_2d_array:\n", new_2d_array)

# Print `my_2d_array` after appending
print("my_2d_array after appending:\n", my_2d_array)

my_2d_array before appending:
 [[1 2 3 4]
  [5 6 7 8]]
new_2d_array:
 [[1 2 3 4 7]
  [5 6 7 8 8]]
my_2d_array after appending:
 [[1 2 3 4]
  [5 6 7 8]]

import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Insert `5` at index 1
np.insert(my_array, 1, 5)

# Delete the value at index 1
np.delete(my_array,[1])

import numpy as np 
x = np.ones((4,))
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Concatentate `my_array` and `x`
print(np.concatenate((my_array,x)))

# Stack arrays row-wise
print(np.vstack((my_array, my_2d_array)))

# Stack arrays row-wise
print(np.r_[my_resized_array, my_2d_array])

# Stack arrays horizontally
print(np.hstack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.column_stack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.c_[my_resized_array, my_2d_array])

import numpy as np
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_stacked_array = np.hstack((my_resized_array, my_2d_array))

# Split `my_stacked_array` horizontally at the 2nd index
print(np.hsplit(my_stacked_array, 2))

# Split `my_stacked_array` vertically at the 2nd index
print(np.vsplit(my_stacked_array, 2))

How to Visualize NumPy Arrays

Zum Schluss: Wie zeichnest du deine Arrays? Das ist in der Exploration nützlich und auch später, wenn du Ergebnisse visualisieren willst.

# Import `numpy` as `np`
import numpy as np

# Initialize your array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Pass the array to `np.histogram()`
print(np.histogram(my_3d_array))

# Specify the number of bins
print(np.histogram(my_3d_array, bins=range(0,13)))

# Import numpy and matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Construct the histogram with a flattened 3d array and a range of bins
plt.hist(my_3d_array.ravel(), bins=range(0,13))

# Add a title to the plot
plt.title('Frequency of My 3D Array Elements')

# Show the plot
plt.show()

# Import NumPy and Matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Create an array
points = np.arange(-5, 5, 0.01)

# Make a meshgrid
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs ** 2 + ys ** 2)

# Display the image on the axes
plt.imshow(z, cmap=plt.cm.gray)

# Draw a color bar
plt.colorbar()

# Show the plot
plt.show()

Beyond Data Analysis with NumPy

Glückwunsch — du hast das NumPy-Tutorial abgeschlossen!

Wir haben viel abgedeckt. Sorge jetzt dafür, dass das Wissen hängen bleibt — hol dir das NumPy-Cheat Sheet von DataCamp zur Unterstützung.

Nach der Theorie ist Praxis gefragt. Eine Möglichkeit: Kehre zum scikit-learn-Tutorial zurück und experimentiere weiter mit den Daten-Arrays für Machine-Learning-Modelle.

Ist das nicht dein Ding, prüfe, ob du Anaconda installiert hast. Starte dann mit NumPy-Arrays in Jupyter — mit diesem Definitive Guide to Jupyter Notebook. Sieh dir auch dieses Jupyter Notebook an — es führt dich durch Datenanalyse in Python mit NumPy und weiteren Bibliotheken in der interaktiven Jupyter-Umgebung.

Zum Schluss: Schau dir DataCamps Kurse zu Datenmanipulation und Visualisierung an. Besonders unsere neuesten Kurse in Zusammenarbeit mit Continuum Analytics könnten dich interessieren — etwa Manipulating DataFrames with Pandas oder Pandas Foundations.