1647375120

# 【NumPy快速入门】如何创建NumPy数组？创建NumPy数组常用函数

``````import numpy as np
np_array = np.array([1, 2, 3])
print(type(np_array)) # <class 'numpy.ndarray'>
print(np_array.shape) # (3,)``````

``````zero_array = np.zeros((5)) # [0. 0. 0. 0. 0.]
one_array = np.ones((4,4))
"""
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
"""
full_array = np.full((3,3), 7)
"""
[[7 7 7]
[7 7 7]
[7 7 7]]
"""
empty_array = np.empty((2, 3)) # 无法预测其数值，内存里有什么就是什么
"""
[[1.94830084e-316 0.00000000e+000 0.00000000e+000]
[0.00000000e+000 0.00000000e+000 0.00000000e+000]]
"""``````

## Axis and Data Type

``````zero_array = np.zeros((3, 4))
zero_array
"""
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
"""
zero_array.shape # (3, 4)
zero_array.ndim # 2
zero_array.size # 12``````

``````int_array = np.array([1, 2])
int_array.dtype # int64
float_array = np.array([1.0, 2.0])
float_array.dtype # float64
float_array.itemsize # 每个元素的大小 8
float32_array = np.array([1, 2], dtype=np.float32)
float32_array.dtype # float64
float32_array.itemsize # 4``````

``````x = np.array([[1, 2, 3], [4, 5, 6]])
x.ndim # 2
x.shape = (6,) # Change its shape in place
x.ndim # 1``````

np.reshape和ravel可以创建出指向相同数据的新数组：

``````y = np.reshape(x, (3, 2)) # 创建形状不同的新数组，此数组指向相同的数据
y[0, 0] = 1000
print(x) # [1000, 2, 3, 4, 5, 6]
z = y.ravel() # 指向相同数组的新数组
z[0] = 2000
print(x) # [2000, 2, 3, 4, 5, 6]``````

``````array1 = np.arange(4)
array2 = array1.copy()
array2[0] = 2000
array1 # [0, 1, 2, 3]``````

## Arithmetic Operations

NumPy数组也支持一些常用的算数运算：

``````array1 = np.array([1, 2, 3, 4])
array2 = np.array([5, 6, 7, 8])
print(array1 + array2) # [6, 8, 10, 12]
print(array1 - array2) # [-4, -4, -4, -4]
print(array1 * array2) # [5, 12, 21, 32]
print(array1 / array2) # [0.2, 0.33333333, 0.42857143, 0.5]
print(array1 // array2) # [0, 0, 0, 0]
print(array1 % array2) # [1, 2, 3, 4]
print(array1 ** array2) # [1, 64, 2187, 65536]``````

## Useful Functions

``````np.random.random((5, 5)) # 创建数值在0~1之间的随机数数组
[[9.90294681e-01 6.51182438e-02 5.48551064e-02 4.13554785e-01 2.77916852e-02]
[2.82902321e-01 3.82854818e-01 9.72110582e-01 6.41764840e-02 2.29831744e-01]
[4.23048152e-01 8.07057740e-01 5.42399825e-01 4.56243935e-01 5.35099209e-01]
[9.25518420e-01 6.01543526e-02 5.92246756e-01 5.86704977e-01 2.16448787e-01]
[1.69499508e-01 2.13986897e-01 4.70516150e-04 9.32854954e-01 6.37419153e-01]]
np.random.randint(100, size=(5)) # 创建5个数值范围在0~100之间的随机整数
np.random.rand(3, 4) # 创建一个形状为(3,4)，数值范围在0~1之间的矩阵
np.random.randn(10) # 创建一个长度为10，数值范围能构成正态分布（normal distribution）的数组``````

``````eye_array = np.eye(4)
"""
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]
"""``````

``````np.arange(1,5) # [1, 2, 3, 4]
np.arange(1.0, 5.0) # [1.0, 2.0, 3.0, 4.0]
np.arnage(1, 5, 0.5) # (最小值, 最大值, 步长) [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]``````

linspace 可以用来创建等分线段型的数据：

``np.linspace(0, 5, 10) # 起点是0，终点是5，将0~5的区间内平均分为10个数据，从小到大存到一个数组中``

``````np.fromfunction(lambda i, j: i == j, (2, 3), dtype=int)
[[True, False, False],
[False, True, False]]

np.fromfunction(lambda i, j: i + j, (2, 3), dtype=int)
[[0, 1, 2],
[1, 2, 3]]

def my_function(z, y, x):
return x * y + z
np.fromfunction(my_function, (3, 2, 10))
array([[[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
[ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.]],

[[ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],
[ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]],

[[ 2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.],
[ 2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11.]]])``````

## 本章函数整理

``````np.array # 创建NumPy数组
np.zeros(array_shape) # 创建只包含0的数组
np.ones(array_shape) # 创建只包含1的数组
np.full(array_shape, number) # 创建只包含一个数值的数组
np.empty(array_shape) # 创建一个不赋值的数组

np_array.shape # 包含各个维度大小的Tuple
np_array.ndim # 数据的rank数量
np_array.size # 包含元素的数量

np.array(python_list, dtype=<numpy_data_type>) # 创建指定数据类型的NumPy数组
np.reshape(original_array, new_shape) # 创建一个不同形状的数组
numpy_array.ravel() # 指向相同数据的新数组
numpy_array.copy() # 复制一个NumPy数组

np_array1 + np_array2 # 相加
np_array1 - np_array2 # 相减
np_array1 * np_array2 # 相乘
np_array1 / np_array2 # 相除
np_array1 // np_array2 # 取整除
np_array1 % np_array2 # 取余
np_array1 ** np_array2 # 幂运算

np.random.randint(number_range, size=shape) # 创建一个取值范围在0~number_range之间的数组
np.random.rand(shape) # 创建一个数值范围在0~1之间，形状为shape的数组
np.random.randn(shape) # 创建一个数值范围能形成正态分布，形状为shape的数组

np.eye(matrix_length) # 创建对角线是1，形状是(matrix_length, matrix_length)的矩阵
np.arange(min_value, max_value, step) # 创建有固定步长，取值范围在min_value和max_value之间的数组
np.linspace(start, end, items_num) # 创建一个起点是start, 终点是end，被等分成items_num数量的数组
np.fromfunction(function, numpy_array_shape) # 使用自定义函数创建numpy数组``````

视频纲要:
00:53 - 创建数组常见函数
12:14 - 常用算术运算函数
13:31 - 其他创建数组有用的函数
#numpy

1647375120

## 【NumPy快速入门】如何创建NumPy数组？创建NumPy数组常用函数

``````import numpy as np
np_array = np.array([1, 2, 3])
print(type(np_array)) # <class 'numpy.ndarray'>
print(np_array.shape) # (3,)``````

``````zero_array = np.zeros((5)) # [0. 0. 0. 0. 0.]
one_array = np.ones((4,4))
"""
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
"""
full_array = np.full((3,3), 7)
"""
[[7 7 7]
[7 7 7]
[7 7 7]]
"""
empty_array = np.empty((2, 3)) # 无法预测其数值，内存里有什么就是什么
"""
[[1.94830084e-316 0.00000000e+000 0.00000000e+000]
[0.00000000e+000 0.00000000e+000 0.00000000e+000]]
"""``````

## Axis and Data Type

``````zero_array = np.zeros((3, 4))
zero_array
"""
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
"""
zero_array.shape # (3, 4)
zero_array.ndim # 2
zero_array.size # 12``````

``````int_array = np.array([1, 2])
int_array.dtype # int64
float_array = np.array([1.0, 2.0])
float_array.dtype # float64
float_array.itemsize # 每个元素的大小 8
float32_array = np.array([1, 2], dtype=np.float32)
float32_array.dtype # float64
float32_array.itemsize # 4``````

``````x = np.array([[1, 2, 3], [4, 5, 6]])
x.ndim # 2
x.shape = (6,) # Change its shape in place
x.ndim # 1``````

np.reshape和ravel可以创建出指向相同数据的新数组：

``````y = np.reshape(x, (3, 2)) # 创建形状不同的新数组，此数组指向相同的数据
y[0, 0] = 1000
print(x) # [1000, 2, 3, 4, 5, 6]
z = y.ravel() # 指向相同数组的新数组
z[0] = 2000
print(x) # [2000, 2, 3, 4, 5, 6]``````

``````array1 = np.arange(4)
array2 = array1.copy()
array2[0] = 2000
array1 # [0, 1, 2, 3]``````

## Arithmetic Operations

NumPy数组也支持一些常用的算数运算：

``````array1 = np.array([1, 2, 3, 4])
array2 = np.array([5, 6, 7, 8])
print(array1 + array2) # [6, 8, 10, 12]
print(array1 - array2) # [-4, -4, -4, -4]
print(array1 * array2) # [5, 12, 21, 32]
print(array1 / array2) # [0.2, 0.33333333, 0.42857143, 0.5]
print(array1 // array2) # [0, 0, 0, 0]
print(array1 % array2) # [1, 2, 3, 4]
print(array1 ** array2) # [1, 64, 2187, 65536]``````

## Useful Functions

``````np.random.random((5, 5)) # 创建数值在0~1之间的随机数数组
[[9.90294681e-01 6.51182438e-02 5.48551064e-02 4.13554785e-01 2.77916852e-02]
[2.82902321e-01 3.82854818e-01 9.72110582e-01 6.41764840e-02 2.29831744e-01]
[4.23048152e-01 8.07057740e-01 5.42399825e-01 4.56243935e-01 5.35099209e-01]
[9.25518420e-01 6.01543526e-02 5.92246756e-01 5.86704977e-01 2.16448787e-01]
[1.69499508e-01 2.13986897e-01 4.70516150e-04 9.32854954e-01 6.37419153e-01]]
np.random.randint(100, size=(5)) # 创建5个数值范围在0~100之间的随机整数
np.random.rand(3, 4) # 创建一个形状为(3,4)，数值范围在0~1之间的矩阵
np.random.randn(10) # 创建一个长度为10，数值范围能构成正态分布（normal distribution）的数组``````

``````eye_array = np.eye(4)
"""
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]
"""``````

``````np.arange(1,5) # [1, 2, 3, 4]
np.arange(1.0, 5.0) # [1.0, 2.0, 3.0, 4.0]
np.arnage(1, 5, 0.5) # (最小值, 最大值, 步长) [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]``````

linspace 可以用来创建等分线段型的数据：

``np.linspace(0, 5, 10) # 起点是0，终点是5，将0~5的区间内平均分为10个数据，从小到大存到一个数组中``

``````np.fromfunction(lambda i, j: i == j, (2, 3), dtype=int)
[[True, False, False],
[False, True, False]]

np.fromfunction(lambda i, j: i + j, (2, 3), dtype=int)
[[0, 1, 2],
[1, 2, 3]]

def my_function(z, y, x):
return x * y + z
np.fromfunction(my_function, (3, 2, 10))
array([[[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
[ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.]],

[[ 1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.],
[ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]],

[[ 2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.,  2.],
[ 2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11.]]])``````

## 本章函数整理

``````np.array # 创建NumPy数组
np.zeros(array_shape) # 创建只包含0的数组
np.ones(array_shape) # 创建只包含1的数组
np.full(array_shape, number) # 创建只包含一个数值的数组
np.empty(array_shape) # 创建一个不赋值的数组

np_array.shape # 包含各个维度大小的Tuple
np_array.ndim # 数据的rank数量
np_array.size # 包含元素的数量

np.array(python_list, dtype=<numpy_data_type>) # 创建指定数据类型的NumPy数组
np.reshape(original_array, new_shape) # 创建一个不同形状的数组
numpy_array.ravel() # 指向相同数据的新数组
numpy_array.copy() # 复制一个NumPy数组

np_array1 + np_array2 # 相加
np_array1 - np_array2 # 相减
np_array1 * np_array2 # 相乘
np_array1 / np_array2 # 相除
np_array1 // np_array2 # 取整除
np_array1 % np_array2 # 取余
np_array1 ** np_array2 # 幂运算

np.random.randint(number_range, size=shape) # 创建一个取值范围在0~number_range之间的数组
np.random.rand(shape) # 创建一个数值范围在0~1之间，形状为shape的数组
np.random.randn(shape) # 创建一个数值范围能形成正态分布，形状为shape的数组

np.eye(matrix_length) # 创建对角线是1，形状是(matrix_length, matrix_length)的矩阵
np.arange(min_value, max_value, step) # 创建有固定步长，取值范围在min_value和max_value之间的数组
np.linspace(start, end, items_num) # 创建一个起点是start, 终点是end，被等分成items_num数量的数组
np.fromfunction(function, numpy_array_shape) # 使用自定义函数创建numpy数组``````

视频纲要:
00:53 - 创建数组常见函数
12:14 - 常用算术运算函数
13:31 - 其他创建数组有用的函数
#numpy

1647396840

## Arithmetic operations

``````matrix1 = np.array([[1,2],[3,4]], dtype=np.float64)
matrix2 = np.array([[5,6],[7,8]], dtype=np.float64)

matrix1 + matrix2 # 加法
[[ 6.  8.]
[10. 12.]]

matrix1 - matrix2 # 减法
[[-4. -4.]
[-4. -4.]]

matrix1 * matrix2 # 相乘
np.multiply(matrix1, matrix2)
[[ 5. 12.]
[21. 32.]]

matrix1 / matrix2 # 相除
np.divide(matrix1, matrix2)
[[0.2        0.33333333]
[0.42857143 0.5       ]]

matrix2 // matrix1 # 整除
np.floor_divide(matrix2, matrix1)
[[5. 3.]
[2. 2.]]

matrix2 % matrix1 # 取余
np.mod(matrix2, matrix1)
[[0. 0.]
[1. 0.]]

matrix1 ** matrix2 # 幂运算
np.power(matrix1, matrix2)
[[1.0000e+00 6.4000e+01]
[2.1870e+03 6.5536e+04]]``````

## Mathematical and statistical functions

``````rand_matrix = (np.random.randint(10, 1000, size=(2,5)) - 500) / 10.0
[[ 20.   15.4 -12.8  -1.1  -8.8]
[-18.3 -19.6  20.2 -15.5  43.1]]

print(np.isnan(rand_matrix)) # 检测是否为nan
[[False False False False False]
[False False False False False]]

print(np.sign(rand_matrix)) # 检测每个元素的正负，正是1，负是-1
[[ 1.  1. -1. -1. -1.]
[-1. -1.  1. -1.  1.]]

print(np.nonzero(rand_matrix)) # 拿到数组中非零元素的位置，会返回非零元素的索引值位置
(array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1]), array([0, 1, 2, 3, 4, 0, 1, 2, 3, 4]))

print(np.ceil(rand_matrix)) # 拿到大于元素的最小整数
[[ 20.  16. -12.  -1.  -8.]
[-18. -19.  21. -15.  44.]]

print(np.cumsum(rand_matrix)) # 计算数组的累计和
[ 20.   35.4  22.6  21.5  12.7  -5.6 -25.2  -5.  -20.5  22.6]

print(np.diff(rand_matrix)) # 计算数组的离散差值
[[ -4.6 -28.2  11.7  -7.7]
[ -1.3  39.8 -35.7  58.6]]

print(np.sqrt(matrix1)) # 计算数组的正平方根
[[4.47213595 3.92428337        nan        nan        nan]
[       nan        nan 4.49444101        nan 6.56505902]]

print(np.square(rand_matrix)) # 计算数组的平方数
[[4.00000e+02 2.37160e+02 1.63840e+02 1.21000e+00 7.74400e+01]
[3.34890e+02 3.84160e+02 4.08040e+02 2.40250e+02 1.85761e+03]]

m2 = np.arange(10) * 2
np.sin(m2) # 计算数组的三角函数 sin
[ 0.          0.90929743 -0.7568025  -0.2794155   0.98935825 -0.54402111
-0.53657292  0.99060736 -0.28790332 -0.75098725]

print(np.sort(rand_matrix)) # 将数组进行排序
[[-12.8  -8.8  -1.1  15.4  20. ]
[-19.6 -18.3 -15.5  20.2  43.1]]``````

``````matrix = np.arange(10).reshape(2, 5)
[[-5 -4 -3 -2 -1]
[ 0  1  2  3  4]]

matrix.mean() # 数组中的平均数: -0.5
np.median(matrix) # 数组中的中位数: -0.5
np.argmin(matrix) # 数组中最大数的索引值: 0
np.argmax(matrix) # 数组中最大数的索引值: 9

np.sum(matrix) # 计算所有元素相加的和: -5
np.abs(matrix) # 计算数组元素的绝对值
[[5 4 3 2 1]
[0 1 2 3 4]]
np.max(matrix) # 数组中最大的数: 4

np.sum(matrix) # 计算所有元素的和: -5
np.sum(matrix, axis=0) # 按列相加之和的数组
[-5 -3 -1  1  3]
np.sum(matrix, axis=1) # 按行相加之和的数组
[-15  10]``````

## Linear Algebra

``````matrix1 = np.arange(8).reshape(2, 4)
print(matrix)
[[0 1 2 3]
[4 5 6 7]]
print(matrix.T) # 转置矩阵 Tranpose
[[0 4]
[1 5]
[2 6]
[3 7]]``````
``````matrix2 = np.arange(5)
print(matrix2)
print(matrix2.T)
[[0 1 2 3 4]]

matrix3 = matrix2.reshape(1, 5)
print(matrix3)
print(matrix3.T)
[[0]
[1]
[2]
[3]
[4]]``````

``````matrix1 = np.arange(8).reshape(2, 4)
print(matrix1)
[[0 1 2 3]
[4 5 6 7]]

matrix2 = np.arange(8).reshape(4, 2)
print(matrix2)
[[0 1]
[2 3]
[4 5]
[6 7]]

print(matrix1.dot(matrix2)) # 矩阵积
[[28 34]
[76 98]]``````

numpy.linalg 模块中有很多线性代数相关函数。 使用这个模块，可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等。

``````matrix = np.arange(9).reshape(3, 3)
inverse_matrix = np.linalg.inv(matrix) # 获得逆矩阵: 此语句会返回错误，因为该矩阵是Singular Matrix，所有没有相对性的逆矩阵

valid_matrix = np.array([[1,2,3],[5,7,11],[21,29,31]])
print(valid_matrix)
inverse_matrix = np.linalg.inv(valid_matrix) # 获得逆矩阵
print(inverse_matrix)
[[-2.31818182  0.56818182  0.02272727]
[ 1.72727273 -0.72727273  0.09090909]
[-0.04545455  0.29545455 -0.06818182]]

print(valid_matrix.dot(inverse_matrix)) # The product of a matrix by its inverse returns the identity matrix
[[ 1.00000000e+00 -1.66533454e-16  0.00000000e+00]
[ 6.31439345e-16  1.00000000e+00 -1.38777878e-16]
[ 5.21110932e-15 -2.38697950e-15  1.00000000e+00]]

print(np.eye(3)) # eye函数可以输出对角线为1的矩阵，函数内的参数代表1的个数``````

``np.linalg.det(valid_matrix) # 获得矩阵的行列式: 43.9999``

``````eigenvalues, eigenvectors = np.linalg.eig(matrix) # 计算方阵的特征值和右特征向量
print(eigenvalues)
print(eigenvectors)
print(matrix.dot(eigenvectors) - eigenvalues * eigenvectors) # M.E1 - E2.E1 = 0``````

• 2x + 6y = 6
• 5x + 3y = -9
``````coeffs = np.array([[2,6],[5,3]])
depvars = np.array([6,-9])
solution = np.linalg.solve(coeffs, depvars) # 以矩阵形式解一个线性矩阵方程
print(solution) # array([-3., 2.])

coeffs.dot(solution), depvars # (array([ 6., -9.]), array([ 6, -9]))``````

## Homework

``````matrix1 = np.arange(15).reshape(3, 5)
matrix2 = np.arange(15).reshape(5, 3)``````

``````matrix3 = np.dot(matrix1, matrix2)
matrix3 = np.sqrt(matrix3)
total_sum =np.sum(matrix3)
print(total_sum) # 143.2015963354727``````

视频纲要:
00:54 - Arithmetic operations
02:30 - Math/Stat functions
11:23 - Linear Algebra
18:47 - Homework

1647385980

## 一维数组索引

``````array = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]
print(array)

print(array[2:5]) # 第3个元素到第5个元素（不包括第五个元素） [2 3 4]

print(array[:5]) # 第1个元素到第5个元素 [0 1 2 3 4]

print(array[:-3]) # 第1个元素到倒数第4个元素（不包括倒数第3个元素） [0 1 2 3 4 5 6]

print(array[3:-1]) # 第4个元素到倒数第2个元素（不包括倒数第1个元素）[3 4 5 6 7 8]

print(array[3:-3]) # 第4个元素到倒数第4个元素 [3 4 5 6]

print(array[::-1]) # 颠倒NumPy的数组 [9 8 7 6 5 4 3 2 1 0]

print(array[2:7:3]) # 从第3个元素到7个元素（不包括第7个元素），间隔为3 [2 5]

print(array[-3:3:-1]) # 从倒数第3个元素（7），到第5个元素（4），回跳一个位置 [7 6 5 4]``````

## 二维矩阵索引

``````matrix_1 = np.arrange(20).reshape(4, 5) # 创建一个 4 * 5 的矩阵，取值范围在 0~19
[[ 0  1  2  3  4]
[ 5  6  7  8  9]
[10 11 12 13 14]
[15 16 17 18 19]]

matrix_1[0, 3] # 第1行第4列的元素：3

matrix_1[0, 1] = 100 # 第1行第2列的元素变成 100
[[  0 100   2   3   4]
[  5   6   7   8   9]
[ 10  11  12  13  14]
[ 15  16  17  18  19]]

matrix_1[2, :] # 第3行的所有元素 [10 11 12 13 14]

matrix_1[:, 2] # 第3列的所有元素 [ 2  7 12 17]

matrix_1[1:3, 2:4] # 第2行到第3行，第3列到第4列的子矩阵
[[ 7  8]
[12 13]]``````

``````matrix_1[[0, 2, 2], [0, 1, 0]] # 返回3个元素 [0 11 10] 第1个元素位置是[0,0],第2个元素位置是[2,1],第3个元素位置是[2,0]

matrix_1[[1, 0, 2], [1, 1, 1]] # 返回3个元素 [6 100 11] 第1个元素位置是[1,1],第2个元素位置是[0,1],第3个元素位置是[2,1]

matrix_1[(0, 3), 2:5] # 第1行和第4行，列数3到5
[[2, 3, 4],
[17, 18, 19]]``````

## 多维数组索引 Ellipsis(…)

``````matrix_3d = np.arange(80).reshape(4, 5, 4)
[[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]
[12 13 14 15]
[16 17 18 19]]

[[20 21 22 23]
[24 25 26 27]
[28 29 30 31]
[32 33 34 35]
[36 37 38 39]]

[[40 41 42 43]
[44 45 46 47]
[48 49 50 51]
[52 53 54 55]
[56 57 58 59]]

[[60 61 62 63]
[64 65 66 67]
[68 69 70 71]
[72 73 74 75]
[76 77 78 79]]]

matrix_3d[2, ...] # 矩阵3中所有的元素
[[40 41 42 43]
[44 45 46 47]
[48 49 50 51]
[52 53 54 55]
[56 57 58 59]]

matrix_3d[0, 2, ...] # 矩阵1中，第3行所有的列
[ 8  9 10 11]

matrix_3d[3, ..., 2] # 矩阵4中，所有行，第3列

matrix_3d[3, :, 2] # 矩阵4中，所有行，第3列``````

``````matrix2 = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
print(matrix2)
[[ 1  2  3]
[ 4  5  6]
[ 7  8  9]
[10 11 12]]

vector = np.array([0, 2, 0, 1])
print(matrix2[np.arange(4), vector]) # 拿到以下4个位置的元素: [0,0],[1,2],[2,0],[3,1]
[ 1  6  7 11]

matrix2[np.arange(4), vector] += 10 # 给特定位置上的元素加10
print(matrix2)
[[11  2  3]
[ 4  5 16]
[17  8  9]
[10 21 12]]``````

## 布尔索引(Boolean Indexing)

``````matrix3 = np.array([[1, 2], [3, 4], [5, 6]])
bool_idx = matrix3 > 2 # 拿到一个布尔数组，其中元素代表相应位置的元素是否大与2
[[False False]
[ True  True]
[ True  True]]

matrix3[bool_idx] # 使用布尔数组，获取矩阵中大于2的值
[3 4 5 6]

matrix3 = np.arange(0, 15).reshape(3, 5)
matrix3[matrix3 > 2] # 拿到矩阵中所有大于2的元素
[ 3  4  5  6  7  8  9 10 11 12 13 14]

print(matrix3[matrix3 % 2 == 1]) # 拿到矩阵中所有不能整除2的元素(奇数)
[ 1  3  5  7  9 11 13]``````

``````matrix4 = np.arange(36).reshape(3, 12)
[[ 0  1  2  3  4  5  6  7  8  9 10 11]
[12 13 14 15 16 17 18 19 20 21 22 23]
[24 25 26 27 28 29 30 31 32 33 34 35]]

rows_on = [True, False, True]
cols_on = np.arange([False, True, False] * 4)

matrix4[np.ix_(rows_on, cols_on)]) # 拿到一个特定的子矩阵：第一个维度位置是1和3，第二个维度位置是1,4,7,10
[[ 1  4  7 10]
[25 28 31 34]]``````

## 迭代 (Iterating)

``````two_d_matrix = np.arange(24).reshape(2, 12)

for row in two_d_matrix: # 迭代row
print(row)
[ 0  1  2  3  4  5  6  7  8  9 10 11]
...

for column in two_d_matrix.T: # .T会转置矩阵，然后迭代row，就会迭代原来的col
print(column)
[ 0 12]
[ 1 13]
...

three_d_matrix = np.arange(24).reshape(2, 3, 4)
[[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]]

[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
for item in three_d_matrix: # 迭代每个矩阵
print(item)
[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]]
...``````
``````for item in three_d_matrix.flat: # 迭代所有的元素
print(item)``````

## 课后练习答案

``np_array = np.arange(45).reshape((3,3,5))``

``````def np_operator(input_array):
input_array[1, (0, 2), 1:4] = 1
print(input_array)
input_array[input_array % 2 == 1] = 1
input_array[input_array % 2 == 0] = 0
print(input_array)
input_array.shape = (9, 5)
print(input_array)
return input_array

new_np_array = np_operator(np_array)``````

00:49 - 1D Array Indexing
05:34 - 2D Matrix Indexing
10:49 - Higher Dimensions Indexing
17:29 - Boolean Indexing
24:40 - Iterating
26:59 - Homework

1647364320

## 什么是Numpy？

### Python Array 和 Numpy Array 的区别

1. 处理数组更快：NumPy和Pandas的底层逻辑是用C语言写的，C这种底层语言自然能更快更有效率地调用电脑资源。
2. 处理数组更灵活：NumPy 库中提供更多处理 Array 的方式，比如合并分割数组、对数组进行统计计算等等。

## NumPy基本功能演示

``import numpy as np``

``````np_array = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(np_array) # 打印出numpy数组
print(np_array.shape) # 打印每个维度上的数组量：(2, 4)``````

numpy中还有一些很便捷的方式，帮助我们创建出特定的数组，比如下面这段代码，就会创建出一个10行10列的数组，其中的数字都是数据类型为float的1.0：

``````np_array = np.ones((10, 10), dtype = np.float)
print(np_array)``````

numpy array 的形状还能被改变，可以简单理解为一个数组的行数和列数被改变，但是其中的数字不变：

``reshaped_np_array = np_array.reshape((2, 50))``

### Numpy vs Python List

``````import sys
python_list = range(1000)
print(f'Python list size: {sys.getsizeof(python_list) * len(python_list)}') # 48000
np_array = np.arange(1000)
print(f'Numpy Array size: {np_array.size * np_array.itemsize}') # 8000``````

``````import time
array_size = 100000
python_list1 = range(array_size)
python_list2 = range(array_size)

start_time = time.time()
python_multiplication = [(n1 * n2) for n1, n2 in zip(python_list1, python_list2)]
print(f'Python multiplication time used: {time.time() - start_time}') # 0.012480020523071289

np_array1 = np.arange(array_size)
np_array2 = np.arange(array_size)

start_time = time.time()
numpy_multiplication = np_array1 * np_array2
print(f'Numpy multiplication time used: {time.time() - start_time}') # 0.0008220672607421875``````

numpy array 还自带一些统计函数，帮助我们很方便地从数组中获得有用的统计数据：

``````np_array = np.arange(1, 21).reshape((4, 5))
print(np.argmin(np_array)) # 0
print(np.argmax(np_array)) # 19
print(np.mean(np_array)) # 10.5
print(np.median(np_array)) # 10.5``````

``````from numpy import savetxt
np_array = np.array([1, 2, 3, 4, 5])
savetxt('data.csv', np_array, delimiter=',')
print(np_array)

print(data.astype(np.int))``````

## NumPy课程大纲

1. Numpy Array 创建
2. Array Indexing 索引
3. Array Math 数学
5. 合并和分割 Numpy Array

视频纲要:
01:49​ - 什么是NumPy?
05:21​ - NumPy代码演示
16:10 - 《NumPy入门教程》大纲
#numpy

1647407700

## Transposing Array 数组变位

``````m1 = np.arange(6).reshape((2, 3))
print(m1)
[[0 1 2]
[3 4 5]]
print(np.transpose(m1)) # 将矩阵的维度进行对换
[[0 3]
[1 4]
[2 5]]

m2 = np.ones((1, 2, 3))
print(np.transpose(m2, (1, 0, 2)).shape) # 将原数组的维度(0, 1, 2)换成(1, 0, 2)

m3 = np.ones((2, 3, 4, 5))
print(np.transpose(m3).shape) # 对换m3矩阵所有的维度(0, 1, 2, 3)换成(3, 2, 1, 0)

m4 = np.arange(24).reshape(2, 3, 4)
print(m4)
[[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]]

[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]

m5 = m4.transpose((2, 0, 1)) # 维度对换：(2, 3, 4) => (4, 2, 3)
print(m5)
[[[ 0  4  8]
[12 16 20]]

[[ 1  5  9]
[13 17 21]]

[[ 2  6 10]
[14 18 22]]

[[ 3  7 11]
[15 19 23]]]

m6 = m4.swapaxes(0, 1) # 置换特定的维度：(2, 3, 4) => (3, 2, 4)
print(m6)``````

## Stacking Arrays 合并

``````array1 = np.full((1, 5), 1.0)
array2 = np.full((1, 5), 2.0)
stacked_array = np.vstack((array1, array2)) # 竖直合并序列中的数组（行方向）
print(stacked_array)
[[1. 1. 1. 1. 1.]
[2. 2. 2. 2. 2.]]``````
``````matrix1 = np.full((3, 2), 1.0)
matrix2 = np.full((3, 2), 2.0)
stacked_matrix = np.hstack((matrix1, matrix2)) # 水平合并序列中的数组（列方向）
print(stacked_matrix)
[[1. 1. 2. 2.]
[1. 1. 2. 2.]
[1. 1. 2. 2.]]``````

``````cmatrix1 = np.concatenate((matrix1, matrix2), axis = 0) # 和vstack相同
cmatrix2 = np.concatenate((matrix1, matrix2), axis = 1) # 和hstack相同
print(cmatrix1)
[[1. 1.]
[1. 1.]
[1. 1.]
[2. 2.]
[2. 2.]
[2. 2.]]
print(cmatrix2)
[[1. 1. 2. 2.]
[1. 1. 2. 2.]
[1. 1. 2. 2.]]``````
``````matrix1 = np.full((3, 3), 1)
matrix2 = np.full((3, 3), 2)

matrix3 = np.stack((matrix1, matrix2)) # 沿着新轴将矩阵合并，要保持两个矩阵形状一致
print(matrix3)
[[[1 1 1]
[1 1 1]
[1 1 1]]

[[2 2 2]
[2 2 2]
[2 2 2]]]``````

## Splitting Array 分割

NumPy还能使用相似的功能分割数组：

``````big_matrix = np.arange(36).reshape(9, 4)
print(big_matrix)
[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]
[24 25 26 27]
[28 29 30 31]
[32 33 34 35]]``````
``````m1, m2, m3 = np.vsplit(big_matrix, 3) # 将一个数组垂直分割成多个子数组（按行）
print(m1)
[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]]
print(m2)
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
print(m3)
[[24 25 26 27]
[28 29 30 31]
[32 33 34 35]]``````
``````m4, m5 = np.hsplit(big_matrix, 2) # 将一个数组水平分割为多个子数组（按列）
print(m4)
[[ 0  1]
[ 4  5]
[ 8  9]
[12 13]
[16 17]
[20 21]
[24 25]
[28 29]
[32 33]]
print(m5)
[[ 2  3]
[ 6  7]
[10 11]
[14 15]
[18 19]
[22 23]
[26 27]
[30 31]
[34 35]]``````

## Tile

Tile函数可以重复某个数组以构成一个新的数组：

``````m1 = np.arange(4)
print(m1)
print()
m2 = np.tile(m1, (4, 1)) # 重复4个m2矩阵，并将它们按行合并
print(m2)
[[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]]
m3 = np.tile(m1, (4, 2)) # 重复8个矩阵，4个按行合并，4个按列合并
print(m3)
[[0 1 2 3 0 1 2 3]
[0 1 2 3 0 1 2 3]
[0 1 2 3 0 1 2 3]
[0 1 2 3 0 1 2 3]]``````

## 重要机制

``````m1 = np.arange(4).reshape(1, 1, 4)
print(m1)
[[[0 1 2 3]]]
print(m1 + [10, 10, 20, 20]) # 等于：m1 + [[[10, 10, 20, 20]]]（形状(1,1,4)）
[[[10 11 22 23]]]``````

``````m2 = np.arange(6).reshape(2, 3)
print(m2)
[[0 1 2]
[3 4 5]]
print(m2 + [[10], [20]]) # 等于: m2 + [[10, 10, 10], [20, 20, 20]]
[[10 11 12]
[23 24 25]]
print(m2 + [10, 20, 30]) # 规则1：[[10,20,30]] => 规则2：[[10,20,30],[10,20,30]]
[[10 21 32]
[13 24 35]]
print(m2 + 100) # 与之相同的逻辑: m2 + [[100, 100, 100], [100, 100, 100]]
[[100 101 102]
[103 104 105]]``````
``````m3 = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])
[[ 1  2  3]
[ 4  5  6]
[ 7  8  9]
[10 11 12]]
m4 = np.array([1, 0, 1])
[1 0 1]
m5 = m3 + m4  # 使用广播将 m4 加到 m3 的每一行上
print(m5)
[[ 2  2  4]
[ 5  5  7]
[ 8  8 10]
[11 11 13]]``````

``````try:
m1 = np.arange(4).reshape(1, 1, 4)
m1 + [33, 44] # 规则3会引发异常
except ValueError as e:
print(e) ``````

### Upcasting

``````m1 = np.arange(0, 5, dtype=np.int8)
print(m1.dtype, m1) # uint8

m2 = m1 + np.array([5, 6, 7, 8, 9], dtype=np.int16)
print(m2.dtype, m2) # int16

m3 = m1 + 1.5
print(m3.dtype, m3) # float64``````

## Homework

``````m1 = np.arange(8).reshape(2, 4)
m2 = np.arange(8).reshape(2, 4)``````

``````m3 = np.vstack((m1, m2))
print(m3)
print('********')
m4, m5 = np.hsplit(m3, 2)
print(m4)
print('********')
m6 = np.tile(m4, (1, 2))
print(m6)``````

视频纲要:
00:56 - Transposing Array
05:00 - Stacking Array
08:27 - Splitting Array
09:53 - Tile