学习 Python 之 NumericalPython库

Posted 2022-10-28 _DiMinisH

学习 Python 之 NumericalPython库

• NumericalPython库
• • 什么是NumericalPython库?
  • NumPy 主要对象
  • ndarray 对象
  • ndarray 创建
  • • 1. 使用array() 函数
    • 2. 快捷创建数组
    • • (1). 0数组
      • • zeros() 函数
        • zeros_like() 函数
      • (2). 1数组
      • • ones() 函数
        • ones_like() 函数
      • (3). 随机值数组
      • • empty() 函数
        • empty_like() 函数
    • 3. 使用arange() 函数
    • 4. 使用linspace() 函数
    • 5. 使用fromfunction() 函数
    • 6. 使用random() 函数
    • 7. print() 函数打印数组
    • • 元素不省略打印
  • ndarray 运算
  • • 1. 加 减 幂 数乘
    • • (1). 加减
      • (2). 幂
      • (3). 数乘
    • 2. 比较
    • • (1). 与数比较
      • (2). 与同型数组比较
      • (3). 不同型数组比较
      • • 多维度与1维度
        • 多维度与某一维度相同
    • 3. 运算
    • • (1). 乘法
      • • 矩阵乘法
        • 数组点乘
      • (2). sum() min() max() 函数
      • • 计算全部元素和
        • 计算某个维度的元素和
        • min() 和 max() 与 sum() 用法一样
      • (3). 通函数
      • (4). 矩阵运算
  • ndarray 切片
  • • 1. 一维数组切片
    • 2. 多维数组切片
    • • (1). 切片
      • (2). 轴缺失
      • (3). 轴省略 ...
    • 3. 数组反转
    • 4. 布尔索引
  • ndarray 遍历
  • • 1. 一维数组遍历
    • 2. 多维数组遍历
    • • (1). 直接使用for-in
      • (2). 遍历数组全部元素
  • ndarray 改变形状
  • • 1. reshape() 函数
    • 2. resize() 函数
  • ndarray 堆叠
  • • 1. 一维数组列堆叠 column_stack() 函数
    • 2. 一维数组行堆叠 row_stack() 函数
    • 3. 水平堆叠 hstack() 函数
    • 4. 垂直堆叠 vstack() 函数
  • ndarray 拷贝
  • • 1. 浅拷贝 view() 函数
    • 2. 深拷贝 copy() 函数
  • ndarray 判断
  • • (1). 沿指定的轴判断所有数组元素是否有等于0的
    • (2). 沿指定的轴判断该轴数组元素是否都不等于0
    • (3). 条件赋值 where() 函数

NumericalPython库

什么是NumericalPython库?

NumericalPython库是使用 Python 进行科学计算的基础软件包, 它提供了 Python 生态系统中数据分析、机器学习、科学计算

除了计算外，它还包括了：

1. 功能强大的 N 维数组对象
2. 精密广播功能函数
3. 集成 C/C+和 Fortran 代码的工具
4. 强大的线性代数、傅立叶变换和随机数功能

NumPy 主要对象

NumPy的主要对象是同构多维数组

它是一个元素表（通常是数字）, 所有类型都相同，由非负整数元组索引。在NumPy维度中称为 轴(axes) 。

例如: 3D空间中的点的坐标[1, 2, 1]具有一个轴。该轴有3个元素，所以我们说它的长度为3

在下图所示的例子中，数组有2个轴。第一轴的长度为2，第二轴的长度为3

实际上, 轴(axes)是数组的维度, 对于二维, 行是一个轴, 列是一个轴

[[ 1., 0., 0.],
 [ 0., 1., 2.]]

ndarray 对象

NumPy的数组类叫做 ndarray

ndarray属性

属性名	作用	备注
.ndim	数组的维度个数	-
.shape	数组的维度	这是一个整数的元组, 表示每个维度中数组的大小; 对于有 n 行和 m 列的矩阵, shape 将是 (n, m)
.size	数组元素的总数	对于有 n 行和 m 列的矩阵，shape 将是 n × m
.dtype	数组元素的类型	可以使用标准的Python类型创建或指定dtype, 也可以是NumPy提供的类型
.itemsize	数组中每个元素的字节大小	例如: 元素为 float64 类型的数组的 itemsize 为8（=64/8）,而 complex32 类型的数组的 itemsize 为 4（=32/8）
.data	该缓冲区包含数组的实际元素	通常, 我们不需要使用此属性, 因为我们将使用索引访问数组中的元素
.flags	数组对象的内存信息	-
.real	数组元素的实数部分	-
.imag	数组元素的虚数部分	-

ndarray 创建

创建函数

函数	作用
array(元素列表, 类型 = None)	使用列表创建数组, 默认类型 int32
zeros(元组, 类型)	创建0数组, 元组用来指定维度, 默认类型 float64
zeros_like(数组, 类型 = None)	创建与给定数组具有相同形状和类型的零数组, 可以指定数组的类型
ones(元组, 类型)	创建1数组, 元组用来指定维度, 默认类型 float64
ones_like(数组, 类型 = None)	创建与给定数组具有相同形状和类型的1数组, 可以指定数组的类型
empty(元组, 类型)	创建随机值数组, 元组用来指定维度, 默认类型 float64
empty_like(数组, 类型 = None)	创建与给定数组具有相同形状和类型的随机值数组, 可以指定数组的类型
arange(起始值, 终止值, 步长 = 1)	根据步长创建数组, 步长默认值为1, 支持浮点类型, 由于有限的浮点精度, 通常不可能预测所获得的元素的数量, 出于这个原因, 最好使用linspace()函数
arange(终止值)	步长为1, 起始值为0, 创建数组
linspace(起始值, 终止值, 元素个数)	根据元素个数创建数组
fromfunction(表达式或函数, 维度元组, dtype = None)	根据一个表达式创建数组

函数	作用
set_printoptions(threshold = sys.maxsize)	打印数组不跳过数组的中心部分, 即全部打印

1. 使用array() 函数

函数	作用
array(元素列表, 类型 = None)	使用列表创建数组, 默认情况类型为int32

import numpy

a = numpy.array([1, 2, 3, 4])
b = numpy.array([[1, 2], [3, 4.0]])
c = numpy.array([[1, 2], [3, 4]], dtype = complex)
print(a)
print(b)
print(c)
print(a.dtype, b.dtype, c.dtype)

结果:

[1 2 3 4]
[[1. 2.]
 [3. 4.]]
[[1.+0.j 2.+0.j]
 [3.+0.j 4.+0.j]]
int32 float64 complex128

2. 快捷创建数组

函数	作用
zeros(元组, 类型)	创建0数组, 元组用来指定维度, 默认情况下, 类型是float64
zeros_like(数组, 类型 = None)	创建与给定数组具有相同形状和类型的零数组, 可以指定数组的类型
ones(元组, 类型)	创建1数组, 元组用来指定维度, 默认情况下, 类型是float64
ones_like(数组, 类型 = None)	创建与给定数组具有相同形状和类型的1数组, 可以指定数组的类型
empty(元组, 类型)	创建随机值数组, 元组用来指定维度, 默认情况下, 类型是float64
empty_like(数组, 类型 = None)	创建与给定数组具有相同形状和类型的随机值数组, 可以指定数组的类型

(1). 0数组

zeros() 函数

创建元素全为0的数组

import numpy

o = numpy.zeros(5)
print(o)

结果:

[0. 0. 0. 0. 0.]

zeros_like() 函数

创建与给定数组具有相同形状和类型的零数组, 可以指定数组的类型

import numpy

o = numpy.array(
    [
        [0, 1, 2],
        [3, 4, 5]
    ]
)
a = numpy.zeros_like(o, float)
print(a)

结果:

[[0. 0. 0.]
 [0. 0. 0.]]

(2). 1数组

ones() 函数

创建元素全为1的数组

import numpy

e = numpy.ones((5, 5), dtype = complex)
print(e)

结果:

[[1.+0.j 1.+0.j 1.+0.j 1.+0.j 1.+0.j]
 [1.+0.j 1.+0.j 1.+0.j 1.+0.j 1.+0.j]
 [1.+0.j 1.+0.j 1.+0.j 1.+0.j 1.+0.j]
 [1.+0.j 1.+0.j 1.+0.j 1.+0.j 1.+0.j]
 [1.+0.j 1.+0.j 1.+0.j 1.+0.j 1.+0.j]]

ones_like() 函数

创建与给定数组具有相同形状和类型的1数组, 可以指定数组的类型

import numpy

o = numpy.array(
    [
        [0, 1, 2],
        [3, 4, 5]
    ]
)
a = numpy.ones_like(o, complex)
print(a)

结果:

[[1.+0.j 1.+0.j 1.+0.j]
 [1.+0.j 1.+0.j 1.+0.j]]

(3). 随机值数组

empty() 函数

创建元素全部是随机产生值的数组

import numpy

e = numpy.empty((3, 5))
print(e)

结果:

[[ 3.68274928e-216  7.87345618e-312  7.87345611e-312  6.15650563e+292
   7.87345618e-312]
 [ 7.87345611e-312  2.64978910e+081  7.87345620e-312  7.87345611e-312
  -1.05477908e+120]
 [ 7.87345620e-312  7.87345597e-312 -9.42910864e+115  7.87345620e-312
   7.87345597e-312]]

empty_like() 函数

创建与给定数组具有相同形状和类型的随机值数组, 可以指定数组的类型

import numpy

o = numpy.array([1, 2])
a = numpy.empty_like(o, complex)
print(a)

结果:

[6.63123696e-315+0.0000000e+000j 7.29112202e-304-7.3874612e+104j]

3. 使用arange() 函数

函数	作用
arange(起始值, 终止值, 步长 = 1)	根据步长创建数组, 步长默认值为1, 支持浮点类型, 由于有限的浮点精度, 通常不可能预测所获得的元素的数量, 出于这个原因, 通常最好使用linspace()函数
arange(终止值)	步长为1, 起始值为0, 创建数组

import numpy

a = numpy.arange(1, 10)
b = numpy.arange(1, 20, 5)
c = numpy.arange(0, 2, 0.3)
d = numpy.arange(10)
print(a)
print(b)
print(c)
print(d)

结果:

[1 2 3 4 5 6 7 8 9]
[ 1  6 11 16]
[0.  0.3 0.6 0.9 1.2 1.5 1.8]
[0 1 2 3 4 5 6 7 8 9]

4. 使用linspace() 函数

函数	作用
linspace(起始值, 终止值, 元素个数)	根据元素个数创建数组

import numpy

a = numpy.linspace(0, 1, 5)
b = numpy.linspace(1, 20, 5)
print(a)
print(b)

结果:

[0.   0.25 0.5  0.75 1.  ]
[ 1.    5.75 10.5  15.25 20.  ]

5. 使用fromfunction() 函数

函数	作用
fromfunction(表达式或函数, 维度元组, dtype = None)	根据一个表达式创建数组

import numpy

a = numpy.fromfunction(lambda x, y: x + y, (2, 2))
print(a)

结果:

[[0. 1.]
 [1. 2.]]

原理:

x的值会从0递增, y的值会从0递增

对于第i行元素, x的值都为i - 1

对于第j列元素, y的值都为j - 1

    y ->  0          1
x    
↓   
0    [[0 = 0 + 0  1 = 0 + 1]
1     [1 = 1 + 0  2 = 1 + 1]]

6. 使用random() 函数

函数	作用
random(维度元组)	创建一个指定维度的数组, 元素的值在0 - 1但不包含1

import numpy

a = numpy.random.random((3, 5))
print(a)

结果:

[[0.88387807 0.69756899 0.447521   0.9923293  0.61855725]
 [0.65555256 0.28584714 0.16432933 0.54858505 0.19058042]
 [0.55937544 0.12831352 0.96037035 0.35226674 0.51170598]]

原理:

x的值会从0递增, y的值会从0递增

对于第i行元素, x的值都为i - 1

对于第j列元素, y的值都为j - 1

    y ->  0          1
x    
↓   
0    [[0 = 0 + 0  1 = 0 + 1]
1     [1 = 1 + 0  2 = 1 + 1]]

7. print() 函数打印数组

函数	作用
set_printoptions(threshold = sys.maxsize)	打印数组不跳过数组的中心部分, 即全部打印

如果数组太大而无法打印，NumPy会自动跳过数组的中心部分并只打印头部元素和尾部元素

import numpy

a = numpy.arange(1, 9999)
print(a)
a = [i for i in range(1, 9999)]
b = numpy.array([a, a])
print(b)

结果:

[   1    2    3 ... 9996 9997 9998]
[[   1    2    3 ... 9996 9997 9998]
 [   1    2    3 ... 9996 9997 9998]]

元素不省略打印

使用 set_printoptions() 函数

import numpy
import sys


a = numpy.arange(1, 9999)
print(a)
numpy.set_printoptions(threshold = sys.maxsize)
print(a)

结果:

[   1    2    3 ... 9996 9997 9998]
[   1    2    3    4    5    6    7    8    9   10   11   12   13   14
   15   16   17   18   19   20   21   22   23   24   25   26   27   28
   29   30   31   32   33   34   35   36   37   38   39   40   41   42
   43   44   45   46   47   48   49   50   51   52   53   54   55   56
   ... 这里省略打印结果

ndarray 运算

运算符与运算函数

运算符	解释	作用
+	加法	数组对应元素相加
+=	相加赋值	数组对应元素相加并赋值
-	减法	数组对应元素相减
-=	相减赋值	数组对应元素相减并赋值
**	幂	对数组中每个元素进行幂运算, 如果是A ** B, 则A的幂为B中对应位置的元素值
**	幂再赋值	对数组中每个元素进行幂并赋值
*	数乘	对数组中每个元素进行相乘
*=	数乘赋值	对数组中每个元素进行相乘并赋值
>	大于	数组对应元素比较大小
<	小于	数组对应元素比较大小
>=	大于等于	数组对应元素比较大小
<=	小于等于	数组对应元素比较大小
==	等于	数组对应元素比较大小
!=	不等于	数组对应元素比较大小

当使用不同类型的数组进行操作时, 结果数组的类型对应于更一般或更精确的数组, 即称为向上转型

1. 加 减 幂 数乘

运算符	解释	作用
+	加法	数组对应元素相加
+=	相加赋值	数组对应元素相加并赋值
-	减法	数组对应元素相减
-=	相减赋值	数组对应元素相减并赋值
**	幂	对数组中每个元素进行幂运算, 如果是A ** B, 则A的幂为B中对应位置的元素值
**	幂再赋值	对数组中每个元素进行幂并赋值
*	数乘	对数组中每个元素进行相乘
*=	数乘赋值	对数组中每个元素进行相乘并赋值

(1). 加减

import numpy

a = numpy.array(
    [
        [1, 2],
        [3, 4]
    ]
)
b = numpy.array(
    [
        [2, 2],
        [3, 3]
    ]
)
print(a)
print(b)
c = a + b
d = a - b
print(c)
print(d)

结果:

[[1 2]
 [3 4]]
[[2 2]
 [3 3]]
[[3 4]
 [6 7]]
[[-1  0]
 [ 0  1]]

(2). 幂

import numpy

a = numpy.array(
    [
        [1, 2],
        [3, 4]
    ]
)
b = a ** 2
print(a)
print(b)
a **= a
print(a)

结果:

[[1 2]
 [3 4]]
[[ 1  4]
 [ 9 16]]
[[  1   4]
 [ 27 256]]

(3). 数乘

import numpy

a = numpy.array(
    [
        [1, 2],
        [3, 4]
    ]
)
b = a * 3
print(a)
print(b)

结果:

[[1 2]
 [3 4]]
[[ 3  6]
 [ 9 12]]

2. 比较

运算符	解释	作用
>	大于	数组对应元素比较大小
<	小于	数组对应元素比较大小
>=	大于等于	数组对应元素比较大小
<=	小于等于	数组对应元素比较大小
==	等于	数组对应元素比较大小
!=	不等于	数组对应元素比较大小

(1). 与数比较

结果是相同维度的布尔数组

import numpy

a = numpy.array(
    [
        [1, 2],
        [3, 4]
    ]
)
print(a > 3)
print(a >= 3)
print(a < 3)
print(a <= 3)
print(a == 3)
print(a != 3)

结果:

[[False False]
 [False  True]]
 
[[False False]
 [ True  True]]
 
[[ True  True]
 [False False]]
 
[[ True  True]
 [ True False]]
 
[[False False]
 [ True False]]
 
[[ True  True]
 [False  True]]

(2). 与同型数组比较

结果是相同维度的布尔数组

import numpy

a = numpy.array(
    [
        [1, 2],
        [3, 4]
    ]
)
b = numpy.array(
    [
        [4, 4],
        [4, 4]
    ]
)
print(a > b)
print(a >= b)
print(a < b)
print(a <= b)
print(a == b)
print(a != b)

结果:

[[False False]
 [False False]]
 
[[False False]
 [False  True]]
 
[[ True  True]
 [ True False]]
 
[[ True  True]
 [ True  True]]
 
[[False False]
 [False  True]]
 
[[ True  True]
 [ True False]]

(3). 不同型数组比较

结果是布尔数组

多维度与1维度

1维度扩展为与多维度同型

import numpy

a = numpy.array(
    [
        [1, 2],
        [3, 4]
    ]
)
b = numpy.array(
    [
        [0]
    ]
)
print(a)
print(b)
print(a == b)

结果:

[[1 2]
 [3 4]]
[[0]]
[[False False]
 [False False]]

多维度与某一维度相同

多维度数组与某一维度相同的数组比较, 后者会扩展为与多维度数组同型的数组

import numpy

a = numpy.array(
    [
        [1, 3],
        [3, 1]
    ]
)
b = numpy.array(
    [
        [1],
        [1]
    ]
)
c = numpy.array(
    [
        [1, 1]
    ]
)
print(a)
print(a == b)
print(a == c)

结果:

[[1 3]
 [3 1]]
[[ True False]
 [False  True]]
[[ True False]
 [False  True]]

3. 运算

运算符或函数	作用
@	矩阵乘法
dot()	数组点乘
.sum(axis = None)	计算数组元素和, axis指定轴(维度)
.min(axis = None)	计算数组元素最大值, axis指定轴(维度)
.max(axis = None)	计算数组元素最小值, axis指定轴(维度)

(1). 乘法

矩阵乘法

import numpy

a = numpy.array(
    [
        [1, 3],
        [3, 1]
    ]
)
b = numpy.array(
    [
        [1, 0],
        [0, 1]
    ]
)
print(a)
print(b)
print(a @ b)

结果:

[[1 3]
 [3 1]]
[[1 0]
 [0 1]]
[[1 3]
 [3 1]]

数组点乘

• 一维数组点乘

x = (a, b, c)

y = (d, e, f)

x·y = ad + be + cf

import numpy

a = numpy.array([1, 2, 3])
b = numpy.array([1, 3, 4])
print(a)
print(b)
print(numpy.dot(a, b))

结果:

[1 2 3]
[1 3 4]
19

• 二维数组点乘

就是矩阵乘法, 与@效果一样

import numpy

a = numpy.array(
    [
        [1, 3],
        [3, 1]
    ]
)
b = numpy.array(
    [
        [1, 0],
        [0, 1]
    ]
)
print(a)
print(b)
print(numpy.dot(a, b))

结果:

[[1 3]
 [3 1]]
[[1 0]
 [0 1]]
[[1 3]
 [3 1]]

(2). sum() min() max() 函数

计算数组元素和

计算全部元素和

import numpy

a = numpy.array(
    [
        [1, 2],
        [3, 4]
    ]
)
print(a.sum())

结果:

10

计算某个维度的元素和

import numpy

a = numpy.array(
    [
        [1, 2.6],
        [3, 4.0]
    ]
)
# 计算列的和
print(a.sum(axis = 0))

结果:

[4 6]

min() 和 max() 与 sum() 用法一样

(3). 通函数

Numpy 提供好的一些数学函数

函数	作用
sin()	对数组每个元素取正弦
cos()	对数组每个元素取余弦
tan()	对数组每个元素取正切
exp()	对数组每个元素取自然指数

还有其他的这里不列举了

(4). 矩阵运算

ndarray 切片

1. 一维数组切片

跟Python 列表切片一样

2. 多维数组切片

(1). 切片

可以看成是列表的嵌套

使用,逗号分割轴(维度)

矩阵:

[[0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 0 0 0 7 8 9]
 [0 1 2 3 0 0 0 7 8 9]
 [0 1 2 3 0 0 0 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]]

使用切片取出矩阵中 3×3的零矩阵

import numpy

a = numpy.array(
[
    [0,1,2,3,4,5,6,7,8,9],
    [0,1,2,3,4,5,6,7,8,9],
    [0,1,2,3,4,5,<
以上是关于学习 Python 之 NumericalPython库的主要内容，如果未能解决你的问题，请参考以下文章
 
 python学习笔记之运算符
 python学习笔记之集合2
 Python学习日记之记录
 Python学习笔记之网络编程
 python学习笔记之语句1
 python学习笔记之字典2