`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ą z całkowitoliczbowych stałych wystawionych na poziomie modułu: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 i numpy.float (domyślnie). Typ wyniku ndarray odnosi się do numpy.ndarray.

Podmoduły#

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 elementu dla nowej tablicy. Jedna z całkowitoliczbowych wartości kodu typu wystawionych przez numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 i numpy.float) 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 każdego elementu. W tablicach uint16, int16 i float odwraca to kolejność bajtów poszczególnych elementów, co jest przydatne przy przetwarzaniu danych z peryferiów o kolejności bajtów niezgodnej z mikrokontrolerem. Dla jednobajtowych typów (bool, uint8, int8) jest to operacja pusta, która zwraca 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().

Obsługiwane operatory#

Instancje ndarray obsługują następujące operatory. Operatory binarne rozgłaszają swoje operandy zgodnie ze standardowymi regułami rozgłaszania numpy i stosują się do reguł rzutowania numpy (np. uint8 + int8 => int16, uint16 + int16 => float).

Arytmetyka (binarna): +, -, *, /, //, %, **. Obsługiwane są również odwrócone (prawostronnych) operandy i warianty w miejscu +=, -=, *=, /=, %=, **=. Akceptowane są zarówno formy ndarray-z-ndarray, jak i ndarray-ze-skalarem.

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

Bitowe (tylko tablice całkowitoliczbowe): &, |, ^. Zastosowanie ich do tablicy float 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 na zamkniętym przedziale [start, stop] (lub półotwartym, jeśli endpoint wynosi False). Gdy retstep wynosi True, zwraca krotkę (samples, step).

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 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 eksponentę e**x każdego elementu x.

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.

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.

numpy — operacje na tablicach zgodne z numpy#