声明：本文仅作为学习使用，不作它用。
NumPy —— Numeric Python
一个由多维数组对象和用于处理数组的例程集合组成的开源的基础库。重在数值计算，用于处理数值型数据，也是大部分python科学计算库的基础库，多用在大型、多维数组上执行数值运算，即提供高性能的矩阵运算，数组结构为ndarray。
Numpy数据类型
使用dtype函数查看数组的数据类型
numpy.dtype(object, align, copy)
参数：
Object：被转换为数据类型的对象。
Align：如果为true，则向字段添加间隔，使其类似 C 的结构体。
Copy：生成dtype对象的新副本，如果为flase，结果是内建数据类型对象的引用。
import numpy as np
a = np.array([1, 2, 3])
print(a.dtype)
输出结果：
int32
import numpy as np
a = np.array([1, 1.2])
print(a.dtype)
输出结果：
float64
转换数据类型
import numpy as np
a = np.array(['1.2', '1.3', '1.4'], dtype = np.string_)
print(a)
print(a.dtype)
输出结果：
[b'1.2' b'1.3' b'1.4']
|S3
Numpy数组属性
ndarray.shape
返回一个包含数组维度的元组，它也可以用于调整数组大小。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print a.shape
输出结果：
(2, 3)
调整数组大小：
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]]
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
返回数组的维数
# 一维数组
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
返回数组中每个元素的字节单位长度
# 数组的 dtype 现在为 float32（四个字节）
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.float32)
print x.itemsize
输出结果：
4
numpy.flags
返回了它们的当前值
| 序号 | 属性及描述 |
|---|---|
| C_CONTIGUOUS © | 数组位于单一的、C 风格的连续区段内 |
| F_CONTIGUOUS (F) | 数组位于单一的、Fortran 风格的连续区段内 |
| OWNDATA (O) | 数组的内存从其它对象处借用 |
| WRITEABLE (W) | 数据区域可写入。 将它设置为flase会锁定数据，使其只读 |
| ALIGNED (A) | 数据和任何元素会为硬件适当对齐 |
| 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创建数组
NumPy 的主要对象是多维数组 Ndarray。在 NumPy 中维度 Dimensions 叫做轴 Axes，轴的个数叫做秩 Rank。
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 序号 | 参数及描述 |
|---|---|
| object | 任何暴露数组接口方法的对象都会返回一个数组或任何（嵌套）序列。 |
| dtype | 数组的所需数据类型，可选。 |
| copy | 可选，默认为true，对象是否被复制。 |
| order | C（按行）、F（按列）或A（任意，默认）。 |
| subok | 默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类。 |
| ndmin | 指定返回数组的最小维数。 |
numpy.empty
创建指定形状和dtype的未初始化数组
numpy.empty(shape, dtype = float, order = 'C')
| 序号 | 参数及描述 |
|---|---|
| Shape | 空数组的形状，整数或整数元组 |
| Dtype | 所需的输出数组类型，可选 |
| 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.zero(shape, dtype = float, order = 'C')
| 序号 | 参数及描述 |
|---|---|
| shape | 空数组的形状，整数或整数元组 |
| dtype | 所需的输出数组类型，可选 |
| order | 'C’为按行的 C 风格数组，'F’为按列的 Fortran 风格数组 |
# 自定义类型
import numpy as np
x = np.zeros((2,2), np.uint8)
print (x)
输出结果：
[[0 0]
[0 0]]
numpy.ones
返回特定大小，以1填充的新数组
用法同上
numpy.full
创建任意大小的数组并填充任意数字
import numpy as np
x = np.full((3, 4), 2)
print x
输出结果：
array([[2, 2, 2, 2],
[2, 2, 2, 2],
[2, 2, 2, 2]])
numpy.random.randint
用于生成一定范围内的随机整数数组，为左闭右开区间 [low,high)
numpy.random.randint(low,high,size)
| 序号 | 参数及描述 |
|---|---|
| low | 随机数最小取值范围 |
| high | 可选参数，随机数最大取值范围。若为空，则取值范围为[0,low)；若不为空，则high必须大于low |
| size | 可选参数，数组维数 |
import numpy as np
n1 = np.random.randint(1, 3, 10)
print("随机生成10个1到3之间且不包括3的整数：")
print(n1)
n2 = np.random.randint(5, 10)
print("size数组大小为空随即返回一个整数：")
print(n2)
n3 = np.random.randint(5, size=(2, 5))
print("随机生成5以内二维数组")
print(n3)
随机生成10个1到3之间且不包括3的整数：
[2 2 2 1 1 2 1 2 2 2]
size数组大小为空随即返回一个整数：
8
随机生成5以内二维数组
[[1 0 2 3 4]
[2 4 4 2 3]]
numpy.eye
返回一个二维数组（N,M），对角线的地方为1，其他地方为0
numpy.eye(N,M=None,k=0,dtype=<class 'float'>,order='C)
参数介绍：
| 序号 | 参数及描述 |
|---|---|
| N | 表示的是输出的行数 |
| M | 可选项，输出的列数，如果没有就默认为N |
| k | 可选项，对角线的下标，默认为0表示的是主对角线，负数表示的是低对角，正数表示的是高对角。 |
| dtype | 数据的类型，可选项，返回的数据的数据类型 |
| order | {‘C’，‘F’}，可选项，也就是输出的数组的形式是按照C语言的行优先’C’，还是按照Fortran形式的列优先‘F’存储在内存中 |
import numpy as np
a=np.eye(3)
print(a)
a=np.eye(4,k=1)
print(a)
a=np.eye(4,k=-1)
print(a)
a=np.eye(4,k=-3)
print(a)
输出结果：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
[[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]
[0. 0. 0. 0.]]
[[0. 0. 0. 0.]
[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]]
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]
[1. 0. 0. 0.]]
numpy.identity
与eye效果相同，但是N=M即只能创建方阵
numpy.arrange
返回ndarray对象，包含给定范围内的等间隔值
numpy.arange(start, stop, step, dtype)
import numpy as np
x = np.arange(10,20,2)
print x
输出结果：
[10 12 14 16 18]
import numpy as np
# 设置了 dtype
x = np.arange(5, dtype = float)
print x
输出结果：
[0. 1. 2. 3. 4.]
numpy.linspace
此函数类似于arange()函数。 在此函数中，指定了范围之间的均匀间隔数量，而不是步长。
numpy.linspace(start, stop, num, endpoint, retstep, dtype)
| 序号 | 参数及描述 |
|---|---|
| start | 序列的起始值 |
| stop | 序列的终止值，如果endpoint为true，该值包含于序列中 |
| num | 要生成的等间隔样例数量，默认为50 |
| endpoint | 序列中是否包含stop值，默认为ture |
| retstep | 如果为true，返回样例，以及连续数字之间的步长 |
| dtype | 输出ndarray的数据类型 |
import numpy as np
x = np.linspace(10,20,5)
print x
输出结果：
[10. 12.5 15. 17.5 20.]
将 endpoint 设为 false
import numpy as np
x = np.linspace(10,20, 5, endpoint = False)
print x
输出结果：
[10. 12. 14. 16. 18.]
输出 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)
| 参数 | 解释 |
|---|---|
| start | 起始值是base ** start |
| stop | 终止值是base ** stop |
| num | 范围内的数值数量，默认为50 |
| endpoint | 如果为true，终止值包含在输出数组当中 |
| base | 对数空间的底数，默认为10 |
| dtype | 输出数组的数据类型，如果没有提供，则取决于其它参数 |
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
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.asarray
将序列转换为ndarray
numpy.asarray(a, dtype = None, order = None)
将列表转换为 ndarray
import numpy as np
x = [1,2,3]
a = np.asarray(x)
print a
输出结果：
[1 2 3]
设置了 dtype
import numpy as np
x = [1,2,3]
a = np.asarray(x, dtype = float)
print a
输出结果：
[ 1. 2. 3.]
来自元组列表的 ndarray
import numpy as np
x = [(1,2),(4,5)]
a = np.asarray(x)
print a
输出结果：
[(1, 2) (4, 5)]
Ndarray切片
一维数组索引
import numpy as np
a = np.arange(3,15)
print(a[3])
输出结果：
6
numpy.slice
numpy.slice(start,stop,step)
import numpy as np
a = np.arange(10)
s = slice(2,7,2)
print a[s]
输出结果：
[2 4 6]
通过将由冒号分隔的切片参数（start:stop:step）直接提供给ndarray对象，也可以获得相同的结果。
import numpy as np
a = np.arange(10)
b = a[2:7:2]
print b
输出结果：
[2 4 6]
如果只输入一个参数，则将返回与索引对应的单个项目。 如果使用a:，则从该索引向后的所有项目将被提取。 如果使用两个参数（以:分隔），则对两个索引（不包括停止索引）之间的元素以默认步骤进行切片。
对索引之间的元素进行切片
import numpy as np
a = np.arange(10)
print a[2:5]
输出结果：
[2 3 4]
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索引
一维数组索引
import numpy as np
a = np.arange(3,15)
print(a[3])
输出结果：
6
二维矩阵索引
行数的索引
import numpy as np
a = np.arange(3,15).reshape((3,4))
print(a[2])
输出结果：
[11 12 13 14]
行、列的索引
import numpy as np
a = np.arange(3,15).reshape((3,4))
print(a[1][1]) #也可以这样写 a[1,1],前面为行，后面为列
输出结果：
8
每一行分别输出
import numpy as np
a = np.arange(3,15).reshape((3,4))
for row in a:
print(row)
输出结果：
[3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]
每一列分别输出
由于不可以直接将每一列输出，所以要先将矩阵转置
import numpy as np
a = np.arange(3,15).reshape((3,4))
for column in a.T:
print(column)
输出结果：
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]
[ 6 10 14]
每一项分别输出
import numpy as np
a = np.arange(3,15).reshape((3,4))
for item in a.flat: #先将二维数组转换为一维数组，再逐个输出
print(item)
输出结果：
3
4
5
6
7
8
9
10
11
12
13
14
整数索引
每个整数数组表示该维度的下标值。行索引包含所有行号，列索引指定要选择的元素。
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]]
print y
输出结果：
[1 4 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'
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print '这个数组的每个角处的元素是：'
print y
输出结果：
我们的数组是：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
这个数组的每个角处的元素是：
[[ 0 2]
[ 9 11]]
高级和基本索引可以通过使用切片:或省略号…与索引数组组合。 以下示例使用slice作为列索引和高级索引。 当切片用于两者时，结果是相同的。 但高级索引会导致复制，并且可能有不同的内存布局。
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]]
布尔索引
当结果对象是布尔运算（例如比较运算符）的结果时，将使用此类型的高级索引。
这个例子中，大于 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]
以下示例显示如何从数组中过滤掉非复数元素。
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]
Ndarray数组复制及运算
加法运算
加法运算是数组中对应位置的元素相加（即每行对应相加），如下图所示：
代码示例如下：
import numpy as np
n1 = np.array([1, 2])
n2 = np.array([3, 4])
print(n1 + n2)
结果如下：
减法和乘除法运算
与加法类似，我们完全可以将加法的对应关系迁移到其他三种运算来：
代码示例如下：
import numpy as np
n1 = np.array([1, 2])
n2 = np.array([3, 4])
print(n1 - n2)
print(n1 * n2)
print(n1 / n2)
结果如下：
幂运算
幂是数组中对应位置元素的幂运算，使用 ** 运算符进行运算，示意图如下：
从图中得知：数组n1的元素1和数组n2的元素3通过幂运算得到的是1的3次幂；第二行同理
代码示例如下：
import numpy as np
n1 = np.array([1, 2])
n2 = np.array([3, 4])
print(n1 ** n2)
结果如下：
比较运算
NumPy创建的数组可以使用逻辑运算符进行比较运算，运算的结果是布尔值数组，数组中的布尔值为相比较的数组在相同位置元素的比较结果。
代码示例如下：
import numpy as np
n1 = np.array([1, 2])
n2 = np.array([3, 4])
print(n1 >= n2)
print(n1 == n2)
print(n1 <= n2)
print(n1 != n2)
结果如下：
复制数组
NumPy提供的array()方法可以使用如下语法复制数据：
n2 = np.array(n1,copy=True)
但开发过程中更常用的是copy()方法：
n2 = n1.copy()
1456
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
