`numpy` --- các phép toán mảng tương thích numpy¶

Submodule numpy của ulab cung cấp API tương thích numpy được xây dựng xung quanh kiểu mảng n chiều ndarray. Nó thực thi một tập con được chọn lọc của numpy CPython: xây dựng mảng, toán học theo từng phần tử, rút gọn và thống kê, đại số tuyến tính, FFT, tạo số ngẫu nhiên, khớp đa thức và I/O cơ bản.

Submodule thường được nhập với tên 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)))

Mỗi đối số dtype là một trong các hằng số nguyên được hiển thị ở mức module: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (mặc định), và (khi hỗ trợ số phức được biên dịch) numpy.complex. Kiểu kết quả ndarray tham chiếu đến numpy.ndarray.

Các submodule¶

class `ndarray` --- mảng n chiều¶

ndarray là container n chiều, nhận biết dtype ở lõi của numpy / ulab. Dữ liệu được lưu trữ trong một khối liên tiếp mà cách diễn giải được mô tả bởi một header nhỏ (dtype, shape, strides, ndim, itemsize). Nhiều phép toán -- reshape, transpose, slicing -- chỉ điều chỉnh header này và do đó rất nhanh; các phương thức cấp phát bộ nhớ mới (copy, flatten, hầu hết các phép toán số học) trả về một mảng dày đặc mới.

Cùng kiểu có thể truy cập dưới dạng ulab.ndarray, numpy.ndarray, và (trong trang này) đơn giản là ndarray.

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

Tạo một ndarray mới.

Tham số:

values -- Dữ liệu nguồn. Có thể là một ndarray khác (sẽ được sao chép sâu, có chuyển đổi kiểu nếu dtype khác nhau) hoặc bất kỳ iterable nào của MicroPython. Các iterable lồng nhau tạo ra mảng nhiều chiều; các iterable bên trong phải có cùng độ dài hoặc sẽ xuất hiện lỗi ValueError.
dtype -- Kiểu phần tử cho mảng mới. Một trong các số nguyên mã kiểu được hiển thị bởi numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float, và -- khi được hỗ trợ -- numpy.complex), hoặc một instance dtype. Mặc định là numpy.float.

Hàm factory numpy.array là cách thông thường để tạo một ndarray; nó chuyển tiếp đến constructor này.

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

Đảo thứ tự byte của mỗi phần tử. Đối với mảng uint16, int16, float và complex, thao tác này đảo thứ tự byte của từng phần tử, hữu ích khi sử dụng dữ liệu từ các ngoại vi có endianness không khớp với vi điều khiển. Đối với các dtype một byte (bool, uint8, int8), đây là thao tác không làm gì, trả về một view hoặc bản sao.

Nếu inplace là False (mặc định), một ndarray mới được trả về và bản gốc không bị thay đổi. Nếu inplace là True, các byte của self được đảo tại chỗ và một view của self được trả về.

copy() → ndarray¶: Trả về một bản sao dày đặc, sao chép sâu của mảng. Bản sao sở hữu dữ liệu riêng; các sửa đổi trên bản sao không ảnh hưởng đến bản gốc.

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

Trả về một bản sao một chiều của mảng.

Tham số:: order -- 'C' (mặc định) duyệt dữ liệu theo thứ tự C (trục cuối thay đổi nhanh nhất); 'F' duyệt theo thứ tự Fortran (trục đầu tiên thay đổi nhanh nhất).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Trả về một view của mảng với shape mới. Tổng số phần tử phải không đổi hoặc sẽ xuất hiện lỗi ValueError. Chỉ khả dụng khi ULAB_MAX_DIMS > 1. Tương đương với việc gán cho shape.

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

Sắp xếp mảng tại chỗ.

Tham số:: axis -- Trục để sắp xếp. -1 (mặc định) sắp xếp theo trục cuối; None trước tiên làm phẳng mảng rồi mới sắp xếp.

tobytes() → bytearray¶: Trả về một bytearray tham chiếu đến bộ đệm dữ liệu bên dưới của mảng. Các thao tác ghi thông qua bytearray trả về sẽ sửa đổi mảng tại chỗ. Xuất hiện lỗi ValueError nếu mảng không dày đặc (ví dụ: một view đã được slice).

tolist() → list¶: Trả về nội dung của mảng dưới dạng một list Python (có thể lồng nhau). Độ sâu lồng nhau bằng ndim.

transpose() → ndarray¶: Trả về hoán vị của mảng (các trục được đảo ngược). Đối với mảng một chiều, trả về self. Chỉ khả dụng khi ULAB_MAX_DIMS > 1. Thuộc tính T là cách viết tắt của phương thức này.

dtype: dtype | int¶: Kiểu dữ liệu của các phần tử trong mảng. Trả về một instance dtype khi firmware được xây dựng với ULAB_HAS_DTYPE_OBJECT được bật, ngược lại là mã kiểu ký tự đơn dạng số nguyên.

flat: flatiter¶: Một iterator phẳng trả về mọi phần tử của mảng theo thứ tự C. Khác với flatten(), việc lặp qua flat không cấp phát mảng mới.

itemsize: int¶: Kích thước tính bằng byte của một phần tử mảng, dẫn xuất từ dtype.

ndim: int¶: Số chiều của mảng (độ dài của shape).

shape: tuple[int, ...]¶: Độ dài của mảng theo từng trục. Gán một tuple cho shape sẽ định hình lại mảng tại chỗ (tương đương với reshape()).

size: int¶: Tổng số phần tử trong mảng (tích các giá trị của shape).

strides: tuple[int, ...]¶: Số byte cần bước trong bộ nhớ theo từng trục để đến phần tử tiếp theo trên trục đó.

T: ndarray¶: Hoán vị của mảng; tương đương với transpose().

real: ndarray¶: Phần thực của mảng số phức, trả về dưới dạng ndarray kiểu float. Đối với mảng thực, đây là bản sao của self với cùng dtype. Chỉ khả dụng khi firmware được xây dựng với hỗ trợ số phức.

imag: ndarray¶: Phần ảo của mảng số phức, trả về dưới dạng ndarray kiểu float. Đối với mảng thực, đây là mảng gồm các số không với cùng dtype như self. Chỉ khả dụng khi firmware được xây dựng với hỗ trợ số phức.

Các toán tử được hỗ trợ¶

Các instance ndarray hỗ trợ các toán tử sau. Các toán tử nhị phân phát sóng (broadcast) các toán hạng theo quy tắc phát sóng numpy chuẩn và tuân theo quy tắc upcasting của numpy (ví dụ: uint8 + int8 => int16, uint16 + int16 => float); các phép toán liên quan đến toán hạng số phức tạo ra kết quả số phức.

Số học (nhị phân): +, -, *, /, //, %, **. Các toán hạng phản chiếu (vế phải) và các biến thể tại chỗ +=, -=, *=, /=, %=, **= cũng được hỗ trợ. Cả hai dạng ndarray-với-ndarray và ndarray-với-scalar đều được chấp nhận. Phép chia lấy phần nguyên (//) và toán tử modulo (%) không được triển khai cho mảng complex.

So sánh: ==, !=, <, <=, >, >=. Mỗi toán tử trả về một ndarray boolean có shape phát sóng.

Bitwise (chỉ mảng nguyên): &, |, ^. Áp dụng các toán tử này cho mảng float hoặc complex sẽ xuất hiện lỗi TypeError.

Unary: + (trả về bản sao), - (phủ định; trên dtype không dấu, các giá trị bao quanh modulo \(2^N\)), abs() (giá trị tuyệt đối theo từng phần tử; trên dtype không dấu trả về bản sao mà không tính toán), ~ (đảo bit, chỉ dtype nguyên), len() (trả về độ dài của trục đầu tiên).

Indexing và slicing: a[i], a[i, j, ...], a[start:stop:step], indexing bằng mặt nạ boolean (a[mask]) và indexing bằng mảng nguyên (fancy) đều được hỗ trợ cho cả đọc lẫn ghi.

Lặp: Lặp qua một ndarray trả về các mảng con theo trục đầu tiên (một phần tử tại một thời điểm với mảng 1-D). Sử dụng flat để lặp qua mọi phần tử scalar bất kể số chiều.

Toán tử nhân ma trận @ không được triển khai; hãy dùng numpy.dot (np.dot(a, b)) thay thế.

Các toán tử dịch bit (<<, >>) không được triển khai ở mức toán tử. Hãy dùng numpy.left_shift và numpy.right_shift để dịch bit nguyên theo từng phần tử.

Xây dựng mảng¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: Xây dựng một ndarray mới từ một iterable lồng nhau các số. Constructor thay thế tương đương cho numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: Trả về các giá trị cách đều nhau trên khoảng nửa mở [start, stop). Nếu chỉ có một đối số vị trí được cung cấp, nó được coi là stop với start = 0. Nếu dtype bị bỏ qua, nó được suy ra từ các đầu vào (nguyên nếu tất cả start, stop, step đều là số nguyên và trong phạm vi).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: Nếu a đã là một ndarray có dtype khớp với dtype (hoặc dtype là None), trả về a không thay đổi; ngược lại tạo một mảng mới (với chuyển đổi dtype được yêu cầu khi được cung cấp). Các iterable được chuyển đổi như trong numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: Nối một dãy ndarray theo axis hiện có. Tất cả các mảng đầu vào phải có cùng dtype, ndim và shape trên mọi trục ngoại trừ axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: Với a 2-D, trả về mảng 1-D chứa đường chéo thứ k. Với a 1-D, trả về mảng vuông 2-D với a được đặt trên đường chéo thứ k. k có thể dương (trên đường chéo chính) hoặc âm (dưới đường chéo chính).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Bí danh cho zeros; trả về mảng đầy không có shape và dtype. (ulab không để bộ đệm chưa được khởi tạo.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Trả về mảng 2-D N x M (vuông N x N nếu M là None) với các số một trên đường chéo thứ k và số không ở chỗ khác.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Diễn giải một đối tượng buffer-protocol như một ndarray 1-D có kiểu dtype. count là số mục cần đọc (-1 đọc tất cả các mục có sẵn); offset bỏ qua đó nhiều byte ở đầu buffer.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Trả về một mảng mới có shape và dtype với mọi phần tử được đặt thành fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: Trả về num mẫu cách đều nhau trên khoảng đóng [start, stop] (hoặc nửa mở nếu endpoint là False). Khi retstep là True, trả về tuple (samples, step). start/stop phức tạo ra mảng số phức (khi hỗ trợ số phức được bật).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: Trả về num mẫu cách đều nhau trên thang log: kết quả bắt đầu từ base ** start và kết thúc ở base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Trả về một tuple các ma trận tọa độ từ một dãy các mảng tọa độ một chiều. Với indexing 'xy' (mặc định), hai đầu vào đầu tiên được coi là tọa độ Cartesian và các trục đầu ra của chúng được hoán đổi; với 'ij', indexing kiểu ma trận được sử dụng. Cài đặt này tương đương với NumPy với copy=True và sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Trả về một mảng mới có shape và dtype được điền bằng các số một.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Trả về một mảng mới có shape và dtype được điền bằng các số không.

Kiểm tra / in¶

numpy.get_printoptions() → dict¶: Trả về các tùy chọn in mảng hiện tại dưới dạng dict với các khóa threshold và edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: Đặt các tùy chọn in mảng. threshold là số phần tử mảng tối đa được in đầy đủ; edgeitems là số mục được hiển thị ở mỗi đầu của trục khi mảng được tóm tắt.

numpy.ndinfo(array: ndarray) → None¶: In thông tin chẩn đoán (shape, strides, dtype, itemsize, ...) về array.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Trả về số phần tử của a theo axis; nếu axis là None, trả về tổng số phần tử (tích của ndarray.shape).

So sánh¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: Cắt các giá trị của a sao cho a_min <= result <= a_max. Tương đương với maximum(a_min, minimum(a, a_max)); phát sóng tuân theo các quy tắc tương tự như minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Theo từng phần tử x1 == x2; trả về một ndarray boolean (hoặc scalar bool nếu cả hai đầu vào là scalar). Được cung cấp để tương thích -- toán tử == trên mảng cho kết quả giống nhau.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Theo từng phần tử x1 != x2; đối tác boolean của equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: Trả về mảng boolean (hoặc scalar) là True tại nơi đầu vào là hữu hạn. Đầu vào nguyên luôn hữu hạn.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Trả về mảng boolean (hoặc scalar) là True tại nơi đầu vào là vô hạn. Đầu vào nguyên không bao giờ vô hạn.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Phần tử tối đa của hai mảng / scalar. Các đối số được phát sóng cùng nhau; nếu dtype khác nhau, đầu ra được upcast.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Phần tử tối thiểu của hai mảng / scalar; đối tác của maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: Trả về một tuple các ndarray, một cho mỗi chiều của a, chứa các chỉ mục của các phần tử khác không của a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: Trả về một ndarray có các phần tử lấy từ x tại nơi condition là truthy, và từ y ở những nơi còn lại. Ba đầu vào được phát sóng cùng nhau; dtype đầu ra là upcast của x và y.

Rút gọn số học¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Kiểm tra xem tất cả các phần tử theo axis có đánh giá là True hay không. Với axis=None (mặc định), mảng được làm phẳng và trả về một bool đơn.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Kiểm tra xem có bất kỳ phần tử nào theo axis đánh giá là True hay không. Với axis=None, mảng được làm phẳng được kiểm tra.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Trả về chỉ mục của phần tử lớn nhất theo axis. Với axis=None, mảng được làm phẳng và trả về một số nguyên đơn.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Trả về chỉ mục của phần tử nhỏ nhất theo axis. Với axis=None, mảng được làm phẳng và trả về một số nguyên đơn.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: Trả về một ndarray chỉ mục nguyên không dấu có các mục sắp xếp a theo thứ tự tăng dần theo axis. Dtype đầu ra là uint16, vì vậy không có trục nào được vượt quá 65535 phần tử. axis=None không được hỗ trợ.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: Trả về tích có hướng của hai mảng 1-D có độ dài 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Trả về hiệu số rời rạc thứ n của a theo axis. n phải nằm trong 0..9 (stencil vi phân được lưu trong int8); độ dài của axis giảm đi n. Các từ khóa prepend và append của numpy không được triển khai.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Trả về một mảng mới với thứ tự các phần tử được đảo ngược theo axis; với axis=None, mảng được đảo ngược theo mọi trục.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Trả về phần tử lớn nhất theo axis. Với axis=None (mặc định), mảng được làm phẳng về một scalar. Từ khóa out của numpy không được triển khai.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Trả về phần tử nhỏ nhất theo axis; đối tác của max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: Trả về giá trị trung bình số học theo axis. Với axis=None (mặc định), giá trị trung bình của mảng được làm phẳng được trả về dưới dạng float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Trả về trung vị theo axis. Với axis=None, mảng được làm phẳng trước. Dtype đầu ra luôn là float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: Trả về a với các phần tử được cuộn (dịch chu kỳ) shift vị trí. Với axis=None (mặc định), mảng được làm phẳng trước. Dịch âm cuộn theo hướng ngược lại.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: Trả về một bản sao đã sắp xếp của a theo axis sử dụng heap sort. Với axis=None, mảng được làm phẳng trước. Các từ khóa kind và order của numpy không được triển khai.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: Trả về độ lệch chuẩn theo axis. ddof là delta bậc tự do -- số chia được sử dụng là N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Trả về tổng theo axis. Với axis=None, tổng của mảng được làm phẳng được trả về dưới dạng scalar.

Thống kê¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: Đếm số lần xuất hiện của mỗi giá trị trong mảng số nguyên không âm một chiều x. Dtype của x phải là uint8 hoặc uint16. Nếu weights được cung cấp, mỗi mục của x đóng góp trọng số khớp với nó thay vì 1 và đầu ra có dtype float; ngược lại, đầu ra có dtype uint16. Nếu minlength được cung cấp, mảng đầu ra có ít nhất nhiều phần tử đó (các mục thêm là không).

numpy.trace(m: ndarray) → int | float¶: Trả về tổng các phần tử đường chéo của ma trận vuông m. Kiểu trả về theo dtype của m (mảng nguyên tạo ra int, mảng float tạo ra float).

Biến đổi¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: Trả về các slice của a được chọn theo axis bởi điều kiện boolean condition. Với axis=None, mảng được làm phẳng được sử dụng.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Trả về bản sao của a với các mục tại indices bị xóa theo axis. Với axis=None, mảng được làm phẳng trước. Các chỉ mục âm đếm từ cuối của axis; indices được sắp xếp nội bộ trước khi xóa.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Trả về tích vô hướng của hai mảng. Với hai mảng 1-D, đây là tích trong (một scalar float). Với mảng 2-D, đây là nhân ma trận; các chiều trong phải khớp. Kết quả luôn có dtype float.

Xấp xỉ¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: Nội suy tuyến tính một chiều. xp phải là một mảng 1-D tăng đơn điệu của các giá trị độc lập; fp chứa các giá trị phụ thuộc tương ứng; x là các điểm tại đó hàm nội suy được đánh giá. left và right ghi đè giá trị trả về cho x < xp[0] và x > xp[-1] tương ứng (mặc định: fp[0] và fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Tích phân y sử dụng quy tắc hình thang tổng hợp. Nếu x được cung cấp, nó cung cấp các vị trí mẫu tương ứng với y; ngược lại, khoảng cách dx được sử dụng. y (và x) phải là 1-D.

Lựa chọn¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: Lấy các phần tử từ a tại indices cho trước theo axis. Với axis=None, mảng được làm phẳng được sử dụng. mode chọn hành vi khi vượt giới hạn: "raise" (mặc định -- xuất hiện lỗi ValueError), "wrap" (modulo độ dài trục), hoặc "clip" (cắt vào phạm vi hợp lệ; các chỉ mục âm không được phép). Nếu out được cung cấp, kết quả được ghi vào đó.

Bitwise¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: Phép AND bitwise theo từng phần tử của hai mảng nguyên; phát sóng được hỗ trợ. Dtype không phải nguyên sẽ xuất hiện ngoại lệ.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: Phép OR bitwise theo từng phần tử của hai mảng nguyên.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: Phép XOR bitwise theo từng phần tử của hai mảng nguyên.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: Dịch bit trái theo từng phần tử x1 đi x2 bit; cả hai mảng phải có dtype nguyên.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: Dịch bit phải theo từng phần tử x1 đi x2 bit; cả hai mảng phải có dtype nguyên.

Lọc¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: Trả về tích chập tuyến tính rời rạc của hai mảng 1-D. Chỉ chế độ "full" được hỗ trợ; từ khóa mode của numpy không được chấp nhận (các chế độ khác có thể thu được bằng cách slice kết quả đầy đủ). Độ dài đầu ra là len(a) + len(v) - 1.

Đa thức¶

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

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Khớp một đa thức bậc deg với các điểm dữ liệu (x, y) bằng bình phương nhỏ nhất và trả về các hệ số đa thức (bậc cao nhất trước). Nếu x bị bỏ qua, range(len(y)) được sử dụng. Xuất hiện lỗi ValueError nếu độ dài của x và y khác nhau.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Đánh giá đa thức có hệ số p (bậc cao nhất trước) tại x. Nếu x là scalar, trả về float; ngược lại trả về ndarray.

I/O¶

numpy.load(file: str) → ndarray¶: Đọc một mảng đã được ghi trước đó bằng save từ file (định dạng .npy độc lập nền tảng của numpy). Endianness được chuyển đổi kịp thời nếu thứ tự byte của file khác với 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¶: Đọc dữ liệu số từ file văn bản và trả về dưới dạng ndarray. delimiter mặc định là khoảng trắng; comments là ký hiệu bình luận dòng; max_rows giới hạn số hàng dữ liệu được đọc (-1 cho tất cả); usecols chọn các cột theo chỉ mục; skiprows bỏ qua đó nhiều hàng đầu. Nếu dtype không phải float, các giá trị được chuyển đổi bằng cách làm tròn.

numpy.save(file: str, a: ndarray) → None¶: Lưu a vào file theo định dạng .npy độc lập nền tảng của numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: Ghi a vào file dưới dạng văn bản. delimiter phân tách các giá trị trong một hàng; header và footer, nếu được cung cấp, được ghi trước/sau dữ liệu, mỗi cái được đặt trước bởi comments. Các giá trị được ghi dưới dạng số thực dấu phẩy động.

Hàm trợ giúp số phức¶

Các hàm này chỉ khả dụng khi ulab được biên dịch với hỗ trợ số phức (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: Trả về phần thực của val. Với đầu vào dtype thực, trả về bản sao giữ nguyên dtype; với đầu vào số phức, trả về ndarray kiểu float.

numpy.imag(val: ndarray) → ndarray¶: Trả về phần ảo của val. Với đầu vào dtype thực, trả về mảng gồm các số không với cùng dtype; với đầu vào số phức, trả về ndarray kiểu float.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: Trả về liên hợp phức của val. Đầu vào có giá trị thực được trả về không thay đổi.

numpy.sort_complex(a: ndarray) → ndarray¶: Sắp xếp mảng 1-D a trước theo phần thực, sau đó theo phần ảo. Kết quả luôn có dtype số phức, ngay cả khi a có giá trị thực.

Hàm phổ quát¶

Các hàm toán học theo từng phần tử. Mỗi hàm chấp nhận một scalar hoặc ndarray và trả về kết quả có shape khớp (scalar float cho đầu vào scalar, ndarray cho đầu vào mảng). Khi được gọi với ndarray, kết quả là một ndarray dấu phẩy động mới; từ khóa tùy chọn out có thể được truyền để ghi kết quả vào một ndarray float được cấp phát trước có cùng kích thước.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Tính arcosine (cosine nghịch đảo) của mỗi phần tử của x; kết quả tính bằng radian.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: Tính arcosine hyperbolic của mỗi phần tử của x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: Tính arctan hai đối số atan2(y, x) theo từng phần tử; hỗ trợ phát sóng giữa hai đầu vào.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: Làm tròn các phần tử của ndarray x đến số decimals cho trước; đối số đầu tiên phải là ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Tính arcsine (sine nghịch đảo) của mỗi phần tử của x; kết quả tính bằng radian.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: Tính arcsin hyperbolic của mỗi phần tử của x.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: Tính arctan (tangent nghịch đảo) của mỗi phần tử của x; kết quả tính bằng radian.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: Tính arctanh hyperbolic của mỗi phần tử của x.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: Tính trần (số nguyên nhỏ nhất không nhỏ hơn giá trị) của mỗi phần tử của x.

numpy.cos(x: ndarray | float, /) → ndarray | float¶: Tính cosine của mỗi phần tử của x (tính bằng radian).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: Tính cosine hyperbolic của mỗi phần tử của x.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: Chuyển đổi mỗi phần tử của x từ radian sang độ.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: Tính số mũ e**x của mỗi phần tử của x; có thể trả về ndarray số phức khi có đầu vào số phức (nếu hỗ trợ số phức được bật).

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: Tính exp(x) - 1 của mỗi phần tử của x với độ chính xác được cải thiện gần không.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Tính sàn (số nguyên lớn nhất không lớn hơn giá trị) của mỗi phần tử của x.

numpy.log(x: ndarray | float, /) → ndarray | float¶: Tính logarithm tự nhiên của mỗi phần tử của x.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: Tính logarithm cơ số 10 của mỗi phần tử của x.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: Tính logarithm cơ số 2 của mỗi phần tử của x.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: Chuyển đổi mỗi phần tử của x từ độ sang radian.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: Tính sine của mỗi phần tử của x (tính bằng radian).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: Tính hàm sinc chuẩn hóa sin(pi*x) / (pi*x) của mỗi phần tử của x.

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: Tính sine hyperbolic của mỗi phần tử của x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: Tính căn bậc hai của mỗi phần tử của x; truyền dtype=numpy.complex để thu được kết quả số phức cho đầu vào thực âm (nếu hỗ trợ số phức được bật).

numpy.tan(x: ndarray | float, /) → ndarray | float¶: Tính tangent của mỗi phần tử của x (tính bằng radian).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: Tính tangent hyperbolic của mỗi phần tử của x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: Trả về một callable áp dụng hàm Python f theo từng phần tử cho một scalar, iterable, hoặc ndarray; otypes chọn dtype đầu ra (mặc định float).

Các hằng số¶

numpy.e: float¶: Số Euler \(e \approx 2.71828\).

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

numpy.inf: float¶: Số dương vô cực dấu phẩy động IEEE-754.

numpy.nan: float¶: Giá trị "không phải số" (NaN) dấu phẩy động IEEE-754.

numpy.bool: int¶: Mã dtype cho mảng boolean (được lưu dưới dạng uint8).

numpy.uint8: int¶: Mã dtype cho mảng số nguyên 8-bit không dấu.

numpy.int8: int¶: Mã dtype cho mảng số nguyên 8-bit có dấu.

numpy.uint16: int¶: Mã dtype cho mảng số nguyên 16-bit không dấu.

numpy.int16: int¶: Mã dtype cho mảng số nguyên 16-bit có dấu.

numpy.float: int¶: Mã dtype cho mảng dấu phẩy động 32-bit.

numpy --- các phép toán mảng tương thích numpy¶