python numpy

最新推荐文章于 2021-06-25 20:30:03 发布

qq_41823444

最新推荐文章于 2021-06-25 20:30:03 发布

阅读量603

点赞数 2

分类专栏： python 爬虫与数据分析文章标签： python numpy numpy numpy总结

本文链接：https://blog.csdn.net/qq_41823444/article/details/101445510

版权

python 爬虫与数据分析专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、NumPy 简介

NumPyshi 是Python的一个拓展程序库，主要用于科学计算
NumPy支持高端大量的维度数组与矩阵运算
NumPy针对数组运算提供大量的数学函数库

同时，NumPy是SciPy、Matplotlib等扩展路的基础组件

二、基本用法

1、NumPy d的数组

Numpy 的主要数据结构是一个同构多维数组，大于矩阵的概念
维度（ dimension）在 Numpy 中称为 axis

NumPy的数组的类被称为 ndarray
NumPy 的 numpy.array 和 Python 标准库中的 array.array 并不相同，NumPy 的 array 仅处理一维数组，因此功能更弱

ndarray包含以下属性（attribute）:

ndarray.ndim：数组的维度
ndarray.shape：数组每个维度的大小，例如一个 n 行 m 列的矩阵的大小为 (n, m)
ndarray.size：数组的元素数量，数值上等于数组每个维度大小的乘积
ndarray.dtype：数组的数值类型，可以自定义或采用 NumPy 的数值类型，例如
numpy.int32、 numpy.int16、 numpy.float64 等
ndarray.itemsize：数组的数值类型的大小，例如 float64 的大小是 8（ =64/8）
ndarray.data：直接读取数组元素，由于没有索引，不推荐使用此属性

>>> import numpy as np
>>> a = np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> a.shape  
(3, 4)
>>> a.ndim
2
>>> a.dtype.name
'int32'
>>> a.itemsize
4
>>> a.size
12
>>> type(a)
<class 'numpy.ndarray'>

>>> b = np.array([3, 4, 5])
>>> b
array([3, 4, 5])
>>> type(b)
<class 'numpy.ndarray'>

2、创建数组

NumPy提供多种创建数组的方法
例如，NumPy可以直接从标准库的列表或元祖中创建数组

>>> import numpy as np
>>> a = np.array([3, 4, 5])
>>>
>>> a.dtype
dtype('int32')
>>> b = np.array([1.3, 3.3, 5.4])
>>> b.dtype
dtype('float64')

需要注意的是，传递给NumPy 数组的构造函数必须是列表或元祖，不能是多个元素。

>>> a = np.array(1,2,3,4)   # Wrong
>>> a = np.array([1,2,3,4])   # Right
>>> a = np.array((1,2,3,4))  # Right

NumPy数组的构造函数会自动将传入格式转换为NumPy的数组格式
基本库的列表和元组在构造 NumPy 数组时可以混用

>>> b = np.array([(1.2, 2.3), (5, 6)])
>>> b
array([[1.2, 2.3],
       [5. , 6. ]])

同时，构造函数允许指定数据类型

>>> c = np.array([[1, 2], [3, 4]],  dtype=complex)
>>> c
array([[1.+0.j, 2.+0.j],
       [3.+0.j, 4.+0.j]])

在实际应用中，构造数组时具体元素的取值往往不确定，但是数组大小一般会提前确定（比如上次tf神经网络时，先生成特定像素的全0图片【ndarray矩阵】）
因此，NumPy提供了一系列的函数方便构造空数组或特定元素值的数组。

函数 zeros 会创建一个所有元素为 0 的数组
函数 ones 会创建一个所有元素为 1 的数组
函数 empty 会创建一个所有元素为随机数的数组

默认情况下使用上述三个函数创建的数组的数值类型是 float64

>>> np.zeros([3,4])
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])
>>> np.ones((2, 3, 4), dtype=np.int16)
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]], dtype=int16)
>>> np.empty((2,3))
array([[6.17692977e-312, 6.17692977e-312, 6.17692846e-312],
       [6.17692915e-312, 6.17692977e-312, 6.17692915e-312]])

NumPy 提供可迅速生成数列的函数

>>> np.arange(10, 30, 5)
array([10, 15, 20, 25])
>>> np.arange(0, 2, 0.3)
array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])

由于小数精度问题，使用 arange 函数较难预测生成数组的元素数量
如果要指定生成的数组长度，可以使用 linspace 函数

>>> from numpy import pi
>>> np.linspace(0, 2, 9)
array([0.  , 0.25, 0.5 , 0.75, 1.  , 1.25, 1.5 , 1.75, 2.  ])
>>> x = np.linspace(0, 2*pi, 100)
>>> f = np.sin(x)

3、打印数组

>>> a = np.arange(6)  # 一维
>>> print(a)
[0 1 2 3 4 5]
>>> b = np.arange(12).reshape(4, 3)  # 二维
>>> print(b)
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
>>> c = np.arange(24).reshape(2, 3, 4)  # 三维
>>> print(c)
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

如果数组太大， NumPy 会自动将中间的数值替换为省略号，只打印头尾的数值

>>> print(np.arange(100000))
[    0     1     2 ... 99997 99998 99999]

如果需要禁用此行为，可以使用：
np.set_printoptions(threshold=np.nan) 当程序报错时使用

import sys
import numpy as np
np.set_printoptions(threshold=sys.maxsize)

4、基本运算

数组间的数学运算通常为元素级别的运算
运算结果会以新数组的形式返回

>>> a = np.array([10, 20, 30, 40, 50])
>>> b = np.arange(5)
>>> b
array([0, 1, 2, 3, 4])
>>> c = a-b
>>> c
array([10, 19, 28, 37, 46])
>>> b**2
array([ 0,  1,  4,  9, 16], dtype=int32)
>>> 10 * np.sin(a)
array([-5.44021111,  9.12945251, -9.88031624,  7.4511316 , -2.62374854])
>>> a < 35
array([ True,  True,  True, False, False])

乘号（*）在NumPy的数组运算中是求元素积，而非求数量积（点积）
求数量积需要使用 @ 或 dot() 函数

>>> A = np.array([[1,1], [0,1]])
>>> B = np.array([[2,0],[3,4]])
>>> A * B  # 对应元素相乘
array([[2, 0],
       [0, 4]])
# 点乘
>>> A @ B
array([[5, 4],
       [3, 4]])
>>> A.dot(B)
array([[5, 4],
       [3, 4]])

与标准库类似，某些运算符（例如 += 和 *=）将直接修改左侧变量，而非返回新数组

>>> a = np.ones((2,3), dtype=int)
>>> b = np.random.random((2,3))
>>> a *= 3
>>> a
array([[3, 3, 3],
       [3, 3, 3]])
>>> b += a
>>> b
array([[3.069918  , 3.66590394, 3.7354047 ],
       [3.95409542, 3.42614061, 3.79219622]])
>>> a + b
array([[6.069918  , 6.66590394, 6.7354047 ],
       [6.95409542, 6.42614061, 6.79219622]])

>>> a += b  # b不能自动转换为int类型
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int32') with casting rule 'same_kind'

如果运算包含多个不同类型的数组，运算结果将向更精确的类型对齐（ upcasting）

>>> a = np.ones(3, dtype=np.int32)
>>> b = np.linspace(0,pi,3)
>>> b.dtype.name
'float64'
>>> c = a+b  # c的类型与b保持一致
>>> c
array([1.        , 2.57079633, 4.14159265])
>>> c.dtype.name
'float64'
>>> d = np.exp(c*1j)  # 与复数类型做运算，结果也变成了复数类型
>>> d
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
       -0.54030231-0.84147098j])
>>> d.dtype.name
'complex128'

对于大部分一元运算（例如数组求和）来说， ndarray 都直接提供相应的函数

>>> c = np.arange(12).reshape(3,4)
>>> c
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
       
>>> c.sum(axis=0)  # 0维上求和（最外维）
array([12, 15, 18, 21])
>>> c.min(axis=1)  # 取1维上的最小值
array([0, 4, 8])
>>> c.cumsum(axis=1)   # 按行梯形求和
array([[ 0,  1,  3,  6],
       [ 4,  9, 15, 22],
       [ 8, 17, 27, 38]], dtype=int32)

5、通用函数

NumPy 提供了一些常用的数学函数，例如 sin、 cos、 exp 等
此类数学函数被称为通用函数（ universal functions）
与数学运算类似，通用函数通常是针对数组元素进行操作的

>>> B = np.arange(3)
>>> B
array([0, 1, 2])
>>> np.exp(B)
array([1.        , 2.71828183, 7.3890561 ])
>>> np.sqrt(B)
array([0.        , 1.        , 1.41421356])
>>> C = np.array([2., -1., 4.])
>>> np.add(B, C)
array([2., 0., 6.])

6、索引、裁剪、迭代

一维数组可以直接被索引、裁剪、或迭代，行为类似标准库的列表

>>> a = np.arange(10) **3
>>> a
array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729], dtype=int32)
>>> a[2]
8
>>> a[2:5]
array([ 8, 27, 64], dtype=int32)
>>> a[:6:2]
array([ 0,  8, 64], dtype=int32)

>>> a[:6:2] = -1000
>>> a
array([-1000,     1, -1000,    27, -1000,   125,   216,   343,   512,
         729], dtype=int32)
>>> a[::-1]  # 逆置
array([  729,   512,   343,   216,   125, -1000,    27, -1000,     1,
       -1000], dtype=int32)

多维数组每个维度都有一套索引，调用时可用逗号隔开

>>> def f(x, y):
...     return 10*x + y
...
>>> b = np.fromfunction(f, (5,4), dtype=int)
>>> b
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23],
       [30, 31, 32, 33],
       [40, 41, 42, 43]])
>>> b[2,3]
23
>>> b[0:5, 1]  # 取每行的第二个元素
array([ 1, 11, 21, 31, 41])
>>> b[1:3, :]  # 取前两行
array([[10, 11, 12, 13],
       [20, 21, 22, 23]])

如果多维数组的索引没有提供，默认情况下会视为全集

>>> b[-1]  # 等效为 b[-1, :]
array([40, 41, 42, 43])

上述例子中由于其他维度没有提供， NumPy 将视其他纬度为 :，即全集
除了冒号（ :）之外， NumPy 也允许使用省略号代表全集，例如： b[i,…]

省略号（ …）代表索引中能提供的尽可能多的维度
例如，如果 x 是一个 5 维数组，那么：
x[1,2,…] 等同于 x[1,2,:,:,:]
x[…,3] 等同于 x[:,:,:,:,3]
x[4,…,5,:] 等同于 x[4,:,:,5,:]

>>> c = np.array([[[0,1,2],
...                [10,12,13]],
...              [[100,101,102],
...                [110,112,113]]])
>>> c.shape
(2, 2, 3)

>>> c[1,...]  # c[1,:,:]
array([[100, 101, 102],
       [110, 112, 113]])
       
>>> c[...,2]  # c[:,:,2]
array([[  2,  13],
       [102, 113]])

遍历一个多维数组在默认情况下会遍历第一维度
如果想遍历一个数组的全部元素，可以使用 flat 属性

>>> b
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23],
       [30, 31, 32, 33],
       [40, 41, 42, 43]])
       
 # 默认只遍历第一个维度      
>>> for row in b:
...     print(row)
...
[0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]

# 取全部元素
>>> for element in b.flat:
...     print(element)
...
0
1
2
3
...

三、数组形式变换

1、维度控制

一个数组的形状（ shape）即每一维度的元素数量

>>> a = np.floor(10*np.random.random((3,4)))
>>> a
array([[4., 3., 0., 7.],
       [6., 8., 4., 8.],
       [3., 4., 8., 8.]])
>>> a.shape
(3, 4)

数组的形状可以通过多种方式修改

>>> a.ravel()  # 返回一个压平后的一维数组
array([4., 3., 0., 7., 6., 8., 4., 8., 3., 4., 8., 8.])

>>> a.reshape(6,2)
array([[4., 3.],
       [0., 7.],
       [6., 8.],
       [4., 8.],
       [3., 4.],
       [8., 8.]])
       
>>> a.T  # 转置
array([[4., 6., 3.],
       [3., 8., 4.],
       [0., 4., 8.],
       [7., 8., 8.]])
>>> a.T.shape
(4, 3)

在 ravel() 函数中，输出的一维数组通常是深度优先遍历的（ C-style）
因此，如果使用 reshape() 函数，遍历方式也是深度优先
如果希望使用广度优先（ FORTRAN-style）或其他遍历方式，可以使用 order 参数

承上所述，使用 reshape() 函数调整维度时，会返回一个新的数组
使用 nadrray.resize() 则会修改本身的纬度

>>> a
array([[4., 3., 0., 7.],
       [6., 8., 4., 8.],
       [3., 4., 8., 8.]])
>>> a.resize((2, 6))
>>> a
array([[4., 3., 0., 7., 6., 8.],
       [4., 8., 3., 4., 8., 8.]])

调整数组维度时，也可以使用 -1 来自动计算剩余维度

>>> a.reshape(3,-1)
array([[4., 3., 0., 7.],
       [6., 8., 4., 8.],
       [3., 4., 8., 8.]])

2、数组叠加和拆分

NumPy 提供了数组叠加的函数 hstack 和 vstack

>>> a = np.floor(10*np.random.random((2,2)))
>>> a
array([[4., 7.],
       [2., 0.]])
>>> b  = np.floor(10*np.random.random((2,2)))
>>> b
array([[2., 1.],
       [8., 2.]])
# 垂直叠加（0维扩展、添加行）       
>>> np.vstack((a,b))
array([[4., 7.],
       [2., 0.],
       [2., 1.],
       [8., 2.]])
# 水平相加（1维延伸、添加列）   
>>> np.hstack((a,b))
array([[4., 7., 2., 1.],
       [2., 0., 8., 2.]])

类似的， NumPy 提供 hsplit 和 vsplit 两个函数用于拆分数组

>>> a = np.floor(10*np.random.random((2,12)))
>>> a
array([[3., 3., 9., 7., 4., 3., 2., 5., 8., 6., 0., 3.],
       [6., 0., 5., 9., 7., 9., 3., 5., 1., 0., 2., 3.]])
       
>>> np.hsplit(a,3)   # 指定以第4列为垂直线来分隔
[array([[3., 3., 9., 7.],
       [6., 0., 5., 9.]]), array([[4., 3., 2., 5.],
       [7., 9., 3., 5.]]), array([[8., 6., 0., 3.],
       [1., 0., 2., 3.]])]
       
>>> np.hsplit(a,(3,4))  # # 指定以第4、5列为垂直线来分隔
[array([[3., 3., 9.],
       [6., 0., 5.]]), array([[7.],
       [9.]]), array([[4., 3., 2., 5., 8., 6., 0., 3.],
       [7., 9., 3., 5., 1., 0., 2., 3.]])]

vstack 和 vsplit 是对第一维操作（ vertically，对于矩阵来说，即“行”）
hstack 和 hsplit 是对第二维操作（ horizontally，对于矩阵来说，即“列”）
如要针对任意维操作：
叠加： concatenate
https://www.numpy.org/devdocs/reference/generated/numpy.concatenate.htm
拆分： array_split
https://www.numpy.org/devdocs/reference/generated/numpy.array_split.html

四、数组复制及内存控制

1、内存控制的概念

NumPy 对于返回过程中的内存控制有以下三种情况：

无复制（ No Copy at All）：数组完全不会被复制
浅复制（ View / Shallow Copy）：数组的部分元素会被复
深度复制（ Deep Copy）：整个数组的内存都会被复制

2、无复制

简单的赋值操作不会复制任何内存

>>> a = np.arange(12)
>>> b = a
>>> b is a
True
>>> b.shape = 3,4
>>> a.shape
(3, 4)

Python 会将可变（ mutable）对象作为引用传递，因此也不会复制任何内存

>>> def f(x):
...     x.shape = 4,3
...
>>> f(a)
>>> a.shape
(4, 3)
>>> b.shape
(4, 3)

3、浅复制

view 函数会使用浅复制的方法创建一个数组对象的“视图”

>>> c = a.view()
>>> c is a
False
>>> c.base is a
True
>>> c.flags.owndata
False
>>> c.shape = 2,6  # a的shape没有被改变
>>> a.shape
(4, 3)
>>> c[0,4]=1234  # a的data没有被改变
>>> a
array([[   0,    1,    2],
       [   3, 1234,    5],
       [   6,    7,    8],
       [   9,   10,   11]])

对数组进行裁剪即会使用 view 函数返回原数组的部分属性（即元素）

>>> s = a[:,1:3]
>>> s[:] = 10
>>> a
array([[ 0, 10, 10],
       [ 3, 10, 10],
       [ 6, 10, 10],
       [ 9, 10, 10]])

3、深度复制

copy 函数会返回一个数组的深度复制，包括所有的属性

>>> d = a.copy()
>>> d is a
False
>>> d.base is a  # d不与a共享任何数据
False
>>> d[0,0] = 999
>>> a
array([[ 0, 10, 10],
       [ 3, 10, 10],
       [ 6, 10, 10],
       [ 9, 10, 10]])

从垃圾处理的角度来说，如果从一个巨大的数组中截取了部分元素，而原数组不再被需
要，那么最好使用 copy 函数深度复制截取的子数组，并将原数组销毁

>>> a = np.arange(int(1e8))
>>> b = a[:100].copy()
>>> del a

上面的例子中，如果使用 b = a[:100] 而不使用 copy 函数，那么 a 所占据的内存将不
能被销毁

五、索引技巧

1、数组索引

Numpy相对于Python标准库来说提供了更多的索引工具
例如，NumPy允许通过一组索引来一次性索引一个数组

>>> a = np.arange(12)
>>> a
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
>>> a = np.arange(12)**2
>>> a
array([  0,   1,   4,   9,  16,  25,  36,  49,  64,  81, 100, 121],
      dtype=int32)
      
>>> i = np.array([1,1,3,8,5])
>>> a[i]
array([ 1,  1,  9, 64, 25], dtype=int32)

>>> j = np.array([[3,4],[9,7]])
>>> a[j] # 形状和j一样
array([[ 9, 16],
       [81, 49]], dtype=int32)

当被检索的数组是多维数组时，传递数组索引将被视为检索第一维度。例如，我们可以
通过检索调色盘来生成一张图片

>>> palette = np.array([[0,0,0],			# black
...                     [255,0,0],			# red
...                     [0,255,0],			# green
...                     [0,0,255],			# blue
...                     [255,255,255]])		#white

>>> image = np.array([[0,1,2,0],  # 每个值对应调色盘里的颜色
...                   [0,3,4,0]])

>>> palette[image]   # （2,4，3）图片
array([[[  0,   0,   0],
        [255,   0,   0],
        [  0, 255,   0],
        [  0,   0,   0]],

       [[  0,   0,   0],
        [  0,   0, 255],
        [255, 255, 255],
        [  0,   0,   0]]])

NumPy也支持传递多维数组作为检索索引，但是每一维的形状必须相同

>>> a = np.arange(12).reshape(3,4)
>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> i = np.array([[0,1],   # a的第一维索引
...               [1,2]])
>>> j = np.array([[2,1],   # a的第二维索引
...               [3,3]])
>>> a[i,j]                # i和j必须是相同形状的
array([[ 2,  5],
       [ 7, 11]])

也可以把 i 和 j 放进一个列表里，再传递给 a

>>> l = [i, j]
>>> a[l]      # 和a[i,j]等价
array([[ 2,  5],
       [ 7, 11]])

但是，不能把 i 和 j 放进一个数组里，否则按照 NumPy 的设定将视为查询第一维度

>>> s = np.array([i,j])
>>> a[s]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: index 3 is out of bounds for axis 0 with size 3

>>> a[tuple(s)]      # 和a[i,j]等价
array([[ 2,  5],
       [ 7, 11]])

数组索引经常被用在检索时间相关的数组中

>>> time = np.linspace(20,145,5)    # time scale
>>> data = np.sin(np.arange(20).reshape(5,4))  # 4 time-dependent series
>>> time
array([ 20.  ,  51.25,  82.5 , 113.75, 145.  ])
>>> data
array([[ 0.        ,  0.84147098,  0.90929743,  0.14112001],
       [-0.7568025 , -0.95892427, -0.2794155 ,  0.6569866 ],
       [ 0.98935825,  0.41211849, -0.54402111, -0.99999021],
       [-0.53657292,  0.42016704,  0.99060736,  0.65028784],
       [-0.28790332, -0.96139749, -0.75098725,  0.14987721]])
>>> ind = data.argmax(axis=0)   # index of the maxima for each series
>>> ind
array([2, 0, 3, 1], dtype=int64)
>>> time_max = time[ind]
>>> data_max = data[ind, range(data.shape[1])]     # => data[ind[0],0], data[ind[1],1]...
>>> time_max
array([ 82.5 ,  20.  , 113.75,  51.25])
>>> data_max
array([0.98935825, 0.84147098, 0.99060736, 0.6569866 ])
>>> np.all(data_max == data.max(axis=0))
True

2、布尔索引

使用数组索引时，我们提供了一个索引的序列来决定哪些元素应当被选中
使用布尔索引时，我们通过提供布尔值来决定那些元素应当被选中
最简单的布尔索引即为对每一个数组元素都指定一个布尔值

>>> a = np.arange(12).reshape(3,4)
>>> b = a > 4
>>> b     			# b是一个有着a的形状的布尔数组
array([[False, False, False, False],
       [False,  True,  True,  True],
       [ True,  True,  True,  True]])
>>> a[b]
array([ 5,  6,  7,  8,  9, 10, 11])   # 选定元素的一维数组
>>> a[b] = 0         			    # a中大于4的元素赋值为0
>>> a  
array([[0, 1, 2, 3],   
       [4, 0, 0, 0],
       [0, 0, 0, 0]])

与数组索引类似，布尔索引也可以传递多个给多维数组，从而获取对应元素

>>> a = np.arange(12).reshape(3,4)
>>>> a
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> b1 = np.array([False,True,True])    		# 第一维
>>> b2 = np.array([True,False,True,False])      # 第二维
>>> a[b1,:]                    # 挑选行
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> a[b1]                     # the same as a[b1,:]
array([[ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
       
>>> a[:,b2]                   # 挑选列
array([[ 0,  2],
       [ 4,  6],
       [ 8, 10]])
>>> a[b1,b2]    #  a weird thing to do？
array([ 4, 10])

NumPy 提供一个 ix_ 函数，能把两个一维数组
转换为一个用于选取方形区域的索引器

>>> arr2 = np.arange(32).reshape((8,4))
>>> arr2
array([[ 0,  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]])
>>> arr2[np.ix_([1,5,7,2],[0,3,1,2])]
array([[ 4,  7,  5,  6],
       [20, 23, 21, 22],
       [28, 31, 29, 30],
       [ 8, 11,  9, 10]])

❖ 在这个例子中， ix_ 函数将数组 [1,5,7,2] 和数
组 [0,3,1,2] 产生笛卡尔积，即： (1,0)， (1,3)，
(1,1)， (1,2)； (5,0)， (5,3)， (5,1)， (5,2)；
(7,0)， (7,3)， (7,1)， (7,2)； (2,0)， (2,3)，
(2,1)， (2,2)
❖ 按照坐标 (1,0)， (1,3)， (1,1)， (1,2) 取得
arr2 所对应的元素 4， 7， 5， 6
❖ 按照坐标 (5,0)， (5,3)， (5,1)， (5,2) 取得
arr2 所对应的元素 20， 23， 21， 22
❖ 如此类推

六、进阶功能

❖ 更多的进阶功能可以参考官方教程：
❖ https://www.numpy.org/devdocs/user/quickstart.html
❖ NumPy 的实用小技巧：
❖ https://www.numpy.org/devdocs/user/quickstart.html#tricks-and-tips
❖ 函数详细说明文档及手册：
❖ https://www.numpy.org/devdocs/reference/routines.html
❖ Wes McKinney《利用 Python 进行数据分析》：
❖ http://product.dangdang.com/25312917.html

qq_41823444

关注

2
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
python numpy

一、NumPy 简介NumPyshi 是Python的一个拓展程序库，主要用于科学计算NumPy支持高端大量的维度数组与矩阵运算NumPy针对数组运算提供大量的数学函数库同时，NumPy是SciPy、Matplotlib等扩展路的基础组件二、基本用法1、NumPy d的数组Numpy 的主要数据结构是一个同构多维数组，大于矩阵的概念维度（ dimension）在 Numpy 中...
复制链接

扫一扫