3.2 Das Modul NumPy#
Python kann auch auf schwachbrüstiger Hardware laufen wie beispielsweise auf dem Raspberry Pi. Ein Grund für die Effizienz von Python ist, dass nicht alle möglichen Datentypen, Funktionen und Methoden von Beginn an in den Speicher geladen werden, sondern erst bei Bedarf. Python-Code ist in sogenannte Module unterteilt.
In diesem Jupyter Notebook werden wir den Modul-Mechanismus anhand des NumPy-Moduls kennenlernen.
Lernziele#
Lernziele
Sie können erklären, was ein Modul in Python ist.
Sie können ein Modul komplett mit import modul importieren und auf die darin enthaltenen Funktionalitäten mit modul.funktionalitaet zugreifen.
Sie können mit from modul import funktionalitaet einzelne Funktionalitäten eines Moduls importieren.
Sie kennen das Modul NumPy.
Importieren von Modulen#
Es wäre schön, häufig gebrauchte Zahlen wie die Kreiszahl \(\pi\) oder die Eulersche Zahl \(e\) zur Verfügung zu haben. Leider gehören beide nicht zum Python-Kern. Geben Sie einmal den folgenden Code ein:
print(pi)
Python gibt eine Fehlermeldung aus. Der Fehler lautet “NameError”. Der Python-Interpreter meldet auch, bei welcher Variable der Namensfehler auftritt, nämlich bei ‘pi’.
Die fehlende Kreiszahl Pi könnte natürlich zu Beginn eines Programmes eingeführt werden.
pi = 3.14
print(pi)
3.14
Aber es gibt ja noch mehr Funktionalitäten, die im Python-Kern fehlen wie beispielsweise die Sinus-Funktion oder die Wurzel-Funktion.
Module sind Python-Programme, die Konstanten oder Anweisungen (Funktionen, Klassen) zur Verfügung stellen und damit den eigentlichen Python-Kern erweitern. Module müssen importiert werden, damit der Python-Interpreter diese erweiterten Funktionalitäten benutzen kann.
Es gibt mehrere Anweisungen, ein Modul zu importieren. Als erstes betrachten wir
die direkte import-Anweisung und importieren das Mathematik-Modul numpy. Das
NumPy-Modul ist eine leistungsstarke Bibliothek für numerische Berechnungen in
Python, die häufig in wissenschaftlichen und technischen Anwendungen verwendet
wird.
import numpy
Wird die obige Anweisung import numpy ausgeführt, passiert scheinbar nichts.
Tatsächlich hat der Python-Interpreter jedoch das Modul geladen. Die Anweisung
dir(numpy) listet auf, was genau alles importiert wurde.
dir(numpy)
['ALLOW_THREADS',
'AxisError',
'BUFSIZE',
'CLIP',
'ComplexWarning',
'DataSource',
'ERR_CALL',
'ERR_DEFAULT',
'ERR_IGNORE',
'ERR_LOG',
'ERR_PRINT',
'ERR_RAISE',
'ERR_WARN',
'FLOATING_POINT_SUPPORT',
'FPE_DIVIDEBYZERO',
'FPE_INVALID',
'FPE_OVERFLOW',
'FPE_UNDERFLOW',
'False_',
'Inf',
'Infinity',
'MAXDIMS',
'MAY_SHARE_BOUNDS',
'MAY_SHARE_EXACT',
'ModuleDeprecationWarning',
'NAN',
'NINF',
'NZERO',
'NaN',
'PINF',
'PZERO',
'RAISE',
'RankWarning',
'SHIFT_DIVIDEBYZERO',
'SHIFT_INVALID',
'SHIFT_OVERFLOW',
'SHIFT_UNDERFLOW',
'ScalarType',
'Tester',
'TooHardError',
'True_',
'UFUNC_BUFSIZE_DEFAULT',
'UFUNC_PYVALS_NAME',
'VisibleDeprecationWarning',
'WRAP',
'_CopyMode',
'_NoValue',
'_UFUNC_API',
'__NUMPY_SETUP__',
'__all__',
'__builtins__',
'__cached__',
'__config__',
'__deprecated_attrs__',
'__dir__',
'__doc__',
'__expired_functions__',
'__file__',
'__former_attrs__',
'__future_scalars__',
'__getattr__',
'__git_version__',
'__loader__',
'__name__',
'__package__',
'__path__',
'__spec__',
'__version__',
'_add_newdoc_ufunc',
'_builtins',
'_distributor_init',
'_financial_names',
'_get_promotion_state',
'_globals',
'_int_extended_msg',
'_mat',
'_no_nep50_warning',
'_pyinstaller_hooks_dir',
'_pytesttester',
'_set_promotion_state',
'_specific_msg',
'_version',
'abs',
'absolute',
'add',
'add_docstring',
'add_newdoc',
'add_newdoc_ufunc',
'all',
'allclose',
'alltrue',
'amax',
'amin',
'angle',
'any',
'append',
'apply_along_axis',
'apply_over_axes',
'arange',
'arccos',
'arccosh',
'arcsin',
'arcsinh',
'arctan',
'arctan2',
'arctanh',
'argmax',
'argmin',
'argpartition',
'argsort',
'argwhere',
'around',
'array',
'array2string',
'array_equal',
'array_equiv',
'array_repr',
'array_split',
'array_str',
'asanyarray',
'asarray',
'asarray_chkfinite',
'ascontiguousarray',
'asfarray',
'asfortranarray',
'asmatrix',
'atleast_1d',
'atleast_2d',
'atleast_3d',
'average',
'bartlett',
'base_repr',
'binary_repr',
'bincount',
'bitwise_and',
'bitwise_not',
'bitwise_or',
'bitwise_xor',
'blackman',
'block',
'bmat',
'bool_',
'broadcast',
'broadcast_arrays',
'broadcast_shapes',
'broadcast_to',
'busday_count',
'busday_offset',
'busdaycalendar',
'byte',
'byte_bounds',
'bytes_',
'c_',
'can_cast',
'cast',
'cbrt',
'cdouble',
'ceil',
'cfloat',
'char',
'character',
'chararray',
'choose',
'clip',
'clongdouble',
'clongfloat',
'column_stack',
'common_type',
'compare_chararrays',
'compat',
'complex128',
'complex64',
'complex_',
'complexfloating',
'compress',
'concatenate',
'conj',
'conjugate',
'convolve',
'copy',
'copysign',
'copyto',
'corrcoef',
'correlate',
'cos',
'cosh',
'count_nonzero',
'cov',
'cross',
'csingle',
'ctypeslib',
'cumprod',
'cumproduct',
'cumsum',
'datetime64',
'datetime_as_string',
'datetime_data',
'deg2rad',
'degrees',
'delete',
'deprecate',
'deprecate_with_doc',
'diag',
'diag_indices',
'diag_indices_from',
'diagflat',
'diagonal',
'diff',
'digitize',
'disp',
'divide',
'divmod',
'dot',
'double',
'dsplit',
'dstack',
'dtype',
'e',
'ediff1d',
'einsum',
'einsum_path',
'emath',
'empty',
'empty_like',
'equal',
'error_message',
'errstate',
'euler_gamma',
'exp',
'exp2',
'expand_dims',
'expm1',
'extract',
'eye',
'fabs',
'fastCopyAndTranspose',
'fft',
'fill_diagonal',
'find_common_type',
'finfo',
'fix',
'flatiter',
'flatnonzero',
'flexible',
'flip',
'fliplr',
'flipud',
'float16',
'float32',
'float64',
'float_',
'float_power',
'floating',
'floor',
'floor_divide',
'fmax',
'fmin',
'fmod',
'format_float_positional',
'format_float_scientific',
'format_parser',
'frexp',
'from_dlpack',
'frombuffer',
'fromfile',
'fromfunction',
'fromiter',
'frompyfunc',
'fromregex',
'fromstring',
'full',
'full_like',
'gcd',
'generic',
'genfromtxt',
'geomspace',
'get_array_wrap',
'get_include',
'get_printoptions',
'getbufsize',
'geterr',
'geterrcall',
'geterrobj',
'gradient',
'greater',
'greater_equal',
'half',
'hamming',
'hanning',
'heaviside',
'histogram',
'histogram2d',
'histogram_bin_edges',
'histogramdd',
'hsplit',
'hstack',
'hypot',
'i0',
'identity',
'iinfo',
'imag',
'in1d',
'index_exp',
'indices',
'inexact',
'inf',
'info',
'infty',
'inner',
'insert',
'int16',
'int32',
'int64',
'int8',
'int_',
'intc',
'integer',
'interp',
'intersect1d',
'intp',
'invert',
'is_busday',
'isclose',
'iscomplex',
'iscomplexobj',
'isfinite',
'isfortran',
'isin',
'isinf',
'isnan',
'isnat',
'isneginf',
'isposinf',
'isreal',
'isrealobj',
'isscalar',
'issctype',
'issubclass_',
'issubdtype',
'issubsctype',
'iterable',
'ix_',
'kaiser',
'kron',
'lcm',
'ldexp',
'left_shift',
'less',
'less_equal',
'lexsort',
'lib',
'linalg',
'linspace',
'little_endian',
'load',
'loadtxt',
'log',
'log10',
'log1p',
'log2',
'logaddexp',
'logaddexp2',
'logical_and',
'logical_not',
'logical_or',
'logical_xor',
'logspace',
'longcomplex',
'longdouble',
'longfloat',
'longlong',
'lookfor',
'ma',
'mask_indices',
'mat',
'math',
'matmul',
'matrix',
'max',
'maximum',
'maximum_sctype',
'may_share_memory',
'mean',
'median',
'memmap',
'meshgrid',
'mgrid',
'min',
'min_scalar_type',
'minimum',
'mintypecode',
'mod',
'modf',
'moveaxis',
'msort',
'multiply',
'nan',
'nan_to_num',
'nanargmax',
'nanargmin',
'nancumprod',
'nancumsum',
'nanmax',
'nanmean',
'nanmedian',
'nanmin',
'nanpercentile',
'nanprod',
'nanquantile',
'nanstd',
'nansum',
'nanvar',
'nbytes',
'ndarray',
'ndenumerate',
'ndim',
'ndindex',
'nditer',
'negative',
'nested_iters',
'newaxis',
'nextafter',
'nonzero',
'not_equal',
'numarray',
'number',
'obj2sctype',
'object_',
'ogrid',
'oldnumeric',
'ones',
'ones_like',
'outer',
'packbits',
'pad',
'partition',
'percentile',
'pi',
'piecewise',
'place',
'poly',
'poly1d',
'polyadd',
'polyder',
'polydiv',
'polyfit',
'polyint',
'polymul',
'polynomial',
'polysub',
'polyval',
'positive',
'power',
'printoptions',
'prod',
'product',
'promote_types',
'ptp',
'put',
'put_along_axis',
'putmask',
'quantile',
'r_',
'rad2deg',
'radians',
'random',
'ravel',
'ravel_multi_index',
'real',
'real_if_close',
'rec',
'recarray',
'recfromcsv',
'recfromtxt',
'reciprocal',
'record',
'remainder',
'repeat',
'require',
'reshape',
'resize',
'result_type',
'right_shift',
'rint',
'roll',
'rollaxis',
'roots',
'rot90',
'round',
'round_',
'row_stack',
's_',
'safe_eval',
'save',
'savetxt',
'savez',
'savez_compressed',
'sctype2char',
'sctypeDict',
'sctypes',
'searchsorted',
'select',
'set_numeric_ops',
'set_printoptions',
'set_string_function',
'setbufsize',
'setdiff1d',
'seterr',
'seterrcall',
'seterrobj',
'setxor1d',
'shape',
'shares_memory',
'short',
'show_config',
'show_runtime',
'sign',
'signbit',
'signedinteger',
'sin',
'sinc',
'single',
'singlecomplex',
'sinh',
'size',
'sometrue',
'sort',
'sort_complex',
'source',
'spacing',
'split',
'sqrt',
'square',
'squeeze',
'stack',
'std',
'str_',
'string_',
'subtract',
'sum',
'swapaxes',
'take',
'take_along_axis',
'tan',
'tanh',
'tensordot',
'test',
'testing',
'tile',
'timedelta64',
'trace',
'tracemalloc_domain',
'transpose',
'trapz',
'tri',
'tril',
'tril_indices',
'tril_indices_from',
'trim_zeros',
'triu',
'triu_indices',
'triu_indices_from',
'true_divide',
'trunc',
'typecodes',
'typename',
'ubyte',
'ufunc',
'uint',
'uint16',
'uint32',
'uint64',
'uint8',
'uintc',
'uintp',
'ulonglong',
'unicode_',
'union1d',
'unique',
'unpackbits',
'unravel_index',
'unsignedinteger',
'unwrap',
'use_hugepage',
'ushort',
'vander',
'var',
'vdot',
'vectorize',
'version',
'void',
'vsplit',
'vstack',
'w',
'where',
'who',
'zeros',
'zeros_like']
Offensichtlich gehören sehr viele mathematische Funktionen zum NumPy-Modul, aber
auch die beiden Zahlen pi und e finden wir in der Liste. Dann können wir ja
\(\pi\) jetzt direkt ausgeben lassen:
print(pi)
3.14
Erstaunlich, dass in einem Standard-Modul von Python die Programmier:innen \(\pi\)
nur mit zwei Nachkommastellen angegeben haben… haben sie auch nicht. Die
Variable pi wurde von uns selbst mit pi = 3.14 definiert und ist nicht
identisch mit pi aus dem NumPy-Modul. Die Kreiszahl aus dem NumPy-Modul heißt
nämlich numpy.pi.
print(numpy.pi)
3.141592653589793
Um Konstanten, Datentypen oder Funktionen eines Moduls zu nutzen, wird der Modulname vorangestellt und erneut der Punkt benutzt. Probieren Sie es in der nächsten Mini-Übung aus.
Mini-Übung
Weisen Sie der Variablen x den Wert \(\pi\) zu. Lassen Sie dann \(y = \sin(x)\) berechnen und ausgeben.
# Hier Ihr Code
Lösung
x = numpy.pi
y = numpy.sin(x)
print(y)
Importieren von einzelnen Funktionen oder Klassen#
Wenn nur die Kreiszahl \(\pi\) gebraucht wird, ist der komplette Import des
NumPy-Modules zuviel des Guten. Auch kann es lästig sein, immer numpy. vor pi
zu setzen. Eine zweite Möglichkeit, Funktionalitäten eines Moduls zu
importieren, ist die Alternative
from modulname import etwas1, etwas2
\(\pi\) und die Sinus-Funktion werden dann folgendermaßen importiert:
from numpy import pi, sin
Jetzt können pi und sin direkt benutzt werden, ohne numpy. davor zu
schreiben.
print(pi)
print(sin(0))
3.141592653589793
0.0
Mini-Übung
Importieren Sie die Wurzel-Funktion sqrt() direkt aus NumPy. Berechnen Sie dann \(\sqrt{49}\) und \(\sqrt{2}\) und lassen Sie das Ergebnis jeweils ausgeben.
# Hier Ihr Code
Lösung
from numpy import sqrt
print(sqrt(49))
print(sqrt(2))
Importieren von Modulen mit Alias#
Es ist üblich, Module mit einem kürzeren Alias zu importieren, um den Code
lesbarer zu gestalten und weniger tippen zu müssen. Im Fall von NumPy wird
häufig der Alias np verwendet:
import numpy as np
Nachdem wir das Modul mit einem Alias importiert haben, verwenden wir diesen Alias, um auf die Funktionen und Klassen des Moduls zuzugreifen:
x = np.pi
print(x)
3.141592653589793
Mini-Übung
Importieren Sie das math-Modul mit dem Alias m und lassen Sie die Kreiszahl \(\pi\) ausgeben. Bilden Sie dann die Differenz aus der Kreiszahl des math-Moduls und der Kreiszahl des NumPy-Moduls.
Gibt es einen Unterschied zwischen den beiden Zahlen?
# Hier Ihr Code
Lösung
import math as m
print(m.pi)
differenz = m.pi - np.pi
print(differenz)
Das math-Modul stellt ebenfalls mathematische Konstanten und Funktionen zur Verfügung, ist aber weniger umfangreich. Daher verwenden wir in dieser Vorlesung NumPy.
Zusammenfassung#
In diesem Kapitel haben wir den Modul-Mechanismus in Python untersucht und das NumPy-Modul als Beispiel verwendet. Wir haben gelernt, wie man Module importiert, spezifische Funktionen und Klassen aus einem Modul importiert und Module mit einem Alias importiert. Durch das Verständnis dieser Konzepte können Sie Ihren Python-Code besser organisieren und die Wiederverwendbarkeit von Code verbessern.