`numpy` — numpy-kompatibilne operacije nad poljima#

Podmodul numpy modula ulab pruža numpy-kompatibilni API izgrađen oko tipa n-dimenzionalnog polja ndarray. Implementira pažljivo odabran podskup CPython numpy-ja: konstrukciju polja, matematiku po elementima, redukcije i statistiku, linearnu algebru, FFT-ove, generiranje slučajnih brojeva, prilagodbu polinoma i osnovni I/O.

Podmodul se po dogovoru uvozi kao np

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

Svaki argument dtype je jedna od cjelobrojnih konstanti izloženih na razini modula: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 i numpy.float (zadano). Vrsta rezultata ndarray odnosi se na numpy.ndarray.

Podmoduli#

klasa `ndarray` — n-dimenzionalno polje#

ndarray je n-dimenzionalni spremnik svjestan dtype-a u srži numpy / ulab. Podaci se pohranjuju u neprekinutom bloku čije je tumačenje opisano malim zaglavljem (dtype, shape, strides, ndim, itemsize). Mnoge operacije – reshape, transpose, rezanje – samo prilagođavaju ovo zaglavlje pa su stoga vrlo jeftine; metode koje alociraju novu pohranu (copy, flatten, većina aritmetike) vraćaju novo gusto polje.

Isti tip dostupan je kao ulab.ndarray, numpy.ndarray te (unutar ove stranice) jednostavno ndarray.

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

Stvara novi ndarray.

Parametri:

values – Izvorni podaci. Bilo drugi ndarray (koji se duboko kopira, uz konverziju tipa ako se dtype razlikuje) ili bilo koji MicroPython iterabilni objekt. Ugniježđeni iterabilni objekti proizvode višedimenzionalna polja; svi unutarnji iterabilni objekti moraju imati istu duljinu, inače se podiže ValueError.
dtype – Vrsta elementa za novo polje. Jedan od cjelobrojnih kodova tipa koje izlaže numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 i numpy.float), ili instanca dtype. Zadana vrijednost je numpy.float.

Tvornička funkcija numpy.array uobičajeni je način za stvaranje ndarray; ona prosljeđuje ovom konstruktoru.

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

Zamjenjuje redoslijed bajtova svakog elementa. Za polja uint16, int16 i float to obrće redoslijed bajtova pojedinih elemenata, što je korisno pri čitanju podataka s perifernih uređaja čiji redoslijed bajtova ne odgovara redoslijedu mikrokontrolera. Za jednobajttne tipove (bool, uint8, int8) ovo je no-op koji vraća pogled ili kopiju.

Ako je inplace False (zadano), vraća se novi ndarray, a izvornik ostaje netaknut. Ako je inplace True, bajtovi objekta self zamjenjuju se na mjestu i vraća se pogled na self.

copy() → ndarray#: Vraća novu gustu, duboku kopiju polja. Kopija posjeduje vlastite podatke; izmjene nad njom ne utječu na izvornik.

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

Vraća novu jednodimenzionalnu kopiju polja.

Parametri:: order – 'C' (zadano) obilazi podatke u C redoslijedu (zadnja os se najbrže mijenja); 'F' ih obilazi u Fortran redoslijedu (prva os se najbrže mijenja).

reshape(shape: int | tuple[int, ...]) → ndarray#: Vraća pogled na polje s novim oblikom. Ukupan broj elemenata mora ostati nepromijenjen, inače se podiže ValueError. Dostupno samo kada je ULAB_MAX_DIMS > 1. Ekvivalentno pridruživanju atributu shape.

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

Sortira polje na mjestu.

Parametri:: axis – Os duž koje se sortira. -1 (zadano) sortira duž zadnje osi; None najprije izravnava polje pa zatim sortira.

tobytes() → bytearray#: Vraća bytearray koji je alias osnovnog podatkovnog međuspremnika polja. Pisanje kroz vraćeni bytearray mijenja polje na mjestu. Podiže ValueError ako polje nije gusto (npr. izrezani pogled).

tolist() → list#: Vraća sadržaj polja kao (moguće ugniježđenu) Python listu list. Dubina ugniježđenja jednaka je ndim.

transpose() → ndarray#: Vraća transponirano polje (osi obrnute). Za jednodimenzionalna polja vraća self. Dostupno samo kada je ULAB_MAX_DIMS > 1. Atribut T skraćenica je za ovu metodu.

dtype: dtype | int#: Tip podataka elemenata polja. Vraća instancu dtype kada je ugrađeni program izgrađen s omogućenim ULAB_HAS_DTYPE_OBJECT, inače osnovni jednoznakovni kod tipa kao cijeli broj.

flat: flatiter#: Plosnati iterator koji daje svaki element polja u C redoslijedu. Za razliku od flatten(), iteriranje kroz flat ne alocira novo polje.

itemsize: int#: Veličina u bajtovima jednog elementa polja, izvedena iz dtype.

ndim: int#: Broj dimenzija polja (duljina od shape).

shape: tuple[int, ...]#: Duljine polja duž svake osi. Pridruživanje torke atributu shape mijenja oblik polja na mjestu (ekvivalentno reshape()).

size: int#: Ukupan broj elemenata u polju (umnožak od shape).

strides: tuple[int, ...]#: Broj bajtova za pomak u memoriji duž svake osi kako bi se došlo do sljedećeg elementa duž te osi.

T: ndarray#: Transponirano polje; ekvivalentno transpose().

Podržani operatori#

Instance ndarray podržavaju sljedeće operatore. Binarni operatori prenose svoje operande slijedeći standardna pravila prijenosa numpy-a i slijede pravila numpy-evog proširenja tipa (npr. uint8 + int8 => int16, uint16 + int16 => float).

Aritmetika (binarna): +, -, *, /, //, %, **. Podržani su i reflektirani (desnostrani) operandi i inačice na mjestu +=, -=, *=, /=, %=, **=. Prihvaćaju se oblici ndarray-s-ndarray i ndarray-sa-skalarom.

Usporedba: ==, !=, <, <=, >, >=. Svaki vraća boolean ndarray broadcast oblika.

Bitske operacije (samo polja cijelih brojeva): &, |, ^. Primjena na polje float podiže TypeError.

Unarni: + (vraća kopiju), - (negacija; na nepredznačenim dtype-ovima vrijednosti se omotavaju modulo \(2^N\)), abs() (apsolutna vrijednost po elementima; na nepredznačenim dtype-ovima vraća kopiju bez izračuna), ~ (bitovna inverzija, samo cjelobrojni dtype-ovi), len() (vraća duljinu prve osi).

Indeksiranje i rezanje: a[i], a[i, j, ...], a[start:stop:step], indeksiranje boolean maskom (a[mask]) i indeksiranje cjelobrojnim poljem (fancy) sve je podržano i za čitanje i za pisanje.

Iteracija: Iteriranje preko ndarray daje podpolja duž prve osi (jedan element odjednom za 1-D polja). Koristite flat za iteriranje preko svakog skalarnog elementa neovisno o dimenzionalnosti.

Operator množenja matrica @ nije implementiran; umjesto njega koristite numpy.dot (np.dot(a, b)).

Operatori pomaka (<<, >>) nisu implementirani na razini operatora. Koristite numpy.left_shift i numpy.right_shift za cjelobrojne pomake po elementima.

Konstrukcija polja#

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray#: Konstruira novi ndarray iz ugniježđenog iterabilnog objekta brojeva. Ekvivalentan alternativni konstruktor za numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray#: Vraća jednoliko razmaknute vrijednosti preko poluotvorenog intervala [start, stop). Ako je dan samo jedan pozicijski argument, on se tretira kao stop uz start = 0. Ako je dtype izostavljen, zaključuje se iz ulaza (cjelobrojan ako su sve start, stop, step cijeli brojevi i unutar raspona).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray#: Ako je a već ndarray čiji se dtype podudara s dtype (ili je dtype None), vraća a nepromijenjeno; inače stvara novo polje (s traženom konverzijom dtype-a kada je zadana). Iterabilni objekti pretvaraju se kao u numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray#: Spaja niz ndarray duž postojeće osi axis. Sva ulazna polja moraju dijeliti isti dtype, ndim i oblik na svakoj osi osim axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray#: Za 2-D a, vraća 1-D polje koje sadrži k-tu dijagonalu. Za 1-D a, vraća 2-D kvadratno polje s a postavljenim na k-tu dijagonalu. k može biti pozitivan (iznad glavne dijagonale) ili negativan (ispod).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Alias za zeros; vraća nulama ispunjeno polje oblika shape i tipa dtype. (ulab ne ostavlja međuspremnik neinicijaliziranim.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray#: Vraća 2-D N x M polje (kvadratno N x N ako je M None) s jedinicama na k-toj dijagonali i nulama drugdje.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray#: Tumači objekt buffer-protokola kao 1-D ndarray tipa dtype. count je broj stavki za čitanje (-1 čita sve dostupne stavke); offset preskače toliko bajtova na početku međuspremnika.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray#: Vraća novo polje oblika shape i tipa dtype sa svakim elementom postavljenim na fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]#: Vraća num ravnomjerno raspoređenih uzoraka na zatvorenom intervalu [start, stop] (ili poluotvorenom ako je endpoint False). Kada je retstep True, vraća n-torku (samples, step).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray#: Vraća num uzoraka jednoliko razmaknutih na logaritamskoj skali: rezultat počinje na base ** start i završava na base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]#: Vraća torku koordinatnih matrica iz niza jednodimenzionalnih koordinatnih polja. Uz indexing 'xy' (zadano) prva dva ulaza tretiraju se kao Kartezijeve koordinate i njihove izlazne osi se zamjenjuju; uz 'ij' koristi se matrično indeksiranje. Implementacija odgovara NumPy ekvivalentu s copy=True i sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Vraća novo polje oblika shape i tipa dtype ispunjeno jedinicama.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Vraća novo polje oblika shape i tipa dtype ispunjeno nulama.

Inspekcija / ispis#

numpy.get_printoptions() → dict#: Vraća trenutne opcije ispisa polja kao rječnik s ključevima threshold i edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None#: Postavlja opcije ispisa polja. threshold je najveći broj elemenata polja koji se ispisuju u cijelosti; edgeitems je broj stavki prikazanih na svakom kraju osi kada je polje sažeto.

numpy.ndinfo(array: ndarray) → None#: Ispisuje dijagnostičke informacije (oblik, koraci, dtype, itemsize, …) o polju array.

numpy.size(a: ndarray, *, axis: int | None = None) → int#: Vraća broj elemenata polja a duž osi axis; ako je axis None, vraća ukupan broj elemenata (umnožak od ndarray.shape).

Usporedba#

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float#: Ograničava vrijednosti polja a tako da vrijedi a_min <= result <= a_max. Ekvivalentno maximum(a_min, minimum(a, a_max)); broadcasting slijedi ista pravila kao minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool#: x1 == x2 po elementima; vraća boolean ndarray (ili bool skalar ako su oba ulaza skalari). Pruženo radi prenosivosti – operator == nad poljima daje isti rezultat.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool#: x1 != x2 po elementima; boolean parnjak funkcije equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool#: Vraća boolean polje (ili skalar) koje je True tamo gdje je ulaz konačan. Cjelobrojni ulazi uvijek su konačni.

numpy.isinf(x: ndarray | int | float) → ndarray | bool#: Vraća boolean polje (ili skalar) koje je True tamo gdje je ulaz beskonačan. Cjelobrojni ulazi nikada nisu beskonačni.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: Maksimum dvaju polja / skalara po elementima. Argumenti se broadcastaju zajedno; ako se dtype-ovi razlikuju, izlaz se uzvisuje.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: Minimum dvaju polja / skalara po elementima; parnjak funkcije maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]#: Vraća torku ndarray, jedan po dimenziji polja a, koji sadrže indekse elemenata polja a različitih od nule.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray#: Vraća ndarray čiji elementi dolaze iz x tamo gdje je condition istinit, a iz y inače. Tri ulaza se broadcastaju zajedno; izlazni dtype je uzvišenje od x i y.

Numeričke redukcije#

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool#: Provjerava jesu li svi elementi duž osi axis jednaki True. Uz axis=None (zadano) testira se izravnano polje i vraća se jedan bool.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool#: Provjerava je li bilo koji element duž osi axis jednak True. Uz axis=None testira se izravnano polje.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int#: Vraća indeks najvećeg elementa duž osi axis. Uz axis=None polje se izravnava i vraća se jedan cijeli broj.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int#: Vraća indeks najmanjeg elementa duž osi axis. Uz axis=None polje se izravnava i vraća se jedan cijeli broj.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray#: Vraća ndarray nepredznačenih cjelobrojnih indeksa čije stavke sortiraju a uzlazno duž osi axis. Izlazni dtype je uint16, pa nijedna os ne smije prelaziti 65535 elemenata. axis=None nije podržan.

numpy.cross(a: ndarray, b: ndarray) → ndarray#: Vraća vektorski umnožak dvaju 1-D polja duljine 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray#: Vraća n-tu diskretnu unaprijednu razliku polja a duž osi axis. n mora biti u 0..9 (predložak diferenciranja pohranjen je u int8); duljina osi axis smanjuje se za n. numpy ključne riječi prepend i append nisu implementirane.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray#: Vraća novo polje s obrnutim redoslijedom elemenata duž osi axis; uz axis=None polje se obrće duž svake osi.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Vraća najveći element duž osi axis. Uz axis=None (zadano) izravnano polje reducira se na skalar. numpy ključna riječ out nije implementirana.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Vraća najmanji element duž osi axis; parnjak funkcije max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float#: Vraća aritmetičku sredinu duž osi axis. Uz axis=None (zadano) sredina izravnanog polja vraća se kao float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float#: Vraća medijan duž osi axis. Uz axis=None polje se najprije izravnava. Izlazni dtype je uvijek float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray#: Vraća a s elementima rotiranima (ciklički pomaknutima) za shift pozicija. Uz axis=None (zadano) polje se najprije izravnava. Negativni pomaci rotiraju u suprotnom smjeru.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray#: Vraća sortiranu kopiju polja a duž osi axis koristeći heap sort. Uz axis=None polje se najprije izravnava. numpy ključne riječi kind i order nisu implementirane.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float#: Vraća standardnu devijaciju duž osi axis. ddof je delta stupnjeva slobode – korišteni djelitelj je N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Vraća zbroj duž osi axis. Uz axis=None ukupna vrijednost izravnanog polja vraća se kao skalar.

Statistika#

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray#: Broji broj pojavljivanja svake vrijednosti u jednodimenzionalnom, nenegativnom cjelobrojnom polju x. Dtype od x mora biti uint8 ili uint16. Ako je dana weights, svaka stavka od x doprinosi svojom odgovarajućom težinom umjesto vrijednosti 1 i izlaz je dtype-a float; inače je izlaz dtype-a uint16. Ako je dana minlength, izlazno polje ima barem toliko elemenata (dodatne stavke su nule).

numpy.trace(m: ndarray) → int | float#: Vraća zbroj dijagonalnih elemenata kvadratne matrice m. Tip povratne vrijednosti slijedi dtype od m (cjelobrojna polja proizvode int, float polja float).

Transformacija#

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray#: Vraća isječke polja a odabrane duž osi axis boolean uvjetom condition. Uz axis=None koristi se izravnano polje.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray#: Vraća kopiju polja a s uklonjenim stavkama na indices duž osi axis. Uz axis=None polje se najprije izravnava. Negativni indeksi broje se od kraja osi axis; indices se interno sortira prije brisanja.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float#: Vraća skalarni umnožak dvaju polja. Za dva 1-D polja to je unutarnji umnožak (float skalar). Za 2-D polja to je množenje matrica; unutarnje dimenzije moraju se podudarati. Rezultat je uvijek dtype-a float.

Aproksimacija#

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray#: Jednodimenzionalna linearna interpolacija. xp mora biti monotono rastuće 1-D polje neovisnih vrijednosti; fp sadrži odgovarajuće zavisne vrijednosti; x su točke u kojima se interpolant procjenjuje. left i right nadjačavaju vrijednost vraćenu za x < xp[0] odnosno x > xp[-1] (zadane vrijednosti: fp[0] i fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float#: Integrira y koristeći složeno trapezno pravilo. Ako je dana x, ona pruža pozicije uzoraka koje odgovaraju y; inače se koristi razmak dx. y (i x) moraju biti 1-D.

Odabir#

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray#: Uzima elemente iz polja a na zadanim indices duž osi axis. Uz axis=None koristi se izravnano polje. mode odabire ponašanje izvan granica: "raise" (zadano – podiže ValueError), "wrap" (modulo duljina osi), ili "clip" (ograničavanje na valjani raspon; negativni indeksi nisu dopušteni). Ako je dana out, rezultat se upisuje u nju.

Bitovno#

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray#: Bitovni AND dvaju cjelobrojnih polja po elementima; broadcasting je podržan. Necjelobrojni dtype podiže iznimku.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray#: Bitovni OR dvaju cjelobrojnih polja po elementima.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray#: Bitovni XOR dvaju cjelobrojnih polja po elementima.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray#: Bitovni pomak polja x1 ulijevo za x2 bitova po elementima; oba polja moraju imati cjelobrojni dtype.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray#: Bitovni pomak polja x1 udesno za x2 bitova po elementima; oba polja moraju imati cjelobrojni dtype.

Filtriranje#

numpy.convolve(a: ndarray, v: ndarray) → ndarray#: Vraća diskretnu linearnu konvoluciju dvaju 1-D polja. Podržan je samo način "full"; numpy ključna riječ mode se ne prihvaća (drugi načini mogu se dobiti rezanjem punog rezultata). Izlazna duljina je 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: Prilagođava polinom stupnja deg podatkovnim točkama (x, y) metodom najmanjih kvadrata i vraća koeficijente polinoma (najviši stupanj prvi). Ako je x izostavljen, koristi se range(len(y)). Podiže ValueError ako se duljine od x i y razlikuju.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float#: Procjenjuje polinom čiji su koeficijenti p (najviši stupanj prvi) u točki x. Ako je x skalar, vraća se float, inače ndarray.

I/O#

numpy.load(file: str) → ndarray#: Čita polje prethodno zapisano s save iz datoteke file (numpy-jev platformski neovisni format .npy). Endianness se pretvara u hodu ako se redoslijed bajtova datoteke razlikuje od onog na hostu.

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#: Čita numeričke podatke iz tekstualne datoteke file i vraća ih kao ndarray. delimiter zadano je razmak; comments je oznaka linijskog komentara; max_rows ograničava broj pročitanih redaka podataka (-1 za sve); usecols odabire stupce po indeksu; skiprows preskače toliko vodećih redaka. Ako dtype nije float, vrijednosti se pretvaraju zaokruživanjem.

numpy.save(file: str, a: ndarray) → None#: Sprema a u datoteku file u numpy-jevu platformski neovisnom formatu .npy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None#: Zapisuje a u datoteku file kao tekst. delimiter razdvaja vrijednosti unutar retka; header i footer, ako su dani, zapisuju se prije/poslije podataka, svaki s prefiksom comments. Vrijednosti se zapisuju kao brojevi s pomičnim zarezom.

Univerzalne funkcije#

Matematičke funkcije po elementima. Svaka prihvaća skalar ili ndarray i vraća rezultat odgovarajućeg oblika (float skalar za skalarni ulaz, ndarray za polje na ulazu). Kada se pozove s ndarray, rezultat je novi ndarray s pomičnim zarezom; opcionalna ključna riječ out može se proslijediti za upisivanje rezultata u prethodno alocirani float ndarray iste veličine.

numpy.acos(x: ndarray | float, /) → ndarray | float#: Računa inverzni kosinus (arkus kosinus) svakog elementa od x; rezultat je u radijanima.

numpy.acosh(x: ndarray | float, /) → ndarray | float#: Računa inverzni hiperbolni kosinus svakog elementa od x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float#: Računa dvoargumentni inverzni tangens atan2(y, x) po elementima; podržava broadcasting između dvaju ulaza.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray#: Zaokružuje elemente ndarray x na zadani broj decimala decimals; prvi argument mora biti ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float#: Računa inverzni sinus (arkus sinus) svakog elementa od x; rezultat je u radijanima.

numpy.asinh(x: ndarray | float, /) → ndarray | float#: Računa inverzni hiperbolni sinus svakog elementa od x.

numpy.atan(x: ndarray | float, /) → ndarray | float#: Računa inverzni tangens (arkus tangens) svakog elementa od x; rezultat je u radijanima.

numpy.atanh(x: ndarray | float, /) → ndarray | float#: Računa inverzni hiperbolni tangens svakog elementa od x.

numpy.ceil(x: ndarray | float, /) → ndarray | float#: Računa strop (najmanji cijeli broj koji nije manji od vrijednosti) svakog elementa od x.

numpy.cos(x: ndarray | float, /) → ndarray | float#: Računa kosinus svakog elementa od x (u radijanima).

numpy.cosh(x: ndarray | float, /) → ndarray | float#: Računa hiperbolni kosinus svakog elementa od x.

numpy.degrees(x: ndarray | float, /) → ndarray | float#: Pretvara svaki element od x iz radijana u stupnjeve.

numpy.exp(x: ndarray | float, /) → ndarray | float#: Izračunava eksponencijalnu funkciju e**x svakog elementa od x.

numpy.expm1(x: ndarray | float, /) → ndarray | float#: Računa exp(x) - 1 svakog elementa od x s poboljšanom preciznošću blizu nule.

numpy.floor(x: ndarray | float, /) → ndarray | float#: Računa pod (najveći cijeli broj koji nije veći od vrijednosti) svakog elementa od x.

numpy.log(x: ndarray | float, /) → ndarray | float#: Računa prirodni logaritam svakog elementa od x.

numpy.log10(x: ndarray | float, /) → ndarray | float#: Računa logaritam po bazi 10 svakog elementa od x.

numpy.log2(x: ndarray | float, /) → ndarray | float#: Računa logaritam po bazi 2 svakog elementa od x.

numpy.radians(x: ndarray | float, /) → ndarray | float#: Pretvara svaki element od x iz stupnjeva u radijane.

numpy.sin(x: ndarray | float, /) → ndarray | float#: Računa sinus svakog elementa od x (u radijanima).

numpy.sinc(x: ndarray | float, /) → ndarray | float#: Računa normaliziranu sinc funkciju sin(pi*x) / (pi*x) svakog elementa od x.

numpy.sinh(x: ndarray | float, /) → ndarray | float#: Računa hiperbolni sinus svakog elementa od x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float#: Izračunava kvadratni korijen svakog elementa od x.

numpy.tan(x: ndarray | float, /) → ndarray | float#: Računa tangens svakog elementa od x (u radijanima).

numpy.tanh(x: ndarray | float, /) → ndarray | float#: Računa hiperbolni tangens svakog elementa od x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable#: Vraća pozivljivi objekt koji primjenjuje Python funkciju f po elementima na skalar, iterabilni objekt ili ndarray; otypes odabire izlazni dtype (zadano float).

Konstante#

numpy.e: float#: Eulerov broj \(e \approx 2.71828\).

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

numpy.inf: float#: IEEE-754 pozitivna beskonačnost s pomičnim zarezom.

numpy.nan: float#: IEEE-754 „nije broj” (not a number) s pomičnim zarezom.

numpy.bool: int#: Dtype kod za boolean polja (pohranjeno kao uint8).

numpy.uint8: int#: Dtype kod za polja nepredznačenih 8-bitnih cijelih brojeva.

numpy.int8: int#: Dtype kod za polja predznačenih 8-bitnih cijelih brojeva.

numpy.uint16: int#: Dtype kod za polja nepredznačenih 16-bitnih cijelih brojeva.

numpy.int16: int#: Dtype kod za polja predznačenih 16-bitnih cijelih brojeva.

numpy.float: int#: Dtype kod za polja 32-bitnih brojeva s pomičnim zarezom.

numpy — numpy-kompatibilne operacije nad poljima#