Arrays mit NumPy

Jens Wagner 07/2015

Download this notebook

In [1]:
import numpy as np

Erstellen von Arrays

Erstellen eines Arrays aus einer Python Liste mit array()

In [2]:
print(np.array([0,1,2,3,4,5]))  #array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
print(np.array([0,1,2,3,4,5],dtype=float)) 
print(np.array([0,1,2,3,4,5.0]))  #Upcasting
print(np.array([0,1,2,3,4,5],dtype=complex)) 

[0 1 2 3 4 5]
[ 0.  1.  2.  3.  4.  5.]
[ 0.  1.  2.  3.  4.  5.]
[ 0.+0.j  1.+0.j  2.+0.j  3.+0.j  4.+0.j  5.+0.j]

Automatische Generierung von Arrays mit arrange()

In [3]:
print(np.arange(0,4,1,int)) #arange([start,] stop[, step,], dtype=None)
print(np.arange(0,4,1))     #dtype wird als "int" interpretiert
print(np.arange(0,4))       #step wird als 1 interpretiert
print(np.arange(4))         #start wird als 0 inerpretiert

[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
In [4]:
print(np.arange(0,4,1,float))
print(np.arange(0,1.1,.1))  

[ 0.  1.  2.  3.]
[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1. ]

Automatische Generierung von Arrays mit linspace(), logspace()

In [5]:
print(np.linspace(0,3,4)) #linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
print(np.linspace(0,3,4,endpoint=False))

[ 0.  1.  2.  3.]
[ 0.    0.75  1.5   2.25]
In [6]:
print(np.logspace(0,3,4)) #logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
print(np.logspace(0,8,9, base=2, dtype=int))
print(np.logspace(-10,0,11))

[    1.    10.   100.  1000.]
[  1   2   4   8  16  32  64 128 256]
[  1.00000000e-10   1.00000000e-09   1.00000000e-08   1.00000000e-07
   1.00000000e-06   1.00000000e-05   1.00000000e-04   1.00000000e-03
   1.00000000e-02   1.00000000e-01   1.00000000e+00]

Array mit 0/1 Elementen und Zufallszahlen

In [7]:
print(np.zeros(5))  #zeros(shape, dtype=float, order='C')
print(np.ones(10))  #ones(shape, dtype=None, order='C')
print(np.ones(10, dtype=int))  
print(np.random.rand(10))

[ 0.  0.  0.  0.  0.]
[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]
[1 1 1 1 1 1 1 1 1 1]
[ 0.24886131  0.38928515  0.81479887  0.38782945  0.75331798  0.60195398
  0.98772735  0.96050931  0.68395079  0.55776653]

Statistische Funktionen an Arrays

In [8]:
a=np.array([1,2,3,4,5])
print(np.mean(a)) #Mittelwert
print(np.std(a))  #Standardabweichung
print(np.max(a))  #Maximum
print(np.min(a))  #Minimum
print(np.sum(a))  #Summe

3.0
1.41421356237
5
1
15

Mehrdimensionale Arrays

Mehrdimensionale Arrays aus Listen oder Tupeln

In [9]:
print(np.array( [[11,12,13], [21,22,23], [31,32,33]] ))
print("")
print(np.array( ((11,12,13), (21,22,23), (31,32,33)) ))

[[11 12 13]
 [21 22 23]
 [31 32 33]]

[[11 12 13]
 [21 22 23]
 [31 32 33]]

Mehrdimensionale Arrays mit linspace()

In [10]:
print(np.array( [np.linspace(1,3,3), np.linspace(4,6,3), np.linspace(7,9,3)]))

[[ 1.  2.  3.]
 [ 4.  5.  6.]
 [ 7.  8.  9.]]

Indizierung von Arrays

In [11]:
a=np.array([1,2,3,4,5])
print(a)
print("") 
aa=np.array( [[11,12,13], [21,22,23], [31,32,33], [41,42,43]] )
print(aa)

[1 2 3 4 5]

[[11 12 13]
 [21 22 23]
 [31 32 33]
 [41 42 43]]
In [12]:
print(np.shape(a)) #liefert die Anzahl der Elemnte in jeder Dimension
print(np.shape(aa))

(5,)
(4, 3)
In [13]:
print(a.ndim) #liefert die Dimension des Arrays
print(aa.ndim)

1
2
In [14]:
print(a[1])  #einzelne Elemente addressieren
print(aa[0][0]) 
print(aa[3][2]) 

2
11
43

Teilmengen von Arrays (Slicing)

a[start:end]       alle Elemente ab start bis end-1
a[start:]          alle Elemente ab start bis zum Ende
a[:end]            alle Elemente vom Anfang bis zu end-1
a[:]               alle Elemente
a[start:end:step]  Ellemente nach start Schrittweite step vor end
a[-1]              das letzte Element
a[-2:]             die letzten beiden Elemente
a[:-2]             alle bis auf die letzten beiden Elemente
a[::-1]            gesamtes Array rueckwaerts auslesen
In [15]:
a=np.array([1,2,3,4,5,6])
print(a)

[1 2 3 4 5 6]
In [16]:
print(a[1:4])
print(a[4:])
print(a[:3])
print(a[0:5:2])
print(a[-1:])
print(a[-2:])
print(a[:-1])
print(a[::-1])

[2 3 4]
[5 6]
[1 2 3]
[1 3 5]
[6]
[5 6]
[1 2 3 4 5]
[6 5 4 3 2 1]

Zweidimensional: a[(zeile , spalte)]: a[(start:stop , start:stop)]

In [17]:
aa=np.array( [[1,2,3],[4,5,6],[7,8,9]])
print(aa)

[[1 2 3]
 [4 5 6]
 [7 8 9]]
In [18]:
aa[1:2,1:2]  #Das mittlere Element
Out[18]:
array([[5]])
In [19]:
aa[1:2]  #Mittlere Zeile
Out[19]:
array([[4, 5, 6]])
In [20]:
aa[1]  #Mittlere Zeile
Out[20]:
array([4, 5, 6])
In [21]:
aa[0:2] #Die ersten beiden Zeilean
Out[21]:
array([[1, 2, 3],
       [4, 5, 6]])
In [22]:
aa[:,0:1] #Die erste Spalte
Out[22]:
array([[1],
       [4],
       [7]])
In [23]:
aa[:,0:2]  #Die ersten beiden Spalten
Out[23]:
array([[1, 2],
       [4, 5],
       [7, 8]])
In [24]:
aa[:-1]  #Alles bis auf die letzte Zeile
Out[24]:
array([[1, 2, 3],
       [4, 5, 6]])
In [25]:
aa[:,:-1] #Alles bis auf die letzte Spalte
Out[25]:
array([[1, 2],
       [4, 5],
       [7, 8]])

Arrayumwandlung

In [26]:
a=np.arange(16)  
print(a)

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
In [27]:
aa=np.reshape(a,(4,4))  # 1dim --> 2dim,  reshape(a, newshape, order='C')
print(aa)
np.shape(aa)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
Out[27]:
(4, 4)
In [28]:
aa.flatten()  # 2dim --> 1dim
Out[28]:
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])
In [29]:
np.reshape(a[0:9],(3,3))
Out[29]:
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

Arrays zusammenfügen

In [33]:
a=np.arange(6) 
print(a)
b=np.arange(6,12) 
print(b)
print(np.concatenate((a,b)))    #concatenate((a1, a2, ...), axis=0)

[0 1 2 3 4 5]
[ 6  7  8  9 10 11]
[ 0  1  2  3  4  5  6  7  8  9 10 11]
In [ ]: