Numpy基础知识

一、Numpy简介

NumPy（Numeric Python）是一个用python实现的科学计算的扩展程序库，提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。NumPy是一个功能强大的Python库，主要用于对多维数组执行计算。NumPy这个词来源于两个单词– Numerical和Python。NumPy提供了许多高级的数值计算工具，如：矩阵数据类型、矢量处理，以及精密的运算库，可以轻松地进行数值计算。

二、Numpy数组计算基础

1、array函数的用法

1.1.1 利用Numpy提供的array函数创建数组对象(object)

import numpy as np  #  导入模块包
arr  = np.array([])    # 创建空数组
arr1 = np.array([1, 2, 3, 4, 5])  #  利用array函数创建一维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])  #  创建二维数组
'
运行
运行

1.1.2 指定数组元素的数据类型(dtype)

arr1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=float)
arr2 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], dtype=bool)
arr3 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=complex)

print("dtype指定数组元素的数据类型为浮点类型", arr1)  # [1. 2. 3. 4. 5. 6. 7. 8. 9.]
print("dtype指定数组元素的数据类型为bool类型", arr2)  # [ True  True  True  True  True  True  True  True  True False]
print("dtype指定数组元素的数据类型为复数类型", arr3)  # [1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j 6.+0.j 7.+0.j 8.+0.j 9.+0.j]

1.1.3 指定数组元素的维数(ndmin)

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9], ndmin=3)
print("ndmin值为1，指定生成一维数组", arr)  # [1 2 3 4 5 6 7 8 9]
print("ndmin值为2，指定生成二维数组", arr)  # [[1 2 3 4 5 6 7 8 9]]
print("ndmin值为3，指定生成三维数组", arr)  # [[[1 2 3 4 5 6 7 8 9]]]

1.2.1 shape用于查看数组形状,结果用元组的形式表示

空的显示(0, )  一维表示 (元素个数，)  二维表示(行, 列)

print(arr.shape)   #  (0,)
print(arr1.shape)  #  (5,)
print(arr2.shape)  #  (2, 3)

1.2.2 shape 重新设置数组的shape属性

arr2.shape = 3, 2 #  把arr2 改成 3行2列数组
[[1, 2],[3, 4],[5, 6]]

1.2.3 dtypt 查看数组元素类型

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("dtype查看数组元素的类型", arr.dtype)  #  int

1.2.4 size 查看数组中的元素个数

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("查看数组个数", arr.size)  # 6

1.2.5 itemsize查看数组元素的储存空间

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("查看数组元素的储存空间", arr.itemsize)  #  4

2、arange函数的用法

  说明:  通过指定开始值、终值和步长来创建一维数组，创建的数组不包含终值

    

2.1、arange函数创建数组

# arange函数的参数(start, stop, step, dtype)
arr = np.arange(0, 10, 2, dtype=int)  # 包首不包尾
print(arr)
[0 2 4 6 8]

3、linspace函数创建等差数列数组

# linspace函数的参数(start, stop, num, dtype)
arr1 = np.linspace(0, 10, 6, dtype=int)  # 包头包尾 等差数列
print(arr1) # [ 0  2  4  6  8 10]

4、logspace函数创建等比数列数组

arrr = np.logspace(1, 5, num=5, endpoint=True, base=10.0, dtype=int, axis=0)
print(arrr)
 
底数为 10 , 生成五个 指数为1-5的等比数列, 类型为int
 
[    10    100   1000  10000 100000]

arrr = np.logspace(0, 4, num=5, endpoint=True, base=2, dtype=int, axis=0)
print(arrr)
[ 1  2  4  8 16]

5、zeros函数创建元素都为0的数组

print("使用zeros创建 几行几列 元素全为0数组:\n", np.zeros((3, 4)))
 
 [[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

6、eye函数创建单位矩阵

print("使用eye创建 (单位矩阵) 数组 :\n", np.eye((3)))
 
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

7、diag函数创建对角矩阵

print("使用diag创建 对角矩阵 数组 :\n", np.diag([1, 2, 3, 4]))
 
[[1 0 0 0]
 [0 2 0 0]
 [0 0 3 0]
 [0 0 0 4]]

8、ones函数创建数组

print("使用ones创建 五行五列全为1 的数组 :\n", np.ones((5, 3)))
 
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]

9、生成随机数

对于Numpy 来说 与随机数相关的函数都在random模块中, 其中可以生成服从多种概率分布的随机数函数

9.1、使用random函数生成随机数

参数为整数，返回随机浮点数个数

import numpy as np
 
print('生成0-1、10个随机数', np.random.random(10))
# [0.10987808 ,0.46744674, 0.17708785, 0.30340278, 0.69318883 ,0.38080395 ,0.97276299 ,0.44607394 ,0.20992605 ,0.1303952 ]
'
运行
运行

9.2、使用rand函数生成服从均匀分布的随机数

np.random.randn(d0,d1,d2……dn)

1)  当函数括号内没有参数时，则返回一个浮点数；

2）当函数括号内有一个参数时，则返回秩为1的数组，不能表示向量和矩阵；

3）当函数括号内有两个及以上参数时，则返回对应维度的数组，能表示向量或矩阵；

# rand函数可以随机生成服从均匀分布的随机数
print('生成2行2列服从均匀分布的随机数', np.random.rand(2, 2))
# [[0.39393012 0.52005315]
#  [0.96116509 0.41460862]]

9.3、使用randn 函数生成服从正态分布的随机数(参数和rand类似)

# 使用randn 函数生成服从正态分布的随机数
print('生成2行2列服从正态分布的随机数', np.random.randn(2, 2))
# [[0.51936168 - 0.85725725]
#  [0.02650592 - 0.12556538]]

9.4、使用randint 函数生成给定范围的随机数

randint(最小值, 最大值, 几行几列的数组)
print('生成2行2列给定范围的随机数', np.random.randint(2, 10, size=[2, 5]))
# [[5 6 8 2 2]
#  [7 2 8 9 6]]

 10、变换数组的形状

10.1、使用reshape函数改变数组形状

arr = np.arange(0, 10)
print("将一维数组改成2行2列", arr.reshape(2, 5))
# [[0 1 2 3 4]
#  [5 6 7 8 9]]

10.2、使用ravel, flatten函数展平数组

arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
newArr = np.array(arr)
# ravel 展平数组
print(newArr.ravel())
# [1 2 3 4 5 6 7 8 9]
 
# flatten 展平数组
# 它可以横向展品和纵向展品
print('数组横向展平', newArr.flatten())
 
print('数组纵向展平', newArr.flatten('F'))

10.3、使用hstack、vstack、concatenate 组合数组

concatenate(数组1, 数组2，axis=0或者1)

参数axis=1 时 可以对数组进行横向组合

参数axis=0 时 可以对数组进行纵向组合

# 使用hstack 函数实现数组横向组合
arr2 = np.arange(12).reshape(3, 4)
arr3 = np.arange(12, 24).reshape(3, 4)
print(arr2, arr3)
# [[ 0  1  2  3]  
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# 
# [[12 13 14 15]
# [16 17 18 19]
#  [20 21 22 23]]
print('使用hstack 函数实现数组横向组合', np.hstack((arr3, arr2)))
# [[12 13 14 15  0  1  2  3]
#  [16 17 18 19  4  5  6  7]
#  [20 21 22 23  8  9 10 11]]
print('使用vstack 函数实现数组纵向组合', np.vstack((arr3, arr2)))
# [[12 13 14 15]
#  [16 17 18 19]
#  [20 21 22 23]
#  [ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# 使用 concatenate 函数组合数组
print('使用concatenate 函数实现数组横向组合', np.concatenate((arr3, arr2), axis=1))
# [[12 13 14 15  0  1  2  3]
#  [16 17 18 19  4  5  6  7]
#  [20 21 22 23  8  9 10 11]]
print('使用concatenate 函数实现数组纵向组合', np.concatenate((arr3, arr2), axis=0))
# [[12 13 14 15]
#  [16 17 18 19]
#  [20 21 22 23]
#  [ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

10.3、使用hsplit、vsplit、split函数分割数组

split(数组1, 分割的份数，axis=0或者1)

参数axis=1 时 可以对数组进行横向分割

参数axis=0 时 可以对数组进行纵向分割

# 使用hsplit vsplit split  函数进行数组分割
print(arr2)
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
print('使用 hsplit 函数实现数组横向分割', np.hsplit(arr2, 4 ))
# [array([[0],[4],[8]]), array([[1],[5],[9]]), array([[ 2],[ 6],[10]]), array([[ 3],[ 7],[11]])]
print('使用 vsplit 函数实现数组纵向分割', np.vsplit(arr2, 3 ))
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
print('使用 split 函数实现数组 纵向 分割', np.split(arr2, 3 , axis=0))
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
print('使用 split 函数实现数组 横向 分割', np.split(arr2, 2, axis=1))
# [array([[0, 1],[4, 5],[8, 9]]), array([[2, 3],[6, 7],[10, 11]])]

三、创建Numpy 矩阵

在NumPy中，矩阵（Matrix）是二维的特殊数组对象，它具有特定的数学和线性代数属性。NumPy中的矩阵可以通过numpy.matrix 、mat、bmat类来创建，也可以使用二维NumPy数组来表示。

以下是一些关于NumPy矩阵的特点和功能：

1. 二维结构：NumPy矩阵是二维的，具有行和列的结构。可以通过行号和列号来访问和操作矩阵中的元素。

2. 矩阵运算：NumPy提供了许多用于矩阵运算的函数和方法，如矩阵乘法、逆矩阵、转置、行列式等。这些操作可以方便地应用于NumPy矩阵对象。

3. 线性代数功能：NumPy的矩阵对象具有丰富的线性代数功能，包括求解线性方程组、特征值和特征向量计算、奇异值分解等。

4. 简化的语法：NumPy矩阵对象提供了一些简化的语法，使得矩阵运算更加直观和易读。例如，可以使用 * 运算符进行矩阵乘法，使用 ** 运算符进行矩阵的幂运算。

5. 切片和索引：与NumPy数组一样，可以使用切片和索引操作来访问和修改矩阵中的元素。可以通过行号和列号进行切片操作，或者使用布尔索引进行条件筛选。

6. 数值计算：与NumPy数组一样，NumPy矩阵对象可以应用各种数值计算和统计函数，如求和、平均值、标准差等。

创建矩阵

# 使用mat 创建矩阵
 
Mat = np.mat('1 2 3; 4 5 6; 7 8 9') # 使用分号隔开数据
print(Mat)
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
 
# 使用 matrix 创建矩阵 直接传入二维数组
Matrix = np.matrix([[1,2,3], [4,5,6], [7,8,9]])  #
print(Matrix)
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
 
# 使用 bmat 函数创建分块矩阵
arr1 = np.eye(3)
print(arr1)
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]
arr2 = np.diag([1,2,3])
print(arr2)
# [[1 0 0]
#  [0 2 0]
#  [0 0 3]]
print("创建的矩阵为\n", np.bmat('arr1 arr2'))
# [[1. 0. 0. 1. 0. 0.]
#  [0. 1. 0. 0. 2. 0.]
#  [0. 0. 1. 0. 0. 3.]]
print("创建的矩阵为\n", np.bmat('arr1 arr2; arr1 arr2'))
# [[1. 0. 0. 1. 0. 0.]
#  [0. 1. 0. 0. 2. 0.]
#  [0. 0. 1. 0. 0. 3.]
#  [1. 0. 0. 1. 0. 0.]
#  [0. 1. 0. 0. 2. 0.]
#  [0. 0. 1. 0. 0. 3.]]

矩阵的运算

# 矩阵运算
# 矩阵相乘
mat1 = np.mat('1 2 3; 4 5 6; 7 8 9') # 使用分号隔开数据
mat2 = np.matrix([[1,2,3], [4,5,6], [7,8,9]])
mutiply= mat1 * mat2
print(mutiply)
# [[ 30  36  42]
#  [ 66  81  96]
#  [102 126 150]]
 
# 矩阵相加
add = mat1 + mat2
print(add)
# [[ 2  4  6]
#  [ 8 10 12]
#  [14 16 18]]
 
# 矩阵相减
subtraction = mat1 - mat2
print(subtraction)
 
# 转置矩阵
print(mat1)
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
print(mat1.T)
# [[1 4 7]
#  [2 5 8]
#  [3 6 9]]
 
# 共轭矩阵
print(mat1)
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
print(mat1.H)
# [[1 4 7]
#  [2 5 8]
#  [3 6 9]]

四、ufunc 函数

ufunc（Universal Function）是NumPy中的一种函数，用于对数组进行逐元素操作的通用函数。ufunc函数可以对数组的每个元素进行相同的操作，支持各种数学运算、逻辑运算和其他操作。

1. 逐元素操作：ufunc函数对数组的每个元素进行操作，而不需要显式使用循环。这使得对大规模数组进行高效的向量化操作成为可能。

2. 数学运算：ufunc函数支持各种数学运算，如加法、减法、乘法、除法、取余、指数、对数等。例如，numpy.add是一个ufunc函数，用于执行两个数组的逐元素加法操作。

3. 逻辑运算：ufunc函数支持逻辑运算，如与（numpy.logical_and）、或（numpy.logical_or）、非（numpy.logical_not）等。这些函数可以应用于布尔类型的数组。

4. 位运算：ufunc函数支持位运算，如与（numpy.bitwise_and）、或（numpy.bitwise_or）、异或（numpy.bitwise_xor）等。这些函数可以应用于整数类型的数组。

5. 比较操作：ufunc函数支持比较操作，如大于（numpy.greater）、小于（numpy.less）、等于（numpy.equal）、不等于（numpy.not_equal）等。这些函数可以应用于各种数据类型的数组。

6. 形状广播：ufunc函数支持形状广播（broadcasting），即在进行逐元素操作时自动调整数组的形状，使得操作能够在不同形状的数组上进行。

7. 自定义ufunc函数：除了NumPy提供的内置ufunc函数，还可以自定义ufunc函数来执行特定的操作。通过使用numpy.vectorize装饰器或numpy.frompyfunc函数，可以将自定义函数转换为ufunc函数。

# 数组的运算
arr1 = np.array([1,2,3,4])
arr2 = np.array([5,6,7,8])
print('数组相加', arr1 + arr2)
# 数组相加 [ 6  8 10 12]
print('数组相乘', arr1 * arr2)
# 数组相乘 [ 5 12 21 32]
print('数组相除', arr1 / arr2)
# 数组相除 [0.2        0.33333333 0.42857143 0.5       ]
print('数组相减', arr1 - arr2)
# 数组相减 [-4 -4 -4 -4]
 
# 数组的比较运算
print(arr1>arr2)
# [False False False False]
print(arr1<arr2)
# [ True  True  True  True]
print(arr1==arr2)
# [False False False False]
print(arr1<=arr2)
# [ True  True  True  True]
print(arr1>=arr2)
# False False False False]
print(arr1!=arr2)
# [ True  True  True  True]
 
# 数组的逻辑运算
print(np.all(arr1 == arr2))
# False
print(np.any(arr1 == arr2))
# False

ufunc函数支持形状广播（broadcasting），即在进行逐元素操作时自动调整数组的形状，使得操作能够在不同形状的数组上进行

 

 

 

arr1 = np.array([1 , 2,  3])
arr2 = np.array([1])
print(arr1 + arr2)
# [2 3 4]
 
arr1 = np.arange(0, 9).reshape(3, 3)
print(arr1)
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]
 
arr2 = np.arange(1,4)
print(arr2)
# [1 2 3]
 
 
print(arr1 + arr2)
# [[ 1  3  5]
#  [ 4  6  8]
#  [ 7  9 11]]