NumPy 基础：数组和矢量计算

NumPy 的 ndarray ： 一种多维数组对象

import numpy as np
data = np.array()
data.shape  #对象的结构，如（2,3）
data.dtype  #对象元素的数据类型
data.ndim  #对象的维度

创建ndarray

data = []  #创建一个list对象
arr = np.array(data)  #传递一个list对象创建ndarray对象
np.zeros(10)  #创建长度为10的全0数组
np.ones(10)  #创建长度为10的全1数组
np.zeros((3,6))  #创建3行6列的全0二维数组
np.arrange(10)  #对应python内置的range函数  

数组创建函数

函数	说明
array	将输入数据（列表、元祖、数组或其他序列类型）转换为ndarray。
asarray	将输入转换为ndarray，如果输入本身就是一个ndarray就不进行复制。
arrange	类似于内置的range。
ones、ones_like	根据指定的形状和dtype创建一个全1数组。ones_like以另一个数组为参数。
zeros、zeros_like	同上
empty、empty_like	创建新数组，只分配内存空间但不填充任何值。
eye、identity	创建一个正方的NxN单位矩阵（对角线为1，其余为0）

ndarray的数据类型

arr1 = np.array([1, 2, 3], dtype=np.float64)
arr2 = np.array([1, 2, 3], dtype=np.int32)
float_arr1 = arr1.astype(np.float64)  #data.astype()显式转换数据类型
float_arr2 = arr2.astype(arr1.dtype)

调用astype无论如何都会常见一个新的数组（原始数组的一份拷贝），即使新dtype跟老dtype相同也是如此。

基本的索引和切片

一维数组跟Python列表的功能差不多，跟列表最重要的区别在于，数组切片是原始数组的视图，并非拷贝。如果要想得到的是ndarray切片的一个副本而非视图，就需要显式的进行复制操作，例如==arr[5:8].copy()==。

以下两种方式是等价的

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr2d[0][2]
arr2d[0, 2]

切片索引

ndarray的切片语法跟Python列表这样的一维对象差不多。高维度对象的花样更多，可以在一个或多个轴上进行切片，也可以跟整数索引混合使用。

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

arr2d
Out: 
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

arr2d[:2]
Out: 
array([[1, 2, 3],
       [4, 5, 6]])

arr2d[:2,1:]
Out: 
array([[2, 3],
       [5, 6]])

布尔型索引

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
data = randn(7,4)  //使用numpy.random中的randn函数生成一些正态分布的随机数据。
data
Out: 
array([[-0.29387507,  0.17205361,  0.66953008,  1.52117065],
       [ 1.10443341,  1.38657273, -0.07698117,  0.14266073],
       [ 0.76090409,  0.971822  , -0.32016532,  0.8410247 ],
       [-0.16898366,  0.18393705, -0.68519614,  1.22744236],
       [ 0.50100988, -0.75611675,  0.18750586, -1.64240784],
       [-0.3859573 ,  0.53440464, -0.74281885,  0.83665929],
       [-0.52089554,  0.65959834, -0.17651269, -1.58237464]])
names == 'Bob'
Out: array([ True, False, False,  True, False, False, False], dtype=bool)

data[names == 'Bob']
Out: 
array([[-0.29387507,  0.17205361,  0.66953008,  1.52117065],
       [-0.16898366,  0.18393705, -0.68519614,  1.22744236]])

布尔型数组的长度必须跟被索引的轴长度一致。还可以跟切片、整数（或整数序列）混合使用：

data[names == 'Bob',2:]
Out: 
array([[ 0.66953008,  1.52117065],
       [-0.68519614,  1.22744236]])

要选择“Bob”以外的其他值，既可以使用不等于号（!=），也可以通过负号（-）对条件进行否定：

data[names != 'Bob']
data[-(names == 'Bob')]

如果需要对布尔条件进行组合使用，可以使用&（和）、|（或）之类的布尔算数运算符即可：

mask = (names == 'Bob') | (names == 'Will')

mask
Out: array([ True, False,  True,  True,  True, False, False], dtype=bool)

data[mask]
Out: 
array([[-0.29387507,  0.17205361,  0.66953008,  1.52117065],
       [ 0.76090409,  0.971822  , -0.32016532,  0.8410247 ],
       [-0.16898366,  0.18393705, -0.68519614,  1.22744236],
       [ 0.50100988, -0.75611675,  0.18750586, -1.64240784]])

通过布尔型索引选取数组中的数据，总是创建数据的副本，即使返回一模一样的数组也是如此。
==Python关键字and和or在布尔型数组中无效。==

可以对数组中的一些符合条件的数据进行重新赋值：

data[data < 0] = 0

data
Out: 
array([[ 0.        ,  0.17205361,  0.66953008,  1.52117065],
       [ 1.10443341,  1.38657273,  0.        ,  0.14266073],
       [ 0.76090409,  0.971822  ,  0.        ,  0.8410247 ],
       [ 0.        ,  0.18393705,  0.        ,  1.22744236],
       [ 0.50100988,  0.        ,  0.18750586,  0.        ],
       [ 0.        ,  0.53440464,  0.        ,  0.83665929],
       [ 0.        ,  0.65959834,  0.        ,  0.        ]])

花式索引

即利用整数数组进行索引。

为了以特定的书序选取行子集，只需传入一个用于指定顺序的整数列表或ndarray即可：

arr = np.empty((8, 4))
for i in range(8):
    arr[i] = i
arr
Out: 
array([[ 0.,  0.,  0.,  0.],
       [ 1.,  1.,  1.,  1.],
       [ 2.,  2.,  2.,  2.],
       [ 3.,  3.,  3.,  3.],
       [ 4.,  4.,  4.,  4.],
       [ 5.,  5.,  5.,  5.],
       [ 6.,  6.,  6.,  6.],
       [ 7.,  7.,  7.,  7.]])

arr[[4, 3, 0, 6]]
Out: 
array([[ 4.,  4.,  4.,  4.],
       [ 3.,  3.,  3.,  3.],
       [ 0.,  0.,  0.,  0.],
       [ 6.,  6.,  6.,  6.]])

一次传入多个索引数组返回的是一个以为数组，其中的元素对应各个索引元组：

arr = np.arange(32).reshape((8, 4))
arr
Out: 
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23],
       [24, 25, 26, 27],
       [28, 29, 30, 31]])
       
arr[[1, 5, 7, 2], [0, 3, 1, 2]]  #返回的是元素（1,0）、（5,3）、（7,1）和（2,2）。
Out: array([ 4, 23, 29, 10])

我们可以通过以下方式获取矩阵的行列子集：

arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]
Out: 
array([[ 4,  7,  5,  6],
       [20, 23, 21, 22],
       [28, 31, 29, 30],
       [ 8, 11,  9, 10]])

还可以通过使用np.ix函数，它可以将两个一维整数数组转换为一个用于选取方形区域的所引器：

arr[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])]
Out: 
array([[ 4,  7,  5,  6],
       [20, 23, 21, 22],
       [28, 31, 29, 30],
       [ 8, 11,  9, 10]])

==花式索引总是将数据复制到新数组中。==

数组转置和轴对换

==转置是重塑的一种特殊形式，它返回的事源数据的视图（不会进行任何复制操作）==。数组不仅有transppose方法，还有一个特殊的T属性：

arr = np.arange(15).reshape((3, 5))
arr
Out: 
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])

arr.T
Out: 
array([[ 0,  5, 10],
       [ 1,  6, 11],
       [ 2,  7, 12],
       [ 3,  8, 13],
       [ 4,  9, 14]])
       
arr = np.random.randn(6, 3)
np.dot(arr.T, arr)  #利用np.dot计算矩阵内积X.T*X

对于高维数组，transpose需要得到一个由轴编号组成的元组才能对这些轴进行转置（比较费脑子）：

arr = np.arange(16).reshape((2, 2, 4))
arr
Out: 
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

arr.transpose(1,0,2)
Out: 
array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],

       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])

ndarray还有一个swapaxes方法，它接受一对轴编号：

arr
Out: 
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])

arr.swapaxes(1,2)
Out: 
array([[[ 0,  4],
        [ 1,  5],
        [ 2,  6],
        [ 3,  7]],

       [[ 8, 12],
        [ 9, 13],
        [10, 14],
        [11, 15]]])

通用函数：快速的元素级数组函数

一元ufunc

函数	说明
abs、fabs	计算整数、浮点数或复数的绝对值。对于复数数值，可以使用更快的fabs。
sqrt	计算各元素的平方根
square	计算各元素的平方
exp	计算各元素的指数e^x
log、log10、log2、log1p	分别为自然对数、底数为10的log、底数为2的log、log(1 + x)
sign	计算各元素的正负号：1（正数）、0（零）、-1（负数）
ceil	计算各元素的ceiling值
floor	计算各元素的floor值
rint	四舍五入到正数，保留dtype
modf	将数组的小数和整数部分以两个独立数组的形式返回
isnan	返回一个表示“哪些值是NaN”的布尔型数组
isfinite、isinf	分别返回一个表示“哪些元素是有穷的”或“哪些元素是无穷的”的布尔型数组
cos、cosh、sin、sinh、tan、tanh	普通型和双曲型三角函数
arccos、arccosh、arcsin、arcsinh、arctan、arctanh	反三角函数
logical_not	计算各元素not x的真值。想到与-arr

二元ufunc

函数	说明
add	将数组中对应的元素相加
subtract	从第一个数组中减去第二个数组中的元素
multiply	数组元素相乘
divide、floor_divide	除法或向下圆整除法
power	对第一个数组中的元素A，根据第二个数组中的相应元素B,计算A的B次方
maximum、fmax	元素级的最大值计算。fmax忽略NaN
minmum、fmin	元素级的最小值计算。fmin忽略NaN
mod	元素级的求模计算
copysign	将第二个数组中的值得负号复制到第一个数组中的值
greate、greate_equal、less、less_equal、equal、not_equal	执行元素级的比价运算，最终产生布尔型的数组。相当于运算符>、>=、<、<=、==、!=
logical_and、logical_or、logical_xor	执行元素级的真值逻辑运算。相当于中缀运算符&、	、^

利用数组进行数据处理

将条件逻辑表述为数组运算

numpy.where 函数是三元表达式 x if condition else y 的矢量化版本。

xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])
result = [(x if c else y)
   .....: for x, y, c in zip(xarr, yarr, cond)]
result
Out: [1.1000000000000001, 2.2000000000000002, 1.3, 1.3999999999999999, 2.5]

这样做会有许多问题。首先，对于大的数组，它不会很快（因为所有的工作都是有纯Python来做的）。其次，对于多维数组，它不能工作。使用 np.where 你可以像这样非常简洁的编写：

result = np.where(cond, xarr, yarr)
result
Out: array([ 1.1, 2.2, 1.3, 1.4, 2.5])

np.where 的第一个和第二个参数不需要是数组；它们中的一个或两个可以是纯量。 在数据分析中 where 的典型使用是生成一个新的数组，其值基于另一个数组。假如你有一个矩阵，其数据是随机生成的，你想要把其中的正值替换为2，负值替换为-2，使用 np.where 非常容易：

arr = randn(4, 4)
arr
Out:
array([[ 0.6372, 2.2043, 1.7904, 0.0752],
       [-1.5926, -1.1536, 0.4413, 0.3483],
       [-0.1798, 0.3299, 0.7827, -0.7585],
       [ 0.5857, 0.1619, 1.3583, -1.3865]])
np.where(arr > 0, 2, -2)
Out:
array([[ 2, 2, 2, 2],
       [-2, -2, 2, 2],
       [-2, 2, 2, -2],
       [ 2, 2, 2, -2]])

np.where(arr > 0, 2, arr) # 仅设置正值为 2
Out:
array([[ 2. , 2. , 2. , 2. ],
       [-1.5926, -1.1536, 2. , 2. ],
       [-0.1798, 2. , 2. , -0.7585],
       [ 2. , 2. , 2. , -1.3865]])

np.where 可以嵌套使用。

数学统计方法

一组数学函数，计算整个数组或一个轴向上数据的统计，和数组函数一样是容易访问的。聚合（通常被称为 reductions ），如 sum ， mean ，标准偏差 std 可以使用数组实例的方法，也可以使用顶层NumPy的函数：

arr = randn(5,4)
arr
Out: 
array([[ 0.39013323, -0.65003199, -1.7659255 ,  0.50657869],
       [ 1.49064958, -2.12313076, -0.06437275, -1.74020972],
       [ 0.58393273, -2.54944833,  1.3207072 ,  0.4929906 ],
       [ 0.29181077,  0.24600015, -0.88524769,  0.1694354 ],
       [-1.29550423, -0.67156125,  0.04152137,  0.6270823 ]])

arr.mean()
Out: -0.27922950905899768

np.mean(arr)
Out: -0.27922950905899768

arr.sum()
Out: -5.5845901811799532

np.sum(arr)
Out: -5.5845901811799532

像 mean 和 sun 函数可以有一个可选的 axis参数，它对给定坐标轴进行统计，结果数组将会减少一个维度：

arr.mean(axis=1)
Out[84]: array([-0.37981139, -0.60926591, -0.03795445, -0.04450034, -0.32461545])
arr.sum(0)
Out[86]: array([ 1.46102209, -5.74817217, -1.35331736,  0.05587727])

像 cumsum 和 cumprod 这些函数并不聚集，而是产生一个中间结果组成的数组：

arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
arr.cumsum(axis=0)
Out: 
array([[ 0,  1,  2],
       [ 3,  5,  7],
       [ 9, 12, 15]])
arr.cumprod(axis=0)
Out: 
array([[ 0,  1,  2],
       [ 0,  4, 10],
       [ 0, 28, 80]])

数学统计方法清单

方法	描述
sum	对数组的所有或一个轴向上的元素求和。零长度的数组的和为灵。
mean	算术平均值。灵长度的数组的均值为NaN。
std, var	标准差和方差，有可选的调整自由度（默认值为n）。
min, max	最大值和最小值
argmin, argmax	索引最小和最大元素。
cumsum	从0元素开始的累计和。
cumprod	从1元素开始的累计乘。

用于布尔型数组的方法

在上面的方法中，布尔值被强制为1( True )和0a( False )。因此， sum 经常被用来作为对一个布尔数组中的 True 计数的手段：

arr = randn(100)
(arr > 0).sum() # 正值的个数
Out: 44

有两个额外的方法， any 和 all ，对布尔数组尤其有用。 any 用来测试一个数组中是否有一个或更多的 True ，而 all 用来测试所有的值是否为 True ：

bools = np.array([False, False, True, False])
bools.any()
Out: True
bools.all()
Out: False

==这些方法这些方法也可以工作在非布尔型数组上，非零元素作为 True 。==

排序

arr.sort(axis=None)会就地排序修改数组本身，而np.sort(arr,axis=None)返回的是数组的已排序数组。计算数组分位数最简单的方法是对其进行排序，然后选取特定位置的值：

large_arr = randn(1000)
large_arr.sort()
large_arr[int(0.05 * len(large_arr))] # 5% 分位点
Out: -1.5791023260896004

唯一化以及其他的集合逻辑

Numpy有一些基本的针对一维ndarrays的集合操作。最常使用的一个可能是 np.unique ，它返回一个数组的经过排序的 unique 值：

names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
np.unique(names)
Out:
array(['Bob', 'Joe', 'Will'],
      dtype='|S4')
ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
np.unique(ints)
Out: array([1, 2, 3, 4])

另一个函数 np.in1d 用于测试一个数组中的值在另一个数组中的成员资格，返回一个布尔型数组：

values = np.array([6, 0, 0, 3, 2, 5, 6])
np.in1d(values, [2, 3, 6])
Out: array([ True, False, False, True, True, False, True], dtype=bool)

函数	说明
unique(x)	计算x单一的元素，并对结果排序
intersect1d(x, y)	计算x和y相同的元素，并对结果排序
union1d	结合x和y的元素，并对结果排序
in1d(x, y)	得到一个布尔数组指示x中的每个元素是否在y中
setdiff1d(x, y)	差集，在x中但不再y中的集合
setxor1d(x, y)	对称差集，不同时在两个数组中的元素

用于数组的文件输入输出

NumPy 能够保存数据到磁盘和从磁盘加载数据，不论数据是文本或二进制的。

将数组以二进制格式保存到磁盘

np.save 和 np.load 是两个主力功能，有效的保存和加载磁盘数据。数组默认保存为未经过压缩的原始二进制数据，文件扩展名为 .npy ：

arr = np.arange(10)
np.save('some_array', arr)

如果文件路进并不是以 .npy 结尾，扩展名将会被自动加上。在磁盘上的数组可以使用 np.load 加载：

np.load('some_array.npy')
Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

可以使用 np.savez 并以关键字参数传递数组来保存多个数组到一个zip的归档文件中：

np.savez('array_archive.npz', a=arr, b=arr)

加载一个 .npz 文件时，会得到一个字典对象，该对象会对各个数组进行延时加载：

arch = np.load('array_archive.npz')
arch['b']
Out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

存取文本文件

从文件加载文本是一个相当标准的任务。对一个新人来说，Python的文件加读取和写入函数的景象可能有一点儿混乱，因此我将主要集中在pandas的 read_csv 和 read_table 函数上。有时使用 np.loadtxt 或更专门的 np.genfromtxt 对于加载数据到普通的 NumPy 数组是很有用的。

# Windows下用type
!cat array_ex.txt
0.580052,0.186730,1.040717,1.134411
0.194163,-0.636917,-0.938659,0.124094
-0.126410,0.268607,-0.695724,0.047428
-1.484413,0.004176,-0.744203,0.005487
2.302869,0.200131,1.670238,-1.881090
-0.193230,1.047233,0.482803,0.960334

# 直接将文件加载到一个二维数组中
arr = np.loadtxt('array_ex.txt', delimiter=',')
arr
Out:
array([[ 0.5801, 0.1867, 1.0407, 1.1344],
[ 0.1942, -0.6369, -0.9387, 0.1241],
[-0.1264, 0.2686, -0.6957, 0.0474],
[-1.4844, 0.0042, -0.7442, 0.0055],
[ 2.3029, 0.2001, 1.6702, -1.8811],
[-0.1932, 1.0472, 0.4828, 0.9603]])

np.savatxt 执行相反的操作：将数组写到以某种分隔符隔开的文本文件中。 genfromtxt 与 loadtxt 相似，但是它是面向结构数组和缺失数据处理的。

线性代数

dot 函数，是数组的一个方法和 numpy 命名空间中的一个函数，用来进行矩阵乘法运算：

x = np.array([[1., 2., 3.], [4., 5., 6.]])
In [195]: y = np.array([[6., 23.], [-1, 7], [8, 9]])

x.dot(y) # 等价于 np.dot(x, y)
Out:
array([[ 28., 64.],
       [ 67., 181.]])

numpy.linalg 有一个关于矩阵分解和像转置和行列式等的一个标准集合。

from numpy.linalg import inv, qr

常见numpy.linalg

函数	描述
diag	返回一个方阵的对角线（或非对角线）元素为一个一维数组，或者转换一个一维数组到一个方阵（非对角线元素为零）
dot	矩阵乘积
trace	计算对角线上元素的和
det	计算矩阵行列式
eig	计算方阵的特征值和特征向量
inv	计算方阵的逆
pinv	计算方阵 Moore-Penrose 伪逆
qr	计算 QR 分解
svd	计算奇异值分解（SVD）
solve	求解线性系统方程 Ax = b 的x，其中A是一个方阵
lstsq	计算 y = Xb 的最小二乘解

随机数生成

numpy.random 模块对 Python 内置的 random 进行了补充，增加了一些用于高效生成多种概率分布的样本值得函数。

numpy.random 函数

函数	说明
seed	确定随机数生成数的种子
permutation	返回一个序列的随机排列或返回一个随机排列的范围
shuffle	对一个序列就地随机排列
rand	产生均匀分布的样本值
randint	从给定的上下限范围内（不包括上限）随机选取整数
randn	产生标准正态分布的样本值
binomial	产生二项分布的样本值
normal	产生正态（高斯）分布的样本值
beta	产生Beta分布的样本值
chisquare	产生卡方分布的样本值
gamma	产生Gamma分布的样本值
uniform	产生在[0,1]中均匀分布的样本值

模拟随机漫步

多个随机漫步

nwalks = 5000
nsteps = 1000
draws = np.random.randint(0, 2, size=(nwalks, nsteps)) # 0 or 1
steps = np.where(draws > 0, 1, -1)
walks = steps.cumsum(1)
walks
Out:
array([[ 1, 0, 1, ..., 8, 7, 8],
       [ 1, 0, -1, ..., 34, 33, 32],
       [ 1, 0, -1, ..., 4, 5, 4],
       ...,
       [ 1, 2, 1, ..., 24, 25, 26],
       [ 1, 2, 3, ..., 14, 13, 14],
       [ -1, -2, -3, ..., -24, -23, -22]])

# 我们可以获得所有游走的最大和最小值     
walks.max() In [229]: walks.min()
Out: 138 Out[229]: -133

# 在这些游走中，让我们来计算到达30或-30的最短时间。这有一点儿狡猾，
# 因为不是所有的5000个游走都能到达30。我们可以使用 any 方法来检测
hits30 = (np.abs(walks) >= 30).any(1)
hits30
Out: array([False, True, False, ..., False, True, False], dtype=bool)
hits30.sum() # 30或-30的个数
Out: 3410

# 我们可以使用这个布尔数组来选择这些游走中跨过绝对值30的行，并调用 argmax 来取得坐标轴1的穿越时间：
crossing_times = (np.abs(walks[hits30]) >= 30).argmax(1)
crossing_times.mean()
Out[234]: 498.88973607038122