`numpy` --- operasi array yang kompatibel dengan numpy#

Submodul numpy dari ulab menyediakan API yang kompatibel dengan numpy yang dibangun di sekitar tipe array n-dimensi ndarray. Ini mengimplementasikan subset terpilih dari CPython numpy: konstruksi array, operasi matematika per-elemen, reduksi dan statistik, aljabar linear, FFT, pembangkitan bilangan acak, pencocokan polinomial, dan I/O dasar.

Submodul ini secara konvensional diimpor sebagai 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)))

Setiap argumen dtype adalah salah satu konstanta integer yang diekspos di tingkat modul: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, dan numpy.float (default). Tipe hasil ndarray merujuk ke numpy.ndarray.

Submodul#

kelas `ndarray` --- array n-dimensi#

ndarray adalah kontainer n-dimensi yang sadar dtype sebagai inti dari numpy / ulab. Data disimpan dalam blok yang berdekatan yang interpretasinya dijelaskan oleh header kecil (dtype, shape, strides, ndim, itemsize). Banyak operasi -- reshape, transpose, slicing -- hanya menyesuaikan header ini sehingga sangat murah; metode yang mengalokasikan penyimpanan baru (copy, flatten, sebagian besar aritmatika) mengembalikan array padat baru.

Tipe yang sama dapat diakses sebagai ulab.ndarray, numpy.ndarray, dan (dalam halaman ini) cukup ndarray.

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

Buat ndarray baru.

Parameter:

values -- Data sumber. Bisa berupa ndarray lain (yang disalin secara mendalam, dengan konversi tipe jika dtype berbeda) atau iterable MicroPython apa pun. Iterable bersarang menghasilkan array multidimensi; iterable dalam harus semua memiliki panjang yang sama, atau ValueError akan dimunculkan.
dtype -- Tipe elemen untuk array baru. Salah satu integer kode tipe yang diekspos oleh numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, dan numpy.float), atau instans dtype. Default ke numpy.float.

Fungsi pabrik numpy.array adalah cara konvensional untuk membuat ndarray; fungsi ini meneruskan ke konstruktor ini.

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

Menukar urutan byte setiap elemen. Untuk array uint16, int16, dan float, ini membalik urutan byte per elemen, yang berguna saat mengonsumsi data dari periferal yang endiannessnya tidak cocok dengan mikrokontroler. Untuk dtype satu byte (bool, uint8, int8) ini adalah no-op yang mengembalikan tampilan atau salinan.

Jika inplace adalah False (default), ndarray baru dikembalikan dan array asli tidak tersentuh. Jika inplace adalah True, byte dari self ditukar di tempat dan view dari self dikembalikan.

copy() → ndarray#: Kembalikan salinan padat dan mendalam baru dari array. Salinan memiliki datanya sendiri; modifikasi pada salinan tidak mempengaruhi array asli.

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

Kembalikan salinan satu-dimensi baru dari array.

Parameter:: order -- 'C' (default) membaca data dalam urutan C (sumbu terakhir bervariasi paling cepat); 'F' membacanya dalam urutan Fortran (sumbu pertama bervariasi paling cepat).

reshape(shape: int | tuple[int, ...]) → ndarray#: Kembalikan view dari array dengan bentuk baru. Total jumlah elemen harus tidak berubah, atau ValueError akan dimunculkan. Hanya tersedia ketika ULAB_MAX_DIMS > 1. Setara dengan penugasan ke shape.

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

Urutkan array di tempat.

Parameter:: axis -- Sumbu tempat pengurutan. -1 (default) mengurutkan sepanjang sumbu terakhir; None pertama meratakan array dan kemudian mengurutkan.

tobytes() → bytearray#: Kembalikan bytearray yang mengalias buffer data underlying array. Penulisan melalui bytearray yang dikembalikan memodifikasi array di tempat. Memunculkan ValueError jika array tidak padat (misalnya, view yang diiris).

tolist() → list#: Kembalikan isi array sebagai list Python (mungkin bersarang). Kedalaman penyarangan sama dengan ndim.

transpose() → ndarray#: Kembalikan transpos dari array (sumbu dibalik). Untuk array satu-dimensi, ini mengembalikan self. Hanya tersedia ketika ULAB_MAX_DIMS > 1. Atribut T adalah singkatan untuk metode ini.

dtype: dtype | int#: Tipe data elemen array. Mengembalikan instance dtype ketika firmware dibangun dengan ULAB_HAS_DTYPE_OBJECT diaktifkan, jika tidak, kode tipe karakter tunggal yang mendasari sebagai integer.

flat: flatiter#: Iterator datar yang menghasilkan setiap elemen array dalam urutan C. Berbeda dengan flatten(), iterasi flat tidak mengalokasikan array baru.

itemsize: int#: Ukuran dalam byte dari satu elemen array, diturunkan dari dtype.

ndim: int#: Jumlah dimensi array (panjang dari shape).

shape: tuple[int, ...]#: Panjang array sepanjang setiap sumbu. Menetapkan tuple ke shape membentuk ulang array di tempat (setara dengan reshape()).

size: int#: Total jumlah elemen dalam array (hasil perkalian dari shape).

strides: tuple[int, ...]#: Jumlah byte untuk melangkah dalam memori sepanjang setiap sumbu guna mencapai elemen berikutnya di sepanjang sumbu tersebut.

T: ndarray#: Transpos dari array; setara dengan transpose().

Operator yang didukung#

Instans ndarray mendukung operator-operator berikut. Operator biner menyiarkan operan mereka mengikuti aturan penyiaran numpy standar dan mengikuti aturan upcasting numpy (misalnya uint8 + int8 => int16, uint16 + int16 => float).

Aritmetika (biner): +, -, *, /, //, %, **. Operan yang tercermin (sisi kanan) dan varian di-tempat +=, -=, *=, /=, %=, **= juga didukung. Baik bentuk ndarray-dengan-ndarray maupun ndarray-dengan-skalar diterima.

Perbandingan: ==, !=, <, <=, >, >=. Masing-masing mengembalikan ndarray boolean dari bentuk yang disiarkan.

Bitwise (hanya array integer): &, |, ^. Menerapkan ini ke array float akan memunculkan TypeError.

Unary: + (mengembalikan salinan), - (negasi; pada dtype unsigned nilainya membungkus modulo \(2^N\)), abs() (nilai absolut per-elemen; pada dtype unsigned mengembalikan salinan tanpa komputasi), ~ (inversi bitwise, hanya dtype integer), len() (mengembalikan panjang sumbu pertama).

Pengindeksan dan slicing: a[i], a[i, j, ...], a[start:stop:step], pengindeksan boolean-mask (a[mask]) dan pengindeksan array integer (fancy) semuanya didukung pada pembacaan dan penulisan.

Iterasi: Iterasi atas ndarray menghasilkan sub-array sepanjang sumbu pertama (satu elemen pada satu waktu untuk array 1-D). Gunakan flat untuk iterasi atas setiap elemen skalar tanpa mempertimbangkan dimensi.

Operator perkalian matriks @ tidak diimplementasikan; gunakan numpy.dot (np.dot(a, b)) sebagai gantinya.

Operator geser (<<, >>) tidak diimplementasikan di tingkat operator. Gunakan numpy.left_shift dan numpy.right_shift untuk geser integer per-elemen.

Konstruksi array#

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray#: Konstruksi ndarray baru dari iterable bersarang berisi angka. Konstruktor alternatif yang setara untuk numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray#: Kembalikan nilai yang tersebar merata dalam interval setengah terbuka [start, stop). Jika hanya satu argumen posisional yang diberikan, itu diperlakukan sebagai stop dengan start = 0. Jika dtype dihilangkan, itu disimpulkan dari input (integer jika semua start, stop, step adalah int dan dalam rentang).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray#: Jika a sudah merupakan ndarray yang dtype-nya cocok dengan dtype (atau dtype adalah None), kembalikan a tanpa perubahan; jika tidak, buat array baru (dengan konversi dtype yang diminta bila diberikan). Iterable dikonversi seperti di numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray#: Gabungkan urutan ndarray sepanjang axis yang ada. Semua array input harus berbagi dtype, ndim, dan shape yang sama pada setiap sumbu selain axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray#: Untuk a 2-D, kembalikan array 1-D yang berisi diagonal ke-k. Untuk a 1-D, kembalikan array persegi 2-D dengan a ditempatkan pada diagonal ke-k. k bisa positif (di atas diagonal utama) atau negatif (di bawah).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Alias untuk zeros; mengembalikan array berisi nol dari shape dan dtype. (ulab tidak meninggalkan buffer tidak diinisialisasi.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray#: Kembalikan array N x M 2-D (persegi N x N jika M adalah None) dengan satu pada diagonal ke-k dan nol di tempat lain.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray#: Interpretasikan objek protokol-buffer sebagai ndarray 1-D dari dtype. count adalah jumlah item yang dibaca (-1 membaca semua item yang tersedia); offset melewati banyak byte di awal buffer.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray#: Kembalikan array baru dari shape dan dtype dengan setiap elemen diatur ke fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]#: Mengembalikan num sampel yang berjarak sama pada interval tertutup [start, stop] (atau setengah terbuka jika endpoint adalah False). Ketika retstep adalah True, mengembalikan tupel (samples, step).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray#: Kembalikan num sampel yang tersebar merata pada skala log: hasilnya dimulai dari base ** start dan berakhir pada base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]#: Kembalikan tuple matriks koordinat dari urutan array koordinat satu-dimensi. Dengan indexing 'xy' (default), dua input pertama diperlakukan sebagai koordinat Kartesius dan sumbu outputnya ditukar; dengan 'ij' pengindeksan gaya matriks digunakan. Implementasi ini sesuai dengan ekuivalen NumPy dengan copy=True dan sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Kembalikan array baru dari shape dan dtype yang diisi dengan satu.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: Kembalikan array baru dari shape dan dtype yang diisi dengan nol.

Inspeksi / pencetakan#

numpy.get_printoptions() → dict#: Kembalikan opsi pencetakan array saat ini sebagai dict dengan kunci threshold dan edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None#: Atur opsi pencetakan array. threshold adalah jumlah maksimum elemen array yang dicetak secara penuh; edgeitems adalah jumlah item yang ditampilkan di setiap ujung sumbu ketika array diringkas.

numpy.ndinfo(array: ndarray) → None#: Cetak informasi diagnostik (shape, strides, dtype, itemsize, ...) tentang array.

numpy.size(a: ndarray, *, axis: int | None = None) → int#: Kembalikan jumlah elemen dari a sepanjang axis; jika axis adalah None, kembalikan jumlah total elemen (hasil perkalian dari ndarray.shape).

Perbandingan#

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float#: Klip nilai a sehingga a_min <= result <= a_max. Setara dengan maximum(a_min, minimum(a, a_max)); penyiaran mengikuti aturan yang sama dengan minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool#: Per-elemen x1 == x2; mengembalikan ndarray boolean (atau skalar bool jika kedua input adalah skalar). Disediakan untuk portabilitas -- operator == pada array memberikan hasil yang sama.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool#: Per-elemen x1 != x2; pasangan boolean dari equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool#: Kembalikan array boolean (atau skalar) yang bernilai True di mana input adalah finite. Input integer selalu finite.

numpy.isinf(x: ndarray | int | float) → ndarray | bool#: Kembalikan array boolean (atau skalar) yang bernilai True di mana input adalah infinite. Input integer tidak pernah infinite.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: Maksimum per-elemen dari dua array / skalar. Argumen disiarkan bersama; jika dtype berbeda, output di-upcast.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: Minimum per-elemen dari dua array / skalar; pasangan dari maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]#: Kembalikan tuple ndarray, satu per dimensi dari a, yang berisi indeks elemen non-nol dari a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray#: Kembalikan ndarray yang elemennya berasal dari x di mana condition bernilai truthy, dan dari y sebaliknya. Tiga input disiarkan bersama; dtype output adalah upcast dari x dan y.

Reduksi numerik#

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool#: Uji apakah semua elemen sepanjang axis bernilai True. Dengan axis=None (default), array yang diratakan diuji dan satu bool dikembalikan.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool#: Uji apakah ada elemen sepanjang axis yang bernilai True. Dengan axis=None, array yang diratakan diuji.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int#: Kembalikan indeks elemen maksimum sepanjang axis. Dengan axis=None, array diratakan dan satu integer dikembalikan.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int#: Kembalikan indeks elemen minimum sepanjang axis. Dengan axis=None, array diratakan dan satu integer dikembalikan.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray#: Kembalikan ndarray indeks integer tidak bertanda yang entrinya mengurutkan a dalam urutan menaik sepanjang axis. Dtype output adalah uint16, sehingga tidak ada sumbu yang boleh melebihi 65535 elemen. axis=None tidak didukung.

numpy.cross(a: ndarray, b: ndarray) → ndarray#: Kembalikan hasil kali silang dari dua array 1-D dengan panjang 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray#: Kembalikan perbedaan maju diskret ke-n dari a sepanjang axis. n harus dalam rentang 0..9 (stensil diferensiasi disimpan dalam int8); panjang axis berkurang sebesar n. Kata kunci numpy prepend dan append tidak diimplementasikan.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray#: Kembalikan array baru dengan urutan elemen yang dibalik sepanjang axis; dengan axis=None array dibalik sepanjang setiap sumbu.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Kembalikan elemen maksimum sepanjang axis. Dengan axis=None (default), array yang diratakan direduksi menjadi skalar. Kata kunci numpy out tidak diimplementasikan.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Kembalikan elemen minimum sepanjang axis; pasangan dari max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float#: Kembalikan rata-rata aritmatika sepanjang axis. Dengan axis=None (default), rata-rata array yang diratakan dikembalikan sebagai float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float#: Kembalikan median sepanjang axis. Dengan axis=None, array diratakan terlebih dahulu. Dtype output selalu float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray#: Kembalikan a dengan elemennya digulung (digeser secara siklik) sebesar shift posisi. Dengan axis=None (default), array diratakan terlebih dahulu. Pergeseran negatif menggulung ke arah berlawanan.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray#: Kembalikan salinan a yang diurutkan sepanjang axis menggunakan heap sort. Dengan axis=None, array diratakan terlebih dahulu. Kata kunci numpy kind dan order tidak diimplementasikan.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float#: Kembalikan deviasi standar sepanjang axis. ddof adalah delta derajat kebebasan -- pembagi yang digunakan adalah N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: Kembalikan jumlah sepanjang axis. Dengan axis=None, total array yang diratakan dikembalikan sebagai skalar.

Statistik#

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray#: Hitung jumlah kemunculan setiap nilai dalam array integer non-negatif satu-dimensi x. Dtype x harus uint8 atau uint16. Jika weights diberikan, setiap entri x memberikan kontribusi sesuai bobotnya daripada 1 dan output bertype float; jika tidak, output bertype uint16. Jika minlength diberikan, array output memiliki setidaknya sebanyak elemen tersebut (entri ekstra bernilai nol).

numpy.trace(m: ndarray) → int | float#: Kembalikan jumlah elemen diagonal dari matriks persegi m. Tipe kembalian mengikuti dtype dari m (array integer menghasilkan int, array float menghasilkan float).

Transformasi#

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray#: Kembalikan irisan a yang dipilih sepanjang axis oleh condition boolean. Dengan axis=None, array yang diratakan digunakan.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray#: Kembalikan salinan a dengan entri pada indices dihapus sepanjang axis. Dengan axis=None, array diratakan terlebih dahulu. Indeks negatif dihitung dari akhir axis; indices diurutkan secara internal sebelum penghapusan.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float#: Kembalikan hasil kali titik dari dua array. Untuk dua array 1-D, ini adalah hasil kali dalam (skalar float). Untuk array 2-D, ini adalah perkalian matriks; dimensi dalam harus cocok. Hasilnya selalu bertype float.

Pendekatan#

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray#: Interpolasi linear satu-dimensi. xp harus berupa array 1-D yang meningkat secara monoton dari nilai-nilai independen; fp berisi nilai-nilai dependen yang bersesuaian; x adalah titik-titik di mana interpolan dievaluasi. left dan right mengganti nilai yang dikembalikan untuk x < xp[0] dan x > xp[-1] masing-masing (default: fp[0] dan fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float#: Integrasikan y menggunakan aturan trapesium komposit. Jika x diberikan, itu menyediakan posisi sampel yang bersesuaian dengan y; jika tidak, spasi dx digunakan. y (dan x) harus 1-D.

Seleksi#

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray#: Ambil elemen dari a pada indices yang diberikan sepanjang axis. Dengan axis=None, array yang diratakan digunakan. mode memilih perilaku di luar batas: "raise" (default -- munculkan ValueError), "wrap" (modulo panjang sumbu), atau "clip" (klip ke rentang valid; indeks negatif tidak diperbolehkan). Jika out diberikan, hasilnya ditulis ke dalamnya.

Bitwise#

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray#: Bitwise AND per-elemen dari dua array integer; penyiaran didukung. Dtype non-integer akan memunculkan pengecualian.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray#: Bitwise OR per-elemen dari dua array integer.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray#: Bitwise XOR per-elemen dari dua array integer.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray#: Geser bitwise per-elemen dari x1 ke kiri sebesar x2 bit; kedua array harus memiliki dtype integer.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray#: Geser bitwise per-elemen dari x1 ke kanan sebesar x2 bit; kedua array harus memiliki dtype integer.

Penyaringan#

numpy.convolve(a: ndarray, v: ndarray) → ndarray#: Kembalikan konvolusi linear diskret dari dua array 1-D. Hanya mode "full" yang didukung; kata kunci numpy mode tidak diterima (mode lain dapat diperoleh dengan mengiris hasil penuh). Panjang output adalah len(a) + len(v) - 1.

Polinomial#

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

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Cocokkan polinomial berderajat deg ke titik data (x, y) dengan kuadrat terkecil dan kembalikan koefisien polinomial (derajat tertinggi terlebih dahulu). Jika x dihilangkan, range(len(y)) digunakan. Memunculkan ValueError jika panjang x dan y berbeda.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float#: Evaluasi polinomial yang koefisiennya adalah p (derajat tertinggi terlebih dahulu) pada x. Jika x adalah skalar, float dikembalikan, jika tidak, ndarray.

I/O#

numpy.load(file: str) → ndarray#: Baca array yang sebelumnya ditulis dengan save dari file (format .npy platform-independen numpy). Endianness dikonversi saat proses jika urutan byte file berbeda dari host.

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#: Baca data numerik dari file teks dan kembalikan sebagai ndarray. delimiter default ke spasi putih; comments adalah penanda komentar baris; max_rows membatasi jumlah baris data yang dibaca (-1 untuk semua); usecols memilih kolom berdasarkan indeks; skiprows melewati banyak baris awal. Jika dtype bukan float, nilai dikonversi dengan pembulatan.

numpy.save(file: str, a: ndarray) → None#: Simpan a ke file dalam format .npy platform-independen numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None#: Tulis a ke file sebagai teks. delimiter memisahkan nilai dalam baris; header dan footer, jika disediakan, ditulis sebelum/sesudah data, masing-masing diawali oleh comments. Nilai ditulis sebagai floating point.

Fungsi universal#

Fungsi matematika per-elemen. Masing-masing menerima skalar atau ndarray dan mengembalikan hasil dengan bentuk yang sesuai (skalar float untuk input skalar, ndarray untuk input array). Ketika dipanggil dengan ndarray, hasilnya adalah ndarray floating point baru; kata kunci opsional out dapat diteruskan untuk menulis hasil ke ndarray float yang telah dialokasikan sebelumnya dengan ukuran yang sama.

numpy.acos(x: ndarray | float, /) → ndarray | float#: Hitung invers kosinus (arc kosinus) dari setiap elemen x; hasilnya dalam radian.

numpy.acosh(x: ndarray | float, /) → ndarray | float#: Hitung invers kosinus hiperbolik dari setiap elemen x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float#: Hitung invers tangen dua-argumen atan2(y, x) per-elemen; mendukung penyiaran antara dua input.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray#: Bulatkan elemen ndarray x ke jumlah decimals yang diberikan; argumen pertama harus berupa ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float#: Hitung invers sinus (arc sinus) dari setiap elemen x; hasilnya dalam radian.

numpy.asinh(x: ndarray | float, /) → ndarray | float#: Hitung invers sinus hiperbolik dari setiap elemen x.

numpy.atan(x: ndarray | float, /) → ndarray | float#: Hitung invers tangen (arc tangen) dari setiap elemen x; hasilnya dalam radian.

numpy.atanh(x: ndarray | float, /) → ndarray | float#: Hitung invers tangen hiperbolik dari setiap elemen x.

numpy.ceil(x: ndarray | float, /) → ndarray | float#: Hitung ceiling (integer terkecil yang tidak kurang dari nilai) dari setiap elemen x.

numpy.cos(x: ndarray | float, /) → ndarray | float#: Hitung kosinus dari setiap elemen x (dalam radian).

numpy.cosh(x: ndarray | float, /) → ndarray | float#: Hitung kosinus hiperbolik dari setiap elemen x.

numpy.degrees(x: ndarray | float, /) → ndarray | float#: Konversi setiap elemen x dari radian ke derajat.

numpy.exp(x: ndarray | float, /) → ndarray | float#: Menghitung eksponen e**x dari setiap elemen x.

numpy.expm1(x: ndarray | float, /) → ndarray | float#: Hitung exp(x) - 1 dari setiap elemen x dengan presisi yang ditingkatkan mendekati nol.

numpy.floor(x: ndarray | float, /) → ndarray | float#: Hitung floor (integer terbesar yang tidak lebih dari nilai) dari setiap elemen x.

numpy.log(x: ndarray | float, /) → ndarray | float#: Hitung logaritma natural dari setiap elemen x.

numpy.log10(x: ndarray | float, /) → ndarray | float#: Hitung logaritma basis-10 dari setiap elemen x.

numpy.log2(x: ndarray | float, /) → ndarray | float#: Hitung logaritma basis-2 dari setiap elemen x.

numpy.radians(x: ndarray | float, /) → ndarray | float#: Konversi setiap elemen x dari derajat ke radian.

numpy.sin(x: ndarray | float, /) → ndarray | float#: Hitung sinus dari setiap elemen x (dalam radian).

numpy.sinc(x: ndarray | float, /) → ndarray | float#: Hitung fungsi sinc ternormalisasi sin(pi*x) / (pi*x) dari setiap elemen x.

numpy.sinh(x: ndarray | float, /) → ndarray | float#: Hitung sinus hiperbolik dari setiap elemen x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float#: Menghitung akar kuadrat dari setiap elemen x.

numpy.tan(x: ndarray | float, /) → ndarray | float#: Hitung tangen dari setiap elemen x (dalam radian).

numpy.tanh(x: ndarray | float, /) → ndarray | float#: Hitung tangen hiperbolik dari setiap elemen x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable#: Kembalikan callable yang menerapkan fungsi Python f per-elemen ke skalar, iterable, atau ndarray; otypes memilih dtype output (default float).

Konstanta#

numpy.e: float#: Bilangan Euler \(e \approx 2.71828\).

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

numpy.inf: float#: IEEE-754 floating-point tak terhingga positif.

numpy.nan: float#: IEEE-754 floating-point "bukan sebuah angka".

numpy.bool: int#: Kode dtype untuk array boolean (disimpan sebagai uint8).

numpy.uint8: int#: Kode dtype untuk array integer 8-bit tidak bertanda.

numpy.int8: int#: Kode dtype untuk array integer 8-bit bertanda.

numpy.uint16: int#: Kode dtype untuk array integer 16-bit tidak bertanda.

numpy.int16: int#: Kode dtype untuk array integer 16-bit bertanda.

numpy.float: int#: Kode dtype untuk array floating-point 32-bit.

numpy --- operasi array yang kompatibel dengan numpy#