Python 数据操作教程：NUMPY 教程与练习

NumPy（“NumericalPython”或“NumericPython”的缩写）是Python中对数组和矩阵进行快速数学计算的最基本的软件包之一。在处理多维数据时它也非常有用。集成C、C++和FORTRAN工具是一件幸事。它还提供了许多傅里叶变换(FT)和线性代数函数。

为什么使用NumPy而不是列表？人们可能会想到为什么我们应该更喜欢NumPy中的数组，而不是我们可以创建具有相同数据类型的列表。如果这句话也引起了你的注意，那么以下原因可能会说服你：1、Numpy数组具有连续的内存分配。因此，如果将相同的数组存储为列表，则与数组相比将需要更多的空间。2、它们的使用速度更快，因此比列表更高效。3、他们打交道更方便。NumPy与PandasPandas构建在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:[1525147896]请注意，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)

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)#30isexcluded.

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]x

Output:[0123456789]

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]=123

xarray([123,

1,

2,123,

4,

5,123,

7,

8,

9])为了反转给定的数组，我们编写：x=np.arange(10)

x[::-1]#reversedxarray([9,8,7,6,5,4,3,2,1,0])请注意，上述命令不会修改原始数组。

重塑数组要重塑数组，我们可以使用reshape()。f=np.arange(101,113)

f.reshape(3,4)

farray([101,102,103,104,105,106,107,108,109,110,111,112])

请注意，reshape()不会改变原始数组的形状。因此，要修改原始数组，我们可以使用resize()f.resize(3,4)

farray([[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（NotaNumber的缩写）表示。您可以使用命令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.ndim

g.size

g.shapeg.ndim

Output:2g.size

Output:6g.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=16”np.zeros([2,4],dtype=16)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)#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.30769231,-0.15384615]])请注意，转置不会修改原始数组。

矩阵加法和减法可以用通常的方式完成：A+B

A-BA+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**2array([[

0,

400,1296],

[1600,2500,

1]],dtype=int32)我们得到B的所有元素的平方矩阵。

为了获得矩阵的元素是否满足条件，我们需要编写条件。例如，要检查B的元素是否超过25，我们编写：B>25array([[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)

Aarray([[1,2,3],

[4,5,6],

[7,8,9]])为了分别求总和、最小值、最大值、平均值、标准差和方差，我们使用以下命令：A.sum()

A.min()

A.max()

A.mean()

A.std()#标准差

A.var()#方差A.sum()

Output:45A.min()

Output:1A.max()

Output:9A.mean()

Output:5.0A.std()

#StandarddeviationOutput:2.5819888974716112A.var()

Output:6.666666666666667为了获得最小和最大元素的索引，我们分别使用argmin()和argmax()。A.argmin()

A.argmax()A.argmin()

Output:0A.argmax()

Output:8如果我们希望找到每一行或每一列的上述统计信息，那么我们需要指定轴：A.sum(轴=0)

A.mean(轴=0)

A.std(轴=0)

A.argmin(轴=0)A.sum(axis=0)

#sumofeachcolumn,itwillmoveindownwarddirectionOutput: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)

#minofeachrow,itwillmoveinrightwisedirectionOutput: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)

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).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

xarray([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]

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]]+=1

xarray([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

barray([[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

aarray([[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,:]

#selectingrowsOutput:

array([[0,1,2,3,4],

[5,6,7,8,9]])

x[y]

#samethingOutput:

array([[0,1,2,3,4],

[5,6,7,8,9]])

x[:,z]

#selectingcolumnsOutput:

array([[0,

1,

3],

[5,

6,

8],

[10,11,13]])

PandasDataFrame的统计数据

让我们创建虚拟数据框进行说明：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

有助于将一维行向量转换为一维列向量。fromnumpyimportnewaxis

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],