numpy — operacje na tablicach zgodne z numpy

Podmoduł numpy modułu ulab udostępnia API zgodne z numpy, zbudowane wokół n-wymiarowego typu tablicowego ndarray. Implementuje on starannie dobrany podzbiór CPythonowego numpy: tworzenie tablic, działania matematyczne wykonywane element po elemencie, redukcje i statystyki, algebrę liniową, transformaty FFT, generowanie liczb losowych, dopasowywanie wielomianów oraz podstawowe operacje wejścia/wyjścia.

Podmoduł jest zwyczajowo importowany jako 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)))

Każdy argument dtype jest jedną ze stałych całkowitych udostępnianych na poziomie modułu: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (wartość domyślna) oraz (gdy skompilowano obsługę liczb zespolonych) numpy.complex. Typ wynikowy ndarray odnosi się do numpy.ndarray.

Podmoduły

• numpy.fft — Procedury szybkiej transformaty Fouriera
• numpy.linalg — Procedury algebry liniowej
• numpy.random — Generowanie liczb losowych

klasa ndarray — tablica n-wymiarowa

ndarray to n-wymiarowy, świadomy typu dtype kontener stanowiący rdzeń numpy / ulab. Dane są przechowywane w ciągłym bloku, którego interpretację opisuje niewielki nagłówek (dtype, shape, strides, ndim, itemsize). Wiele operacji – reshape, transpose, wycinanie – jedynie modyfikuje ten nagłówek, są więc bardzo tanie; metody alokujące nową pamięć (copy, flatten, większość działań arytmetycznych) zwracają nową, gęstą tablicę.

Ten sam typ jest dostępny jako ulab.ndarray, numpy.ndarray oraz (w obrębie tej strony) po prostu ndarray.

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

Tworzy nowy obiekt ndarray.

Parametry:

• values – Dane źródłowe. Albo inny obiekt ndarray (kopiowany głęboko, z konwersją typu, jeśli dtype się różni), albo dowolny iterowalny obiekt MicroPython. Zagnieżdżone obiekty iterowalne tworzą tablice wielowymiarowe; wszystkie wewnętrzne obiekty iterowalne muszą mieć tę samą długość, w przeciwnym razie zgłaszany jest wyjątek ValueError.

• dtype – Typ elementów nowej tablicy. Jedna z liczb całkowitych kodujących typ udostępnianych przez numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float oraz – jeśli jest obsługiwana – numpy.complex) lub instancja dtype. Domyślnie numpy.float.

Funkcja fabryczna numpy.array jest zwyczajowym sposobem tworzenia obiektu ndarray; przekazuje ona wywołanie do tego konstruktora.

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

Zamienia kolejność bajtów w każdym elemencie. W przypadku tablic uint16, int16, float i complex odwraca to kolejność bajtów w obrębie każdego elementu, co jest przydatne podczas odczytu danych z urządzeń peryferyjnych, których endianowość nie odpowiada endianowości mikrokontrolera. W przypadku jednobajtowych typów dtype (bool, uint8, int8) jest to operacja pusta, zwracająca widok lub kopię.

Jeśli inplace ma wartość False (domyślnie), zwracany jest nowy obiekt ndarray, a oryginał pozostaje nietknięty. Jeśli inplace ma wartość True, bajty obiektu self są zamieniane w miejscu i zwracany jest widok obiektu self.

copy() → ndarray

Zwraca nową, gęstą, głęboką kopię tablicy. Kopia jest właścicielem własnych danych; jej modyfikacje nie wpływają na oryginał.

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

Zwraca nową, jednowymiarową kopię tablicy.

Parametry:

order – 'C' (domyślnie) przechodzi dane w kolejności C (ostatnia oś zmienia się najszybciej); 'F' przechodzi je w kolejności Fortran (pierwsza oś zmienia się najszybciej).

reshape(shape: int | tuple[int, ...]) → ndarray

Zwraca widok tablicy o nowym kształcie. Całkowita liczba elementów musi pozostać niezmieniona, w przeciwnym razie zgłaszany jest wyjątek ValueError. Dostępne tylko, gdy ULAB_MAX_DIMS > 1. Równoważne przypisaniu do shape.

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

Sortuje tablicę w miejscu.

Parametry:

axis – Oś, wzdłuż której odbywa się sortowanie. -1 (domyślnie) sortuje wzdłuż ostatniej osi; None najpierw spłaszcza tablicę, a następnie ją sortuje.

tobytes() → bytearray

Zwraca obiekt bytearray będący aliasem bazowego bufora danych tablicy. Zapisy poprzez zwrócony bytearray modyfikują tablicę w miejscu. Zgłasza ValueError, jeśli tablica nie jest gęsta (np. jest wycinkiem-widokiem).

tolist() → list

Zwraca zawartość tablicy jako (potencjalnie zagnieżdżoną) Pythonową list. Głębokość zagnieżdżenia jest równa ndim.

transpose() → ndarray

Zwraca transpozycję tablicy (osie odwrócone). W przypadku tablic jednowymiarowych zwraca self. Dostępne tylko, gdy ULAB_MAX_DIMS > 1. Atrybut T jest skrótem do tej metody.

dtype: dtype | int

Typ danych elementów tablicy. Zwraca instancję dtype, gdy oprogramowanie układowe zostało zbudowane z włączoną opcją ULAB_HAS_DTYPE_OBJECT, w przeciwnym razie bazowy jednoznakowy kod typu jako liczbę całkowitą.

flat: flatiter

Płaski iterator, który zwraca każdy element tablicy w kolejności C. W przeciwieństwie do flatten(), iterowanie po flat nie alokuje nowej tablicy.

itemsize: int

Rozmiar pojedynczego elementu tablicy w bajtach, wyprowadzony z dtype.

ndim: int

Liczba wymiarów tablicy (długość shape).

shape: tuple[int, ...]

Długości tablicy wzdłuż każdej osi. Przypisanie krotki do shape zmienia kształt tablicy w miejscu (równoważne reshape()).

size: int

Całkowita liczba elementów w tablicy (iloczyn shape).

strides: tuple[int, ...]

Liczba bajtów, o jaką należy przesunąć się w pamięci wzdłuż każdej osi, aby dotrzeć do następnego elementu wzdłuż tej osi.

T: ndarray

Transpozycja tablicy; równoważne transpose().

real: ndarray

Część rzeczywista tablicy zespolonej, zwracana jako ndarray typu float. W przypadku tablic rzeczywistych jest to kopia self o tym samym dtype. Dostępne tylko, gdy oprogramowanie układowe zostało zbudowane z obsługą liczb zespolonych.

imag: ndarray

Część urojona tablicy zespolonej, zwracana jako ndarray typu float. W przypadku tablic rzeczywistych jest to tablica zer o tym samym dtype co self. Dostępne tylko, gdy oprogramowanie układowe zostało zbudowane z obsługą liczb zespolonych.

Obsługiwane operatory

Instancje ndarray obsługują następujące operatory. Operatory binarne rozszerzają (broadcast) swoje argumenty zgodnie ze standardowymi regułami rozszerzania numpy oraz stosują reguły rozszerzania typu (upcasting) numpy (np. uint8 + int8 => int16, uint16 + int16 => float); operacje z udziałem argumentu zespolonego dają wynik zespolony.

Arytmetyczne (binarne): +, -, *, /, //, %, **. Obsługiwane są również odbite (prawostronne) argumenty oraz warianty w miejscu +=, -=, *=, /=, %=, **=. Akceptowane są zarówno formy ndarray-z-ndarray, jak i ndarray-ze-skalarem. Dzielenie całkowite (//) oraz operator modulo (%) nie są zaimplementowane dla tablic complex.

Porównania: ==, !=, <, <=, >, >=. Każdy zwraca logiczny ndarray o rozszerzonym kształcie.

Bitowe (tylko tablice całkowite): &, |, ^. Zastosowanie ich do tablicy float lub complex zgłasza TypeError.

Jednoargumentowe: + (zwraca kopię), - (negacja; dla typów bez znaku wartości zawijają się modulo \(2^N\)), abs() (wartość bezwzględna element po elemencie; dla typów bez znaku zwraca kopię bez obliczeń), ~ (inwersja bitowa, tylko typy całkowite), len() (zwraca długość pierwszej osi).

Indeksowanie i wycinanie: a[i], a[i, j, ...], a[start:stop:step], indeksowanie maską logiczną (a[mask]) oraz indeksowanie tablicą całkowitą (fancy indexing) są obsługiwane zarówno przy odczycie, jak i zapisie.

Iteracja: Iterowanie po ndarray zwraca podtablice wzdłuż pierwszej osi (po jednym elemencie naraz w przypadku tablic 1-W). Użyj flat, aby iterować po każdym elemencie skalarnym niezależnie od wymiarowości.

Operator mnożenia macierzowego @ nie jest zaimplementowany; zamiast niego użyj numpy.dot (np.dot(a, b)).

Operatory przesunięcia (<<, >>) nie są zaimplementowane na poziomie operatorów. Użyj numpy.left_shift i numpy.right_shift do bitowych przesunięć całkowitych element po elemencie.

Tworzenie tablic

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray

Tworzy nowy ndarray z zagnieżdżonego iterowalnego obiektu liczb. Równoważny alternatywny konstruktor dla numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray

Zwraca równomiernie rozmieszczone wartości w przedziale półotwartym [start, stop). Jeśli podano tylko jeden argument pozycyjny, jest on traktowany jako stop przy start = 0. Jeśli pominięto dtype, jest on wnioskowany na podstawie danych wejściowych (całkowity, jeśli wszystkie start, stop, step są liczbami całkowitymi i mieszczą się w zakresie).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray

Jeśli a jest już obiektem ndarray, którego dtype odpowiada dtype (lub dtype ma wartość None), zwraca a bez zmian; w przeciwnym razie tworzy nową tablicę (z żądaną konwersją dtype, gdy ją podano). Obiekty iterowalne są konwertowane tak jak w numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray

Łączy sekwencję obiektów ndarray wzdłuż istniejącej osi axis. Wszystkie tablice wejściowe muszą mieć ten sam dtype, ndim oraz kształt na każdej osi innej niż axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray

Dla dwuwymiarowego a zwraca tablicę 1-W zawierającą k-tą przekątną. Dla jednowymiarowego a zwraca dwuwymiarową tablicę kwadratową z a umieszczonym na k-tej przekątnej. k może być dodatnie (powyżej głównej przekątnej) lub ujemne (poniżej).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray

Alias dla zeros; zwraca tablicę wypełnioną zerami o kształcie shape i typie dtype. (ulab nie pozostawia bufora niezainicjalizowanego).

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray

Zwraca dwuwymiarową tablicę N x M (kwadratową N x N, jeśli M ma wartość None) z jedynkami na k-tej przekątnej i zerami w pozostałych miejscach.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray

Interpretuje obiekt zgodny z protokołem buforowym jako jednowymiarowy ndarray typu dtype. count to liczba elementów do odczytania (-1 odczytuje wszystkie dostępne elementy); offset pomija tyle bajtów na początku bufora.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray

Zwraca nową tablicę o kształcie shape i typie dtype z każdym elementem ustawionym 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]

Zwraca num równomiernie rozmieszczonych próbek w przedziale domkniętym [start, stop] (lub półotwartym, jeśli endpoint ma wartość False). Gdy retstep ma wartość True, zwraca krotkę (samples, step). Zespolone start/stop dają tablicę zespoloną (gdy obsługa liczb zespolonych jest włączona).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray

Zwraca num próbek rozmieszczonych równomiernie w skali logarytmicznej: wynik zaczyna się od base ** start, a kończy na base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]

Zwraca krotkę macierzy współrzędnych z sekwencji jednowymiarowych tablic współrzędnych. Przy indexing 'xy' (domyślnie) pierwsze dwa wejścia są traktowane jako współrzędne kartezjańskie, a ich osie wyjściowe są zamieniane; przy 'ij' używane jest indeksowanie macierzowe. Implementacja odpowiada odpowiednikowi NumPy z copy=True i sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray

Zwraca nową tablicę o kształcie shape i typie dtype wypełnioną jedynkami.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray

Zwraca nową tablicę o kształcie shape i typie dtype wypełnioną zerami.

Inspekcja / drukowanie

numpy.get_printoptions() → dict

Zwraca bieżące opcje drukowania tablic jako słownik z kluczami threshold i edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None

Ustawia opcje drukowania tablic. threshold to maksymalna liczba elementów tablicy drukowanych w całości; edgeitems to liczba elementów pokazywanych na każdym końcu osi, gdy tablica jest skracana.

numpy.ndinfo(array: ndarray) → None

Drukuje informacje diagnostyczne (kształt, kroki, dtype, itemsize, …) o tablicy array.

numpy.size(a: ndarray, *, axis: int | None = None) → int

Zwraca liczbę elementów a wzdłuż osi axis; jeśli axis ma wartość None, zwraca całkowitą liczbę elementów (iloczyn ndarray.shape).

Porównanie

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float

Przycina wartości a tak, aby a_min <= result <= a_max. Równoważne maximum(a_min, minimum(a, a_max)); rozszerzanie (broadcasting) podlega tym samym regułom co minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool

x1 == x2 element po elemencie; zwraca logiczny ndarray (lub skalar bool, jeśli oba wejścia są skalarami). Dostarczone dla przenośności – operator == na tablicach daje ten sam wynik.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool

x1 != x2 element po elemencie; logiczny odpowiednik equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool

Zwraca tablicę logiczną (lub skalar), która ma wartość True tam, gdzie wejście jest skończone. Wejścia całkowite są zawsze skończone.

numpy.isinf(x: ndarray | int | float) → ndarray | bool

Zwraca tablicę logiczną (lub skalar), która ma wartość True tam, gdzie wejście jest nieskończone. Wejścia całkowite nigdy nie są nieskończone.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float

Maksimum dwóch tablic / skalarów element po elemencie. Argumenty są rozszerzane razem (broadcast); jeśli typy dtype się różnią, wynik jest rozszerzany do typu nadrzędnego (upcast).

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float

Minimum dwóch tablic / skalarów element po elemencie; odpowiednik maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]

Zwraca krotkę obiektów ndarray, po jednym na każdy wymiar a, zawierających indeksy niezerowych elementów a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray

Zwraca ndarray, którego elementy pochodzą z x tam, gdzie condition jest prawdziwe, a w przeciwnym razie z y. Trzy wejścia są rozszerzane razem (broadcast); dtype wyniku to typ nadrzędny x i y.

Redukcje numeryczne

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool

Sprawdza, czy wszystkie elementy wzdłuż osi axis przyjmują wartość True. Przy axis=None (domyślnie) testowana jest spłaszczona tablica i zwracany jest pojedynczy bool.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool

Sprawdza, czy którykolwiek element wzdłuż osi axis przyjmuje wartość True. Przy axis=None testowana jest spłaszczona tablica.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int

Zwraca indeks elementu maksymalnego wzdłuż osi axis. Przy axis=None tablica jest spłaszczana i zwracana jest pojedyncza liczba całkowita.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int

Zwraca indeks elementu minimalnego wzdłuż osi axis. Przy axis=None tablica jest spłaszczana i zwracana jest pojedyncza liczba całkowita.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray

Zwraca ndarray całkowitych indeksów bez znaku, których wpisy sortują a w kolejności rosnącej wzdłuż osi axis. Wyjściowy dtype to uint16, więc żadna oś nie może przekroczyć 65535 elementów. axis=None nie jest obsługiwane.

numpy.cross(a: ndarray, b: ndarray) → ndarray

Zwraca iloczyn wektorowy dwóch tablic 1-W o długości 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray

Zwraca n-tą dyskretną różnicę progresywną a wzdłuż osi axis. n musi mieścić się w 0..9 (szablon różnicowania jest przechowywany jako int8); długość osi axis zmniejsza się o n. Słowa kluczowe numpy prepend i append nie są zaimplementowane.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray

Zwraca nową tablicę z odwróconą kolejnością elementów wzdłuż osi axis; przy axis=None tablica jest odwracana wzdłuż każdej osi.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float

Zwraca element maksymalny wzdłuż osi axis. Przy axis=None (domyślnie) spłaszczona tablica jest redukowana do skalara. Słowo kluczowe numpy out nie jest zaimplementowane.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float

Zwraca element minimalny wzdłuż osi axis; odpowiednik max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float

Zwraca średnią arytmetyczną wzdłuż osi axis. Przy axis=None (domyślnie) zwracana jest średnia spłaszczonej tablicy jako float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float

Zwraca medianę wzdłuż osi axis. Przy axis=None tablica jest najpierw spłaszczana. Wyjściowy dtype jest zawsze typu float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray

Zwraca a z elementami przewiniętymi (cyklicznie przesuniętymi) o shift pozycji. Przy axis=None (domyślnie) tablica jest najpierw spłaszczana. Ujemne przesunięcia przewijają w przeciwnym kierunku.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray

Zwraca posortowaną kopię a wzdłuż osi axis przy użyciu sortowania kopcowego. Przy axis=None tablica jest najpierw spłaszczana. Słowa kluczowe numpy kind i order nie są zaimplementowane.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float

Zwraca odchylenie standardowe wzdłuż osi axis. ddof to delta stopni swobody – użyty dzielnik to N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float

Zwraca sumę wzdłuż osi axis. Przy axis=None suma spłaszczonej tablicy jest zwracana jako skalar.

Statystyki

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray

Zlicza liczbę wystąpień każdej wartości w jednowymiarowej, nieujemnej całkowitej tablicy x. dtype x musi być uint8 lub uint16. Jeśli podano weights, każdy wpis x wnosi swoją odpowiadającą wagę zamiast 1, a wynik jest typu float; w przeciwnym razie wynik jest typu uint16. Jeśli podano minlength, tablica wyjściowa ma co najmniej tyle elementów (dodatkowe wpisy są zerowe).

numpy.trace(m: ndarray) → int | float

Zwraca sumę elementów na przekątnej kwadratowej macierzy m. Typ zwracany odpowiada dtype m (tablice całkowite dają int, tablice float dają float).

Transformacja

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray

Zwraca wycinki a wybrane wzdłuż osi axis przez logiczny warunek condition. Przy axis=None używana jest spłaszczona tablica.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray

Zwraca kopię a z usuniętymi wpisami o indeksach indices wzdłuż osi axis. Przy axis=None tablica jest najpierw spłaszczana. Ujemne indeksy liczone są od końca osi axis; indices jest wewnętrznie sortowane przed usunięciem.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float

Zwraca iloczyn skalarny dwóch tablic. Dla dwóch tablic 1-W jest to iloczyn wewnętrzny (skalar float). Dla tablic 2-W jest to mnożenie macierzowe; wymiary wewnętrzne muszą się zgadzać. Wynik jest zawsze typu float.

Aproksymacja

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray

Jednowymiarowa interpolacja liniowa. xp musi być monotonicznie rosnącą tablicą 1-W wartości niezależnych; fp zawiera odpowiadające wartości zależne; x to punkty, w których obliczana jest funkcja interpolująca. left i right nadpisują wartość zwracaną odpowiednio dla x < xp[0] i x > xp[-1] (wartości domyślne: fp[0] i fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float

Całkuje y przy użyciu złożonej reguły trapezów. Jeśli podano x, dostarcza ono pozycje próbek odpowiadające y; w przeciwnym razie używany jest odstęp dx. y (i x) muszą być 1-W.

Wybór

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray

Pobiera elementy z a o podanych indeksach indices wzdłuż osi axis. Przy axis=None używana jest spłaszczona tablica. mode wybiera zachowanie poza zakresem: "raise" (domyślnie – zgłasza ValueError), "wrap" (modulo długość osi) lub "clip" (przycięcie do prawidłowego zakresu; ujemne indeksy są niedozwolone). Jeśli podano out, wynik jest do niego zapisywany.

Operacje bitowe

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray

Bitowy AND dwóch tablic całkowitych element po elemencie; rozszerzanie (broadcasting) jest obsługiwane. Niecałkowity dtype zgłasza wyjątek.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray

Bitowy OR dwóch tablic całkowitych element po elemencie.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray

Bitowy XOR dwóch tablic całkowitych element po elemencie.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray

Bitowe przesunięcie x1 w lewo o x2 bitów element po elemencie; obie tablice muszą mieć całkowity dtype.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray

Bitowe przesunięcie x1 w prawo o x2 bitów element po elemencie; obie tablice muszą mieć całkowity dtype.

Filtrowanie

numpy.convolve(a: ndarray, v: ndarray) → ndarray

Zwraca dyskretną liniową konwolucję dwóch tablic 1-W. Obsługiwany jest tylko tryb "full"; słowo kluczowe numpy mode nie jest akceptowane (inne tryby można uzyskać przez wycinanie pełnego wyniku). Długość wyniku wynosi len(a) + len(v) - 1.

Wielomiany

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

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

Dopasowuje wielomian stopnia deg do punktów danych (x, y) metodą najmniejszych kwadratów i zwraca współczynniki wielomianu (najwyższy stopień jako pierwszy). Jeśli pominięto x, używane jest range(len(y)). Zgłasza ValueError, jeśli długości x i y się różnią.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float

Oblicza wartość wielomianu o współczynnikach p (najwyższy stopień jako pierwszy) w punkcie x. Jeśli x jest skalarem, zwracany jest float, w przeciwnym razie ndarray.

I/O

numpy.load(file: str) → ndarray

Odczytuje tablicę zapisaną wcześniej za pomocą save z pliku file (niezależny od platformy format .npy numpy). Endianowość jest konwertowana w locie, jeśli kolejność bajtów pliku różni się od kolejności hosta.

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

Odczytuje dane liczbowe z tekstowego pliku file i zwraca je jako ndarray. delimiter domyślnie to białe znaki; comments to znacznik komentarza liniowego; max_rows ogranicza liczbę odczytywanych wierszy danych (-1 dla wszystkich); usecols wybiera kolumny według indeksu; skiprows pomija tyle początkowych wierszy. Jeśli dtype nie jest typu float, wartości są konwertowane przez zaokrąglanie.

numpy.save(file: str, a: ndarray) → None

Zapisuje a do pliku file w niezależnym od platformy formacie .npy numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None

Zapisuje a do pliku file jako tekst. delimiter oddziela wartości w obrębie wiersza; header i footer, jeśli podano, są zapisywane przed/po danych, każdy poprzedzony przez comments. Wartości są zapisywane jako zmiennoprzecinkowe.

Funkcje pomocnicze dla liczb zespolonych

Te funkcje są dostępne tylko, gdy ulab został skompilowany z obsługą liczb zespolonych (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray

Zwraca część rzeczywistą val. Dla wejścia o rzeczywistym dtype zwraca kopię zachowującą dtype; dla wejścia zespolonego zwraca ndarray typu float.

numpy.imag(val: ndarray) → ndarray

Zwraca część urojoną val. Dla wejścia o rzeczywistym dtype zwraca tablicę zer o tym samym dtype; dla wejścia zespolonego zwraca ndarray typu float.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float

Zwraca sprzężenie zespolone val. Wejścia o wartościach rzeczywistych są zwracane bez zmian.

numpy.sort_complex(a: ndarray) → ndarray

Sortuje tablicę 1-W a najpierw według części rzeczywistej, a następnie według części urojonej. Wynik jest zawsze typu zespolonego, nawet jeśli a miało wartości rzeczywiste.

Funkcje uniwersalne

Funkcje matematyczne wykonywane element po elemencie. Każda przyjmuje skalar lub ndarray i zwraca wynik o pasującym kształcie (skalar float dla wejścia skalarnego, ndarray dla wejścia tablicowego). Wywołana z ndarray zwraca nowy zmiennoprzecinkowy ndarray; opcjonalnie można przekazać słowo kluczowe out, aby zapisać wynik do uprzednio zaalokowanego ndarray typu float o tym samym rozmiarze.

numpy.acos(x: ndarray | float, /) → ndarray | float

Oblicza odwrotny cosinus (arcus cosinus) każdego elementu x; wynik jest w radianach.

numpy.acosh(x: ndarray | float, /) → ndarray | float

Oblicza odwrotny cosinus hiperboliczny każdego elementu x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float

Oblicza dwuargumentowy odwrotny tangens atan2(y, x) element po elemencie; obsługuje rozszerzanie (broadcasting) między dwoma wejściami.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray

Zaokrągla elementy ndarray x do podanej liczby miejsc dziesiętnych decimals; pierwszy argument musi być obiektem ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float

Oblicza odwrotny sinus (arcus sinus) każdego elementu x; wynik jest w radianach.

numpy.asinh(x: ndarray | float, /) → ndarray | float

Oblicza odwrotny sinus hiperboliczny każdego elementu x.

numpy.atan(x: ndarray | float, /) → ndarray | float

Oblicza odwrotny tangens (arcus tangens) każdego elementu x; wynik jest w radianach.

numpy.atanh(x: ndarray | float, /) → ndarray | float

Oblicza odwrotny tangens hiperboliczny każdego elementu x.

numpy.ceil(x: ndarray | float, /) → ndarray | float

Oblicza sufit (najmniejszą liczbę całkowitą nie mniejszą od wartości) każdego elementu x.

numpy.cos(x: ndarray | float, /) → ndarray | float

Oblicza cosinus każdego elementu x (w radianach).

numpy.cosh(x: ndarray | float, /) → ndarray | float

Oblicza cosinus hiperboliczny każdego elementu x.

numpy.degrees(x: ndarray | float, /) → ndarray | float

Konwertuje każdy element x z radianów na stopnie.

numpy.exp(x: ndarray | float, /) → ndarray | float

Oblicza funkcję wykładniczą e**x każdego elementu x; może zwrócić zespolony ndarray, gdy podano wejście zespolone (jeśli obsługa liczb zespolonych jest włączona).

numpy.expm1(x: ndarray | float, /) → ndarray | float

Oblicza exp(x) - 1 każdego elementu x z poprawioną precyzją w pobliżu zera.

numpy.floor(x: ndarray | float, /) → ndarray | float

Oblicza podłogę (największą liczbę całkowitą nie większą od wartości) każdego elementu x.

numpy.log(x: ndarray | float, /) → ndarray | float

Oblicza logarytm naturalny każdego elementu x.

numpy.log10(x: ndarray | float, /) → ndarray | float

Oblicza logarytm o podstawie 10 każdego elementu x.

numpy.log2(x: ndarray | float, /) → ndarray | float

Oblicza logarytm o podstawie 2 każdego elementu x.

numpy.radians(x: ndarray | float, /) → ndarray | float

Konwertuje każdy element x ze stopni na radiany.

numpy.sin(x: ndarray | float, /) → ndarray | float

Oblicza sinus każdego elementu x (w radianach).

numpy.sinc(x: ndarray | float, /) → ndarray | float

Oblicza znormalizowaną funkcję sinc sin(pi*x) / (pi*x) każdego elementu x.

numpy.sinh(x: ndarray | float, /) → ndarray | float

Oblicza sinus hiperboliczny każdego elementu x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float

Oblicza pierwiastek kwadratowy każdego elementu x; przekaż dtype=numpy.complex, aby uzyskać wyniki zespolone dla ujemnych wejść rzeczywistych (jeśli obsługa liczb zespolonych jest włączona).

numpy.tan(x: ndarray | float, /) → ndarray | float

Oblicza tangens każdego elementu x (w radianach).

numpy.tanh(x: ndarray | float, /) → ndarray | float

Oblicza tangens hiperboliczny każdego elementu x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable

Zwraca obiekt wywoływalny, który stosuje Pythonową funkcję f element po elemencie do skalara, obiektu iterowalnego lub ndarray; otypes wybiera wyjściowy dtype (domyślnie float).

Stałe

numpy.e: float

Liczba Eulera \(e \approx 2.71828\).

numpy.pi: float

\(\pi \approx 3.14159\).

numpy.inf: float

Zmiennoprzecinkowa dodatnia nieskończoność IEEE-754.

numpy.nan: float

Zmiennoprzecinkowe „nie-liczba” (NaN) IEEE-754.

numpy.bool: int

Kod dtype dla tablic logicznych (przechowywanych jako uint8).

numpy.uint8: int

Kod dtype dla tablic całkowitych 8-bitowych bez znaku.

numpy.int8: int

Kod dtype dla tablic całkowitych 8-bitowych ze znakiem.

numpy.uint16: int

Kod dtype dla tablic całkowitych 16-bitowych bez znaku.

numpy.int16: int

Kod dtype dla tablic całkowitych 16-bitowych ze znakiem.

numpy.float: int

Kod dtype dla tablic zmiennoprzecinkowych 32-bitowych.