Python für die Datenanalyse Kapitel 4

NumPy Basics: Arrays and Vectorized Computation

ndarray Von NumPy bereitgestelltes N-dimensionales Array-Objekt Creating dnarrays

#Erstellt aus einem Array
data1 = [6, 7.5, 8, 9]
arr1 = np.array(data1)

#Kann auch in mehrdimensionalen Arrays erstellt werden
data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr2 = np.array(data2)

#Python-Range-Funktion
np.arange(10)

#Nullvektor
np.zeros(10)

#Nullmatrix
np.zeros((3, 6))

#Ohne Initialisierung generieren
np.empty((2, 3, 2))

#Bestätigung der Abmessungen
arr2.ndim

#Array-Form
arr2.shap

#Datentypbestätigung
arr1.dtype

#Generieren Sie durch Angabe des Datentyps
arr1 = np.array([1, 2, 3], dtype=np.float64)

#Aus einer Zeichenfolge generiert
data3 = ["1.1", "2.2", "3.3"]
arr3 = np.array(data3, dtype=float64)

Operations between Arrays and Scalars

#Die Berechnung zwischen Arrays ist die Berechnung zwischen demselben Ort
arr = np.array([[1, 2, 3], [4, 5, 6]])
"""
In [32]: arr
Out[32]: 
array([[1, 2, 3],
       [4, 5, 6]])
"""
arr * arr
"""
In [33]: arr * arr
Out[33]: 
array([[ 1,  4,  9],
       [16, 25, 36]])
"""

#Die Berechnung mit Skalar wird für alle Elemente berechnet
arr - 1
"""
In [34]: arr - 1
Out[34]: 
array([[0, 1, 2],
       [3, 4, 5]])
"""
1 / arr
"""
In [35]: 1 / arr
Out[35]: 
array([[1, 0, 0],
       [0, 0, 0]])
"""

Basic Indexing and Slicing / Fancy Indexing

Die Elementspezifikation entspricht der mathematischen Matrix (Zeile, Spalte)

__Wenn Sie eine Kopie eines Array-Slice möchten, ändert sich das Slice, wenn Sie es nicht kopieren, wenn sich das ursprüngliche Array ändert __ arr[5:8].copy()

Boolean Indexing Sie können das Array mit dem Bool-Array maskieren

name = np.array(["bob", "martin" ,"feed","max","rosetta","john"])
"""
In [63]: name == "bob"
Out[63]: array([ True, False, False, False, False, False], dtype=bool)
"""
arr = np.arange(6)
"""
In [68]: arr[name=="rosetta"]
Out[68]: array([4])
"""

Boolescher Operator & (and) | (or)

python

mask = (name=="rosetta") | (name=="martin")
"""
In [72]: mask
Out[72]: array([False,  True, False, False,  True, False], dtype=bool)
"""

Auswahl durch Vergleichsoperator

data = randn(10)
"""
In [78]: data
Out[78]: 
array([-0.43930899, -0.18084457,  0.50384496,  0.34177923,  0.4786331 ,
        0.0930973 ,  0.95264648,  1.29876589,  0.96616151,  0.69204729])
"""
data[data < 0] = 0
"""
In [80]: data
Out[80]: 
array([ 0.        ,  0.        ,  0.50384496,  0.34177923,  0.4786331 ,
        0.0930973 ,  0.95264648,  1.29876589,  0.96616151,  0.69204729])
"""

Transposing Arrays and Swapping Axes !! !! !! !! !! schwer! !! !! !! !! Ich denke, es ist einfacher, mit einem ausgefallenen Stück nur das zu nehmen, was Sie wollen ...

arr = np.arange(15).reshape((3,5))

#Translokation
arr.T

#Innenprodukt
np.dot(arr.T, arr)

arr = np.arange(45).reshape((3,5,3))

#Transformieren Sie durch Angabe der Achse
arr.transpose((1, 0, 2))

#Wellenwechsel
arr.swapaxes(1, 2)

Universal Functions: Fast Element-wise Array Functions

1 Argumentfunktion

Eine Funktion, die elementweise arbeitet. Wenden Sie mit np.func (x) eine Funktion auf jedes Element von x an.

2-Argument-Funktion

Wird in np.func (x1, x2) verwendet.

Data Processing Using Arrays Visualisieren Sie zweidimensionale Daten. Zeigen Sie als Beispiel das Raster an, das sqrt berechnet hat (x ^ 2, y ^ 2).

#Erstellen Sie 1000 Punkte
points = np.arange(-5, 5, 0.01)
#Erstellen Sie ein 2D-Netz
#x ist ein zweidimensionales Array mit einem Array von x in Zeilen und y ist ein Array von y in Spalten
xs, ys = np.meshgrid(points, points)
#Berechnung
z = np.sqrt(xs ** 2 + ys ** 2)
#Anzeige
plt.imshow(z, cmap=plt.cm.gray); plt.colorbar()
plt.title("Image plot of $\sqrt{x^2 + y^2}$ for a grid of values")

Expressing Conditional Logic as Array Operations np.where ist eine Funktion, die je nach Wert des ersten Arguments entweder das zweite oder das dritte Argument zurückgibt. Das heißt, np.where (cond, xarr, yarr) = [(x wenn c sonst y) für x, y, c in zip (xarr, yarr, cond)]

arr = randn(5, 5)
"""
In [5]: arr
Out[5]: 
array([[-0.63774199, -0.76558645, -0.46003378,  0.61095653,  0.78277454],
       [ 0.25332127,  0.50226145, -1.45706102,  1.14315867,  0.28015   ],
       [-0.76326506,  0.33218657, -0.18509161, -0.3410194 , -0.29194451],
       [-0.32247669, -0.64285987, -0.61059921, -0.38261289,  0.41530912],
       [-1.7341384 ,  1.39960857,  0.78411537,  0.25922757, -0.22972615]])
"""
arrtf = np.where(arr > 0, True, False)
"""
In [6]: arrtf
Out[6]: 
array([[False, False, False,  True,  True],
       [ True,  True, False,  True,  True],
       [False,  True, False, False, False],
       [False, False, False, False,  True],
       [False,  True,  True,  True, False]], dtype=bool)
"""

Durch die Kombination dieser ist es möglich, nach mehreren Bedingungen zu klassifizieren.

cond1 = np.where(randn(10) > 0, True, False)
cond2 = np.where(randn(10) > 0, True, False)
"""
In [16]: cond1
Out[16]: array([False,  True, False, False,  True,  True,  True,  True,  True,  True], dtype=bool)

In [17]: cond2
Out[17]: array([False, False, False, False, False,  True, False,  True,  True,  True], dtype=bool)
"""
result = np.where(cond1 & cond2, 0, np.where(cond1, 1, np.where(cond2, 2, 3)))
"""
In [19]: result
Out[19]: array([3, 1, 3, 3, 1, 0, 1, 0, 0, 0])
"""

Wenn und sonst kann umgeschrieben werden.

result = []
for i in range(n):
    if cond1[i] and cond2[i]:
        result.append(0)
    elif cond1[i]:
        result.append(1)
    elif cond2[i]:
        result.append(2)
    else:
        result.append(3)

Dies ist auch mit Formeln möglich. (Beachten Sie, dass 0 und 3 mit den anderen ausgetauscht werden) result = 1*cond1 + 2*cond2

Mathematical and Statistical Methods Statistische Funktionen sind ebenfalls verfügbar.

arr = randn(5, 4)
arr.mean()
#Achse kann auch angegeben werden
arr.mean(0)
arr.mean(1)
"""
In [60]: arr.mean()
Out[60]: 0.51585861805229682

In [62]: arr.mean(0)
Out[62]: array([ 0.65067115, -0.03856606,  1.06405353,  0.38727585])

In [63]: arr.mean(1)
Out[63]: array([ 1.18400902,  0.84203136,  0.50352006,  0.07445734, -0.0247247 ])
"""

• sum
• mean
• std, var
• min, max
• argmin, argmax (gibt den maximalen / minimalen Index zurück)
• Cumsum (progressive Summe)
• cumprod (kumulierte Summe)

Methods for Boolean Arrays Da der Boolesche Typ True als 1 und False als 0 gezählt wird, wird häufig die Zählung mit der Summenfunktion verwendet.

arr = randn(100)
sumnum = (arr > 0).sum()
"""
In [75]: sumnum
Out[75]: 43
"""

Andere Boolesche Funktionen

• any (True, wenn es nur ein True gibt)
• all (True wenn alle True sind)

Sorting Sie können auch sortieren. arr.sort()

Unique and Other Set Logic Sie können auch so etwas wie die echte Python-Set-Funktion verwenden.

• unique(x)
• intersect1d(x, y)（unique(x) & unique(y)）
• union1d(x, y)（unique(x) | unique(y)）
• in1d (x, y) (gibt ein Array von Booleschen Werten zurück, wenn das Element von y in x enthalten ist)
• setdiff1d (x, y) (Wert von x nicht in y)
• setxor1d (x, y) (Wert von x nicht in y & Wert von y nicht in x)

File Input and Output with Arrays Sie können das NumPy-Array-Objekt in einer externen Datei speichern. Natürlich können Sie die gespeicherte Datei auch laden und wiederherstellen.

arr = np.arange(10)

#Im Binärformat speichern
np.save("array_name", arr)
#Datei im Binärformat laden
arr = np.load("array_name.npy")
#Speichern Sie mehrere Arrays in zip
np.savez("array_archive.npz", a=arr, b=arr)
#Laden Sie mehrere Array-Zip
arr_a = np.load("array_archive.npz")["a"]
arr_b = np.load("array_archive.npz")["b"]

#Speichern Sie im CSV-Format
np.savetxt("array_ex.txt", arr, delimiter=",")
#Lesen Sie die Datei im CSV-Format
arr = np.loadtxt("array_ex.txt", delimiter=",")

Linear Algebra Sie können auch die lineare Algebra berechnen.

Random Number Generation Zufallswerte verschiedener Verteilungen können mit hoher Geschwindigkeit erhalten werden.

Example: Random Walks Führen Sie in ipython Folgendes aus

nsteps = 1000
draws = np.random.randint(0, 2, size=nsteps)
steps = np.where(draws > 0, 1, -1)
walk = steps.cumsum()
plt.plot(walk)

Simulating Many Random Walks at Once

nwalks = 100
nsteps = 1000
draws = np.random.randint(0, 2, size=(nwalks, nsteps))
steps = np.where(draws > 0, 1, -1)
walks = steps.cumsum(1)
plt.plot(walks)

Erweiterung Es sieht nicht so aus, als wäre es ein zufälliger Wert von sehr hoher Qualität, aber es sollte eine ziemlich hohe Qualität haben, da tatsächlich Mercennu Twister verwendet wird.