Dieser Artikel hilft Ihnen, sich mit der weit verbreiteten Array-Verarbeitungsbibliothek in Python, NumPy , vertraut zu machen .

Was ist NumPy?
NumPy ist ein universelles Array-Verarbeitungspaket. Es bietet ein leistungsstarkes mehrdimensionales Array-Objekt und Tools für die Arbeit mit diesen Arrays.

Es ist das grundlegende Paket für wissenschaftliches Rechnen mit Python. Es enthält verschiedene Funktionen, einschließlich dieser wichtigen:

• Ein leistungsstarkes N-dimensionales Array-Objekt
• Anspruchsvolle (Rundfunk-) Funktionen
• Tools zur Integration von C / C ++ - und Fortran-Code
• Nützliche Funktionen für lineare Algebra, Fourier-Transformation und Zufallszahlen

Neben seiner offensichtlichen wissenschaftlichen Verwendung kann NumPy auch als effizienter mehrdimensionaler Container mit generischen Daten verwendet werden.
Mit Numpy können beliebige Datentypen definiert werden, wodurch NumPy nahtlos und schnell in eine Vielzahl von Datenbanken integriert werden kann.

Installation:

• Mac- und Linux- Benutzer können NumPy über den Befehl pip installieren:

  pip install numpy

• Windows hat keinen analogen Paketmanager wie Linux oder Mac.
  Bitte laden Sie das vorgefertigte Windows Installer für NumPy von hier (je nach Systemkonfiguration und Python - Version).
  Und dann installieren Sie die Pakete manuell.

Hinweis: Alle unten beschriebenen Beispiele können nicht auf einer Online-IDE ausgeführt werden.

1. Arrays in NumPy: Das Hauptobjekt von NumPy ist das homogene mehrdimensionale Array.

• Es ist eine Tabelle von Elementen (normalerweise Zahlen) vom gleichen Typ, die durch ein Tupel positiver Ganzzahlen indiziert sind.
• In NumPy werden Dimensionen als Achsen bezeichnet . Die Anzahl der Achsen ist Rang .
• Die Array-Klasse von NumPy heißt ndarray . Es ist auch durch das Alias- Array bekannt .

Beispiel:

[[1, 2, 3],
 [4, 2, 5]]
Hier,
Rang = 2 (da es zweidimensional ist oder 2 Achsen hat)
Länge der ersten Dimension (Achse) = 2, zweite Dimension Länge = 3
Die Gesamtform kann ausgedrückt werden als: (2, 3)

import numpy as np 
  
arr = np.array( [[ 1, 2, 3], 
                 [ 4, 2, 5]] ) 
  
print("Array is of type: ", type(arr)) 
  
print("No. of dimensions: ", arr.ndim) 
  
print("Shape of array: ", arr.shape) 
  
print("Size of array: ", arr.size) 
  
print("Array stores elements of type: ", arr.dtype) 

Ausgabe :

Das Array ist vom Typ: <Klasse>
Anzahl der Abmessungen: 2
Form des Arrays: (2, 3)
Größe des Arrays: 6
Das Array speichert Elemente vom Typ: int64 </ class>

2. Array-Erstellung: Es gibt verschiedene Möglichkeiten, Arrays in NumPy zu erstellen.

• Beispielsweise können Sie mit der Array- Funktion ein Array aus einer regulären Python- Liste oder einem Tupel erstellen . Der Typ des resultierenden Arrays wird aus dem Typ der Elemente in den Sequenzen abgeleitet.
• Oft sind die Elemente eines Arrays ursprünglich unbekannt, aber seine Größe ist bekannt. Daher bietet NumPy verschiedene Funktionen zum Erstellen von Arrays mit anfänglichem Platzhalterinhalt . Diese minimieren die Notwendigkeit wachsender Arrays, eine teure Operation.
  Zum Beispiel: np.zeros, np.ones, np.full, np.empty usw.
• Um Zahlenfolgen zu erstellen, bietet NumPy eine Funktion analog zum Bereich, die Arrays anstelle von Listen zurückgibt.
• arange: Gibt innerhalb eines bestimmten Intervalls gleichmäßig verteilte Werte zurück. Schrittgröße angegeben.
• linspace: Gibt innerhalb eines bestimmten Intervalls gleichmäßig verteilte Werte zurück. num nein von Elementen werden zurückgegeben.
• Array umformen : Wir können die Umformmethode verwenden, um ein Array umzuformen. Betrachten Sie ein Array mit Form (a1, a2, a3,…, aN). Wir können es umformen und in ein anderes Array mit Form (b1, b2, b3,…, bM) konvertieren. Die einzige erforderliche Bedingung ist:
  a1 x a2 x a3… x aN = b1 x b2 x b3… x bM. (dh die ursprüngliche Größe des Arrays bleibt unverändert.)
• Array reduzieren: Wir können die Flatten- Methode verwenden, um eine Kopie des Arrays in eine Dimension zu reduzieren . Er akzeptiert , um Argument. Der Standardwert ist 'C' (für die Hauptreihenfolge). Verwenden Sie 'F' für die Hauptreihenfolge der Spalte.

Hinweis: Der Array-Typ kann beim Erstellen des Arrays explizit definiert werden.

import numpy as np 
  
a = np.array([[1, 2, 4], [5, 8, 7]], dtype = 'float') 
print ("Array created using passed list:\n", a) 
  
b = np.array((1 , 3, 2)) 
print ("\nArray created using passed tuple:\n", b) 
  
c = np.zeros((3, 4)) 
print ("\nAn array initialized with all zeros:\n", c) 
  
d = np.full((3, 3), 6, dtype = 'complex') 
print ("\nAn array initialized with all 6s." 
            "Array type is complex:\n", d) 
  
e = np.random.random((2, 2)) 
print ("\nA random array:\n", e) 
  
f = np.arange(0, 30, 5) 
print ("\nA sequential array with steps of 5:\n", f) 
  
g = np.linspace(0, 5, 10) 
print ("\nA sequential array with 10 values between"
                                        "0 and 5:\n", g) 
  
arr = np.array([[1, 2, 3, 4], 
                [5, 2, 4, 2], 
                [1, 2, 0, 1]]) 
  
newarr = arr.reshape(2, 2, 3) 
  
print ("\nOriginal array:\n", arr) 
print ("Reshaped array:\n", newarr) 
  
arr = np.array([[1, 2, 3], [4, 5, 6]]) 
flarr = arr.flatten() 
  
print ("\nOriginal array:\n", arr) 
print ("Fattened array:\n", flarr) 

Ausgabe :

Array erstellt mit übergebener Liste:
 [[1. 2. 4.]
 [5. 8. 7.]]
Array erstellt mit übergebenem Tupel:
 [1 3 2]
Ein mit allen Nullen initialisiertes Array:
 [[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
Ein mit allen 6s initialisiertes Array. Der Array-Typ ist komplex:
 [[6. + 0.j 6. + 0.j 6. + 0.j]
 [6. + 0.j 6. + 0.j 6. + 0.j]
 [6. + 0.j 6. + 0.j 6. + 0.j]]
Ein zufälliges Array:
 [[0.46829566 0.67079389]
 [0.09079849 0.95410464]]
Ein sequentielles Array mit Schritten von 5:
 [0 5 10 15 20 25]
Ein sequentielles Array mit 10 Werten zwischen 0 und 5:
 [0. 0.55555556 1.11111111 1.66666667 2.22222222 2.77777778
  3.33333333 3.88888889 4.44444444 5.]
Ursprüngliches Array:
 [[1 2 3 4]
 [5 2 4 2]
 [1 2 0 1]]
Umgeformtes Array:
 [[[1 2 3]
  [4 5 2]]
 [[4 2 1]
  [2 0 1]]]
Ursprüngliches Array:
 [[1 2 3]
 [4 5 6]]
Mastarray:
 [1 2 3 4 5 6]

3. Array-Indizierung: Für die Analyse und Bearbeitung des Array-Objekts ist es wichtig, die Grundlagen der Array-Indizierung zu kennen. NumPy bietet viele Möglichkeiten zur Array-Indizierung.

• Slicing: Genau wie Listen in Python können NumPy-Arrays geschnitten werden. Da Arrays mehrdimensional sein können, müssen Sie für jede Dimension des Arrays einen Slice angeben.
• Indizierung ganzzahliger Arrays: Bei dieser Methode werden Listen für die Indizierung für jede Dimension übergeben. Eine Eins-zu-Eins-Zuordnung entsprechender Elemente wird durchgeführt, um ein neues beliebiges Array zu erstellen.
• Boolesche Array-Indizierung: Diese Methode wird verwendet, wenn Elemente aus dem Array ausgewählt werden sollen, die eine bestimmte Bedingung erfüllen.

import numpy as np 
  
arr = np.array([[-1, 2, 0, 4], 
                [4, -0.5, 6, 0], 
                [2.6, 0, 7, 8], 
                [3, -7, 4, 2.0]]) 
  
temp = arr[:2, ::2] 
print ("Array with first 2 rows and alternate"
                    "columns(0 and 2):\n", temp) 
  
temp = arr[[0, 1, 2, 3], [3, 2, 1, 0]] 
print ("\nElements at indices (0, 3), (1, 2), (2, 1),"
                                    "(3, 0):\n", temp) 
  
cond = arr > 0
temp = arr[cond] 
print ("\nElements greater than 0:\n", temp) 

Ausgabe :

Array mit den ersten 2 Zeilen und alternativen Spalten (0 und 2):
 [[-1. 0.]
 [4. 6.]]
Elemente bei den Indizes (0, 3), (1, 2), (2, 1), (3, 0):
 [4. 6. 0. 3.]
Elemente größer als 0:
 [2. 4. 4. 6. 2.6 7. 8. 3. 4. 2.]

4. Grundlegende Operationen: In NumPy stehen eine Vielzahl integrierter arithmetischer Funktionen zur Verfügung.

• Operationen auf einem einzelnen Array: Wir können überladene arithmetische Operatoren verwenden, um elementweise Operationen auf dem Array durchzuführen und ein neues Array zu erstellen. Bei Operatoren + =, - =, * = wird das vorhandene Array geändert.

import numpy as np 
  
a = np.array([1, 2, 5, 3]) 
  
print ("Adding 1 to every element:", a+1) 
  
print ("Subtracting 3 from each element:", a-3) 
  
print ("Multiplying each element by 10:", a*10) 
  
print ("Squaring each element:", a**2) 
  
a *= 2
print ("Doubled each element of original array:", a) 
  
a = np.array([[1, 2, 3], [3, 4, 5], [9, 6, 0]]) 
  
print ("\nOriginal array:\n", a) 
print ("Transpose of array:\n", a.T) 

Ausgabe :

1 zu jedem Element hinzufügen: [2 3 6 4]
Subtrahieren von 3 von jedem Element: [-2 -1 2 0]
Jedes Element mit 10 multiplizieren: [10 20 50 30]
Quadrieren jedes Elements: [1 4 25 9]
Verdoppelte jedes Element des ursprünglichen Arrays: [2 4 10 6]
Ursprüngliches Array:
 [[1 2 3]
 [3 4 5]
 [9 6 0]]
Transponieren des Arrays:
 [[1 3 9]
 [2 4 6]
 [3 5 0]]

• Unäre Operatoren: Viele unäre Operationen werden als Methode der ndarray- Klasse bereitgestellt . Dies umfasst Summe, Min, Max usw. Diese Funktionen können auch zeilen- oder spaltenweise angewendet werden, indem ein Achsenparameter festgelegt wird.

import numpy as np 
  
arr = np.array([[1, 5, 6], 
                [4, 7, 2], 
                [3, 1, 9]]) 
  
print ("Largest element is:", arr.max()) 
print ("Row-wise maximum elements:", 
                    arr.max(axis = 1)) 
  
print ("Column-wise minimum elements:", 
                        arr.min(axis = 0)) 
  
print ("Sum of all array elements:", 
                            arr.sum()) 
  
print ("Cumulative sum along each row:\n", 
                        arr.cumsum(axis = 1)) 

Ausgabe :

Größtes Element ist: 9
Zeilenweise maximale Elemente: [6 7 9]
Spaltenweise Mindestelemente: [1 1 2]
Summe aller Array-Elemente: 38
Kumulative Summe entlang jeder Zeile:
[[1 6 12]
 [4 11 13]
 [3 4 13]]

• Binäroperatoren : Diese Operationen gelten für das Array elementweise und ein neues Array wird erstellt. Sie können alle grundlegenden arithmetischen Operatoren wie +, -, / usw. verwenden. Bei Operatoren + =, - =, = wird das vorhandene Array geändert.

import numpy as np 
  
a = np.array([[1, 2], 
            [3, 4]]) 
b = np.array([[4, 3], 
            [2, 1]]) 
  
print ("Array sum:\n", a + b) 
  
print ("Array multiplication:\n", a*b) 
  
print ("Matrix multiplication:\n", a.dot(b)) 

Ausgabe:

Arraysumme:
[[5 5]
 [5 5]]
Array-Multiplikation:
[[4 6]
 [6 4]]
Matrix-Multiplikation:
[[8 5]
 [20 13]]

• Universelle Funktionen (ufunc): NumPy bietet bekannte mathematische Funktionen wie sin, cos, exp usw. Diese Funktionen arbeiten auch elementweise auf einem Array und erzeugen ein Array als Ausgabe.

Hinweis: Alle Operationen, die wir oben mit überladenen Operatoren ausgeführt haben, können mit ufuncs wie np.add, np.subtract, np.multiply, np.divide, np.sum usw. ausgeführt werden.

import numpy as np 
  
a = np.array([0, np.pi/2, np.pi]) 
print ("Sine values of array elements:", np.sin(a)) 
  
a = np.array([0, 1, 2, 3]) 
print ("Exponent of array elements:", np.exp(a)) 
  
print ("Square root of array elements:", np.sqrt(a)) 

Ausgabe:

Sinuswerte von Array-Elementen: [0.00000000e + 00 1.00000000e + 00 1.22464680e-16]
Exponent der Array-Elemente: [1. 2.71828183 7.3890561 20.08553692]
Quadratwurzel der Array-Elemente: [0. 1. 1.41421356 1.73205081]

4. Array sortieren : Es gibt eine einfache Methode np.sort zum Sortieren von NumPy-Arrays. Lassen Sie es uns ein bisschen erkunden.

import numpy as np 
  
a = np.array([[1, 4, 2], 
                 [3, 4, 6], 
              [0, -1, 5]]) 
  
print ("Array elements in sorted order:\n", 
                    np.sort(a, axis = None)) 
  
print ("Row-wise sorted array:\n", 
                np.sort(a, axis = 1)) 
  
print ("Column wise sort by applying merge-sort:\n", 
            np.sort(a, axis = 0, kind = 'mergesort')) 
  
dtypes = [('name', 'S10'), ('grad_year', int), ('cgpa', float)] 
  
values = [('Hrithik', 2009, 8.5), ('Ajay', 2008, 8.7),  
           ('Pankaj', 2008, 7.9), ('Aakash', 2009, 9.0)] 
             
arr = np.array(values, dtype = dtypes) 
print ("\nArray sorted by names:\n", 
            np.sort(arr, order = 'name')) 
              
print ("Array sorted by grauation year and then cgpa:\n", 
                np.sort(arr, order = ['grad_year', 'cgpa'])) 

Ausgabe:

Array-Elemente in sortierter Reihenfolge:
[-1 0 1 2 3 4 4 5 6]
Zeilenweise sortiertes Array:
[[1 2 4]
 [3 4 6]
 [-1 0 5]]
Spaltenweise Sortierung durch Anwendung der Zusammenführungssortierung:
[[0 -1 2]
 [1 4 5]
 [3 4 6]]
Array sortiert nach Namen:
[('Aakash', 2009, 9.0) ('Ajay', 2008, 8.7) ('Hrithik', 2009, 8.5)
 ('Pankaj', 2008, 7.9)]
Array sortiert nach Grauierungsjahr und dann cgpa:
[('Pankaj', 2008, 7.9) ('Ajay', 2008, 8.7) ('Hrithik', 2009, 8.5)
 ('Aakash', 2009, 9.0)]

Dies war also eine kurze, aber prägnante Einführung in die NumPy-Bibliothek.
Ausführlichere Informationen finden Sie im NumPy-Referenzhandbuch .
Dieser Artikel wurde von Nikhil Kumar verfasst. Wenn Ihnen GeeksforGeeks gefällt und Sie einen Beitrag leisten möchten, können Sie auch einen Artikel mit Contrib.geeksforgeeks.org schreiben oder Ihren Artikel an Contribute@geeksforgeeks.org senden. Sehen Sie sich Ihren Artikel auf der GeeksforGeeks-Hauptseite an und helfen Sie anderen Geeks.

Bitte schreiben Sie Kommentare, wenn Sie etwas Falsches finden oder weitere Informationen zu dem oben diskutierten Thema teilen möchten.