Python

NumPy reference

[NỘI DUNG BÀI VIẾT ĐƯỢC CẬP NHẬT LIÊN TỤC]

NumPy is a library for the Python programming language that (among other things) provides support for large, multidimensional arrays. Why is that important? Using NumPy, we can express images as multi-dimensional arrays. Representing images as NumPy arrays is not only computationally and resource efficient, many other image processing and machine learning libraries use NumPy array representations as well. Furthermore, by using NumPy’s built-in high-level mathematical functions, we can quickly and easily perform numerical analysis on an image.


DATA TYPES

NumPy hỗ trợ các kiểu dữ liệu sau:

  • Boolean: numpy.bool_;
  • Unsigned Integer: numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64;
  • Signed Integer: numpy.int8, numpy.int16, numpy.int32, numpy.int64;
  • Float: numpy.float16, numpy.float32, numpy.float64;
  • Complex: numpy.complex64, numpy.complex128.

Các kiểu dữ liệu này có thể được sử dụng như các function để chuyển đổi kiểu dữ liệu từ Python numbers/”sequence of numbers” sang NumPy scalars/array:

Ví dụ: np.uint8([1, 2, 3, 4, 5])

Các kiểu dữ liệu này còn được dùng làm đối số dtype cho method ndarray.astype(dtype), và có thể được truyền vào ở dạng String. Khi được dùng làm đối số, NumPy quy định bool tương đương với numpy.bool_, int tương đương với numpy.int32 (hoặc numpy.int64), float tương đương với numpy.float64, complex tương đương với numpy.complex128.

Ví dụ: X.astype(numpy.int32) tương đương với X.astype(“int32”) và X.astype(int)


FUNCTIONS

  • numpy.set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None, sign=None, floatmode=None, **kwarg)

-precision: int, optional – Number of digits of precision for floating point output (default 8).
-sign: string, either ‘-‘, ‘+’, or ‘ ‘, optional – Controls printing of the sign of floating-point types. If ‘+’, always print the sign of positive values. If ‘ ‘, always prints a space (whitespace character) in the sign position of positive values. If ‘-‘, omit the sign character of positive values. (default ‘-‘)


  • numpy.random.randint(low, high=None, size=None, dtype=’l’) – return random integers from low (inclusive) to high (exclusive) with “discrete uniform” distribution.

-low: int – giới hạn dưới (inclusive) trong khoảng random, nếu high=None thì low sẽ là giới hạn trên (exclusive).
-high: int, optional – giới hạn trên (exclusive) trong khoảng random.
-size: int hoặc tuple of integers, optional – nếu size=n là một số nguyên, output sẽ là một array có n phần tử; nếu size=(k,m,n), output sẽ là một matrix có các chiều là k,m,n; nếu size=None, output sẽ là một giá trị single.
-dtype: dtype, optional.

Return: int hoặc ndarray of integers – size-shaped array of random integers from the discrete uniform distribution, or a single such random int if size not provided.

  • numpy.random.uniform(low=0, high=1,size=None) – draw samples from a uniform distribution in the interval [low, high).

-low: float, optional – giới hạn dưới (inclusive) trong khoảng random;
-high: float, optional – giới hạn trên (exclusive) trong khoảng random.
-size: int hoặc tuple of integers, optional – nếu size=n là một số nguyên, output sẽ là một array có n phần tử; nếu size=(k,m,n), output sẽ là một matrix có các chiều là k,m,n; nếu size=None, output sẽ là một giá trị single.

Return: int hoặc ndarray of integers – size-shaped array of random floats from the uniform distribution, or a single such random int if size not provided.

  • numpy.random.rand(d1,d2,…,dn) – Random values in a given shape (d1,d2,…). Create an array of the given shape and populate it with random samples from a uniform distribution over [0, 1).
  • numpy.random.randn(d1,d2,…,dn) – Random values in a given shape (d1,d2,…). Create an array of the given shape and populate it with random samples from a “standard normal” distribution over [0, 1).
  • numpy.random.random(size=None) – Return random floats in the interval [0.0, 1.0) with “continuous uniform” distribution.

– size: int or tuple of ints, optional – kích thước của output array;

Returnfloat or ndarray of floats – Array of random floats of shape size.

Example: Tạo một ma trận 2×2 có các phần tử ngẫu nhiên thuộc [0, 100).

>>> import numpy as np
>>> number = np.random.randint(0, 100, (2, 2))
>>> number
array([[75, 36]
       [68, 26]])

  • numpy.random.choice(range, size=None, replace=True) – chọn ra các sample ngẫu nhiên từ một array 1-d

– range: ndarray hoặc int – chọn các sample ngẫu nhiên từ array hoặc từ numpy.arange(range) nếu range là một số int;
– size: tuple hoặc int – kích thước của kết quả, trả về một giá trị nếu size=None;
– replace: cho phép trùng lặp khi chọn, mặc định là True.

Return: int hoặc ndarray

Example:

>>> import numpy as np
>>> np.random.choice(15, size=(3,3), replace=False)
array([[11, 8, 2],
       [ 4, 5, 0],
       [12, 1, 7]])
>>> np.random.choice(15, size=(3,3), replace=True)
array([[ 3,  6, 10],
       [ 6,  6,  4],
       [11, 12,  7]])

  • numpy.random.permutation(x) – hoán vị ngẫu nhiên các phần từ của array x hoặc arange(x)

– xint hoặc ndarray: nếu x là một số int, thì thực hiện hoán vị ngẫu nhiên các phần tử có trong array numpy.arange(x).

Return: ndarray: một array có phần tử đã được hoán vị ngẫu nhiên.

  • numpy.random.shuffle(x) – in-place function: xáo trộn vị trí các phần tử của array x.

– xarray-like: ndarray hoặc list cần xáo trộn. Đối với multi-dimensional array, chỉ có vị trí các sub-arrays bị xáo trộn, các phần tử trong từng sub-array không bị ảnh hưởng.

Return: None.


  • numpy.zeros(shape, dtype=None, order=’C’) – return a new array of given shape and type, filled with zeros.
  • numpy.ones(shape, dtype=None, order=’C’) – return a new array of given shape and type, filled with ones.

– shape: int or tuples of integers – shape of the new array.
– dtype: data-type, optional – uint8, uint32,…

returnndarray – Array of zeros or ones with the given shape, dtype, and order.

Example: Tạo một ma trận 3×4 có tất cả các phần tử là 10.

import numpy as np
M = np.ones((3, 4), dtype="uint8") * 10


  • numpy.array(nested list or tuple, dtype=None) – tạo một array object.
  • numpy.hstack([sequence of arrays]) – ghép các arrays theo chiều ngang (column wise). Các arrays phải có số hàng bằng nhau.
  • numpy.vstack([sequence of arrays]) – ghép các arrays theo chiều dọc (row wise). Các arrays phải có số cột bằng nhau.
  • numpy.dstack([sequence of arrays]) – Stack arrays in sequence depth wise (along third axis), output array sẽ là 3-D.
  • numpy.column_stack([sequence of arrays]) – Stack 1-D arrays as columns into a 2-D array; đối với 2-D arrays, kết quả nhận được tương tự với numpy.hstack().
  • numpy.concatenate([sequence of arrays], axis=0) – join a sequence of arrays along an existing axis.
  • numpy.c_[ndarray, ndarray] – stack arrays in column wise;
  • numpy.r_[ndarray, ndarray] – stack arrays in row wise;

return: ndarray

Example:

>>> import numpy as np
>>> a = np.array((1,2,3))
>>> b = np.array((4,5,6))
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6])
>>> np.dstack((a,b))
array([[[1, 4],
       [2, 5],
       [3, 6]]])
>>> np.column_stack((a,b))
array([[1, 4],
       [2, 5],
       [3, 6]])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[4],[5],[6]])
>>> np.hstack((a,b))
array([[1, 4],
       [2, 5],
       [3, 6]])
>>> np.dstack((a,b))
array([[[1, 4]],
       [[2, 5]],
       [[3, 6]]])
>>> np.column_stack((a,b))
array([[1, 4],
       [2, 5],
       [3, 6]])

  • numpy.append(array, values, axis=None) – thêm các phần tử mới vào cuối array theo trục axis.

array: ndarray – mảng được thêm các phần tử mới;
values: ndarray – mảng chứa các phần tử mới, kích thước của valuesarray phải tương thích nhau theo trục axis;
axis: None hoặc int – trục mà các phần tử mới sẽ được thêm vào.

Return: ndarray

  • numpy.insert(array, indexs, values, axis=None) – chèn các phần tử mới vào trước các index của array theo trục axis.

array: ndarray – mảng được chèn các phần tử mới;
indexs: scalar hoặc ndarray – indexs theo trục axis mà các phần tử mới sẽ được chèn vào;
values: ndarray – mảng chứa các phần tử mới, kích thước của valuesarray phải tương thích nhau theo trục axis;
axis: None hoặc int – trục mà các phần tử mới sẽ được thêm vào.

Return: ndarray

  • numpy.delete(array, indexs, axis=None) – xóa các hàng/cột theo trục axis.

array: ndarray – mảng sẽ được xóa các phần tử;
indexs: int, ndarray hoặc slice – index của các hàng/cột cần xóa theo trục axis;
axis: None hoặc int – trục của array.

Return: ndarray

Example:

>>> import numpy as np
>>> A = np.arange(9).reshape(3,3)
>>> A
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
>>> np.append(A, [[-1],[-2],[-3]], axis=1)
array([[0, 1, 2, -1],
       [3, 4, 5, -2],
       [6, 7, 8, -3]])
>>> np.insert(A, [0,2], [[-1,-2,-3]], axis=0)
array([[-1, -2, -3],
       [ 0,  1,  2],
       [ 3,  4,  5],
       [-1, -2, -3],
       [ 6,  7,  8]])
>>> np.delete(A, 1, axis=1)
array([[0, 2],
       [3, 5],
       [6, 8]])


  • numpy.reshape(array, newShape) – Gives a new shape to an array without changing its data;
  • ndarray.reshape(newShape) – Equivalent to numpy.reshape();
  • ndarray.shape = newShape.

array: array-like – Array to be reshaped.
newShape: int or tuple of integers – The new shape should be compatible with the original shape.

Return: ndarray

  • numpy.expand_dims(array, axis) – thêm một chiều dữ liệu vào array.

array: array-like – array sẽ được biến đổi;
axis: int – chiều dữ liệu được thêm mới sẽ trở thành trục axis.

Return: ndarray

Example:

>>> import numpy as np
>>> array = np.array([[1,2,3],[4,5,6]])
>>> array.shape
(2, 3)
>>> A = np.expand_dims(array, 0)
>>> A
array([[[1, 2, 3],
       [4, 5, 6]]])
>>> A.shape
(1, 2, 3)
>>> B = np.expand_dims(array, 1)
>>> B
array([[[1, 2, 3]],
       [[4, 5, 6]]])
>>> B.shape
(2, 1, 3)
>>> C = np.expand_dims(array, 2)
>>> C
array([[[1],
        [2],
        [3]],
       [[4],
        [5],
        [6]]])
>>> C.shape
(2, 3, 1)

  • numpy.atleast_1d(*arrays) – biến đổi các arrays để có số chiều ít nhất là 1-D;
  • numpy.atleast_2d(*arrays) – biến đổi các arrays để có số chiều ít nhất là 2-D;
  • numpy.atleast_3d(*arrays) – biến đổi các arrays để có số chiều ít nhất là 3-D;

  • numpy.transpose(ndarray), ndarray.T – trả về ma trận chuyển vị của ndarray.

Example:

>>> import numpy as np
>>> a = np.arange(6).reshape(2,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> np.transpose(a)
array([[0, 3],
       [1, 4],
       [2, 5]])
>>> a.T
array([[0, 3],
       [1, 4],
       [2, 5]])


  • numpy.ndarray.flatten() – Return a copy of the array collapsed into one dimension.
  • numpy.ravel(array), ndarray.ravel() – Return a contiguous flattened array.

  • numpy.copy(array), ndarray.copy() – Return an array copy of the given object.

  • numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) – Return evenly spaced numbers over a specified interval.

-start – The starting value of the sequence.
-stop – The end value of the sequence.
-num: int, optional – Number of samples to generate. Default is 50.
-endpoint: bool, optional – If True, stop is the last sample. Otherwise, it is not included. Default is True.
-retstep: bool, optional – If True, return (samples, step), where step is the spacing between samples.
-dtype: dtype, optional – The type of the output array.

return: ndarray

  • numpy.arange([start, ]stop, [step, ]dtype=None) – similar to function range() của Python.

return: ndarray

Example: linspace and arange

>>> import numpy as np
>>> arangeArray = np.arange(0, 10, 2)
>>> arangeArray
array([0, 2, 4, 6, 8])
>>> linspaceArray = np.linspace(0, 10, 5)
>>> linspaceArray
array([0, 2.5, 5.0, 7.5, 10.])


  • numpy.sum(array, axis, keepdims=“novalue”)
  • array.sum(axis, keepdims=“novalue”) – tính tổng các phần tử trong array theo trục axis cho trước.

– axis: None, 0 hoặc 1.
+ axis = None: tính tổng tất cả các phần tử trong array;
+ axis = 0: tính tổng tất cả các phần tử của từng cột trong array;
+ axis = 1: tính tổng tất cả các phần tử của từng hàng trong array.
– keepdims: boolean, optional
+ keepdims = True: kết quả trả về sẽ có kích thước theo trục axis là 1;
Return: int or ndarray

Example:

>>> np.sum([0.5, 1.5])
2.0
>>> np.sum([[0, 1], [0, 5]], axis=0)
array([0, 6])
>>> np.sum([[0, 1], [0, 5]], axis=0, keepdims=True)
array([[0, 6]])
>>> np.sum([[0, 1], [0, 5]], axis=1)
array([1, 5])
>>> np.sum([[0, 1], [0, 5]], axis=1, keepdims=True)
array([[1],
       [5]])


  • numpy.diff(array, axis) – tính hiệu giữa 2 phần tử liền kề theo trục axis cho trước của array.

– array: ndarray;
– axis: 0 hoặc 1
+ axis = 0: tính hiệu giữa 2 phần tử liền kề theo từng cột;
+ axis = 1: tính hiệu giữa 2 phần tử liền kề theo từng hàng.

Return: ndarray
Example:

>>> import numpy as np
>>> a = np.array([[1,3,7],[5,8,2]])
>>> d = np.diff(a, axis=0)
>>> d
array([[4, 5, -5]])
>>> d = np.diff(a, axis=1)
>>> d
array([[2, 4],
       [3, -6]])


  • numpy.argmin(array, axis), ndarray.argmin(axis) – Returns the indices of the minimum values along an axis.
  • numpy.argmax(array, axis),  ndarray.argmax(axis) – Returns the indices of the maximum values along an axis.

Returnndarray of ints – Array of indices into the array. It has the same shape as array shape with the dimension along axis removed.

  • numpy.amin(array, axis), ndarray.min(axis) – Returns the minimum values along an axis;
  • numpy.amax(array, axis), ndarray.max(axis) – Returns the maximum values along an axis.

Returnndarray or scalar – một array chứa các giá trị max/min theo chiều được chọn, có kích thước bằng với kích thước của input array bỏ đi chiều axis.

  • numpy.maximum(array_A, array_B) – Element-wise maximum of array elements;
  • numpy.minimum(array_A, array_B) – Element-wise minimum of array elements.

Return: ndarray or scalar – một array có kích thước bằng với các input array, chứa các giá trị “element-wise max/min”.

Example:

>>> A = np.array([[0,3,1],[3,4,-1]])
>>> B = np.array([[2,1,5],[4,1,3]])
>>> A
array([[0,  3,  1],
       [3,  4, -1]])
>>> B
array([[2, 1, 5],
       [4, 1, 3]])
>>> np.argmin(A)
5
>>> np.argmin(A, axis=0)
array([0, 0, 1])
>>> np.argmin(A, axis=1)
array([0, 2])
>>> np.maximum(A, B)
array([[2, 3, 5],
       [4, 4, 3]])
>>> np.minimum(A, B)
array([[0,  1,  1],
       [3,  1, -1]])


  • numpy.mean(array, axis=None), ndarray.mean(axis=None) – tính giá trị mean của các phần tử trong mảng array theo từng trục. Nếu axis=None thì tính giá trị mean của tất cả các phần tử trong mảng.

Return: 1-d ndarray hoặc scalar ở dạng float64.

Example:

>>> a = np.array([[1,2,3,4],[5,6,7,8]])
>>> a.mean()
4.5
>>> a.mean(axis=0)
array([3., 4., 5., 6.])
>>> a.mean(axis=1)
array([2.5, 6.5])


  • numpy.where(condition, [x, y]) – Return elements, either from x or y, depending on condition.

– conditionarray-like, bool – When True, yield x, otherwise yield y.
– x,y – Values from which to choose

Return: ndarray or tuple of ndarrays

    • If both x and y are specified, the output array contains elements of x where condition is True, and elements from y elsewhere.
  • If only condition is given, return the tuple contains rows and columns, where condition is True.

Example:

>>> import numpy as np
>>> array = np.arange(15).reshape(3,5)
>>> array
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9],
       [10, 11, 12, 13, 14]])
>>> index = np.where(array >= 10, array, -1)
>>> index
array([[-1, -1, -1, -1, -1],
       [-1, -1, -1, -1, -1],
       [10, 11, 12, 13, 14]])
>>> index = np.where(array >= 10)
(array([2, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 4], dtype=int64))

  • numpy.unique(array, return_index=False, return_inverse=False, return_counts=False, axis=None) – tìm ra các phần tử không trùng lặp trong array.

array: ndarray – input array;
return_index: boolean – trả về index ở trong input array của các phần tử được tìm thấy;
return_inverse: boolean – trả về index của từng phần tử trong input array tương ứng với unique array, có thể dùng để reconstruct input array;
return_counts: boolean – trả về tần số xuất hiện của các phần tử được tìm thấy trong input array;
axis: int or None
+ Nếu axis = None: input array sẽ được flatten và tìm kiếm các phần tử duy nhất trong flattened array đó;
+ Nếu axis = 0: tìm kiếm các “unique column” có trong input array;
+ Nếu axis = 1: tìm kiếm các “unique row” có trong input array;

Return:
unique: ndarray – array chứa các phần tử không trùng lặp được sắp xếp theo thứ tự tăng dần;
unique_indices: ndarray, nếu return_index=True;
unique_inverse: ndarray, nếu return_inverse=True;
unique_counts: ndarray, nếu return_counts=True.

Example:

>>> import numpy as np
>>> A = np.random.randint(20, size=(4,5))
>>> A
array([[11, 18, 19, 18, 15],
       [17, 10,  9, 10, 17],
       [9,   1,  2, 10,  0],
       [12, 10,  5, 14, 13]])
>>> np.unique(A,return_counts=True)
(array([0, 1, 2, 5, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19]),
array([1, 1, 1, 1, 2, 4, 1, 1, 1, 1, 1, 2, 2, 1], dtype=int64)

  • numpy.clip(array, min, max) – giới hạn các giá trị của array trong khoảng [min, max].

array: ndarray – input array;
min: scalar hoặc ndarry – giá trị giới hạn dưới;
max: scalar hoặc ndarray – giá trị giới hạn trên

Return: ndarray
Example:

>>> import numpy as np
>>> data = np.arange(10)
>>> np.clip(data, 1, 5)
array([1, 1, 2, 3, 4, 5, 5, 5, 5, 5])


  • numpy.sort(ndarray, axis=-1, kind=’quicksort’);
  • numpy.ndarray.sort(axis=-1, kind=’quicksort’) – sắp xếp một array;
  • numpy.argsort(ndarray, axis=-1, kind=’quicksort’) – trả về indice của các phần tử theo đó array sẽ được sắp xếp;
  • numpy.ndarray.argsort(axis=-1, kind=’quicksort’).

– axis: trục sắp xếp
+ axis = -1: sắp xếp theo trục cuối cùng của array;
+ axis = 0: sắp xếp theo cột;
+ axis = 1: sắp xếp theo hàng;
+ axis = None: chuyển array về 1-d rồi sắp xếp.
– kind: method sắp xếp:
+ kind = “quicksort”
+ kind = “mergesort”
+ kind = “heapsort”

Return: ndarray

Example:

>>> import numpy as np
>>> array = np.random.randint(20, size=(4,5))
>>> array
array([[ 8,  2,  1, 19, 12],
       [ 2, 11, 19,  1,  1],
       [ 2, 14, 11, 14,  7],
       [ 1,  2, 13, 13,  5]])
>>> np.sort(array, axis=0)
array([[ 1,  2,  1,  1,  1],
       [ 2,  2, 11, 13,  5],
       [ 2, 11, 13, 14,  7],
       [ 8, 14, 19, 19, 12]])


  • numpy.meshgrid(X, Y) – tạo ra hai ma trận N x M chứa tọa độ được kết hợp từ vector X có kích thước M và vector Y có kích thước N.

X : ndarray 1-D – chứa tọa độ trên trục x, có kích thước 1 x M;
Y : ndarray 1-D – chứa tọa độ trên trục y, có kích thước 1 x N;

Return: ndarray N x M  – hai array N x M mới

Example:

>>> import numpy as np
>>> X = np.arange(10)
>>> Y = np.arange(5)
>>> X, Y = np.meshgrid(X, Y)
>>> X
array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
>>> Y
array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
       [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
       [2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
       [3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
       [4, 4, 4, 4, 4, 4, 4, 4, 4, 4]])


NUMPY INDEXING

Basic slicing and indexing

Chúng ta có thể sử dụng slicing (:) tương tự như với List trong Python, ngoài ra numpy còn hỗ trợ multiple dimensions indexing dùng cho multidimensional arrays.

Dấu … (3 chấm) có thể được sử dụng để thay thế cho các dấu slicing (:) liên tiếp.

Khi sử dụng indexing trong multidimensional arrays, các dimension index cách nhau bởi dấu phẩy, ví dụ: array[2,4,1] sẽ truy cập tới phần tử có index là 1, ở hàng 2, cột 4.

Example: Basic indexing

>>> import numpy as np
>>> array1 = np.array([0,1,2,3,4,5,6,7,8,9])
>>> array2 = np.array([[1,2,3],[4,5,6],[7,8,9]])
>>> array1[5]
5
>>> array1[:3]
array([0, 1, 2])
>>> array1[5:]
array([5, 6, 7, 8, 9])
>>> array2[:2]
array([[1, 2, 3],
       [4, 5, 6]])
>>> array2[:2,:2]
array([[1,2],
       [4,5]])
>>> array2[1,2]
6

Integer array indexing

Integer array indexing allows selection of arbitrary items in the array based on their N-dimensional index. Each integer array represents a number of indexes into that dimension.

Đối với array 1 chiều, chúng ta cần cung cấp một list các index cần access.

Đối với array 2 chiều, ta cần một list (hoặc nested-list) các row và một list (hoặc nested-list) các column. Mỗi phần tử của “row list” sẽ kết hợp với một phần tử của “column list”.

Số lượng sub-list tối đa trong nested-list sẽ qui định số hàng của ma trận kết quả, trong khi đó số lượng phần tử tối đa trong các sub-list sẽ qui định số cột.

Chú ý: kích thước của rowList và columnList phải tương ứng

Example: Integer indexing

>>> import numpy as np
>>> array1 = np.array([0,1,2,3,4,5,6,7,8,9])
>>> array2 = np.array([[1,2,3],[4,5,6],[7,8,9]])
>>> # access to elements array1[1], array1[3], array1[4] and array1[9]
...
>>> array1[[1,3,4,9]]
array([1, 3, 4, 9])
>>> # access to elements array2[0][2] and array2[1][1]
...
>>> array2[[0,1],[2,1]]
array([3, 5])
>>> # access to elements array2[0][0], array2[0][1], array2[2][0], array2[2][2]
...
>>> array2[[[0,0],[2,2]],[[0,1],[0,2]]]
array([[1, 2],
       [7, 9]])

Boolean array indexing

Được sử dụng hiệu quả khi cần thay đổi tất cả các phần tử của array theo một điều kiện nào đó.

Example: Boolean indexing

>>> import numpy as np
>>> array1 = np.array([0,1,2,3,4,5,6,7,8,9])
>>> array2 = np.array([[1,2,3],[4,5,6],[7,8,9]])
>>> # set all element in array1 which greater than 4 to 10
...
>>> array1[array1 > 4] = 10
>>> array1
array([0, 1, 2, 3, 4, 10, 10, 10, 10, 10])
>>> # set all element in array2 which greater than 4 to 0
...
>>> array2[array2 > 4] = 0
>>> array2
array([[1, 2, 3],
       [4, 0, 0],
       [0, 0, 0]])


CÁC PHÉP TOÁN THƯỜNG GẶP

  • numpy.multiply(A, B) – thực hiện phép nhân giữa từng phần tử trong hai array (element-wise) hoặc giữa array và scalar. Có thể sử dụng ký tự * để thay thế.

– A, B: array hoặc scalar
+ nếu A và B đều là array 1-d thì chúng phải có kích thước giống nhau;
+ nếu A là array n-d và B là array m-d thì chúng phải có kích thước các chiều phù hợp.

return: array hoặc scalar.

Example:

>>> import numpy as np
>>> A = np.arange(1,10,1).reshape(3,3)
>>> B = np.arange(9,0,-1).reshape(3,3)
>>> C = np.arange(3)
>>> D = 10
>>> A
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> B
array([[9, 8, 7],
       [6, 5, 4],
       [3, 2, 1]])
>>> C
array([0, 1, 2])
>>> np.multiply(A,B)
array([[9, 16, 21],
       [24, 25, 24],
       [21, 16, 9]])
>>> np.multiply(A,C)
array([[0, 2, 6],
       [0, 5, 12],
       [0, 8, 18]])
>>> np.multiply(A,D)
array([[10, 20, 30],
       [40, 50, 60],
       [70, 80, 90]])


  • numpy.inner(A, B) – thực hiện phép Tích vô hướng giữa 2 vector (1-d array) hoặc phép toán “sum product” theo trục cuối giữa 2 array n-d.

– A, B: array hoặc scalar
+ nếu A và B đều là array 1-d thì chúng phải có kích thước giống nhau;
+ nếu A là array n-d và B là array m-d thì chúng phải có kích thước của chiều cuối cùng bằng nhau.

return: ndarray out.shape = A.shape[:-1] + B.shape[:-1]

Example:

>>> import numpy as np
>>> A = np.array([1,2,3])
>>> B = np.array([4,5,6])
>>> C = np.arange(1,10,1).reshape(3,3)
>>> D = np.arange(6).reshape(2,3)
>>> C
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> D
array([[0, 1, 2],
       [3, 4, 5]])
>>> np.inner(A,B)
32
>>> np.inner(A,C)
array([14, 32, 50])
>>> np.inner(C,D)
array([[8, 26],
       [17, 62],
       [26, 98]])


  • numpy.matmul(A, B) – thực hiện phép nhân ma trận giữa 2 array có kích thước phù hợp. Có thể dùng ký tự @ để thay thế.

– A, B: chỉ có thể là array;
+ nếu A và B đều là array 1-d thì chúng phải có kích thước giống nhau;
+ nếu A và B là array 2-d thì chúng phải có kích thước phù hợp với nhau.

return: array hoặc scalar.

Example:

>>> import numpy as np
>>> A = np.array([[1,2,3],[4,5,6]])
>>> B = np.array([[1,2],[3,4],[5,6]])
>>> A
array([[1, 2, 3],
       [4, 5, 6]])
>>> B
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> np.matmul(A,B)
array([[22, 28],
       [49, 64]])


  • numpy.dot(A, B) – thực hiện phép Tích vô hướng giữa 2 array.

– A, B: array hoặc scalar;
+ nếu A và B đều là array 1-d thì chúng phải có kích thước giống nhau và kết quả tương đương với numpy.inner();
+ nếu A và B đều là array 2-d, hoặc A là array 1-d còn B là array 2-d thì chúng phải có kích thước phù hợp với nhau và kết quả tương đương với numpy.matmul();
+ nếu A hoặc B là scalar thì kết quả tương đương với numpy.multiply();
+ nếu A là array n-d còn B là array 1-d thì chúng phải có kích thước của chiều cuối cùng giống nhau và kết quả tương đương với numpy.inner().

return: array hoặc scalar.


INPUT & OUTPUT

  • numpy.loadtxt(filename, dtype=, comments=’#’, delimiter=None) – Load data from a text file.

filename: File hoặc String – đối tượng file hoặc tên file cần đọc;
dtype: data-type – kiểu dữ liệu cần đọc, mặc định là float;
comments: String – ký tự quy định comment trong file;
delimiter: None hoặc String – ký tự dùng để phân tách các giá trị, mặc định là “whitespace”.

Return: 1-D hoặc 2-D ndarray

  • numpy.savetxt(filename, data, fmt=’%.18e’, delimiter=’ ‘) – Save an array to a text file.

filename: File hoặc String – đối tượng file hoặc tên file cần ghi;
data: ndarray – mảng 1-D hoặc 2-D chứa dữ liệu cần ghi vào file;
fmt: String – format khi ghi dữ liệu vào file, mặc định là 18 chữ số thập phân ‘%.18e’, ngoài ra có thể là ‘%s’, ‘%d’, ‘%5.2f’, v.v..;
delimiter: None hoặc String – ký tự dùng để phân tách các giá trị, mặc định là “whitespace”.

  • numpy.ndarray.tofile(filename, sep=”, format=”%s”) – Write array to a file as text or binary (default);
  • numpy.fromfile(filename, dtype=float, count=-1, sep=”) – Construct an array from data in a text or binary file;

sep: String – ký tự phân tách các giá trị, mặc định sep=” (empty) dành cho đọc/ghi file binary;
format: String – format khi ghi dữ liệu vào file text;

Return: 1-D ndarray

  • numpy.load(filename) – Load arrays or pickled objects from .npy, .npz or pickled files.

Return: ndarray

  • numpy.save(filename, data) – Save an array to a binary file in NumPy .npy format.
  • numpy.frombuffer(buffer, dtype=float, count=-1, offset=0) – tạo một 1-D array từ buffer.

Return: ndarray

  • numpy.ndarray.tobytes() – trả về một chuỗi bytes biểu diễn các giá trị của array.

Return: bytes

  • numpy.fromstring(string, dtype=float, count=-1, sep=”) – tạo một 1-D array từ dữ liệu ở dạng String.

Return: ndarray

Example:

>>> import numpy as np
>>> dataArray = np.array([[1,2,3],[4,5,6]], dtype="uint8")
>>> dataArray.tobytes()
b'\x01\x02\x03\x04\x05\x06'
>>>
>>> dataBytes = b'ABC'
>>> np.frombuffer(dataBytes, dtype="uint8")
array([97, 98, 99], dtype="uint8")
>>>
>>> dataString = "1,2,3"
>>> np.fromstring(dataString, dtype="uint8", sep=',')
array([1, 2, 3], dtype="uint8")


  • numpy.lib.stride_tricks.as_strided(data, shape, strides) – tạo sliding window từ array cho trước.

data: 2-D ndarray – input 2-D array;
shape: sequence of int – [numWindowOnHeight, numWindowOnWidth, windowHeight, windowWidth]: kích thước của output array;
strides: sequence of int – [data.strides[0]*stepSize, data.strides[1]*stepSize, data.strides[0], data.strides[1]].

Return: ndarray

Example:

import numpy as np

data = np.random.randint(0, 255, size=(400,400), dtype="uint8")
windowSize = (40,20)
stepSize = 10
numWindow = [(data.shape[1]-windowSize[0])//stepSize+1, (data.shape[0]-windowSize[1])//stepSize+1]

shape = numWindow[::-1]
shape.extend(windowSize[::-1])

strides = [data.strides[0]*stepSize, data.strides[1]*stepSize]
strides.extend(data.strides)

# Create sliding window
patches = np.lib.stride_tricks.as_strided(data, shape=shape, strides=strides).reshape(-1, windowSize[1], windowSize[0])

# Generate coordinates for each sliding window
X = np.linspace(0, num_win[0], num=numWindow[0], endpoint=False)*stepSize
Y = np.linspace(0, num_win[1], num=numWindow[1], endpoint=False)*stepSize
Xgrid, Ygrid = np.meshgrid(X,Y)
grid = np.dstack([Xgrid, Ygrid]).reshape(-1,2)

Reference:
[1] NumPy Reference.

One thought on “NumPy reference

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s