Numpy

  • Meist hat man nach in einer Auswertung Datenpunkte, die verarbeitet werden müssen
  • Numpy ist eine Python-Bibliothek, die den Umgang mit Datenpunkten enorm vereinfacht
In [1]:
%%javascript
$.getScript('https://kmahelona.github.io/ipython_notebook_goodies/ipython_notebook_toc.js')

Inhalt

Grundlagen

In [2]:
import numpy as np
  • Grunddatentyp von Numpy: das Array
  • Kann man sich als effizientere Liste vorstellen
  • Idee von Numpy: Man kann ein Array ähnlich wie eine Zahl verwenden. Operationen werden dann auf allen Elementen ausgeführt
  • Am besten versteht man das mit einigen Beispielen:
In [3]:
# convert list to array
x = np.array([1, 2, 3, 4, 5])
In [4]:
2 * x
Out[4]:
array([ 2,  4,  6,  8, 10])
In [5]:
x**2
Out[5]:
array([ 1,  4,  9, 16, 25])
In [6]:
x**x
Out[6]:
array([   1,    4,   27,  256, 3125])
In [7]:
np.cos(x)
Out[7]:
array([ 0.54030231, -0.41614684, -0.9899925 , -0.65364362,  0.28366219])

Bei großen Datensätzen relevant: Laufzeit!

In [8]:
%%timeit
xs = [42] * 100000
xs2 = [x**2 for x in xs]
15.2 ms ± 44.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
In [9]:
%%timeit 
x = np.full(100000, 42)
x2 = x**2
224 µs ± 3.16 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Achtung: Man braucht das cos aus numpy!

In [10]:
import math
math.cos(x)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-87cdf88e21ce> in <module>
      1 import math
----> 2 math.cos(x)

TypeError: only size-1 arrays can be converted to Python scalars

Selbstgeschriebene Funktionen, die nur für eine Zahl geschrieben wurden, funktionieren oft ohne Änderung mit Arrays!

In [11]:
def poly(y):
    return y + 2 * y**2 - y**3

poly(x)
Out[11]:
array([  2,   2,  -6, -28, -70])
In [12]:
poly(np.pi)
Out[12]:
-8.125475224531307
In [13]:
# this also works:
def poly(x):
    return x + 2 * x**2 - x**3

poly(x)
Out[13]:
array([  2,   2,  -6, -28, -70])

Das erlaubt es einem unter anderem sehr leicht physikalische Formeln auf seine Datenpunkte anzuwenden.

Arrays können beliebige Dimension haben:

In [14]:
# two-dimensional array
y = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

y + y
Out[14]:
array([[ 2,  4,  6],
       [ 8, 10, 12],
       [14, 16, 18]])

Das erlaubt es z.B. eine ganze Tabelle als ein Array abzuspeichern.

Nützliche Eigenschaften

In [15]:
a = np.array([1.5, 3.0, 4.2])
b = np.array([[1, 2], [3, 4]])

print(a.ndim, a.shape, a.size, a.dtype)
print(b.ndim, b.shape, b.size, b.dtype)
1 (3,) 3 float64
2 (2, 2) 4 int64

Erstellen von Arrays

Es gibt viele nützliche Funktionen, die bei der Erstellung von Arrays helfen:

In [16]:
np.zeros(10)
Out[16]:
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
In [17]:
np.ones((5, 2))
Out[17]:
array([[1., 1.],
       [1., 1.],
       [1., 1.],
       [1., 1.],
       [1., 1.]])
In [18]:
np.linspace(0, 1, 11)
Out[18]:
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
In [19]:
# like range() for arrays:
np.arange(0, 10)
Out[19]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [20]:
np.logspace(-4, 5, 10)
Out[20]:
array([1.e-04, 1.e-03, 1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03,
       1.e+04, 1.e+05])

Numpy Indexing

Numpy erlaubt einem sehr bequem bestimmte Elemente aus einem Array auszuwählen

In [21]:
x = np.arange(0, 10)

# like lists:
x[4]
Out[21]:
4
In [22]:
# all elements with indices ≥1 and <4:
x[1:4]
Out[22]:
array([1, 2, 3])
In [23]:
# negative indices count from the end
x[-1], x[-2]
Out[23]:
(9, 8)
In [24]:
# combination:
x[3:-2]
Out[24]:
array([3, 4, 5, 6, 7])
In [25]:
# step size
x[::2]
Out[25]:
array([0, 2, 4, 6, 8])
In [26]:
# trick for reversal: negative step
x[::-1]
Out[26]:
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

Indexing1D

In [27]:
y = np.array([x, x + 10, x + 20, x + 30])
y
Out[27]:
array([[ 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, 32, 33, 34, 35, 36, 37, 38, 39]])
In [28]:
# comma between indices
y[3, 2:-1]
Out[28]:
array([32, 33, 34, 35, 36, 37, 38])
In [29]:
# only one index ⇒ one-dimensional array
y[2]
Out[29]:
array([20, 21, 22, 23, 24, 25, 26, 27, 28, 29])
In [30]:
# other axis: (: alone means the whole axis)
y[:, 3]
Out[30]:
array([ 3, 13, 23, 33])
In [31]:
# inspecting the number of elements per axis:
y.shape
Out[31]:
(4, 10)