NumPy（“Numerical Python”或“Numeric Python”的缩写）是 Python 中对数组和矩阵进行快速数学计算的最基本的软件包之一。在处理多维数据时它也非常有用。集成C、C++和FORTRAN工具是一件幸事。它还提供了许多傅里叶变换 (FT) 和线性代数函数。
为什么使用 NumPy 而不是列表？
人们可能会想到为什么我们应该更喜欢 NumPy 中的数组，而不是我们可以创建具有相同数据类型的列表。如果这句话也引起了你的注意，那么以下原因可能会说服你：
- Numpy 数组具有连续的内存分配。因此，如果将相同的数组存储为列表，则与数组相比将需要更多的空间。
- 它们的使用速度更快，因此比列表更高效。
- 他们打交道更方便。
NumPy 与 Pandas
Pandas 构建在 NumPy 之上。换句话说，pandas 需要 Numpy 才能使其工作。所以 Pandas 并不是 Numpy 的替代品。相反，pandas 提供了额外的方法或提供了在 Python 中处理数字和表格数据的更简化的方式。
导入numpy
首先，您需要导入 numpy 库。可以通过运行以下命令来导入 numpy：
将 numpy 导入为 np
这是导入 numpy 的通用方法，别名为“np”。如果未提供别名，那么要从 numpy 访问函数，我们将编写numpy.function。为了方便起见，引入了别名“np”，以便我们可以编写np.function。下面列出了 numpy 的一些常用函数 -
| 功能 | 任务 |
|---|---|
| 大批 | 创建 numpy 数组 |
| 这就是我 | 数组的维数 |
| 形状 | 数组的大小（行数和列数） |
| 尺寸 | 数组中元素的总数 |
| 数据类型 | 数组中元素的类型，即int64、character |
| 重塑 | 在不改变原始形状的情况下重塑数组 |
| 调整大小 | 重塑数组。也改变原来的形状 |
| 排列 | 在数组中创建数字序列 |
| 商品尺寸 | 每个项目的大小（以字节为单位） |
| 诊断 | 创建对角矩阵 |
| 虚拟堆栈 | 垂直堆叠 |
| 栈 | 水平堆叠 |
一维数组 使用 numpy 可以使用np.array
创建数组：
a = np.array([15,25,14,78,96])
a
print(a)
a
Output: array([15, 25, 14, 78, 96])
print(a)
Output: [15 25 14 78 96]
请注意，np.array 中存在方括号。缺少方括号会导致错误。要打印数组，我们可以使用print(a) 。
更改数据类型 np.array( ) 有一个附加的dtype
参数，通过该参数可以定义元素是整数、浮点还是复数。
a.dtype
a = np.array([15,25,14,78,96],dtype = "float")
a
a.dtype
最初 'a' 的数据类型是 'int32' ，修改后变为 'float64' 。
-
int32指的是没有小数点的数字。'32' 表示数字可以在 -2147483648 和 2147483647 之间。类似地，int16 表示数字可以在 -32768 到 32767 范围内
-
float64指的是带有小数位的数字。
创建数字序列
如果您想创建数字序列，那么使用np.arange， 我们可以获得我们的序列。要获取从 20 到 29 的数字序列，我们运行以下命令。
b = np.arange(start = 20,stop = 30, step = 1)
b
array([20, 21, 22, 23, 24, 25, 26, 27, 28, 29])
在np.arange中，终点始终被排除。
np.arange提供了一个步长选项，它定义了两个连续数字之间的差异。如果未提供步骤，则默认采用值 1。
假设我们要创建一个初始项为 20、公差为 2 的等差级数30 被排除在外。
c = np.arange(20,30,2) #30 is excluded.
c
array([20, 22, 24, 26, 28])
需要注意的是，在 np.arange( ) 中，stop 参数始终被排除。
数组中的索引
需要注意的是，Python 索引从 0 开始。索引的语法如下 -
-
x[start:end:step] ：数组 x 中的元素从开始到结束（但不包括结束），默认步长值为 1。
-
x[start:end] ：数组 x 中的元素从开始到结束（但不包括结束）
-
x[start:] ：元素从末尾开始
-
x[:end] ：从开头到结尾的元素（但不包括结尾）
如果我们想提取第三个元素，我们将索引写为 2，因为它从 0 开始。
x = np.arange(10)
x[2]
x[2:5]
x[::2]
x[1::2]
x
Output: [0 1 2 3 4 5 6 7 8 9]
x[2]
Output: 2
x[2:5]
Output: array([2, 3, 4])
x[::2]
Output: array([0, 2, 4, 6, 8])
x[1::2]
Output: array([1, 3, 5, 7, 9])
请注意，在x[2:5] 中，选择从第 2 个索引开始到第 5 个索引（不包括）的元素。
如果我们想要更改从索引 7 开始到索引 7（不包括 7）的所有元素的值，步长为 3，即 123，我们可以这样写：
x[:7:3] = 123
x
array([123, 1, 2, 123, 4, 5, 123, 7, 8, 9])
为了反转给定的数组，我们编写：
x = np.arange(10)
x[ : :-1] # reversed x
array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])
请注意，上述命令不会修改原始数组。
重塑数组
要重塑数组，我们可以使用reshape()。
f = np.arange(101,113)
f.reshape(3,4)
f
array([101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112])
请注意，reshape() 不会改变原始数组的形状。因此，要修改原始数组，我们可以使用resize( )
f.resize(3,4)
f
array([[101, 102, 103, 104],
[105, 106, 107, 108],
[109, 110, 111, 112]])
如果在重塑中将某个维度指定为 -1，则只要给定维度是数组中元素总数的倍数，就会自动计算其他维度。
f.reshape(3,-1)
array([[101, 102, 103, 104],
[105, 106, 107, 108],
[109, 110, 111, 112]])
在上面的代码中，我们只指定了 3 行。Python 自动计算其他维度的元素数量，即 4 列。
缺失数据
缺失的数据由 NaN（Not a Number 的缩写）表示。您可以使用命令np.nan
val = np.array([15,10, np.in , 3, 2, 5, 6, 4])
val.sum()
Out: nan
要忽略缺失值，可以使用np.nansum(val) ，它返回 45
要检查数组是否包含缺失值，可以使用函数isnan( )
np.isnan(val)
2D 数组
numpy 中的 2D 数组可以通过以下方式创建：
g = np.array([(10,20,30),(40,50,60)])
#或者
g = np.array([[10,20,30],[40,50,60]])
G
维度、元素总数和形状可以分别通过ndim、size和shape确定：
g.ndim
g.size
g.shape
g.ndim
Output: 2
g.size
Output: 6
g.shape
Output: (2, 3)
创建一些常用矩阵
numpy 提供了创建一些常用于线性代数的常用矩阵的实用程序。
要创建 2 行 4 列全零矩阵，我们可以使用np.zeros( ) ：
np.zeros( (2,4) )
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]])
这里还可以指定 dtype。对于零矩阵，默认数据类型是“float”。要将其更改为整数，我们编写 “dtype = np.int16”
np.zeros([2,4],dtype=np.int16)
array([[0, 0, 0, 0],
[0, 0, 0, 0]], dtype=int16)
为了获得从 0 到 1 的所有随机数的矩阵，我们编写np.empty。
np.empty( (2,3) )
array([[ 2.16443571e-312, 2.20687562e-312, 2.24931554e-312],
[ 2.29175545e-312, 2.33419537e-312, 2.37663529e-312]])
注意：每次运行 np.empty 时结果可能会有所不同 。
为了创建统一矩阵，我们编写np.ones( ) 。我们可以通过以下方式创建一个全为 3 * 3 的矩阵：
np.ones([3,3])
array([[ 1., 1., 1.],
[ 1., 1., 1.],
[ 1., 1., 1.]])
要创建对角矩阵，我们可以编写np.diag( ) 。要创建对角线元素为 14、15、16 和 17 的对角矩阵，我们编写：
np.diag([14,15,16,17])
array([[14, 0, 0, 0],
[ 0, 15, 0, 0],
[ 0, 0, 16, 0],
[ 0, 0, 0, 17]])
要创建单位矩阵，我们可以使用np.eye( ) 。
np.eye(5,dtype = "int")
array([[1, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 0, 1]])
默认情况下，np.eye() 中的数据类型是“float”，因此我们编写 dtype = "int" 将其转换为整数。
重塑 2D 数组
要获得展平的 1D 数组，我们可以使用ravel( )
g = np.array([(10,20,30),(40,50,60)])
g.ravel()
array([10, 20, 30, 40, 50, 60])
要改变二维数组的形状，我们可以使用reshape。写入-1会自动计算另一个维度，并且不会修改原始数组。
g.reshape(3,-1) # 返回形状修改后的数组
它不会修改原始数组
g.shape
(2, 3)
与一维数组类似，使用resize( ) 将修改原始数组中的形状。
g.resize((3,2))
g #resize修改原数组
array([[10, 20],
[30, 40],
[50, 60]])
是时候学习一些矩阵代数了
让我们创建一些数组 A、b 和 B，它们将用于本节：
A = np.array([[2,0,1],[4,3,8],[7,6,9]])
b = np.array([1,101,14])
B = np.array( [[10,20,30],[40,50,60],[70,80,90]]）
为了获得转置、迹和逆，我们分别使用A.transpose( ) 、 np.trace( ) 和np.linalg.inv( ) 。
A.T #transpose
A.transpose() #transpose
np.trace(A) # trace
np.linalg.inv(A) #Inverse
A.transpose() #transpose
Output:
array([[2, 4, 7],
[0, 3, 6],
[1, 8, 9]])
np.trace(A) # trace
Output: 14
np.linalg.inv(A) #Inverse
Output:
array([[ 0.53846154, -0.15384615, 0.07692308],
[-0.51282051, -0.28205128, 0.30769231],
[-0.07692308, 0.30769231, -0.15384615]])
请注意，转置不会修改原始数组。
矩阵加法和减法可以用通常的方式完成：
A+B
A-B
A+B
Output:
array([[12, 20, 31],
[44, 53, 68],
[77, 86, 99]])
A-B
Output:
array([[ -8, -20, -29],
[-36, -47, -52],
[-63, -74, -81]])
A 和 B 的矩阵乘法可以通过 A.dot(B) 完成。其中 A 将是左侧的第一个矩阵，B 将是右侧的第二个矩阵。
A.点(B)
array([[ 90, 120, 150],
[ 720, 870, 1020],
[ 940, 1160, 1380]])
为了求解线性方程组：Ax = b，我们使用np.linalg.solve( )
np.linalg.solve(A,b)
array([-13.92307692, -24.69230769, 28.84615385])
特征值和特征向量可以使用np.linalg.eig( ) 计算
np.linalg.eig(A)
(array([ 14.0874236 , 1.62072127, -1.70814487]),
array([[-0.06599631, -0.78226966, -0.14996331],
[-0.59939873, 0.54774477, -0.81748379],
[-0.7977253 , 0.29669824, 0.55608566]]))
第一行是各种特征值，第二个矩阵表示特征向量矩阵，其中每一列是对应特征值的特征向量。
一些数学函数
我们可以使用 numpy 得到各种三角函数，如正弦、余弦等：
B = np.array([[0,-20,36],[40,50,1]])
np.sin(B)
array([[ 0. , -0.91294525, -0.99177885],
[ 0.74511316, -0.26237485, 0.84147098]])
结果是所有 sin( ) 元素的矩阵。
为了获得指数，我们使用 ******
B**2
array([[ 0, 400, 1296],
[1600, 2500, 1]], dtype=int32)
我们得到 B 的所有元素的平方矩阵。
为了获得矩阵的元素是否满足条件，我们需要编写条件。例如，要检查 B 的元素是否超过 25，我们编写：
B>25
array([[False, False, True],
[ True, True, False]], dtype=bool)
我们得到一个布尔矩阵，其中 True 表示相应元素大于 25，False 表示不满足条件。
以类似的方式，np.absolute、np.sqrt和np.exp分别返回绝对数、平方根和指数的矩阵。
np.absolute(B)
np.sqrt(B)
np.exp(B)
现在我们考虑形状为 3*3 的矩阵 A：
A = np.arange(1,10).reshape(3,3)
A
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
为了分别求总和、最小值、最大值、平均值、标准差和方差，我们使用以下命令：
A.sum()
A.min()
A.max()
A.mean()
A.std() #标准差
A.var() #方差
A.sum()
Output: 45
A.min()
Output: 1
A.max()
Output: 9
A.mean()
Output: 5.0
A.std() #Standard deviation
Output: 2.5819888974716112
A.var()
Output: 6.666666666666667
为了获得最小和最大元素的索引，我们分别使用argmin() 和argmax() 。
A.argmin()
A.argmax()
A.argmin()
Output: 0
A.argmax()
Output: 8
如果我们希望找到每一行或每一列的上述统计信息，那么我们需要指定轴：
A.sum(轴=0)
A.mean(轴=0)
A.std(轴=0)
A.argmin(轴=0)
A.sum(axis=0) # sum of each column, it will move in downward direction
Output: array([12, 15, 18])
A.mean(axis = 0)
Output: array([ 4., 5., 6.])
A.std(axis = 0)
Output: array([ 2.44948974, 2.44948974, 2.44948974])
A.argmin(axis = 0)
Output: array([0, 0, 0], dtype=int64)
通过定义axis = 0， 计算将向下移动，即它将给出每列的统计数据。为了找到每行的最小值和最大元素的索引，我们需要向右移动，所以我们写axis = 1：
A.min(轴=1)
A.argmax(轴=1)
A.min(axis=1) # min of each row, it will move in rightwise direction
Output: array([1, 4, 7])
A.argmax(axis = 1)
Output: array([2, 2, 2], dtype=int64)
为了找到每行的累积和，我们使用cumsum( )
A.cumsum(轴=1)
array([[ 1, 3, 6],
[ 4, 9, 15],
[ 7, 15, 24]], dtype=int32)
创建 3D 数组
Numpy 还提供创建 3D 数组的工具。3D 数组可以创建为：
X = np.array( [[[ 1, 2,3],
[ 4, 5, 6]],
[[7,8,9],
[10,11,12]]])
X.shape
X.ndim
X尺寸
X 包含两个 2D 数组，因此形状为 2,2,3。元素总数为 12。
为了计算沿特定轴的总和，我们使用 axis 参数，如下所示：
X.sum(轴 = 0)
X.sum(轴 = 1)
X.sum(轴 = 2)
X.sum(axis = 0)
Output:
array([[ 8, 10, 12],
[14, 16, 18]])
X.sum(axis = 1)
Output:
array([[ 5, 7, 9],
[17, 19, 21]])
X.sum(axis = 2)
Output:
array([[ 6, 15],
[24, 33]])
axis = 0 返回每个二维数组对应元素的总和。axis = 1 返回每个矩阵中每列元素的总和，而 axis = 2 返回每个矩阵中每行元素的总和。
X.ravel()
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
ravel( ) 将所有元素写入单个数组中。
考虑一个 3D 数组：
X = np.array( [[[ 1, 2,3],
[ 4, 5, 6]],
[[7,8,9],
[10,11,12]]])
为了提取第二个矩阵，我们编写：
X[1,...] # 与 X[1,:,:] 或 X[1] 相同
array([[ 7, 8, 9],
[10, 11, 12]])
请记住，Python 索引从 0 开始，这就是为什么我们编写 1 来提取第二个二维数组。
要从我们编写的所有行中提取第一个元素：
X[...,0] # 与 X[:,:,0] 相同
array([[ 1, 4],
[ 7, 10]])
找出满足给定条件的元素的位置
a = np.array([8, 3, 7, 0, 4, 2, 5, 2])
np.where(a > 4)
array([0, 2, 6]
np.where定位数组中数组元素大于 4 的位置。
使用索引数组进行索引
考虑一维数组。
x = np.arange(11,35,2)
x
array([11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33])
我们形成一个一维数组 i，它对 x 的元素进行子集化，如下所示：
i = np.array( [0,1,5,3,7,9 ] )
x[i]
array([11, 13, 21, 17, 25, 29])
以类似的方式，我们创建一个 2D 数组 j，其索引为子集 x。
j = np.array( [ [ 0, 1], [ 6, 2 ] ] )
x[j]
array([[11, 13],
[23, 15]])
类似地，我们可以将 i 和 j 创建为 x 的索引的二维数组
x = np.arange(15).reshape(3,5)
x
i = np.array( [ [0,1], # 第一个暗淡的索引
[2,0] ] )
j = np.array( [ [ 1,1], # 第二个暗淡的索引
[2,0] ] )
为了获取行中的第 i 个索引和列的第 j 个索引，我们编写：
x[i,j] # i 和 j 必须具有相同的形状
array([[ 1, 6],
[12, 0]])
要从第三列中提取第 i 个索引，我们编写：
x[i,2]
array([[ 2, 7],
[12, 2]])
对于每一行，如果我们想找到第 j 个索引，我们可以这样写：
x[:,j]
array([[[ 1, 1],
[ 2, 0]],
[[ 6, 6],
[ 7, 5]],
[[11, 11],
[12, 10]]])
固定第 1 行和第 j 个索引，固定第 2 行第 j 个索引，固定第 3 行和第 j 个索引。
您还可以使用数组索引来分配值：
x = np.arange(10)
x
x[[4,5,8,1,2]] = 0
x
array([0, 0, 0, 3, 0, 0, 6, 7, 0, 9])
0 被分配给 x 的第 4、5、8、1 和 2 个索引。
当索引列表包含重复项时，它将最后一个值分配给该索引：
x = np.arange(10)
x
x[[4,4,2,3]] = [100,200,300,400]
x
array([ 0, 1, 300, 400, 200, 5, 6, 7, 8, 9])
请注意，对于第 5 个元素（即第 4 个索引），分配的值是 200，而不是 100。
注意：如果对重复索引使用 += 运算符，则它仅对重复索引执行一次运算符。
x = np.arange(10)
x[[1,1,1,7,7]]+=1
x
array([0, 2, 2, 3, 4, 5, 6, 8, 8, 9])
虽然索引 1 和 7 重复，但它们仅递增一次。
使用布尔数组索引
我们创建一个 2D 数组并将条件存储在 b 中。如果条件为真，则结果为 True，否则为 False。
a = np.arange(12).reshape(3,4)
b = a > 4
b
array([[False, False, False, False],
[False, True, True, True],
[ True, True, True, True]], dtype=bool)
请注意，“b”是一个布尔值，其形状与“a”相同。
要从“a”中选择符合条件“b”的元素，我们编写：
一个[b]
array([ 5, 6, 7, 8, 9, 10, 11])
现在 'a' 变成带有选定元素的一维数组
此属性在赋值中非常有用：
a[b] = 0
a
array([[0, 1, 2, 3],
[4, 0, 0, 0],
[0, 0, 0, 0]])
'a' 中大于 4 的所有元素都变为 0
正如整数索引中所做的那样，我们可以通过布尔值进行索引：
设 x 为原始矩阵，'y' 和 'z' 为布尔值数组以选择行和列。
x = np.arange(15).reshape(3,5)
y = np.array([True,True,False]) # 第一个暗淡选择
z = np.array([True,True,False,True,False] ) # 第二个暗淡选择
我们编写 x[y,:] ，它将仅选择 y 为 True 的行。
x[y,:] # 选择行
x[y] # 相同的事情
写入 x[:,z] 将仅选择 z 为 True 的那些列。
x[:,z] # 选择列
x[y,:] # selecting rows
Output:
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
x[y] # same thing
Output:
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
x[:,z] # selecting columns
Output:
array([[ 0, 1, 3],
[ 5, 6, 8],
[10, 11, 13]])
Pandas DataFrame 的统计数据
让我们创建虚拟数据框进行说明：
np.random.seed(234)
mydata = pd.DataFrame({"x1" : np.random.randint(low=1, high=100, size=10),
"x2" : range(10)
})
1.计算数据框每列的平均值
np.mean(mydata)
2.计算数据框每列的中位数
np.中位数（mydata，轴=0）
axis = 0表示将在每列上运行中值函数。axis = 1 表示要在每一行上运行的函数。
堆叠各种数组
让我们考虑 2 个数组 A 和 B：
A = np.array([[10,20,30],[40,50,60]])
B = np.array([[100,200,300],[400,500,600]])
为了垂直连接它们，我们使用np.vstack( )。
np.vstack((A,B)) #垂直堆叠
array([[ 10, 20, 30],
[ 40, 50, 60],
[100, 200, 300],
[400, 500, 600]])
为了水平连接它们，我们使用 np.hstack( )。
np.hstack((A,B)) #水平堆叠
array([[ 10, 20, 30, 100, 200, 300],
[ 40, 50, 60, 400, 500, 600]])
newaxis 有助于将一维行向量转换为一维列向量。
from numpy import newaxis
a = np.array([4.,1.])
b = np.array([2.,8.])
a[:,newaxis]
array([[ 4.],
[ 1.]])
#函数np.column_stack( ) 将一维数组作为列堆叠到二维数组中。它仅相当于一维数组的 hstack：
np.column_stack((a[:,newaxis],b[:,newaxis]))
np.hstack((a[:,newaxis],b[:,newaxis])) # 与column_stack相同
np.column_stack((a[:,newaxis],b[:,newaxis]))
Output:
array([[ 4., 2.],
[ 1., 8.]])
np.hstack((a[:,newaxis],b[:,newaxis]))
Output:
array([[ 4., 2.],
[ 1., 8.]])
拆分数组
考虑一个包含 15 个元素的数组“z”：
z = np.arange(1,16)
使用np.hsplit( ) 可以分割数组
np.hsplit(z,5) # 将a分割成5个数组
[array([1, 2, 3]),
array([4, 5, 6]),
array([7, 8, 9]),
array([10, 11, 12]),
array([13, 14, 15])]
它将“z”分成 5 个等长的数组。
传递 2 个元素后，我们得到：
例如hsplit(z,(3,5))
[array([1, 2, 3]),
array([4, 5]),
array([ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])]
它在第三个和第五个元素之后分割“z”。
对于 2D 数组，np.hsplit() 的工作原理如下：
A = np.arange(1,31).reshape(3,10)
A
np.hsplit(A,5) # 将a拆分为5个数组
[array([[ 1, 2],
[11, 12],
[21, 22]]), array([[ 3, 4],
[13, 14],
[23, 24]]), array([[ 5, 6],
[15, 16],
[25, 26]]), array([[ 7, 8],
[17, 18],
[27, 28]]), array([[ 9, 10],
[19, 20],
[29, 30]])]
在上面的命令中，A 被分成 5 个形状相同的数组。
要在第三列和第五列之后进行拆分，我们编写：
np.hsplit(A,(3,5))
[array([[ 1, 2, 3],
[11, 12, 13],
[21, 22, 23]]), array([[ 4, 5],
[14, 15],
[24, 25]]), array([[ 6, 7, 8, 9, 10],
[16, 17, 18, 19, 20],
[26, 27, 28, 29, 30]])]
复制
考虑一个数组 x
x = np.arange(1,16)
我们将 y 指定为 x，然后说“y 是 x”
y = x
y 是 x
让我们改变 y 的形状
y.形状 = 3,5
请注意，它改变了 x 的形状
x.形状
(3, 5)
创建数据视图
让我们将 z 存储为x 的视图：
z = x.view()
z 是 x
False
因此 z 不是 x。
改变 z 的形状
z.形状 = 5,3
创建视图不会改变 x 的形状
x.形状
(3, 5)
更改 z 中的元素
z[0.0] = 1234
请注意，x 中的值也会发生变化：
X
array([[1234, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[ 11, 12, 13, 14, 15]])
因此，显示的变化不会妨碍原始数据，但视图值的变化会影响原始数据。
创建数据的副本：
现在让我们创建 z 作为 x 的副本：
z = x.copy()
注意 z 不是 x
z 是 x
更改 z 中的值
z[0,0] = 9999
x 中没有进行任何更改。
X
array([[1234, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[ 11, 12, 13, 14, 15]])
Python 有时可能会给出“设置复制”警告，因为它无法识别新的数据帧或数组（作为另一个数据帧或数组的子集创建）是视图还是副本。因此，在这种情况下，用户需要指定它是副本还是视图，否则 Python 可能会妨碍结果。
练习：Numpy
1. 如何从数组中提取偶数？
arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
所需输出： 数组([0,2,4,6,8])
显示解决方案
arr[arr % 2 == 0]
2. 如何找出x和y元素相同的位置
x = np.array([5,6,7,8,3,4])
y = np.array([5,3,4,5,2,4])
所需输出： 数组([0, 5]
显示解决方案
np.where(x == y)
3. 如何标准化值，使其介于 0 和 1 之间
k = np.array([5,3,4,5,2,4])
提示： k-min(k)/(max(k)-min(k))
显示解决方案
kmax, kmin = k.max(), k.min()
k_new = (k - kmin)/(kmax - kmin)
4. 如何计算数组的百分位数
p = np.array([15,10, 3,2,5,6,4])
显示解决方案
np.percentile(p, q=[5, 95])
5. 打印数组中缺失值的数量
p = np.array([5,10, np.in, 3, 2, 5, 6, np.in])
显示解决方案
print("缺失值的个数=", np.isnan(p).sum())
