`numpy` — numpy-kompatible Array-Operationen#

Das Submodul numpy von ulab stellt eine numpy-kompatible API bereit, die um den n-dimensionalen Array-Typ ndarray herum aufgebaut ist. Es implementiert eine ausgewählte Teilmenge von CPython numpy: Array-Konstruktion, elementweise Mathematik, Reduktionen und Statistik, lineare Algebra, FFTs, Erzeugung von Zufallszahlen, Polynomanpassung und grundlegende Ein-/Ausgabe.

Das Submodul wird üblicherweise als np importiert:

from ulab import numpy as np

a = np.array([1, 2, 3, 4], dtype=np.float)
b = np.linspace(0, 1, num=5)
c = np.dot(a.reshape((2, 2)), a.reshape((2, 2)))

Jedes dtype-Argument ist eine der auf Modulebene bereitgestellten Integer-Konstanten: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 und numpy.float (Standard). Der Ergebnistyp ndarray verweist auf numpy.ndarray.

Submodule#

Klasse `ndarray` — das n-dimensionale Array#

Das ndarray ist der n-dimensionale, dtype-bewusste Container im Kern von numpy / ulab. Die Daten werden in einem zusammenhängenden Block gespeichert, dessen Interpretation durch einen kleinen Header (dtype, shape, strides, ndim, itemsize) beschrieben wird. Viele Operationen – reshape, transpose, Slicing – passen nur diesen Header an und sind daher sehr günstig; Methoden, die neuen Speicher belegen (copy, flatten, die meisten arithmetischen Operationen), geben ein neues dichtes Array zurück.

Derselbe Typ ist als ulab.ndarray, numpy.ndarray und (innerhalb dieser Seite) einfach als ndarray erreichbar.

class numpy.ndarray(values: ndarray | bytes | list | tuple, *, dtype: int = numpy.float)#

Erzeugt ein neues ndarray.

Parameter:

values – Quelldaten. Entweder ein anderes ndarray (das tief kopiert wird, mit Typkonvertierung, falls sich dtype unterscheidet) oder ein beliebiges iterierbares MicroPython-Objekt. Verschachtelte iterierbare Objekte erzeugen mehrdimensionale Arrays; die inneren iterierbaren Objekte müssen alle dieselbe Länge haben, andernfalls wird ein ValueError ausgelöst.
dtype – Elementtyp für das neue Array. Eines der Typcodeintegers, die von numpy bereitgestellt werden (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 und numpy.float), oder eine dtype-Instanz. Standardmäßig numpy.float.

Die Fabrikfunktion numpy.array ist die übliche Methode, um ein ndarray zu erzeugen; sie leitet an diesen Konstruktor weiter.

byteswap(*, inplace: bool = False) → ndarray#

Vertauscht die Byte-Reihenfolge jedes Elements. Bei uint16-, int16- und float-Arrays kehrt dies die Byte-Reihenfolge jedes Elements um, was nützlich ist, wenn Daten von Peripheriegeräten verarbeitet werden, deren Byte-Reihenfolge nicht mit der des Mikrocontrollers übereinstimmt. Bei Einzelbyte-Datentypen (bool, uint8, int8) ist dies ein No-Op, der eine Ansicht oder Kopie zurückgibt.

Wenn inplace gleich False ist (Standard), wird ein neues ndarray zurückgegeben und das Original bleibt unverändert. Wenn inplace gleich True ist, werden die Bytes von self an Ort und Stelle vertauscht und eine Ansicht von self zurückgegeben.

copy() → ndarray#: Gibt eine neue dichte, tiefe Kopie des Arrays zurück. Die Kopie besitzt ihre eigenen Daten; Änderungen daran wirken sich nicht auf das Original aus.

flatten(*, order: str = 'C') → ndarray#

Gibt eine neue eindimensionale Kopie des Arrays zurück.

Parameter:: order – 'C' (Standard) durchläuft die Daten in C-Reihenfolge (letzte Achse variiert am schnellsten); 'F' durchläuft sie in Fortran-Reihenfolge (erste Achse variiert am schnellsten).

reshape(shape: int | tuple[int, ...]) → ndarray#: Gibt eine Ansicht des Arrays mit einer neuen Form zurück. Die Gesamtzahl der Elemente muss unverändert bleiben, andernfalls wird ein ValueError ausgelöst. Nur verfügbar, wenn ULAB_MAX_DIMS > 1. Entspricht der Zuweisung an shape.

sort(*, axis: int | None = -1) → None#

Sortiert das Array an Ort und Stelle.

Parameter:: axis – Achse, entlang der sortiert wird. -1 (Standard) sortiert entlang der letzten Achse; None flacht das Array zunächst ab und sortiert es dann.

tobytes() → bytearray#: Gibt ein bytearray zurück, das den zugrunde liegenden Datenpuffer des Arrays referenziert. Schreibvorgänge über das zurückgegebene bytearray ändern das Array an Ort und Stelle. Löst ValueError aus, wenn das Array nicht dicht ist (z. B. eine gesliced Ansicht).

tolist() → list#: Gibt den Inhalt des Arrays als (möglicherweise verschachtelte) Python-list zurück. Die Verschachtelungstiefe entspricht ndim.

transpose() → ndarray#: Gibt die Transponierte des Arrays zurück (umgekehrte Achsen). Für eindimensionale Arrays wird self zurückgegeben. Nur verfügbar, wenn ULAB_MAX_DIMS > 1. Das Attribut T ist eine Kurzform für diese Methode.

dtype: dtype | int#: Der Datentyp der Array-Elemente. Gibt eine dtype-Instanz zurück, wenn die Firmware mit aktiviertem ULAB_HAS_DTYPE_OBJECT erstellt wurde, andernfalls den zugrunde liegenden Ein-Zeichen-Typ-Code als Ganzzahl.

flat: flatiter#: Ein flacher Iterator, der jedes Element des Arrays in C-Reihenfolge liefert. Anders als flatten() belegt das Iterieren über flat kein neues Array.

itemsize: int#: Größe eines einzelnen Array-Elements in Bytes, abgeleitet aus dtype.

ndim: int#: Anzahl der Array-Dimensionen (Länge von shape).

shape: tuple[int, ...]#: Längen des Arrays entlang jeder Achse. Die Zuweisung eines Tupels an shape ändert die Form des Arrays an Ort und Stelle (entspricht reshape()).

size: int#: Gesamtzahl der Elemente im Array (das Produkt von shape).

strides: tuple[int, ...]#: Anzahl der Bytes, die im Speicher entlang jeder Achse zu durchlaufen sind, um das nächste Element entlang dieser Achse zu erreichen.

T: ndarray#: Die Transponierte des Arrays; entspricht transpose().

Unterstützte Operatoren#

Instanzen von ndarray unterstützen die folgenden Operatoren. Binäre Operatoren übertragen ihre Operanden gemäß den Standard-Broadcasting-Regeln von numpy und befolgen die Upcasting-Regeln von numpy (z. B. uint8 + int8 => int16, uint16 + int16 => float).

Arithmetik (binär): +, -, *, /, //, %, **. Reflektierte (rechtsseitige) Operanden und die In-Place-Varianten +=, -=, *=, /=, %=, **= werden ebenfalls unterstützt. Sowohl die Form ndarray-mit-ndarray als auch ndarray-mit-Skalar werden akzeptiert.

Vergleich: ==, !=, <, <=, >, >=. Jeder gibt ein boolesches ndarray der Broadcast-Form zurück.

Bitweise (nur Integer-Arrays): &, |, ^. Diese auf ein float-Array anzuwenden wirft TypeError.

Unär: + (gibt eine Kopie zurück), - (Negation; bei vorzeichenlosen dtypes wickeln sich die Werte modulo \(2^N\) um), abs() (elementweiser Absolutwert; bei vorzeichenlosen dtypes wird ohne Berechnung eine Kopie zurückgegeben), ~ (bitweise Inversion, nur Ganzzahl-dtypes), len() (gibt die Länge der ersten Achse zurück).

Indizierung und Slicing: a[i], a[i, j, ...], a[start:stop:step], boolesche Maskenindizierung (a[mask]) und Ganzzahl-Array-Indizierung (Fancy Indexing) werden alle sowohl beim Lesen als auch beim Schreiben unterstützt.

Iteration: Das Iterieren über ein ndarray liefert Teil-Arrays entlang der ersten Achse (bei 1-D-Arrays jeweils ein Element). Verwenden Sie flat, um unabhängig von der Dimensionalität über jedes skalare Element zu iterieren.

Der Matrixmultiplikationsoperator @ ist nicht implementiert; verwenden Sie stattdessen numpy.dot (np.dot(a, b)).

Die Verschiebungsoperatoren (<<, >>) sind nicht auf Operatorebene implementiert. Verwenden Sie numpy.left_shift und numpy.right_shift für elementweise Ganzzahlverschiebungen.

Array-Konstruktion#

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray#: Konstruiert ein neues ndarray aus einem verschachtelten iterierbaren Objekt von Zahlen. Entspricht dem alternativen Konstruktor für numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray#: Gibt gleichmäßig beabstandete Werte über das halboffene Intervall [start, stop) zurück. Wenn nur ein Positionsargument angegeben wird, wird es als stop mit start = 0 behandelt. Wenn dtype weggelassen wird, wird es aus den Eingaben abgeleitet (Ganzzahl, falls start, stop und step alle Ganzzahlen und im Bereich sind).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray#: Wenn a bereits ein ndarray ist, dessen dtype mit dtype übereinstimmt (oder dtype gleich None ist), wird a unverändert zurückgegeben; andernfalls wird ein neues Array erzeugt (mit der angeforderten dtype-Konvertierung, sofern angegeben). Iterierbare Objekte werden wie in numpy.array konvertiert.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray#: Verbindet eine Sequenz von ndarray entlang einer vorhandenen Achse axis. Alle Eingabe-Arrays müssen denselben dtype, dieselbe ndim und auf jeder Achse außer axis dieselbe Form besitzen.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray#: Für ein 2-D-a wird ein 1-D-Array zurückgegeben, das die k-te Diagonale enthält. Für ein 1-D-a wird ein 2-D-Quadratarray zurückgegeben, in dem a auf der k-ten Diagonale platziert ist. k kann positiv (oberhalb der Hauptdiagonale) oder negativ (unterhalb) sein.

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Alias für zeros; gibt ein mit Nullen gefülltes Array der Form shape und des Typs dtype zurück. (ulab lässt den Puffer nicht uninitialisiert.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray#: Gibt ein 2-D-N x M-Array zurück (quadratisch N x N, falls M gleich None ist) mit Einsen auf der k-ten Diagonale und Nullen andernorts.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray#: Interpretiert ein Buffer-Protokoll-Objekt als 1-D-ndarray vom Typ dtype. count ist die Anzahl der zu lesenden Elemente (-1 liest alle verfügbaren Elemente); offset überspringt so viele Bytes am Anfang des Puffers.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray#: Gibt ein neues Array der Form shape und des Typs dtype zurück, bei dem jedes Element auf fill_value gesetzt ist.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]#: Gibt num gleichmäßig verteilte Stichproben über das geschlossene Intervall [start, stop] zurück (oder halboffenes Intervall, wenn endpoint False ist). Wenn retstep True ist, wird ein Tupel (samples, step) zurückgegeben.

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray#: Gibt num gleichmäßig auf einer logarithmischen Skala beabstandete Stichproben zurück: Das Ergebnis beginnt bei base ** start und endet bei base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]#: Gibt ein Tupel von Koordinatenmatrizen aus einer Sequenz eindimensionaler Koordinaten-Arrays zurück. Mit indexing 'xy' (Standard) werden die ersten beiden Eingaben als kartesische Koordinaten behandelt und ihre Ausgabeachsen vertauscht; mit 'ij' wird Matrix-Indizierung verwendet. Die Implementierung entspricht dem NumPy-Äquivalent mit copy=True und sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Gibt ein neues Array der Form shape und des Typs dtype gefüllt mit Einsen zurück.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Gibt ein neues Array der Form shape und des Typs dtype gefüllt mit Nullen zurück.

Inspektion / Ausgabe#

numpy.get_printoptions() → dict#: Gibt die aktuellen Array-Ausgabeoptionen als Dict mit den Schlüsseln threshold und edgeitems zurück.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None#: Legt die Array-Ausgabeoptionen fest. threshold ist die maximale Anzahl von Array-Elementen, die vollständig ausgegeben werden; edgeitems ist die Anzahl der Elemente, die an jedem Ende einer Achse angezeigt werden, wenn das Array zusammengefasst wird.

numpy.ndinfo(array: ndarray) → None#: Gibt Diagnoseinformationen (shape, strides, dtype, itemsize, …) über array aus.

numpy.size(a: ndarray, *, axis: int | None = None) → int#: Gibt die Anzahl der Elemente von a entlang axis zurück; wenn axis gleich None ist, wird die Gesamtzahl der Elemente zurückgegeben (das Produkt von ndarray.shape).

Vergleich#

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float#: Begrenzt die Werte von a, sodass a_min <= result <= a_max. Entspricht maximum(a_min, minimum(a, a_max)); das Broadcasting folgt denselben Regeln wie minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool#: Elementweises x1 == x2; gibt ein boolesches ndarray zurück (oder einen bool-Skalar, falls beide Eingaben Skalare sind). Zur Portabilität bereitgestellt – der ==-Operator auf Arrays liefert dasselbe Ergebnis.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool#: Elementweises x1 != x2; das boolesche Gegenstück zu equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool#: Gibt ein boolesches Array (oder einen Skalar) zurück, das/der True ist, wo die Eingabe endlich ist. Ganzzahlige Eingaben sind immer endlich.

numpy.isinf(x: ndarray | int | float) → ndarray | bool#: Gibt ein boolesches Array (oder einen Skalar) zurück, das/der True ist, wo die Eingabe unendlich ist. Ganzzahlige Eingaben sind nie unendlich.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: Elementweises Maximum zweier Arrays / Skalare. Die Argumente werden zusammen gebroadcastet; falls sich die dtypes unterscheiden, wird die Ausgabe aufwärtskonvertiert.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: Elementweises Minimum zweier Arrays / Skalare; Gegenstück zu maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]#: Gibt ein Tupel von ndarray zurück, eines pro Dimension von a, das die Indizes der von null verschiedenen Elemente von a enthält.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray#: Gibt ein ndarray zurück, dessen Elemente aus x stammen, wo condition wahr ist, und aus y andernfalls. Die drei Eingaben werden zusammen gebroadcastet; der Ausgabe-dtype ist die Aufwärtskonvertierung von x und y.

Numerische Reduktionen#

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool#: Prüft, ob alle Elemente entlang axis zu True ausgewertet werden. Mit axis=None (Standard) wird das abgeflachte Array getestet und ein einzelner bool zurückgegeben.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool#: Prüft, ob irgendein Element entlang axis zu True ausgewertet wird. Mit axis=None wird das abgeflachte Array getestet.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int#: Gibt den Index des größten Elements entlang axis zurück. Mit axis=None wird das Array abgeflacht und eine einzelne Ganzzahl zurückgegeben.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int#: Gibt den Index des kleinsten Elements entlang axis zurück. Mit axis=None wird das Array abgeflacht und eine einzelne Ganzzahl zurückgegeben.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray#: Gibt ein vorzeichenloses Ganzzahl-Index-ndarray zurück, dessen Einträge a in aufsteigender Reihenfolge entlang axis sortieren. Der Ausgabe-dtype ist uint16, daher darf keine Achse 65535 Elemente überschreiten. axis=None wird nicht unterstützt.

numpy.cross(a: ndarray, b: ndarray) → ndarray#: Gibt das Kreuzprodukt zweier 1-D-Arrays der Länge 3 zurück.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray#: Gibt die n-te diskrete Vorwärtsdifferenz von a entlang axis zurück. n muss im Bereich 0..9 liegen (die Differenzierungsschablone wird in einem int8 gespeichert); die Länge von axis schrumpft um n. Die numpy-Schlüsselwörter prepend und append sind nicht implementiert.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray#: Gibt ein neues Array zurück, in dem die Reihenfolge der Elemente entlang axis umgekehrt ist; mit axis=None wird das Array entlang jeder Achse umgekehrt.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Gibt das größte Element entlang axis zurück. Mit axis=None (Standard) wird das abgeflachte Array auf einen Skalar reduziert. Das numpy-Schlüsselwort out ist nicht implementiert.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Gibt das kleinste Element entlang axis zurück; Gegenstück zu max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float#: Gibt das arithmetische Mittel entlang axis zurück. Mit axis=None (Standard) wird das Mittel des abgeflachten Arrays als float zurückgegeben.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float#: Gibt den Median entlang axis zurück. Mit axis=None wird das Array zuerst abgeflacht. Der Ausgabe-dtype ist immer float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray#: Gibt a zurück, wobei seine Elemente um shift Positionen gerollt (zyklisch verschoben) werden. Mit axis=None (Standard) wird das Array zuerst abgeflacht. Negative Verschiebungen rollen in die entgegengesetzte Richtung.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray#: Gibt eine sortierte Kopie von a entlang axis unter Verwendung von Heap-Sort zurück. Mit axis=None wird das Array zuerst abgeflacht. Die numpy-Schlüsselwörter kind und order sind nicht implementiert.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float#: Gibt die Standardabweichung entlang axis zurück. ddof ist der Delta-Freiheitsgrad – der verwendete Divisor ist N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Gibt die Summe entlang axis zurück. Mit axis=None wird die Gesamtsumme des abgeflachten Arrays als Skalar zurückgegeben.

Statistik#

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray#: Zählt die Anzahl der Vorkommen jedes Werts im eindimensionalen, nicht-negativen Ganzzahl-Array x. Der dtype von x muss uint8 oder uint16 sein. Wenn weights angegeben ist, trägt jeder Eintrag von x sein passendes Gewicht bei statt 1, und die Ausgabe ist vom dtype float; andernfalls ist die Ausgabe vom dtype uint16. Wenn minlength angegeben ist, hat das Ausgabe-Array mindestens so viele Elemente (zusätzliche Einträge sind null).

numpy.trace(m: ndarray) → int | float#: Gibt die Summe der Diagonalelemente der quadratischen Matrix m zurück. Der Rückgabetyp folgt dem dtype von m (Ganzzahl-Arrays erzeugen eine Ganzzahl, float-Arrays einen float).

Transformation#

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray#: Gibt Ausschnitte von a zurück, die entlang axis durch die boolesche condition ausgewählt werden. Mit axis=None wird das abgeflachte Array verwendet.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray#: Gibt eine Kopie von a zurück, bei der die Einträge an indices entlang axis entfernt sind. Mit axis=None wird das Array zuerst abgeflacht. Negative Indizes zählen vom Ende von axis; indices wird vor dem Löschen intern sortiert.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float#: Gibt das Skalarprodukt zweier Arrays zurück. Für zwei 1-D-Arrays ist dies das innere Produkt (ein float-Skalar). Für 2-D-Arrays ist dies die Matrixmultiplikation; die inneren Dimensionen müssen übereinstimmen. Das Ergebnis ist immer vom dtype float.

Approximation#

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray#: Eindimensionale lineare Interpolation. xp muss ein monoton steigendes 1-D-Array unabhängiger Werte sein; fp enthält die entsprechenden abhängigen Werte; x sind die Punkte, an denen der Interpolant ausgewertet wird. left und right überschreiben den zurückgegebenen Wert für x < xp[0] bzw. x > xp[-1] (Standardwerte: fp[0] und fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float#: Integriert y mit der zusammengesetzten Trapezregel. Wenn x angegeben ist, liefert es die Stichprobenpositionen, die zu y gehören; andernfalls wird der Abstand dx verwendet. y (und x) müssen 1-D sein.

Auswahl#

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray#: Entnimmt Elemente aus a an den angegebenen indices entlang axis. Mit axis=None wird das abgeflachte Array verwendet. mode wählt das Verhalten außerhalb der Grenzen: "raise" (Standard – löst ValueError aus), "wrap" (modulo der Achsenlänge) oder "clip" (auf den gültigen Bereich begrenzen; negative Indizes sind nicht erlaubt). Wenn out angegeben ist, wird das Ergebnis dort hineingeschrieben.

Bitweise#

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray#: Elementweises bitweises UND zweier Ganzzahl-Arrays; Broadcasting wird unterstützt. Ein nicht-ganzzahliger dtype löst eine Ausnahme aus.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray#: Elementweises bitweises ODER zweier Ganzzahl-Arrays.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray#: Elementweises bitweises XOR zweier Ganzzahl-Arrays.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray#: Elementweise bitweise Verschiebung von x1 um x2 Bits nach links; beide Arrays müssen einen Ganzzahl-dtype haben.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray#: Elementweise bitweise Verschiebung von x1 um x2 Bits nach rechts; beide Arrays müssen einen Ganzzahl-dtype haben.

Filterung#

numpy.convolve(a: ndarray, v: ndarray) → ndarray#: Gibt die diskrete lineare Faltung zweier 1-D-Arrays zurück. Es wird nur der Modus "full" unterstützt; das numpy-Schlüsselwort mode wird nicht akzeptiert (andere Modi lassen sich durch Slicing des vollständigen Ergebnisses erhalten). Die Ausgabelänge beträgt len(a) + len(v) - 1.

Polynom#

numpy.polyfit(x: ndarray | list | tuple, y: ndarray | list | tuple, deg: int) → ndarray#

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Passt ein Polynom vom Grad deg mittels kleinster Quadrate an die Datenpunkte (x, y) an und gibt die Polynomkoeffizienten zurück (höchster Grad zuerst). Wenn x weggelassen wird, wird range(len(y)) verwendet. Löst ValueError aus, wenn sich die Längen von x und y unterscheiden.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float#: Wertet das Polynom mit den Koeffizienten p (höchster Grad zuerst) an der Stelle x aus. Wenn x ein Skalar ist, wird ein float zurückgegeben, andernfalls ein ndarray.

Ein-/Ausgabe#

numpy.load(file: str) → ndarray#: Liest ein zuvor mit save geschriebenes Array aus file (numpys plattformunabhängiges .npy-Format). Die Endianness wird zur Laufzeit konvertiert, wenn die Byte-Reihenfolge der Datei von der des Hosts abweicht.

numpy.loadtxt(file: str, *, delimiter: str | None = None, comments: str = '#', max_rows: int = -1, usecols: int | ndarray | list | tuple | None = None, dtype: int = float, skiprows: int = 0) → ndarray#: Liest numerische Daten aus einer Text-file und gibt sie als ndarray zurück. delimiter ist standardmäßig Leerraum; comments ist der Zeilenkommentar-Marker; max_rows begrenzt die Anzahl der gelesenen Datenzeilen (-1 für alle); usecols wählt Spalten per Index; skiprows überspringt so viele führende Zeilen. Wenn dtype nicht float ist, werden Werte durch Runden konvertiert.

numpy.save(file: str, a: ndarray) → None#: Speichert a in file in numpys plattformunabhängigem .npy-Format.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None#: Schreibt a als Text in file. delimiter trennt Werte innerhalb einer Zeile; header und footer werden, falls angegeben, vor/nach den Daten geschrieben, jeweils mit comments präfixiert. Werte werden als Gleitkommazahlen geschrieben.

Universelle Funktionen#

Elementweise mathematische Funktionen. Jede akzeptiert einen Skalar oder ein ndarray und gibt ein Ergebnis passender Form zurück (einen float-Skalar bei skalarer Eingabe, ein ndarray bei Array-Eingabe). Beim Aufruf mit einem ndarray ist das Ergebnis ein neues Gleitkomma-ndarray; ein optionales out-Schlüsselwort kann übergeben werden, um das Ergebnis in ein vorab belegtes float-ndarray derselben Größe zu schreiben.

numpy.acos(x: ndarray | float, /) → ndarray | float#: Berechnet den Arkuskosinus (inverser Kosinus) jedes Elements von x; das Ergebnis ist in Radiant.

numpy.acosh(x: ndarray | float, /) → ndarray | float#: Berechnet den inversen hyperbolischen Kosinus jedes Elements von x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float#: Berechnet elementweise den Arkustangens mit zwei Argumenten atan2(y, x); unterstützt Broadcasting zwischen den beiden Eingaben.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray#: Rundet die Elemente des ndarray x auf die angegebene Anzahl von decimals; das erste Argument muss ein ndarray sein.

numpy.asin(x: ndarray | float, /) → ndarray | float#: Berechnet den Arkussinus (inverser Sinus) jedes Elements von x; das Ergebnis ist in Radiant.

numpy.asinh(x: ndarray | float, /) → ndarray | float#: Berechnet den inversen hyperbolischen Sinus jedes Elements von x.

numpy.atan(x: ndarray | float, /) → ndarray | float#: Berechnet den Arkustangens (inverser Tangens) jedes Elements von x; das Ergebnis ist in Radiant.

numpy.atanh(x: ndarray | float, /) → ndarray | float#: Berechnet den inversen hyperbolischen Tangens jedes Elements von x.

numpy.ceil(x: ndarray | float, /) → ndarray | float#: Berechnet die Aufrundung (kleinste Ganzzahl, die nicht kleiner als der Wert ist) jedes Elements von x.

numpy.cos(x: ndarray | float, /) → ndarray | float#: Berechnet den Kosinus jedes Elements von x (in Radiant).

numpy.cosh(x: ndarray | float, /) → ndarray | float#: Berechnet den hyperbolischen Kosinus jedes Elements von x.

numpy.degrees(x: ndarray | float, /) → ndarray | float#: Konvertiert jedes Element von x von Radiant in Grad.

numpy.exp(x: ndarray | float, /) → ndarray | float#: Berechnet die Exponentialfunktion e**x jedes Elements von x.

numpy.expm1(x: ndarray | float, /) → ndarray | float#: Berechnet exp(x) - 1 jedes Elements von x mit verbesserter Genauigkeit nahe null.

numpy.floor(x: ndarray | float, /) → ndarray | float#: Berechnet die Abrundung (größte Ganzzahl, die nicht größer als der Wert ist) jedes Elements von x.

numpy.log(x: ndarray | float, /) → ndarray | float#: Berechnet den natürlichen Logarithmus jedes Elements von x.

numpy.log10(x: ndarray | float, /) → ndarray | float#: Berechnet den Logarithmus zur Basis 10 jedes Elements von x.

numpy.log2(x: ndarray | float, /) → ndarray | float#: Berechnet den Logarithmus zur Basis 2 jedes Elements von x.

numpy.radians(x: ndarray | float, /) → ndarray | float#: Konvertiert jedes Element von x von Grad in Radiant.

numpy.sin(x: ndarray | float, /) → ndarray | float#: Berechnet den Sinus jedes Elements von x (in Radiant).

numpy.sinc(x: ndarray | float, /) → ndarray | float#: Berechnet die normalisierte sinc-Funktion sin(pi*x) / (pi*x) jedes Elements von x.

numpy.sinh(x: ndarray | float, /) → ndarray | float#: Berechnet den hyperbolischen Sinus jedes Elements von x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float#: Berechnet die Quadratwurzel jedes Elements von x.

numpy.tan(x: ndarray | float, /) → ndarray | float#: Berechnet den Tangens jedes Elements von x (in Radiant).

numpy.tanh(x: ndarray | float, /) → ndarray | float#: Berechnet den hyperbolischen Tangens jedes Elements von x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable#: Gibt ein aufrufbares Objekt zurück, das die Python-Funktion f elementweise auf einen Skalar, ein iterierbares Objekt oder ein ndarray anwendet; otypes wählt den Ausgabe-dtype (Standard float).

Konstanten#

numpy.e: float#: Eulersche Zahl \(e \approx 2.71828\).

numpy.pi: float#: \(\pi \approx 3.14159\).

numpy.inf: float#: IEEE-754-Gleitkomma-positiv-Unendlich.

numpy.nan: float#: IEEE-754-Gleitkomma-„not a number“.

numpy.bool: int#: Dtype-Code für boolesche Arrays (gespeichert als uint8).

numpy.uint8: int#: Dtype-Code für vorzeichenlose 8-Bit-Ganzzahl-Arrays.

numpy.int8: int#: Dtype-Code für vorzeichenbehaftete 8-Bit-Ganzzahl-Arrays.

numpy.uint16: int#: Dtype-Code für vorzeichenlose 16-Bit-Ganzzahl-Arrays.

numpy.int16: int#: Dtype-Code für vorzeichenbehaftete 16-Bit-Ganzzahl-Arrays.

numpy.float: int#: Dtype-Code für 32-Bit-Gleitkomma-Arrays.

numpy — numpy-kompatible Array-Operationen#