【学习笔记】Python大数据处理与分析——NumPy数据计算

有为肥宅

已于 2024-04-17 01:05:25 修改

阅读量961

点赞数 20

分类专栏：学习笔记文章标签： numpy 学习笔记

于 2024-04-17 00:04:30 首次发布

本文链接：https://blog.csdn.net/Liu_Xin233/article/details/137838349

版权

学习笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文详细介绍了如何在NumPy中创建数组，包括array(),zeros(),ones(),empty()和arange()等函数，以及数组对象的常用属性如ndim,shape,size,dtype等。还涵盖了数组元素的基础运算、常用的数组函数如reshape(),ravel(),concatenate(),delete(),sort(),where()等，以及数学运算如位运算、三角函数、舍入函数等。

摘要由CSDN通过智能技术生成

一、NumPy中的数组对象

1、数组对象的创建

（1）用array()函数创建数组

创建n维数组需在array()函数中传入n层列表数据即可。

import numpy as np

# 创建n维数组
arr1 = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]])
print(arr1)
→[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]]

（2）用zeros()、ones()、empty()函数创建数组

arr2 = np.zeros((3, 4))    # 创建数组元素全为0的数组
print(arr2)
→[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

arr3 = np.ones((2, 2))     # 创建数组元素全为1的数组
print(arr3)
→[[1. 1.]
 [1. 1.]]

arr4 = np.empty(5)         # 创建数组元素为随机内容的数组
print(arr4)
→[0.   0.25 0.5  0.75 1.  ]

（3）创建指定类型的数组

使用arange()函数可以创建等间隔的数字数组，其函数参数有3个，分别是：起始值、终止值和间隔距离，间隔距离默认值为None，即1个单位。

arr5 = np.arange(6.6, 12.7, dtype=None)
print(arr5)
→[6.6  7.6  8.6  9.6 10.6 11.6 12.6]

arr6 = np.arange(3.8, 8.2, 0.6)
print(arr6)
→[3.8 4.4 5.  5.6 6.2 6.8 7.4 8. ]

2、数组对象的常用属性

创建基本数组如下：

array1 = np.array([[88, 90, 94, 90, 85],
                   [93.5, 93.5, 92.5, 90.5, 90.5],
                   [0, 0, 0, 0, 0]])

（1）ndarray.ndim

返回数组的维数，即秩。

print(array1.ndim)    # 返回数组的维数，即秩
→2

arr8 = array1.reshape(5, 1, 3)    # 改变数组的形状
print(arr8)
→[[[88.  90.  94. ]]
 [[90.  85.  93.5]]
 [[93.5 92.5 90.5]]
 [[90.5  0.   0. ]]
 [[ 0.   0.   0. ]]]

print(arr8.ndim)
→3

（2）ndarray.shape

表述数组的维度，返回一个元组，其长度就是维度的数目，此维度代表了这个数组的具体形式。

print(array1.shape)
→(3, 5)

arr9 = array1
arr9.shape = (5, 3)
print(arr9)
→[[88.  90.  94. ]
 [90.  85.  93.5]
 [93.5 92.5 90.5]
 [90.5  0.   0. ]
 [ 0.   0.   0. ]]

arr10 = array1.reshape(5, 3)
print(arr10)
→[[88.  90.  94. ]
 [90.  85.  93.5]
 [93.5 92.5 90.5]
 [90.5  0.   0. ]
 [ 0.   0.   0. ]]

（3）ndarray.size

返回数组元素的总个数，相当与.shape中n×m的值。

print(array1.size)
→15

（4）ndarray.dtype

返回对象的元素类型。

print(array1.dtype)
→float64

（5）numpy.itemsize

以字节的形式返回数组中每个元素的大小，如元素类型为float64的数组的itemsize属性值为8（float64每个字节长度为8，占用8个字节）。

print(array1.itemsize)
→8

（6）ndarray.flags

返回ndarray对象的内存信息。

C_CONTIGUOUS (C)：数据是在一个单一的C风格的连续段中
F_CONTIGUOUS (F)：数据是在一个单一的Fortran风格的连续段中
OWNDATA (O)：数组拥有自己所使用的内存或从另一个对象中借用
WRITEABLE (W)：数据区域可以被写入，将值设置为 False，则数据为只读
ALIGNED (A)：数据和所有元素都适当地对齐到硬件上

WRITEBACKIFCOPY（X）：写回副本
UPDATEIFCOPY (U)：数组是其它数组的一个副本，当数组被释放时，原数组的内容将被更新

print(array1.flags)
→ C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False

3、数组元素的基础运算

数组对象之间可以相互访问并进行运算，分算术运算和自增自减运算。

array2 = np.array([1, 3, 5, 7, 9])

print(array2 + 5)
→[ 6  8 10 12 14]

print(array2 * 2)
→[ 2  6 10 14 18]

4、数组对象的常用函数

（1）reshape()

改变数组的形状，如x维数组改为y维数组，函数原型为reshape(n)，n为要改变的形状，是一个数组。

array3 = np.array([1, 2, 3, 4, 5, 6, 7, 8])

arr11 = array3.reshape((2, 4))
print(arr11)
→[[1 2 3 4]
 [5 6 7 8]]

arr12 = arr11.reshape((2, 2, 2))
print(arr12)
→[[[1 2]
  [3 4]]
 [[5 6]
  [7 8]]]

（2）ravel()

将多维数组展开为一维数组。

arr13 = arr12.ravel()
print(arr13)
→[1 2 3 4 5 6 7 8]

（3）concatenate()

将多个数组连接，函数原型为concatenate(arr, axis)，arr为要拼接的数组（维数需一致），axis为拼接的维度，默认值为0。

array4 = np.array([[1, 2], [3, 4]])
array5 = np.array([[5, 6]])

print(np.concatenate((array4, array5)))
→[[1 2]
 [3 4]
 [5 6]]

print(array5.T)
→[[5]
 [6]]

print(np.concatenate((array4, array5.T), axis=1))
→[[1 2 5]
 [3 4 6]]

（4）delete()

从数组中删除指定值，函数原型为delete(arr, obj, axis)，arr为待处理矩阵，obj为处理位置，axis为可选参数，取值为None或1或0。

axis=None：，arr按行展开，再根据obj删除第obj-1（从0开始）位置的数，返回一行矩阵

axis=0：arr按行删除

axis=1：arr按列删除

array6 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])

print(np.delete(array6, 3))
→[1 2 3 5 6 7 8]

print(np.delete(array6, 1, 0))
→[[1 2 3 4]]

print(np.delete(array6, 0, 1))
→[[2 3 4]
 [6 7 8]]

（5）sort()

返回输入数组的排序副本，函数原型为sort(arr, axis, kind, order)，arr为待排序数组，axis为沿着它进行数组排序的轴，若没有则数组被展开，沿着最后的轴排序；若为0则按列排序；若为1则按行排序。kind为排序方法，默认为quicksort（快速排序），此外还有mergesort（归并排序）、heapsort（堆排序）等。order为排序字段，可以不包含。

array7 = np.array([[3, 9], [1, 7]])

print(np.sort(array7))
→[[3 9]
 [1 7]]

print(np.sort(array7, axis=0))
→[[1 7]
 [3 9]]

（6）where()和extract()

前者用于筛选出满足条件的元素下标，有两种用法：

① where(condition, x, y)，若满足条件condition，则输出x，否则输出y；

② where(condition)，输出满足条件（非0）的元素坐标（以tuple的形式给出）

array8 = np.arange(10)
array9 = np.arange(1, 10, 2)

print(np.where(array8, 1, -1))
→[-1  1  1  1  1  1  1  1  1  1]

print(np.where(array8 > 4, 2, -3))
→[-3 -3 -3 -3 -3  2  2  2  2  2]

print(np.where(array9 > 4))            # 返回索引
→(array([2, 3, 4], dtype=int64),)

print(array9[np.where(array9 > 4)])    # 等价于array9[array9 > 4]
→[5 7 9]

print(np.where([[0, 1], [1, 0]]))
→(array([0, 1], dtype=int64), array([1, 0], dtype=int64))

后者与前者类似，但是用于筛选满足条件元素的值并返回。

arr14 = np.mod(array8, 3) == 0

print(arr14)
→[ True False False  True False False  True False False  True]

print(np.extract(arr14, array8))
→[0 3 6 9]

二、使用NumPy进行数学运算

1、位运算函数

# 按位与运算
print('23和29的二进制形式: {} {}'.format(bin(23), bin(29)))
→23和29的二进制形式: 0b10111 0b11101

print('23和29的位与: {}'.format(np.bitwise_and(23, 29)))
→23和29的位与: 21


# 按位或运算
print('23和29的位或: {}'.format(np.bitwise_or(23, 29)))
→23和29的位或: 31


# 按位取反运算
print(np.invert(np.array([23], dtype=np.uint8)))
→[232]

print(np.binary_repr(23, width=8))
→00010111

print(np.binary_repr(232, width=8))
→11101000


# 按位左移(右端补0)
print(np.left_shift(29, 2))
→116

print(np.binary_repr(29, width=8))
→00011101

print(np.binary_repr(116, width=8))
→01110100


# 按位右移(左端补0)
print(np.right_shift(29, 2))
→7

print(np.binary_repr(29, width=8))
→00011101

print(np.binary_repr(7, width=8))
→00000111

2、数学函数

（1）三角函数

print(np.sin(np.pi / 4))
→0.7071067811865476

print(np.cos(np.pi / 4))
→0.7071067811865476

print(np.tan(np.pi / 4))
→0.9999999999999999

print(np.arcsin(np.sqrt(2) / 2))
→0.7853981633974484

print(np.arccos(np.sqrt(2) / 2))
→0.7853981633974483

print(np.arctan(1))
→0.7853981633974483

# degree()函数可将弧度转化为角度
print(np.degrees(np.arcsin(0.5)))
→30.000000000000004

print(np.degrees(np.arccos(0.5)))
→60.00000000000001

print(np.degrees(np.arctan(1)))
→45.0

（2）舍入函数

array10 = np.array([1.45, 2.15, 5.71, 6.198, 10.982])

print(np.around(array10))        # around()取整，以1为单位
→[ 1.  2.  6.  6. 11.]

print(np.around(array10, -1))    # around()取整，以10为单位
→[ 0.  0. 10. 10. 10.]

print(np.around(array10, 1))     # around()取整，以0.1为单位
→[ 1.4  2.2  5.7  6.2 11. ]

print(np.around(array10, 2))     # around()取整，以0.01为单位
→[ 1.45  2.15  5.71  6.2  10.98]

print(np.floor(array10))         # floor()向下取整
→[ 1.  2.  5.  6. 10.]

print(np.ceil(array10))          # ceil()向上取整
→[ 2.  3.  6.  7. 11.]

3、算术函数

（1）四则运算函数

array11 = np.array([[1, 4, 7], [2, 5, 8], [3, 6, 9]])
array12 = np.array([2, 3, 4])

print(np.add(array11, array12))
→[[ 3  7 11]
 [ 4  8 12]
 [ 5  9 13]]

print(np.subtract(array11, array12))
→[[-1  1  3]
 [ 0  2  4]
 [ 1  3  5]]

print(np.multiply(array11, array12))
→[[ 2 12 28]
 [ 4 15 32]
 [ 6 18 36]]

print(np.divide(array11, array12))
→[[0.5        1.33333333 1.75      ]
 [1.         1.66666667 2.        ]
 [1.5        2.         2.25      ]]

（2）reciprocal()

返回参数的倒数。

array13 = np.array([1 / 5, 5 / 2, 5 / 4])

print(array13)
→[0.2  2.5  1.25]

print(np.reciprocal(array13))
→[5.  0.4 0.8]

（3）power()

将第一个输入数组中元素作为底数，计算与第二个输入数组中相应元素的幂。

array14 = np.array([2, 3, 4])
array15 = np.array([4, 3, 2])

print(np.power(array14, array15))
→[16 27 16]

（4）mod()和remainder()

两者都计算输入数组中相应元素相除后的余数。

array16 = np.array([15, 23, 34])
array17 = np.array([4, 3, 2])

print(np.mod(array16, array17))
→[3 2 0]

print(np.remainder(array16, array17))
→[3 2 0]

4、统计函数

（1）最值函数和极差函数

array18 = np.array([13, 65, 89, 34, 32, 11, 23, 25, 46])

print(np.amax(array18))
→89

print(np.amin(array18))
→11

print(np.ptp(array18))
→78

（2）百分位数函数

查找位于数组一维轴中x%的值，函数原型为percentile(array, q, axis)，参数依次为输入数组、计算的百分位数（0~100）和计算百分位数的轴。

print(np.percentile(array18, 0, 0))
→11.0

print(np.percentile(array18, 25, 0))
→23.0

print(np.percentile(array18, 50, 0))
→32.0

print(np.percentile(array18, 75, 0))
→46.0

print(np.percentile(array18, 100, 0))
→89.0

（3）中位数函数

print(np.median(array18))
→32.0

（4）算术平均值函数和加权平均值函数

array19 = np.array([3, 6, 9])
array20 = np.array([3, 2, 1])

print(np.mean(array19))
→6.0

print(np.average(array19, weights=array20)) # 根据weight给出的权重计算数组中元素的加权平均值
→5.0

（5）标准差函数和方差函数

print(np.std(array18))
→24.019025380870758

print(np.var(array18))
→576.9135802469136

5、线性代数函数

（1）dot()

对于一维数组，计算两数组对应下标元素的乘积之和（内积）；对于二维数组，计算两数组的矩阵乘积；对于多维数组，通用计算公式为dot(a, b)[i, j, k, m] = sum(a[i, j,:] * b[k,:, m])，即结果数组每个元素都是数组a最后一维上的所有元素与数组b的倒数第二维上的所有元素的乘积之和。

array21 = np.array([[1, 2], [3, 4]])
array22 = np.array([[2, 4], [6, 8]])

print(array21)
→[[1 2]
 [3 4]]

print(array22)
→[[2 4]
 [6 8]]

print(np.dot(array21, array22))
→[[14 20]
 [30 44]]

（2）vdot()

计算两向量的点积。

array23 = np.array([1, 2, 3, 4])
array24 = np.array([1, 2, 3, 4])

print(np.vdot(array23, array24))
→30

print(np.vdot(array23, array24.reshape((2, 2))))
→30

（3）inner()

返回一维数组的向量内积。

print(np.inner(array23, array24))
→30

（4）matmul()

计算两个数组的矩阵乘积。

print(np.matmul(array21, array22))
→[[14 20]
 [30 44]]

（5）linalg.det()

计算输入矩阵的行列式。

print(np.linalg.det(np.array([[1, 2], [3, 4]])))
→-2.0000000000000004

（6）linalg.solve()

求矩阵形式的线性方程的解，举例如下：

$\begin{bmatrix} 1&1&1\\ 0&2&5\\ 2&5&1 \end{bmatrix} \begin{bmatrix} x\\ y\\ z \end{bmatrix} = \begin{bmatrix} 6\\ -4\\ 27 \end{bmatrix}$

array25 = np.array([[1, 1, 1], [0, 2, 5], [2, 5, -1]])
array26 = np.array([[6], [-4], [27]])

print(np.linalg.solve(array25, array26))
→[[ 5.]
 [ 3.]
 [-2.]]

（7）linalg.inv()

计算矩阵的乘法逆矩阵。设A是数域上一n阶矩阵，若在相同数域上存在另一n阶矩阵B，使得AB=BA=E，则称B是A的逆矩阵，A被称为“可逆矩阵”。、

print(np.linalg.inv(np.array([[1, 2], [3, 4]])))
→[[-2.   1. ]
 [ 1.5 -0.5]]