Vorwort des Übersetzers

Hallo allerseits, hier kommen wir zum letzten Teil. Viel Spaß beim Lesen!
Navigation:

Mathematische Polynome

NumPy bietet Methoden zum Arbeiten mit Polynomen. Durch Übergeben einer Liste von Wurzeln können Sie die Koeffizienten der Gleichung erhalten:

>>> np.poly([-1, 1, 1, 10]) array([ 1, -11, 9, 11, -10])

Hier gibt das Array die der Gleichung entsprechenden Koeffizienten zurück:

x^{4} - 11 x^{3} + 9 x^{2} + 11 x - 10

$x ^ 4 - 11x ^ 3 + 9x ^ 2 + 11x - 10$ .
Die umgekehrte Operation kann auch ausgeführt werden: Wenn die Liste der Koeffizienten übergeben wird, gibt die Wurzelfunktion alle Wurzeln des Polynoms zurück:

 >>> np.roots([1, 4, -2, 3]) array([-4.57974010+0.j , 0.28987005+0.75566815j, 0.28987005-0.75566815j])

Beachten Sie dies in dieser Gleichung

x^{3} + 4 x^{2} - 2 x + 3

$x ^ 3 + 4x ^ 2 - 2x + 3$ Zwei Wurzeln sind imaginär.
Polynomkoeffizienten können integriert werden. Betrachten wir die Integration

x^{3} + x^{2} + x + 1

$x ^ 3 + x ^ 2 + x + 1$ in

x^{4} / 4 + x^{3} / 3 + x^{2} / 2 + x + C

$x ^ 4/4 + x ^ 3/3 + x ^ 2/2 + x + C$ . Normalerweise ist die Konstante C Null:

 >>> np.polyint([1, 1, 1, 1]) array([ 0.25 , 0.33333333, 0.5 , 1. , 0. ])

Ebenso können Derivate genommen werden:

 >>> np.polyder([1./4., 1./3., 1./2., 1., 0.]) array([ 1., 1., 1., 1.])

Die Funktionen Polyadd, Polysub, Polymul und Polydiv unterstützen auch die Summierung, Subtraktion, Multiplikation und Division von Polynomkoeffizienten.
Die Polyvalfunktion ersetzt den angegebenen Wert durch das Polynom. Betrachten Sie ein Polynom

x^{3} - 2 x^{2} + 2

$x ^ 3 - 2x ^ 2 + 2$ bei x = 4:

 >>> np.polyval([1, -2, 0, 2], 4) 34

Zusammenfassend kann die Polyfit-Funktion verwendet werden, um ein Polynom einer bestimmten Ordnung auf eine Reihe von Werten auszuwählen (zu interpolieren):

 >>> x = [1, 2, 3, 4, 5, 6, 7, 8] >>> y = [0, 2, 1, 3, 7, 10, 11, 19] >>> np.polyfit(x, y, 2) array([ 0.375 , -0.88690476, 1.05357143])

Das zurückgegebene Array ist eine Liste von Polynomkoeffizienten. Anspruchsvollere Interpolationsfunktionen finden Sie in SciPy.

Statistiken

Zusätzlich zu den Funktionen mean, var und std bietet NumPy einige weitere Methoden zum Arbeiten mit Statistiken in Arrays.
Der Median kann wie folgt gefunden werden:

 >>> a = np.array([1, 4, 3, 8, 9, 2, 3], float) >>> np.median(a) 3.0

Der Korrelationskoeffizient für einige Variablen wird mehrmals beobachtet und kann aus Arrays der folgenden Form ermittelt werden: [[x1, x2, ...], [y1, y2, ...], [z1, z2, ...], .. .], wobei x, y, z verschiedene Quantenbeobachtungsgrößen sind und Zahlen die Anzahl der "Beobachtungen" angeben:

 >>> a = np.array([[1, 2, 1, 3], [5, 3, 1, 8]], float) >>> c = np.corrcoef(a) >>> c array([[ 1. , 0.72870505], [ 0.72870505, 1. ]])

Wir haben ein zurückgegebenes Array c [i, j], das den Korrelationskoeffizienten für die i-ten und j-ten Quantenbeobachtungsgrößen speichert.
Ebenso kann der Kovarianzmoment gefunden werden:

 >>> np.cov(a) array([[ 0.91666667, 2.08333333], [ 2.08333333, 8.91666667]])

Zufallszahlen

Ein wichtiger Teil jeder Simulation ist die Fähigkeit, Zufallszahlen zu generieren. Dazu verwenden wir den in NumPy eingebauten Pseudozufallszahlengenerator im Zufalls-Submodul. Zahlen sind pseudozufällig in dem Sinne, dass sie deterministisch aus einer Startnummer erzeugt werden, aber zufällig in statistischen Ähnlichkeiten verteilt sind. Um NumPy zu generieren, wird ein spezieller Algorithmus namens Mersenne Twister verwendet.
Sie können das generierende Element einer Folge von Zufallszahlen wie folgt angeben:

 >>> np.random.seed(293423)

Seed ist eine ganze Zahl. Jedes Programm, das mit demselben Startwert beginnt, generiert jedes Mal dieselbe Zahlenfolge. Dies kann für das Debuggen nützlich sein, aber im Allgemeinen müssen wir den Startwert nicht festlegen. Wenn wir das Programm mehrmals ausführen, möchten wir jedes Mal eine andere Zahlenfolge erhalten. Wenn dieser Befehl nicht ausgeführt wird, wählt NumPy automatisch einen zufälligen Startwert (basierend auf der Zeit) aus, der sich bei jedem Programmstart unterscheidet.
Ein Array von Zufallszahlen aus dem Halbintervall [0.0, 1.0] kann wie folgt erzeugt werden:

 >>> np.random.rand(5) array([ 0.40783762, 0.7550402 , 0.00919317, 0.01713451, 0.95299583])

Die Rand-Funktion kann verwendet werden, um zweidimensionale Arrays zu erzeugen, oder die Umformungsfunktion kann verwendet werden:

 >>> np.random.rand(2,3) array([[ 0.50431753, 0.48272463, 0.45811345], [ 0.18209476, 0.48631022, 0.49590404]]) >>> np.random.rand(6).reshape((2,3)) array([[ 0.72915152, 0.59423848, 0.25644881], [ 0.75965311, 0.52151819, 0.60084796]])

So generieren Sie eine einzelne Zufallszahl für das Intervall [0.0, 1.0]:

 >>> np.random.random() 0.70110427435769551

Verwenden Sie die Randint-Funktion (min, max), um eine zufällige Ganzzahl im Bereich [min, max] zu generieren:

 >>> np.random.randint(5, 10) 9

In jedem unserer Beispiele haben wir Zahlen aus einer kontinuierlichen Gleichverteilung generiert. NumPy enthält auch Generatoren für andere Verteilungen wie Beta, Binomial, Chi-Quadrat, Dirichlet, Exponential, Fischer, Gamma, Geometrie, Gambal, Hypergeometrie, Laplace, Logistik, Lognormal, Logarithmus, Multinomial, Mehrdimensional Normal, Negativ Binomial, Nichtzentral Chi-Quadrat, außermittiger Fischer, Normal (Gauß), Pareto, Poisson, Macht, Rayleigh, Cauchy, Student, Dreieck, Von Mies, Wald, Weibull und Zipf. Schauen wir uns zwei Beispiele an.
Um aus einer diskreten Poisson-Verteilung bei λ = 6,0 zu erzeugen,

 >>> np.random.poisson(6.0) 5

Um eine Zahl aus der Normalverteilung (Gauß) mit einem Durchschnittswert von μ = 1,5 und einer Standardabweichung von σ = 4,0 zu erzeugen:

 >>> np.random.normal(1.5, 4.0) 0.83636555041094318

So erhalten Sie eine Zahl aus der Normalverteilung (μ = 0, σ = 1) ohne Angabe von Argumenten:

 >>> np.random.normal() 0.27548716940682932

Verwenden Sie das Größenargument, um mehrere Werte zu generieren:

 >>> np.random.normal(size=5) array([-1.67215088, 0.65813053, -0.70150614, 0.91452499, 0.71440557])

Das Modul zum Generieren von Zufallszahlen kann auch zum zufälligen Verteilen von Werten in einer Liste verwendet werden. Dies kann nützlich sein, wenn wir Werte in einer Liste zufällig verteilen möchten:

 >>> l = range(10) >>> l [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> np.random.shuffle(l) >>> l [4, 9, 5, 0, 2, 7, 6, 8, 1, 3]

Beachten Sie, dass die Zufallsfunktion ein vorhandenes Array ändert und kein neues zurückgibt.

Einige zusätzliche Informationen

NumPy enthält viele weitere Funktionen, die wir hier nicht erwähnt haben. Dies sind insbesondere Funktionen zum Arbeiten mit der diskreten Fourier-Transformation, komplexere Operationen in der linearen Algebra, Testen von Arrays auf Größe / Dimension / Typ, Aufteilen und Verbinden von Arrays, Histogramme, Erstellen von Arrays aus beliebigen Daten auf unterschiedliche Weise, Erstellen und Betreiben von Grid-Arrays mit speziellen Werten (NaN, Inf), Mengenoperationen, der Erzeugung verschiedener Arten von speziellen Matrizen und der Berechnung spezieller mathematischer Funktionen (zum Beispiel: Bessel-Funktionen). Weitere Informationen finden Sie auch in der NumPy-Dokumentation .

SciPy-Module

SciPy erweitert die Funktionalität von NumPy sehr gut. Wir werden nicht über seine Details sprechen, sondern einige seiner Möglichkeiten betrachten. Die meisten SciPy-Funktionen sind nach dem Import des Moduls verfügbar:

 >>> import scipy

Die Hilfefunktion bietet nützliche Informationen zu SciPy:

>>> help(scipy)
Help on package scipy:

NAME
scipy
FILE
c:\python25\lib\site-packages\scipy\__init__.py
DESCRIPTION
SciPy --- A scientific computing package for Python
===================================================
Documentation is available in the docstrings and
online at http://docs.scipy.org.

Contents
--------
SciPy imports all the functions from the NumPy namespace, and in
addition provides:

Available subpackages
---------------------
odr --- Orthogonal Distance Regression [*]
misc --- Various utilities that don't have
another home.sparse.linalg.eigen.arpack --- Eigenvalue solver using iterative methods. [*]
fftpack --- Discrete Fourier Transform algorithms[*]
io --- Data input and output [*]
sparse.linalg.eigen.lobpcg --- Locally Optimal Block Preconditioned Conjugate Gradient Method (LOBPCG) [*]
special --- Airy Functions [*]
lib.blas --- Wrappers to BLAS library [*]
sparse.linalg.eigen --- Sparse Eigenvalue Solvers [*]
stats --- Statistical Functions [*]
lib --- Python wrappers to external libraries [*]
lib.lapack --- Wrappers to LAPACK library [*]
maxentropy --- Routines for fitting maximum entropymodels [*]
integrate --- Integration routines [*]
ndimage --- n-dimensional image package [*]
linalg --- Linear algebra routines [*]
spatial --- Spatial data structures and algorithms[*]
interpolate --- Interpolation Tools [*]
sparse.linalg --- Sparse Linear Algebra [*]
sparse.linalg.dsolve.umfpack --- :Interface to the UMFPACK library: [*]
sparse.linalg.dsolve --- Linear Solvers [*]
optimize --- Optimization Tools [*]
cluster --- Vector Quantization / Kmeans [*]
signal --- Signal Processing Tools [*]
sparse --- Sparse Matrices [*]
[*] - using a package requires explicit import (see pkgload)
...

Beachten Sie, dass einige Untermodule direkt zusätzlichen Import benötigen, der mit einem Stern gekennzeichnet ist:

 >>> import scipy >>> import scipy.interpolate

Die Funktionen in jedem Modul sind in internen Dokumentenstrings und in der offiziellen Dokumentation gut dokumentiert. Die meisten von ihnen bieten direkt Funktionen für die Arbeit mit numerischen Algorithmen und sind sehr einfach zu bedienen. Somit kann SciPy bei wissenschaftlichen Berechnungen enorm viel Zeit sparen, weil Es bietet bereits geschriebene und getestete Funktionen.
Wir werden SciPy nicht im Detail betrachten, aber die folgende Tabelle wird einige seiner Funktionen behandeln:

Modul	Wofür wird verwendet?
scipy.constants	Satz mathematischer und physikalischer Konstanten
scipy.special	Viele spezielle Funktionen für die mathematische Physik, wie: Luftig, elliptisch, Bessel, Gamma, Beta, hypergeometrischer, parabolischer Zylinder, Mathieu, Kugelwelle, Struve, Kelvin.
scipy.integrate	Funktionen zum Arbeiten mit numerischer Integration unter Verwendung der Methoden von Trapez, Simpson, Romberg und anderen. Bietet auch Methoden zum Arbeiten mit vollständigen Differentialgleichungen.
scipy.optimize	Standard-High / Low-Methoden für die Arbeit mit allgemeinen Benutzerfunktionen. Eingeschlossene Algorithmen: Nelder - Mead, Pull ( Powell's ), konjugierte Gradienten, Bruden - Fletcher - Goldfarb - Channo, kleinste Quadrate, bedingte Optimierung, simuliertes Tempern, vollständige Suche, Brent, Newton, Halbierung, Broyden, Anderson und lineare Suche.
scipy.linalg	Breitere Funktionalität für die Arbeit mit linearer Algebra als in NumPy. Bietet mehr Optionen für die Verwendung spezieller und schneller Funktionen für bestimmte Objekte (z. B. eine Matrix mit drei Diagonalen). Eingeschlossene Methoden: Suche nach einer nicht entarteten Matrix, Suche nach einer Determinante, Lösung linearer Gleichungssysteme, Berechnung von Normen und einer pseudoinversen Matrix, spektrale Zerlegung, singuläre Zerlegung, LU-Zerlegung, Cholesky-Zerlegung, QR-Zerlegung, Schur-Zerlegung und viele andere mathematische Operationen zum Arbeiten mit Matrizen.
scipy.sparse	Funktionen zum Arbeiten mit großen, spärlichen Matrizen
scipy.interpolate	Methoden und Klassen zum Interpolieren von Objekten, die für diskrete numerische Daten verwendet werden können. Für ein- und zweidimensionale Datensätze ist eine lineare und eine Spline-Interpolation ( Hinweisübersetzer: mathematische Darstellung glatter Kurven ) verfügbar.
scipy.fftpack	Methoden zur Verarbeitung von Fourier-Transformationen.
scipy.signal	Verfahren zur Verarbeitung von Signalen, zum Beispiel: Funktionsfaltung, Korrelation, diskrete Fourier-Transformation, B-Spline-Glättung, Filterung usw. usw.
scipy.stats	Eine große Bibliothek statistischer Funktionen und Verteilungen für die Arbeit mit Datensätzen.

Eine große Gruppe von Entwicklern entwickelt kontinuierlich neue SciPy-Funktionen. Ein guter praktischer Ansatz ist folgender: Wenn Sie numerische Funktionen und Methoden in Ihren Code implementieren möchten, können Sie sich zunächst die Originaldokumentation von SciPy ansehen. Es besteht die Möglichkeit, dass jemand SciPy bereits implementiert und dazu beigetragen hat.

Nachwort

Unsere Artikelserie ist zu Ende gegangen. Vielen Dank an alle, die gelesen und sich die Zeit genommen haben. Ich hoffe auch, dass Sie einige nützliche Informationen herausgebracht und etwas Neues gelernt haben. Entwickle und lerne weiter! Bis bald.

NumPy in Python. Teil 4