Python--numpy (kontinuierlich aktualisiert)

1. Ndarray-Array

(1) numpy.array()

N-dimensionales Array-Objekt (Matrix), alle Elemente müssen vom gleichen Typ sein.
Das Numpy-Objekt ist in Array-Array und Matrix-Mat unterteilt, die von der Liste der Liste unterschieden werden müssen

1. Die erste Dimension eines zweidimensionalen Arrays ist eine Spalte und die zweite Dimension ist eine Zeile; (3, 2) bedeutet, dass die dritte Zeile nach einer Spalte sortiert ist und die zweite Zeile nach der zweiten, also dritten, sortiert ist Zeile und die zweite Spalte
2. [0,1,2] kann eine eindimensionale Matrix darstellen, [[0,1,2]] stellt eine zweidimensionale Matrix 1*3 dar

---

(2) numpy.asarray()

np.array und np.asarray haben die gleiche Funktion, beide konvertieren die Eingabe in das Matrixformat. Wenn es sich bei der Eingabe um eine Liste handelt, wirkt sich die Änderung des Werts der Liste nicht auf den in
eine Matrix konvertierten Wert aus. Wenn es sich bei der Eingabe um ein Array handelt, kopiert np.array die Eingabe und np.asarray schneidet die Eingabe aus, sodass sie als Eingabe dient Änderungen np Die Ausgabe von .array bleibt unverändert, während sich die Ausgabe von np.asarray ändert. Wenn wir np.asarray verwenden, um seinen Typ zu ändern (die Eingabe ist float64, wird in float32 geändert), ändert sich also die Ausgabe, wenn sich die Eingabe ändert von np.asarray Es wird sich auch nicht ändern.
 

2. Die Methode von numpy.array()

(1) Grundattribute

1. .ich bin es

Gibt die Anzahl der Dimensionen an
 

2. .dtype

(Datentypobjekt)-Eigenschaft, die den Datentyp darstellt

import numpy

data=[[1,2],[3,4],[5,6]]
x=numpy.array(data)

print(x)
#[[1 2],[3 4],[5 6]]
print(x.ndim)
#2
print(x.dtype)
#int32

 

(2) numpy.shape und numpy.reshape

1.numpy.shape(array) / .shape

Es wird verwendet, um die Länge der Matrix zu lesen und die Größe jeder Dimension anzugeben.
 
Der frühere Rückgabewert:

• Wenn das Parameterarray eine Zahl ist, wird ein leeres Tupel zurückgegeben.
• Wenn es sich um eine eindimensionale Matrix handelt, wird ein Zahlentupel zurückgegeben.
• Geben Sie für eine zweidimensionale Matrix ein Tupel aus Zeilen und Spalten zurück

Der Rückgabewert des letzteren: Schauen Sie sich das vorherige Array-Array an, das andere ist das gleiche wie oben, ohne „()“

Man kann davon ausgehen, dass eindimensional die äußerste eckige Klammer ist, eine eindimensionale Zahl die Anzahl der Elemente in der äußersten eckigen Klammer ist, zweidimensional die zweite Ebene ist und so weiter

import numpy as np

print(np.shape(7))
#()

a=numpy.array([7,8])
print(a.shape)
#(2,)

print(np.shape([[7,8],[1,2],[100,102]]))
#(3, 2)

 

2.numpy.reshape(array, (newshape)) / .reshape(newshape)

Wird verwendet, um einem Array eine neue Form zu geben, ohne die Daten zu ändern.
 
Parameter:
(1) Array: das Array, das umgeformt werden muss.
(2) NewShape: Die neue Form sollte mit der Originalform kompatibel sein. Bei einer Ganzzahl ist das Ergebnis ein 1D-Array dieser Länge. Eine Formdimension kann -1 oder andere negative Zahlen sein. In diesem Fall wird der Wert vom System basierend auf der Länge und den verbleibenden Abmessungen des Arrays abgeleitet.

import numpy as np

a=np.array([[2,3,4],[5,6,7]])
a=np.reshape(a,(3,2))
print(a)
#[[2 3],[4 5],[6 7]]

b=np.array([[2,3,4],[5,6,7]])
b=b.reshape(2,-2)
print(b)
#[[2 3 4],[5 6 7]]

c=b.reshape(-1,2)
print(c)
#[[2 3],[4 5],[6 7]]

---

veranschaulichen:

Das neu generierte Reshape-Array und das ursprüngliche Array teilen sich einen Speicher. Unabhängig davon, welches geändert wird, wirkt es sich gegenseitig aus

import numpy as np

a=np.array([[1,2],
            [3,4]])
b=a.reshape(1,4)
b*=2

print(a)
#[[2 4]
# [6 8]]
print(b)
#[[2 4 6 8]]

Ein Array kann mit arange und reshape gleichzeitig erstellt werden

import numpy as np
print(np.arange(1,6).reshape(5,1))
#[[1]
# [2]
# [3]
# [4]
# [5]]

 

(3) Daten und Sortierung

1.numpy.sum(array,axis,dtype) / .sum(axis,dtype)

Summationsparameter
 
:
(1) Array
(2) Achse: Dimension, der Standardwert ist -1
(3) dtype
 

2.numpy.max(array,axis,dtype) / .max(axis,dtype)

Finden Sie das Maximum
 

3.numpy.min(array,axis,dtype) / .min(axis,dtype)

Finden Sie das Minimum
 

4.numpy.abs(array,axis,dtype) / .abs(axis,dtype)

Finden Sie den absoluten Wert

---

Unterscheiden Sie zwischen np.min(), np.max(), np.abs() und min(), max(), abs()
 

5.numpy.average(array,axis,dtype) / .average(axis,dtype)

Durchschnitt
 

6.numpy.sort(array,axis,dtype) / .sort(axis,dtype)

Sortieren

import numpy as np

vector1=np.array([26,10,15,20])

print(vector1.sum())
#71
print(vector1.max())
#26
print(vector1.min())
#10
print(np.average(vector1))
#17.75
print(np.sort(vector1))
#[10 15 20 26]

vector2=np.array([[35,5,15],
                     [10,25,45],
                     [20,40,30]])

print(vector2)
#[[35  5 15],[10 25 45],[20 40 30]]
print(vector2.max(axis=0))#第一维列取最大值
#[35 40 45]
print(vector2.max(axis=1))#第二维行取最大值
#[35 45 40]
print(vector2.sum(axis=0))#第一维列求和
#[65 70 90]
print(vector2.sum(axis=1))#第二维行求和
#[55 80 90]

 

(4) entwirren und glätten

1.numpy.ravel() / .ravel()

Konvertieren Sie ein mehrdimensionales Array in einen eindimensionalen
 
Rückgabewert: view (Ansicht), der sich auf die ursprüngliche Matrix auswirkt
 

2. .flatten()

Konvertieren Sie ein mehrdimensionales Array in einen eindimensionalen
 
Rückgabewert: Kopieren (Kopie). An der Kopie vorgenommene Änderungen wirken sich nicht auf die Originalmatrix aus

---

veranschaulichen:

1. Es kann nur auf Numpy-Objekte angewendet werden, dh auf Arrays oder Mats. Normale Listenlisten sind nicht akzeptabel
2. Es gibt keine Funktion numpy.flatten()

import numpy as np

a = np.array([[1, 2],[3, 4]])
b=a.flatten()
b*=2
print(a)
#[[1 2],[3 4]]
print(b)
#[2 4 6 8]

c1=a.ravel()
c2=np.ravel(a)
c1*=2
print(a)
#[[2 4],[6 8]]
print(c1)
#[2 4 6 8]
print(c2)
#[2 4 6 8]

#降维默认行序有限，传入参数‘F’表示列序优先
d=a.ravel('F')
print(d)
#[2 6 4 8]

 

(5) Sonstiges

1.numpy.transpose() / .transpose() / .T

Matrix transponieren

import numpy as np

x1=np.array([[90,10,15],[20,25,30]])
x2=np.array([[5,10,15],[20,25,30],[90,10,15],[90,10,15]])
x1_x2_1=np.dot(x1,x2.transpose())
x1_x2_2=np.dot(x1,np.transpose(x2))

print(x1_x2_1)
#[[ 775 2500 8425 8425],[ 800 1925 2500 2500]]
print(x1_x2_2)
#[[ 775 2500 8425 8425],[ 800 1925 2500 2500]]

 

2.numpy.squeeze(array,axis) / .squeeze(array,axis)

Löschen Sie eindimensionale Einträge aus der Form des Arrays, d. h. entfernen Sie die Dimension 1 in der Form. Rückgabewert: Array- Parameter
 
mit möglicher Dimensionsreduzierung : (1) Array: Eingabearray (2) Achse: Geben Sie die Dimension an gelöscht werden, aber angeben: Die Dimension von muss eindimensional sein, sonst wird ein Fehler gemeldet; der Wert kann None oder int oder ein Tupel von ints sein, optional. Wenn die Achse leer ist, löschen Sie alle eindimensionalen Einträge
 

1. Diese Funktion verändert das ursprüngliche Array nicht
2. Beim maschinellen Lernen und Deep Learning ist das Ergebnis des Algorithmus normalerweise ein Array, das einen Vektor darstellen kann (dh zwei oder mehr Paare eckiger Klammern [[]] enthält). Wenn Sie dieses Array direkt zum Zeichnen verwenden, wird die Anzeige angezeigt Die Schnittstelle ist möglicherweise leer. Sie können die Funktion Squeeze() verwenden, um ein Array, das einen Vektor darstellt, in ein Array mit Rang 1 umzuwandeln

import numpy as np

a=np.array([[1,2,3]])
b=np.squeeze(a)
c=a.squeeze()

print(b)
#[1 2 3]
print(c)
#[1 2 3]

---

 

3. Allgemeine Funktionen

(1) Erzeugen Sie ein Array

1. Arithmetisches Array

1.1 numpy.arange(start,end,step)

Parameter:
(1) Start: der Startpunkt des Zahlenbereichs
(2) Ende: der Endpunkt des Zahlenbereichs, ohne diesen Wert
(3) Schritt: die Schrittgröße des Zahlenbereichs

import numpy as np

print(np.arange(6))
#[0 1 2 3 4 5]
print(np.arange(0,6,2))
#[0 2 4]
print(np.arange(0,6,0.9))
#[0.  0.9 1.8 2.7 3.6 4.5 5.4]

 

1.2 numpy.linspace(start,stop,num,endpoint,dtype)

Parameter:
(1) Start: der Startpunkt des Wertebereichs
(2) Stopp: der Endpunkt des Wertebereichs
(3) Num (optional): die Anzahl der Elemente im Ergebnis, der Standardwert ist 50
(4) Endpunkt (optional): Bestimmen Sie, ob der Abschlusswert im Ergebnisarray enthalten ist. Wenn endpoint=True, ist der Abschlusswert im Ergebnis enthalten. Andernfalls ist der Abschlusswert nicht enthalten. Der Standardwert ist True ( 5) dtype (optional
) : Bestimmt den Datentyp des Ausgabearrays

---

veranschaulichen:

numpy.linspace(start=0,stop=100,num=5)	numpy.linspace(0,100,5)
benannte Parameter	Positionsparameter

---

Der Unterschied zwischen den beiden:

1. Das erstere Intervall ist links geschlossen und rechts geöffnet, das zweite Intervall ist links geschlossen und rechts geschlossen, wenn Endpunkt = Wahr, und links geschlossen und rechts geöffnet, wenn Endpunkt = Falsch
2. Wenn die angegebenen Parameter „steps“ und „num“ Ganzzahlen sind, gibt arange den Datentyp numpy.int32 zurück, während linspace den Datentyp numpy.float zurückgibt

import numpy as np

a=np.arange(0,10,step=1)
b=np.arange(0,10,step=1.0)
c=np.linspace(0,10,num=10,endpoint=False)
d=np.linspace(0,10,num=11,endpoint=True)

print(a)
#[0 1 2 3 4 5 6 7 8 9]
print(b)
#[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
print(c)
#[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
print(d)
#[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

 

2. Konstantes Array

2.1 numpy.ones(shape,dtype)

Generieren Sie alle 1 Matrixparameter
 
:
(1) Form: kann eine Zahl oder ein Tupel sein und die Form des Arrays angeben
(2) dtype

import numpy as np

a=np.ones(4)
b=np.ones((2,3,4),dtype=np.int32)

print(a)
#[1. 1. 1. 1.]
print(b)
#[[[1 1 1 1]
#  [1 1 1 1]
#  [1 1 1 1]]
# [[1 1 1 1]
#  [1 1 1 1]
#  [1 1 1 1]]]

 

2.2 numpy.zeros(shape,dtype)

Generieren Sie alle 0 Matrixparameter
 
:
(1) Form: kann eine Zahl oder ein Tupel sein und die Form des Arrays angeben
(2) dtype

import numpy as np

a=np.zeros(5)
b=np.zeros((3,4))

print(a)
#[0. 0. 0. 0. 0.]
print(b)
#[[0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]]

 

2.3 numpy.full(shape, fill_value, dtype)

Generieren Sie einen Matrixparameter mit allen gleichen Elementen
 
:
(1) Form: Es kann eine Zahl oder ein Tupel sein, die die Form des Arrays angibt
(2) Füllwert: der gefüllte Wert

import numpy as np

a=np.full(2,3)
b=np.full((2,3),4)

print(a)
#[3 3]
print(b)
#[[4 4 4],[4 4 4]]

 

3. Zufälliges Array numpy.random

numpy.random.seed (int)
Zufallszahlen-Seed

---

Der Rückgabewert der folgenden Funktionen:

• Wenn die Funktion keine Parameter in den Klammern enthält, gibt sie eine Gleitkommazahl oder eine Ganzzahl zurück
• Wenn in den Funktionsklammern ein Parameter steht, wird ein eindimensionales Array mit Rang 1 zurückgegeben, das keine Vektoren und Matrizen darstellen kann
• Wenn zwei oder mehr Parameter in den Funktionsklammern stehen, wird ein Array der entsprechenden Dimension zurückgegeben, das einen Vektor oder eine Matrix darstellen kann
   

3.1 numpy.random.rand()

Generieren Sie einen zufälligen Dezimalparameter, der einer gleichmäßigen Verteilung im Intervall [0,1) folgt
 
, d. h. der Form des Arrays, und standardmäßig 1 Wert ausgibt

import numpy as np

np.random.seed(2)

a=np.random.rand()
b=np.random.rand(2)
c=np.random.rand(2,3)

print(a)
#0.43599490214200376
print(b)
#[0.02592623 0.54966248]
print(c)
#[[0.43532239 0.4203678  0.33033482]
# [0.20464863 0.61927097 0.29965467]]

 

3.2 numpy.random.random()

Generieren Sie zufällige Dezimalparameter
 
im Intervall [0,1): Das heißt, die Form des Arrays, mehr als zwei Parameter müssen in Form von Tupeln vorliegen und standardmäßig 1 Wert ausgeben

import numpy as np

np.random.seed(1)

a=np.random.random()
b=np.random.random(2)
c=np.random.random((2,3))

print(a)
#0.417022004702574
print(b)
#[7.20324493e-01 1.14374817e-04]
print(c)
#[[0.30233257 0.14675589 0.09233859]
# [0.18626021 0.34556073 0.39676747]]

numpy.random.rand() und numpy.random.random() scheinen dieselbe Zufallszahl zu erzeugen, wenn sie denselben Zufallszahlen-Startwert verwenden, was bei anderen Funktionen nicht der Fall ist

 

3.3 numpy.random.randn()

Generieren Sie einen Dezimalparameter, der der (0, 1)-Normalverteilung folgt
 
, also der Form des Arrays, und standardmäßig 1 Wert ausgibt

import numpy as np

np.random.seed(1)

a=np.random.randn()
b=np.random.randn(2)
c=np.random.randn(2,3)
d=4*np.random.randn(3,3,3) + 3 #生成服从均值为3，标准差为4的正态分布的三维数组

print(a)
#1.6243453636632417
print(b)
#[-0.61175641 -0.52817175]
print(c)
#[[-1.07296862  0.86540763 -2.3015387 ]
# [ 1.74481176 -0.7612069   0.3190391 ]]

print(d) #三维数组
#[[[ 2.0025185   8.84843175 -5.24056284]
#  [ 1.71033118  1.46378258  7.53507777]
#  [-1.39956507  2.31028717 -0.51143367]]
# [[ 3.16885499  5.33126085 -1.40247671]
#  [ 7.57889484  6.60636288  5.00997736]
#  [ 6.6034238   0.26508856  2.5084391 ]]
# [[-0.74307774  1.92844768  5.12142187]
#  [ 0.23335699  1.41298589  0.2513092 ]
#  [-0.38082257  0.31501548  2.9493416 ]]]

 

3.4 numpy.random.randint(*args) / numpy.random.randint(low,high,size,dtype)

Um eine Ganzzahl in einem bestimmten Intervall zu generieren, muss mindestens ein Parameter vorhanden sein
 
:
(1) * args: drei Zahlen, die jeweils Low, High und Size entsprechen
(2) Low (optional): int oder float, the Mindestwert generierter Wert (enthalten), der Standardwert ist 0
(3) hoch: int oder float, der Maximalwert des generierten Werts (nicht enthalten)
(4) Größe (optional): int oder Tupel von Ints, die Größe des Zufallszahl, Ganzzahl bedeutet generierte Zahl, das Tupel gibt die Form des Arrays an, der Standardwert ist 1 und das leere Tupel wird als 1 (5
) betrachtet. dtype (optional): Der Ergebnistyp der Ausgabe, der Standardwert ist int

import numpy as np

np.random.seed(1)

a=np.random.randint(10) #0到10的一个随机整数
b=np.random.randint(1,10) #1到10的一个随机整数
c=np.random.randint(1,10,10) #1到10的十个随机整数，构成一维数组
d=np.random.randint(10,99,(5,5)) #10到99的二十五个随机整数，构成5*5的二维数组

print(a)
#5
print(b)
#9
print(c)
#[6 1 1 2 8 7 3 5 6 3]
print(d)
#[[94 21 38 39 24]
# [60 78 97 97 96]
# [23 19 17 73 71]
# [32 67 11 10 70]
# [91 18 98 23 57]]

---

Besondere Verwendung:

import numpy as np

np.random.seed(1)

# 可单独指定每个元素的最小值和最大值
# 如果不指定 size 默认根据第一个和第二个参数的长度来决定生成结果的长度
a=np.random.randint([3, 5, 7], 10) #生成3个分别不小于3,5,7的值，都小于10的值
print(a)
#[8 8 7]

b=np.random.randint(1, [3, 5, 10]) #生成3个都不小于1，分别小于3,5,10的值
print(b)
#[1 4 6]

c=np.random.randint([1, 2, 3,], [4, 5, 10]) #生成3个分别不小于1,2,3，分别小于4,5,10的值
print(c)
#[1 2 4]

#生成2*4的数组，其中每一行不小于[1, 3, 5, 7]，第一行都小于10，第二行都小于20
#注意第二个参数里面的每个元素都要用[]，因为它控制的是一整行
d=np.random.randint([1, 3, 5, 7], [[10], [20]])
print(d)
#[[ 8  8  9  9]
# [19  8  7 11]]

#生成4*2的数组，其中，第一行都不小于1，第二行都不小于3，第三行都不小于5，第四行都不小于7，每一行都小于[10,20]
e=np.random.randint([[1],[3],[5],[7]],[10,20])
print(e)
#[[ 3  5]
# [ 4  3]
# [ 6 14]
# [ 8 13]]

Beim Generieren von Arrays mit mehr als zwei Dimensionen erfordern numpy.random.rand() und numpy.random.randn() nur eine Klammer (), während numpy.random.random() und numpy.random.randint() zwei Klammern erfordern ()

 

3.5 numpy.random.uniform(low, high, size)

Generieren Sie Gleitkommazahlenparameter in einem bestimmten Intervall
 
:
(1) niedrig: Float-Typ, der Mindestwert des generierten Werts (einschließlich), der Standardwert ist 0
(2) hoch: Float-Typ, der Mindestwert des generierten Werts ( nicht enthalten), der Standardwert ist 1
(3). Größe: int oder ganzzahliger Tupeltyp, der die Form des Ausgabearrays angibt und standardmäßig 1 Wert ausgibt

import numpy as np

np.random.seed(1)

a=np.random.uniform()
b=np.random.uniform(2,4,3)
c=np.random.uniform(2,3,(2,4))

print(a)
#0.417022004702574
print(b)
#[3.44064899 2.00022875 2.60466515]
print(c)
#[[2.14675589 2.09233859 2.18626021 2.34556073]
# [2.39676747 2.53881673 2.41919451 2.6852195 ]]

 

3.6 numpy.random.normal(loc, scale, size)

Generieren Sie Zufallszahlen mit Normalverteilungswahrscheinlichkeitsdichte

Parameter:
(1) loc: float, der Mittelwert dieser Wahrscheinlichkeitsverteilung, der Standardwert ist 0,0
(2) Scale: float, die Standardabweichung dieser Wahrscheinlichkeitsverteilung, der Standardwert ist 1,0
(3) Größe: int oder ganzzahliges Tupel, Gibt die Ausgabeform des Arrays an und gibt standardmäßig 1 Wert aus

import numpy as np

np.random.seed(1)

a=np.random.normal()
b=np.random.normal(2,4,3)
c=np.random.normal(2,3,(2,4))

print(a)
#1.6243453636632417
print(b)
#[-0.44702565 -0.11268701 -2.29187449]
print(c)
#[[ 4.59622289 -4.90461609  7.23443529 -0.2836207 ]
# [ 2.95711729  1.25188887  6.38632381 -4.18042213]]

---

Besondere Verwendung:

import numpy as np

np.random.seed(1)

loc = [0,2,4,6]
scale = [1,3,5,7]

a=np.random.normal(loc, scale)
b=np.random.normal(loc, scale, size=4)
c=np.random.normal(loc, scale, size=(3,4))
d=np.random.normal(loc, scale, size=(2,3,4))

#输出数组形状最后一维与列表等长，四个表示同时处理四组数据
print(a)
#[ 1.62434536  0.16473076  1.35914124 -1.51078036]
print(b)
#[ 0.86540763 -4.90461609 12.72405882  0.67155169]
print(c)
#[[ 0.3190391   1.25188887 11.31053969 -8.42098497]
# [-0.3224172   0.84783694  9.66884721 -1.69923887]
# [-0.17242821 -0.63357525  4.21106873 10.0797065 ]]
print(d)
#[[[-1.10061918  5.43417113  8.5079536   9.51746037]
#  [ 0.90085595 -0.05118358  3.38554887 -0.55038604]
#  [-0.26788808  3.5910664   0.54169624  3.22272531]]
# [[-0.6871727  -0.53561692  0.64376935  5.91134781]
#  [-1.11731035  2.70324709 12.29901089 11.19430912]
#  [-0.19183555 -0.66288689  0.26420853 17.84718221]]]

 

3.7 numpy.random.choice(array, size, replacement, p)

Gibt zufällig ein Element der angegebenen Form mit mindestens einem Argument zurück

Parameter:
(1) Array: Array-Array oder Listenliste oder Tupel-Tupel, muss eindimensional sein, die Quelle der Zahl nehmen (
2) Größe: int oder ganzzahliges Tupel, das die Form des Ausgabearrays angibt und 1 Wert ausgibt Standardmäßig
(3) ersetzen: Boolescher Wert, der angibt, ob dieselbe Zahl angenommen werden kann. Der Standardwert ist True
(4) p: entspricht dem Array-Array, erfordert die gleiche Länge, muss jedoch nicht konsistent sein und gibt die Wahrscheinlichkeit der Annahme an Jedes Element im Array-Array ist keine absolute Wahrscheinlichkeit 0 <p <1, sondern ein relatives Gewicht. Standardmäßig ist die Wahrscheinlichkeit, jedes Element auszuwählen, gleich.

import numpy as np

np.random.seed(1)

m=[1,3,5,7,9]
n=(2,4,6,8,10)

a=np.random.choice(m)
b=np.random.choice(m,2)
c=np.random.choice(m,(2,3))
d=np.random.choice(n,(2,3),m)

print(a)
#7
print(b)
#[9 1]
print(c)
#[[3 7 1]
# [1 3 9]]
print(d)
#[[10  4  6]
# [10  6 10]]

x=np.random.choice(m,(2,2),replace=True)
y=np.random.choice(m,(2,2),replace=False)

print(x)
#[[7 9]
# [5 9]]
print(y)
#[[7 9]
# [3 1]]

 

3.8 numpy.random.shuffle(x)

Ordnen Sie das angegebene Array in der ersten Dimension neu an, führen Sie eine Bearbeitung des ursprünglichen Arrays durch, ändern Sie seine eigene Reihenfolge und geben Sie keinen Wert zurück.

import numpy as np

a = np.arange(12).reshape(4,3)
print(a)
#[[ 0  1  2]
# [ 3  4  5]
# [ 6  7  8]
# [ 9 10 11]]

np.random.shuffle(a)
print(a)
#[[ 9 10 11]
# [ 6  7  8]
# [ 3  4  5]
# [ 0  1  2]]

np.random.shuffle(a)
print(a)
#[[ 9 10 11]
# [ 6  7  8]
# [ 3  4  5]
# [ 0  1  2]]

 

3.9 numpy.random.permutation(x)

Ordnen Sie das angegebene Array in der ersten Dimension anstelle des ursprünglichen Arrays neu an und geben Sie ein neues Array zurück, ohne das eigene Array zu ändern

• numpy.random.permutation(int)==numpy.random.permutation(numpy.arange(int))

import numpy as np

n=np.random.permutation(10)
print(n)
#[7 9 8 6 2 1 3 5 0 4]

a = np.arange(9).reshape((3, 3))
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]
b = np.random.permutation(a)
print(a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]
print(b)
#[[0 1 2]
# [6 7 8]
# [3 4 5]]

 

(2) Dimensionsoperationen

numpy.newaxis

neue Dimension einfügen

Die Wirkung von y=x[:,np.newaxis] entspricht dem Hinzufügen einer eckigen Klammer zum Element in der innersten Klammer, und die Wirkung von y=x[np.newaxis,:] entspricht dem Hinzufügen einer eckigen Klammer zu die äußerste Schicht.

import numpy as np

x1=np.arange(3)
print(np.shape(x1))
#(3,)

x2=x1[:,np.newaxis]
print(x2)
#[[0],[1],[2]]
print(np.shape(x2))
#(3, 1)

x3=x1[np.newaxis,:]
print(x3)
#[[0 1 2]]
print(np.shape(x3))
#(1, 3)


vector1=np.array([5,10,15,20])
print(vector1[0:3])
#[ 5 10 15]

vector2=np.array([[5,10,15],[20,25,30],[35,40,45]])

print(vector2[:,1])
#[10 25 40]
print(vector2[:,0:2])
#[[ 5 10],[20 25],[35 40]]
print(vector2[1:3,0:2])
#[[20 25],[35 40]]

 

(3) Elementbetrieb

1. Allgemeine Operation von Vektor und Vektor, Operation von Vektor und Skalar

Im ersten Fall werden Operationen zwischen Array-Schlüsseln derselben Form und Größe auf Elemente angewendet und entsprechende Elemente addiert, subtrahiert, multipliziert und dividiert. Im zweiten Fall werden Skalaroperationen
auf jedes Element angewendet

---

Multiplizieren Sie entsprechende Elemente	Teilen Sie entsprechende Elemente
Array1*Array2	Array1/Array2
numpy.multiply(array1,array2)	numpy.divide(array1,array2)

---

import numpy as np

a=np.array([1,2])
b=np.array([3,4])
c1=b+a
c2=b-a
c3=b*a
c4=b/a
d=a*2+b*3

print(c1)
#[4 6]
print(c2)
#[2 2]
print(c3)
#[3 8]
print(c4)
#[3. 2.]
print(d)
#[11 16]


vector1=numpy.array([[2,6,3],[2,1,2]])
vector2=numpy.array([[1,2,3],[4,5,8]])

m1=vector1*vector2
m2=numpy.multiply(vector1,vector2)
print(m1)
#[[ 2 12  9],[ 8  5 16]]
print(m2)
#[[ 2 12  9],[ 8  5 16]]

n1=vector1/vector2
n2=numpy.divide(vector1,vector2)
print(n1)
#[[2.   3.   1.  ],[0.5  0.2  0.25]]
print(n2)
#[[2.   3.   1.  ],[0.5  0.2  0.25]]

 

2. Rundfunkübertragung

1. Wenn die Formen unterschiedlich sind, ist Numpy automatisch kompatibel.
2. Die sogenannte Kompatibilität bedeutet, dass mindestens eine der Zeilen und Spalten der beiden Arrays gleich ist und eines davon ein eindimensionales Array oder ein zweidimensionales Array mit Rang 1 ist
   

import numpy as np

a=np.array([[1,2],[2,6]])
b1=np.array([1,2])
b2=np.array([[1,2]])
b3=np.array([[[1,2]]])
            
print(a+b1)
#[[2 4],[3 8]]
print(a+b2)
#[[2 4],[3 8]]
print(a+b3)
#[[[2 4],[3 8]]]
print(a*b1)
#[[ 1  4],[ 2 12]]

 

3.numpy.all()

Bestimmen Sie, ob die Werte der Elemente im gesamten Array die Bedingungen erfüllen.
 
Rückgabewert: Gibt True zurück, wenn alle Bedingungen erfüllt sind, andernfalls wird False zurückgegeben.
 

4.numpy.absolute() / numpy.abs()

Finden Sie den absoluten Wert jedes Elements im Array

import numpy as np

a=np.array([4,2,3])
b=np.array([1,6,9])
c=b-a
print(c)
#[-3  4  6]

d=np.absolute(c)
print(d)
#[3 4 6]

if numpy.all((d)>1):
    print('yes')
    #yes

 

5.numpy.floor(array,dtype)

Runden Sie jedes Element im Array ab

import numpy as np

a=np.array([-1.5,-0.5,0.5,1.5])
b=np.floor(a)
print(b)
#[-2. -1.  0.  1.]

 

(4) Matrixoperation

1.numpy.dot(array1,array2)

Inneres Produkt der Matrix

import numpy as np

vector1=np.array([1,2,3]) #1-D array
vector2=np.array([4,5,6])
m=np.dot(vector1,vector2) #计算两个一维矩阵的内积
print(m)
#32

vector3=np.array([[1,2,3],[4,5,6]]) #2-D array
vector4=np.array([[1,2],[3,4],[5,6]])
n=np.dot(vector3,vector4) #计算两个二维矩阵的内积
print(n)
#[[22 28],[49 64]]

 

2.numpy.outer(array1,array2)

äußeres Matrixprodukt

import numpy as np

vector1=np.array([1,2,3]) #1-D array
vector2=np.array([4,5,6])
m=np.outer(vector1,vector2) #计算两个一维矩阵的内积
print(m)
#[[ 4  5  6]
# [ 8 10 12]
# [12 15 18]]

vector3=np.array([[1,2,3],[4,5,6]]) #2-D array
vector4=np.array([[1,2],[3,4],[5,6]])
n=np.outer(vector3,vector4) #计算两个二维矩阵的内积
print(n)
#[[ 1  2  3  4  5  6]
# [ 2  4  6  8 10 12]
# [ 3  6  9 12 15 18]
# [ 4  8 12 16 20 24]
# [ 5 10 15 20 25 30]
# [ 6 12 18 24 30 36]]

 

3.numpy.rot90(array,num)

Realisieren Sie die Drehung eines beliebigen Vielfachen des 90 ° -Winkels der Matrix. Die positive Zahl ist gegen den Uhrzeigersinn und die negative Zahl ist im Uhrzeigersinn

import numpy as np

a=np.array([[1,2],
            [3,4]])
b1=np.rot90(a,-1)
b2=np.rot90(a,2)

print(b1)
#[[3 1]
# [4 2]]
print(b2)
#[[4 3]
# [2 1]]

 

4.numpy.fliplr(array)

Matrix-Horizontalspiegelung

import numpy as np

a=np.array([[1,2],
            [3,4]])
b=np.fliplr(a)

print(b)
#[[2 1]
# [4 3]]

 

5.numpy.meshgrid(array1,array2)

Erzeugen Sie eine Koordinatenmatrix gemäß dem Koordinatenarray der Ebenenpunkte.
 
Rückgabewert: eine Liste mit zwei Elementen

Die Elemente der Liste sind ein Array aus Punkt-x-Koordinaten und ein Array aus y-Koordinaten. Die Anzahl der Elemente im Array bedeutet die Anzahl der repräsentativen Punkte.

import numpy as np

x=np.linspace(1,3,3)
y=np.linspace(4,5,2)
Z=np.meshgrid(x,y)

print(Z)
#[array([[1., 2., 3.],
#       [1., 2., 3.]]),
# array([[4., 4., 4.],
#       [5., 5., 5.]])]

X,Y=np.meshgrid(x,y)

print(X)
#[[1. 2. 3.],
# [1. 2. 3.]]

print(Y)
#[[4. 4. 4.],
# [5. 5. 5.]]

 

(5) Zeilen- und Spaltenverarbeitung

1.numpy.hsplit(array,indices_or_sections)

Array-Parameter für horizontales Schneiden
 
:
(1) Array: zu verarbeitendes Array
(2) indices_or_sections: Index oder Abschnitt. Wenn es sich um eine Liste handelt, wird sie mit den Elementen der Liste als Index geschnitten; wenn es eine positive ganze Zahl ist, wird sie gleichmäßig geteilt, aber diese positive ganze Zahl muss teilbar sein
 

2.numpy.vsplit(array,indices_or_sections)

Schneiden Sie das Array wie oben vertikal ab

import numpy as np

np.random.seed(10)

a1=np.floor(10*np.random.random((2,6))) #random会产生0-1的随机数
a2=np.floor(10*np.random.random((6,2))) #a1,a2的元素都是0-9的整型浮点数

print(a1)
#[[7. 0. 6. 7. 4. 2.],
# [1. 7. 1. 0. 6. 9.]]
print(a2)
#[[0. 5.],
# [8. 6.],
# [7. 2.],
# [9. 7.],
# [5. 1.],
# [3. 6.]]

b=np.hsplit(a1,3)
print(b)
#[array([[7., 0.],
#       [1., 7.]]), 
# array([[6., 7.],
#       [1., 0.]]), 
# array([[4., 2.],
#       [6., 9.]])]

b1,b2,b3=np.hsplit(a1,3)

print(b1)
#[[7. 0.]
# [1. 7.]]
print(b2)
#[[6. 7.]
# [1. 0.]]
print(b3)
#[[4. 2.]
# [6. 9.]]

c=np.vsplit(a2,[1,3,5])
print(c)
#[array([[0., 5.]]), 
# array([[8., 6.],
#       [7., 2.]]), 
# array([[9., 7.],
#       [5., 1.]]), 
# array([[3., 6.]])]

c1,c2,c3,c4=np.vsplit(a2,[1,3,5])

print(c1)
#[[0. 5.]]
print(c2)
#[[8. 6.]
# [7. 2.]]
print(c3)
#[[9. 7.]
# [5. 1.]]
print(c4)
#[[3. 6.]]

 

3.numpy.r_[array1,array2] / numpy.vstack([array1,array2])

Spleißen in einer Dimension
Bei einer eindimensionalen Matrix entspricht dies dem sequentiellen Spleißen.
Bei einer zweidimensionalen Matrix entspricht dies dem sequentiellen Spleißen entlang der Auf- und Ab-Richtung, und die Anzahl der Spalten muss gleich sein
 

4.numpy.c_[array1,array2] / numpy.hstack([array1,array2])

Spleißen in zwei Dimensionen
Für eine eindimensionale Matrix entspricht dies einer zweidimensionalen Matrix, die in (n, 2) umgewandelt wird.
Für eine zweidimensionale Matrix entspricht dies einem horizontalen Spleißen entlang der linken und rechten Richtung und der Zahl Anzahl der Zeilen muss gleich sein

import numpy as np

a=np.arange(1,5).reshape(4,1)
b=np.ones((4,2))

c=np.hstack((a,b))
d=np.c_[a,b]

print(c)
#[[1. 1. 1.]
# [2. 1. 1.]
# [3. 1. 1.]
# [4. 1. 1.]]
print(d)
#[[1. 1. 1.]
# [2. 1. 1.]
# [3. 1. 1.]
# [4. 1. 1.]]

 

5.numpy.tile(array,shape)

Kopieren Sie das Array in alle Richtungen.
 
Parameter:
(1) Array
(2) Form: Tupel, die Dimension muss mit dem Array übereinstimmen und die Elemente sind alle ganze Zahlen

import numpy as np

a=np.array([[1,2],
            [3,4]])
b=np.tile(a,(2,3))

print(b)
#[[1 2 1 2 1 2]
# [3 4 3 4 3 4]
# [1 2 1 2 1 2]
# [3 4 3 4 3 4]]

 

6. numpy.stack([array1, … ], Achse)

(6) Ansicht anzeigen und kopieren

1. b = a: Genau das gleiche wie das Quellarray mit derselben ID. Jede Änderung wirkt sich auf das Quellarray aus
2. c=a[:], d=a.view(): Das Array-Slice ist die Ansichtsansicht des ursprünglichen Arrays. Jede Änderung an der Ansicht wirkt sich auf das Quellarray aus
3. e=a.copy(): Kopie kopieren, die Änderung hat keine Auswirkungen auf das Quellarray

import numpy as np

a=np.arange(4)
print(a)
#[0 1 2 3]

b=a
print(b)
#[0 1 2 3]
print(b is a)
#True
print(id(a))
#2522915940944
print(id(b))
#2522915940944
b*=2
print(id(a))
#2522915940944
print(id(b))
#2522915940944
print(a)
#[0 2 4 6]
print(b)
#[0 2 4 6]


c=a[:]
print(c)
#[0 2 4 6]
print(c is a)
#False
print(id(a))
#2522915940944
print(id(c))
#2522915942000
c*=2
print(a)
#[ 0  4  8 12]
print(c)
#[ 0  4  8 12]

d=a.view()
print(d)
#[ 0  4  8 12]
print(d is a)
#False
print(id(a))
#2522915940944
print(id(d))
#2522915941136
d*=2
print(a)
#[ 0  8 16 24]
print(d)
#[ 0  8 16 24]

e=a.copy()
print(e)
#[ 0  8 16 24]
print(e is a)
#False
print(id(a))
#2522915940944
print(id(e))
#2522915796048
e*=2
print(a)
#[ 0  8 16 24]
print(e)
#[ 0 16 32 48]

---

 

4. Lesen von Dateien

numpy.genfromtxt(Fname, DType, Kommentare, Trennzeichen, Autostrip, Skipd_Header, Skip_Fonter, Konverter, Missing_Values, Filling_Values, Usecols)

Standardmäßig wird es im Float-Format gelesen. Für Daten, die nicht in den Float-Typ konvertiert werden können, werden sie als nan (keine Zahl) gelesen, daher sollten Parameter hinzugefügt werden

Parameter:
(1) fname: str/list/IO Objekt usw., das die Datenquelle angibt; Dateipfad, String-Liste und StringIO-Objekt sind alle akzeptabel; wenn es mit gz endet, wird es vor dem Laden der Daten automatisch dekomprimiert beim Lesen, aber es ist relativ. Die häufigsten sind TXT-Texte

IO -> Eingabe, Ausgabe

(2) dtype: dtype, der Datentyp des endgültigen Arrays
(3) Kommentare: str, der Kommentarbezeichner, die Zeichenfolge nach der Zeile, in der sich der Kommentarbezeichner befindet, wird beim Laden automatisch ignoriert; (4)
Trennzeichen: str/ int/sequenz

• Wenn Trennzeichen ein Zeichen ist, bedeutet dies das Trennzeichen, und die Elemente jeder Zeile werden durch das Trennzeichen getrennt.
• Wenn es sich bei dem Trennzeichen um eine Zeichenliste handelt, bedeutet dies, dass das Trennzeichen aus mehreren Zeichen bestehen kann.
• Wenn Trennzeichen ein ganzzahliges Tupel ist, stellt es die maximale Breite des Elements in jeder Spalte dar

import numpy as np
from io import BytesIO

data1 = b"1, 2, 3\n4, 5, 6"
a=np.genfromtxt(BytesIO(data1), delimiter=",")
print(a)
#[[1. 2. 3.]
# [4. 5. 6.]]

data2 = b"  1  2  3\n  4  5 67\n890123  4"
b=np.genfromtxt(BytesIO(data2), delimiter=3) 
print(b)
#[[  1.   2.   3.]
# [  4.   5.  67.]
# [890. 123.   4.]]

data3 = B"123456789\n   4  7 9\n   4567 9"
c=np.genfromtxt(BytesIO(data3), delimiter=(4, 3, 2))
print(c)
#[[1234.  567.   89.]
# [   4.    7.    9.]
# [   4.  567.    9.]]

(5) Autostrip: Wenn True, wird die Leerzeichenkennung im Element automatisch gelöscht.
(6) Skip_header: int, überspringt die Anzahl der Zeichenfolgenzeilen im Dateikopf, wenn Daten geladen werden.
(7) Skip_footer: Int, überspringt, wenn Daten werden geladen. Die Anzahl der Zeichenfolgenzeilen am Ende der Datei
(8) Konverter: Variable, die in Form eines Wörterbuchs oder einer Lambda-Funktion vorliegen kann, was bedeutet, dass ein bestimmtes Datenformat in ein anderes Datenformat konvertiert wird (9)
fehlende_Werte : Variable, geben Sie die Werte im Array an. Fehlende Werte werden markiert
(10)filling_values: Variable, geben Sie die markierten fehlenden Werte im Array an, um die Füllwerte zu ersetzen

Beispiel:
fehlende_Werte={0:“N/A“, 1:“ „, 2:“???“}, füllende_Werte={0:0,1:0, 2:-999})

(11) usercols: Sequenz, die angibt, nur die angegebene Anzahl von Spalten in den Daten zu lesen, 0 bedeutet die erste Spalte, -1 ist die letzte Spalte

---

 

5. Kosinusähnlichkeit

 
||A|| gibt die Norm von A an, ausgedrückt durch numpy.linalg.norm(), und kann mithilfe der Achse eine Dimensionsreduktionsberechnung durchführen

import numpy as np

v1=np.array([1,2,3])
v2=np.array([7,14,5])
result=(np.sum(v1*v2))/(np.linalg.norm(v1)*np.linalg.norm(v2))

print(result)
#0.8132500607904444

 
Im Folgenden wird die Kosinusähnlichkeit zweier Matrizen berechnet:

import numpy

matrix1=numpy.array([[90,10,15],
                     [20,25,30]]) #二维数组2*3
matrix2=numpy.array([[5,10,15],
                     [20,25,30],
                     [90,10,15],
                     [90,10,15]]) #二维数组3*4

matrix1_matrix2=numpy.dot(matrix1,matrix2.T) #计算矩阵乘积，结果为二维数组2*4

matrix1_norm1=numpy.linalg.norm(matrix1,axis=1) #按行取范数，得一维数组1*2
matrix1_norm2=matrix1_norm1[:,numpy.newaxis] #增加维度，变成二维数组2*1

matrix2_norm1=numpy.linalg.norm(matrix2,axis=1) #按行取范数，得一维数组1*4
matrix2_norm2=matrix2_norm1[numpy.newaxis,:] #增加维度，变成二维数组1*4

#余弦相似度
cosine=numpy.divide(matrix1_matrix2,numpy.dot(matrix1_norm2,matrix2_norm2))

print(cosine)
#[[0.45131807 0.62078282 1.         1.        ]
# [0.97463185 1.         0.62078282 0.62078282]]

---

 

6. Andere

(1) Vergleichsoperatoren können Arrays generieren, deren Elemente wahr oder falsch sind

import numpy as np

a=np.array([1,2,3])
print(a>2)
#[False False  True]
b=np.array([3,4,5])
print(a<b)
#[ True  True  True]


x = np.linspace(-2,2,5)
y = np.linspace(0,4,5)

xx,yy = np.meshgrid(x,y)
z = np.square(xx) - yy>0

print(z)
#[[ True  True False  True  True]
# [ True False False False  True]
# [ True False False False  True]
# [ True False False False  True]
# [False False False False False]]


vector=numpy.array([[5,10,15],[20,25,30],[35,40,45]])
vector==25
#array([[False, False, False],
#       [False,  True, False],
#       [False, False, False]])

(2) Skalar und Array

numpy.sin(), numpy.cos()

import numpy as np

a1=1
a2=np.sin(a1)
print(a2)
#0.8414709848078965

b1=[1,2]
b2=np.sin(b1)
print(b2)
#[0.84147098 0.90929743]

c1=[[1,2],
    [3,4]]
c2=np.cos(c1)
print(c2)
#[[ 0.54030231 -0.41614684]
# [-0.9899925  -0.65364362]]

---

Das Obige ist noch nicht abgeschlossen und muss aktualisiert werden. Es dient nur dem persönlichen Studium. Der Verstoßkontakt wurde gelöscht. Wenn Fehler oder Mängel vorliegen, weisen Sie bitte darauf hin, um Verbesserungen vorzunehmen.