`numpy` — numpy-kompatibilis tömbműveletek¶

A ulab numpy almodulja egy numpy-kompatibilis API-t biztosít, amely az ndarray n-dimenziós tömbtípus köré épül. A CPython numpy egy gondosan válogatott részhalmazát valósítja meg: tömbkonstrukció, elemenkénti matematika, redukciók és statisztika, lineáris algebra, FFT-k, véletlenszám-generálás, polinomillesztés és alapvető I/O.

Az almodult hagyományosan np néven importáljuk:

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)))

Minden dtype argumentum a modul szintjén elérhető egész konstansok egyike: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 és numpy.float (az alapértelmezett). Az ndarray eredménytípus a numpy.ndarray-re utal.

Almodulok¶

`ndarray` osztály — az n-dimenziós tömb¶

Az ndarray az n-dimenziós, dtype-tudatos tároló, amely a numpy / ulab magját képezi. Az adatok egy összefüggő blokkban tárolódnak, amelynek értelmezését egy kis fejléc írja le (dtype, shape, strides, ndim, itemsize). Sok művelet – reshape, transpose, szeletelés – csak ezt a fejlécet módosítja, ezért nagyon olcsó; az új tárterületet allokáló metódusok (copy, flatten, a legtöbb aritmetikai művelet) új, sűrű tömböt adnak vissza.

Ugyanez a típus elérhető ulab.ndarray, numpy.ndarray néven, és (ezen az oldalon) egyszerűen ndarray néven is.

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

Új ndarray létrehozása.

Paraméterek:

values – Forrásadat. Vagy egy másik ndarray (amely mély másolatként készül, típuskonverzióval, ha a dtype eltér), vagy bármilyen MicroPython iterálható objektum. A beágyazott iterálható objektumok többdimenziós tömböket hoznak létre; a belső iterálható objektumoknak mind azonos hosszúságúnak kell lenniük, különben ValueError keletkezik.
dtype – Az új tömb elemeinek típusa. A numpy által közzétett típuskód-egészek egyike (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 és numpy.float), vagy egy dtype példány. Alapértelmezett: numpy.float.

A numpy.array gyári függvény a hagyományos módja egy ndarray létrehozásának; ez továbbítja a hívást ennek a konstruktornak.

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

Felcseréli minden elem byte-sorrendjét. A uint16, int16 és float tömbök esetén ez megfordítja az egyes elemek byte-sorrendjét, ami hasznos, ha olyan perifériákból kell adatot feldolgozni, amelyek byte-sorrendje nem egyezik a mikrokontrollerével. Egybájtos típusok esetén (bool, uint8, int8) ez egy no-op, amely nézetet vagy másolatot ad vissza.

Ha az inplace értéke False (az alapértelmezett), egy új ndarray kerül visszaadásra, és az eredeti érintetlen marad. Ha az inplace értéke True, a self bájtjai helyben cserélődnek fel, és a self egy nézete kerül visszaadásra.

copy() → ndarray¶: Visszaad egy új, sűrű, mély másolatot a tömbről. A másolat saját adatait birtokolja; annak módosításai nem érintik az eredetit.

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

Visszaad egy új, egydimenziós másolatot a tömbről.

Paraméterek:: order – A 'C' (az alapértelmezett) C sorrendben járja be az adatokat (az utolsó tengely változik a leggyorsabban); az 'F' Fortran sorrendben járja be (az első tengely változik a leggyorsabban).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Visszaad egy új alakú nézetet a tömbről. Az elemek teljes számának változatlannak kell maradnia, különben ValueError keletkezik. Csak akkor érhető el, ha ULAB_MAX_DIMS > 1. Egyenértékű a shape értékének beállításával.

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

A tömb helyben történő rendezése.

Paraméterek:: axis – A tengely, amely mentén a rendezés történik. A -1 (az alapértelmezett) az utolsó tengely mentén rendez; a None először kilapítja a tömböt, majd rendez.

tobytes() → bytearray¶: Visszaad egy bytearray-t, amely a tömb mögöttes adatpufferét aliasolja. A visszaadott bytearray-en keresztüli írások helyben módosítják a tömböt. ValueError-t vált ki, ha a tömb nem sűrű (pl. egy szeletelt nézet).

tolist() → list¶: Visszaadja a tömb tartalmát egy (esetleg beágyazott) Python list-ként. A beágyazás mélysége megegyezik a ndim értékkel.

transpose() → ndarray¶: Visszaadja a tömb transzponáltját (a tengelyek megfordítva). Egydimenziós tömböknél ez a self-et adja vissza. Csak akkor érhető el, ha ULAB_MAX_DIMS > 1. A T attribútum ennek a metódusnak a rövidítése.

dtype: dtype | int¶: A tömb elemeinek adattípusa. Egy dtype példányt ad vissza, ha a firmware ULAB_HAS_DTYPE_OBJECT engedélyezésével lett építve, egyébként a mögöttes egykarakteres típuskódot egész számként.

flat: flatiter¶: Egy lapos iterátor, amely C sorrendben adja vissza a tömb minden elemét. A flatten()-nel ellentétben a flat bejárása nem allokál új tömböt.

itemsize: int¶: Egyetlen tömbelem mérete bájtban, a dtype-ból származtatva.

ndim: int¶: A tömb dimenzióinak száma (a shape hossza).

shape: tuple[int, ...]¶: A tömb hosszai az egyes tengelyek mentén. Egy tuple hozzárendelése a shape-hez helyben átalakítja a tömb alakját (egyenértékű a reshape()-pel).

size: int¶: A tömb elemeinek teljes száma (a shape szorzata).

strides: tuple[int, ...]¶: A memóriában megteendő bájtok száma az egyes tengelyek mentén, hogy elérjük a következő elemet az adott tengely mentén.

T: ndarray¶: A tömb transzponáltja; egyenértékű a transpose()-szal.

Támogatott operátorok¶

Az ndarray példányok a következő operátorokat támogatják. A bináris operátorok operandusaikat a numpy szokásos sugárzási szabályai szerint terjesztik, és követik a numpy típusbővítési szabályait (pl. uint8 + int8 => int16, uint16 + int16 => float).

Aritmetika (bináris): +, -, *, /, //, %, **. A tükrözött (jobb oldali) operandusok és a helyi változók +=, -=, *=, /=, %=, **= szintén támogatottak. Mind az ndarray-ndarray, mind az ndarray-skaláris formák elfogadottak.

Összehasonlítás: ==, !=, <, <=, >, >=. Mindegyik egy boolean ndarray-t ad vissza a broadcast alakkal.

Bitenkénti (csak egész tömbök): &, |, ^. Ezek alkalmazása float tömbre TypeError-t vált ki.

Unáris: + (másolatot ad vissza), - (negálás; előjel nélküli dtype-okon az értékek \(2^N\) modulo szerint körbefordulnak), abs() (elemenkénti abszolút érték; előjel nélküli dtype-okon számítás nélkül másolatot ad vissza), ~ (bitenkénti invertálás, csak egész dtype-okon), len() (az első tengely hosszát adja vissza).

Indexelés és szeletelés: a[i], a[i, j, ...], a[start:stop:step], boolean-maszkos indexelés (a[mask]) és egész-tömbös (fancy) indexelés egyaránt támogatott olvasáskor és íráskor is.

Iteráció: Egy ndarray bejárása az első tengely mentén adja vissza az altömböket (1-D tömböknél egyszerre egy elemet). A flat segítségével iterálhatsz minden skalár elemen, a dimenzionalitástól függetlenül.

A mátrixszorzás operátora (@) nincs megvalósítva; helyette használd a numpy.dot-ot (np.dot(a, b)).

A léptető (<<, >>) operátorok operátorszinten nincsenek megvalósítva. Az elemenkénti egész léptetésekhez használd a numpy.left_shift és numpy.right_shift függvényeket.

Tömbkonstrukció¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: Új ndarray létrehozása számok beágyazott iterálható objektumából. A numpy.ndarray egyenértékű alternatív konstruktora.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: Egyenletesen elosztott értékeket ad vissza a [start, stop) félig nyílt intervallumon. Ha csak egy pozicionális argumentumot adunk meg, az stop-ként kerül kezelésre start = 0 mellett. Ha a dtype el van hagyva, az a bemenetekből kerül kikövetkeztetésre (egész, ha a start, stop, step mind egész és tartományon belül van).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: Ha az a már egy ndarray, amelynek dtype-ja megegyezik a dtype-pal (vagy a dtype értéke None), az a-t változatlanul adja vissza; egyébként egy új tömböt hoz létre (a megadott dtype-konverzióval, ha van). Az iterálható objektumok a numpy.array-ben leírtak szerint kerülnek konvertálásra.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: Egy ndarray sorozat összefűzése egy meglévő axis mentén. Minden bemeneti tömbnek azonos dtype-pal, ndim-mel és alakkal kell rendelkeznie minden tengelyen, kivéve az axis-t.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: Egy 2-D a esetén egy 1-D tömböt ad vissza, amely a k-adik átlót tartalmazza. Egy 1-D a esetén egy 2-D négyzetes tömböt ad vissza, amelyben az a a k-adik átlóra van helyezve. A k lehet pozitív (a fő átló felett) vagy negatív (alatta).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: A zeros aliasa; egy shape és dtype szerinti, nullával feltöltött tömböt ad vissza. (Az ulab nem hagyja a puffert inicializálatlanul.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Egy 2-D N x M tömböt ad vissza (négyzetes N x N, ha az M értéke None), amelyben a k-adik átlón egyesek, máshol nullák vannak.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Egy puffer-protokollt megvalósító objektumot dtype típusú 1-D ndarray-ként értelmez. A count az olvasandó elemek száma (a -1 minden elérhető elemet beolvas); az offset ennyi bájtot ugrik át a puffer elején.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Egy új, shape és dtype szerinti tömböt ad vissza, amelyben minden elem a fill_value értékre van állítva.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: Visszaad num egyenletesen elosztott mintát a zárt [start, stop] intervallumon (vagy félig nyitottan, ha endpoint False). Ha retstep True, egy (samples, step) tuplet ad vissza.

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: num darab, logaritmikus skálán egyenletesen elosztott mintát ad vissza: az eredmény a base ** start értéknél kezdődik és a base ** stop értéknél végződik.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Egy koordinátamátrixokból álló tuple-t ad vissza egydimenziós koordinátatömbök sorozatából. 'xy' indexing (az alapértelmezett) esetén az első két bemenetet Descartes-koordinátaként kezeli, és a kimeneti tengelyeiket felcseréli; 'ij' esetén mátrix-stílusú indexelést használ. A megvalósítás a NumPy megfelelőjének felel meg copy=True és sparse=False mellett.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Egy új, shape és dtype szerinti, egyesekkel feltöltött tömböt ad vissza.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Egy új, shape és dtype szerinti, nullákkal feltöltött tömböt ad vissza.

Vizsgálat / kiírás¶

numpy.get_printoptions() → dict¶: Visszaadja az aktuális tömbkiírási beállításokat egy dict-ként, threshold és edgeitems kulcsokkal.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: Beállítja a tömbkiírási opciókat. A threshold a teljes egészében kiírt tömbelemek maximális száma; az edgeitems az egy tengely mindkét végén megjelenített elemek száma, amikor a tömb összefoglalva jelenik meg.

numpy.ndinfo(array: ndarray) → None¶: Diagnosztikai információt ír ki (alak, strides, dtype, itemsize, …) az array-ről.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Visszaadja az a elemeinek számát az axis mentén; ha az axis értéke None, az elemek teljes számát adja vissza (a ndarray.shape szorzatát).

Összehasonlítás¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: Levágja az a értékeit úgy, hogy a_min <= result <= a_max. Egyenértékű a maximum(a_min, minimum(a, a_max))-mal; a broadcasting ugyanazokat a szabályokat követi, mint a minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Elemenkénti x1 == x2; egy boolean ndarray-t ad vissza (vagy egy bool skalárt, ha mindkét bemenet skalár). Hordozhatóság céljából biztosított – a tömbökön alkalmazott == operátor ugyanazt az eredményt adja.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Elemenkénti x1 != x2; az equal boolean megfelelője.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: Egy boolean tömböt (vagy skalárt) ad vissza, amely True ott, ahol a bemenet véges. Az egész bemenetek mindig végesek.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Egy boolean tömböt (vagy skalárt) ad vissza, amely True ott, ahol a bemenet végtelen. Az egész bemenetek soha nem végtelenek.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Két tömb / skalár elemenkénti maximuma. Az argumentumok együtt kerülnek broadcastolásra; ha a dtype-ok eltérnek, a kimenet felfelé konvertálódik.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Két tömb / skalár elemenkénti minimuma; a maximum megfelelője.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: Egy ndarray-ekből álló tuple-t ad vissza, az a minden dimenziójához egyet, amely az a nem nulla elemeinek indexeit tartalmazza.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: Egy ndarray-t ad vissza, amelynek elemei az x-ből származnak ott, ahol a condition igaz, és az y-ból egyébként. A három bemenet együtt kerül broadcastolásra; a kimenet dtype-ja az x és y felfelé konvertált típusa.

Numerikus redukciók¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Megvizsgálja, hogy az axis mentén minden elem True értékre értékelődik-e ki. axis=None (az alapértelmezett) esetén a kilapított tömböt vizsgálja, és egyetlen bool értéket ad vissza.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Megvizsgálja, hogy az axis mentén bármely elem True értékre értékelődik-e ki. axis=None esetén a kilapított tömböt vizsgálja.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Visszaadja a maximális elem indexét az axis mentén. axis=None esetén a tömb kilapul, és egyetlen egész szám kerül visszaadásra.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Visszaadja a minimális elem indexét az axis mentén. axis=None esetén a tömb kilapul, és egyetlen egész szám kerül visszaadásra.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: Egy előjel nélküli egész index ndarray-t ad vissza, amelynek bejegyzései növekvő sorrendbe rendezik az a-t az axis mentén. A kimenet dtype-ja uint16, így egyetlen tengely sem haladhatja meg a 65535 elemet. Az axis=None nem támogatott.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: Visszaadja két, 3 hosszúságú 1-D tömb keresztszorzatát.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Visszaadja az a n-edik diszkrét előretartó differenciáját az axis mentén. Az n értékének 0..9 között kell lennie (a differenciálási sablon egy int8-ban tárolódik); az axis hossza n-nel csökken. A numpy prepend és append kulcsszavai nincsenek megvalósítva.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Egy új tömböt ad vissza, amelyben az elemek sorrendje megfordul az axis mentén; axis=None esetén a tömb minden tengely mentén megfordul.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Visszaadja a maximális elemet az axis mentén. axis=None (az alapértelmezett) esetén a kilapított tömb skalárrá redukálódik. A numpy out kulcsszava nincs megvalósítva.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Visszaadja a minimális elemet az axis mentén; a max megfelelője.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: Visszaadja a számtani átlagot az axis mentén. axis=None (az alapértelmezett) esetén a kilapított tömb átlaga float-ként kerül visszaadásra.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Visszaadja a mediánt az axis mentén. axis=None esetén a tömb először kilapul. A kimenet dtype-ja mindig float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: Visszaadja az a-t, amelynek elemei shift pozícióval el vannak forgatva (ciklikusan eltolva). axis=None (az alapértelmezett) esetén a tömb először kilapul. A negatív eltolások ellentétes irányban forgatnak.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: Visszaad egy rendezett másolatot az a-ból az axis mentén, heap rendezést használva. axis=None esetén a tömb először kilapul. A numpy kind és order kulcsszavai nincsenek megvalósítva.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: Visszaadja a szórást az axis mentén. A ddof a szabadsági fokok delta értéke – a használt osztó N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Visszaadja az összeget az axis mentén. axis=None esetén a kilapított tömb teljes összege skalárként kerül visszaadásra.

Statisztika¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: Megszámolja az egyes értékek előfordulásainak számát az egydimenziós, nem negatív egész x tömbben. Az x dtype-jának uint8-nak vagy uint16-nak kell lennie. Ha a weights meg van adva, az x minden bejegyzése a hozzá tartozó súllyal járul hozzá 1 helyett, és a kimenet dtype-ja float; egyébként a kimenet dtype-ja uint16. Ha a minlength meg van adva, a kimeneti tömbnek legalább annyi eleme van (a többletbejegyzések nullák).

numpy.trace(m: ndarray) → int | float¶: Visszaadja az m négyzetes mátrix átlós elemeinek összegét. A visszatérési típus az m dtype-ját követi (az egész tömbök egészet, a float tömbök float-ot eredményeznek).

Transzformáció¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: Visszaadja az a azon szeleteit, amelyeket a boolean condition választ ki az axis mentén. axis=None esetén a kilapított tömböt használja.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Visszaad egy másolatot az a-ból, amelyből az indices helyén lévő bejegyzések el vannak távolítva az axis mentén. axis=None esetén a tömb először kilapul. A negatív indexek az axis végétől számolnak; az indices belsőleg rendezésre kerül a törlés előtt.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Visszaadja két tömb skaláris szorzatát. Két 1-D tömb esetén ez a belső szorzat (egy float skalár). 2-D tömbök esetén ez mátrixszorzás; a belső dimenzióknak meg kell egyezniük. Az eredmény dtype-ja mindig float.

Közelítés¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: Egydimenziós lineáris interpoláció. Az xp-nek monoton növekvő 1-D tömbnek kell lennie a független értékekkel; az fp a megfelelő függő értékeket tartalmazza; az x azok a pontok, ahol az interpoláns kiértékelésre kerül. A left és a right felülírja az x < xp[0], illetve az x > xp[-1] esetén visszaadott értéket (alapértelmezések: fp[0] és fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Integrálja az y-t az összetett trapéz-szabállyal. Ha az x meg van adva, az adja meg az y-nak megfelelő mintapozíciókat; egyébként a dx lépésköz kerül felhasználásra. Az y-nak (és az x-nek) 1-D-nek kell lennie.

Kiválasztás¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: Elemeket vesz ki az a-ból a megadott indices helyeken az axis mentén. axis=None esetén a kilapított tömböt használja. A mode a tartományon kívüli viselkedést választja ki: "raise" (alapértelmezett – ValueError-t vált ki), "wrap" (a tengely hosszával modulózva), vagy "clip" (az érvényes tartományra levágva; negatív indexek nem engedélyezettek). Ha az out meg van adva, az eredmény oda kerül írásra.

Bitenkénti¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: Két egész tömb elemenkénti bitenkénti ÉS művelete; a broadcasting támogatott. Egy nem egész dtype kivételt vált ki.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: Két egész tömb elemenkénti bitenkénti VAGY művelete.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: Két egész tömb elemenkénti bitenkénti KIZÁRÓ VAGY (XOR) művelete.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: Az x1 elemenkénti bitenkénti eltolása balra x2 bittel; mindkét tömbnek egész dtype-pal kell rendelkeznie.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: Az x1 elemenkénti bitenkénti eltolása jobbra x2 bittel; mindkét tömbnek egész dtype-pal kell rendelkeznie.

Szűrés¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: Visszaadja két 1-D tömb diszkrét lineáris konvolúcióját. Csak a "full" mód támogatott; a numpy mode kulcsszava nem elfogadott (más módok a teljes eredmény szeletelésével érhetők el). A kimenet hossza len(a) + len(v) - 1.

Polinom¶

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

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Egy deg fokú polinomot illeszt az (x, y) adatpontokra legkisebb négyzetek módszerével, és visszaadja a polinom együtthatóit (a legmagasabb fokszámmal kezdve). Ha az x el van hagyva, a range(len(y)) kerül felhasználásra. ValueError-t vált ki, ha az x és az y hossza eltér.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Kiértékeli azt a polinomot, amelynek együtthatói p (a legmagasabb fokszámmal kezdve), az x-ben. Ha az x skalár, egy float kerül visszaadásra, egyébként egy ndarray.

I/O¶

numpy.load(file: str) → ndarray¶: Beolvas egy korábban a save-vel kiírt tömböt a file-ból (a numpy platformfüggetlen .npy formátumában). A bájtsorrend menet közben konvertálódik, ha a fájl bájtsorrendje eltér a hostétól.

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¶: Numerikus adatokat olvas be egy szöveges file-ból, és ndarray-ként adja vissza. A delimiter alapértelmezése a szóköz; a comments a sorvégi megjegyzés jelölője; a max_rows korlátozza a beolvasott adatsorok számát (a -1 az összeset jelenti); a usecols index szerint választ ki oszlopokat; a skiprows ennyi kezdő sort ugrik át. Ha a dtype nem float, az értékek kerekítéssel konvertálódnak.

numpy.save(file: str, a: ndarray) → None¶: Az a kiírása a file-ba a numpy platformfüggetlen .npy formátumában.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: Az a kiírása a file-ba szövegként. A delimiter a soron belüli értékeket választja el; a header és a footer, ha meg vannak adva, az adatok elé/mögé kerülnek kiírásra, mindegyik a comments előtaggal. Az értékek lebegőpontos formában íródnak ki.

Univerzális függvények¶

Elemenkénti matematikai függvények. Mindegyik egy skalárt vagy egy ndarray-t fogad el, és azonos alakú eredményt ad vissza (skalár bemenetnél float skalárt, tömb bemenetnél ndarray-t). Egy ndarray-jel hívva az eredmény egy új lebegőpontos ndarray; egy opcionális out kulcsszó átadható, hogy az eredmény egy azonos méretű, előre allokált float ndarray-be íródjon.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének inverz koszinuszát (arkusz koszinusz); az eredmény radiánban van.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének inverz hiperbolikus koszinuszát.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: Kiszámítja az elemenkénti kétargumentumú inverz tangenst atan2(y, x); támogatja a broadcastingot a két bemenet között.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: Kerekíti az x ndarray elemeit a megadott decimals tizedesjegyre; az első argumentumnak ndarray-nek kell lennie.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének inverz szinuszát (arkusz szinusz); az eredmény radiánban van.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének inverz hiperbolikus szinuszát.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének inverz tangensét (arkusz tangens); az eredmény radiánban van.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének inverz hiperbolikus tangensét.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének felső egészét (a legkisebb egész szám, amely nem kisebb az értéknél).

numpy.cos(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének koszinuszát (radiánban).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének hiperbolikus koszinuszát.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: Az x minden elemét radiánból fokra konvertálja.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az e**x exponenciálist x minden eleméhez.

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemére az exp(x) - 1 értéket, nulla közelében javított pontossággal.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének alsó egészét (a legnagyobb egész szám, amely nem nagyobb az értéknél).

numpy.log(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének természetes logaritmusát.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének 10-es alapú logaritmusát.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének 2-es alapú logaritmusát.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: Az x minden elemét fokból radiánba konvertálja.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének szinuszát (radiánban).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének normalizált sinc függvényét sin(pi*x) / (pi*x).

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének hiperbolikus szinuszát.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: Kiszámítja x minden elemének négyzetgyökét.

numpy.tan(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének tangensét (radiánban).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: Kiszámítja az x minden elemének hiperbolikus tangensét.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: Visszaad egy hívható objektumot, amely az f Python függvényt elemenként alkalmazza egy skalárra, iterálható objektumra vagy ndarray-re; az otypes választja ki a kimeneti dtype-ot (alapértelmezés: float).

Konstansok¶

numpy.e: float¶: Euler-féle szám \(e \approx 2.71828\).

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

numpy.inf: float¶: IEEE-754 lebegőpontos pozitív végtelen.

numpy.nan: float¶: IEEE-754 lebegőpontos „nem szám” (not a number).

numpy.bool: int¶: Dtype kód boolean tömbökhöz (uint8-ként tárolva).

numpy.uint8: int¶: Dtype kód előjel nélküli 8 bites egész tömbökhöz.

numpy.int8: int¶: Dtype kód előjeles 8 bites egész tömbökhöz.

numpy.uint16: int¶: Dtype kód előjel nélküli 16 bites egész tömbökhöz.

numpy.int16: int¶: Dtype kód előjeles 16 bites egész tömbökhöz.

numpy.float: int¶: Dtype kód 32 bites lebegőpontos tömbökhöz.

numpy — numpy-kompatibilis tömbműveletek¶