- NumPy 数组类型
- NumPy 数组生成
- 数组维度和形状
- 数组基本操作
- NumPy 随机数
NumPy 数组类型
Python 本身支持的数值类型有 int（整型）、float（浮点型）、bool（布尔型） 和 complex（复数型）。而 NumPy 支持比 Python 本身更为丰富的数值类型，细分如下：
bool 布尔类型，1 个字节，值为 True 或 False。
int 整数类型，通常为 int64 或 int32 。
intc 与 C 里的 int 相同，通常为 int32 或 int64。
intp 用于索引，通常为 int32 或 int64。
int8 字节（从 -128 到 127）
int16 整数（从 -32768 到 32767）
int32 整数（从 -2147483648 到 2147483647）
int64 整数（从 -9223372036854775808 到 9223372036854775807）
uint8 无符号整数（从 0 到 255）
uint16 无符号整数（从 0 到 65535）
uint32 无符号整数（从 0 到 4294967295）
uint64 无符号整数（从 0 到 18446744073709551615）
float float64 的简写。
float16 半精度浮点，5 位指数，10 位尾数
float32 单精度浮点，8 位指数，23 位尾数
float64 双精度浮点，11 位指数，52 位尾数
complex complex128 的简写。
complex64 复数，由两个 32 位浮点表示。
complex128 复数，由两个 64 位浮点表示。
在 NumPy 中，上面提到的这些数值类型都被归于 dtype（data-type） 对象的实例。 可以用 numpy.dtype(object, align, copy) 来指定数值类型。而在数组里面，可以用 dtype= 参数。
import numpy as np # 导入 NumPy 模块
a = np.array([1.1, 2.2, 3.3], dtype=np.float64) # 指定 1 维数组的数值类型为 float64
a, a.dtype # 查看 a 及 dtype 类型
可以使用 .astype() 方法在不同的数值类型之间相互转换。
a.astype(int).dtype # 将 a 的数值类型从 float64 转换为 int，并查看 dtype 类型
NumPy 数组生成
在 Python 内建对象中，数组有三种形式：
列表：[1, 2, 3]
元组：(1, 2, 3, 4, 5)
字典：{A:1, B:2}
其中，元组与列表相似，不同之处在于元组的元素不能修改。而字典由键和值构成。python 标准类针对数组的处理局限于 1 维，并仅提供少量的功能。而 NumPy 最核心且最重要的一个特性就是 ndarray 多维数组对象，它区别于 Python 的标准类，拥有对高维数组的处理能力，这也是数值计算过程中缺一不可的重要特性。
NumPy 中，ndarray 类具有六个参数，它们分别为：
- shape：数组的形状。
- dtype：数据类型。
- buffer：对象暴露缓冲区接口。
- offset：数组数据的偏移量。
- strides：数据步长。
- order：{‘C’，‘F’}，以行或列为主排列顺序。
在 NumPy 中，主要通过以下 5 种途径创建数组，它们分别是：
- 从 Python 数组结构列表，元组等转换。
- 使用 np.arange、np.ones、np.zeros 等 NumPy 原生方法。
- 从存储空间读取数组。
- 通过使用字符串或缓冲区从原始字节创建数组。
- 使用特殊函数，如 random。
(1) 列表或元组转换
使用 numpy.array 将列表或元组转换为 ndarray 数组：
numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
object：列表、元组等。
dtype：数据类型。如果未给出，则类型为被保存对象所需的最小类型。
copy：布尔类型，默认 True，表示复制对象。
order：顺序。
subok：布尔类型，表示子类是否被传递。
ndmin：生成的数组应具有的最小维数。
栗子：
np.array([[1, 2, 3], [4, 5, 6]])
>array([[1, 2, 3],
[4, 5, 6]])
np.array([(1, 2), (3, 4), (5, 6)])
>array([[1, 2],
[3, 4],
[5, 6]])
(2) arange 方法创建
arange() 的功能是在给定区间内创建一系列均匀间隔的值:
numpy.arange(start, stop, step, dtype=None)
先设置值所在的区间 [开始， 停止)，这是一个半开半闭区间。然后，设置 step 步长用于设置值之间的间隔。最后的可选参数 dtype可以设置返回ndarray 的值类型。
栗子
# 在区间 [3, 7) 中以 0.5 为步长新建数组
np.arange(3, 7, 0.5, dtype='float32')
>array([3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5], dtype=float32)
(3) linspace 方法创建
linspace方法也可以像arange方法一样，创建数值有规律的数组。linspace 用于在指定的区间内返回间隔均匀的值。其方法如下：
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
start：序列的起始值。
stop：序列的结束值。
num：生成的样本数。默认值为50。
endpoint：布尔值，如果为真，则最后一个样本包含在序列内。
retstep：布尔值，如果为真，返回间距。
dtype：数组的类型。
栗子
np.linspace(0, 10, 10, endpoint=True)
>array([ 0. , 1.11111111, 2.22222222, 3.33333333, 4.44444444,
5.55555556, 6.66666667, 7.77777778, 8.88888889, 10. ])
(4) ones 方法创建
快速创建数值全部为 1 的多维数组:
numpy.ones(shape, dtype=None, order='C')
shape：用于指定数组形状，例如（1， 2）或 3。
dtype：数据类型。
order：{'C'，'F'}，按行或列方式储存数组。
(5) zeros 方法创建
numpy.zeros(shape, dtype=None, order='C')
(6) eye 方法创建
numpy.eye 用于创建一个二维数组，其特点是k 对角线上的值为 1，其余值全部为0。方法如下：
numpy.eye(N, M=None, k=0, dtype=<type 'float'>)
N：输出数组的行数。
M：输出数组的列数。
k：对角线索引：0（默认）是指主对角线，正值是指上对角线，负值是指下对角线。
(7) 从已知数据创建
还可以从已知数据文件、函数中创建 ndarray。NumPy 提供了下面 5 个方法：
- frombuffer（buffer）：将缓冲区转换为 1 维数组。
- fromfile（file，dtype，count，sep）：从文本或二进制文件中构建多维数组。
- fromfunction（function，shape）：通过函数返回值来创建多维数组。
- fromiter（iterable，dtype，count）：从可迭代对象创建 1 维数组。
- fromstring（string，dtype，count，sep）：从字符串中创建 1 维数组。
栗子
np.fromfunction(lambda a, b: a + b, (5, 4))
>array([[0., 1., 2., 3.],
[1., 2., 3., 4.],
[2., 3., 4., 5.],
[3., 4., 5., 6.],
[4., 5., 6., 7.]])
(8) ndarray 数组属性
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
a # 查看 a 的值
a.T # ndarray.T 用于数组的转置,与 .transpose() 相同
a.dtype # ndarray.dtype 用来输出数组包含元素的数据类型
a.imag # ndarray.imag 用来输出数组包含元素的虚部
a.real # ndarray.real用来输出数组包含元素的实部
a.size # ndarray.size用来输出数组中的总包含元素数
a.itemsize # ndarray.itemsize输出一个数组元素的字节数
a.nbytes # ndarray.nbytes用来输出数组的元素总字节数
a.ndim # ndarray.ndim用来输出数组维度
a.shape # ndarray.shape用来输出数组形状
a.strides # ndarray.strides用来遍历数组时，输出每个维度中步进的字节数组
数组维度和形状
NumPy 数组又被称之为 ndarray 多维数组，那么 n 就可以从 1 维依次递增。
1 维数组可以被看作数学中的向量，2 维数组可以看作是矩阵，而 3 维数组则是一个数据立方。
one = np.array([7, 2, 9, 10])
two = np.array([[5.2, 3.0, 4.5],
[9.1, 0.1, 0.3]])
three = np.array([[[1, 1], [1, 1], [1, 1]],
[[1, 1], [1, 1], [1, 1]],
[[1, 1], [1, 1], [1, 1]],
[[1, 1], [1, 1], [1, 1]]])
one.shape, two.shape, three.shape
#((4,), (2, 3), (4, 3, 2))
数组基本操作
(1) 重设形状numpy.reshape(a, newshape)
np.arange(10).reshape((5, 2))
(2) 数组展开numpy.ravel(a, order='C')
order 表示变换时的读取顺序，默认是按照行依次读取，当 order='F' 时，可以按列依次读取排序。
np.ravel(a)
np.ravel(a, order='F')
(3) 轴移动numpy.moveaxis(a, source, destination)
a = np.ones((1, 2, 3))
np.moveaxis(a, 0, -1)
a.shape, np.moveaxis(a, 0, -1).shape
>((1, 2, 3), (2, 3, 1))
(4) 轴交换numpy.swapaxes(a, axis1, axis2)
a = np.ones((1, 4, 3))
np.swapaxes(a, 0, 2)
(5) 数组转置numpy.transpose(a, axes=None)
a = np.arange(4).reshape(2, 2)
np.transpose(a)
(6) 维度改变
atleast_xd 支持将输入数据直接视为 x维。这里的 x 可以表示：1，2，3。方法分别为：
numpy.atleast_1d()
numpy.atleast_2d()
numpy.atleast_3d()
print(np.atleast_1d([1, 2, 3]))
print(np.atleast_2d([4, 5, 6]))
print(np.atleast_3d([7, 8, 9]))
>[1 2 3]
[[4 5 6]]
[[[7]
[8]
[9]]]
(7) 类型转换
有一系列以 as 开头的方法，它们可以将特定输入转换为数组，亦可将数组转换为矩阵、标量，ndarray 等。如下：
asarray(a，dtype，order)：将特定输入转换为数组。
asanyarray(a，dtype，order)：将特定输入转换为 ndarray。
asmatrix(data，dtype)：将特定输入转换为矩阵。
asfarray(a，dtype)：将特定输入转换为 float 类型的数组。
asarray_chkfinite(a，dtype，order)：将特定输入转换为数组，检查 NaN 或 infs。
asscalar(a)：将大小为 1 的数组转换为标量。
a = np.arange(4).reshape(2, 2)
np.asmatrix(a) # 将二维数组转化为矩阵类型
(8) 数组连接
concatenate 可以将多个数组沿指定轴连接在一起:
numpy.concatenate((a1, a2, ...), axis=0)
(a1, a2, ...)：需要连接的数组。
axis：指定连接轴。
a = np.array([[1, 2], [3, 4], [5, 6]])
b = np.array([[7, 8], [9, 10]])
c = np.array([[11, 12]])
np.concatenate((a, b, c), axis=0)
>array([[ 1, 2],
[ 3, 4],
[ 5, 6],
[ 7, 8],
[ 9, 10],
[11, 12]])
a = np.array([[1, 2], [3, 4], [5, 6]])
b = np.array([[7, 8, 9]])
np.concatenate((a, b.T), axis=1)
>array([[1, 2, 7],
[3, 4, 8],
[5, 6, 9]])
(9) 数组堆叠
stack(arrays，axis)：沿着新轴连接数组的序列。
column_stack()：将 1 维数组作为列堆叠到 2 维数组中。
hstack()：按水平方向堆叠数组。
vstack()：按垂直方向堆叠数组。
dstack()：按深度方向堆叠数组。
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
np.stack((a, b))
> array([[1, 2, 3],
[4, 5, 6]])
np.stack((a, b), axis=-1)
>array([[1, 4],
[2, 5],
[3, 6]])
(10) 拆分
split 及与之相似的一系列方法主要是用于数组的拆分，列举如下：
split(ary，indices_or_sections，axis)：将数组拆分为多个子数组。
dsplit(ary，indices_or_sections)：按深度方向将数组拆分成多个子数组。
hsplit(ary，indices_or_sections)：按水平方向将数组拆分成多个子数组。
vsplit(ary，indices_or_sections)：按垂直方向将数组拆分成多个子数组。
a = np.arange(10)
np.split(a, 5)
> [array([0, 1]), array([2, 3]), array([4, 5]), array([6, 7]), array([8, 9])]
(11) 删除
delete(arr，obj，axis)：沿特定轴删除数组中的子数组。
a = np.arange(12).reshape(3, 4)
np.delete(a, 2, 1)# 这里代表沿着横轴，将第 3 列(索引 2)删除。
>array([[ 0, 1, 3],
[ 4, 5, 7],
[ 8, 9, 11]])
np.delete(a, 2, 0)
#当然也可以沿着纵轴，将第三行删除。
(12) 数组插入
insert(arr，obj，values，axis)：依据索引在特定轴之前插入值。
a = np.arange(12).reshape(3, 4)
b = np.arange(4)
np.insert(a, 2, b, 0)
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 0, 1, 2, 3],
[ 8, 9, 10, 11]])
(13) 附加
append(arr，values，axis)：将值附加到数组的末尾，并返回 1 维数组。
a = np.arange(6).reshape(2, 3)
b = np.arange(3)
np.append(a, b)
#注意 append方法返回值，默认是展平状态下的 1 维数组
>array([0, 1, 2, 3, 4, 5, 0, 1, 2])
(14) 重设尺寸resize(a，new_shape)
a = np.arange(10)
a.resize(2, 5)
a
>array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
reshape 在改变形状时，不会影响原数组，相当于对原数组做了一份拷贝。而 resize 则是对原数组执行操作。
(15) 翻转数组
fliplr(m)：左右翻转数组。
flipud(m)：上下翻转数组。
a = np.arange(16).reshape(4, 4)
print(np.fliplr(a))
print(np.flipud(a))
> [[ 3 2 1 0]
[ 7 6 5 4]
[11 10 9 8]
[15 14 13 12]]
[[12 13 14 15]
[ 8 9 10 11]
[ 4 5 6 7]
[ 0 1 2 3]]
NumPy 随机数
numpy.random.rand(d0, d1, ..., dn) ：指定一个数组，并使用 [0, 1) 区间随机数据填充，这些数据均匀分布。
numpy.random.randn(d0, d1, ..., dn)：从标准正态分布中返回一个或多个样本值。
np.random.rand(2, 5)
> array([[0.45707057, 0.71760793, 0.9237991 , 0.20679728, 0.71666777],
[0.26413235, 0.2159173 , 0.89368415, 0.20945761, 0.87704287]])
np.random.randn(1, 10)
> array([[ 0.71917661, 0.74699329, -0.63083962, -0.12872782, -0.13484163,
-0.89962194, 1.02601243, 0.79774512, 0.60209379, -0.30149857]])
randint(low, high, size, dtype) ：生成 [low, high) 的随机整数。注意这是一个半开半闭区间。
np.random.randint(2, 5, 10)
> array([4, 2, 4, 2, 2, 4, 3, 2, 4, 4])
random_sample(size) ：方法将会在 [0, 1) 区间内生成指定 size 的随机浮点数。
np.random.random_sample([10])
array([0.84537088, 0.53911115, 0.50538487, 0.6636087 , 0.74062365,
0.48874626, 0.05434319, 0.74291595, 0.7470888 , 0.10189714])
与 numpy.random.random_sample 类似的方法还有：numpy.random.random([size]),numpy.random.ranf([size]),numpy.random.sample([size]),它们 4 个的效果都差不多。
choice(a, size, replace, p) 方法将会给定的数组里随机抽取几个值，该方法类似于随机抽样。
np.random.choice(10, 5) # 在 np.arange(10) 中随机抽取 5 个数
> array([0, 4, 5, 2, 8])
概率密度分布
numpy.random.beta(a，b，size)：从 Beta 分布中生成随机数。
numpy.random.binomial(n, p, size)：从二项分布中生成随机数。
numpy.random.chisquare(df，size)：从卡方分布中生成随机数。
numpy.random.dirichlet(alpha，size)：从 Dirichlet 分布中生成随机数。
numpy.random.exponential(scale，size)：从指数分布中生成随机数。
numpy.random.f(dfnum，dfden，size)：从 F 分布中生成随机数。
numpy.random.gamma(shape，scale，size)：从 Gamma 分布中生成随机数。
numpy.random.geometric(p，size)：从几何分布中生成随机数。
numpy.random.gumbel(loc，scale，size)：从 Gumbel 分布中生成随机数。
numpy.random.hypergeometric(ngood, nbad, nsample, size)：从超几何分布中生成随机数。
numpy.random.laplace(loc，scale，size)：从拉普拉斯双指数分布中生成随机数。
numpy.random.logistic(loc，scale，size)：从逻辑分布中生成随机数。
numpy.random.lognormal(mean，sigma，size)：从对数正态分布中生成随机数。
numpy.random.logseries(p，size)：从对数系列分布中生成随机数。
numpy.random.multinomial(n，pvals，size)：从多项分布中生成随机数。
numpy.random.multivariate_normal(mean, cov, size)：从多变量正态分布绘制随机样本。
numpy.random.negative_binomial(n, p, size)：从负二项分布中生成随机数。
numpy.random.noncentral_chisquare(df，nonc，size)：从非中心卡方分布中生成随机数。
numpy.random.noncentral_f(dfnum, dfden, nonc, size)：从非中心 F 分布中抽取样本。
numpy.random.normal(loc，scale，size)：从正态分布绘制随机样本。
numpy.random.pareto(a，size)：从具有指定形状的 Pareto II 或 Lomax 分布中生成随机数。
numpy.random.poisson(lam，size)：从泊松分布中生成随机数。
numpy.random.power(a，size)：从具有正指数 a-1 的功率分布中在 0，1 中生成随机数。
numpy.random.rayleigh(scale，size)：从瑞利分布中生成随机数。
numpy.random.standard_cauchy(size)：从标准 Cauchy 分布中生成随机数。
numpy.random.standard_exponential(size)：从标准指数分布中生成随机数。
numpy.random.standard_gamma(shape，size)：从标准 Gamma 分布中生成随机数。
numpy.random.standard_normal(size)：从标准正态分布中生成随机数。
numpy.random.standard_t(df，size)：从具有 df 自由度的标准学生 t 分布中生成随机数。
numpy.random.triangular(left，mode，right，size)：从三角分布中生成随机数。
numpy.random.uniform(low，high，size)：从均匀分布中生成随机数。
numpy.random.vonmises(mu，kappa，size)：从 von Mises 分布中生成随机数。
numpy.random.wald(mean，scale，size)：从 Wald 或反高斯分布中生成随机数。
numpy.random.weibull(a，size)：从威布尔分布中生成随机数。
numpy.random.zipf(a，size)：从 Zipf 分布中生成随机数。
