`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 modulszinten elérhető egész szám konstansok egyike: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (az alapértelmezett), és (ha a komplex támogatás bele van fordítva) numpy.complex. 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 elemtípusa. A numpy által közzétett típuskód-egészek egyike (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float, és – ha támogatott – numpy.complex), vagy egy dtype példány. Alapértelmezése 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 bájtsorrendjét. A uint16, int16, float és complex tömböknél ez megfordítja az elemenkénti bájtsorrendet, ami hasznos, ha olyan perifériáktól származó adatokat dolgozunk fel, amelyek bájtsorrendje nem egyezik a mikrokontrollerével. Az egybájtos dtype-oknál (bool, uint8, int8) ez egy üresjárati művelet, amely egy 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.

real: ndarray¶: Egy komplex tömb valós része, float ndarray-ként visszaadva. Valós tömböknél ez a self egy másolata, azonos dtype-pal. Csak akkor érhető el, ha a firmware komplex támogatással lett építve.

imag: ndarray¶: Egy komplex tömb képzetes része, float ndarray-ként visszaadva. Valós tömböknél ez egy nullákból álló tömb, a self-fel azonos dtype-pal. Csak akkor érhető el, ha a firmware komplex támogatással lett építve.

Támogatott operátorok¶

Az ndarray példányok a következő operátorokat támogatják. A bináris operátorok a standard numpy broadcasting szabályok szerint terjesztik ki az operandusaikat, és a numpy felfelé konvertálási (upcasting) szabályait követik (pl. uint8 + int8 => int16, uint16 + int16 => float); a komplex operandust tartalmazó műveletek komplex eredményt adnak.

Aritmetikai (bináris): +, -, *, /, //, %, **. A tükrözött (jobb oldali) operandusok és a helyben módosító változatok +=, -=, *=, /=, %=, **= szintén támogatottak. Mind az ndarray-ndarray, mind az ndarray-skalár forma elfogadott. A maradékos osztás (//) és a modulo operátor (%) nincs megvalósítva a complex tömbökhöz.

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

Bitenkénti (csak egész tömbökön): &, |, ^. Ezek alkalmazása egy float vagy complex 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]¶: num darab egyenletesen elosztott mintát ad vissza a zárt [start, stop] intervallumon (vagy félig nyílt intervallumon, ha az endpoint értéke False). Ha a retstep értéke True, egy (samples, step) tuple-t ad vissza. A komplex start/stop komplex tömböt eredményez (ha a komplex támogatás engedélyezve van).

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.

Komplex segédfüggvények¶

Ezek a függvények csak akkor érhetők el, ha az ulab komplex támogatással lett lefordítva (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: Visszaadja a val valós részét. Valós dtype-ú bemenetnél egy másolatot ad vissza a dtype megőrzésével; komplex bemenetnél egy float ndarray-t ad vissza.

numpy.imag(val: ndarray) → ndarray¶: Visszaadja a val képzetes részét. Valós dtype-ú bemenetnél egy nullákból álló tömböt ad vissza azonos dtype-pal; komplex bemenetnél egy float ndarray-t ad vissza.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: Visszaadja a val komplex konjugáltját. A valós értékű bemenetek változatlanul kerülnek visszaadásra.

numpy.sort_complex(a: ndarray) → ndarray¶: Rendezi az 1-D a tömböt először a valós rész, majd a képzetes rész szerint. Az eredmény dtype-ja mindig komplex, még akkor is, ha az a valós értékű volt.

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 x minden elemének exponenciálisát e**x; komplex bemenet esetén komplex ndarray-t adhat vissza (ha a komplex támogatás engedélyezve van).

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 az x minden elemének négyzetgyökét; add át a dtype=numpy.complex-et, hogy komplex eredményeket kapj negatív valós bemenetekhez (ha a komplex támogatás engedélyezve van).

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¶