Numpy Cheat Sheet: Grundlegende Datenanalyse in Python

Als Datenwissenschaftler, der mit Python arbeitet, sind Sie höchstwahrscheinlich auf die NumPy-Bibliothek gestoßen . Es ist eines der grundlegenden Pakete für wissenschaftliches Rechnen in Python .

Mit seiner Fähigkeit, Hochleistungsoperationen an mehrdimensionalen Arrays durchzuführen, ist NumPy ein unverzichtbares Werkzeug für jeden, der sich mit Datenwissenschaft oder numerischem Rechnen in Python beschäftigt.

Ein NumPy-Spickzettel kann eine hervorragende Ressource sein, die Sie bei Ihrer Reise in diese Python-Bibliothek unterstützt. Ein umfassender Spickzettel hilft Ihnen dabei, sich in den Funktionen von NumPy zurechtzufinden und sich schnell mit der Verwendung für verschiedene Aufgaben vertraut zu machen!

Denken Sie auch daran, dass NumPy den Kern wichtiger Bibliotheken wie Pandas, SciPy, Sci-Kit-Learn und anderer Python-Pakete bildet.

Wenn Sie die Grundlagen mithilfe des Python NumPy- Spickzettels beherrschen , sind Sie besser für die Arbeit mit diesen Bibliotheken gerüstet. Darüber hinaus erweitern Sie Ihre Fähigkeiten im Umgang mit komplexen Datenstrukturen und Berechnungen.

Sind Sie altmodisch (wie wir) und möchten Ihren Spickzettel herunterladen und möglicherweise ausdrucken?

Scrollen Sie dazu nach unten.

Inhaltsverzeichnis

• NumPy-Grundlagen
  • 1. NumPy installieren und importieren
  • 2. Array-Erstellung
  • 3. Array-Attribute
  • 4. Datentypen
• Array-Manipulation
  • 1. Umformen
  • 2. Kopieren
  • 3. Verkettung
  • 4. Aufteilen
  • 5. Elemente hinzufügen/entfernen
  • 6. Indizierung
  • 7. Schneiden
• Elementare Funktionen
  • 1. Arithmetische Operationen
  • 2. Trigonometrie
  • 3. Exponenten und Logarithmen
• Array-Analyse
  • 1. Aggregatfunktionen
  • 2. Statistische Funktionen
  • 3. Suchen
  • 4. Sortieren
• Erweiterte Funktionen
  • 1. Rundfunk
  • 2. Lineare Algebra
• Eingabe und Ausgabe
  • 1. Arrays speichern und laden
  • 2. Lesen und Schreiben in Textdateien
• Laden Sie unten Ihren Spickzettel herunter
• Abschließende Gedanken

NumPy-Grundlagen

In diesem Abschnitt behandeln wir die Grundlagen von NumPy und konzentrieren uns auf die Installation von NumPy, die Array-Erstellung, Array-Attribute und Datentypen. Diese Konzepte bilden eine solide Grundlage für das Verständnis und die effektive Nutzung von NumPy in Ihren Python-Data-Science-Projekten.

1. NumPy installieren und importieren

Sie können NumPy über die Befehlszeile mit dem folgenden Befehl installieren:

pip install numpy

Sobald es installiert ist, importieren Sie es in Ihren Code.

import numpy as np

Beachten Sie, dass Sie außer np jeden anderen Namen verwenden können . Allerdings ist np die Standard-NumPy-Importkonvention, die von den meisten Entwicklern und Datenwissenschaftlern verwendet wird.

2. Array-Erstellung

Das Erstellen von Arrays in NumPy ist einfach und unkompliziert. Mit der Funktion numpy.array() können Sie Arrays aus Listen oder Tupeln erstellen :

import numpy as np

a = np.array([1, 2, 3])  # Creates a 1D array
b = np.array([(1, 2, 3), (4, 5, 6)])  # Creates a 2D array

Sie können mit verschiedenen Funktionen auch Arrays mit bestimmten Formen und Werten generieren:

• np.zeros() : Erstellt ein mit Nullen gefülltes Array

• np.ones() : Erstellt ein mit Einsen gefülltes Array

• np.identity() : Erstellt ein Identitätsmatrix-Array.

• np.empty() : Erstellt ein Array, ohne seine Elemente auf einen bestimmten Wert zu initialisieren

• np.arange() : Erstellt ein Array mit regelmäßig beabstandeten Werten zwischen einem Start- und einem Endwert

• np.linspace() : Erstellt ein Array mit einer angegebenen Anzahl gleichmäßig verteilter Werte zwischen einem Start- und einem Endwert

Hinweis: Sie können in NumPy kein leeres Array generieren. Jedes NumPy-Array hat eine feste, unveränderliche Größe und jedes Element im Array muss beim Erstellen des Arrays ausgefüllt werden.

Die Funktion np.empty() erstellt die erforderliche Array-Form und füllt sie mit Zufallswerten. Die Standardmethode erstellt ein Array aus zufälligen Gleitkommazahlen.

Mit dem Parameter dtype können Sie einen anderen Array-Datentyp erstellen .

3. Array-Attribute

NumPy-Arrays verfügen über mehrere Attribute, die nützliche Informationen über das Array liefern. Schauen wir uns einige davon an:

• ndarray.shape: Gibt die Abmessungen des Arrays als Tupel (Zeilen, Spalten) zurück.

• ndarray.ndim: Gibt die Anzahl der Dimensionen im Array zurück

• ndarray.size: Gibt die Gesamtzahl der Elemente im Array zurück

• ndarray.dtype: Gibt den Datentyp der Array-Elemente zurück

Um auf diese Attribute zuzugreifen, verwenden Sie die Punktnotation, etwa so:

a = np.array([(1, 2, 3), (4, 5, 6)])

#Print out the array shape
print(a.shape)  # Output: (2, 3)

4. Datentypen

NumPy bietet mehrere Datentypen zum Speichern von Daten in Arrays, z. B. Integer, String, Float, Boolean und Complex. Standardmäßig versucht NumPy, den Datentyp anhand der Eingabeelemente abzuleiten.

Sie können den Datentyp jedoch auch explizit mit dem Schlüsselwort dtype angeben . Zum Beispiel:

import numpy as np
a = np.array([1, 2, 3], dtype=float)  # Creates an array of floats

Zu den gängigen NumPy-Datentypen gehören:

• np.int32 : 32-Bit-Ganzzahl

• np.int64: 64-Bit-Ganzzahl

• np.float32: 32-bit floating-point number

• np.float64: 64-bit floating-point number

• np.complex: Complex number, represented by two 64-bit floating-point numbers

You can also convert arrays from one data type to another. In this example, here’s how we can convert the Integer array a into a Boolean array arr using the np.array() method.

From the example, we can see the array() method converts the array elements into boolean values. These boolean values then form the new NumPy array arr.

Understanding these basic concepts of NumPy will allow you to effectively work with arrays and perform a variety of mathematical NumPy operations. For example, you can check out our video on how to transform and code addresses In Python.

In it, we used Python Pandas and NumPy data types to geocode home addresses.

Array Manipulation

In this section, you will learn about various array shape manipulation techniques in NumPy. We will discuss reshaping, concatenation, copying, splitting, adding/removing elements, indexing, and slicing.

These techniques are crucial for effectively working with array data in your data science projects.

Let’s dive into each sub-section.

1. Reshaping

Reshaping an array in NumPy is a common task you’ll perform. You might need to change the shape of your array to match the requirements of a function or an algorithm.

To reshape an array, use the reshape() function:

arr = np.array([1, 2, 3, 4, 5, 6])
new_arr = arr.reshape(2, 3)

This will convert your one-dimensional array into a two-dimensional array with 2 rows and 3 columns.

Note: Make sure the new shape you provide has the same size (number of array elements) as the original array.

2. Copying

You can copy the elements in one NumPy array to another using the copy() method. You should note that using the assignment operator ‘=’ creates a shallow copy.

#Creating a shallow copy of a NumPy array
a = np.array([9, 6, 12, 16, 20])
b = a
b[0] = 19

print(a) #Output:[19, 6, 12, 16, 20]
print(b) #Output:[19, 6, 12, 16, 20]

The new array only references the old array in the system’s memory. They contain the same elements and they are not independent of each other.

By using the deep copy, you create a new NumPy array that contains the same data as the old one while being independent of it.

#Creating a deep copy of a NumPy array
a = np.array([9, 6, 12, 16, 20])
b = np.copy(a)
b[0] = 19

print(a) #Output:[9, 6, 12, 16, 20]
print(b) #Output:[19, 6, 12, 16, 20]

3. Concatenation

Occasionally, you may need to merge two arrays into a single one. In NumPy, you can use the concatenate() function to join arrays along an existing axis:

import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
result = np.concatenate((arr1, arr2))

This combines arr1 and arr2 into a single array. Keep in mind that the arrays being concatenated should have the same shape, except along the specified axis.

4. Splitting

Splitting is the opposite of concatenation. You can divide an array into smaller sub-arrays using the split() function:

arr = np.array([1, 2, 3, 4, 5, 6])
result = np.split(arr, 3)

This splits the array into 3 equal-sized sub-arrays. Ensure that the number of splits you specify can evenly divide the size of the array along the given axis.

5. Adding/Removing Elements

Adding or removing elements in a NumPy array can be achieved using the append() and delete() functions. You can use the former to append values to the end of the array while the latter deletes the element at a specified index.

Here’s an example:

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

arr = np.append(arr, [4, 5, 6]) # Appends values to the end of the array
arr = np.delete(arr, 0) # Removes the array element on index 0

Keep in mind that NumPy arrays have a fixed size. When using append() or delete(), a new array is created, and the original one is not modified.

6. Indexing

You can perform indexing operations on NumPy arrays the same way you’d do them on Python lists or tuples. Let’s look at how you can access or change array elements in a given array.

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

#Returns the array element on index 1
element_2 = b[1]

#Change the array element on index 0
arr[0]= 89

7. Slicing

You can also slice NumPy arrays to extract or view a section of the data the same way you’d do Python lists or sets. Let’s take a look at an example below:

arr1 = np.array([1, 2, 3, 4, 5, 6, 7])
arr2 = np.array([(1, 2, 3, 6, 0), (4, 5, 6, 11, 13)]) 

# To return the first 3 elements of arr1
print(arr1[0:3]) #Output: [1, 2, 3]

# To return the second row in arr2
b = arr2[1, : ].copy() #Output: [4, 5, 6, 11, 13]

Note: Slicing creates a shallow copy that still references the main array. So, any change you make to the sliced data will be applied to the main array and vice versa.

To avoid this, you can use the copy() method to create a deep, independent copy.

Elementary Functions

In this section, you’ll learn about different elementary functions in NumPy, which will ease your data analysis tasks. We’ll cover arithmetic operations, trigonometry, and exponents and logarithms.

1. Arithmetic Operations

NumPy offers various math operations on arrays that make them simple and efficient to work with. array mathematics vector math

Some of the operations are:

• Addition: numpy.add(x1, x2)

• Subtraction: numpy.subtract(x1, x2)

• Multiplication: numpy.multiply(x1, x2)

• Division: numpy.divide(x1, x2)

• Modulus: numpy.mod(x1, x2)

• Power: numpy.power(x1, x2)

• Square root: numpy.sqrt(x)

Note: When using these operations, the two arrays must be the same shape. If not, you’ll run into errors.

There is an exception for certain arrays thanks to a NumPy feature called broadcasting. We’ll cover that in a later section.

You can perform these operations element-wise on the arrays, which makes them highly efficient for large-scale data manipulation.

2. Trigonometry

Trigonometric functions play a significant role in various mathematical and scientific computations. NumPy provides a wide range of trigonometric functions.

Some of the essential functions are:

• Sine: numpy.sin(x)

• Cosine: numpy.cos(x)

• Tangent: numpy.tan(x)

• Arcsine: numpy.arcsin(x)

• Arccosine: numpy.arccos(x)

• Arctangent: numpy.arctan(x)

These functions work seamlessly with arrays, making it easier for you to perform vectorized computations on large datasets.

3. Exponents and Logarithms

Exponents and logarithms are crucial for various numerical operations. NumPy provides an extensive collection of functions for dealing with exponents and logarithms.

Some of the primary functions are:

• Exponential: numpy.exp(x)

• Logarithm(base e): numpy.log(x)

• Logarithm(base 10): numpy.log10(x)

• Logarithm(base 2): numpy.log2(x)

Utilizing these functions, you can quickly perform complex mathematical operations on each element in the array. This makes your data analysis tasks more accessible and efficient.

Array Analysis

In this section, we will discuss various techniques to analyze arrays and array elements in NumPy. Some of the key features we will cover include aggregate functions, statistical functions, searching, and sorting.

1. Aggregate Functions

NumPy provides several aggregate functions that allow you to perform operations on arrays, such as summing all their elements, finding the minimum or maximum value, and more:

• sum: np.sum(your_array) – Calculate the sum of all the elements in the array.

• min: np.min(your_array) – Find the minimum array element.

• max: np.max(your_array) – Find the maximum array element.

• bedeuten : np.mean(your_array) – Berechnen Sie den Mittelwert der Werte im Array.

• median : np.median(your_array) – Finden Sie den Median der Werte im Array.

2. Statistische Funktionen

NumPy verfügt außerdem über verschiedene Statistikfunktionen, die Sie bei der Datenanalyse unterstützen:

• std: np.std(your_array) – Berechnen Sie die Standardabweichung der Werte im Array.

• var: np.var(your_array) – Berechnen Sie die Varianz der Werte im Array.

• corrcoef : np.corrcoef(your_array) – Berechnen Sie den Korrelationskoeffizienten des Arrays.

3. Suchen

Die Suche in NumPy-Arrays kann mit verschiedenen Methoden erfolgen:

• argmin: np.argmin(your_array) – Finden Sie den Index des minimalen Array-Elements.

• argmax: np.argmax(your_array) – Finden Sie den Index des maximalen Array-Elements.

• wobei: np.where(condition) – Gibt die Indizes der Elemente im Array zurück, die die gegebene Bedingung erfüllen.

4. Sortieren

Sie können die Elemente in Ihrem Array mit den folgenden Funktionen sortieren:

• sort : np.sort(your_array) – Sortieren Sie die Elemente im Array in aufsteigender Reihenfolge.

• argsort: np.argsort(your_array) – Gibt die Indizes zurück, die das Array sortieren würden.

Mit diesen Funktionen und Techniken können Sie Ihre NumPy-Arrays bequem analysieren und manipulieren, um wertvolle Erkenntnisse zu gewinnen und Ihre Datenanalysebemühungen zu unterstützen.

Erweiterte Funktionen

In diesem Abschnitt untersuchen wir einige erweiterte Funktionen in NumPy, die Ihnen helfen, effizienter mit Ihren Daten zu arbeiten. Wir werden die Funktionen „Broadcasting“ und „Lineare Algebra“ behandeln.

1. Rundfunk

Broadcasting ist eine leistungsstarke NumPy-Funktion, mit der Sie Operationen an Arrays unterschiedlicher Form und Größe ausführen können. Es funktioniert, indem es die Abmessungen des kleineren Arrays automatisch erweitert, um sie an das größere Array anzupassen, wodurch es einfacher wird, elementweise Operationen durchzuführen.

Hier ist ein Beispiel:

import numpy as np
A = np.array([1, 2, 3])
B = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

C = A + B

In diesem Beispiel wird das 1D-Array A so übertragen, dass es mit der Form des 2D-Arrays B übereinstimmt, was eine elementweise Addition ermöglicht.

Beachten Sie bei der Arbeit mit Rundfunk die folgenden Regeln:

• Die Abmessungen der Arrays müssen kompatibel sein (entweder gleich groß oder eines davon ist 1).

• Die Übertragung erfolgt von den hinteren Dimensionen aus und arbeitet in Richtung der führenden Dimensionen.

2. Lineare Algebra

NumPy bietet mehrere lineare Algebra-Funktionen, die bei der Arbeit mit mehrdimensionalen Arrays nützlich sein können. Zu diesen Funktionen gehören unter anderem:

• np.dot(A, B): Berechnet das Skalarprodukt zweier Arrays.

• np.linalg.inv(A) : Berechnet die Umkehrung einer quadratischen Matrix.

• np.linalg.eig(A) : Berechnet die Eigenwerte und Eigenvektoren einer quadratischen Matrix.

• np.linalg.solve(A, B): Löst ein lineares Gleichungssystem, wobei A die Koeffizientenmatrix und B die konstante Matrix ist.

Denken Sie daran, immer zu prüfen, ob Ihre Matrizen kompatibel sind, bevor Sie diese Vorgänge durchführen.

Eingabe und Ausgabe

In diesem Abschnitt erfahren Sie, wie Sie Arrays speichern und laden sowie Dateien mit NumPy lesen und schreiben.

1. Arrays speichern und laden

Um ein Array zu speichern, können Sie die Funktion np.save() von NumPy verwenden . Diese Funktion verwendet den Dateinamen und das Array als ihre beiden Hauptargumente.

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

np.save('my_array.npy', arr)

Um das gespeicherte Array zu laden, verwenden Sie die Funktion np.load() und geben Sie den Dateinamen als Argument an.

loaded_array = np.load('my_array.npy')

print(loaded_array)  
# Output: array([1, 2, 3])

Sie können auch mehrere Arrays mit den Funktionen np.save() und np.load() speichern und laden .

2. Lesen und Schreiben in Textdateien

NumPy bietet Funktionen zum Lesen und Schreiben von Textdateien mit Arrays, wie zum Beispiel np.loadtxt() und np.savetxt() . Mit diesen Funktionen können Sie Daten aus Dateiformaten wie einer TXT- oder CSV-Datei speichern und laden.

Um eine Textdatei in ein Array einzulesen, verwenden Sie die Funktion np.loadtxt() . Es verwendet den Dateinamen als Hauptargument und unterstützt auch optionale Argumente zur Angabe von Trennzeichen, dtype und mehr.

arr_from_txt = np.loadtxt('data.txt', delimiter=',')
print(arr_from_txt)

Um die Daten aus einer CSV-Datei auszulesen, können Sie auch die Funktion np.loadtxt() verwenden . Stellen Sie jedoch sicher, dass das Trennzeichen immer auf das Komma „ , „ gesetzt ist .

Um ein Array in eine Textdatei zu schreiben, verwenden Sie die Funktion np.savetxt() . Diese Funktion verwendet den Dateinamen und das Array als ihre beiden Hauptargumente, gefolgt von optionalen Argumenten wie Trennzeichen und Header.

arr_to_txt = np.array([[1, 2, 3], [4, 5, 6]])
np.savetxt('output_data.txt', arr_to_txt, delimiter=',')

Diese Eingabe- und Ausgabefunktionen ermöglichen Ihnen die effiziente Arbeit mit Arrays und Textdateien bei Ihren Datenverarbeitungs- und Manipulationsaufgaben mit NumPy.

Laden Sie unten Ihren Spickzettel herunter

Numpy-Cheat-Sheet herunterladen

Abschließende Gedanken

Nun, das ist alles, was Sie wissen müssen, um mit der Numpy Python-Bibliothek zu beginnen! Sie können auch den Python-Numpy-Spickzettel als praktische Referenz bei der Arbeit mit der Bibliothek verwenden.

Weitere erweiterte Funktionen finden Sie in der NumPy-Dokumentation . Sie können sich auch diesen unterhaltsamen Python-Spickzettel ansehen, den wir sowohl für neue als auch für erfahrene Entwickler zusammengestellt haben.

Viel Glück!