Numpy简介
NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。
Numeric,即 NumPy 的前身,是由 Jim Hugunin 开发的。 也开发了另一个包 Numarray ,它拥有一些额外的功能。 2005年,Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 这个开源项目有很多贡献者。
Numpy操作
使用NumPy,开发人员可以执行以下操作:
-
数组的算数和逻辑运算。
-
傅立叶变换和用于图形操作的例程。
-
与线性代数有关的操作。 NumPy 拥有线性代数和随机数生成的内置函数。
NumPy – MatLab 的替代之一
NumPy 通常与 SciPy(Scientific Python)和 Matplotlib(绘图库)一起使用。 这种组合广泛用于替代 MatLab,是一个流行的技术计算平台。 但是,Python 作为 MatLab 的替代方案,现在被视为一种更加现代和完整的编程语言。
NumPy 是开源的,这是它的一个额外的优势。
NumPy - Ndarray 对象
NumPy 中定义的最重要的对象是称为 ndarray
的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目。
ndarray
中的每个元素在内存中使用相同大小的块。 ndarray
中的每个元素是数据类型对象的对象(称为 dtype
)。
从ndarray
对象提取的任何元素(通过切片)由一个数组标量类型的 Python 对象表示。
ndarray类的实例可以通过本教程后面描述的不同的数组创建例程来构造。 基本的
ndarray`是使用 NumPy 中的数组函数创建的,如下所示:
numpy.array
它从任何暴露数组接口的对象,或从返回数组的任何方法创建一个ndarray。
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
上面的构造器接受以下参数:
序号 | 参数及描述 |
---|---|
1. | object 任何暴露数组接口方法的对象都会返回一个数组或任何(嵌套)序列。 |
2. | dtype 数组的所需数据类型,可选。 |
3. | copy 可选,默认为true ,对象是否被复制。 |
4. | order C (按行)、F (按列)或A (任意,默认)。 |
5. | subok 默认情况下,返回的数组被强制为基类数组。 如果为true ,则返回子类。 |
6. | ndimin 指定返回数组的最小维数。 |
看看下面的例子来更好地理解。
示例 1
import numpy as np
a = np.array([1,2,3])
print a
输出如下:
[1, 2, 3]
示例 2
# 多于一个维度
import numpy as np
a = np.array([[1, 2], [3, 4]])
print a
输出如下:
[[1, 2]
[3, 4]]
示例 3
# 最小维度
import numpy as np
a = np.array([1, 2, 3,4,5], ndmin = 2)
print a
输出如下:
[[1, 2, 3, 4, 5]]
示例 4
# dtype 参数
import numpy as np
a = np.array([1, 2, 3], dtype = complex) #复数
print a
输出如下:
[ 1.+0.j, 2.+0.j, 3.+0.j]
**ndarray ** 对象由计算机内存中的一维连续区域组成,带有将每个元素映射到内存块中某个位置的索引方案。 内存块以按行(C 风格)或按列(FORTRAN 或 MatLab 风格)的方式保存元素。
NumPy - 数据类型
NumPy 支持比 Python 更多种类的数值类型。 下表显示了 NumPy 中定义的不同标量数据类型。
序号 | 数据类型及描述 |
---|---|
1. | bool_ 存储为一个字节的布尔值(真或假) |
2. | int_ 默认整数,相当于 C 的long ,通常为int32 或int64 |
3. | intc 相当于 C 的int ,通常为int32 或int64 |
4. | intp 用于索引的整数,相当于 C 的size_t ,通常为int32 或int64 |
5. | int8 字节(-128 ~ 127) |
6. | int16 16 位整数(-32768 ~ 32767) |
7. | int32 32 位整数(-2147483648 ~ 2147483647) |
8. | int64 64 位整数(-9223372036854775808 ~ 9223372036854775807) |
9. | uint8 8 位无符号整数(0 ~ 255) |
10. | uint16 16 位无符号整数(0 ~ 65535) |
11. | uint32 32 位无符号整数(0 ~ 4294967295) |
12. | uint64 64 位无符号整数(0 ~ 18446744073709551615) |
13. | float_ float64 的简写 |
14. | float16 半精度浮点:符号位,5 位指数,10 位尾数 |
15. | float32 单精度浮点:符号位,8 位指数,23 位尾数 |
16. | float64 双精度浮点:符号位,11 位指数,52 位尾数 |
17. | complex_ complex128 的简写 |
18. | complex64 复数,由两个 32 位浮点表示(实部和虚部) |
19. | complex128 复数,由两个 64 位浮点表示(实部和虚部) |
NumPy 数字类型是dtype
(数据类型)对象的实例,每个对象具有唯一的特征。 这些类型可以是np.bool_
,np.float32
等。
数据类型对象 (dtype
)
数据类型对象描述了对应于数组的固定内存块的解释,取决于以下方面:
-
数据类型(整数、浮点或者 Python 对象)
-
数据大小
-
字节序(小端或大端)
-
在结构化类型的情况下,字段的名称,每个字段的数据类型,和每个字段占用的内存块部分。
-
如果数据类型是子序列,它的形状和数据类型。
字节顺序取决于数据类型的前缀<
或>
。 <
意味着编码是小端(最小有效字节存储在最小地址中)。 >
意味着编码是大端(最大有效字节存储在最小地址中)。
dtype
可由一下语法构造:
numpy.dtype(object, align, copy)
参数为:
-
Object
:被转换为数据类型的对象。 -
Align
:如果为true
,则向字段添加间隔,使其类似 C 的结构体。 -
Copy
生成dtype
对象的新副本,如果为flase
,结果是内建数据类型对象的引用。
示例 1
# 使用数组标量类型
import numpy as np
dt = np.dtype(np.int32)
print dt
输出如下:
int32
示例 2
#int8,int16,int32,int64 可替换为等价的字符串 'i1','i2','i4',以及其他。
import numpy as np
dt = np.dtype('i4')
print dt
输出如下:
int32
示例 3
# 使用端记号
import numpy as np
dt = np.dtype('>i4')
print dt
输出如下:
>i4
下面的例子展示了结构化数据类型的使用。 这里声明了字段名称和相应的标量数据类型。
示例 4
# 首先创建结构化数据类型。
import numpy as np
dt = np.dtype([('age',np.int8)])
print dt
输出如下:
[('age', 'i1')]
示例 5
# 现在将其应用于 ndarray 对象
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print a
输出如下:
[(10,) (20,) (30,)]
示例 6
# 文件名称可用于访问 age 列的内容
import numpy as np
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)], dtype = dt)
print a['age']
输出如下:
[10 20 30]
示例 7
以下示例定义名为 student 的结构化数据类型,其中包含字符串字段name
,整数字段age
和浮点字段marks
。 此dtype
应用于ndarray
对象。
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
print student
输出如下:
[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])
示例 8
import numpy as np
student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
a = np.array([('abc', 21, 50),('xyz', 18, 75)], dtype = student)
print a
输出如下:
[('abc', 21, 50.0), ('xyz', 18, 75.0)]
每个内建类型都有一个唯一定义它的字符代码:
-
'b'
:布尔值 -
'i'
:符号整数 -
'u'
:无符号整数 -
'f'
:浮点 -
'c'
:复数浮点 -
'm'
:时间间隔 -
'M'
:日期时间 -
'O'
:Python 对象 -
'S', 'a'
:字节串 -
'U'
:Unicode -
'V'
:原始数据(void
)
NumPy - 数组属性
这一章中,我们会讨论 NumPy 的多种数组属性。
ndarray.shape
这一数组属性返回一个包含数组维度的元组,它也可以用于调整数组大小。
示例 1
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print a.shape
输出如下:
(2, 3)
示例 2
# 这会调整数组大小
import numpy as np
a = np.array([[1,2,3],[4,5,6]]) a.shape = (3,2)
print a
输出如下:
[[1, 2]
[3, 4]
[5, 6]]
示例 3
NumPy 也提供了reshape
函数来调整数组大小。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print b
输出如下:
[[1, 2]
[3, 4]
[5, 6]]
ndarray.ndim
这一数组属性返回数组的维数。
示例 1
# 等间隔数字的数组
import numpy as np
a = np.arange(24) print a
输出如下:
[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
示例 2
# 一维数组
import numpy as np
a = np.arange(24) a.ndim
# 现在调整其大小
b = a.reshape(2,4,3)
print b
# b 现在拥有三个维度
输出如下:
[[[ 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.itemsize
这一数组属性返回数组中每个元素的字节单位长度。
示例 1
# 数组的 dtype 为 int8(一个字节)
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.int8)
print x.itemsize
输出如下:
1
示例 2
# 数组的 dtype 现在为 float32(四个字节)
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.float32)
print x.itemsize
输出如下:
4
numpy.flags
ndarray
对象拥有以下属性。这个函数返回了它们的当前值。
序号 | 属性及描述 |
---|---|
1. | C_CONTIGUOUS (C) 数组位于单一的、C 风格的连续区段内 |
2. | F_CONTIGUOUS (F) 数组位于单一的、Fortran 风格的连续区段内 |
3. | OWNDATA (O) 数组的内存从其它对象处借用 |
4. | WRITEABLE (W) 数据区域可写入。 将它设置为flase 会锁定数据,使其只读 |
5. | ALIGNED (A) 数据和任何元素会为硬件适当对齐 |
6. | UPDATEIFCOPY (U) 这个数组是另一数组的副本。当这个数组释放时,源数组会由这个数组中的元素更新 |
示例
下面的例子展示当前的标志。
import numpy as np
x = np.array([1,2,3,4,5])
print x.flags
输出如下:
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
NumPy - 数组创建例程
新的ndarray
对象可以通过任何下列数组创建例程或使用低级ndarray
构造函数构造。
numpy.empty
它创建指定形状和dtype
的未初始化数组。 它使用以下构造函数:
构造器接受下列参数:
序号 | 参数及描述 |
---|---|
1. | Shape 空数组的形状,整数或整数元组 |
2. | Dtype 所需的输出数组类型,可选 |
3. | Order 'C' 为按行的 C 风格数组,'F' 为按列的 Fortran 风格数组 |
示例
下面的代码展示空数组的例子:
import numpy as np
x = np.empty([3,2], dtype = int)
print x
输出如下:
[[22649312 1701344351]
[1818321759 1885959276]
[16779776 156368896]]
注意:数组元素为随机值,因为它们未初始化。
numpy.zeros
返回特定大小,以 0 填充的新数组。
numpy.zeros(shape, dtype = float, order = 'C')
构造器接受下列参数:
序号 | 参数及描述 |
---|---|
1. | Shape 空数组的形状,整数或整数元组 |
2. | Dtype 所需的输出数组类型,可选 |
3. | Order 'C' 为按行的 C 风格数组,'F' 为按列的 Fortran 风格数组 |
示例 1
# 含有 5 个 0 的数组,默认类型为 float
import numpy as np
x = np.zeros(5)
print x
输出如下:
[ 0. 0. 0. 0. 0.]
示例 2
import numpy as np
x = np.zeros((5,), dtype = np.int)
print x
输出如下:
[0 0 0 0 0]
示例 3
# 自定义类型
import numpy as np
x = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
print x
输出如下:
[[(0,0)(0,0)]
[(0,0)(0,0)]]
numpy.ones
返回特定大小,以 1 填充的新数组。
numpy.ones(shape, dtype = None, order = 'C')
构造器接受下列参数:
序号 | 参数及描述 |
---|---|
1. | Shape 空数组的形状,整数或整数元组 |
2. | Dtype 所需的输出数组类型,可选 |
3. | Order 'C' 为按行的 C 风格数组,'F' 为按列的 Fortran 风格数组 |
示例 1
# 含有 5 个 1 的数组,默认类型为 float
import numpy as np
x = np.ones(5) print x
输出如下:
[ 1. 1. 1. 1. 1.]
示例 2
import numpy as np
x = np.ones([2,2], dtype = int)
print x
输出如下:
[[1 1]
[1 1]]
NumPy - 来自现有数据的数组
这一章中,我们会讨论如何从现有数据创建数组。
numpy.asarray
此函数类似于numpy.array
,除了它有较少的参数。 这个例程对于将 Python 序列转换为ndarray
非常有用。
numpy.asarray(a, dtype = None, order = None)
构造器接受下列参数:
序号 | 参数及描述 |
---|---|
1. | a 任意形式的输入参数,比如列表、列表的元组、元组、元组的元组、元组的列表 |
2. | dtype 通常,输入数据的类型会应用到返回的ndarray |
3. | order 'C' 为按行的 C 风格数组,'F' 为按列的 Fortran 风格数组 |
示例 1
# 将列表转换为 ndarray
import numpy as np
x = [1,2,3]
a = np.asarray(x)
print a
输出如下:
[1 2 3]
示例 2
# 设置了 dtype
import numpy as np
x = [1,2,3]
a = np.asarray(x, dtype = float)
print a
输出如下:
[ 1. 2. 3.]
示例 3
# 来自元组的 ndarray
import numpy as np
x = (1,2,3)
a = np.asarray(x)
print a
输出如下:
[1 2 3]
示例 4
# 来自元组列表的 ndarray
import numpy as np
x = [(1,2,3),(4,5)]
a = np.asarray(x)
print a
输出如下:
[(1, 2, 3) (4, 5)]
numpy.frombuffer
此函数将缓冲区解释为一维数组。 暴露缓冲区接口的任何对象都用作参数来返回ndarray
。
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
构造器接受下列参数:
序号 | 参数及描述 |
---|---|
1. | buffer 任何暴露缓冲区借口的对象 |
2. | dtype 返回数组的数据类型,默认为float |
3. | count 需要读取的数据数量,默认为-1 ,读取所有数据 |
4. | offset 需要读取的起始位置,默认为0 |
示例
下面的例子展示了frombuffer
函数的用法。
import numpy as np
s = 'Hello World'
a = np.frombuffer(s, dtype = 'S1')
print a
输出如下:
['H' 'e' 'l' 'l' 'o' ' ' 'W' 'o' 'r' 'l' 'd']
numpy.fromiter
此函数从任何可迭代对象构建一个ndarray
对象,返回一个新的一维数组。
numpy.fromiter(iterable, dtype, count = -1)
构造器接受下列参数:
序号 | 参数及描述 |
---|---|
1. | iterable 任何可迭代对象 |
2. | dtype 返回数组的数据类型 |
3. | count 需要读取的数据数量,默认为-1 ,读取所有数据 |
以下示例展示了如何使用内置的range()
函数返回列表对象。 此列表的迭代器用于形成 ndarray
对象。
示例 1
# 使用 range 函数创建列表对象
import numpy as np
list = range(5)
print list
输出如下:
[0, 1, 2, 3, 4]
示例 2
# 从列表中获得迭代器
import numpy as np
list = range(5)
it = iter(list)
# 使用迭代器创建 ndarray
x = np.fromiter(it, dtype = float)
print x
输出如下:
[0. 1. 2. 3. 4.]
NumPy - 来自数值范围的数组
这一章中,我们会学到如何从数值范围创建数组。
numpy.arange
这个函数返回ndarray
对象,包含给定范围内的等间隔值。
numpy.arange(start, stop, step, dtype)
构造器接受下列参数:
序号 | 参数及描述 |
---|---|
1. | start 范围的起始值,默认为0 |
2. | stop 范围的终止值(不包含) |
3. | step 两个值的间隔,默认为1 |
4. | dtype 返回ndarray 的数据类型,如果没有提供,则会使用输入数据的类型。 |
下面的例子展示了如何使用该函数:
示例 1
import numpy as np
x = np.arange(5)
print x
输出如下:
[0 1 2 3 4]
示例 2
import numpy as np
# 设置了 dtype
x = np.arange(5, dtype = float)
print x
输出如下:
[0. 1. 2. 3. 4.]
示例 3
# 设置了起始值和终止值参数
import numpy as np
x = np.arange(10,20,2)
print x
输出如下:
[10 12 14 16 18]
numpy.linspace
此函数类似于arange()
函数。 在此函数中,指定了范围之间的均匀间隔数量,而不是步长。 此函数的用法如下。
numpy.linspace(start, stop, num, endpoint, retstep, dtype)
构造器接受下列参数:
序号 | 参数及描述 |
---|---|
1. | start 序列的起始值 |
2. | stop 序列的终止值,如果endpoint 为true ,该值包含于序列中 |
3. | num 要生成的等间隔样例数量,默认为50 |
4. | endpoint 序列中是否包含stop 值,默认为ture |
5. | retstep 如果为true ,返回样例,以及连续数字之间的步长 |
6. | dtype 输出ndarray 的数据类型 |
下面的例子展示了linspace
函数的用法。
示例 1
import numpy as np
x = np.linspace(10,20,5)
print x
输出如下:
[10. 12.5 15. 17.5 20.]
示例 2
# 将 endpoint 设为 false
import numpy as np
x = np.linspace(10,20, 5, endpoint = False)
print x
输出如下:
[10. 12. 14. 16. 18.]
示例 3
# 输出 retstep 值
import numpy as np
x = np.linspace(1,2,5, retstep = True)
print x
# 这里的 retstep 为 0.25
输出如下:
(array([ 1. , 1.25, 1.5 , 1.75, 2. ]), 0.25)
numpy.logspace
此函数返回一个ndarray
对象,其中包含在对数刻度上均匀分布的数字。 刻度的开始和结束端点是某个底数的幂,通常为 10。
numpy.logscale(start, stop, num, endpoint, base, dtype)
logspace
函数的输出由以下参数决定:
序号 | 参数及描述 |
---|---|
1. | start 起始值是base ** start |
2. | stop 终止值是base ** stop |
3. | num 范围内的数值数量,默认为50 |
4. | endpoint 如果为true ,终止值包含在输出数组当中 |
5. | base 对数空间的底数,默认为10 |
6. | dtype 输出数组的数据类型,如果没有提供,则取决于其它参数 |
下面的例子展示了logspace
函数的用法。
示例 1
import numpy as np
# 默认底数是 10
a = np.logspace(1.0, 2.0, num = 10)
print a
输出如下:
[ 10. 12.91549665 16.68100537 21.5443469 27.82559402
35.93813664 46.41588834 59.94842503 77.42636827 100. ]
示例 2
# 将对数空间的底数设置为 2
import numpy as np
a = np.logspace(1,10,num = 10, base = 2)
print a
输出如下:
[ 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.]
NumPy - 切片和索引
ndarray
对象的内容可以通过索引或切片来访问和修改,就像 Python 的内置容器对象一样。
如前所述,ndarray
对象中的元素遵循基于零的索引。 有三种可用的索引方法类型: 字段访问,基本切片和高级索引。
基本切片是 Python 中基本切片概念到 n 维的扩展。 通过将start
,stop
和step
参数提供给内置的slice
函数来构造一个 Python slice
对象。 此slice
对象被传递给数组来提取数组的一部分。
示例 1
import numpy as np
a = np.arange(10)
s = slice(2,7,2)
print a[s]
输出如下:
[2 4 6]
在上面的例子中,ndarray
对象由arange()
函数创建。 然后,分别用起始,终止和步长值2
,7
和2
定义切片对象。 当这个切片对象传递给ndarray
时,会对它的一部分进行切片,从索引2
到7
,步长为2
。
通过将由冒号分隔的切片参数(start:stop:step
)直接提供给ndarray
对象,也可以获得相同的结果。
示例 2
import numpy as np
a = np.arange(10)
b = a[2:7:2]
print b
输出如下:
[2 4 6]
如果只输入一个参数,则将返回与索引对应的单个项目。 如果使用a:
,则从该索引向后的所有项目将被提取。 如果使用两个参数(以:
分隔),则对两个索引(不包括停止索引)之间的元素以默认步骤进行切片。
示例 3
# 对单个元素进行切片
import numpy as np
a = np.arange(10)
b = a[5]
print b
输出如下:
5
示例 4
# 对始于索引的元素进行切片
import numpy as np
a = np.arange(10)
print a[2:]
输出如下:
[2 3 4 5 6 7 8 9]
示例 5
# 对索引之间的元素进行切片
import numpy as np
a = np.arange(10)
print a[2:5]
输出如下:
[2 3 4]
上面的描述也可用于多维ndarray
。
示例 6
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print a
# 对始于索引的元素进行切片
print '现在我们从索引 a[1:] 开始对数组切片'
print a[1:]
输出如下:
[[1 2 3]
[3 4 5]
[4 5 6]]
现在我们从索引 a[1:] 开始对数组切片
[[3 4 5]
[4 5 6]]
切片还可以包括省略号(...
),来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号,它将返回包含行中元素的ndarray
。
示例 7
# 最开始的数组
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print '我们的数组是:'
print a
print '\n'
# 这会返回第二列元素的数组:
print '第二列的元素是:'
print a[...,1]
print '\n'
# 现在我们从第二行切片所有元素:
print '第二行的元素是:'
print a[1,...]
print '\n'
# 现在我们从第二列向后切片所有元素:
print '第二列及其剩余元素是:'
print a[...,1:]
输出如下:
我们的数组是:
[[1 2 3]
[3 4 5]
[4 5 6]]
第二列的元素是:
[2 4 5]
第二行的元素是:
[3 4 5]
第二列及其剩余元素是:
[[2 3]
[4 5]
[5 6]]
NumPy - 高级索引
如果一个ndarray
是非元组序列,数据类型为整数或布尔值的ndarray
,或者至少一个元素为序列对象的元组,我们就能够用它来索引ndarray
。高级索引始终返回数据的副本。 与此相反,切片只提供了一个视图。
有两种类型的高级索引:整数和布尔值。
整数索引
这种机制有助于基于 N 维索引来获取数组中任意元素。 每个整数数组表示该维度的下标值。 当索引的元素个数就是目标ndarray
的维度时,会变得相当直接。
以下示例获取了ndarray
对象中每一行指定列的一个元素。 因此,行索引包含所有行号,列索引指定要选择的元素。
示例 1
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]] #对应00,11,20坐标 分别为1,4,5
print y
输出如下:
[1 4 5]
该结果包括数组中(0,0)
,(1,1)
和(2,0)
位置处的元素。
下面的示例获取了 4X3 数组中的每个角处的元素。 行索引是[0,0]
和[3,3]
,而列索引是[0,2]
和[0,2]
。
示例 2
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print '我们的数组是:'
print x
print '\n'
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols] #这个对应00 02 30 32位置
print '这个数组的每个角处的元素是:'
print y
输出如下:
我们的数组是:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
这个数组的每个角处的元素是:
[[ 0 2]
[ 9 11]]
高级和基本索引可以通过使用切片:
或省略号...
与索引数组组合。 以下示例使用slice
作为列索引和高级索引。 当切片用于两者时,结果是相同的。 但高级索引会导致复制,并且可能有不同的内存布局。
示例 3
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print '我们的数组是:'
print x
print '\n'
# 切片
z = x[1:4,1:3]
print '切片之后,我们的数组变为:'
print z
print '\n'
# 对列使用高级索引
y = x[1:4,[1,2]]
print '对列使用高级索引来切片:'
print y
输出如下:
我们的数组是:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
切片之后,我们的数组变为:
[[ 4 5]
[ 7 8]
[10 11]]
对列使用高级索引来切片:
[[ 4 5]
[ 7 8]
[10 11]]
布尔索引
当结果对象是布尔运算(例如比较运算符)的结果时,将使用此类型的高级索引。
示例 1
这个例子中,大于 5 的元素会作为布尔索引的结果返回。
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print '我们的数组是:'
print x
print '\n'
# 现在我们会打印出大于 5 的元素
print '大于 5 的元素是:'
print x[x > 5]
输出如下:
我们的数组是:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
大于 5 的元素是:
[ 6 7 8 9 10 11]
示例 2
这个例子使用了~
(取补运算符)来过滤NaN
。
import numpy as np
a = np.array([np.nan, 1,2,np.nan,3,4,5])
print a[~np.isnan(a)]
输出如下:
[ 1. 2. 3. 4. 5.]
示例 3
以下示例显示如何从数组中过滤掉非复数元素。
import numpy as np
a = np.array([1, 2+6j, 5, 3.5+5j])
print a[np.iscomplex(a)]
输出如下:
[2.0+6.j 3.5+5.j]
NumPy - 广播
术语广播是指 NumPy 在算术运算期间处理不同形状
的数组的能力。 对数组的算术运算通常在相应的元素上进行。 如果两个阵列具有完全相同的形状,则这些操作被无缝执行。
示例 1
import numpy as np
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
c = a * b
print c
输出如下:
[10 40 90 160]
如果两个数组的维数不相同,则元素到元素的操作是不可能的。 然而,在 NumPy 中仍然可以对形状不相似的数组进行操作,因为它拥有广播功能。 较小的数组会广播到较大如果满足以下规则,可以进行广播:
-
ndim
较小的数组会在前面追加一个长度为 1 的维度。 -
输出数组的每个维度的大小是输入数组该维度大小的最大值。
-
如果输入在每个维度中的大小与输出大小匹配,或其值正好为 1,则在计算中可它。
-
如果输入的某个维度大小为 1,则该维度中的第一个数据元素将用于该维度的所有计算。
如果上述规则产生有效结果,并且满足以下条件之一,那么数组被称为可广播的。
-
数组拥有相同形状。
-
数组拥有相同的维数,每个维度拥有相同长度,或者长度为 1。
-
数组拥有极少的维度,可以在其前面追加长度为 1 的维度,使上述条件成立。
下面的例称展示了广播的示例。
数组的大小,以便使它们的形状可兼容。
示例 2
import numpy as np
a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]])
b = np.array([1.0,2.0,3.0])
print '第一个数组:'
print a
print '\n'
print '第二个数组:'
print b
print '\n'
print '第一个数组加第二个数组:'
print a + b
输出如下:
第一个数组:
[[ 0. 0. 0.]
[ 10. 10. 10.]
[ 20. 20. 20.]
[ 30. 30. 30.]]
第二个数组:
[ 1. 2. 3.]
第一个数组加第二个数组:
[[ 1. 2. 3.]
[ 11. 12. 13.]
[ 21. 22. 23.]
[ 31. 32. 33.]]
下面的图片展示了数组b
如何通过广播来与数组a
兼容。
NumPy - 数组上的迭代
NumPy 包包含一个迭代器对象numpy.nditer
。 它是一个有效的多维迭代器对象,可以用于在数组上进行迭代。 数组的每个元素可使用 Python 的标准Iterator
接口来访问。
让我们使用arange()
函数创建一个 3X4 数组,并使用nditer
对它进行迭代。
示例 1
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print '原始数组是:'
print a print '\n'
print '修改后的数组是:'
for x in np.nditer(a):
print x,
输出如下:
原始数组是:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
修改后的数组是:
0 5 10 15 20 25 30 35 40 45 50 55
示例 2
迭代的顺序匹配数组的内容布局,而不考虑特定的排序。 这可以通过迭代上述数组的转置来看到。
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print '原始数组是:'
print a
print '\n'
print '原始数组的转置是:'
b = a.T
print b
print '\n'
print '修改后的数组是:'
for x in np.nditer(b):
print x,
输出如下:
原始数组是:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
原始数组的转置是:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
修改后的数组是:
0 5 10 15 20 25 30 35 40 45 50 55
迭代顺序
如果相同元素使用 F 风格顺序存储,则迭代器选择以更有效的方式对数组进行迭代。
示例 1
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print '原始数组是:'
print a print '\n'
print '原始数组的转置是:'
b = a.T
print b
print '\n'
print '以 C 风格顺序排序:'
c = b.copy(order='C')
print c
for x in np.nditer(c):
print x,
print '\n'
print '以 F 风格顺序排序:'
c = b.copy(order='F')
print c
for x in np.nditer(c):
print x,
输出如下:
原始数组是:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
原始数组的转置是:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
以 C 风格顺序排序:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55
以 F 风格顺序排序:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 5 10 15 20 25 30 35 40 45 50 55
修改数组的值
nditer
对象有另一个可选参数op_flags
。 其默认值为只读,但可以设置为读写或只写模式。 这将允许使用此迭代器修改数组元素。
示例
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print '原始数组是:'
print a
print '\n'
for x in np.nditer(a, op_flags=['readwrite']):
x[...]=2*x
print '修改后的数组是:'
print a
输出如下:
原始数组是:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
修改后的数组是:
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]
外部循环
nditer
类的构造器拥有flags
参数,它可以接受下列值:
序号 | 参数及描述 |
---|---|
1. | c_index 可以跟踪 C 顺序的索引 |
2. | f_index 可以跟踪 Fortran 顺序的索引 |
3. | multi-index 每次迭代可以跟踪一种索引类型 |
4. | external_loop 给出的值是具有多个值的一维数组,而不是零维数组 |
示例
在下面的示例中,迭代器遍历对应于每列的一维数组。
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print '原始数组是:'
print a
print '\n'
print '修改后的数组是:'
for x in np.nditer(a, flags = ['external_loop'], order = 'F'):
print x,
输出如下:
原始数组是:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
修改后的数组是:
[ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]
广播迭代
如果两个数组是可广播的,nditer
组合对象能够同时迭代它们。 假设数组a
具有维度 3X4,并且存在维度为 1X4 的另一个数组b
,则使用以下类型的迭代器(数组b
被广播到a
的大小)。
示例
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print '第一个数组:'
print a
print '\n'
print '第二个数组:'
b = np.array([1, 2, 3, 4], dtype = int)
print b
print '\n'
print '修改后的数组是:'
for x,y in np.nditer([a,b]):
print "%d:%d" % (x,y),
输出如下:
第一个数组:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
第二个数组:
[1 2 3 4]
修改后的数组是:
0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4
NumPy - 数组操作
NumPy包中有几个例程用于处理ndarray
对象中的元素。 它们可以分为以下类型:
序号 | 形状及描述 |
---|---|
1. | reshape 不改变数据的条件下修改形状 |
2. | flat 数组上的一维迭代器 |
3. | flatten 返回折叠为一维的数组副本 |
4. | ravel 返回连续的展开数组 |
numpy.reshape
这个函数在不改变数据的条件下修改形状,它接受如下参数:
numpy.reshape(arr, newshape, order')
其中:
arr
:要修改形状的数组newshape
:整数或者整数数组,新的形状应当兼容原有形状order
:'C'
为 C 风格顺序,'F'
为 F 风格顺序,'A'
为保留原顺序。
例子
import numpy as np
a = np.arange(8)
print '原始数组:'
print a
print '\n'
b = a.reshape(4,2)
print '修改后的数组:'
print b
输出如下:
原始数组:
[0 1 2 3 4 5 6 7]
修改后的数组:
[[0 1]
[2 3]
[4 5]
[6 7]]
numpy.ndarray.flat
该函数返回数组上的一维迭代器,行为类似 Python 内建的迭代器。
例子
import numpy as np
a = np.arange(8).reshape(2,4)
print '原始数组:'
print a
print '\n'
print '调用 flat 函数之后:'
# 返回展开数组中的下标的对应元素
print a.flat[5]
输出如下:
原始数组:
[[0 1 2 3]
[4 5 6 7]]
调用 flat 函数之后:
5
numpy.ndarray.flatten
该函数返回折叠为一维的数组副本,函数接受下列参数:
ndarray.flatten(order)
其中:
order
:'C'
– 按行,'F'
– 按列,'A'
– 原顺序,'k'
– 元素在内存中的出现顺序。
例子
import numpy as np
a = np.arange(8).reshape(2,4)
print '原数组:'
print a
print '\n'
# default is column-major
print '展开的数组:'
print a.flatten()
print '\n'
print '以 F 风格顺序展开的数组:'
print a.flatten(order = 'F')
输出如下:
原数组:
[[0 1 2 3]
[4 5 6 7]]
展开的数组:
[0 1 2 3 4 5 6 7]
以 F 风格顺序展开的数组:
[0 4 1 5 2 6 3 7]
numpy.ravel
这个函数返回展开的一维数组,并且按需生成副本。返回的数组和输入数组拥有相同数据类型。这个函数接受两个参数。
numpy.ravel(a, order)
构造器接受下列参数:
order
:'C'
– 按行,'F'
– 按列,'A'
– 原顺序,'k'
– 元素在内存中的出现顺序。
import numpy as np
a = np.arange(8).reshape(2,4)
print '原数组:'
print a
print '\n'
print '调用 ravel 函数之后:'
print a.ravel()
print '\n'
print '以 F 风格顺序调用 ravel 函数之后:'
print a.ravel(order = 'F')
原数组:
[[0 1 2 3]
[4 5 6 7]]
调用 ravel 函数之后:
[0 1 2 3 4 5 6 7]
以 F 风格顺序调用 ravel 函数之后:
[0 4 1 5 2 6 3 7]
翻转操作
序号 | 操作及描述 |
---|---|
1. | transpose 翻转数组的维度 |
2. | ndarray.T 和self.transpose() 相同 |
3. | rollaxis 向后滚动指定的轴 |
4. | swapaxes 互换数组的两个轴 |
numpy.transpose
这个函数翻转给定数组的维度。如果可能的话它会返回一个视图。函数接受下列参数:
numpy.transpose(arr, axes)
其中:
arr
:要转置的数组axes
:整数的列表,对应维度,通常所有维度都会翻转。
例子
import numpy as np
a = np.arange(12).reshape(3,4)
print '原数组:'
print a
print '\n'
print '转置数组:'
print np.transpose(a)
输出如下:
原数组:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
转置数组:
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
numpy.ndarray.T
该函数属于ndarray
类,行为类似于 numpy.transpose
。
例子
import numpy as np
a = np.arange(12).reshape(3,4)
print '原数组:'
print a
print '\n'
print '转置数组:'
print a.T
输出如下:
原数组:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
转置数组:
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
numpy.rollaxis
该函数向后滚动特定的轴,直到一个特定位置。这个函数接受三个参数:
numpy.rollaxis(arr, axis, start)
其中:
arr
:输入数组axis
:要向后滚动的轴,其它轴的相对位置不会改变start
:默认为零,表示完整的滚动。会滚动到特定位置。
[x][y][z]
[z][x][y] 2
[x][z][y] 1
例子
# 创建了三维的 ndarray
import numpy as np
a = np.arange(8).reshape(2,2,2)
print '原数组:'
print a
print '\n'
# 将轴 2 滚动到轴 0(宽度到深度)
print '调用 rollaxis 函数:'
print np.rollaxis(a,2)
# 将轴 0 滚动到轴 1:(宽度到高度)
print '\n'
print '调用 rollaxis 函数:'
print np.rollaxis(a,2,1)
输出如下:
原数组:
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
调用 rollaxis 函数:
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
调用 rollaxis 函数:
[[[0 2]
[1 3]]
[[4 6]
[5 7]]]
numpy.swapaxes
该函数交换数组的两个轴。对于 1.10 之前的 NumPy 版本,会返回交换后数组的试图。这个函数接受下列参数:
numpy.swapaxes(arr, axis1, axis2)
arr
:要交换其轴的输入数组axis1
:对应第一个轴的整数axis2
:对应第二个轴的整数
# 创建了三维的 ndarray
import numpy as np
a = np.arange(8).reshape(2,2,2)
print '原数组:'
print a
print '\n'
# 现在交换轴 0(深度方向)到轴 2(宽度方向)
print '调用 swapaxes 函数后的数组:'
print np.swapaxes(a, 2, 0)
输出如下:
原数组:
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
调用 swapaxes 函数后的数组:
[[[0 4]
[2 6]]
[[1 5]
[3 7]]]
修改维度
序号 | 维度和描述 |
---|---|
1. | broadcast 产生模仿广播的对象 |
2. | broadcast_to 将数组广播到新形状 |
3. | expand_dims 扩展数组的形状 |
4. | squeeze 从数组的形状中删除单维条目 |
broadcast
如前所述,NumPy 已经内置了对广播的支持。 此功能模仿广播机制。 它返回一个对象,该对象封装了将一个数组广播到另一个数组的结果。
该函数使用两个数组作为输入参数。 下面的例子说明了它的用法。
import numpy as np
x = np.array([[1], [2], [3]])
y = np.array([4, 5, 6])
# 对 y 广播 x
b = np.broadcast(x,y)
# 它拥有 iterator 属性,基于自身组件的迭代器元组
print '对 y 广播 x:'
r,c = b.iters
print r.next(), c.next()
print r.next(), c.next()
print '\n'
# shape 属性返回广播对象的形状
print '广播对象的形状:'
print b.shape
print '\n'
# 手动使用 broadcast 将 x 与 y 相加
b = np.broadcast(x,y)
c = np.empty(b.shape)
print '手动使用 broadcast 将 x 与 y 相加:'
print c.shape
print '\n'
c.flat = [u + v for (u,v) in b]
print '调用 flat 函数:'
print c
print '\n'
# 获得了和 NumPy 内建的广播支持相同的结果
print 'x 与 y 的和:'
print x + y
输出如下:
对 y 广播 x:
1 4
1 5
广播对象的形状:
(3, 3)
手动使用 broadcast 将 x 与 y 相加:
(3, 3)
调用 flat 函数:
[[ 5. 6. 7.]
[ 6. 7. 8.]
[ 7. 8. 9.]]
x 与 y 的和:
[[5 6 7]
[6 7 8]
[7 8 9]]
numpy.broadcast_to
此函数将数组广播到新形状。 它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则,该函数可能会抛出ValueError
。
注意 - 此功能可用于 1.10.0 及以后的版本。
该函数接受以下参数。
numpy.broadcast_to(array, shape, subok)
例子
import numpy as np
a = np.arange(4).reshape(1,4)
print '原数组:'
print a
print '\n'
print '调用 broadcast_to 函数之后:'
print np.broadcast_to(a,(4,4))
输出如下:
[[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]]
numpy.expand_dims
函数通过在指定位置插入新的轴来扩展数组形状。该函数需要两个参数:
numpy.expand_dims(arr, axis)
其中:
arr
:输入数组axis
:新轴插入的位置
例子
import numpy as np
x = np.array(([1,2],[3,4]))
print '数组 x:'
print x
print '\n'
y = np.expand_dims(x, axis = 0)
print '数组 y:'
print y
print '\n'
print '数组 x 和 y 的形状:'
print x.shape, y.shape
print '\n'
# 在位置 1 插入轴
y = np.expand_dims(x, axis = 1)
print '在位置 1 插入轴之后的数组 y:'
print y
print '\n'
print 'x.ndim 和 y.ndim:'
print x.ndim,y.ndim
print '\n'
print 'x.shape 和 y.shape:'
print x.shape, y.shape
输出如下:
数组 x:
[[1 2]
[3 4]]
数组 y:
[[[1 2]
[3 4]]]
数组 x 和 y 的形状:
(2, 2) (1, 2, 2)
在位置 1 插入轴之后的数组 y:
[[[1 2]]
[[3 4]]]
x.shape 和 y.shape:
2 3
x.shape and y.shape:
(2, 2) (2, 1, 2)
numpy.squeeze
函数从给定数组的形状中删除一维条目。 此函数需要两个参数。
numpy.squeeze(arr, axis)
其中:
arr
:输入数组axis
:整数或整数元组,用于选择形状中单一维度条目的子集
例子
import numpy as np
x = np.arange(9).reshape(1,3,3)
print '数组 x:'
print x
print '\n'
y = np.squeeze(x)
print '数组 y:'
print y
print '\n'
print '数组 x 和 y 的形状:'
print x.shape, y.shape
输出如下:
数组 x:
[[[0 1 2]
[3 4 5]
[6 7 8]]]
数组 y:
[[0 1 2]
[3 4 5]
[6 7 8]]
数组 x 和 y 的形状:
(1, 3, 3) (3, 3)
数组的连接
序号 | 数组及描述 |
---|---|
1. | concatenate 沿着现存的轴连接数据序列 |
2. | stack 沿着新轴连接数组序列 |
3. | hstack 水平堆叠序列中的数组(列方向) |
4. | vstack 竖直堆叠序列中的数组(行方向) |
numpy.concatenate
数组的连接是指连接。 此函数用于沿指定轴连接相同形状的两个或多个数组。 该函数接受以下参数。
numpy.concatenate((a1, a2, ...), axis)
其中:
a1, a2, ...
:相同类型的数组序列axis
:沿着它连接数组的轴,默认为 0
例子
import numpy as np
a = np.array([[1,2],[3,4]])
print '第一个数组:'
print a
print '\n'
b = np.array([[5,6],[7,8]])
print '第二个数组:'
print b
print '\n'
# 两个数组的维度相同
print '沿轴 0 连接两个数组:'
print np.concatenate((a,b))
print '\n'
print '沿轴 1 连接两个数组:'
print np.concatenate((a,b),axis = 1)
输出如下:
第一个数组:
[[1 2]
[3 4]]
第二个数组:
[[5 6]
[7 8]]
沿轴 0 连接两个数组:
[[1 2]
[3 4]
[5 6]
[7 8]]
沿轴 1 连接两个数组:
[[1 2 5 6]
[3 4 7 8]]
numpy.stack
此函数沿新轴连接数组序列。 此功能添加自 NumPy 版本 1.10.0。 需要提供以下参数。
numpy.stack(arrays, axis)
其中:
arrays
:相同形状的数组序列axis
:返回数组中的轴,输入数组沿着它来堆叠
import numpy as np
a = np.array([[1,2],[3,4]])
print '第一个数组:'
print a
print '\n'
b = np.array([[5,6],[7,8]])
print '第二个数组:'
print b
print '\n'
print '沿轴 0 堆叠两个数组:'
print np.stack((a,b),0)
print '\n'
print '沿轴 1 堆叠两个数组:'
print np.stack((a,b),1)
输出如下:
第一个数组:
[[1 2]
[3 4]]
第二个数组:
[[5 6]
[7 8]]
沿轴 0 堆叠两个数组:
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
沿轴 1 堆叠两个数组:
[[[1 2]
[5 6]]
[[3 4]
[7 8]]]
numpy.hstack
numpy.stack
函数的变体,通过堆叠来生成水平的单个数组。
例子
import numpy as np
a = np.array([[1,2],[3,4]])
print '第一个数组:'
print a
print '\n'
b = np.array([[5,6],[7,8]])
print '第二个数组:'
print b
print '\n'
print '水平堆叠:'
c = np.hstack((a,b))
print c
print '\n'
输出如下:
第一个数组:
[[1 2]
[3 4]]
第二个数组:
[[5 6]
[7 8]]
水平堆叠:
[[1 2 5 6]
[3 4 7 8]]
numpy.vstack
numpy.stack
函数的变体,通过堆叠来生成竖直的单个数组。
import numpy as np
a = np.array([[1,2],[3,4]])
print '第一个数组:'
print a
print '\n'
b = np.array([[5,6],[7,8]])
print '第二个数组:'
print b
print '\n'
print '竖直堆叠:'
c = np.vstack((a,b))
print c
输出如下:
第一个数组:
[[1 2]
[3 4]]
第二个数组:
[[5 6]
[7 8]]
竖直堆叠:
[[1 2]
[3 4]
[5 6]
[7 8]]
数组分割
序号 | 数组及操作 |
---|---|
1. | split 将一个数组分割为多个子数组 |
2. | hsplit 将一个数组水平分割为多个子数组(按列) |
3. | vsplit 将一个数组竖直分割为多个子数组(按行) |
numpy.split
该函数沿特定的轴将数组分割为子数组。函数接受三个参数:
numpy.split(ary, indices_or_sections, axis)
其中:
ary
:被分割的输入数组indices_or_sections
:可以是整数,表明要从输入数组创建的,等大小的子数组的数量。 如果此参数是一维数组,则其元素表明要创建新子数组的点。axis
:默认为 0
例子
import numpy as np
a = np.arange(9)
print '第一个数组:'
print a
print '\n'
print '将数组分为三个大小相等的子数组:'
b = np.split(a,3)
print b
print '\n'
print '将数组在一维数组中表明的位置分割:'
b = np.split(a,[4,7])
print b
输出如下:
第一个数组:
[0 1 2 3 4 5 6 7 8]
将数组分为三个大小相等的子数组:
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
将数组在一维数组中表明的位置分割:
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
numpy.hsplit
numpy.hsplit
是split()
函数的特例,其中轴为 1 表示水平分割,无论输入数组的维度是什么。
import numpy as np
a = np.arange(16).reshape(4,4)
print '第一个数组:'
print a
print '\n'
print '水平分割:'
b = np.hsplit(a,2)
print b
print '\n'
输出:
第一个数组:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
水平分割:
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
numpy.vsplit
numpy.vsplit
是split()
函数的特例,其中轴为 0 表示竖直分割,无论输入数组的维度是什么。下面的例子使之更清楚。
import numpy as np
a = np.arange(16).reshape(4,4)
print '第一个数组:'
print a
print '\n'
print '竖直分割:'
b = np.vsplit(a,2)
print b
输出如下:
第一个数组:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
竖直分割:
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
添加/删除元素
序号 | 元素及描述 |
---|---|
1. | resize 返回指定形状的新数组 |
2. | append 将值添加到数组末尾 |
3. | insert 沿指定轴将值插入到指定下标之前 |
4. | delete 返回删掉某个轴的子数组的新数组 |
5. | unique 寻找数组内的唯一元素 |
numpy.resize
此函数返回指定大小的新数组。 如果新大小大于原始大小,则包含原始数组中的元素的重复副本。 该函数接受以下参数。
numpy.resize(arr, shape)
其中:
arr
:要修改大小的输入数组shape
:返回数组的新形状
例子
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print '第一个数组:'
print a
print '\n'
print '第一个数组的形状:'
print a.shape
print '\n'
b = np.resize(a, (3,2))
print '第二个数组:'
print b
print '\n'
print '第二个数组的形状:'
print b.shape
print '\n'
# 要注意 a 的第一行在 b 中重复出现,因为尺寸变大了
print '修改第二个数组的大小:'
b = np.resize(a,(3,3))
print b
输出如下:
第一个数组:
[[1 2 3]
[4 5 6]]
第一个数组的形状:
(2, 3)
第二个数组:
[[1 2]
[3 4]
[5 6]]
第二个数组的形状:
(3, 2)
修改第二个数组的大小:
[[1 2 3]
[4 5 6]
[1 2 3]]
numpy.append
此函数在输入数组的末尾添加值。 附加操作不是原地的,而是分配新的数组。 此外,输入数组的维度必须匹配否则将生成ValueError
。
函数接受下列函数:
numpy.append(arr, values, axis)
其中:
arr
:输入数组values
:要向arr
添加的值,比如和arr
形状相同(除了要添加的轴)axis
:沿着它完成操作的轴。如果没有提供,两个参数都会被展开。
例子
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print '第一个数组:'
print a
print '\n'
print '向数组添加元素:'
print np.append(a, [7,8,9])
print '\n'
print '沿轴 0 添加元素:'
print np.append(a, [[7,8,9]],axis = 0)
print '\n'
print '沿轴 1 添加元素:'
print np.append(a, [[5,5,5],[7,8,9]],axis = 1)
输出如下:
第一个数组:
[[1 2 3]
[4 5 6]]
向数组添加元素:
[1 2 3 4 5 6 7 8 9]
沿轴 0 添加元素:
[[1 2 3]
[4 5 6]
[7 8 9]]
沿轴 1 添加元素:
[[1 2 3 5 5 5]
[4 5 6 7 8 9]]
numpy.insert
此函数在给定索引之前,沿给定轴在输入数组中插入值。 如果值的类型转换为要插入,则它与输入数组不同。 插入没有原地的,函数会返回一个新数组。 此外,如果未提供轴,则输入数组会被展开。
insert()
函数接受以下参数:
numpy.insert(arr, obj, values, axis)
其中:
arr
:输入数组obj
:在其之前插入值的索引values
:要插入的值axis
:沿着它插入的轴,如果未提供,则输入数组会被展开
例子
import numpy as np
a = np.array([[1,2],[3,4],[5,6]])
print '第一个数组:'
print a
print '\n'
print '未传递 Axis 参数。 在插入之前输入数组会被展开。'
print np.insert(a,3,[11,12])
print '\n'
print '传递了 Axis 参数。 会广播值数组来配输入数组。'
print '沿轴 0 广播:'
print np.insert(a,1,[11],axis = 0)
print '\n'
print '沿轴 1 广播:'
print np.insert(a,1,11,axis = 1)
numpy.delete
此函数返回从输入数组中删除指定子数组的新数组。 与insert()
函数的情况一样,如果未提供轴参数,则输入数组将展开。 该函数接受以下参数:
Numpy.delete(arr, obj, axis)
其中:
arr
:输入数组obj
:可以被切片,整数或者整数数组,表明要从输入数组删除的子数组axis
:沿着它删除给定子数组的轴,如果未提供,则输入数组会被展开
例子
import numpy as np
a = np.arange(12).reshape(3,4)
print '第一个数组:'
print a
print '\n'
print '未传递 Axis 参数。 在插入之前输入数组会被展开。'
print np.delete(a,5)
print '\n'
print '删除第二列:'
print np.delete(a,1,axis = 1)
print '\n'
print '包含从数组中删除的替代值的切片:'
a = np.array([1,2,3,4,5,6,7,8,9,10])
print np.delete(a, np.s_[::2])
输出如下:
第一个数组:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0 1 2 3 4 6 7 8 9 10 11]
删除第二列:
[[ 0 2 3]
[ 4 6 7]
[ 8 10 11]]
包含从数组中删除的替代值的切片:
[ 2 4 6 8 10]
numpy.unique
此函数返回输入数组中的去重元素数组。 该函数能够返回一个元组,包含去重数组和相关索引的数组。 索引的性质取决于函数调用中返回参数的类型。
numpy.unique(arr, return_index, return_inverse, return_counts)
其中:
arr
:输入数组,如果不是一维数组则会展开return_index
:如果为true
,返回输入数组中的元素下标return_inverse
:如果为true
,返回去重数组的下标,它可以用于重构输入数组return_counts
:如果为true
,返回去重数组中的元素在原数组中的出现次数
例子
import numpy as np
a = np.array([5,2,6,2,7,5,6,8,2,9])
print '第一个数组:'
print a
print '\n'
print '第一个数组的去重值:'
u = np.unique(a)
print u
print '\n'
print '去重数组的索引数组:'
u,indices = np.unique(a, return_index = True)
print indices
print '\n'
print '我们可以看到每个和原数组下标对应的数值:'
print a
print '\n'
print '去重数组的下标:'
u,indices = np.unique(a,return_inverse = True)
print u
print '\n'
print '下标为:'
print indices
print '\n'
print '使用下标重构原数组:'
print u[indices]
print '\n'
print '返回去重元素的重复数量:'
u,indices = np.unique(a,return_counts = True)
print u
print indices
输出如下:
第一个数组:
[5 2 6 2 7 5 6 8 2 9]
第一个数组的去重值:
[2 5 6 7 8 9]
去重数组的索引数组:
[1 0 2 4 7 9]
我们可以看到每个和原数组下标对应的数值:
[5 2 6 2 7 5 6 8 2 9]
去重数组的下标:
[2 5 6 7 8 9]
下标为:
[1 0 2 0 3 1 2 4 0 5]
使用下标重构原数组:
[5 2 6 2 7 5 6 8 2 9]
返回唯一元素的重复数量:
[2 5 6 7 8 9]
[3 2 2 1 1 1]
NumPy - 位操作
下面是 NumPy 包中可用的位操作函数。
序号 | 操作及描述 |
---|---|
1. | bitwise_and 对数组元素执行位与操作 |
2. | bitwise_or 对数组元素执行位或操作 |
3. | invert 计算位非 |
4. | left_shift 向左移动二进制表示的位 |
5. | right_shift 向右移动二进制表示的位 |
6. | bitwise_xor 对数组元素执行位或操作 |
bitwise_and
通过np.bitwise_and()
函数对输入数组中的整数的二进制表示的相应位执行位与运算。
例子
import numpy as np
print '13 和 17 的二进制形式:'
a,b = 13,17
print bin(a), bin(b)
print '\n'
print '13 和 17 的位与:'
print np.bitwise_and(13, 17)
输出如下:
13 和 17 的二进制形式:
0b1101 0b10001
13 和 17 的位与:
1
你可以使用下表验证此输出。 考虑下面的位与真值表。
A | B | AND |
---|---|---|
1 | 1 | 1 |
1 | 0 | 0 |
0 | 1 | 0 |
0 | 0 | 0 |
bitwise_or
通过np.bitwise_or()
函数对输入数组中的整数的二进制表示的相应位执行位或运算。
例子
import numpy as np
a,b = 13,17
print '13 和 17 的二进制形式:'
print bin(a), bin(b)
print '13 和 17 的位或:'
print np.bitwise_or(13, 17)
输出如下:
13 和 17 的二进制形式:
0b1101 0b10001
13 和 17 的位或:
29
你可以使用下表验证此输出。 考虑下面的位或真值表。
A | B | OR |
---|---|---|
1 | 1 | 1 |
1 | 0 | 1 |
0 | 1 | 1 |
0 | 0 | 0 |
| | | 1 | 1 | 0 | 1 |
| — | — |
| OR |
| | 1 | 0 | 0 | 0 | 1 |
| result | 1 | 1 | 1 | 0 | 1 |
invert
此函数计算输入数组中整数的位非结果。 对于有符号整数,返回补码。
例子
import numpy as np
print '13 的位反转,其中 ndarray 的 dtype 是 uint8:'
print np.invert(np.array([13], dtype = np.uint8))
print '\n'
# 比较 13 和 242 的二进制表示,我们发现了位的反转
print '13 的二进制表示:'
print np.binary_repr(13, width = 8)
print '\n'
print '242 的二进制表示:'
print np.binary_repr(242, width = 8)
输出如下:
13 的位反转,其中 ndarray 的 dtype 是 uint8:
[242]
13 的二进制表示:
00001101
242 的二进制表示:
11110010
请注意,np.binary_repr()
函数返回给定宽度中十进制数的二进制表示。
left_shift
numpy.left shift()
函数将数组元素的二进制表示中的位向左移动到指定位置,右侧附加相等数量的 0。
例如,
import numpy as np
print '将 10 左移两位:'
print np.left_shift(10,2)
print '\n'
print '10 的二进制表示:'
print np.binary_repr(10, width = 8)
print '\n'
print '40 的二进制表示:'
print np.binary_repr(40, width = 8)
# '00001010' 中的两位移动到了左边,并在右边添加了两个 0。
输出如下:
将 10 左移两位:
40
10 的二进制表示:
00001010
40 的二进制表示:
00101000
right_shift
numpy.right_shift()
函数将数组元素的二进制表示中的位向右移动到指定位置,左侧附加相等数量的 0。
import numpy as np
print '将 40 右移两位:'
print np.right_shift(40,2)
print '\n'
print '40 的二进制表示:'
print np.binary_repr(40, width = 8)
print '\n'
print '10 的二进制表示:'
print np.binary_repr(10, width = 8)
# '00001010' 中的两位移动到了右边,并在左边添加了两个 0。
输出如下:
将 40 右移两位:
10
40 的二进制表示:
00101000
10 的二进制表示:
00001010
NumPy - 字符串函数
以下函数用于对dtype
为numpy.string_
或numpy.unicode_
的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。
序号 | 函数及描述 |
---|---|
1. | add() 返回两个str 或Unicode 数组的逐个字符串连接 |
2. | multiply() 返回按元素多重连接后的字符串 |
3. | center() 返回给定字符串的副本,其中元素位于特定字符串的中央 |
4. | capitalize() 返回给定字符串的副本,其中只有第一个字符串大写 |
5. | title() 返回字符串或 Unicode 的按元素标题转换版本 |
6. | lower() 返回一个数组,其元素转换为小写 |
7. | upper() 返回一个数组,其元素转换为大写 |
8. | split() 返回字符串中的单词列表,并使用分隔符来分割 |
9. | splitlines() 返回元素中的行列表,以换行符分割 |
10. | strip() 返回数组副本,其中元素移除了开头或者结尾处的特定字符 |
11. | join() 返回一个字符串,它是序列中字符串的连接 |
12. | replace() 返回字符串的副本,其中所有子字符串的出现位置都被新字符串取代 |
13. | decode() 按元素调用str.decode |
14. | encode() 按元素调用str.encode |
这些函数在字符数组类(numpy.char
)中定义。 较旧的 Numarray 包包含chararray
类。 numpy.char
类中的上述函数在执行向量化字符串操作时非常有用。
numpy.char.add()
函数执行按元素的字符串连接。
import numpy as np
print '连接两个字符串:'
print np.char.add(['hello'],[' xyz'])
print '\n'
print '连接示例:'
print np.char.add(['hello', 'hi'],[' abc', ' xyz'])
输出如下:
连接两个字符串:
['hello xyz']
连接示例:
['hello abc' 'hi xyz']
numpy.char.multiply()
这个函数执行多重连接。
import numpy as np
print np.char.multiply('Hello ',3)
输出如下:
Hello Hello Hello
## `numpy.char.center()`
此函数返回所需宽度的数组,以便输入字符串位于中心,并使用`fillchar`在左侧和右侧进行填充。
import numpy as np
np.char.center(arr, width,fillchar)
print np.char.center('hello', 20,fillchar = '*')
输出如下:
*******hello********
numpy.char.capitalize()
函数返回字符串的副本,其中第一个字母大写
import numpy as np
print np.char.capitalize('hello world')
输出如下:
Hello world
numpy.char.title()
返回输入字符串的按元素标题转换版本,其中每个单词的首字母都大写。
import numpy as np
print np.char.title('hello how are you?')
输出如下:
Hello How Are You?
numpy.char.lower()
函数返回一个数组,其元素转换为小写。它对每个元素调用str.lower
。
import numpy as np
print np.char.lower(['HELLO','WORLD'])
print np.char.lower('HELLO')
输出如下:
['hello' 'world']
hello
numpy.char.upper()
函数返回一个数组,其元素转换为大写。它对每个元素调用str.upper
。
import numpy as np
print np.char.upper('hello')
print np.char.upper(['hello','world'])
输出如下:
HELLO
['HELLO' 'WORLD']
numpy.char.split()
此函数返回输入字符串中的单词列表。 默认情况下,空格用作分隔符。 否则,指定的分隔符字符用于分割字符串。
import numpy as np
print np.char.split ('hello how are you?')
print np.char.split ('TutorialsPoint,Hyderabad,Telangana', sep = ',')
输出如下:
['hello', 'how', 'are', 'you?']
['TutorialsPoint', 'Hyderabad', 'Telangana']
numpy.char.splitlines()
函数返回数组中元素的单词列表,以换行符分割。
import numpy as np
print np.char.splitlines('hello\nhow are you?')
print np.char.splitlines('hello\rhow are you?')
输出如下:
['hello', 'how are you?']
['hello', 'how are you?']
'\n'
,'\r'
,'\r\n'
都会用作换行符。
numpy.char.strip()
函数返回数组的副本,其中元素移除了开头或结尾处的特定字符。
import numpy as np
print np.char.strip('ashok arora','a')
print np.char.strip(['arora','admin','java'],'a')
输出如下:
shok aror
['ror' 'dmin' 'jav']
numpy.char.join()
这个函数返回一个字符串,其中单个字符由特定的分隔符连接。
import numpy as np
print np.char.join(':','dmy')
print np.char.join([':','-'],['dmy','ymd'])
输出如下:
d:m:y
['d:m:y' 'y-m-d']
numpy.char.replace()
这个函数返回字符串副本,其中所有字符序列的出现位置都被另一个给定的字符序列取代。
import numpy as np
print np.char.replace ('He is a good boy', 'is', 'was')
输出如下:
He was a good boy
numpy.char.decode()
这个函数在给定的字符串中使用特定编码调用str.decode()
。
import numpy as np
a = np.char.encode('hello', 'cp500')
print a
print np.char.decode(a,'cp500')
输出如下:
\x88\x85\x93\x93\x96
hello
numpy.char.encode()
此函数对数组中的每个元素调用str.encode
函数。 默认编码是utf_8
,可以使用标准 Python 库中的编解码器。
import numpy as np
a = np.char.encode('hello', 'cp500')
print a
输出如下:
\x88\x85\x93\x93\x96
NumPy - 算数函数
很容易理解的是,NumPy 包含大量的各种数学运算功能。 NumPy 提供标准的三角函数,算术运算的函数,复数处理函数等。
三角函数
NumPy 拥有标准的三角函数,它为弧度制单位的给定角度返回三角函数比值。
示例
import numpy as np
a = np.array([0,30,45,60,90])
print '不同角度的正弦值:'
# 通过乘 pi/180 转化为弧度
print np.sin(a*np.pi/180)
print '\n'
print '数组中角度的余弦值:'
print np.cos(a*np.pi/180)
print '\n'
print '数组中角度的正切值:'
print np.tan(a*np.pi/180)
输出如下:
不同角度的正弦值:
[ 0. 0.5 0.70710678 0.8660254 1. ]
数组中角度的余弦值:
[ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
数组中角度的正切值:
[ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
arcsin
,arccos
,和arctan
函数返回给定角度的sin
,cos
和tan
的反三角函数。 这些函数的结果可以通过numpy.degrees()
函数通过将弧度制转换为角度制来验证。
示例
import numpy as np
a = np.array([0,30,45,60,90])
print '含有正弦值的数组:'
sin = np.sin(a*np.pi/180)
print sin
print '\n'
print '计算角度的反正弦,返回值以弧度为单位:'
inv = np.arcsin(sin)
print inv
print '\n'
print '通过转化为角度制来检查结果:'
print np.degrees(inv)
print '\n'
print 'arccos 和 arctan 函数行为类似:'
cos = np.cos(a*np.pi/180)
print cos
print '\n'
print '反余弦:'
inv = np.arccos(cos)
print inv
print '\n'
print '角度制单位:'
print np.degrees(inv)
print '\n'
print 'tan 函数:'
tan = np.tan(a*np.pi/180)
print tan
print '\n'
print '反正切:'
inv = np.arctan(tan)
print inv
print '\n'
print '角度制单位:'
print np.degrees(inv)
输出如下:
含有正弦值的数组:
[ 0. 0.5 0.70710678 0.8660254 1. ]
计算角度的反正弦,返回值以弧度制为单位:
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
通过转化为角度制来检查结果:
[ 0. 30. 45. 60. 90.]
arccos 和 arctan 函数行为类似:
[ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
反余弦:
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
角度制单位:
[ 0. 30. 45. 60. 90.]
tan 函数:
[ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
反正切:
[ 0. 0.52359878 0.78539816 1.04719755 1.57079633]
角度制单位:
[ 0. 30. 45. 60. 90.]
舍入函数
numpy.around()
这个函数返回四舍五入到所需精度的值。 该函数接受以下参数。
numpy.around(a,decimals)
其中:
序号 | 参数及描述 |
---|---|
1. | a 输入数组 |
2. | decimals 要舍入的小数位数。 默认值为0。 如果为负,整数将四舍五入到小数点左侧的位置 |
示例
import numpy as np
a = np.array([1.0,5.55, 123, 0.567, 25.532])
print '原数组:'
print a
print '\n'
print '舍入后:'
print np.around(a)
print np.around(a, decimals = 1)
print np.around(a, decimals = -1)
输出如下:
原数组:
[ 1. 5.55 123. 0.567 25.532]
舍入后:
[ 1. 6. 123. 1. 26. ]
[ 1. 5.6 123. 0.6 25.5]
[ 0. 10. 120. 0. 30. ]
numpy.floor()
此函数返回不大于输入参数的最大整数。 即标量x
的下限是最大的整数i
,使得i <= x
。 注意在Python中,向下取整总是从 0 舍入。
示例
import numpy as np
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print '提供的数组:'
print a
print '\n'
print '修改后的数组:'
print np.floor(a)
输出如下:
提供的数组:
[ -1.7 1.5 -0.2 0.6 10. ]
修改后的数组:
[ -2. 1. -1. 0. 10.]
numpy.ceil()
ceil()
函数返回输入值的上限,即,标量x
的上限是最小的整数i
,使得 i> = x
。
示例
import numpy as np
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print '提供的数组:'
print a
print '\n'
print '修改后的数组:'
print np.ceil(a)
输出如下:
提供的数组:
[ -1.7 1.5 -0.2 0.6 10. ]
修改后的数组:
[ -1. 2. -0. 1. 10.]
NumPy - 算数运算
用于执行算术运算(如add()
,subtract()
,multiply()
和divide()
)的输入数组必须具有相同的形状或符合数组广播规则。
示例
import numpy as np
a = np.arange(9, dtype = np.float_).reshape(3,3)
print '第一个数组:'
print a
print '\n'
print '第二个数组:'
b = np.array([10,10,10])
print b
print '\n'
print '两个数组相加:'
print np.add(a,b)
print '\n'
print '两个数组相减:'
print np.subtract(a,b)
print '\n'
print '两个数组相乘:'
print np.multiply(a,b)
print '\n'
print '两个数组相除:'
print np.divide(a,b)
输出如下:
第一个数组:
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
第二个数组:
[10 10 10]
两个数组相加:
[[ 10. 11. 12.]
[ 13. 14. 15.]
[ 16. 17. 18.]]
两个数组相减:
[[-10. -9. -8.]
[ -7. -6. -5.]
[ -4. -3. -2.]]
两个数组相乘:
[[ 0. 10. 20.]
[ 30. 40. 50.]
[ 60. 70. 80.]]
两个数组相除:
[[ 0. 0.1 0.2]
[ 0.3 0.4 0.5]
[ 0.6 0.7 0.8]]
让我们现在来讨论 NumPy 中提供的一些其他重要的算术函数。
numpy.reciprocal()
此函数返回参数逐元素的倒数,。 由于 Python 处理整数除法的方式,对于绝对值大于 1 的整数元素,结果始终为 0, 对于整数 0,则发出溢出警告。
示例
import numpy as np
a = np.array([0.25, 1.33, 1, 0, 100])
print '我们的数组是:'
print a
print '\n'
print '调用 reciprocal 函数:'
print np.reciprocal(a)
print '\n'
b = np.array([100], dtype = int)
print '第二个数组:'
print b
print '\n'
print '调用 reciprocal 函数:'
print np.reciprocal(b)
输出如下:
我们的数组是:
[ 0.25 1.33 1. 0. 100. ]
调用 reciprocal 函数:
main.py:9: RuntimeWarning: divide by zero encountered in reciprocal
print np.reciprocal(a)
[ 4. 0.7518797 1. inf 0.01 ]
第二个数组:
[100]
调用 reciprocal 函数:
[0]
numpy.power()
此函数将第一个输入数组中的元素作为底数,计算它与第二个输入数组中相应元素的幂。
import numpy as np
a = np.array([10,100,1000])
print '我们的数组是;'
print a
print '\n'
print '调用 power 函数:'
print np.power(a,2)
print '\n'
print '第二个数组:'
b = np.array([1,2,3])
print b
print '\n'
print '再次调用 power 函数:'
print np.power(a,b)
输出如下:
我们的数组是;
[ 10 100 1000]
调用 power 函数:
[ 100 10000 1000000]
第二个数组:
[1 2 3]
再次调用 power 函数:
[ 10 10000 1000000000]
numpy.mod()
此函数返回输入数组中相应元素的除法余数。 函数numpy.remainder()
也产生相同的结果。
import numpy as np
a = np.array([10,20,30])
b = np.array([3,5,7])
print '第一个数组:'
print a
print '\n'
print '第二个数组:'
print b
print '\n'
print '调用 mod() 函数:'
print np.mod(a,b)
print '\n'
print '调用 remainder() 函数:'
print np.remainder(a,b)
输出如下:
第一个数组:
[10 20 30]
第二个数组:
[3 5 7]
调用 mod() 函数:
[1 0 2]
调用 remainder() 函数:
[1 0 2]
以下函数用于对含有复数的数组执行操作。
-
numpy.real()
返回复数类型参数的实部。 -
numpy.imag()
返回复数类型参数的虚部。 -
numpy.conj()
返回通过改变虚部的符号而获得的共轭复数。 -
numpy.angle()
返回复数参数的角度。 函数的参数是degree
。 如果为true
,返回的角度以角度制来表示,否则为以弧度制来表示。
import numpy as np
a = np.array([-5.6j, 0.2j, 11. , 1+1j])
print '我们的数组是:'
print a
print '\n'
print '调用 real() 函数:'
print np.real(a)
print '\n'
print '调用 imag() 函数:'
print np.imag(a)
print '\n'
print '调用 conj() 函数:'
print np.conj(a)
print '\n'
print '调用 angle() 函数:'
print np.angle(a)
print '\n'
print '再次调用 angle() 函数(以角度制返回):'
print np.angle(a, deg = True)
输出如下:
我们的数组是:
[ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]
调用 real() 函数:
[ 0. 0. 11. 1.]
调用 imag() 函数:
[-5.6 0.2 0. 1. ]
调用 conj() 函数:
[ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]
调用 angle() 函数:
[-1.57079633 1.57079633 0. 0.78539816]
再次调用 angle() 函数(以角度制返回):
[-90. 90. 0. 45.]