[PYTHON] NumPy-Grundlagen
Funktionen von NumPy
--Berechnen Sie mehrdimensionale Arrays gleichzeitig mit hoher Geschwindigkeit.
ndarray: Mehrdimensionales Array-Objekt
- Beispiel für ndarray
import numpy as np
data = np.random.randn(2,3) #Zufallszahlen mit 2 Spalten und 3 Zeilen
print(data)
# [[-0.4440664 -0.07889544 -0.84781375]
# [ 0.59333292 -0.03008522 1.54106015]]
print(data * 10) #Multiplizieren
# [[-4.44066398 -0.78895438 -8.47813747]
# [ 5.93332925 -0.3008522 15.41060155]]
print(data + data) #Hinzufügen
# [[-0.8881328 -0.15779088 -1.69562749]
# [ 1.18666585 -0.06017044 3.08212031]]
print(data.shape) #Anzahl der vertikalen und horizontalen Elemente
# (2, 3)
print(data.dtype) #Elementtyp
# float64
Erzeugung von Ndarray
- Generieren Sie mit
np.array (Liste). --np.zeros (10) `` np.zeros ((3,6))erstellt ein ndarray mit allen Elementen 0. - Ähnlich erstellt
np.ones ()ein ndarray mit allen Elementen 1. --Füllen Sienp.full ()mit dem angegebenen Wert. - Erzeugen Sie mit
np.arange (10)ein ndarray, in dem die Elemente 0 bis 9 der Reihe nach eingegeben werden.
import numpy as np
data = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr = np.array(data) #Generiere ndarray aus der Liste
print(arr)
# [[1 2 3 4]
# [5 6 7 8]]
print(arr.ndim) #Abmessungen
# 2
print(arr.shape) #Elementanzahl
# (2, 4)
Datentyp von ndarray
- int8、16、32、64、uint8、16、32、64
- float16、32、64、128
- complex64、128、256
- bool
- object
- string_
- unicode_
import numpy as np
arr1 = np.array([-3.7, -1.2, 0.5, 4.5])
print(arr1)
# [-3.7 -1.2 0.5 4.5]
arr2 = arr1.astype(np.int32) #Besetzung
print(arr2)
# [-3 -1 0 4]
arr3 = np.array(['-3.7', '-1.2', '0.5', '4.5'], dtype=np.string_)
print(arr3)
# [b'-3.7' b'-1.2' b'0.5' b'4.5']
print(arr3.dtype)
# |S4
arr4 = arr3.astype(np.float64) #Besetzung
print(arr4)
# [-3.7 -1.2 0.5 4.5]
Arithmetische Operation von ndarray
- Berechnungen gleicher Größe werden an derselben Position berechnet.
- Der Vorgang zwischen ndarrays unterschiedlicher Größe wird als Broadcast bezeichnet.
import numpy as np
arr1 = np.array([[1., 2., 3., 4.], [5., 6., 7., 8.]])
print(arr1 ** 2)
# [[ 1. 4. 9. 16.]
# [25. 36. 49. 64.]]
print(arr1 - arr1)
# [[0. 0. 0. 0.]
# [0. 0. 0. 0.]]
print(1 / arr1)
# [[1. 0.5 0.33333333 0.25 ]
# [0.2 0.16666667 0.14285714 0.125 ]]
arr2 = np.array([[0., 4., 1., 5.], [3., 9., 4., 9.]])
print(arr1 < arr2)
# [[False True False True]
# [False True False True]]
Grundlagen der Indexreferenz und des Schneidens
- Die Indexreferenz schneidet einen Teil aus den Daten aus. ――Sie können einen Skalar für einen Teil des Ausschnitts angeben, und der angegebene Wert wird auf den gesamten Ausschnitt übertragen. (Übertragung)
- Slices sind Ansichten, keine Kopien.
import numpy as np
arr1 = np.arange(10)
print(arr1)
# [0 1 2 3 4 5 6 7 8 9]
print(arr1[5:8])
# [5 6 7]
arr1[5:8] = 12
print(arr1)
# [ 0 1 2 3 4 12 12 12 8 9]
arr_slice = arr1[5:8]
arr_slice[1] = 12345
print(arr_slice)
# [ 12 12345 12]
print(arr1)
# [ 0 1 2 3 4 12 12345 12 8 9]
- Zweidimensionale Scheibe
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) #2D
print(arr2d)
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
print(arr2d[:2]) #Vertikal 0,Nehmen Sie den ersten heraus
# [[1 2 3]
# [4 5 6]]
print(arr2d[:2, 1:]) #Vertikal 0,1., 1 in der Seitenstraße,Nehmen Sie die zweite heraus
# [[2 3]
# [5 6]]
print(arr2d[1, :2]) #1. in der Vertikalen, 0 in der horizontalen Straße,Nehmen Sie den ersten heraus
# [4 5]
print(arr2d[:, :1]) #Alle vertikalen, horizontalen 0,Nehmen Sie den ersten heraus
# [[1]
# [4]
# [7]]
arr2d[:2, 1:] = 0 #Ersetzen Sie alles in diesem Bereich
print(arr2d)
# [[1 0 0]
# [4 0 0]
# [7 8 9]]
Boolesche Indexreferenz
- Basierend auf der Bedingung eines Arrays mit 7 Arrays (Gültigkeitswert-Array) können die Zeilen des zweidimensionalen Arrays von (7,4) extrahiert werden.
- Die Anzahl der Elemente auf der Achse des referenzierten Arrays und die Anzahl der Elemente auf dem booleschen Array müssen übereinstimmen.
import numpy as np
names = np.array(['Yamada', 'Suzuki', 'Sato', 'Yamada', 'Tanaka', 'Tanaka', 'Sato'])
data = np.random.randn(7, 4) #Erstellen Sie ein Array mit 7 Zeilen vertikal und 4 Spalten horizontal mit Zufallszahlen
print(data)
# [[-0.92866442 -0.81744986 1.11821763 -0.55440628]
# [-0.09511771 0.99145963 0.38475434 0.59748055]
# [ 0.0444708 -0.00381292 0.97888419 1.242504 ]
# [ 0.89214068 -1.0411466 0.90850611 -2.02933442]
# [ 0.78789041 -0.84593788 -0.5624772 0.32488453]
# [ 0.50153002 -0.25411512 0.30855623 -1.31825153]
# [-0.6596584 1.53735231 -0.37044833 1.93782111]]
print(names == 'Yamada') # 'Yamada'Passender Fluss, 0,4. gibt True zurück
# [ True False False True False False False]
print(data[names == 'Yamada']) #Daten auf 0,Nehmen Sie den 4. heraus
# [[-0.92866442 -0.81744986 1.11821763 -0.55440628]
# [ 0.89214068 -1.0411466 0.90850611 -2.02933442]]
mask = (names == 'Yamada') | (names == 'Sato') #Sie können es auch mit oder herausnehmen
print(data[(names == 'Yamada') | (names == 'Sato')])
# [[-0.92866442 -0.81744986 1.11821763 -0.55440628]
# [ 0.0444708 -0.00381292 0.97888419 1.242504 ]
# [ 0.89214068 -1.0411466 0.90850611 -2.02933442]
# [-0.6596584 1.53735231 -0.37044833 1.93782111]]
data[names == 'Yamada'] = 0 # 0,Viertens setzen Sie 0
print(data)
# [[ 0. 0. 0. 0. ]
# [-0.09511771 0.99145963 0.38475434 0.59748055]
# [ 0.0444708 -0.00381292 0.97888419 1.242504 ]
# [ 0. 0. 0. 0. ]
# [ 0.78789041 -0.84593788 -0.5624772 0.32488453]
# [ 0.50153002 -0.25411512 0.30855623 -1.31825153]
# [-0.6596584 1.53735231 -0.37044833 1.93782111]]
Siehe ausgefallener Index
--Fancy Index Reference ist eine Methode, die ein Integer-Array als Indexreferenz verwendet.
- Im Gegensatz zum Schneiden geben ausgefallene Indexreferenzen immer eine Kopie der Originaldaten zurück
import numpy as np
arr = np.arange(32).reshape(8, 4) # 8,Erstellen Sie ein Array von 4
print(arr)
# [[ 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 25 26 27]
# [28 29 30 31]]
print(arr[[0, 4, 5, -1]]) # 0, 4, 5, -Gibt eine Zeile zurück
# [[ 0 1 2 3]
# [16 17 18 19]
# [20 21 22 23]
# [28 29 30 31]]
print(arr[[1, 5, 7, 2], [0, 3, 1, 2]]) # (1,0),(5,3),(7,1),(2,2)Gib es zurück
# [ 4 23 29 10]
Translokationsmatrix, Vertauschen von Zeilen und Spalten
--Die Transposition von ndarray gibt eine spezielle Ansicht zurück, die die ursprüngliche Matrix rekonstruiert. Erstellt keine Kopie.
- Es gibt eine Methode zum Anwenden der Transponierungsfunktion und eine Methode zum Verweisen auf T, das eines der Attribute von ndarray ist.
import numpy as np
arr1 = np.arange(15).reshape(3, 5) # 3,Erstellen Sie ein Array von 5
print(arr1)
# [[ 0 1 2 3 4]
# [ 5 6 7 8 9]
# [10 11 12 13 14]]
print(arr1.T)
# [[ 0 5 10]
# [ 1 6 11]
# [ 2 7 12]
# [ 3 8 13]
# [ 4 9 14]]
arr2 = np.arange(24).reshape((2, 3, 4)) # (2,3,4)Erstellen Sie ein Array von
print(arr2)
# [[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]]
print(arr2.transpose((1, 0, 2))) #Ändern Sie die Reihenfolge der Achsen.(3,2,4)In eine Reihe von gemacht
# [[[ 0 1 2 3]
# [12 13 14 15]]
#
# [[ 4 5 6 7]
# [16 17 18 19]]
#
# [[ 8 9 10 11]
# [20 21 22 23]]]
Universelle Funktion: Funktionsanwendung auf alle Array-Elemente
-Die universelle Funktion ist eine Funktion, die die Suchergebnisse für jedes Element für ndarray zurückgibt.
-Single term ufunc Nimm einen ndarray
-Abs, fabs, sqrt, square, exp, log, log10, log2, log1p, sign, cell, floor, rint modf, isnan, isfinite, isinf, cos, sin, tan usw.
-Zwei Begriffe ufunc Nimm zwei ndarrays
-Add, subtrahieren, multiplizieren, dividieren, floor_dvide, Leistung, Maximum, fmax, Minimum, fmin, Mod, Copysign, Reibe, weniger, gleich, logisch_und usw.
Array-orientierte Programmierung mit ndarray
- Zeigen Sie das Ergebnis von
sqrt (x ^ 2 + y ^ 2)für Gitterpunktdaten an --np.meshgridübernimmt zwei eindimensionale Funktionen und zählt alle Kombinationen jedes Elements auf.
import numpy as np
import matplotlib.pyplot as plt
points = np.arange(-5, 5, 0.01) #1000 Gitterpunkte
xs, ys = np.meshgrid(points, points) #Gibt alle Kombinationen zurück
z = np.sqrt(xs ** 2 + ys ** 2)
print(z)
plt.imshow(z, cmap=plt.cm.gray)
plt.colorbar()
plt.title("Image plot of $\\sqrt{x^2 + x^2}$ for a grid of values")
plt.show()
Darstellung der bedingten Kontrolle in ndarray
--np.where () gibt das zweite Argument zurück, wenn das erste Argument True ist, und das dritte Argument, wenn das erste Argument nicht True ist.
- Jedes Argument kann ein Listenwert oder ein Skalarwert sein.
import numpy as np
import matplotlib.pyplot as plt
xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])
#Nimmt x, wenn cond True ist, andernfalls y
#Einschlussnotation (langsam)
reult1 = [(x if c else y) for x, y, c in zip(xarr, yarr, cond)]
#benutze wo
result2 = np.where(cond, xarr,yarr)
print(result2)
# [1.1 2.2 1.3 1.4 2.5]
Mathematische Funktion, statistische Funktion
Geben Sie an, welche Achse mit "Achse" verarbeitet werden soll
--arr.sum () ,arr.mean ()Gesamtsumme und Durchschnitt
--arr.sum (Achse = 1) ,arr.mean (Achse = 0)In zwei Dimensionen die Summe der Zeilen bzw. der Durchschnitt der Spalten.
Boolesche Array-Funktion
- Wenn
arr`` np.arrayist, ist(arr> 0) .sum ()die Anzahl der positiven Zahlen (True). --Wennbool = boolean array - Wenn es sogar in
bools.any ()1 True gibt, dann True --bools.all ()True, wenn alles True ist
Sortieren
--Wenn arr`` np.array ist, sortieren Sie sich mit arr.sort (). (Destruktiv)
- Geben Sie für mehrdimensionale Arrays eine beliebige Achse an, z. B. "arr.sort (1)".
Aggregatfunktion: einzigartig usw.
--np.unique (arr) entfernt Duplikate und gibt das sortierte Ergebnis zurück.
--np.inld (arr, [2, 3, 6]) ist True, wenn die Liste von arr 2,3,6 enthält, andernfalls ist False eine Liste mit der gleichen Länge wie arr. Rückkehr.
Dateieingabe / -ausgabe von ndarray
- Viele verwenden "Pandas", um Textdateien und Tabellendaten zu lesen.
- Hier konzentrieren wir uns auf das Binärformat.
--Um "arr" zu speichern, speichern Sie es unkomprimiert mit "np.save" ("some_array", arr) ". Die Erweiterung wird automatisch mit
.npyhinzugefügt. - Ähnlich lesen Sie mit
arr = np.load ('save_array.npy'). - Mit
np.savez ('array_archive.npz', a = arr1, b = arr2)mehrere arrs unkomprimiert speichern.a,bsind der Schlüssel zum Wörterbuch. --Lesen Sie mitarch = np.load ('array_archive.npz'). Nichtloadz. --Retrvearr1witharch ['a']. Extrahierearr2mitarch ['b']. --Komprimieren und speichern Sie mitnp.savez_compressed ('arrays_compressed.npz' ,, a = arr1, b = arr2). Das Lesen ist das gleiche wie oben.
Matrixberechnung
- Zur Berechnung des inneren Produkts. Verwenden Sie
dot.
import numpy as np
x = np.array([[1., 2., 3.], [4., 5., 6., ]])
y = np.array([[6., 23.], [-1., 7.], [8., 9.]])
print(x.dot(y)) #Innenprodukt
# [[ 28. 64.]
# [ 67. 181.]]
print(np.dot(x, y)) #Eine andere Art zu schreiben
# [[ 28. 64.]
# [ 67. 181.]]
print(x @ y) # @Kann auch benutzt werden.
# [[ 28. 64.]
# [ 67. 181.]]
Pseudozufallszahlengenerierung
--Verwenden Sie normal für eine 4x4-Matrix mit np.random.normal (size = (4,4)), um Zufallszahlen basierend auf einer Normalverteilung zu generieren.
--randint Gibt eine ganzzahlige Zufallszahl innerhalb des angegebenen ganzzahligen Bereichs zurück.
import numpy as np
import matplotlib.pyplot as plt
samples = np.random.normal(size=(4,4))
print(samples)
# [[ 1.45907882 1.78873804 -0.52480754 0.20770224]
# [-1.55474475 -1.67045483 -1.3589208 1.25584424]
# [ 0.90562937 -1.50742692 1.48579887 1.48081589]
# [ 1.3478]5606 -0.20653648 0.13308665 -0.24455952]
Beispiel: Zufälliger Spaziergang
Mehrfacher zufälliger Spaziergang
- Finden Sie in einem zufälligen Spaziergang nach 5000 Versuchen den Index, der zuerst 30 oder -30 auf einmal erreichte.
import numpy as np
import matplotlib.pyplot as plt
nwalks = 5000
nsteps = 1000
#Generiere zufällig 0 oder 1
draws = np.random.randint(0, 2, size=(nwalks, nsteps))
print(draws)
# [[1 1 1 ... 0 1 1]
# [1 1 0 ... 0 0 1]
# [0 0 1 ... 1 1 0]
# ...
# [0 0 1 ... 0 0 0]
# [0 0 1 ... 1 0 0]
# [1 0 1 ... 1 1 0]]
#0 und 1-Teilen Sie in 1 und 1
steps = np.where(draws > 0, 1, -1)
print(steps)
# [[ 1 1 1 ... -1 1 1]
# [ 1 1 -1 ... -1 -1 1]
# [-1 -1 1 ... 1 1 -1]
# ...
# [-1 -1 1 ... -1 -1 -1]
# [-1 -1 1 ... 1 -1 -1]
# [ 1 -1 1 ... 1 1 -1]]
#In horizontaler Richtung hinzufügen
walks = steps.cumsum(1)
print(walks)
# [[ 1 2 3 ... 10 11 12]
# [ 1 2 1 ... -44 -45 -44]
# [ -1 -2 -1 ... -28 -27 -28]
# ...
# [ -1 -2 -1 ... 6 5 4]
# [ -1 -2 -1 ... -6 -7 -8]
# [ 1 0 1 ... 28 29 28]]
print(walks.max())
# 128
print(walks.min())
# -123
#Hast du 30 erreicht? Wahr in Zeilen/Kehre mit Falsch zurück
hits30 = (np.abs(walks) >= 30).any(1)
print(hits30)
# [False False True ... True True True]
#30-Anzahl der erreichten 30
print(hits30.sum())
# 3377
# 30/-Nehmen Sie die Zeile heraus, die 30 erreicht hat, und suchen Sie den ersten Index
crossing_times = (np.abs(walks[hits30]) >= 30).argmax(1)
print(crossing_times)
# [671 313 161 ... 307 289 89]
#durchschnittlich
print(crossing_times.mean())
# 500.09327805744744
#Anzeige in der Grafik
max_row = walks[(walks == walks.max()).any(1)][0]
min_row = walks[(walks == walks.min()).any(1)][0]
plt.plot(max_row)
plt.plot(min_row)
plt.show()
- Maximale und minimale Grafik des zufälligen Gehens
Referenz
- Einführung in die Datenanalyse mit Python 2nd Edition
Recommended Posts