（二）Numpy基础操作

最新推荐文章于 2024-11-26 11:04:35 发布

风影楼前

最新推荐文章于 2024-11-26 11:04:35 发布

阅读量304

点赞数 1

分类专栏： Python数据科学文章标签： python numpy

本文链接：https://blog.csdn.net/qq_23897391/article/details/110217276

版权

Python数据科学专栏收录该内容

6 篇文章 1 订阅

订阅专栏

1. Numpy数组

2. Numpy运算

3. Numpy内置函数

1. Numpy数组

可以直接用Python列表来创建数组。

import numpy as np
a = np.array([1,2,3,4])
a
Out[3]: array([1, 2, 3, 4])

b = np.array([[1, 2], [3, 4], [5, 6]])
b
Out[5]:array([[1, 2],
              [3, 4],
              [5, 6]])

可以查看array的属性，包括数据的维度和类型。

b.ndim 
Out[6]: 2 

b.shape 
Out[7]: (3, 2) 

b.dtype # 查看数组里元素的数据类型 
Out[8]: dtype('int32')

也可以使用Numpy提供的函数来创建数组。

c = np.arange(10) # 创建连续数组 
c 
Out[9]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

a = np.arange(0, 51 ,10) # 3个参数表示起始、结束和步长，不包含结束位置 
a
Out[5]: array([ 0, 10, 20, 30, 40, 50])

d = np.linspace(0, 2, 11) # [0, 2] 分成 11 等分后的数组 
d 
Out[11]: array([ 0. , 0.2, 0.4, 0.6, 0.8, 1. , 1.2, 1.4, 1.6, 1.8, 2. ]) 

np.ones((3, 3)) # 注意参数两边的括号，参数是个元组 
Out[12]: array([[ 1., 1., 1.], 
                [ 1., 1., 1.],
                [ 1., 1., 1.]])

np.zeros((3, 6)) 
Out[13]: array([[ 0., 0., 0., 0., 0., 0.], 
                [ 0., 0., 0., 0., 0., 0.], 
                [ 0., 0., 0., 0., 0., 0.]]) 

np.eye(4) 
Out[14]: array([[ 1., 0., 0., 0.], 
                [ 0., 1., 0., 0.], 
                [ 0., 0., 1., 0.], 
                [ 0., 0., 0., 1.]]) 
				
np.random.randn(6, 4) # 创建6×4的随机数组 
Out[17]: array([[-0.49815866, -0.34571599, -0.44144955, 0.28833876], 
                [ 1.48639293, -0.56259401, -0.32584788, 0.39799156], 
                [ 1.35458161, -1.21808153, -0.17011994, 0.95870198], 
                [-1.36688808, 0.75892299, -1.25336314, -1.12267624], 
                [-2.24057506, -0.25099611, 1.6995657 , -0.14504619], 
                [ 0.52316692, -1.55100505, 0.65085791, -1.45710045]])

Numpy提供了灵活的索引机制来访问数组内的元素。

In [23]: a = np.arange(10) 
In [24]: a 
Out[24]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

In [25]: a[0], a[3], a[-1] 
Out[25]: (0, 3, 9) 

In [26]: a[:4] # 半开闭区间，不包含最后一个元素 
Out[26]: array([0, 1, 2, 3]) 

In [27]: a[3:7] 
Out[27]: array([3, 4, 5, 6])  #不包含最后一个元素 

In [28]: a[6:] 
Out[28]: array([6, 7, 8, 9]) 

In [29]: a[2:8:2] # 3个参数表示起始、结束和步长，不包含结束位置 
Out[29]: array([2, 4, 6]) 

In [30]: a[2::2] # 结束位置可以省略 
Out[30]: array([2, 4, 6, 8]) 

In [31]: a[::3] # 开始和结束都省略 
Out[31]: array([0, 3, 6, 9])

二维数据的索引分成行和列两个维度，会更灵活一些。

# 创建一个6行6列的二维数据，使用了广播机制，后文介绍

a = np.arange(0, 51, 10).reshape(6, 1) + np.arange(6)
a
Out[10]: 
array([[ 0,  1,  2,  3,  4,  5],
       [10, 11, 12, 13, 14, 15],
       [20, 21, 22, 23, 24, 25],
       [30, 31, 32, 33, 34, 35],
       [40, 41, 42, 43, 44, 45],
       [50, 51, 52, 53, 54, 55]])

a[0, 0], a[2, -1]
Out[11]: (0, 25)

a[0, 2:5]
Out[12]: array([2, 3, 4])

a[:3, 3:]
Out[13]: 
array([[ 3,  4,  5],
       [13, 14, 15],
       [23, 24, 25]])

a[2, :]
Out[14]: array([20, 21, 22, 23, 24, 25])

a[:, 3] #结果应该是列向量，但 Numpy 自动转换行向量形式
Out[15]: array([ 3, 13, 23, 33, 43, 53])

a[:, ::2]
Out[16]: 
array([[ 0,  2,  4],
       [10, 12, 14],
       [20, 22, 24],
       [30, 32, 34],
       [40, 42, 44],
       [50, 52, 54]])

a[::2, ::3]
Out[17]: 
array([[ 0,  3],
       [20, 23],
       [40, 43]])

另外一个索引的方法是通过布尔数组。

a = np.random.randint(10, 20, 6) # 在 [10, 20] 之间产生 6 个随机数
a
Out[19]: array([19, 19, 16, 15, 11, 19])

a % 2 == 0
Out[20]: array([False, False,  True, False, False, False], dtype=bool)

a[a % 2 == 0]
Out[21]: array([16])

2. Numpy运算

最简单的数值计算是数组和标量进行计算，计算过程是直接把数组里的元素和标量逐个进行计算。

a = np.arange(6)
a
Out[4]: array([0, 1, 2, 3, 4, 5])

a+5
Out[5]: array([ 5,  6,  7,  8,  9, 10])

a*2
Out[6]: array([ 0,  2,  4,  6,  8, 10])

另外一种是数组和数组的运算，如果数组的维度相同，那么在组里对应位置进行逐个元素的数学运算。

a = np.random.randint(1, 5, (5, 4))
a
Out[9]: 
array([[3, 4, 3, 2],
       [3, 4, 3, 2],
       [4, 4, 2, 4],
       [1, 2, 4, 3],
       [1, 4, 3, 2]])

b = np.ones((5, 4), dtype=int)
b
Out[11]: 
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])

a+b  # 数组加法
Out[12]: 
array([[4, 5, 4, 3],
       [4, 5, 4, 3],
       [5, 5, 3, 5],
       [2, 3, 5, 4],
       [2, 5, 4, 3]])

c=b*2
c
Out[14]: 
array([[2, 2, 2, 2],
       [2, 2, 2, 2],
       [2, 2, 2, 2],
       [2, 2, 2, 2],
       [2, 2, 2, 2]])


a*c     # 数组相乘，逐元素相乘，不是矩阵内积运算
Out[16]: 
array([[6, 8, 6, 4],
       [6, 8, 6, 4],
       [8, 8, 4, 8],
       [2, 4, 8, 6],
       [2, 8, 6, 4]])

需要注意的是，乘法是对应元素相乘，不是矩阵内积，矩阵内积使用的是np.dot()函数。

a = np.random.randint(1, 5, (3, 2))
b = np.random.randint(1, 5, (2, 3))

a
Out[19]: 
array([[1, 1],
       [4, 3],
       [1, 2]])

b
Out[20]: 
array([[1, 4, 1],
       [4, 1, 2]])

np.dot(a,b)
Out[21]: 
array([[ 5,  5,  3],
       [16, 19, 10],
       [ 9,  6,  5]])

如果数组的维度不同，则Numpy会试图使用广播机制来匹配，如果能匹配得上，就进行运算；如果不满足广播条件，则报错。

符合广播的条件是两个数组必须有一个维度可以扩展，然后在这个维度上进行复制，最终复制出两个相同维度的数组，再进行运算。作为广播的一个特例，当一个二维数组和一个标量进行运算时，实际上执行的也是广播机制，它有两个维度可扩展，先在行上进行复制，再在列上进行复制，最终复制出和待运算的二维数组维度相同的数组后，再进行运算。

a = np.random.randint(1, 5, (3, 2))
a
Out[19]: 
array([[1, 1],
       [4, 3],
       [1, 2]])

b = np.arange(2)
b
Out[23]: array([0, 1])

a+b  # 3*2 数组与 1*2 数组的加法，都是两列，满足广播条件，逐行相加
Out[24]: 
array([[1, 2],
       [4, 4],
       [1, 3]])

c = np.arange(3)
a+c  # 3*2 数组与 1*3数组加法，不满足广播条件，报错
Traceback (most recent call last):

  File "<ipython-input-26-637545a26abd>", line 1, in <module>
    a+c

ValueError: operands could not be broadcast together with shapes (3,2) (3,) 


c = np.arange(3).reshape(3, 1)
a+c   # 3*2 数组与 3*1数组加法，都是三行，满足广播条件
Out[28]: 
array([[1, 1],
       [5, 4],
       [3, 4]])

数组还可以直接进行比较，返回一个同维度的布尔数组。针对布尔数组，可以使用 all()/any() 函数来返回布尔数组的标量值。

a = np.array([1, 2, 3])

b = np.array([4, 2, 2])

a == b
Out[31]: array([False,  True, False], dtype=bool)

a > b
Out[32]: array([False, False,  True], dtype=bool)

a != b
Out[33]: array([ True, False,  True], dtype=bool)

(a == b).all() #且的关系
Out[34]: False

(a == b).any() #或的关系
Out[35]: True

3. Numpy内置函数

Numpy还提供了一些数组运算的内置函数：

a = np.arange(0,8,2)
a
Out[39]: array([0, 2, 4, 6])

np.cos(a)
Out[40]: array([ 1.        , -0.41614684, -0.65364362,  0.96017029])

np.sin(a)
Out[41]: array([ 0.        ,  0.90929743, -0.7568025 , -0.2794155 ])

np.exp(a)
Out[42]: array([   1.        ,    7.3890561 ,   54.59815003,  403.42879349])

np.sqrt(a)
Out[43]: array([ 0.        ,  1.41421356,  2.        ,  2.44948974])

Numpy 提供了一些基本的聚合统计功能：

a = np.arange(0,8,2)
a
Out[39]: array([0, 2, 4, 6])

a.sum() #求和
Out[44]: 12

a.min() #最小值
Out[46]: 0

a.max() #最大值
Out[47]: 6

a.mean() #平均数
Out[48]: 3.0

a.std() #标准差
Out[49]: 2.2360679774997898

a.argmin() #最小值元素所在的索引
Out[50]: 0

a.argmax() #最大值元素所在的索引
Out[51]: 3

针对二维数组或者更高维度的数组，可以根据行或列来计算。其中，axis参数表示坐标轴，0表示按行计算，1表示按列计算。需要特别注意的是，按列计算后，计算结果Numpy会默认转换为行向量。

b = np.random.randint(1, 5, (2, 3))
b
Out[53]: 
array([[4, 4, 1],
       [1, 2, 4]])

b.sum()
Out[54]: 16

b.sum(axis=0)
Out[55]: array([5, 6, 5])

b.sum(axis=1)
Out[56]: array([9, 7])

b.sum(axis=1).sum()
Out[57]: 16

b.sum(axis=0).min()
Out[59]: 5