学习 Python 之 NumericalPython库

已于 2023-01-16 22:29:52 修改
阅读量2.3k 收藏 5
点赞数 1
分类专栏： Python 文章标签： python 学习 数据分析
于 2022-05-27 00:29:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37354060/article/details/124995733
版权

学习 Python 之 NumericalPython库

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)创建与给定数组具有相同形状和类型的随机值数组, 可以指定数组的类型
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.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,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]
]
)
b = a[4:7, 4:7]
print(b)

结果:

[[0 0 0]
 [0 0 0]
 [0 0 0]]

使用切片取出矩阵中 矩阵中 99 的元素

[[ 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 99  3 99  0 99  7 99  9]
 [ 0  1 99  3 99  0 99  7 99  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]]

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,6,7,8,9],
    [0,1,2,3,4,5,6,7,8,9],
    [0,1,99,3,99,0,99,7,99,9],
    [0,1,99,3,99,0,99,7,99,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]
]
)
b = a[4:6, 2:9:2]
print(b)

结果:

[[99 99 99 99]
 [99 99 99 99]]
(2). 检索与赋值

行数和列数从0开始
m x n的矩阵行下标0 ~ m-1, 列数从0 ~ n-1
数组[维度1, 维度2, ... 维度n]

把第一行第三列的值赋值为5

[[1 1 1]
 [1 1 1]]

import numpy

x = numpy.array(
    [
        [1, 1, 1],
        [1, 1, 1]
    ]
)
print(x)
x[0, 2] = 5
print(x)

结果:

[[1 1 1]
 [1 1 1]]
[[1 1 5]
 [1 1 1]]
(3). 轴缺失

当提供的索引少于轴(维度)的数量时，缺失的索引被认为是完整的切片

import numpy

a = numpy.fromfunction(lambda x, y: x + y, (2, 2), dtype = int)
print(a)
print(a[0])
print(a[0, :])

结果:

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

a[0] 相当于 a[, : ]

(4). 轴省略 …

使用 ...省略轴

import numpy

a = numpy.fromfunction(lambda x, y: x + y, (2, 2), dtype = int)
print(a)
print(a[...]) # 相当于 a[ : : ]

print('-----------------')

a = numpy.fromfunction(lambda a, b, c: a + b + c, (4, 4, 4), dtype = numpy.int32)
print(a)
print(a[0, 0, ...]) # 相当于 a[0, 0, :]

结果:

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

如果x数组有5个维度, 则:

x[1,2,…] 相当于 x[1,2,:,:,:]

x[…,3] 相当于 x[:,:,:,:,3]

x[4,…,5,:] 相当于 x[4,:,:,5,:]

3. 数组反转

import numpy

a = numpy.arange(0, 10, 2)
print(a)
a = a[ : :-1]
print(a)

b = numpy.array([
    [1, 2, 3],
    [4, 5, 6]
])
print(b)
b = b[ : :-1, : : -1]
print(b)

结果:

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

[ : : -1] 可以反转某个维度下的元素

4. 布尔索引

import numpy

a = numpy.arange(15).reshape((5, 3))
print(a)
b = numpy.array([True, True, False, False, True])
print(b)
c = a[b, 1:]
print(c)
c[c < 6] = 0
print(c)

结果:

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [12 13 14]]
[ True  True False False  True]
[[ 1  2]
 [ 4  5]
 [13 14]]
[[ 0  0]
 [ 0  0]
 [13 14]]

ndarray 遍历

1. 一维数组遍历

跟Python 列表遍历一样

2. 多维数组遍历

(1). 直接使用for-in

直接使用for-in遍历数组第一个维度的元素

import numpy

a = numpy.fromfunction(lambda a, b, c: a + b + c, (3, 3, 3), dtype = numpy.int32)
for i in a:
    print(i)

结果:

[[0 1 2]
 [1 2 3]
 [2 3 4]]
[[1 2 3]
 [2 3 4]
 [3 4 5]]
[[2 3 4]
 [3 4 5]
 [4 5 6]]

因为a是 3 × 3 的立方体

所以是按照立方体的高遍历的

(2). 遍历数组全部元素

如果想要对数组中的每个元素执行操作, 可以使用flat属性, 该属性是数组的所有元素的迭代器

import numpy

a = numpy.fromfunction(lambda a, b, c: a + b + c, (3, 3, 3), dtype = numpy.int32)
for i in a.flat:
    print(i, end = ' ')

结果:

0 1 2 1 2 3 2 3 4 1 2 3 2 3 4 3 4 5 2 3 4 3 4 5 4 5 6

按照层行列遍历, 第一列结束第二列, 第一行结束第二行, 第一层结束第二层

ndarray 改变形状

常用函数

函数作用
.reshape(新的维度元组)返回对原来数组进行形状改变后的数组, 但元素总个数不变, 原数组不改变
.resize(新的维度元组)对原来数组进行形状改变, 原数组发生改变, 但元素总个数不变

1. reshape() 函数

改变数组的形状

函数作用
.reshape(新的维度元组)返回对原来数组进行形状改变后的数组, 但元素总个数不变, 原数组不改变
import numpy

a = numpy.fromfunction(lambda a, b: a + b, (4, 3), dtype = numpy.int32)
print(a)
a = a.reshape(2, 6)
print(a)

结果:

[[0 1 2]
 [1 2 3]
 [2 3 4]
 [3 4 5]]
[[0 1 2 1 2 3]
 [2 3 4 3 4 5]]

如果某个维度被指定为 -1, 则改维度的个数将自动计算

import numpy

a = numpy.fromfunction(lambda a, b: a + b, (4, 3), dtype = numpy.int32)
print(a)
a = a.reshape(-1, 6)
print(a)

结果:

[[0 1 2]
 [1 2 3]
 [2 3 4]
 [3 4 5]]
[[0 1 2 1 2 3]
 [2 3 4 3 4 5]]

注意: 以下情况会报错

  1. 全部维度都为-1
  2. 自动计算出来的值唯分数, 即 (3, 4) -> (5, -1) 会报错

2. resize() 函数

改变数组的形状

函数作用
.resize(新的维度元组)对原来数组进行形状改变, 原数组发生改变, 但元素总个数不变
import numpy

a = numpy.fromfunction(lambda a, b: a + b, (4, 3), dtype = numpy.int32)
print(a)
a.resize((6, 2))
print(a)

结果:

[[0 1 2]
 [1 2 3]
 [2 3 4]
 [3 4 5]]
[[0 1]
 [2 1]
 [2 3]
 [2 3]
 [4 3]
 [4 5]]

该情况不允许使用 -1 表示自动计算

ndarray 堆叠

函数

函数作用
hstack(数组元组)返回水平方向堆叠的数组
vstack(数组元组)返回垂直方向堆叠的数组

1. 一维数组列堆叠 column_stack() 函数

函数作用
一维数组列堆叠(数组元组)返回列堆叠的数组
import numpy

e = numpy.array([1, 2, 3])
a = numpy.column_stack((e, e))
print(e)
print(a)

结果:

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

2. 一维数组行堆叠 row_stack() 函数

函数作用
一维数组列堆叠(数组元组)返回列堆叠的数组
import numpy

e = numpy.array([1, 2, 3])
a = numpy.row_stack((e, e))
print(e)
print(a)

结果:

[1 2 3]
[[1 2 3]
 [1 2 3]]

3. 水平堆叠 hstack() 函数

函数作用
hstack(数组元组)返回水平方向堆叠的数组

对于一维, 两个数组拼接

对于二维, 按照行堆叠, 只要行的个数一致, 就可以堆叠

import numpy

e = numpy.array([1, 2, 3])
a = numpy.zeros((2, 2))
b = numpy.ones((2, 2))
c = numpy.ones((2, 3))
print(numpy.hstack((e, e)))
print(numpy.hstack((a, b)))
print(numpy.hstack((a, c)))

结果:

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

4. 垂直堆叠 vstack() 函数

函数作用
vstack(数组元组)返回垂直方向堆叠的数组

对于一维, 两个数组长度要一样

对于二维, 按照列堆叠, 只要列的个数一致, 就可以堆叠

import numpy

e = numpy.array([1, 2, 3])
a = numpy.zeros((2, 2))
b = numpy.ones((2, 2))
c = numpy.ones((3, 2))
print(numpy.vstack((e, e)))
print(numpy.vstack((a, b)))
print(numpy.vstack((a, c)))

结果:

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

ndarray 拷贝

函数

函数作用
.view()浅拷贝元素
.copy()深拷贝元素

1. 深拷贝 copy() 函数

import numpy

a = numpy.arange(6).reshape(2, 3)
c = a.view()
print(a)
print(c)
c[0, 0] = 2
print(a)

结果:

[[0 1 2]
 [3 4 5]]
[[0 1 2]
 [3 4 5]]
[[2 1 2]
 [3 4 5]]

可以看出修改c的值, a的值也改变了

2. 浅拷贝 view() 函数

import numpy

a = numpy.arange(6).reshape(2, 3)
c = a.copy()
print(a)
print(c)
c[0, 0] = 2
print(a)

结果:

[[0 1 2]
 [3 4 5]]
[[0 1 2]
 [3 4 5]]
[[0 1 2]
 [3 4 5]]

可以看出修改c的值, a的值没有改变

ndarray 判断

函数

函数作用
.all(axis = None)沿指定的轴判断该轴数组元素是否都不等于0
.any(axis = None)沿指定的轴判断该轴数组元素是否都不等于0
where(条件, 满足条件操作, 不满足条件操作)条件赋值

(1). 沿指定的轴判断所有数组元素是否有等于0的

非数字, 正无穷, 负无穷都不等于0

import numpy

a = numpy.arange(6).reshape(2, 3)
print(a)
print(a.all())
print(a.all(axis = 0))
print(a.all(axis = 1))

结果:

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

(2). 沿指定的轴判断该轴数组元素是否都不等于0

非数字, 正无穷, 负无穷都不等于0

import numpy

a = numpy.array([[0, 0, 0], [1, 2, 3]])
print(a)
print(a.any())
print(a.any(axis = 0))
print(a.any(axis = 1))

结果:

[[0 0 0]
 [1 2 3]]
True
[ True  True  True]
[False  True]

(3). 条件赋值 where() 函数

where(条件, 满足条件操作, 不满足条件操作)

import numpy

a = numpy.array([[0, 0, 0], [1, 2, 3]])
print(a)
print(numpy.where(a < 5, a + 3, a))

结果:

[[0 0 0]
 [1 2 3]]
[[3 3 3]
 [4 5 6]]
_ZestyJt
关注
专栏目录
python机器学习库常用汇总
09-21
主要为大家汇总了常用python机器学习库，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Python之NumPy详解
twg666的博客
03-07 4228
NumPy(Numerical Python) 是Python语言的一个数值计算扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
python中numeric_Python中的Numeric
weixin_39957312的博客
12-10 1731
整型Integer在Python2.X中，Integer有两种类型，一种是32bit的普通类型，一种是精度无限制的long类型，在数字后面标识l或者L来标识long类型，并且，当32bit发生overflow无法表示时，会自动转换成long类型；在Python3.X中，Integer只有一种类型，就是long类型，因此，后面的l或者L标识就可以不用写了浮点数Float在标准的CPython中，浮点...
Python之NumPy基础：数组与向量化计算
寒夜的博客
02-21 1463
本博客为《利用Python进行数据分析》的读书笔记，请勿转载用于其他商业用途。 文章目录1. NumPy ndarray：多维数组对象 NumPy是Numerical Python的简称。 1. NumPy ndarray：多维数组对象 Numpy的核心特征之一就是N-维数组对象——ndarray。ndarray是Python中一个快速、灵活的大型数据集容器。数组允许你使用类似于标量的操作语法在整...
(Python3) Numeric (数字)类型
科学技术是第一生产力
04-11 2080
数字类型：int, float, complex 操作运算符 表达式 结果 函数 x+y 求和 x-y 求差 x*y 求积 x/y 除法，返回一个浮点数 x//y 除法，返回一个整数 x%y 求余 -x 取负数 +x 不变 ...
《利用Python进行数据分析·第2版》第4章 NumPy基础：数组和矢量计算
weixin_34075551的博客
11-09 904
第1章 准备工作第2章 Python语法基础，IPython和Jupyter第3章 Python的数据结构、函数和文件 第4章 NumPy基础：数组和矢量计算第5章 pandas入门第6章 数据加载、存储与文件格式第7章 数据清洗和准备第8章 数据规整：聚合、合并和重塑第9章 绘图和可视化第10章 数据聚合...
Python的深度学习库.docx
06-12
Python的深度学习库是开发人工智能应用的关键工具，其在当今自动化时代扮演着不可或缺的角色。Python作为一门开源且功能强大的编程语言，由Guido van Rossum于1989年创立，以其易读性、易学性和高效性而受到开发者...
基于 Python 的深度学习库keras
最新发布
04-19
keras-team/keras: 是一个基于 Python 的深度学习库，它没有使用数据库。适合用于深度学习任务的开发和实现，特别是对于需要使用 Python 深度学习库的场景。特点是深度学习库、Python、无数据库。
Python中的张量学习_python_库
06-03
Python中的张量学习_python import tensorly as tl import numpy as np tensor = tl.tensor(np.arange(24).reshape((3, 4, 2)), dtype=tl.float64) unfolded = tl.unfold(tensor, mode=0) tl.fold(unfolded, mode=...
NumPy（Numerical Python的简称）是一个开源的Python库，用于处理大型多维数组和矩阵
博客域名:borter.blog.csdn.net
03-23 349
NumPy（Numerical Python的简称）是一个开源的Python库，用于处理大型多维数组和矩阵，以及用于进行与数组相关的数学运算。2. **数学函数**：NumPy包含大量的数学函数，用于进行各种数学运算，如加法、减法、乘法、除法、幂运算、对数、三角函数等。8. **高效的数据处理**：NumPy的数组存储是连续的，并且支持切片、索引和迭代等操作，这使得数据处理变得非常高效。5. **广播功能**：广播是NumPy处理不同形状数组进行数学运算的一种机制，它允许在不同形状的数组间进行数学运算。
Python numpy
smallworldxyl的博客
03-10 749
一.简介 Numpy的英文全称为 Numerical Python，意味 Python 面向数值计算的第三方库。NumPy 的特点在于，针对 Python 内建的数组类型做了扩充，支持更高维度的数组和矩阵运算，以及更丰富的数学函数。 NumPy 是 Scipy.org 中最重要的库之一，它同时也被 Pandas，Matplotlib 等我们熟知的第三方库作为核心计算库。当你在单独安装这些库时，你会发现同时会安装 NumPy 作为依赖 二 数值类型 Python 本身支持的数值类型有 int（整型，P
Python浅析——列举一些Numerical Python的常用函数
StandbyTheSea的博客
04-12 898
Numerical Python，简称 Numpy，是一个开源的Python科学计算库。通过它，我们可以很简单地使用数组、矩阵，以及很多实用的数学函数（涵盖线性代数运算、傅里叶变换和随机数等）。减少了许多编码过程中，无意义的行为。 那么，Numerical Python在编码过程中都为我们提供了那些便利呢？ 首先就是便捷： 时间就是金钱，当你费心费力编写的代码他人直接通过Numpy迅速实现，这时...
NumPy学习
weixin_45439324的博客
12-24 556
NumPy学习 1. NumPy介绍 Numpy（Numerical Python）是一个开源的Python科学计算库，用于快速处理任意维度的数组。 Numpy支持常见的数组和矩阵操作。对于同样的数值计算任务，使用Numpy比直接使用Python要简洁的多。 Numpy使用ndarray对象来处理多维数组，该对象是一个快速而灵活的大数据容器。 2. ndarray介绍 NumPy提供了一个N维数组...
python基础-numeric types
渔道的博客
06-18 814
数值类型(numeric types) 文章目录integers(整型)什么是整数整型可表示的范围floating point numbers(浮点数)科学计数法什么是浮点数python中的浮点数浮点数可表示的范围complex numbers(复数)运算符基本算数运算 integers(整型) 什么是整数 数学上，整数是指正整数、零、负整数。python中也是如此。 整型可表示的范围 sys.maxsize An integer giving the maximum value a variable of
Python中的Numeric
chaoguo1234的专栏
06-03 4408
&#13; 整型Integer 在Python2.X中，Integer有两种类型，一种是32bit的普通类型，一种是精度无限制的long类型，在数字后面标识l或者L来标识long类型，并且，当32bit发生overflow无法表示时，会自动转换成long类型； 在Python3.X中，Integer只有一种类型，就是long类型，因此，后面的l或者L标识就可以不用写了   浮...
python学习—最全Numpy教程
一键难忘的博客
12-15 1万+
1. Numpy概述 NumPy（Numerical Python的简称）是Python数值计算最重要的基础包。大多数提供科学计算的包都是用NumPy的数组作为构建基础。 1.1.1. Why NumPy? 1.一个强大的N维数组对象ndarray，具有矢量算术运算和复杂广播能力的快速且节省空间的多维数组 2.用于集成由C、C++、Fortran等语言类库的C语言 API 3.线性代数、随机数生成以及傅里叶变换功能。 4.用于对整组数据进行快速运算的标准数学函数（无需编写循环）,支持大量的数据运算 5.
NumPy学习：NumPy(Numerical Python)基础（一）
Snailandfish的专栏
12-07 1083
NumPy 是 Python 中用于科学计算的基础包。它是一个 Python 库，提供多维数组对象， 各种派生对象（例如掩码数组和矩阵），以及 用于对阵列进行快速操作的各种例程，包括 数学、逻辑、形状操作、排序、选择、I/O、 离散傅里叶变换、基本线性代数、基本统计 操作、随机模拟等等。NumPy 包的核心是ndarray对象。这 封装同构数据类型的 N 维数组，其中 为了提高性能，在编译的代码中执行许多操作。
NumPy库的介绍与使用（一）
热门推荐
qq_37289115的博客
09-11 2万+
一、NumPy库简介 NumPy(Numerical Python)是 Python 语言的一个扩展程序库。其中提供了许多向量和矩阵操作，能让用户轻松完成最优化、线性代数、积分、插值、特殊函数、傅里叶变换、信号处理和图像处理、常微分方程求解以及其他科学与工程中常用的计算，不仅方便易用而且效率更高。 NumPy 是一个开源的Python科学计算基础库，是SciPy、Pandas等数据处理或科学计算库的基础。包含： 拥有一个类似于列表的、强大的N维数组对象ndarray，它描述了相同类型的元素的集合。并且它还
Python编程练习题库与解答
这个题库旨在帮助学习者巩固Python编程技能，提高编程能力。" 详细解释: 1. `pip`是Python中用于安装和管理扩展库的命令行工具，可以用来安装、升级或卸载Python库。 2. `math`模块是Python标准库的一部分，提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值