Dieser Beitrag ist eine formatierte Version meines Blogposts für Qiita. Wenn es zusätzliche Artikel gibt, werde ich sie auf dem Blog schreiben. __ "Einführung in die Python Numerical Calculation Library NumPy" __ http://rest-term.com/archives/2999/

Einführung in die Python Numerical Calculation Library NumPy

ScientificComputingToolsForPython—Numpy

NumPy ist eine Erweiterung der Programmiersprache Python, die Unterstützung für große mehrdimensionale Arrays und Matrizen sowie eine große übergeordnete mathematische Funktionsbibliothek für deren Bearbeitung bietet. (via Wikipedia)

Ich möchte NumPy überprüfen, dessen Wissen bisher nicht eindeutig war. NumPy wird häufig zusammen mit SciPy in wissenschaftlichen und technologischen Berechnungen verwendet. Da Matrixoperationen mit hoher Geschwindigkeit ausgeführt werden können, bietet OpenCV (Computer Vision Library) außerdem eine Python-Schnittstelle mit NumPy.

Als Referenz habe ich 2011 in meinem Blog die OpenCV Python-Bindung behandelt.

OpenCV auf Sakura VPS installieren und von Python aus verwenden

Umgebung

CentOS 6.4 (x86_64) Python 2.7.5 (ELF 64-bit LSB executable) NumPy 1.7.1

Was ist ein NumPy-Array (numpy.ndarray)?
Attribute von numpy.ndarray
Über den Datentyp
Sequenzgenerierung
Ändern Sie die Anordnungsform
Indexing
Fancy Indexing
Indexsuche
Operationen / Operationen auf Arrays
Array verbinden / teilen, Achsenmanipulation
Array sortieren
Operationen an Array-Elementen
Broadcasting
Array-Scan
Statistische Funktion
Dateieingabe / -ausgabe

Was ist ein NumPy-Array (numpy.ndarray)?

An ndarray is a (usually fixed-size) multidimensional container of items of the same type and size.

numpy.ndarray ist eine Klasse, die mehrdimensionale Arrays verarbeitet. Grundsätzlich gibt es folgende Einschränkungen.

Alle Elemente im Array haben den gleichen Typ
Array mit fester Länge (Array mit fester Länge)
Die Anzahl der Elemente in jeder Dimension des Arrays ist gleich

(* Die Form der Anordnung kann jedoch mit Einschränkungen geändert werden. Die Erklärung wird später beschrieben.) Es ist einem C-Spracharray sehr ähnlich. Aufgrund der Einschränkung ist es beim Umgang mit großen Arrays effizienter als der Listentyp von Python. Wenn der Begriff "Array" danach verwendet wird, bezieht er sich im Wesentlichen auf numpy.ndarray.

`import`


##Es scheint üblich, beim Importieren einen Alias von np anzugeben.
import numpy as np

Attribute von numpy.ndarray

Die Hauptattribute von numpy.ndarray sind wie folgt. Die Daten im ndarray werden zur effizienten Verarbeitung in einem zusammenhängenden Speicherbereich gespeichert (). Sie können jedoch anhand dieser Attribute sehen, wie die Daten im Speicher angeordnet sind.

An instance of class ndarray consists of a contiguous one-dimensional segment of computer memory

Internal memory layout of an ndarray


ndarray.flags	Speicherlayoutinformationen für Arraydaten(numpy.flagsobj)
ndarray.ndim	Anzahl der Dimensionen des Arrays
ndarray.size	Anzahl der Elemente im Array
ndarray.shape	Anzahl der Elemente in jeder Dimension
ndarray.itemsize	Anzahl der Bytes pro Element
ndarray.strides	Anzahl der Bytes, die erforderlich sind, um zum nächsten Element in jeder Dimension zu gelangen
ndarray.nbytes	Anzahl der Bytes im gesamten Array
ndarray.dtype	Array-Element-Datentyp(numpy.dtype)

`numpy.ndarray`


##Zweidimensionales Array(Warteschlange)
>>> a = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
>>> a
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])
>>> a.flags
  C_CONTIGUOUS : True   ##Sind die Daten kontinuierlich im Speicher?(C-Array-Typ)
  F_CONTIGUOUS : False  ##Das gleiche wie oben(Fortran-Array-Typ)
  OWNDATA : True        ##Zeigen Sie an, ob es sich um Ihre eigenen Daten handelt(Siehe unten)Im Falle von False
  WRITEABLE : True      ##Ist es möglich, die Daten zu ändern?
  ALIGNED : True        ##Ist der Datentyp ausgerichtet?
  UPDATEIFCOPY : False  ##Sie können es nicht in True ändern, sodass Sie sich darüber keine Sorgen machen müssen.
>>> a.ndim              ##Anzahl der Dimensionen
2
>>> a.size              ##Elementanzahl
12
>>> a.shape             ##Anzahl der Elemente in jeder Dimension(Anzahl der Zeilen,Anzahl der Spalten)
(4, 3)
>>> a.itemsize          ##Anzahl der Bytes pro Element
8
>>> a.strides           ##24 Bytes für die nächste Zeile, 8 Bytes für die nächste Spalte
(24, 8)
>>> a.nbytes            ##Anzahl der Bytes im gesamten Array(size*itemsize)
96
>>> a.dtype             ##Elementdatentyp(Siehe unten)
dtype('int64')

Schritte zeigen an, dass a [0,0] und a [0,1] 8 Bytes voneinander entfernt sind und a [0,0] und a [1,0] im Speicher 24 Bytes voneinander entfernt sind. Wenn die Datensequenz vom Typ Fortran ist, sind Streiks (8, 32). Bei einer Dimension ist weder der C-Typ noch der Fortran-Typ relevant.

Über den Datentyp

Der Datentyp des Array-Elements wird von einem Objekt namens numpy.dtype verarbeitet. Die Typen, die angegeben werden können, sind grob in fünf Typen unterteilt: logischer Typ, vorzeichenbehafteter Integer-Typ, vorzeichenloser Integer-Typ, Gleitkomma-Typ und komplexer Zahlentyp. Danach können Sie jedes durch die Anzahl der Bits des Datentyps angeben. Weitere Informationen finden Sie auf der offiziellen Website.

Data types — NumPy

`datatypes`


## numpy.array()Wenn Sie die Option dtype in nicht angeben, wird sie automatisch festgelegt.
##Da es sich hier um eine 64-Bit-Umgebung handelt, wird sie mit einem 64-Bit-Typ generiert.
>>> a = np.array([1,2,3,4,5])
>>> a.dtype
dtype('int64')    ##64-Bit-Ganzzahl mit Vorzeichen
>>> a.itemsize
8
>>> a = np.array([1.0,2.0,3.0,4.0,5.0])
>>> a.dtype
dtype('float64')  ##64-Bit-Gleitkommazahl
>>> a.itemsize
8
## numpy.array()Geben Sie die Option dtype mit an
##32-Bit-Ganzzahl mit Vorzeichen
>>> a = np.array([1,2,3], dtype=np.int32)
>>> a.dtype
dtype('int32')
>>> a.itemsize
4
##8-Bit-Ganzzahl ohne Vorzeichen(Wird häufig in der Bildverarbeitung verwendet)
>>> a = np.array([1,2,3], dtype=np.uint8)
>>> a.dtype
dtype('uint8')
>>> a.itemsize
1

Sie können auch Datentypen umwandeln. Verwenden Sie ndarray.astype ().

`ndarray.astype()`


>>> a = np.array([1, 2, 3, 4, 5]))
>>> a.dtype
dtype('int64')
##Umwandlung vom Typ int64 in den Typ int32
>>> a.astype(np.int32)
array([1, 2, 3, 4, 5], dtype=int32)

>>> a = np.array([1.2, 2.4, 3.6, 4.8, 5.0])
>>> a.dtype
dtype('float64')
##Vom Typ float64 in int64 umwandeln und nach dem Dezimalpunkt abschneiden
>>> a.astype(np.int64)
array([1, 2, 3, 4, 5])

Downcasting löst keine Ausnahme aus. Beachten Sie auch, dass ndarray.astype () ein neues Array erstellt und zurückgibt.

Sequenzgenerierung

Zunächst, wie man ein Array generiert. Es gibt viele Generierungsmethoden, aber hier konzentrieren wir uns auf die grundlegenden und häufig verwendeten Methoden.

`python`


>>> import numpy as np
## numpy.array()Erstellt von, Liste als Argument(Oder Taple)geben
>>> np.array([1,4,3,2,5])
array([1, 4, 3, 2, 5])
##Das zweidimensionale Array ist ebenfalls in Ordnung
>>> np.array([[3,1,2], [6,4,5]])
array([[3, 1, 2],
       [6, 4, 5]])

## numpy.zeros()Generiert von ist der Wert aller Elemente 0
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
>>> np.zeros([2,3])
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])

## numpy.ones()Generiert von ist der Wert aller Elemente 1
>>> np.ones(5)
array([ 1.,  1.,  1.,  1.,  1.])
>>> np.ones([2,3])
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

## numpy.identity()Erstellt von, Einheitsmatrix(Da es sich um eine quadratische Matrix handelt, gibt es ein Argument.)
>>> np.identity(3)
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])

## numpy.eye()Erzeugt von, Identität()Ähnlich wie, aber Sie können die Anzahl der Spalten angeben
>>> np.eye(3, 2)
array([[ 1.,  0.],
       [ 0.,  1.],
       [ 0.,  0.]])

## numpy.arange()Erstellt von, eingebauter Bereich()Gleiches Verfahren wie
>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
## (Startpunkt,Endpunkt,inkrementell)Angeben
>>> np.arange(1.0, 2.0, 0.2)
array([ 1. ,  1.2,  1.4,  1.6,  1.8])

## numpy.linspace()Erstellt von, arrangieren()Ähnlich wie, aber Sie können die Anzahl der Elemente angeben
>>> np.linspace(1, 4, 6)
array([ 1. ,  1.6,  2.2,  2.8,  3.4,  4. ])

## numpy.logspace()Der Wert von wird durch eine logarithmische Skala generiert(Gemeinsamer Logarithmus)Angestellt mit
>>> np.logspace(2, 3, 4)
array([  100.        ,   215.443469  ,   464.15888336,  1000.        ])
##Unterseite(base)Wird als 2 angegeben
>>> np.logspace(2, 4 ,4, base=2)
array([  4.        ,   6.34960421,  10.0793684 ,  16.        ])

## numpy.tile()Gibt ein Array wiederholter Elemente zurück, die von generiert wurden
>>> np.tile([0,1,2,3,4], 2)
array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4])

## numpy.meshgrid()Erzeugt durch eine gitterartige Anordnung, die vertikal und horizontal gleichmäßig verteilt ist
>>> a, b = np.meshgrid([1,2,3], [4,5,6,7])
>>> a
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])
>>> b
array([[4, 4, 4],
       [5, 5, 5],
       [6, 6, 6],
       [7, 7, 7]])

## numpy.tri()Erzeugt durch dreieckige Matrix
>>> np.tri(3)
array([[ 1.,  0.,  0.],
       [ 1.,  1.,  0.],
       [ 1.,  1.,  1.]])

## numpy.diag()Gibt ein Array mit diagonalen Elementen zurück, die aus dem von generierten Eingabearray extrahiert wurden
>>> a = np.array([[0,1,2], [3,4,5], [6,7,8]])
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> np.diag(a)
array([0, 4, 8])

## numpy.empty()Erstellt von, nur sicherer Bereich, nicht initialisiert
>>> np.empty(5)
array([  1.06452759e-312,   1.06452759e-312,   1.00000000e+000,
         1.00000000e+000,   2.37151510e-322])

## ndarray.copy()Tiefe Kopie des Arrays mit
>>> a = np.array([1,2,3])
>>> b = a.copy()

## numpy.Verwendung eines Zufallsmoduls
## numpy.random.randint()Generieren Sie ein Array mit ganzzahligen Zufallswerten als Elementen
##Bereich der zu generierenden Zufallszahlen(Minimalwert, Maximalwert), Geben Sie die Anzahl der Elemente an
>>> np.random.randint(0,100,10)
array([54, 68, 19, 57, 23, 27, 36, 99, 53, 70])

Änderung der Arrayform

Das ndarray-Objekt kann die Arrayform mit Einschränkungen ändern.

Anzeigen (siehe) Das von einigen NumPy-Operationen zurückgegebene Objekt wird als Ansicht bezeichnet und verweist auf die Originaldaten. Beachten Sie daher, dass durch Ändern des Werts in der Ansicht auch die Originaldaten geändert werden.

`python`


##Eindimensionales Array
>>> a = np.arange(10)
>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

## ndarray.reshape()Ändern Sie die Anordnungsform mit
##Wechseln Sie zu einem zweidimensionalen Array und geben Sie eine Ansicht zurück
>>> b = a.reshape((2,5))
>>> b
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
##Ändern Sie den Wert der Ansicht
>>> b[0] = 100
>>> b
array([[100, 100, 100, 100, 100],
       [  5,   6,   7,   8,   9]])
##Die Originaldaten werden ebenfalls geändert
>>> a
array([100, 100, 100, 100, 100,   5,   6,   7,   8,   9])
##Ein Fehler tritt auf, wenn die Anzahl der Elemente unterschiedlich ist.
>>> a.reshape((2,3))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: total size of new array must be unchanged

## ndarray.resize()Ändern Sie die Anordnungsform mit(in-place)
>>> a = np.arange(10)
##Wechseln Sie zu einem zweidimensionalen Array mit der gleichen Anzahl von Elementen, ohne dass eine Ansicht zurückgegeben wird
>>> a.resize((2,5))
##Die Form der Originaldaten wird geändert
>>> a
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
##Anzahl der Elemente, wenn die Variable auch nach der Generierung einmal referenziert wird(Sequenzlänge)Kann nicht geändert werden
>>> a.resize(11)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot resize an array references or is referenced
by another array in this way.  Use the resize function
##Wenn die Refcheck-Option jedoch auf False gesetzt ist, wird keine Referenzprüfung durchgeführt.
>>> a.resize(11, refcheck=False)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0])

## ndarray.flatten()Wechseln Sie zu einem eindimensionalen Array und geben Sie eine Kopie anstelle einer Ansicht zurück
>>> a = np.arange(10).reshape((2,5))
>>> a
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
>>> b = a.flatten()
>>> b
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Es ist eine gute Idee zu wissen, ob das zurückgegebene Array eine Ansicht oder eine Kopie ist. Außerdem wird ndarray.reshape () häufig verwendet, daher ist es eine gute Idee, sich auch daran zu erinnern.

Indexing Führt die Referenz / Zuweisung von Array-Elementen, das Array-Slice usw. ein. Es ähnelt im Grunde der Liste von Python, hat jedoch eine erweiterte Syntax. Probieren Sie es aus.

`python`


##Zweidimensionales Array(Warteschlange)
>>> a = np.array([[0,1,2], [3,4,5], [6,7,8]])
>>> a
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

##Elementreferenz/Auswechslung(Gleich wie Liste)
>>> a[2]
array([7, 8, 9])
>>> a[1][2]
6
>>> a[1][2] = 1
>>> a[1][2]
1
##IndexError, wenn außerhalb des Bereichs angegeben ist
>>> a[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: index out of bounds

##Referenz durch Kommas getrennt/Auswechslung(Erweiterte Syntax)
## a[Linie,Säule]
>>> a[1,2]  
6
##Wenn Sie eine negative Zahl für den Index angeben, zählt diese ab dem Ende
>>> a[-1,-2]
8
>>> a[1,2] = 10
>>> a[1,2]
10

##Scheibe(Die Notation entspricht der Liste, der Rückgabewert ist die Ansicht)
## a[start:end:step]
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a[1:8:2]
array([1, 3, 5, 7])
>>> a[3:]    ## a[3:10:1]
array([3, 4, 5, 6, 7, 8, 9])
>>> a[:8]    ## a[0:8:1]
array([0, 1, 2, 3, 4, 5, 6, 7])
>>> a[::-2]  ## a[-1:-10:-2]
array([9, 7, 5, 3, 1])

##Kann kombiniert werden
>>> a = np.arange(25).reshape((5,5))
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])
>>> a[:,3] = 10     ## a[0:5:1,3] = 10 (Aktualisieren Sie mehrere Elemente gleichzeitig)
>>> a
array([[ 0,  1,  2, 10,  4],
       [ 5,  6,  7, 10,  9],
       [10, 11, 12, 10, 14],
       [15, 16, 17, 10, 19],
       [20, 21, 22, 10, 24]])
>>> a[:2,:3] = 100  ## a[0:2:1,0:3:1] = 100
>>> a
array([[100, 100, 100,  10,   4],
       [100, 100, 100,  10,   9],
       [ 10,  11,  12,  10,  14],
       [ 15,  16,  17,  10,  19],
       [ 20,  21,  22,  10,  24]])
>>> a[2::2,::2]     ## a[2:5:2,0:5:2](Fälle, die schwer zu lesen sind, wenn sie weggelassen werden)
array([[10, 12, 14],
       [20, 22, 24]])

Fancy Indexing Es ist auch möglich, einen speziellen Index anzugeben, der durch die Position und die Bedingungen des Elements maskiert ist.

`python`


>>> a = np.arange(15,0,-1)
>>> a
array([15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1])
##Index, der als ganzzahliges Array angegeben wird, gibt eine Kopie zurück
>>> a[[0,2,4,8]]
array([15, 13, 11,  7])
##Im Array vom Typ Bool angegebener Index, Kopie zurückgeben
>>> n = a>10
>>> n
array([ True,  True,  True,  True,  True, False, False, False, False,
       False, False, False, False, False, False], dtype=bool)
>>> a[n]
array([15, 14, 13, 12, 11])
##Es ist in Ordnung, die Bedingung direkt im Index anzugeben
>>> a[a>10]
array([15, 14, 13, 12, 11])
##Verwenden Sie den Bitoperator, wenn mehrere Bedingungen vorliegen
>>> a[(4<a) & (a<10)]
array([9, 8, 7, 6, 5])
##Sie können auch Werte zuweisen
>>> a[a<8] = 0
>>> a
array([15, 14, 13, 12, 11, 10,  9,  8,  0,  0,  0,  0,  0,  0,  0])

Indexsuche

`python`


## numpy.argmax()Gibt den kleinsten Index der Maximalwertelemente zurück
>>> a = np.tile(np.arange(3),3)
>>> a
array([0, 1, 2, 0, 1, 2, 0, 1, 2])
>>> np.argmax(a)
2

## numpy.argmin()Gibt den kleinsten Index der Minimalwertelemente zurück
>>> np.argmin(a)
0

## numpy.nonzero()Gibt ein Indexarray von Nicht-Null-Elementen in zurück
>>> a = np.eye(3)
>>> a
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])
>>> np.nonzero(a)  ##Da es sich um ein zweidimensionales Array handelt, werden zwei Arrays zurückgegeben.
(array([0, 1, 2]), array([0, 1, 2]))

## numpy.where()Gibt ein Indexarray von Elementen zurück, die die Bedingungen in erfüllen
>>> a = np.arange(15).reshape((3,5))
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> np.where(a%2==0)
(array([0, 0, 0, 1, 1, 2, 2, 2]), array([0, 2, 4, 1, 3, 0, 2, 4]))

## numpy.select()Durchsuchen Sie mehrere Bedingungen mit und setzen Sie den Wert auf den Index
##Erstes Argument:Array von Bedingungen(Bool-Array)
##Zweites Argument:Ein Array von Werten, die im Index des Elements festgelegt werden sollen, das der Bedingung entspricht
>>> a = np.arange(10)
>>> np.select([a<3, a>5], [a, a**2])
array([ 0,  1,  2,  0,  0,  0, 36, 49, 64, 81])

Obwohl die interne Struktur von ndarray dem C-Array ähnlich ist, ist die Schnittstelle wirklich eine hochklassige Sprache. Wenn Sie jedoch beim Array-Slicing zu viel NumPy-spezifische Notation verwenden, ist das Lesen möglicherweise schwierig. Daher scheint es besser, sie bei der Entwicklung mit mehreren Personen bescheiden zu verwenden.

Operationen / Operationen auf Arrays

Zusätzlich zu der oben erwähnten Änderung der Anordnungsform sind verschiedene Operationen möglich. Ich kann hier nicht alle behandeln, daher werde ich nur einen Teil von ihnen auflisten.

Array verbinden / teilen, Achsenmanipulation

`python`


>>> a = np.arange(9).reshape((3,3))
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> b = np.arange(8,-1,-1).reshape((3,3))
>>> b
array([[8, 7, 6],
       [5, 4, 3],
       [2, 1, 0]])

## numpy.dstack()Kombinieren Sie zweidimensionale Arrays zu einem dreidimensionalen Array mit
>>> np.dstack((a,b))
array([[[0, 8],
        [1, 7],
        [2, 6]],

       [[3, 5],
        [4, 4],
        [5, 3]],

       [[6, 2],
        [7, 1],
        [8, 0]]])

## numpy.hstack()Verbinden Sie in Spaltenrichtung mit
>>> np.hstack((a,b))
array([[0, 1, 2, 8, 7, 6],
       [3, 4, 5, 5, 4, 3],
       [6, 7, 8, 2, 1, 0]])

## numpy.vstack()Verbinden Sie in der Zeilenrichtung mit
>>> np.vstack((a,b))
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8],
       [8, 7, 6],
       [5, 4, 3],
       [2, 1, 0]])

## numpy.dsplit()Teilen Sie ein dreidimensionales Array mit
>>> a = np.arange(16).reshape(2,2,4)
>>> a
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

>>> np.dsplit(a,2)
[array([[[ 0,  1],
        [ 4,  5]],

       [[ 8,  9],
        [12, 13]]]), array([[[ 2,  3],
        [ 6,  7]],

       [[10, 11],
        [14, 15]]])]

## numpy.hsplit()In Spaltenrichtung mit teilen
>>> a = np.arange(16).reshape(4,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
>>> np.hsplit(a,2)
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]

## numpy.vsplit()In Zeilenrichtung mit teilen
>>> np.vsplit(a,2)
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]

## numpy.transpose()Transponieren Sie das Array mit
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
       [3, 4]])
>>> np.transpose(a)
array([[1, 3],
       [2, 4]])
## ndarray.T ist in Ordnung
>>> a.T
array([[1, 3],
       [2, 4]])
       
## numpy.swapaxes()Ersetzen der Welle durch
>>> a = np.array([[1,2,3]])
>>> np.swapaxes(a, 0, 1)
array([[1],
       [2],
       [3]])

Array sortieren

`python`


## numpy.sort()Sortieren Sie das Array mit und geben Sie eine Kopie zurück
>>> a = np.random.randint(0,100,10)
>>> a
array([75, 24, 74, 49, 93, 18, 19, 85, 73, 90])
>>> np.sort(a)
array([18, 19, 24, 49, 73, 74, 75, 85, 90, 93])

## ndarray.sort()Zerstörerische Anordnung mit(in-place)Sortieren nach
>>> a.sort()
>>> a
array([18, 19, 24, 49, 73, 74, 75, 85, 90, 93])

##Für mehrdimensionale Arrays
>> a = np.array([[1,4,2],[9,6,8],[5,3,7]])
>>> a
array([[1, 4, 2],
       [9, 6, 8],
       [5, 3, 7]])
>>> np.sort(a)
array([[1, 2, 4],
       [6, 8, 9],
       [3, 5, 7]])
##Geben Sie die Achse an(Hier nach Spalten sortieren)
>>> np.sort(a, axis=0)
array([[1, 3, 2],
       [5, 4, 7],
       [9, 6, 8]])
##Sortieren Sie in einem eindimensionalen Array
>>> np.sort(a, axis=None)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

Operationen an Array-Elementen

Es bietet elementweise arithmetische Funktionen für verschiedene Array-Elemente. Viele dieser Funktionen können auch mit jedem Bediener verwendet werden.

`python`


>>> a = np.array([1,2,3])
>>> b = np.array([4,5,6])
##Hinzufügen
>>> a + b    ## np.add(a,b)
array([5, 7, 9])
##Subtrahieren
>>> b - a    ## np.subtract(b,a)
array([3, 3, 3])
##Multiplizieren
>>> a * b    ## np.multiply(a,b)
array([ 4, 10, 18])
##Teilung
>>> b / a    ## np.divide(b,a)
array([4, 2, 2])
##Überschuss
>>> a % b    ## np.mod(a,b)
array([1, 2, 3])
##Reiten
>>> a ** b   ## np.power(a,b)
array([  1,  32, 729])
##Vorzeichenumkehrung
>>> -a       ## np.negative(a)
array([-1, -2, -3])

Broadcasting Jede Operation für die obigen Array-Elemente wurde zwischen Arrays derselben Größe / Form ausgeführt. Mit NumPy ist es jedoch auch möglich, Operationen zwischen Arrays unterschiedlicher Größe / Form auszuführen, was als Broadcast bezeichnet wird.

`python`


>>> a = np.array([1,2,3,4,5])
>>> b = np.array([10])
>>> a * b    ## (1,5) * (1,1) = (1,5)
array([10, 20, 30, 40, 50]

>>> a = np.array([0,10,20,30]).reshape((4,1))
>>> a
array([[ 0],
       [10],
       [20],
       [30]])
>>> b = np.array([0,1,2])
>>> a + b    ## (4,1) + (1,3) = (4,3)
array([[ 0,  1,  2],
       [10, 11, 12],
       [20, 21, 22],
       [30, 31, 32]])

##Beispiele, die nicht gesendet werden können
>>> b = np.array([[1,2],[3,4]])
>>> a + b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (4,1) (2,2)

Das zweite Beispiel ist interessant. Wenn Sie die Broadcast-Funktion gut nutzen, können Sie anscheinend die Codemenge erheblich reduzieren.

Array-Scan

Sie können ein Array mit der for-In-Syntax wie eine Liste scannen.

`python`


>>> a = np.arange(9).reshape((3,3))
>>> a
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

##aufführen(list)Kann sowohl mit als auch mit gescannt werden
##Hier scannen wir Zeile für Zeile
>>> for row in a:
...     print row
...
[0 1 2]
[3 4 5]
[6 7 8]
       
## numpy.ndenumerate()Scannen eines mehrdimensionalen Arrays mit
## enumerate()Sie können den Index ebenso erhalten wie
>>> for i, value in np.ndenumerate(a):
...     print i, value
...
(0, 0) 0
(0, 1) 1
(0, 2) 2
(1, 0) 3
(1, 1) 4
(1, 2) 5
(2, 0) 6
(2, 1) 7
(2, 2) 8

## ndarray.Scannen Sie als eindimensionales Array mit flach
>>> for value in a.flat:
...     print value
...
0
1
2
3
4
5
6
7
8

Statistische Funktion

NumPy bietet eine Reihe von Funktionen für die grundlegende statistische Verarbeitung.

`python`


>>> a = np.random.randint(0,500,20)
>>> a
array([260, 253, 185, 240, 252, 375,  63, 413, 293, 431, 207, 230, 288,
       462, 270, 477, 451,  58, 408, 492])
>>> np.amax(a)       ##Maximalwert
492
>>> np.amin(a)       ##Mindestwert
58
>>> np.ptp(a)        ##Wertebereich(Maximalwert-Mindestwert)
434
>>> np.mean(a)       ##Arithmetischer Durchschnitt
305.39999999999998
>>> np.median(a)     ##Median
279.0
>>> np.std(a)        ##Standardabweichung
125.73519793597973
>>> np.var(a)        ##Verteilt
15809.34
>>> b = np.random.randint(0,500,20)
>>> b
array([313, 117, 167, 353, 468, 289, 177, 196,  20,  70, 235, 280, 480,
       125, 195, 271, 253,  55,  49, 354])
>>> np.corrcoef(a,b) ##Korrelationskoeffizient
array([[ 1.        ,  0.05950681],
       [ 0.05950681,  1.        ]])
>>> c = np.random.randint(0,10,20)
>>> c
array([3, 8, 7, 9, 1, 8, 4, 0, 8, 3, 9, 4, 2, 1, 4, 3, 0, 4, 8, 4])
>>> np.histogram(c)  ##Histogramm
(array([2, 2, 1, 3, 5, 0, 0, 1, 4, 2]), array([ 0. ,  0.9,  1.8,  2.7,  3.6,  4.5,  5.4,  6.3,  7.2,  8.1,  9. ]))

Wenn Sie eine erweiterte statistische Verarbeitung durchführen möchten, werden Sie wahrscheinlich SciPy verwenden.

Dateieingabe / -ausgabe

Sie können auch Array-Datendateien eingeben und ausgeben. Diese Funktion wird häufig in experimentellen Arbeiten übernommen.

`python`


>>> a = np.array([[1,3,2], [4,6,5]])
>>> a
array([[1, 3, 2],
       [4, 6, 5]])
## numpy.savetxt()Schreiben Sie Array-Daten in eine Datei im ASCII-Format mit
>>> np.savetxt('data.txt', a)
##Delimita kann optional frei angegeben werden(TSV-Format)
>>> np.savetxt('data.txt', a, delimiter='\t')

##Da es im ASCII-Format vorliegt, kann der Inhalt der Datei von Menschen gelesen werden.
$ cat data.txt
1.000000000000000000e+00        3.000000000000000000e+00        2.000000000000000000e+00
4.000000000000000000e+00        6.000000000000000000e+00        5.000000000000000000e+00

## numpy.loadtxt()Lesen Sie Array-Daten aus einer Textdatei mit
>>> np.loadtxt('data.txt', delimiter='\t')
array([[ 1.,  3.,  2.],
       [ 4.,  6.,  5.]])

## numpy.save()Schreiben Sie Array-Daten in eine Datei im Binärformat mit
##Die Erweiterung der Ausgabedatei lautet.Werde npy
>>> np.save('data', a)

## numpy.load()Lesen Sie Array-Daten aus der Binärdatei mit
>>> np.load('data.npy')
array([[1, 3, 2],
       [4, 6, 5]])

## numpy.savez()Schreiben Sie mehrere Array-Daten in eine Datei im Binärformat mit
>>> a, y = np.meshgrid([1,2,3], [4,5,6,7])
>>> a
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])
>>> y
array([[4, 4, 4],
       [5, 5, 5],
       [6, 6, 6],
       [7, 7, 7]])
##Die Erweiterung der Ausgabedatei lautet.wird npz
>>> np.savez('data', x=x, y=y)

## .npy, .Beide npz-Dateien sind numpy.load()Kann von gelesen werden
>>> npz = np.load('data.npz')
>>> npz.files
['y', 'x']
>>> npz['x']
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])
>>> npz['y']
array([[4, 4, 4],
       [5, 5, 5],
       [6, 6, 6],
       [7, 7, 7]])

Wenn Sie eine große Datenmenge speichern, ist es besser, sie im Binärformat zu speichern, da die Dateigröße kleiner ist.

Dieses Mal habe ich versucht, die Grundlagen von NumPy zu organisieren. Ich benutze NumPy selten alleine, aber bei der Verwendung der Python-Bindungen von OpenCV werde ich oft umsorgt. Da NumPy viele Funktionen hat, müssen Sie bei jeder Verwendung auf die offizielle Referenz verweisen.