Zoeken…
Invoering
N-dimensionale arrays of ndarrays zijn het ndarrays van numpy dat wordt gebruikt voor het opslaan van items van hetzelfde gegevenstype. Ze bieden een efficiënte gegevensstructuur die superieur is aan gewone Pythons-arrays.
Opmerkingen
Druk waar mogelijk bewerkingen op gegevens uit in termen van arrays en vectorbewerkingen. Vectorbewerkingen worden veel sneller uitgevoerd dan equivalent voor lussen
Maak een array
Lege array
np.empty((2,3))
Merk op dat in dit geval de waarden in deze array niet zijn ingesteld. Deze manier om een array te maken, is daarom alleen nuttig als de array later in de code wordt ingevuld.
Uit een lijst
np.array([0,1,2,3])
# Out: array([0, 1, 2, 3])
Maak een bereik
np.arange(4)
# Out: array([0, 1, 2, 3])
Maak nullen
np.zeros((3,2))
# Out:
# array([[ 0., 0.],
# [ 0., 0.],
# [ 0., 0.]])
Maak degenen
np.ones((3,2))
# Out:
# array([[ 1., 1.],
# [ 1., 1.],
# [ 1., 1.]])
Maak array-items met een lineaire afstand
np.linspace(0,1,21)
# Out:
# array([ 0. , 0.05, 0.1 , 0.15, 0.2 , 0.25, 0.3 , 0.35, 0.4 ,
# 0.45, 0.5 , 0.55, 0.6 , 0.65, 0.7 , 0.75, 0.8 , 0.85,
# 0.9 , 0.95, 1. ])
Maak matrixitems met logboekafstand
np.logspace(-2,2,5)
# Out:
# array([ 1.00000000e-02, 1.00000000e-01, 1.00000000e+00,
# 1.00000000e+01, 1.00000000e+02])
Maak een array op basis van een bepaalde functie
np.fromfunction(lambda i: i**2, (5,))
# Out:
# array([ 0., 1., 4., 9., 16.])
np.fromfunction(lambda i,j: i**2, (3,3))
# Out:
# array([[ 0., 0., 0.],
# [ 1., 1., 1.],
# [ 4., 4., 4.]])
Array-operators
x = np.arange(4)
x
#Out:array([0, 1, 2, 3])
scalaire toevoeging is elementair
x+10
#Out: array([10, 11, 12, 13])
scalaire vermenigvuldiging is elementair
x*2
#Out: array([0, 2, 4, 6])
array-toevoeging is elementair
x+x
#Out: array([0, 2, 4, 6])
matrixvermenigvuldiging is elementair
x*x
#Out: array([0, 1, 4, 9])
dotproduct (of meer in het algemeen matrixvermenigvuldiging) wordt gedaan met een functie
x.dot(x)
#Out: 14
In Python 3.5 is de operator @ toegevoegd als een infix-operator voor matrixvermenigvuldiging
x = np.diag(np.arange(4))
print(x)
'''
Out: array([[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 3]])
'''
print(x@x)
print(x)
'''
Out: array([[0, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 9]])
'''
Toevoegen . Retourneert kopie met toegevoegde waarden. NIET op zijn plaats.
#np.append(array, values_to_append, axis=None)
x = np.array([0,1,2,3,4])
np.append(x, [5,6,7,8,9])
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
x
# Out: array([0, 1, 2, 3, 4])
y = np.append(x, [5,6,7,8,9])
y
# Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
hstack . Horizontale stapel. (kolomstapel)
vstack . Verticale stapel. (rij stapel)
# np.hstack(tup), np.vstack(tup)
x = np.array([0,0,0])
y = np.array([1,1,1])
z = np.array([2,2,2])
np.hstack(x,y,z)
# Out: array([0, 0, 0, 1, 1, 1, 2, 2, 2])
np.vstack(x,y,z)
# Out: array([[0, 0, 0],
# [1, 1, 1],
# [2, 2, 2]])
Array toegang
Segmentsyntaxis is i:j:k waarbij i de startindex (inclusief) is, j de stopindex (exclusief) en k de stapgrootte is. Net als andere python-datastructuren heeft het eerste element een index van 0:
x = np.arange(10)
x[0]
# Out: 0
x[0:4]
# Out: array([0, 1, 2, 3])
x[0:4:2]
# Out:array([0, 2])
Negatieve waarden tellen in vanaf het einde van de array. -1 daarom toegang tot het laatste element in een array:
x[-1]
# Out: 9
x[-1:0:-1]
# Out: array([9, 8, 7, 6, 5, 4, 3, 2, 1])
U kunt toegang krijgen tot multidimensionale arrays door elke dimensie op te geven, gescheiden door komma's. Alle voorgaande regels zijn van toepassing.
x = np.arange(16).reshape((4,4))
x
# Out:
# array([[ 0, 1, 2, 3],
# [ 4, 5, 6, 7],
# [ 8, 9, 10, 11],
# [12, 13, 14, 15]])
x[1,1]
# Out: 5
x[0:3,0]
# Out: array([0, 4, 8])
x[0:3, 0:3]
# Out:
# array([[ 0, 1, 2],
# [ 4, 5, 6],
# [ 8, 9, 10]])
x[0:3:2, 0:3:2]
# Out:
# array([[ 0, 2],
# [ 8, 10]])
Een array transponeren
arr = np.arange(10).reshape(2, 5)
Met behulp van .transpose methode:
arr.transpose()
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
.T methode:
arr.T
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
Of np.transpose :
np.transpose(arr)
# Out:
# array([[0, 5],
# [1, 6],
# [2, 7],
# [3, 8],
# [4, 9]])
In het geval van een tweedimensionale array is dit equivalent aan een standaardmatrix-transponering (zoals hierboven afgebeeld). In het n-dimensionale geval kunt u een permutatie van de matrixassen opgeven. Standaard keert dit array.shape :
a = np.arange(12).reshape((3,2,2))
a.transpose() # equivalent to a.transpose(2,1,0)
# Out:
# array([[[ 0, 4, 8],
# [ 2, 6, 10]],
#
# [[ 1, 5, 9],
# [ 3, 7, 11]]])
Maar elke permutatie van de asindexen is mogelijk:
a.transpose(2,0,1)
# Out:
# array([[[ 0, 2],
# [ 4, 6],
# [ 8, 10]],
#
# [[ 1, 3],
# [ 5, 7],
# [ 9, 11]]])
a = np.arange(24).reshape((2,3,4)) # shape (2,3,4)
a.transpose(2,0,1).shape
# Out:
# (4, 2, 3)
Booleaanse indexering
arr = np.arange(7)
print(arr)
# Out: array([0, 1, 2, 3, 4, 5, 6])
Vergelijking met een scalair levert een booleaanse array op:
arr > 4
# Out: array([False, False, False, False, False, True, True], dtype=bool)
Deze array kan worden gebruikt bij het indexeren om alleen de getallen groter dan 4 te selecteren:
arr[arr>4]
# Out: array([5, 6])
Booleaanse indexering kan worden gebruikt tussen verschillende arrays (bijv. Gerelateerde parallelle arrays):
# Two related arrays of same length, i.e. parallel arrays
idxs = np.arange(10)
sqrs = idxs**2
# Retrieve elements from one array using a condition on the other
my_sqrs = sqrs[idxs % 2 == 0]
print(my_sqrs)
# Out: array([0, 4, 16, 36, 64])
Een array opnieuw vormgeven
De numpy.reshape (hetzelfde als numpy.ndarray.reshape ) retourneert een array met dezelfde totale grootte, maar in een nieuwe vorm:
print(np.arange(10).reshape((2, 5)))
# [[0 1 2 3 4]
# [5 6 7 8 9]]
Het retourneert een nieuwe array en werkt niet op zijn plaats:
a = np.arange(12)
a.reshape((3, 4))
print(a)
# [ 0 1 2 3 4 5 6 7 8 9 10 11]
Het is echter mogelijk om het shape van een ndarray te overschrijven:
a = np.arange(12)
a.shape = (3, 4)
print(a)
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Dit gedrag is in het begin misschien verrassend, maar ndarray 's worden opgeslagen in aangrenzende geheugenblokken en hun shape alleen aan hoe deze gegevensstroom moet worden geïnterpreteerd als een multidimensionaal object.
Tot een as in de shape tupel kan een waarde hebben van -1 . numpy zal vervolgens de lengte van deze as voor u afleiden:
a = np.arange(12)
print(a.reshape((3, -1)))
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
Of:
a = np.arange(12)
print(a.reshape((3, 2, -1)))
# [[[ 0 1]
# [ 2 3]]
# [[ 4 5]
# [ 6 7]]
# [[ 8 9]
# [10 11]]]
Meerdere niet-gespecificeerde dimensies, bijvoorbeeld a.reshape((3, -1, -1)) zijn niet toegestaan en a.reshape((3, -1, -1)) een ValueError .
Uitzenden van bewerkingen
Rekenkundige bewerkingen worden elementair uitgevoerd op Numpy-arrays. Voor arrays met identieke vorm betekent dit dat de bewerking wordt uitgevoerd tussen elementen op overeenkomstige indices.
# Create two arrays of the same size
a = np.arange(6).reshape(2, 3)
b = np.ones(6).reshape(2, 3)
a
# array([0, 1, 2],
# [3, 4, 5])
b
# array([1, 1, 1],
# [1, 1, 1])
# a + b: a and b are added elementwise
a + b
# array([1, 2, 3],
# [4, 5, 6])
Rekenkundige bewerkingen kunnen ook worden uitgevoerd op arrays van verschillende vormen door middel van Numpy- uitzendingen . In het algemeen wordt de ene reeks over de andere "uitgezonden" zodat elementaire bewerkingen worden uitgevoerd op sub-reeksen van congruente vorm.
# Create arrays of shapes (1, 5) and (13, 1) respectively
a = np.arange(5).reshape(1, 5)
a
# array([[0, 1, 2, 3, 4]])
b = np.arange(4).reshape(4, 1)
b
# array([0],
# [1],
# [2],
# [3])
# When multiplying a * b, slices with the same dimensions are multiplied
# elementwise. In the case of a * b, the one and only row of a is multiplied
# with each scalar down the one and only column of b.
a*b
# array([[ 0, 0, 0, 0, 0],
# [ 0, 1, 2, 3, 4],
# [ 0, 2, 4, 6, 8],
# [ 0, 3, 6, 9, 12]])
Om dit verder te illustreren, overweeg dan de vermenigvuldiging van 2D- en 3D-arrays met congruente subdimensies.
# Create arrays of shapes (2, 2, 3) and (2, 3) respectively
a = np.arange(12).reshape(2, 2, 3)
a
# array([[[ 0 1 2]
# [ 3 4 5]]
#
# [[ 6 7 8]
# [ 9 10 11]]])
b = np.arange(6).reshape(2, 3)
# array([[0, 1, 2],
# [3, 4, 5]])
# Executing a*b broadcasts b to each (2, 3) slice of a,
# multiplying elementwise.
a*b
# array([[[ 0, 1, 4],
# [ 9, 16, 25]],
#
# [[ 0, 7, 16],
# [27, 40, 55]]])
# Executing b*a gives the same result, i.e. the smaller
# array is broadcast over the other.
Wanneer wordt array-uitzending toegepast?
Uitzending vindt plaats wanneer twee arrays compatibele vormen hebben.
Vormen worden component-gewijs vergeleken beginnend met de volgende. Twee dimensies zijn compatibel als ze hetzelfde zijn of één ervan 1 . Als de ene vorm een hogere dimensie heeft dan de andere, worden de overtollige componenten niet vergeleken.
Enkele voorbeelden van compatibele vormen:
(7, 5, 3) # compatible because dimensions are the same
(7, 5, 3)
(7, 5, 3) # compatible because second dimension is 1
(7, 1, 3)
(7, 5, 3, 5) # compatible because exceeding dimensions are not compared
(3, 5)
(3, 4, 5) # incompatible
(5, 5)
(3, 4, 5) # compatible
(1, 5)
Hier is de officiële documentatie over array-uitzendingen .
Vul een array in met de inhoud van een CSV-bestand
filePath = "file.csv"
data = np.genfromtxt(filePath)
Veel opties worden ondersteund, zie officiële documentatie voor de volledige lijst:
data = np.genfromtxt(filePath, dtype='float', delimiter=';', skip_header=1, usecols=(0,1,3) )
Numpy n-dimensionale array: de ndarray
De kerngegevensstructuur in numpy is de ndarray ( ndarray voor n -dimensional array). ndarray s zijn
- homogeen (dwz ze bevatten items van hetzelfde gegevenstype)
- items met vaste afmetingen bevatten (gegeven door een vorm , een tupel van n positieve gehele getallen die de afmetingen van elke dimensie specificeren)
Eendimensionale array:
x = np.arange(15)
# array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
x.shape
# (15,)
Tweedimensionale reeks:
x = np.asarray([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])
x
# array([[ 0, 1, 2, 3, 4],
# [ 5, 6, 7, 8, 9],
# [10, 11, 12, 13, 14]])
x.shape
# (3, 5)
Driedimensionale:
np.arange(12).reshape([2,3,2])
Om een array te initialiseren zonder de inhoud ervan op te geven, gebruikt u:
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
Datatype raden en automatisch casten
Het gegevenstype is standaard ingesteld om te zweven
x = np.empty([2, 2])
# array([[ 0., 0.],
# [ 0., 0.]])
x.dtype
# dtype('float64')
Als sommige gegevens worden verstrekt, raadt numpy het gegevenstype:
x = np.asarray([[1, 2], [3, 4]])
x.dtype
# dtype('int32')
Merk op dat bij het uitvoeren van opdrachten, numpy zal proberen automatisch waarden te casten die passen bij het gegevenstype van de ndarray
x[1, 1] = 1.5 # assign a float value
x[1, 1]
# 1
# value has been casted to int
x[1, 1] = 'z' # value cannot be casted, resulting in a ValueError
Array-uitzending
Zie ook Broadcasting array-bewerkingen .
x = np.asarray([[1, 2], [3, 4]])
# array([[1, 2],
[3, 4]])
y = np.asarray([[5, 6]])
# array([[5, 6]])
In matrixterminologie zouden we een 2x2-matrix en een 1x2-rijvector hebben. Toch kunnen we een bedrag doen
# x + y
array([[ 6, 8],
[ 8, 10]])
Dit komt omdat de array y wordt " uitgerekt " naar:
array([[5, 6],
[5, 6]])
passend bij de vorm van x .
Middelen:
- Inleiding tot de ndarray uit de officiële documentatie: de N-dimensionale array (ndarray)
- Klasse referentie: ndarray .