学习 Python 之 NumericalPython库
Posted _DiMinisH
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了学习 Python 之 NumericalPython库相关的知识，希望对你有一定的参考价值。
学习 Python 之 NumericalPython库
- NumericalPython库
NumericalPython库
什么是NumericalPython库?
NumericalPython库是使用 Python 进行科学计算的基础软件包, 它提供了 Python 生态系统中数据分析、机器学习、科学计算
除了计算外，它还包括了：
- 功能强大的 N 维数组对象
- 精密广播功能函数
- 集成 C/C+和 Fortran 代码的工具
- 强大的线性代数、傅立叶变换和随机数功能
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) | 创建与给定数组具有相同形状和类型的随机值数组, 可以指定数组的类型 |
full(元组, 填充值, 类型 = None) | 创建数组中全部值都一样的数组, 可以指定数组的类型. 默认情况下, 类型是int32 |
identity(矩阵的阶数, 类型 = None) | 创建方阵单位矩阵, 可以指定数组的类型, 默认情况下, 类型是float64 |
eye(元组, k = 0(1开始的位置)) | 创建方阵非单位矩阵, 可以指定数组的类型, 默认情况下, 类型是float64 |
(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]
(4). 全部值一样的数组
full() 函数
创建元素全部是一样的数组
import numpy
x = numpy.full((2, 2), 6, float)
print(x)
结果:
[[6. 6.]
[6. 6.]]
(5). 单位矩阵
identity() 函数
创建方阵单位矩阵
import numpy
i = numpy.identity(3, dtype = float)
print(i)
结果:
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
eye() 函数
创建非方阵单位矩阵
import numpy
a = numpy.eye(5)
print(a)
b = numpy.eye(4, 8)
print(b)
c = numpy.eye(3, 5, k = 3)
print(c)
结果:
[[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.]]
[[1. 0. 0. 0. 0. 0. 0. 0.]
[0. 1. 0. 0. 0. 0. 0. 0.]
[0. 0. 1. 0. 0. 0. 0. 0.]
[0. 0. 0. 1. 0. 0. 0. 0.]]
[[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]
[0. 0. 0. 0. 0.]]
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.0python学习笔记之运算符