NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。
Numeric,即 NumPy 的前身,是由 Jim Hugunin 开发的。 也开发了另一个包 Numarray ,它拥有一些额外的功能。 2005年,Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 这个开源项目有很多贡献者。
使用NumPy,开发人员可以执行以下操作:
NumPy 通常与 SciPy(Scientific Python)和 Matplotlib(绘图库)一起使用。 这种组合广泛用于替代 MatLab,是一个流行的技术计算平台。 但是,Python 作为 MatLab 的替代方案,现在被视为一种更加现代和完整的编程语言。
NumPy 是开源的,这是它的一个额外的优势。
NumPy 中定义的最重要的对象是称为 ndarray
的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目。
ndarray
中的每个元素在内存中使用相同大小的块。 ndarray
中的每个元素是数据类型对象的对象(称为 dtype
)。
从ndarray
对象提取的任何元素(通过切片)由一个数组标量类型的 Python 对象表示。 下图显示了ndarray
,数据类型对象(dtype
)和数组标量类型之间的关系。
Ndarray
ndarray
类的实例可以通过本教程后面描述的不同的数组创建例程来构造。 基本的ndarray
是使用 NumPy 中的数组函数创建的,如下所示:
numpy.
array
它从任何暴露数组接口的对象,或从返回数组的任何方法创建一个ndarray。
numpy.array(object, dtype =
None, copy =
True, order =
None, subok =
False, ndmin =
0)
上面的构造器接受以下参数:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
5. |
|
6. |
|
看看下面的例子来更好地理解。
import numpy
as np
a = np.
array([
1,
2,
3])
a
输出如下:
import numpy
as np
a = np.
array([[
1,
2], [
3,
4]])
a
输出如下:
import numpy
as np
a = np.
array([
1,
2,
3,
4,
5], ndmin =
2)
a
输出如下:
numpy as np
a = np.
array([
1,
2,
3], dtype =
complex)
print a
输出如下:
**ndarray ** 对象由计算机内存中的一维连续区域组成,带有将每个元素映射到内存块中某个位置的索引方案。 内存块以按行(C 风格)或按列(FORTRAN 或 MatLab 风格)的方式保存元素。
NumPy 支持比 Python 更多种类的数值类型。 下表显示了 NumPy 中定义的不同标量数据类型。
序号 |
数据类型及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
5. |
|
6. |
|
7. |
|
8. |
|
9. |
|
10. |
|
11. |
|
12. |
|
13. |
|
14. |
|
15. |
|
16. |
|
17. |
|
18. |
|
19. |
|
NumPy 数字类型是dtype
(数据类型)对象的实例,每个对象具有唯一的特征。 这些类型可以是np.bool_
,np.float32
等。
dtype
)数据类型对象描述了对应于数组的固定内存块的解释,取决于以下方面:
字节顺序取决于数据类型的前缀<
或>
。 <
意味着编码是小端(最小有效字节存储在最小地址中)。 >
意味着编码是大端(最大有效字节存储在最小地址中)。
dtype
可由一下语法构造:
参数为:
Object
:被转换为数据类型的对象。Align
:如果为true
,则向字段添加间隔,使其类似 C 的结构体。Copy
? 生成dtype
对象的新副本,如果为flase
,结果是内建数据类型对象的引用。 numpy
as np
dt = np.dtype(np.int32)
dt
输出如下:
numpy
as np
dt = np.dtype(
'i4')
dt
输出如下:
numpy
as np
dt = np.dtype(
'>i4')
dt
输出如下:
下面的例子展示了结构化数据类型的使用。 这里声明了字段名称和相应的标量数据类型。
numpy
as np
dt = np.dtype([(
'age',np.int8)])
dt
输出如下:
import numpy
as np
dt = np.dtype([(
'age',np.int8)])
a = np.
array([(
10,),(
20,),(
30,)], dtype = dt)
a
输出如下:
import numpy
as np
dt = np.dtype([(
'age',np.int8)])
a = np.
array([(
10,),(
20,),(
30,)], dtype = dt)
a[
'age']
输出如下:
以下示例定义名为 student 的结构化数据类型,其中包含字符串字段name
,整数字段age
和浮点字段marks
。 此dtype
应用于ndarray
对象。
numpy
as np
student = np.dtype([(
'name',
'S20'), (
'age',
'i1'), (
'marks',
'f4')])
student
输出如下:
import numpy
as np
student = np.dtype([(
'name',
'S20'), (
'age',
'i1'), (
'marks',
'f4')])
a = np.
array([(
'abc',
21,
50),(
'xyz',
18,
75)], dtype = student)
a
输出如下:
每个内建类型都有一个唯一定义它的字符代码:
'b'
:布尔值'i'
:符号整数'u'
:无符号整数'f'
:浮点'c'
:复数浮点'm'
:时间间隔'M'
:日期时间'O'
:Python 对象'S', 'a'
:字节串'U'
:Unicode'V'
:原始数据(void
)这一章中,我们会讨论 NumPy 的多种数组属性。
ndarray.shape
这一数组属性返回一个包含数组维度的元组,它也可以用于调整数组大小。
import numpy
as np
a = np.
array([[
1,
2,
3],[
4,
5,
6]])
a.shape
输出如下:
import numpy
as np
a = np.
array([[
1,
2,
3],[
4,
5,
6]]) a.shape = (
3,
2)
a
输出如下:
NumPy 也提供了reshape
函数来调整数组大小。
import numpy
as np
a = np.
array([[
1,
2,
3],[
4,
5,
6]])
b = a.reshape(
3,
2)
b
输出如下:
ndarray.ndim
这一数组属性返回数组的维数。
numpy
as np
a = np.arange(
24)
print a
输出如下:
numpy
as np
a = np.arange(
24) a.ndim
b = a.reshape(
2,
4,
3)
b
输出如下:
numpy.itemsize
这一数组属性返回数组中每个元素的字节单位长度。
import numpy
as np
x = np.
array([
1,
2,
3,
4,
5], dtype = np.int8)
x.itemsize
输出如下:
import numpy
as np
x = np.
array([
1,
2,
3,
4,
5], dtype = np.float32)
x.itemsize
输出如下:
numpy.flags
ndarray
对象拥有以下属性。这个函数返回了它们的当前值。
序号 |
属性及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
5. |
|
6. |
|
下面的例子展示当前的标志。
import numpy
as np
x = np.
array([
1,
2,
3,
4,
5])
x.flags
输出如下:
C_CONTIGUOUS :
True
F_CONTIGUOUS :
True
OWNDATA :
True
WRITEABLE :
True
ALIGNED :
True
UPDATEIFCOPY :
False
新的ndarray
对象可以通过任何下列数组创建例程或使用低级ndarray
构造函数构造。
numpy.empty
它创建指定形状和dtype
的未初始化数组。 它使用以下构造函数:
构造器接受下列参数:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
下面的代码展示空数组的例子:
import numpy
as np
x = np.
empty([
3,
2], dtype = int)
x
输出如下:
注意:数组元素为随机值,因为它们未初始化。
numpy.zeros
返回特定大小,以 0 填充的新数组。
构造器接受下列参数:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
numpy
as np
x = np.zeros(
5)
x
输出如下:
numpy
as np
x = np.zeros((
5,), dtype = np.int)
x
输出如下:
numpy
as np
x = np.zeros((
2,
2), dtype = [(
'x',
'i4'), (
'y',
'i4')])
x
输出如下:
numpy.ones
返回特定大小,以 1 填充的新数组。
numpy.ones(shape, dtype =
None, order =
'C')
构造器接受下列参数:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
numpy
as np
x = np.ones(
5)
print x
输出如下:
numpy
as np
x = np.ones([
2,
2], dtype = int)
x
输出如下:
这一章中,我们会讨论如何从现有数据创建数组。
numpy.asarray
此函数类似于numpy.array
,除了它有较少的参数。 这个例程对于将 Python 序列转换为ndarray
非常有用。
numpy.asarray(a, dtype =
None, order =
None)
构造器接受下列参数:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
下面的例子展示了如何使用asarray
函数:
numpy
as np
x = [
1,
2,
3]
a = np.asarray(x)
a
输出如下:
numpy
as np
x = [
1,
2,
3]
a = np.asarray(x, dtype = float)
a
输出如下:
numpy
as np
x = (
1,
2,
3)
a = np.asarray(x)
a
输出如下:
numpy
as np
x = [(
1,
2,
3),(
4,
5)]
a = np.asarray(x)
a
输出如下:
numpy.frombuffer
此函数将缓冲区解释为一维数组。 暴露缓冲区接口的任何对象都用作参数来返回ndarray
。
构造器接受下列参数:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
下面的例子展示了frombuffer
函数的用法。
numpy
as np
s =
'Hello World'
a = np.frombuffer(s, dtype =
'S1')
a
输出如下:
numpy.fromiter
此函数从任何可迭代对象构建一个ndarray
对象,返回一个新的一维数组。
构造器接受下列参数:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
以下示例展示了如何使用内置的range()
函数返回列表对象。 此列表的迭代器用于形成ndarray
对象。
import numpy
as np
= range(
5)
list输出如下:
import numpy
as np
= range(
5)
it = iter(
list)
x = np.fromiter(it, dtype = float)
x
输出如下:
这一章中,我们会学到如何从数值范围创建数组。
numpy.arange
这个函数返回ndarray
对象,包含给定范围内的等间隔值。
(
start,
stop,
step,
dtype)
构造器接受下列参数:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
下面的例子展示了如何使用该函数:
numpy
as np
x = np.arange(
5)
x
输出如下:
numpy
as np
x = np.arange(
5, dtype = float)
x
输出如下:
numpy
as np
x = np.arange(
10,
20,
2)
x
输出如下:
numpy.linspace
此函数类似于arange()
函数。 在此函数中,指定了范围之间的均匀间隔数量,而不是步长。 此函数的用法如下。
(
start,
stop,
num,
endpoint,
retstep,
dtype)
构造器接受下列参数:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
5. |
|
6. |
|
下面的例子展示了linspace
函数的用法。
numpy
as np
x = np.linspace(
10,
20,
5)
x
输出如下:
numpy
as np
x = np.linspace(
10,
20,
5, endpoint =
False)
x
输出如下:
numpy
as np
x = np.linspace(
1,
2,
5, retstep =
True)
x
输出如下:
(
array(
[ , 25, 5 , 75, 2. ]), 0
.25)
numpy.logspace
此函数返回一个ndarray
对象,其中包含在对数刻度上均匀分布的数字。 刻度的开始和结束端点是某个底数的幂,通常为 10。
(
start,
stop,
num,
endpoint,
base,
dtype)
logspace
函数的输出由以下参数决定:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
5. |
|
6. |
|
下面的例子展示了logspace
函数的用法。
numpy
as np
a = np.logspace(
1.0,
2.0, num =
10)
a
输出如下:
numpy
as np
a = np.logspace(
1,
10,num =
10, base =
2)
a
输出如下:
ndarray
对象的内容可以通过索引或切片来访问和修改,就像 Python 的内置容器对象一样。
如前所述,ndarray
对象中的元素遵循基于零的索引。 有三种可用的索引方法类型: 字段访问,基本切片和高级索引。
基本切片是 Python 中基本切片概念到 n 维的扩展。 通过将start
,stop
和step
参数提供给内置的slice
函数来构造一个 Python slice
对象。 此slice
对象被传递给数组来提取数组的一部分。
numpy
as np
a = np.arange(
10)
s = slice(
2,
7,
2)
a[s]
输出如下:
在上面的例子中,ndarray
对象由arange()
函数创建。 然后,分别用起始,终止和步长值2
,7
和2
定义切片对象。 当这个切片对象传递给ndarray
时,会对它的一部分进行切片,从索引2
到7
,步长为2
。
通过将由冒号分隔的切片参数(start:stop:step
)直接提供给ndarray
对象,也可以获得相同的结果。
numpy
as np
a = np.arange(
10)
b = a[
2:
7:
2]
b
输出如下:
如果只输入一个参数,则将返回与索引对应的单个项目。 如果使用a:
,则从该索引向后的所有项目将被提取。 如果使用两个参数(以:
分隔),则对两个索引(不包括停止索引)之间的元素以默认步骤进行切片。
numpy
as np
a = np.arange(
10)
b = a[
5]
b
输出如下:
numpy
as np
a = np.arange(
10)
a[
2:]
输出如下:
numpy
as np
a = np.arange(
10)
a[
2:
5]
输出如下:
上面的描述也可用于多维ndarray
。
import numpy
as np
a = np.
array([[
1,
2,
3],[
3,
4,
5],[
4,
5,
6]])
a
'现在我们从索引 a[1:] 开始对数组切片'
a[
1:]
输出如下:
[3 4 5]
[4 5 6]]
现在我们从索引
a[1:]
开始对数组切片
[4 5 6]]
切片还可以包括省略号(...
),来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号,它将返回包含行中元素的ndarray
。
import numpy
as np
a = np.
array([[
1,
2,
3],[
3,
4,
5],[
4,
5,
6]])
'我们的数组是:'
a
'\n'
'第二列的元素是:'
a[...,
1]
'\n'
'第二行的元素是:'
a[
1,...]
'\n'
'第二列及其剩余元素是:'
a[...,
1:]
输出如下:
我们的数组是:
[3 4 5]
[4 5 6]]
第二列的元素是:
第二行的元素是:
第二列及其剩余元素是:
[4 5]
[5 6]]
如果一个ndarray
是非元组序列,数据类型为整数或布尔值的ndarray
,或者至少一个元素为序列对象的元组,我们就能够用它来索引ndarray
。高级索引始终返回数据的副本。 与此相反,切片只提供了一个视图。
有两种类型的高级索引:整数和布尔值。
这种机制有助于基于 N 维索引来获取数组中任意元素。 每个整数数组表示该维度的下标值。 当索引的元素个数就是目标ndarray
的维度时,会变得相当直接。
以下示例获取了ndarray
对象中每一行指定列的一个元素。 因此,行索引包含所有行号,列索引指定要选择的元素。
import numpy
as np
x = np.
array([[
1,
2], [
3,
4], [
5,
6]])
y = x[[
0,
1,
2], [
0,
1,
0]]
y
输出如下:
该结果包括数组中(0,0)
,(1,1)
和(2,0)
位置处的元素。
下面的示例获取了 4X3 数组中的每个角处的元素。 行索引是[0,0]
和[3,3]
,而列索引是[0,2]
和[0,2]
。
import numpy
as np
x = np.
array([[
0,
1,
2],[
3,
4,
5],[
6,
7,
8],[
9,
10,
11]])
'我们的数组是:'
x
'\n'
rows = np.
array([[
0,
0],[
3,
3]])
cols = np.
array([[
0,
2],[
0,
2]])
y = x[rows,cols]
'这个数组的每个角处的元素是:'
y
输出如下:
我们的数组是:
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
这个数组的每个角处的元素是:
[ 9 11]]
返回的结果是包含每个角元素的ndarray
对象。
高级和基本索引可以通过使用切片:
或省略号...
与索引数组组合。 以下示例使用slice
作为列索引和高级索引。 当切片用于两者时,结果是相同的。 但高级索引会导致复制,并且可能有不同的内存布局。
import numpy
as np
x = np.
array([[
0,
1,
2],[
3,
4,
5],[
6,
7,
8],[
9,
10,
11]])
'我们的数组是:'
x
'\n'
z = x[
1:
4,
1:
3]
'切片之后,我们的数组变为:'
z
'\n'
y = x[
1:
4,[
1,
2]]
'对列使用高级索引来切片:'
y
输出如下:
我们的数组是:
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
切片之后,我们的数组变为:
[ 7 8]
[10 11]]
对列使用高级索引来切片:
[ 7 8]
[10 11]]
当结果对象是布尔运算(例如比较运算符)的结果时,将使用此类型的高级索引。
这个例子中,大于 5 的元素会作为布尔索引的结果返回。
import numpy
as np
x = np.
array([[
0,
1,
2],[
3,
4,
5],[
6,
7,
8],[
9,
10,
11]])
'我们的数组是:'
x
'\n'
'大于 5 的元素是:'
x[x >
5]
输出如下:
我们的数组是:
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
大于
5
的元素是:
这个例子使用了~
(取补运算符)来过滤NaN
。
import numpy
as np
a = np.
array([np.nan,
1,
2,np.nan,
3,
4,
5])
a[~np.isnan(a)]
输出如下:
以下示例显示如何从数组中过滤掉非复数元素。
import numpy
as np
a = np.
array([
1,
2+
6j,
5,
3.5+
5j])
a[np.iscomplex(a)]
输出如下:
术语广播是指 NumPy 在算术运算期间处理不同形状的数组的能力。 对数组的算术运算通常在相应的元素上进行。 如果两个阵列具有完全相同的形状,则这些操作被无缝执行。
import numpy
as np
a = np.
array([
1,
2,
3,
4])
b = np.
array([
10,
20,
30,
40])
c = a * b
c
输出如下:
如果两个数组的维数不相同,则元素到元素的操作是不可能的。 然而,在 NumPy 中仍然可以对形状不相似的数组进行操作,因为它拥有广播功能。 较小的数组会广播到较大数组的大小,以便使它们的形状可兼容。
如果满足以下规则,可以进行广播:
ndim
较小的数组会在前面追加一个长度为 1 的维度。如果上述规则产生有效结果,并且满足以下条件之一,那么数组被称为可广播的。
下面的例称展示了广播的示例。
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,
0])
'第一个数组:'
a
'\n'
'第二个数组:'
b
'\n'
'第一个数组加第二个数组:'
a + b
输出如下:
第一个数组:
[ 10. 10. 10.]
[ 20. 20. 20.]
[ 30. 30. 30.]]
第二个数组:
第一个数组加第二个数组:
[ 11. 13.]
[ 21. 22. 23.]
[ 31. 32. 33.]]
下面的图片展示了数组b
如何通过广播来与数组a
兼容。
array
NumPy 包包含一个迭代器对象numpy.nditer
。 它是一个有效的多维迭代器对象,可以用于在数组上进行迭代。 数组的每个元素可使用 Python 的标准Iterator
接口来访问。
让我们使用arange()
函数创建一个 3X4 数组,并使用nditer
对它进行迭代。
numpy
as np
a = np.arange(
0,
60,
5)
a = a.reshape(
3,
4)
'原始数组是:'
a
print
'\n'
'修改后的数组是:'
x
in np.nditer(a):
print x,
输出如下:
原始数组是:
[20 25 30 35]
[40 45 50 55]]
修改后的数组是:
0 5 10 15 20 25 30 35 40 45 50 55
迭代的顺序匹配数组的内容布局,而不考虑特定的排序。 这可以通过迭代上述数组的转置来看到。
numpy
as np
a = np.arange(
0,
60,
5)
a = a.reshape(
3,
4)
'原始数组是:'
a
'\n'
'原始数组的转置是:'
b = a.T
b
'\n'
'修改后的数组是:'
x
in np.nditer(b):
print x,
输出如下:
原始数组是:
[20 25 30 35]
[40 45 50 55]]
原始数组的转置是:
[ 5 25 45]
[10 30 50]
[15 35 55]]
修改后的数组是:
0 5 10 15 20 25 30 35 40 45 50 55
如果相同元素使用 F 风格顺序存储,则迭代器选择以更有效的方式对数组进行迭代。
numpy
as np
a = np.arange(
0,
60,
5)
a = a.reshape(
3,
4)
'原始数组是:'
a
print
'\n'
'原始数组的转置是:'
b = a.T
b
'\n'
'以 C 风格顺序排序:'
c = b.copy(order=
'C')
c
for x
in np.nditer(c):
print x,
'\n'
'以 F 风格顺序排序:'
c = b.copy(order=
'F')
c
x
in np.nditer(c):
print x,
输出如下:
原始数组是:
[20 25 30 35]
[40 45 50 55]]
原始数组的转置是:
[ 5 25 45]
[10 30 50]
[15 35 55]]
以
C
风格顺序排序:
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55
以
F
风格顺序排序:
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 5 10 15 20 25 30 35 40 45 50 55
可以通过显式提醒,来强制nditer
对象使用某种顺序:
numpy
as np
a = np.arange(
0,
60,
5)
a = a.reshape(
3,
4)
'原始数组是:'
a
'\n'
'以 C 风格顺序排序:'
x
in np.nditer(a, order =
'C'):
print x,
'\n'
'以 F 风格顺序排序:'
x
in np.nditer(a, order =
'F'):
print x,
输出如下:
原始数组是:
[20 25 30 35]
[40 45 50 55]]
以
C
风格顺序排序:
0 5 10 15 20 25 30 35 40 45 50 55
以
F
风格顺序排序:
0 20 40 5 25 45 10 30 50 15 35 55
nditer
对象有另一个可选参数op_flags
。 其默认值为只读,但可以设置为读写或只写模式。 这将允许使用此迭代器修改数组元素。
numpy
as np
a = np.arange(
0,
60,
5)
a = a.reshape(
3,
4)
'原始数组是:'
a
'\n'
x
in np.nditer(a, op_flags=[
'readwrite']):
x[...]=
2*x
'修改后的数组是:'
a
输出如下:
原始数组是:
[20 25 30 35]
[40 45 50 55]]
修改后的数组是:
[ 40 50 60 70]
[ 80 90 100 110]]
nditer
类的构造器拥有flags
参数,它可以接受下列值:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
在下面的示例中,迭代器遍历对应于每列的一维数组。
numpy
as np
a = np.arange(
0,
60,
5)
a = a.reshape(
3,
4)
'原始数组是:'
a
'\n'
'修改后的数组是:'
x
in np.nditer(a, flags = [
'external_loop'], order =
'F'):
print x,
输出如下:
原始数组是:
[20 25 30 35]
[40 45 50 55]]
修改后的数组是:
[ 5 25 45]
[10 30 50]
[15 35 55]
如果两个数组是可广播的,nditer
组合对象能够同时迭代它们。 假设数组a
具有维度 3X4,并且存在维度为 1X4 的另一个数组b
,则使用以下类型的迭代器(数组b
被广播到a
的大小)。
numpy
as np
a = np.arange(
0,
60,
5)
a = a.reshape(
3,
4)
'第一个数组:'
a
'\n'
'第二个数组:'
b = np.array([
1,
2,
3,
4], dtype = int)
b
'\n'
'修改后的数组是:'
x,y
in np.nditer([a,b]):
print
"%d:%d" % (x,y),
输出如下:
第一个数组:
[20 25 30 35]
[40 45 50 55]]
第二个数组:
修改后的数组是:
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包中有几个例程用于处理ndarray
对象中的元素。 它们可以分为以下类型:
序号 |
形状及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
numpy.reshape
这个函数在不改变数据的条件下修改形状,它接受如下参数:
numpy.reshape(arr, newshape,
order')
其中:
arr
:要修改形状的数组newshape
:整数或者整数数组,新的形状应当兼容原有形状order
:'C'
为 C 风格顺序,'F'
为 F 风格顺序,'A'
为保留原顺序。例子
numpy
as np
a = np.arange(
8)
'原始数组:' a
'\n'
b = a.reshape(
4,
2)
'修改后的数组:' b
输出如下:
原始数组:
修改后的数组:
[2 3]
[4 5]
[6 7]]
numpy.ndarray.flat
该函数返回数组上的一维迭代器,行为类似 Python 内建的迭代器。
例子
numpy
as np
a = np.arange(
8).reshape(
2,
4)
'原始数组:'
a
'\n'
'调用 flat 函数之后:'
a.flat[
5]
输出如下:
原始数组:
[4 5 6 7]]
调用
flat
函数之后:
5
numpy.ndarray.flatten
该函数返回折叠为一维的数组副本,函数接受下列参数:
(
order)
其中:
order
:'C'
-- 按行,'F'
-- 按列,'A'
-- 原顺序,'k'
-- 元素在内存中的出现顺序。例子
numpy
as np
a = np.arange(
8).reshape(
2,
4)
'原数组:'
a
'\n'
'展开的数组:'
a.flatten()
'\n'
'以 F 风格顺序展开的数组:'
a.flatten(order =
'F')
输出如下:
原数组:
[4 5 6 7]]
展开的数组:
以
F
风格顺序展开的数组:
numpy.ravel
这个函数返回展开的一维数组,并且按需生成副本。返回的数组和输入数组拥有相同数据类型。这个函数接受两个参数。
(
a,
order)
构造器接受下列参数:
order
:'C'
-- 按行,'F'
-- 按列,'A'
-- 原顺序,'k'
-- 元素在内存中的出现顺序。例子
numpy
as np
a = np.arange(
8).reshape(
2,
4)
'原数组:'
a
'\n'
'调用 ravel 函数之后:'
a.ravel()
'\n'
'以 F 风格顺序调用 ravel 函数之后:'
a.ravel(order =
'F')
原数组:
[4 5 6 7]]
调用
ravel
函数之后:
以
F
风格顺序调用
ravel
函数之后:
序号 |
操作及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
numpy.transpose
这个函数翻转给定数组的维度。如果可能的话它会返回一个视图。函数接受下列参数:
(
arr,
axes)
其中:
arr
:要转置的数组axes
:整数的列表,对应维度,通常所有维度都会翻转。例子
numpy
as np
a = np.arange(
12).reshape(
3,
4)
'原数组:'
a
'\n'
'转置数组:'
np.transpose(a)
输出如下:
原数组:
[ 4 5 6 7]
[ 8 9 10 11]]
转置数组:
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
numpy.ndarray.T
该函数属于ndarray
类,行为类似于numpy.transpose
。
例子
numpy
as np
a = np.arange(
12).reshape(
3,
4)
'原数组:'
a
'\n'
'转置数组:'
a.T
输出如下:
原数组:
[ 4 5 6 7]
[ 8 9 10 11]]
转置数组:
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
numpy.rollaxis
该函数向后滚动特定的轴,直到一个特定位置。这个函数接受三个参数:
(
arr,
axis,
start)
其中:
arr
:输入数组axis
:要向后滚动的轴,其它轴的相对位置不会改变start
:默认为零,表示完整的滚动。会滚动到特定位置。例子
numpy
as np
a = np.arange(
8).reshape(
2,
2,
2)
'原数组:'
a
'\n'
'调用 rollaxis 函数:'
np.rollaxis(a,
2)
'\n'
'调用 rollaxis 函数:'
np.rollaxis(a,
2,
1)
输出如下:
原数组:
[2 3]]
[[4 5]
[6 7]]]
调用
rollaxis
函数:
[4 6]]
[[1 3]
[5 7]]]
调用
rollaxis
函数:
[1 3]]
[[4 6]
[5 7]]]
numpy.swapaxes
该函数交换数组的两个轴。对于 1.10 之前的 NumPy 版本,会返回交换后数组的试图。这个函数接受下列参数:
(
arr,
axis1,
axis2)
arr
:要交换其轴的输入数组axis1
:对应第一个轴的整数axis2
:对应第二个轴的整数 numpy
as np
a = np.arange(
8).reshape(
2,
2,
2)
'原数组:' a
'\n'
'调用 swapaxes 函数后的数组:'
np.swapaxes(a,
2,
0)
输出如下:
原数组:
[2 3]]
[[4 5]
[6 7]]]
调用
swapaxes
函数后的数组:
[2 6]]
[[1 5]
[3 7]]]
序号 |
维度和描述 |
1. |
|
2. |
|
3. |
|
4. |
|
broadcast
如前所述,NumPy 已经内置了对广播的支持。 此功能模仿广播机制。 它返回一个对象,该对象封装了将一个数组广播到另一个数组的结果。
该函数使用两个数组作为输入参数。 下面的例子说明了它的用法。
import numpy
as np
x = np.
array([[
1], [
2], [
3]])
y = np.
array([
4,
5,
6])
b = np.broadcast(x,y)
'对 y 广播 x:'
r,c = b.iters
r.next(), c.next()
r.next(), c.next()
'\n'
'广播对象的形状:'
b.shape
'\n'
b = np.broadcast(x,y)
c = np.
empty(b.shape)
'手动使用 broadcast 将 x 与 y 相加:'
c.shape
'\n'
c.flat = [u + v
for (u,v) in b]
'调用 flat 函数:'
c
'\n'
'x 与 y 的和:'
x + y
输出如下:
对
y
广播
x:
1 4
1 5
广播对象的形状:
(3, 3)
手动使用
broadcast
将
x
与
y
相加:
(3, 3)
调用
flat
函数:
[ 6. 7. 8.]
[ 7. 8. 9.]]
与
y
的和:
[6 7 8]
[7 8 9]]
numpy.broadcast_to
此函数将数组广播到新形状。 它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则,该函数可能会抛出ValueError
。
注意 - 此功能可用于 1.10.0 及以后的版本。
该函数接受以下参数。
numpy.broadcast_to(
array, shape, subok)
例子
numpy
as np
a = np.arange(
4).reshape(
1,
4)
'原数组:'
a
'\n'
'调用 broadcast_to 函数之后:'
np.broadcast_to(a,(
4,
4))
输出如下:
numpy.expand_dims
函数通过在指定位置插入新的轴来扩展数组形状。该函数需要两个参数:
(
arr,
axis)
其中:
arr
:输入数组axis
:新轴插入的位置例子
import numpy
as np
x = np.
array(([
1,
2],[
3,
4]))
'数组 x:'
x
'\n'
y = np.expand_dims(x, axis =
0)
'数组 y:'
y
'\n'
'数组 x 和 y 的形状:'
x.shape, y.shape
'\n'
y = np.expand_dims(x, axis =
1)
'在位置 1 插入轴之后的数组 y:'
y
'\n'
'x.ndim 和 y.ndim:'
x.ndim,y.ndim
'\n'
'x.shape 和 y.shape:'
x.shape, y.shape
输出如下:
数组
x:
[3 4]]
数组
y:
[3 4]]]
数组
x
和
y
的形状:
(2, 2) (1, 2, 2)
在位置
1
插入轴之后的数组
y:
]
[[3 4]]]
和
y.shape:
2 3
and
y.shape:
(2, 2) (2, 1, 2)
numpy.squeeze
函数从给定数组的形状中删除一维条目。 此函数需要两个参数。
(
arr,
axis)
其中:
arr
:输入数组axis
:整数或整数元组,用于选择形状中单一维度条目的子集例子
numpy
as np
x = np.arange(
9).reshape(
1,
3,
3)
'数组 x:'
x
'\n'
y = np.squeeze(x)
'数组 y:'
y
'\n'
'数组 x 和 y 的形状:'
x.shape, y.shape
输出如下:
数组
x:
[3 4 5]
[6 7 8]]]
数组
y:
[3 4 5]
[6 7 8]]
数组
x
和
y
的形状:
(1, 3, 3) (3, 3)
序号 |
数组及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
numpy.concatenate
数组的连接是指连接。 此函数用于沿指定轴连接相同形状的两个或多个数组。 该函数接受以下参数。
((
a1,
a2, ...),
axis)
其中:
a1, a2, ...
:相同类型的数组序列axis
:沿着它连接数组的轴,默认为 0例子
import numpy
as np
a = np.
array([[
1,
2],[
3,
4]])
'第一个数组:'
a
'\n'
b = np.
array([[
5,
6],[
7,
8]])
'第二个数组:'
b
'\n'
'沿轴 0 连接两个数组:'
np.concatenate((a,b))
'\n'
'沿轴 1 连接两个数组:'
np.concatenate((a,b),axis =
1)
输出如下:
第一个数组:
[3 4]]
第二个数组:
[7 8]]
沿轴
0
连接两个数组:
[3 4]
[5 6]
[7 8]]
沿轴
1
连接两个数组:
[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]])
'第一个数组:'
a
'\n'b = np.
array([[
5,
6],[
7,
8]])
'第二个数组:'
b
'\n'
'沿轴 0 堆叠两个数组:'
np.stack((a,b),
0)
'\n'
'沿轴 1 堆叠两个数组:'
np.stack((a,b),
1)
输出如下:
第一个数组:
[3 4]]
第二个数组:
[7 8]]
沿轴
0
堆叠两个数组:
[3 4]]
[[5 6]
[7 8]]]
沿轴
1
堆叠两个数组:
[5 6]]
[[3 4]
[7 8]]]
numpy.hstack
numpy.stack
函数的变体,通过堆叠来生成水平的单个数组。
例子
import numpy
as np
a = np.
array([[
1,
2],[
3,
4]])
'第一个数组:'
a
'\n'
b = np.
array([[
5,
6],[
7,
8]])
'第二个数组:'
b
'\n'
'水平堆叠:'
c = np.hstack((a,b))
c
'\n'输出如下:
第一个数组:
[3 4]]
第二个数组:
[7 8]]
水平堆叠:
[3 4 7 8]]
numpy.vstack
numpy.stack
函数的变体,通过堆叠来生成竖直的单个数组。
import numpy
as np
a = np.
array([[
1,
2],[
3,
4]])
'第一个数组:'
a
'\n'
b = np.
array([[
5,
6],[
7,
8]])
'第二个数组:'
b
'\n'
'竖直堆叠:'
c = np.vstack((a,b))
c
输出如下:
第一个数组:
[3 4]]
第二个数组:
[7 8]]
竖直堆叠:
[3 4]
[5 6]
[7 8]]
序号 |
数组及操作 |
1. |
|
2. |
|
3. |
|
numpy.split
该函数沿特定的轴将数组分割为子数组。函数接受三个参数:
(
ary,
indices_or_sections,
axis)
其中:
ary
:被分割的输入数组indices_or_sections
:可以是整数,表明要从输入数组创建的,等大小的子数组的数量。 如果此参数是一维数组,则其元素表明要创建新子数组的点。axis
:默认为 0例子
numpy
as np
a = np.arange(
9)
'第一个数组:'
a
'\n'
'将数组分为三个大小相等的子数组:'
b = np.split(a,
3)
b
'\n'
'将数组在一维数组中表明的位置分割:'
b = np.split(a,[
4,
7])
b
输出如下:
第一个数组:
将数组分为三个大小相等的子数组:
),
array(
[3, 4, 5]),
array(
[6, 7, 8])]
将数组在一维数组中表明的位置分割:
),
array(
[4, 5, 6]),
array(
[7, 8])]
numpy.hsplit
numpy.hsplit
是split()
函数的特例,其中轴为 1 表示水平分割,无论输入数组的维度是什么。
numpy
as np
a = np.arange(
16).reshape(
4,
4)
'第一个数组:'
a
'\n'
'水平分割:'
b = np.hsplit(a,
2)
b
'\n'输出:
第一个数组:
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
水平分割:
,
[ 4, 5],
[ 8, 9],
[12, 13]]),
array(
[[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
numpy.vsplit
numpy.vsplit
是split()
函数的特例,其中轴为 0 表示竖直分割,无论输入数组的维度是什么。下面的例子使之更清楚。
numpy
as np
a = np.arange(
16).reshape(
4,
4)
'第一个数组:'
a
'\n'
'竖直分割:'
b = np.vsplit(a,
2)
b
输出如下:
第一个数组:
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
竖直分割:
,
[4, 5, 6, 7]]),
array(
[[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
序号 |
元素及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
5. |
|
numpy.resize
此函数返回指定大小的新数组。 如果新大小大于原始大小,则包含原始数组中的元素的重复副本。 该函数接受以下参数。
(
arr,
shape)
其中:
arr
:要修改大小的输入数组shape
:返回数组的新形状例子
import numpy
as np
a = np.
array([[
1,
2,
3],[
4,
5,
6]])
'第一个数组:'
a
'\n'
'第一个数组的形状:'
a.shape
'\n'
b = np.resize(a, (
3,
2))
'第二个数组:'
b
'\n'
'第二个数组的形状:'
b.shape
'\n'
'修改第二个数组的大小:'
b = np.resize(a,(
3,
3))
b
输出如下:
第一个数组:
[4 5 6]]
第一个数组的形状:
(2, 3)
第二个数组:
[3 4]
[5 6]]
第二个数组的形状:
(3, 2)
修改第二个数组的大小:
[4 5 6]
[1 2 3]]
numpy.append
此函数在输入数组的末尾添加值。 附加操作不是原地的,而是分配新的数组。 此外,输入数组的维度必须匹配否则将生成ValueError
。
函数接受下列函数:
(
arr,
values,
axis)
其中:
arr
:输入数组values
:要向arr
添加的值,比如和arr
形状相同(除了要添加的轴)axis
:沿着它完成操作的轴。如果没有提供,两个参数都会被展开。例子
import numpy
as np
a = np.
array([[
1,
2,
3],[
4,
5,
6]])
'第一个数组:'
a
'\n'
'向数组添加元素:'
np.append(a, [
7,
8,
9])
'\n'
'沿轴 0 添加元素:'
np.append(a, [[
7,
8,
9]],axis =
0)
'\n'
'沿轴 1 添加元素:'
np.append(a, [[
5,
5,
5],[
7,
8,
9]],axis =
1)
输出如下:
第一个数组:
[4 5 6]]
向数组添加元素:
沿轴
0
添加元素:
[4 5 6]
[7 8 9]]
沿轴
1
添加元素:
[4 5 6 7 8 9]]
numpy.insert
此函数在给定索引之前,沿给定轴在输入数组中插入值。 如果值的类型转换为要插入,则它与输入数组不同。 插入没有原地的,函数会返回一个新数组。 此外,如果未提供轴,则输入数组会被展开。
insert()
函数接受以下参数:
(
arr,
obj,
values,
axis)
其中:
arr
:输入数组obj
:在其之前插入值的索引values
:要插入的值axis
:沿着它插入的轴,如果未提供,则输入数组会被展开例子
import numpy
as np
a = np.
array([[
1,
2],[
3,
4],[
5,
6]])
'第一个数组:'
a
'\n'
'未传递 Axis 参数。 在插入之前输入数组会被展开。'
np.insert(a,
3,[
11,
12])
'\n'
'传递了 Axis 参数。 会广播值数组来配输入数组。'
'沿轴 0 广播:'
np.insert(a,
1,[
11],axis =
0)
'\n'
'沿轴 1 广播:'
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)
'第一个数组:'
a
'\n'
'未传递 Axis 参数。 在插入之前输入数组会被展开。'
np.delete(a,
5)
'\n'
'删除第二列:'
np.delete(a,
1,axis =
1)
'\n'
'包含从数组中删除的替代值的切片:'
a = np.
array([
1,
2,
3,
4,
5,
6,
7,
8,
9,
10])
np.delete(a, np.s_[::
2])
输出如下:
第一个数组:
[ 4 5 6 7]
[ 8 9 10 11]]
未传递
Axis
参数。
在插入之前输入数组会被展开。
删除第二列:
[ 4 6 7]
[ 8 10 11]]
包含从数组中删除的替代值的切片:
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])
'第一个数组:'
a
'\n'
'第一个数组的去重值:'
u = np.unique(a)
u
'\n'
'去重数组的索引数组:'
u,indices = np.unique(a, return_index =
True)
indices
'\n'
'我们可以看到每个和原数组下标对应的数值:'
a
'\n'
'去重数组的下标:'
u,indices = np.unique(a,return_inverse =
True)
u
'\n'
'下标为:'
indices
'\n'
'使用下标重构原数组:'
u[indices]
'\n'
'返回去重元素的重复数量:'
u,indices = np.unique(a,return_counts =
True)
u
indices
输出如下:
第一个数组:
第一个数组的去重值:
去重数组的索引数组:
我们可以看到每个和原数组下标对应的数值:
去重数组的下标:
下标为:
使用下标重构原数组:
返回唯一元素的重复数量:
[3 2 2 1 1 1]下面是 NumPy 包中可用的位操作函数。
序号 |
操作及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
5. |
|
bitwise_and
通过np.bitwise_and()
函数对输入数组中的整数的二进制表示的相应位执行位与运算。
例子
numpy
as np
'13 和 17 的二进制形式:'
a,b =
13,
17
bin(a), bin(b)
'\n'
'13 和 17 的位与:'
np.bitwise_and(
13,
17)
输出如下:
你可以使用下表验证此输出。 考虑下面的位与真值表。
A |
B |
AND |
1 |
1 |
1 |
1 |
0 |
0 |
0 |
1 |
0 |
0 |
0 |
0 |
| | | 1 | 1 | 0 | 1 |
| --- | --- |
| AND |
| | 1 | 0 | 0 | 0 | 1 |
| result | 0 | 0 | 0 | 0 | 1 |
bitwise_or
通过np.bitwise_or()
函数对输入数组中的整数的二进制表示的相应位执行位或运算。
例子
numpy
as np
a,b =
13,
17
'13 和 17 的二进制形式:'
bin(a), bin(b)
'13 和 17 的位或:'
np.bitwise_or(
13,
17)
输出如下:
你可以使用下表验证此输出。 考虑下面的位或真值表。
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
'13 的位反转,其中 ndarray 的 dtype 是 uint8:'
np.invert(np.
array([
13], dtype = np.uint8))
'\n'
'13 的二进制表示:'
np.binary_repr(
13, width =
8)
'\n'
'242 的二进制表示:'
np.binary_repr(
242, width =
8)
输出如下:
13
的位反转,其中
ndarray
的
dtype
是
uint8:
13
的二进制表示:
00001101
242
的二进制表示:
11110010
请注意,np.binary_repr()
函数返回给定宽度中十进制数的二进制表示。
left_shift
numpy.left shift()
函数将数组元素的二进制表示中的位向左移动到指定位置,右侧附加相等数量的 0。
例如,
numpy
as np
'将 10 左移两位:'
np.left_shift(
10,
2)
'\n'
'10 的二进制表示:'
np.binary_repr(
10, width =
8)
'\n'
'40 的二进制表示:'
np.binary_repr(
40, width =
8)
输出如下:
right_shift
numpy.right_shift()
函数将数组元素的二进制表示中的位向右移动到指定位置,左侧附加相等数量的 0。
numpy
as np
'将 40 右移两位:'
np.right_shift(
40,
2)
'\n'
'40 的二进制表示:'
np.binary_repr(
40, width =
8)
'\n'
'10 的二进制表示:'
np.binary_repr(
10, width =
8)
输出如下:
以下函数用于对dtype
为numpy.string_
或numpy.unicode_
的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。
序号 |
函数及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
5. |
|
6. |
|
7. |
|
8. |
|
9. |
|
10. |
|
11. |
|
12. |
|
13. |
|
14. |
|
这些函数在字符数组类(numpy.char
)中定义。 较旧的 Numarray 包包含chararray
类。 numpy.char
类中的上述函数在执行向量化字符串操作时非常有用。
numpy.char.add()
函数执行按元素的字符串连接。
numpy
as np
'连接两个字符串:'
np.char.add([
'hello'],[
' xyz'])
'\n'
'连接示例:'
np.char.add([
'hello',
'hi'],[
' abc',
' xyz'])
输出如下:
numpy.char.multiply()
这个函数执行多重连接。
numpy
as np
np.char.multiply(
'Hello ',
3)
输出如下:
Hello Hello Hello
numpy.char.center()
此函数返回所需宽度的数组,以便输入字符串位于中心,并使用fillchar
在左侧和右侧进行填充。
numpy
as np
np.char.center(
'hello',
20,fillchar =
'*')
输出如下:
*******hello********
numpy.char.capitalize()
函数返回字符串的副本,其中第一个字母大写
numpy
as np
np.char.capitalize(
'hello world')
输出如下:
Hello world
numpy.char.title()
返回输入字符串的按元素标题转换版本,其中每个单词的首字母都大写。
numpy
as np
np.char.title(
'hello how are you?')
输出如下:
Hello How Are You?
numpy.char.lower()
函数返回一个数组,其元素转换为小写。它对每个元素调用str.lower
。
numpy
as np
np.char.lower([
'HELLO',
'WORLD'])
np.char.lower(
'HELLO')
输出如下:
numpy.char.upper()
函数返回一个数组,其元素转换为大写。它对每个元素调用str.upper
。
numpy
as np
np.char.upper(
'hello')
np.char.upper([
'hello',
'world'])
输出如下:
numpy.char.split()
此函数返回输入字符串中的单词列表。 默认情况下,空格用作分隔符。 否则,指定的分隔符字符用于分割字符串。
numpy
as np
np.char.split (
'hello how are you?')
np.char.split (
'TutorialsPoint,Hyderabad,Telangana', sep =
',')
输出如下:
numpy.char.splitlines()
函数返回数组中元素的单词列表,以换行符分割。
numpy
as np
np.char.splitlines(
'hello\nhow are you?')
np.char.splitlines(
'hello\rhow are you?')
输出如下:
'\n'
,'\r'
,'\r\n'
都会用作换行符。
numpy.char.strip()
函数返回数组的副本,其中元素移除了开头或结尾处的特定字符。
numpy
as np
np.char.strip(
'ashok arora',
'a')
np.char.strip([
'arora',
'admin',
'java'],
'a')
输出如下:
numpy.char.join()
这个函数返回一个字符串,其中单个字符由特定的分隔符连接。
numpy
as np
np.char.join(
':',
'dmy')
np.char.join([
':',
'-'],[
'dmy',
'ymd'])
输出如下:
numpy.char.replace()
这个函数返回字符串副本,其中所有字符序列的出现位置都被另一个给定的字符序列取代。
numpy
as np
np.char.replace (
'He is a good boy',
'is',
'was')
输出如下:
He was a good boy
numpy.char.decode()
这个函数在给定的字符串中使用特定编码调用str.decode()
。
numpy
as np
a = np.char.encode(
'hello',
'cp500')
a
np.char.decode(a,
'cp500')
输出如下:
numpy.char.encode()
此函数对数组中的每个元素调用str.encode
函数。 默认编码是utf_8
,可以使用标准 Python 库中的编解码器。
numpy
as np
a = np.char.encode(
'hello',
'cp500')
a
输出如下:
\x88\x85\x93\x93\x96
很容易理解的是,NumPy 包含大量的各种数学运算功能。 NumPy 提供标准的三角函数,算术运算的函数,复数处理函数等。
NumPy 拥有标准的三角函数,它为弧度制单位的给定角度返回三角函数比值。
示例
import numpy
as np
a = np.
array([
0,
30,
45,
60,
90])
'不同角度的正弦值:'
np.sin(a*np.pi/
180)
'\n'
'数组中角度的余弦值:'
np.cos(a*np.pi/
180)
'\n'
'数组中角度的正切值:'
np.tan(a*np.pi/
180)
输出如下:
arcsin
,arccos
,和arctan
函数返回给定角度的sin
,cos
和tan
的反三角函数。 这些函数的结果可以通过numpy.degrees()
函数通过将弧度制转换为角度制来验证。
示例
import numpy
as np
a = np.
array([
0,
30,
45,
60,
90])
'含有正弦值的数组:'sin = np.sin(a*np.pi/
180)
sin
'\n'
'计算角度的反正弦,返回值以弧度为单位:'inv = np.arcsin(sin)
inv
'\n'
'通过转化为角度制来检查结果:'
np.degrees(inv)
'\n'
'arccos 和 arctan 函数行为类似:'cos = np.cos(a*np.pi/
180)
cos
'\n'
'反余弦:'inv = np.arccos(cos)
inv
'\n'
'角度制单位:'
np.degrees(inv)
'\n'
'tan 函数:'tan = np.tan(a*np.pi/
180)
tan
'\n'
'反正切:'inv = np.arctan(tan)
inv
'\n'
'角度制单位:'
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.]
函数:
[
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()
这个函数返回四舍五入到所需精度的值。 该函数接受以下参数。
(
a,
decimals)
其中:
序号 |
参数及描述 |
1. |
|
2. |
|
示例
import numpy
as np
a = np.
array([
1.0,
5.55,
123,
0.567,
25.532])
'原数组:'
a
'\n'
'舍入后:'
np.around(a)
np.around(a, decimals =
1)
np.around(a, decimals =
-1)
输出如下:
原数组:
舍入后:
numpy.floor()
此函数返回不大于输入参数的最大整数。 即标量x
的下限是最大的整数i
,使得i <= x
。 注意在Python中,向下取整总是从 0 舍入。
示例
import numpy
as np
a = np.
array([
-1.7,
1.5,
-0.2,
0.6,
10])
'提供的数组:'
a
'\n'
'修改后的数组:'
np.floor(a)
输出如下:
提供的数组:
修改后的数组:
numpy.ceil()
ceil()
函数返回输入值的上限,即,标量x
的上限是最小的整数i
,使得i> = x
。
示例
import numpy
as np
a = np.
array([
-1.7,
1.5,
-0.2,
0.6,
10])
'提供的数组:'
a
'\n'
'修改后的数组:'
np.ceil(a)
输出如下:
提供的数组:
修改后的数组:
用于执行算术运算(如add()
,subtract()
,multiply()
和divide()
)的输入数组必须具有相同的形状或符合数组广播规则。
import numpy
as np
a = np.arange(
9, dtype = np.float_).reshape(
3,
3)
'第一个数组:'
a
'\n'
'第二个数组:'
b = np.
array([
10,
10,
10])
b
'\n'
'两个数组相加:'
np.add(a,b)
'\n'
'两个数组相减:'
np.subtract(a,b)
'\n'
'两个数组相乘:'
np.multiply(a,b)
'\n'
'两个数组相除:'
np.divide(a,b)
输出如下:
第一个数组:
[ 4. 5.]
[ 6. 7. 8.]]
第二个数组:
两个数组相加:
[ 13. 14. 15.]
[ 16. 17. 18.]]
两个数组相减:
[ -7. -6. -5.]
[ -4. -3. -2.]]
两个数组相乘:
[ 30. 40. 50.]
[ 60. 70. 80.]]
两个数组相除:
[ 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])
'我们的数组是:'
a
'\n'
'调用 reciprocal 函数:'
np.reciprocal(a)
'\n'
b = np.
array([
100], dtype = int)
'第二个数组:'
b
'\n'
'调用 reciprocal 函数:'
np.reciprocal(b)
输出如下:
我们的数组是:
调用
reciprocal
函数:
:
RuntimeWarning:
divide
by
zero
encountered
in
reciprocal
print
np.reciprocal(
a)
第二个数组:
调用
reciprocal
函数:
numpy.power()
此函数将第一个输入数组中的元素作为底数,计算它与第二个输入数组中相应元素的幂。
import numpy
as np
a = np.
array([
10,
100,
1000])
'我们的数组是;'
a
'\n'
'调用 power 函数:'
np.power(a,
2)
'\n'
'第二个数组:'
b = np.
array([
1,
2,
3])
b
'\n'
'再次调用 power 函数:'
np.power(a,b)
输出如下:
我们的数组是;
调用
power
函数:
第二个数组:
再次调用
power
函数:
numpy.mod()
此函数返回输入数组中相应元素的除法余数。 函数numpy.remainder()
也产生相同的结果。
import numpy
as np
a = np.
array([
10,
20,
30])
b = np.
array([
3,
5,
7])
'第一个数组:'
a
'\n'
'第二个数组:'
b
'\n'
'调用 mod() 函数:'
np.mod(a,b)
'\n'
'调用 remainder() 函数:'
np.remainder(a,b)
输出如下:
第一个数组:
第二个数组:
调用
mod()
函数:
调用
remainder()
函数:
以下函数用于对含有复数的数组执行操作。
numpy.real()
返回复数类型参数的实部。numpy.imag()
返回复数类型参数的虚部。numpy.conj()
返回通过改变虚部的符号而获得的共轭复数。numpy.angle()
返回复数参数的角度。 函数的参数是degree
。 如果为true
,返回的角度以角度制来表示,否则为以弧度制来表示。import numpy
as np
a = np.
array([
-5.6j,
0.2j,
11. ,
1+
1j])
'我们的数组是:'
a
'\n'
'调用 real() 函数:'
np.real(a)
'\n'
'调用 imag() 函数:'
np.imag(a)
'\n'
'调用 conj() 函数:'
np.conj(a)
'\n'
'调用 angle() 函数:'
np.angle(a)
'\n'
'再次调用 angle() 函数(以角度制返回):'
np.angle(a, deg =
True)
输出如下:
我们的数组是:
调用
real()
函数:
调用
imag()
函数:
调用
conj()
函数:
调用
angle()
函数:
再次调用
angle()
函数(以角度制返回):
NumPy 有很多有用的统计函数,用于从数组中给定的元素中查找最小,最大,百分标准差和方差等。 函数说明如下:
numpy.amin()
和 numpy.amax()
这些函数从给定数组中的元素沿指定轴返回最小值和最大值。
import numpy
as np
a = np.
array([[
3,
7,
5],[
8,
4,
3],[
2,
4,
9]])
'我们的数组是:'
a
'\n'
'调用 amin() 函数:'
np.amin(a,
1)
'\n'
'再次调用 amin() 函数:'
np.amin(a,
0)
'\n'
'调用 amax() 函数:'
np.amax(a)
'\n'
'再次调用 amax() 函数:'
np.amax(a, axis =
0)
输出如下:
我们的数组是:
]
调用
amin()
函数:
再次调用
amin()
函数:
调用
amax()
函数:
9
再次调用
amax()
函数:
numpy.ptp()
numpy.ptp()
函数返回沿轴的值的范围(最大值 - 最小值)。
import numpy
as np
a = np.
array([[
3,
7,
5],[
8,
4,
3],[
2,
4,
9]])
'我们的数组是:'
a
'\n'
'调用 ptp() 函数:'
np.ptp(a)
'\n'
'沿轴 1 调用 ptp() 函数:'
np.ptp(a, axis =
1)
'\n'
'沿轴 0 调用 ptp() 函数:'
np.ptp(a, axis =
0)
输出如下:
我们的数组是:
]
调用
ptp()
函数:
7
沿轴
1
调用
ptp()
函数:
沿轴
0
调用
ptp()
函数:
numpy.percentile()
百分位数是统计中使用的度量,表示小于这个值得观察值占某个百分比。 函数numpy.percentile()
接受以下参数。
(
a,
q,
axis)
其中:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
import numpy
as np
a = np.
array([[
30,
40,
70],[
80,
20,
10],[
50,
90,
60]])
'我们的数组是:'
a
'\n'
'调用 percentile() 函数:'
np.percentile(a,
50)
'\n'
'沿轴 1 调用 percentile() 函数:'
np.percentile(a,
50, axis =
1)
'\n'
'沿轴 0 调用 percentile() 函数:'
np.percentile(a,
50, axis =
0)
输出如下:
我们的数组是:
[80 20 10]
[50 90 60]]
调用
percentile()
函数:
50
.0
沿轴
1
调用
percentile()
函数:
沿轴
0
调用
percentile()
函数:
numpy.median()
中值定义为将数据样本的上半部分与下半部分分开的值。 numpy.median()
函数的用法如下面的程序所示。
import numpy
as np
a = np.
array([[
30,
65,
70],[
80,
95,
10],[
50,
90,
60]])
'我们的数组是:'
a
'\n'
'调用 median() 函数:'
np.median(a)
'\n'
'沿轴 0 调用 median() 函数:'
np.median(a, axis =
0)
'\n'
'沿轴 1 调用 median() 函数:'
np.median(a, axis =
1)
输出如下:
我们的数组是:
[80 95 10]
[50 90 60]]
调用
median()
函数:
65
.0
沿轴
0
调用
median()
函数:
沿轴
1
调用
median()
函数:
numpy.mean()
算术平均值是沿轴的元素的总和除以元素的数量。 numpy.mean()
函数返回数组中元素的算术平均值。 如果提供了轴,则沿其计算。
import numpy
as np
a = np.
array([[
1,
2,
3],[
3,
4,
5],[
4,
5,
6]])
'我们的数组是:'
a
'\n'
'调用 mean() 函数:'
np.mean(a)
'\n'
'沿轴 0 调用 mean() 函数:'
np.mean(a, axis =
0)
'\n'
'沿轴 1 调用 mean() 函数:'
np.mean(a, axis =
1)
输出如下:
我们的数组是:
[3 4 5]
[4 5 6]]
调用
mean()
函数:
3
.66666666667
沿轴
0
调用
mean()
函数:
沿轴
1
调用
mean()
函数:
numpy.average()
加权平均值是由每个分量乘以反映其重要性的因子得到的平均值。 numpy.average()
函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 该函数可以接受一个轴参数。 如果没有指定轴,则数组会被展开。
考虑数组[1,2,3,4]
和相应的权重[4,3,2,1]
,通过将相应元素的乘积相加,并将和除以权重的和,来计算加权平均值。
加权平均值
= (1*4+2*3+3*2+4*1)/(4+3+2+1)
import numpy
as np
a = np.
array([
1,
2,
3,
4])
'我们的数组是:'
a
'\n'
'调用 average() 函数:'
np.average(a)
'\n'
wts = np.
array([
4,
3,
2,
1])
'再次调用 average() 函数:'
np.average(a,weights = wts)
'\n'
'权重的和:'
np.average([
1,
2,
3,
4],weights = [
4,
3,
2,
1], returned =
True)
输出如下:
我们的数组是:
调用
average()
函数:
2
.5
再次调用
average()
函数:
2
.0
权重的和:
(2
.0, 10
.0)
在多维数组中,可以指定用于计算的轴。
import numpy
as np
a = np.arange(
6).reshape(
3,
2)
'我们的数组是:'
a
'\n'
'修改后的数组:'
wt = np.
array([
3,
5])
np.average(a, axis =
1, weights = wt)
'\n'
'修改后的数组:'
np.average(a, axis =
1, weights = wt, returned =
True)
输出如下:
我们的数组是:
[2 3]
[4 5]]
修改后的数组:
修改后的数组:
(
array(
[ 0.625, 2.625, 4.625]),
array(
[ 8., 8., 8.]))
标准差是与均值的偏差的平方的平均值的平方根。 标准差公式如下:
=
sqrt(mean((x - x.mean())**
2))
如果数组是[1,2,3,4]
,则其平均值为2.5
。 因此,差的平方是[2.25,0.25,0.25,2.25]
,并且其平均值的平方根除以4,即sqrt(5/4)
是1.1180339887498949
。
numpy
as np
np.std([
1,
2,
3,
4])
输出如下:
1
.1180339887498949
方差是偏差的平方的平均值,即mean((x - x.mean())** 2)
。 换句话说,标准差是方差的平方根。
import numpy
as np
np.
var([
1,
2,
3,
4])
输出如下:
1
.25
NumPy中提供了各种排序相关功能。 这些排序函数实现不同的排序算法,每个排序算法的特征在于执行速度,最坏情况性能,所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。
种类 |
速度 |
最坏情况 |
工作空间 |
稳定性 |
|
1 |
|
0 |
否 |
|
2 |
|
~n/2 |
是 |
|
3 |
|
0 |
否 |
numpy.sort()
sort()
函数返回输入数组的排序副本。 它有以下参数:
(
a,
axis,
kind,
order)
其中:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
import numpy
as np
a = np.
array([[
3,
7],[
9,
1]])
'我们的数组是:'
a
'\n'
'调用 sort() 函数:'
np.sort(a)
'\n'
'沿轴 0 排序:'
np.sort(a, axis =
0)
'\n'
dt = np.dtype([(
'name',
'S10'),(
'age', int)])
a = np.
array([(
"raju",
21),(
"anil",
25),(
"ravi",
17), (
"amar",
27)], dtype = dt)
'我们的数组是:'
a
'\n'
'按 name 排序:'
np.sort(a, order =
'name')
输出如下:
numpy.argsort()
numpy.argsort()
函数对输入数组沿给定轴执行间接排序,并使用指定排序类型返回数据的索引数组。 这个索引数组用于构造排序后的数组。
numpy
as np
x = np.array([
3,
1,
2])
'我们的数组是:'
x
'\n'
'对 x 调用 argsort() 函数:'
y = np.argsort(x)
y
'\n'
'以排序后的顺序重构原数组:'
x[y]
'\n'
'使用循环重构原数组:'
i
in y:
print x[i],
输出如下:
我们的数组是:
对
x
调用
argsort()
函数:
以排序后的顺序重构原数组:
使用循环重构原数组:
1 2 3
numpy.lexsort()
函数使用键序列执行间接排序。 键可以看作是电子表格中的一列。 该函数返回一个索引数组,使用它可以获得排序数据。 注意,最后一个键恰好是 sort 的主键。
numpy
as np
nm = (
'raju',
'anil',
'ravi',
'amar')
dv = (
'f.y.',
's.y.',
's.y.',
'f.y.')
ind = np.lexsort((dv,nm))
'调用 lexsort() 函数:'
ind
'\n'
'使用这个索引来获取排序后的数据:'
[nm[i] +
", " + dv[i]
for i
in ind]
输出如下:
NumPy 模块有一些用于在数组内搜索的函数。 提供了用于找到最大值,最小值以及满足给定条件的元素的函数。
numpy.argmax()
和 numpy.argmin()
这两个函数分别沿给定轴返回最大和最小元素的索引。
import numpy
as np
a = np.
array([[
30,
40,
70],[
80,
20,
10],[
50,
90,
60]])
'我们的数组是:'
a
'\n'
'调用 argmax() 函数:'
np.argmax(a)
'\n'
'展开数组:'
a.flatten()
'\n'
'沿轴 0 的最大值索引:'
maxindex = np.argmax(a, axis =
0)
maxindex
'\n'
'沿轴 1 的最大值索引:'
maxindex = np.argmax(a, axis =
1)
maxindex
'\n'
'调用 argmin() 函数:'
minindex = np.argmin(a)
minindex
'\n'
'展开数组中的最小值:'
a.flatten()[minindex]
'\n'
'沿轴 0 的最小值索引:'
minindex = np.argmin(a, axis =
0)
minindex
'\n'
'沿轴 1 的最小值索引:'
minindex = np.argmin(a, axis =
1)
minindex
输出如下:
我们的数组是:
[80 20 10]
[50 90 60]]
调用
argmax()
函数:
7
展开数组:
沿轴
0
的最大值索引:
沿轴
1
的最大值索引:
调用
argmin()
函数:
5
展开数组中的最小值:
10
沿轴
0
的最小值索引:
沿轴
1
的最小值索引:
numpy.nonzero()
numpy.nonzero()
函数返回输入数组中非零元素的索引。
import numpy
as np
a = np.
array([[
30,
40,
0],[
0,
20,
10],[
50,
0,
60]])
'我们的数组是:'
a
'\n'
'调用 nonzero() 函数:'
np.nonzero (a)
输出如下:
我们的数组是:
[ 0 20 10]
[50 0 60]]
调用
nonzero()
函数:
(
array(
[0, 0, 1, 1, 2, 2]),
array(
[0, 1, 1, 2, 0, 2]))
numpy.where()
where()
函数返回输入数组中满足给定条件的元素的索引。
numpy
as np
x = np.arange(
9.).reshape(
3,
3)
'我们的数组是:'
x
'大于 3 的元素的索引:'
y = np.where(x >
3)
y
'使用这些索引来获取满足条件的元素:'
x[y]
输出如下:
我们的数组是:
[ 4. 5.]
[ 6. 7. 8.]]
大于
3
的元素的索引:
(
array(
[1, 1, 2, 2, 2]),
array(
[1, 2, 0, 1, 2]))
使用这些索引来获取满足条件的元素:
numpy.extract()
extract()
函数返回满足任何条件的元素。
numpy
as np
x = np.arange(
9.).reshape(
3,
3)
'我们的数组是:'
x
condition = np.mod(x,
2) ==
0
'按元素的条件值:'
condition
'使用条件提取元素:'
np.extract(condition, x)
输出如下:
我们的数组是:
[[
0.
1.
]
[
4.
5.]
[
6.
7.
8.]]
按元素的条件值:
[[
True
False
True]
[
False
True
False]
[
True
False
True]]
使用条件提取元素:
[
0.
2.
4.
6.
8.]
我们已经看到,存储在计算机内存中的数据取决于 CPU 使用的架构。 它可以是小端(最小有效位存储在最小地址中)或大端(最小有效字节存储在最大地址中)。
numpy.ndarray.byteswap()
numpy.ndarray.byteswap()
函数在两个表示:大端和小端之间切换。
import numpy
as np
a = np.
array([
1,
256,
8755], dtype = np.int16)
'我们的数组是:'
a
'以十六进制表示内存中的数据:'
map(hex,a)
'调用 byteswap() 函数:'
a.byteswap(
True)
'十六进制形式:'
map(hex,a)
输出如下:
在执行函数时,其中一些返回输入数组的副本,而另一些返回视图。 当内容物理存储在另一个位置时,称为副本。 另一方面,如果提供了相同内存内容的不同视图,我们将其称为视图。
简单的赋值不会创建数组对象的副本。 相反,它使用原始数组的相同id()
来访问它。 id()
返回 Python 对象的通用标识符,类似于 C 中的指针。
此外,一个数组的任何变化都反映在另一个数组上。 例如,一个数组的形状改变也会改变另一个数组的形状。
numpy
as np
a = np.arange(
6)
'我们的数组是:'
a
'调用 id() 函数:'
id(a)
'a 赋值给 b:'
b = a
b
'b 拥有相同 id():'
id(b)
'修改 b 的形状:'
b.shape =
3,
2
b
'a 的形状也修改了:'
a
输出如下:
我们的数组是:
调用
id()
函数:
139747815479536
赋值给
b:
拥有相同
id()
:
139747815479536
修改
b
的形状:
[2 3]
[4 5]]
的形状也修改了:
[2 3]
[4 5]]
NumPy 拥有ndarray.view()
方法,它是一个新的数组对象,并可查看原始数组的相同数据。 与前一种情况不同,新数组的维数更改不会更改原始数据的维数。
numpy
as np
a = np.arange(
6).reshape(
3,
2)
'数组 a:'
a
'创建 a 的视图:'
b = a.view()
b
'两个数组的 id() 不同:'
'a 的 id():'
id(a)
'b 的 id():'
id(b)
b.shape =
2,
3
'b 的形状:'
b
'a 的形状:'
a
输出如下:
数组
a:
[2 3]
[4 5]]
创建
a
的视图:
[2 3]
[4 5]]
两个数组的
id()
不同:
的
id()
:
140424307227264
的
id()
:
140424151696288
的形状:
[3 4 5]]
的形状:
[2 3]
[4 5]]
数组的切片也会创建视图:
import numpy
as np
a = np.
array([[
10,
10], [
2,
3], [
4,
5]])
'我们的数组:'
a
'创建切片:'
s = a[:, :
2]
s
输出如下:
我们的数组:
[ 2 3]
[ 4 5]]
创建切片:
[ 2 3]
[ 4 5]]
ndarray.copy()
函数创建一个深层副本。 它是数组及其数据的完整副本,不与原始数组共享。
numpy
as np
a = np.array([[
10,
10], [
2,
3], [
4,
5]])
'数组 a:'
a
'创建 a 的深层副本:'
b = a.copy()
'数组 b:'
b
'我们能够写入 b 来写入 a 吗?'
b
is a
'修改 b 的内容:'
b[
0,
0] =
100
'修改后的数组 b:'
b
'a 保持不变:'
a
输出如下:
数组
a:
[ 2 3]
[ 4 5]]
创建
a
的深层副本:
数组
b:
[ 2 3]
[ 4 5]]
我们能够写入
b
来写入
a
吗?
修改
b
的内容:
修改后的数组
b:
[ 2 3]
[ 4 5]]
保持不变:
[ 2 3]
[ 4 5]]
NumPy 包包含一个 Matrix库numpy.matlib
。此模块的函数返回矩阵而不是返回ndarray
对象。
matlib.empty()
matlib.empty()
函数返回一个新的矩阵,而不初始化元素。 该函数接受以下参数。
(
shape,
dtype,
order)
其中:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
numpy.matlib
numpy
as np
np.matlib.empty((
2,
2))
输出如下:
numpy.matlib.zeros()
此函数返回以零填充的矩阵。
numpy.matlib
numpy
as np
np.matlib.zeros((
2,
2))
输出如下:
[ 0. 0.]])
numpy.matlib.ones()
此函数返回以一填充的矩阵。
numpy.matlib
numpy
as np
np.matlib.ones((
2,
2))
输出如下:
numpy.matlib.eye()
这个函数返回一个矩阵,对角线元素为 1,其他位置为零。 该函数接受以下参数。
(
n,
M,
k,
dtype)
其中:
序号 |
参数及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
numpy.matlib
numpy
as np
np.matlib.eye(n =
3, M =
4, k =
0, dtype = float)
输出如下:
[ 0. 1. 0. 0.]
[ 0. 0. 1. 0.]])
numpy.matlib.identity()
numpy.matlib.identity()
函数返回给定大小的单位矩阵。单位矩阵是主对角线元素都为 1 的方阵。
numpy.matlib
numpy
as np
np.matlib.identity(
5, dtype = float)
输出如下:
numpy.matlib.rand()
·numpy.matlib.rand()`函数返回给定大小的填充随机值的矩阵。
numpy.matlib
numpy
as np
np.matlib.rand(
3,
3)
输出如下:
注意,矩阵总是二维的,而ndarray
是一个 n 维数组。 两个对象都是可互换的。
numpy.matlib
numpy
as np
i = np.matrix(
'1,2;3,4')
i
输出如下:
numpy.matlib
numpy
as np
j = np.asarray(i)
j
输出如下:
numpy.matlib
numpy
as np
k = np.asmatrix (j)
k
输出如下:
NumPy 包包含numpy.linalg
模块,提供线性代数所需的所有功能。 此模块中的一些重要功能如下表所述。
序号 |
函数及描述 |
1. |
|
2. |
|
3. |
|
4. |
|
5. |
|
6. |
|
7. |
|
numpy.dot()
此函数返回两个数组的点积。 对于二维向量,其等效于矩阵乘法。 对于一维数组,它是向量的内积。 对于 N 维数组,它是a
的最后一个轴上的和与b
的倒数第二个轴的乘积。
numpy.matlib
numpy as np
a = np.
array([[
1,
2],[
3,
4]])
b = np.
array([[
11,
12],[
13,
14]])
np.dot(a,b)
输出如下:
要注意点积计算为:
[[1*11+2*13, 1*12+2*14],
[3*11+4*13, 3*12+4*14]]
numpy.vdot()
此函数返回两个向量的点积。 如果第一个参数是复数,那么它的共轭复数会用于计算。 如果参数id
是多维数组,它会被展开。
例子
import numpy
as np
a = np.
array([[
1,
2],[
3,
4]])
b = np.
array([[
11,
12],[
13,
14]])
np.vdot(a,b)
输出如下:
130
注意:1*11 + 2*12 + 3*13 + 4*14 = 130
。
numpy.inner()
此函数返回一维数组的向量内积。 对于更高的维度,它返回最后一个轴上的和的乘积。
例子
import numpy
as np
np.inner(np.
array([
1,
2,
3]),np.
array([
0,
1,
0]))
输出如下:
2
例子
import numpy
as np
a = np.
array([[
1,
2], [
3,
4]])
'数组 a:'
a
b = np.
array([[
11,
12], [
13,
14]])
'数组 b:'
b
'内积:'
np.inner(a,b)
输出如下:
数组
a:
]
数组
b:
]
内积:
]
上面的例子中,内积计算如下:
numpy.matmul
numpy.matmul()
函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积,但如果任一参数的维数大于2,则将其视为存在于最后两个索引的矩阵的栈,并进行相应广播。
另一方面,如果任一参数是一维数组,则通过在其维度上附加 1 来将其提升为矩阵,并在乘法之后被去除。
例子
numpy.matlib
numpy
as np
a = [[
1,
0],[
0,
1]]
b = [[
4,
1],[
2,
2]]
np.matmul(a,b)
输出如下:
例子
numpy.matlib
numpy
as np
a = [[
1,
0],[
0,
1]]
b = [
1,
2]
np.matmul(a,b)
np.matmul(b,a)
输出如下:
例子
numpy.matlib
numpy
as np
a = np.arange(
8).reshape(
2,
2,
2)
b = np.arange(
4).reshape(
2,
2)
np.matmul(a,b)
输出如下:
numpy.linalg.det()
行列式在线性代数中是非常有用的值。 它从方阵的对角元素计算。 对于 2×2 矩阵,它是左上和右下元素的乘积与其他两个的乘积的差。
换句话说,对于矩阵[[a,b],[c,d]]
,行列式计算为ad-bc
。 较大的方阵被认为是 2×2 矩阵的组合。
numpy.linalg.det()
函数计算输入矩阵的行列式。
例子
import numpy
as np
a = np.
array([[
1,
2], [
3,
4]])
np.linalg.det(a)
输出如下:
例子
b = np.
array([[
6,
1,
1], [
4,
-2,
5], [
2,
8,
7]])
b
np.linalg.det(b)
6*(
-2*
7 -
5*
8) -
1*(
4*
7 -
5*
2) +
1*(
4*
8 -
-2*
2)
输出如下:
numpy.linalg.solve()
numpy.linalg.solve()
函数给出了矩阵形式的线性方程的解。
考虑以下线性方程:
可以使用矩阵表示为:
如果矩阵成为A
、X
和B
,方程变为:
AX = B
或
X = A^(-1)B
numpy.linalg.inv()
我们使用numpy.linalg.inv()
函数来计算矩阵的逆。 矩阵的逆是这样的,如果它乘以原始矩阵,则得到单位矩阵。
例子
import numpy
as np
x = np.
array([[
1,
2],[
3,
4]])
y = np.linalg.inv(x)
x
y
np.dot(x,y)
输出如下:
例子
现在让我们在示例中创建一个矩阵A的逆。
import numpy
as np
a = np.
array([[
1,
1,
1],[
0,
2,
5],[
2,
5,
-1]])
'数组 a:' a
ainv = np.linalg.inv(a)
'a 的逆:'
ainv
'矩阵 b:'
b = np.
array([[
6],[
-4],[
27]])
b
'计算:A^(-1)B:'
x = np.linalg.solve(a,b)
x
输出如下:
数组
a:
[ 0 2 5]
[ 2 5 -1]]
的逆:
[-0.47619048 0.14285714 0.23809524]
[ 0.19047619 0.14285714 -0.0952381 ]]
矩阵
b:
[-4]
[27]]
计算:
A^(
-1)
B:
[ 3.]
[-2.]]
结果也可以使用下列函数获取
x = np.dot(ainv,b)
Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用,提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用,如 PyQt 和 wxPython。
Matplotlib 模块最初是由 John D. Hunter 编写的。 自 2012 年以来,Michael Droettboom 是主要开发者。 目前,Matplotlib 1.5.1 是可用的稳定版本。 该软件包可以二进制分发,其源代码形式在 www.matplotlib.org 上提供。
通常,通过添加以下语句将包导入到 Python 脚本中:
matplotlib
import pyplot
as plt
这里pyplot()
是 matplotlib 库中最重要的函数,用于绘制 2D 数据。 以下脚本绘制方程y = 2x + 5
:
numpy
as np
matplotlib
import pyplot
as plt
x = np.arange(
1,
11)
y =
2 * x +
5
plt.title(
"Matplotlib demo")
plt.xlabel(
"x axis caption")
plt.ylabel(
"y axis caption")
plt.plot(x,y) plt.show()
ndarray
对象x
由np.arange()
函数创建为x
轴上的值。y
轴上的对应值存储在另一个数组对象y
中。 这些值使用matplotlib
软件包的pyplot
子模块的plot()
函数绘制。
图形由show()
函数展示。
上面的代码应该产生以下输出:
Matplotlib Demo
作为线性图的替代,可以通过向plot()
函数添加格式字符串来显示离散值。 可以使用以下格式化字符。
字符 |
描述 |
|
|
实线样式 |
|
|
短横线样式 |
|
|
点划线样式 |
|
|
虚线样式 |
|
|
点标记 |
|
|
像素标记 |
|
|
圆标记 |
|
|
倒三角标记 |
|
|
正三角标记 |
|
|
左三角标记 |
|
|
右三角标记 |
|
|
下箭头标记 |
|
|
上箭头标记 |
|
|
左箭头标记 |
|
|
右箭头标记 |
|
|
正方形标记 |
|
|
五边形标记 |
|
|
星形标记 |
|
|
六边形标记 1 |
|
|
六边形标记 2 |
|
|
加号标记 |
|
|
X 标记 |
|
|
菱形标记 |
|
|
窄菱形标记 |
|
`' |
'` |
竖直线标记 |
|
水平线标记 |
还定义了以下颜色缩写。
字符 |
颜色 |
|
蓝色 |
|
绿色 |
|
红色 |
|
青色 |
|
品红色 |
|
黄色 |
|
黑色 |
|
白色 |
要显示圆来代表点,而不是上面示例中的线,请使用ob
作为plot()
函数中的格式字符串。
numpy
as np
matplotlib
import pyplot
as plt
x = np.arange(
1,
11)
y =
2 * x +
5
plt.title(
"Matplotlib demo")
plt.xlabel(
"x axis caption")
plt.ylabel(
"y axis caption")
plt.plot(x,y,
"ob")
plt.show()
上面的代码应该产生以下输出:
Color Abbreviation
以下脚本使用 matplotlib 生成正弦波图。
numpy
as np
matplotlib.pyplot
as plt
x = np.arange(
0,
3 * np.pi,
0.1)
y = np.sin(x)
plt.title(
"sine wave form")
plt.plot(x, y)
plt.show()
Sine Wave
subplot()
subplot()
函数允许你在同一图中绘制不同的东西。 在下面的脚本中,绘制正弦和余弦值。
numpy
as np
matplotlib.pyplot
as plt
x = np.arange(
0,
3 * np.pi,
0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
plt.subplot(
2,
1,
1)
plt.plot(x, y_sin)
plt.title(
'Sine')
plt.subplot(
2,
1,
2)
plt.plot(x, y_cos)
plt.title(
'Cosine')
plt.show()
上面的代码应该产生以下输出:
Sub Plot
bar()
pyplot
子模块提供bar()
函数来生成条形图。 以下示例生成两组x
和y
数组的条形图。
matplotlib
import pyplot
as plt
x = [
5,
8,
10]
y = [
12,
16,
6]
x2 = [
6,
9,
11]
y2 = [
6,
15,
7]
plt.bar(x, y, align =
'center')
plt.bar(x2, y2, color =
'g', align =
'center')
plt.title(
'Bar graph')
plt.ylabel(
'Y axis')
plt.xlabel(
'X axis')
plt.show()
NumPy 有一个numpy.histogram()
函数,它是数据的频率分布的图形表示。 水平尺寸相等的矩形对应于类间隔,称为bin
,变量height
对应于频率。
numpy.histogram()
numpy.histogram()
函数将输入数组和bin
作为两个参数。 bin
数组中的连续元素用作每个bin
的边界。
import numpy
as np
a = np.
array([
22,
87,
5,
43,
56,
73,
55,
54,
11,
20,
51,
5,
79,
31,
27]) ]
np.histogram(a,bins = [
0,
20,
40,
60,
80,
100])
hist,bins = np.histogram(a,bins = [
0,
20,
40,
60,
80,
100])
hist
bins
输出如下:
plt()
Matplotlib 可以将直方图的数字表示转换为图形。 pyplot
子模块的plt()
函数将包含数据和bin
数组的数组作为参数,并转换为直方图。
matplotlib
import pyplot
as plt
numpy
as np
a = np.array([
22,
87,
5,
43,
56,
73,
55,
54,
11,
20,
51,
5,
79,
31,
27])
plt.hist(a, bins = [
0,
20,
40,
60,
80,
100])
plt.title(
"histogram")
plt.show()
输出如下:
Histogram Plot
ndarray
对象可以保存到磁盘文件并从磁盘文件加载。 可用的 IO 功能有:
load()
和save()
函数处理 numPy 二进制文件(带npy
扩展名)loadtxt()
和savetxt()
函数处理正常的文本文件NumPy 为ndarray
对象引入了一个简单的文件格式。 这个npy
文件在磁盘文件中,存储重建ndarray
所需的数据、图形、dtype
和其他信息,以便正确获取数组,即使该文件在具有不同架构的另一台机器上。
numpy.save()
numpy.save()
文件将输入数组存储在具有npy
扩展名的磁盘文件中。
numpy
as np
a = np.array([
1,
2,
3,
4,
5])
np.save(
'outfile',a)
为了从outfile.npy
重建数组,请使用load()
函数。
numpy
as np
b = np.load(
'outfile.npy')
b
输出如下:
([
1,
2,
3,
4,
5])
save()
和load()
函数接受一个附加的布尔参数allow_pickles
。 Python 中的pickle
用于在保存到磁盘文件或从磁盘文件读取之前,对对象进行序列化和反序列化。
savetxt()
以简单文本文件格式存储和获取数组数据,是通过savetxt()
和loadtx()
函数完成的。
import numpy
as np
a = np.
array([
1,
2,
3,
4,
5])
np.savetxt(
'out.txt',a)
b = np.loadtxt(
'out.txt')
b
输出如下:
savetxt()
和loadtxt()
数接受附加的可选参数,例如页首,页尾和分隔符。
以下资源包含有关 NumPy 的其他信息。 请使用它们获得更多的深入知识。
原文:https://blog.csdn.net/a373595475/article/details/79580734