?NumPy（“Numerical Python”或“Numeric Python”的缩写）是 Python 中对数组和矩阵进行快速数学计算
的最基本的软件包之一。在处理多维数据时它也非常有用。集成C、C++和FORTRAN工具是一件幸事。它还提供了许多傅里叶变换 (FT
) 和线性代数函数。?为什么使用 NumPy 而不是列表？人们可能会想到为什么我们应该更喜欢 NumPy 中的数组，而不是我们可以
创建具有相同数据类型的列表。如果这句话也引起了你的注意，那么以下原因可能会说服你：1、Numpy 数组具有连续的内存分配。因此，如
果将相同的数组存储为列表，则与数组相比将需要更多的空间。2、它们的使用速度更快，因此比列表更高效。3、他们打交道更方便。NumPy
与 PandasPandas 构建在 NumPy 之上。换句话说，pandas 需要 Numpy 才能使其工作。所以 Panda
s 并不是 Numpy 的替代品。相反，pandas 提供了额外的方法或提供了在 Python 中处理数字和表格数据的更简化的方式
。导入numpy首先，您需要导入 numpy 库。可以通过运行以下命令来导入 numpy：将 numpy 导入为 np这是导入 n
umpy 的通用方法，别名为“np”。如果未提供别名，那么要从 numpy 访问函数，我们将编写numpy.function。为了
方便起见，引入了别名“np”，以便我们可以编写np.function。下面列出了 numpy 的一些常用函数 -?功能 任务 大批
创建 numpy 数组 这就是我 数组的维数 形状 数组的大小（行数和列数） 尺寸 数组中元素的总数 数据类型 数组中元素的类型
，即int64、character 重塑 在不改变原始形状的情况下重塑数组 调整大小 重塑数组。也改变原来的形状 排列 在数组中创
建数字序列 商品尺寸 每个项目的大小（以字节为单位） 诊断 创建对角矩阵 虚拟堆栈 垂直堆叠 栈 水平堆叠一维数组使用 numpy
可以使用np.array创建数组：a = np.array([15,25,14,78,96])aprint(a)aOutput:
array([15, 25, 14, 78, 96])print(a)Output: [15 25 14 78 96]请注意，n
p.array 中存在方括号。缺少方括号会导致错误。要打印数组，我们可以使用print(a)。更改数据类型np.array( )
有一个附加的dtype参数，通过该参数可以定义元素是整数、浮点还是复数。a.dtypea = np.array([15,25,14
,78,96],dtype = "float")aa.dtype最初 ''a'' 的数据类型是''int32''，修改后变为''float6
4''。int32指的是没有小数点的数字。''32'' 表示数字可以在 -2147483648 和 2147483647 之间。类似地，
int16 表示数字可以在 -32768 到 32767 范围内float64指的是带有小数位的数字。创建数字序列如果您想创建数字
序列，那么使用np.arange，?我们可以获得我们的序列。要获取从 20 到 29 的数字序列，我们运行以下命令。b = np.
arange(start = 20,stop = 30, step = 1)barray([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.carray([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]xOutput: [0 1 2 3 4 5 6 7 8 9]x[2]Output: 2x
[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] = 123xarray([123, ? 1, ? 2, 123, ? 4, ? 5, 123, ? 7
, ? 8, ? 9])为了反转给定的数组，我们编写：x = np.arange(10)x[ : :-1] # reversed
xarray([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])请注意，resha
pe()不会改变原始数组的形状。因此，要修改原始数组，我们可以使用resize( )f.resize(3,4)farray([[1
01, 102, 103, 104], [105, 106, 107, 108], [109, 110, 111, 112]])如
果在重塑中将某个维度指定为 -1，则只要给定维度是数组中元素总数的倍数，就会自动计算其他维度。f.reshape(3,-1)arr
ay([[101, 102, 103, 104], [105, 106, 107, 108], [109, 110, 111, 1
12]])在上面的代码中，我们只指定了 3 行。Python 自动计算其他维度的元素数量，即 4 列。缺失数据缺失的数据由 NaN
（Not a Number 的缩写）表示。您可以使用命令np.nanval = 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.ndimg.sizeg.
shapeg.ndimOutput: 2g.sizeOutput: 6g.shapeOutput: (2, 3)创建一些常用矩阵n
umpy 提供了创建一些常用于线性代数的常用矩阵的实用程序。要创建 2 行 4 列全零矩阵，我们可以使用np.zeros( )：n
p.zeros( (2,4) )array([[ 0., ?0., ?0., ?0.], [ 0., ?0., ?0., ?0.]
])这里还可以指定 dtype。对于零矩阵，默认数据类型是“float”。要将其更改为整数，我们编写“dtype = np.int
16”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-31
2], [ ?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]])要创建单位矩阵，我们可以使用n
p.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.rav
el()array([10, 20, 30, 40, 50, 60])要改变二维数组的形状，我们可以使用reshape。写入-1会
自动计算另一个维度，并且不会修改原始数组。g.reshape(3,-1) # 返回形状修改后的数组# 它不会修改原始数组g.sha
pe(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 #t
ransposeA.transpose() #transposenp.trace(A) # tracenp.linalg.inv(
A) #InverseA.transpose() ?#transposeOutput: array([[2, 4, 7], [0,
3, 6], [1, 8, 9]])np.trace(A) ?# traceOutput: 14np.linalg.inv(A)
?#InverseOutput: array([[ 0.53846154, -0.15384615, ?0.07692308],
[-0.51282051, -0.28205128, ?0.30769231], [-0.07692308, ?0.307692
31, -0.15384615]])请注意，转置不会修改原始数组。矩阵加法和减法可以用通常的方式完成：A+BA-BA+BOutpu
t: array([[12, 20, 31], [44, 53, 68], [77, 86, 99]])A-BOutput: ar
ray([[ -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]])为了求解线性方程组：A
x = b，我们使用np.linalg.solve( )np.linalg.solve(A,b)array([-13.923076
92, -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.262374
85, ?0.84147098]])结果是所有 sin( ) 元素的矩阵。为了获得指数，我们使用B2array([[ ?
0, ?400, 1296], [1600, 2500, ? ?1]], dtype=int32)我们得到 B 的所有元素的平方矩
阵。为了获得矩阵的元素是否满足条件，我们需要编写条件。例如，要检查 B 的元素是否超过 25，我们编写：B>25array([[F
alse, 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)现在我们考虑形状为
33 的矩阵 A：A = np.arange(1,10).reshape(3,3)Aarray([[1, 2, 3], [4,
5, 6], [7, 8, 9]])为了分别求总和、最小值、最大值、平均值、标准差和方差，我们使用以下命令：A.sum()A.mi
n()A.max()A.mean()A.std() #标准差A.var() #方差A.sum()Output: 45A.min()
Output: 1A.max()Output: 9A.mean()Output: 5.0A.std() ? #Standard d
eviationOutput: 2.5819888974716112A.var()Output: 6.66666666666666
7为了获得最小和最大元素的索引，我们分别使用argmin()和argmax() 。A.argmin()A.argmax()A.ar
gmin()Output: 0A.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 directi
onOutput: 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=in
t64)通过定义axis = 0，计算将向下移动，即它将给出每列的统计数据。为了找到每行的最小值和最大元素的索引，我们需要向右移动
，所以我们写axis = 1：A.min(轴=1)A.argmax(轴=1)A.min(axis=1) ? ? ? ? ? ? ?
? ?# min of each row, it will move in rightwise directionOutput:
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],[1
0,11,12]]])X.shapeX.ndimX尺寸X 包含两个 2D 数组，因此形状为 2,2,3。元素总数为 12。为了计算
沿特定轴的总和，我们使用 axis 参数，如下所示：X.sum(轴 = 0)X.sum(轴 = 1)X.sum(轴 = 2)X.s
um(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)Ou
tput: 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.wher
e(a > 4)array([0, 2, 6]np.where定位数组中数组元素大于 4 的位置。使用索引数组进行索引考虑一维数组
。x = np.arange(11,35,2)xarray([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).re
shape(3,5)xi = 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)xx[[4,5,8,1,2]] = 0xarray([0, 0, 0, 3
, 0, 0, 6, 7, 0, 9])0 被分配给 x 的第 4、5、8、1 和 2 个索引。当索引列表包含重复项时，它将最后一
个值分配给该索引：x = np.arange(10)xx[[4,4,2,3]] = [100,200,300,400]xarray
([ ?0, ? 1, 300, 400, 200, ? 5, ? 6, ? 7, ? 8, ? 9])请注意，对于第 5 个元素
（即第 4 个索引），分配的值是 200，而不是 100。注意：如果对重复索引使用 += 运算符，则它仅对重复索引执行一次运算符。
x = np.arange(10)x[[1,1,1,7,7]]+=1x 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 > 4b
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] = 0aarray([[0, 1, 2, 3], [
4, 0, 0, 0], [0, 0, 0, 0]])''a'' 中大于 4 的所有元素都变为 0正如整数索引中所做的那样，我们可以通
过布尔值进行索引：设 x 为原始矩阵，''y'' 和 ''z'' 为布尔值数组以选择行和列。x = np.arange(15).resha
pe(3,5)y = np.array([True,True,False]) # 第一个暗淡选择z = np.array([Tru
e,True,False,True,False] ) # 第二个暗淡选择我们编写 x[y,:] ，它将仅选择 y 为 True 的
行。x[y,:] # 选择行x[y] # 相同的事情写入 x[:,z] 将仅选择 z 为 True 的那些列。x[:,z] # 选
择列x[y,:] ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? # selecting rowsOutput
: array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])x[y] ? ? ? ? ? ? ? ? ?
? ? ? ? ? ? ? ? ? # same thingOutput: array([[0, 1, 2, 3, 4], [5
, 6, 7, 8, 9]])x[:,z] ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? # selecti
ng columnsOutput: 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(m
ydata)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 newaxisa = np.array([4.,1.])b = np.array([2.,8.
])a[:,newaxis]array([[ 4.], [ 1.]])#函数np.column_stack( )将一维数组作为列堆
叠到二维数组中。它仅相当于一维数组的 hstack：np.column_stack((a[:,newaxis],b[:,newax
is]))np.hstack((a[:,newaxis],b[:,newaxis])) # 与column_stack相同np.c
olumn_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]), arra
y([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)Anp.hsplit(A,5) # 将a拆分为5个数组[arra
y([[ 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],?[1
4, 15],?[24, 25]]), array([[ 6, ?7, ?8, ?9, 10],?[16, 17, 18, 19,
20],?[26, 27, 28, 29, 30]])]复制考虑一个数组 xx = np.arange(1,16)我们将 y 指
定为 x，然后说“y 是 x”y = xy 是 x让我们改变 y 的形状y.形状 = 3,5请注意，它改变了 x 的形状x.形状(
3, 5)创建数据视图让我们将 z 存储为x 的视图：z = x.view()z 是 xFalse因此 z 不是 x。改变 z 的
形状z.形状 = 5,3创建视图不会改变 x 的形状x.形状(3, 5)更改 z 中的元素z[0.0] = 1234请注意，x 中
的值也会发生变化：Xarray([[1234, ? ?2, ? ?3, ? ?4, ? ?5], [ ? 6, ? ?7, ? ?
8, ? ?9, ? 10], [ ?11, ? 12, ? 13, ? 14, ? 15]])因此，显示的变化不会妨碍原始数据，但视图值的变化会影响原始数据。创建数据的副本：现在让我们创建 z 作为 x 的副本：z = x.copy()注意 z 不是 xz 是 x更改 z 中的值z[0,0] = 9999x 中没有进行任何更改。Xarray([[1234, ? ?2, ? ?3, ? ?4, ? ?5], [ ? 6, ? ?7, ? ?8, ? ?9, ? 10], [ ?11, ? 12, ? 13, ? 14, ? 15]])Python 有时可能会给出“设置复制”警告，因为它无法识别新的数据帧或数组（作为另一个数据帧或数组的子集创建）是视图还是副本。因此，在这种情况下，用户需要指定它是副本还是视图，否则 Python 可能会妨碍结果。?练习：Numpy1. 如何从数组中提取偶数？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()) |
|
