什么是 NumPy？依据其官网文档的介绍：
NumPy 是Python中科学计算的根底包。它是一个Python库，提供多维数组对象，各种派生对象（如掩码数组和矩阵），以及用于数组疾速操作的各种API，有包含数学、逻辑、形态操作、排序、抉择、输入输出、离散傅立叶变换、根本线性代数，根本统计运算和随机模仿等等。
NumPy 的外围是一个非凡的数组对象——ndarray 对象。当运算波及到 ndarray 对象时，默认通过预编译的 C 代码对一一元素操作，在运算大量数据时，运算速度极快。此外，咱们还能够看到 NumPy 的语法更简略。
乍一看有些抽象。那么，就让咱们一点一点，揭开 NumPy 的面纱。
2.1 ndarray: 一种多维数组对象
想应用 NumPy，首先让咱们导入 NumPy 包：
import numpy as np2.1.1 创立 ndarray 对象
NumPy 的所有运算简直都是围绕数组（ ndarray 对象）开展的。那么如何创立数组呢？
简略的，咱们能够将一个序列转换为数组。
in : data1 = [6, 7.5, 8, 0, 1] arr1 = np.array(data1) # np.array() 能够将所有序列型的对象转换为一个数组 arr1out: array([6. , 7.5, 8. , 0. , 1. ])in : data2 = [[1, 2, 3, 4], [5, 6, 7, 8]] arr2 = np.array(data2) # 等长嵌套序列将被转换为多维数组 arr2out: array([[1, 2, 3, 4], [5, 6, 7, 8]])也有其余的函数能帮忙咱们间接创立一些非凡数组。
in : np.zeros((2, 3)) # 创立指定规格的全 0 数组out: array([[0., 0., 0.], [0., 0., 0.]])in : np.ones(4) # 创立指定规格的全 1 数组out: array([1., 1., 1., 1.])in : np.arange(10) # 相似 range()out: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])in : data = np.random.randn(2, 3) # 创立指定规格的随机值数组（基于规范正态分布） dataout: array([[-0.22036948, -0.92073677, 0.38747356], [ 0.48489615, -0.74062949, 0.5220284 ]])每个数组都有两个根本属性：shape (示意各维度大小的元组)，dtype (用于阐明数组数据类型的对象)。
in : data.shapeout: (2, 3)in : data.dtypeout: dtype('float64')2.1.2 ndarray 的数据类型
NumPy 能主动为输出的序列设定一个适合的数据类型。
in : arr1 = np.array([1, 2, 3]) arr1.dtypeout: dtype('int32')in : arr2 = np.array([1.2, 0.78, 5]) arr2.dtypeout: dtype('float64')也能够本人手动设置数组的数据类型。
arr3 = np.array([1, 2, 3], dtype=np.float64) # 留神这里的类型名称是“np.float64”如果你想对一个数组进行类型转换，能够应用 astype() 。然而留神，astype() 并非在原数组上进行批改，而是会建设一个新数组。
in : arr3.astype(np.int32)out: array([1, 2, 3])in : arr3.dtypeout: dtype('float64') # 能够看到，原数组 arr3 的数据类型并未被批改2.1.3 雷同大小数组的运算
大小相等的数组之间，任何算术运算都会将运算利用到元素级。
in : arr = np.array([[1., 2., 3.], [4., 5., 6.]]) arrout: array([[1., 2., 3.], [4., 5., 6.]])in : arr * arrout: array([[ 1., 4., 9.], [16., 25., 36.]])in : arr + arrout: array([[ 2., 4., 6.], [ 8., 10., 12.]])in : arr ** 2 # 幂运算out: array([[ 1., 4., 9.], [16., 25., 36.]])数组之间进行比拟，会生成布尔值数组。
in : arr2 = np.array([[0., 4., 1.], [7., 2., 12.]]) arr2out: array([[ 0., 4., 1.], [ 7., 2., 12.]])in : arr2 > arrout: array([[False, True, False], [ True, False, True]])2.1.4 根本的索引和切片
咱们先来看一维数组。首先建设一个一维数组：
in : arr = np.arange(10) arrout: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])创立数组切片的形式与创立序列切片的形式雷同。
in : arr[5:8]out: array([5, 6, 7])对切片赋值会被利用到每个元素之上。
in : arr[5:8] = 12 # 等式左边输出 1 个值，即可对切片蕴含的所有值赋值 arrout: array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])in : arr = 12 # 这样赋值的话，arr 就被赋值为一个整数了，并不能放弃原来的数组构造 arrout: 12# 如果想在原来的数组构造上，将所有值赋值为一个整数，能够这样：in : arr[:] = 12 arrout: array([12, 12, 12, 12, 12, 12, 12, 12, 12, 12])即便将切片保留为一个新的数组，对新数组的任何批改也会被利用到原数组上。这是因为 NumPy 为了解决大量数据，须要防止复制数组造成的占用运算性能问题。能够说，咱们并没失去原数组切片的一个正本，而是失去了原数组切片的一个视图。
in : arr_slice = arr[5:8] # 创立一个数组切片的视图 arr_slice[0] = 100 arrout: array([ 12, 12, 12, 12, 12, 100, 12, 12, 12, 12]) # 能够看到原数组也被扭转了以上个性是和 Python 根底的序列对象不同的。以 list 为例：
in : list1 = list(range(10)) list1out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]in : list1[5:8] = 12 # 一般的 python 列表则不能间接以这样的形式赋值给每个元素（NumPy 数组能够）out: Traceback (most recent call last): File "<input>", line 1, in <module> TypeError: can only assign an iterablein : list1[5:8] = [12, 12, 12] # 能够通过这样的办法赋值 list1out: [0, 1, 2, 3, 4, 12, 12, 12, 8, 9]in : list1_slice = list1[5:8] list1_slice[0] = 100 list1out: [0, 1, 2, 3, 4, 12, 12, 12, 8, 9] # 能够看到原列表没有被扭转如果想得到数组切片的正本（而不是视图），能够采纳 copy() 。
in : arr_slice_copy = arr[5:8].copy() # 创立一个数组切片的正本 arr_slice_copy[0] = 123456 arrout: array([ 12, 12, 12, 12, 12, 100, 12, 12, 12, 12]) # 能够看到原数组就没有被扭转了那么如何对二维数组进行切片呢？
in : arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) arr2dout: array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])in : arr2d[0, 2] arr2d[0][2] # 这两种索引形式是一样的成果out: 3in : arr2d[:2] # 对第0轴切片out: array([[1, 2, 3], [4, 5, 6]]) # 切片后，数组仍是个二维数组in : arr2d[:2, :1] # 对第0轴、第1轴切片out: array([[1], [4]]) # 切片后，数组仍是个二维数组# 注：能够看到，切片不扭转数组的维度2.1.5 布尔型索引
咱们先建设两个数组用于举例：
in : names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe']) data = np.random.randn(7, 4) names dataout: array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'], dtype='<U4') array([[ 0.05817461, 0.82783485, 0.46839737, 0.50975782], [ 1.15212531, 1.4481847 , -0.4201631 , -0.30265817], [ 1.05658084, -0.38813849, 0.16464375, 1.48137849], [-0.64680744, -0.90829029, -0.74018895, 0.17760956], [ 1.96177662, 0.747304 , 0.08973106, 1.37109694], [-0.46767001, -0.50060317, 0.07396933, 0.8385746 ], [-1.71710491, -0.58035244, 2.19566878, 1.33896025]])逻辑表达式能够用于生成布尔型数组，这个布尔型数组能够用于索引。
in : names == 'Bob' # 用逻辑表达式生成布尔型数组out: array([ True, False, False, True, False, False, False])in : data_bob = data[names == 'Bob'] # 布尔型数组用于索引 # 留神：布尔型数组的长度必须跟被索引的轴长度统一 data_bobout: array([[ 0.05817461, 0.82783485, 0.46839737, 0.50975782], [-0.64680744, -0.90829029, -0.74018895, 0.17760956]])布尔型数组用于索引时，能够用 “~” 反转条件。
in : data[~(names == 'Bob')] # ~ 用于反转条件out: array([[ 1.15212531, 1.4481847 , -0.4201631 , -0.30265817], [ 1.05658084, -0.38813849, 0.16464375, 1.48137849], [ 1.96177662, 0.747304 , 0.08973106, 1.37109694], [-0.46767001, -0.50060317, 0.07396933, 0.8385746 ], [-1.71710491, -0.58035244, 2.19566878, 1.33896025]])创立布尔型索引时，Python 能辨认的 not, and, or 是有效的，须要应用 ! & | 。
in : data[(names != 'Bob') & (names != 'Joe')]out: array([[ 1.05658084, -0.38813849, 0.16464375, 1.48137849], [ 1.96177662, 0.747304 , 0.08973106, 1.37109694]])2.1.6 数组的构造重塑和转置
如果想把一个一维数组进行构造重塑，变成 3 × 5 的二维数组，该怎么做呢？
in : arr = np.arange(15).reshape((3, 5)) # reshape() 用于数组的构造重塑 arrout: array([[ 0, 1, 2, 3, 4], [ 5, 6, 7, 8, 9], [10, 11, 12, 13, 14]])如果想把上述数组转置，该怎么做呢？
in : arr.Tout: array([[ 0, 5, 10], [ 1, 6, 11], [ 2, 7, 12], [ 3, 8, 13], [ 4, 9, 14]])2.2 通用函数（ufunc）
通用函数（ ufunc ）是一种对 ndarray 中的数据执行元素级运算的函数。
ufunc 须要至多一个数组作为参数。输出一个数组的 ufunc，被称为一元 ufunc。
in : arr = np. arrange(10) arrout: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])# 开平方in : np.sqrt(arr)out: array([0. , 1. , 1.41421356, 1.73205081, 2. , 2.23606798, 2.44948974, 2.64575131, 2.82842712, 3. ])# 天然底数 e 的 x 次方in : np.exp(arr)out: array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01, 5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03, 2.98095799e+03, 8.10308393e+03])而输出两个数组的 ufunc 被称为 二元 ufunc。
in : x = np.random.randn(8) y = np.random.randn(8) x yout: array([ 0.88741632, -0.47989197, 0.961642 , 1.43875204, -1.28796969, -0.04834001, 0.27405319, -0.03876604]) array([-2.25585454, 0.9791547 , 2.72284215, -0.44911582, 0.39418769, -0.73406601, -0.77432083, -3.21548859])# 返回两个数组中，对应地位更大的值组成的数组（与 x, y 雷同构造）in : np.maximum(x, y) out: array([ 0.88741632, 0.9791547 , 2.72284215, 1.43875204, 0.39418769, -0.04834001, 0.27405319, -0.03876604])也有能返回两个后果数组的函数。
in : arr = np.random.randn(7) * 5 arrout: array([-7.01330576, -0.40563694, 5.65876183, -6.69774849, 0.42850616, 4.65646863, 4.64433757])# 返回浮点数数组的小数和整数局部in : remainder, whole_part = np.modf(arr) remainder whole_partout: array([-0.01330576, -0.40563694, 0.65876183, -0.69774849, 0.42850616, 0.65646863, 0.64433757]) array([-7., -0., 5., -6., 0., 4., 4.]) # 尽管是整数局部，但数组类型仍是“float64”通用函数都并非在原始数组上进行更改，而是构建了一个新的数组。如果想原地操作数组，能够明确指明 out 参数。
in : arr = np.random.randn(5) arrout: array([-0.97691849, 0.31726746, -0.75027946, 0.51031132, -0.54012687])in : np.sqrt(arr) arrout: array([-0.97691849, 0.31726746, -0.75027946, 0.51031132, -0.54012687]) # 能够看到原数组没有被批改in : np.sqrt(arr, arr)out: array([ nan, 0.563265 , nan, 0.71436078, nan])其余的通用函数列举于此：
2.3 利用数组进行数据处理
NumPy 数组能够让咱们在不编写循环的状况下，用简洁的数组表达式进行数学运算。这种用数组表达式代替循环的做法，通常被称为矢量化。
比方，咱们当初想对一个网格型数据计算：
$$\sqrt{(x^2 + y^2)}$$
首先，让咱们创立一个网格型数据。
in : points1 = np.arange(-5, 0) # x轴 points2 = np.arange(0, 5) # y轴 points1 points2out: array([-5, -4, -3, -2, -1]) array([0, 1, 2, 3, 4])# np.meshgrid() 能够承受两个一维数组，并产生两个二维矩阵。# 能够把下面建设的网格画进去，将x轴和y轴组成的网格中，每个 (x, y) 都写进去，就容易了解了。# xs 是这个网格上 (x, y) 中 x 组成的二维矩阵；ys 是这个网格上 (x, y) 中 y 组成的二维矩阵；in : xs, ys = np.meshgrid(points1, points2) xs ysout: array([[-5, -4, -3, -2, -1], [-5, -4, -3, -2, -1], [-5, -4, -3, -2, -1], [-5, -4, -3, -2, -1], [-5, -4, -3, -2, -1]]) array([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3], [4, 4, 4, 4, 4]])# 当初，咱们就能够来计算下面的公式了in : z = np.sqrt(xs ** 2 + ys ** 2) # NumPy 让咱们能够像计算浮点数一样，编写计算数组的代码 zout: array([[5. , 4. , 3. , 2. , 1. ], [5.09901951, 4.12310563, 3.16227766, 2.23606798, 1.41421356], [5.38516481, 4.47213595, 3.60555128, 2.82842712, 2.23606798], [5.83095189, 5. , 4.24264069, 3.60555128, 3.16227766], [6.40312424, 5.65685425, 5. , 4.47213595, 4.12310563]])2.3.1 将条件逻辑表述为数组运算
这一节介绍一下 np.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])咱们想要依据 cond 中的值选取 xarr 和 yarr 的值：当 cond 中的值为 True 时，选取 xarr 的值，否则从 yarr 中选取。
如果用列表推导式编写：
result = [(x if c else y) for x, y, c in zip(xarr, yarr, cond)]但如果用 np.where() 编写，代码会简洁很多：
in : result = np.where(cond, xarr, yarr) resultout: array([1.1, 2.2, 1.3, 1.4, 2.5])np.where() 的第一个参数是逻辑型数组，第二、三个参数则无需是数组。该函数的逻辑是：依据第一个逻辑型数组参数进行断定，若是，把数据替换为参数2,；若不是，把数据替换为参数3。
比方，咱们想把一个二维数组中，负数赋值为2，正数放弃不变。
in : arr = np.random.randn(4,4) arrout: array([[-1.14810005, -1.26020793, -0.88391974, 0.92820162], [-0.37743466, 0.72906491, -2.08884266, 1.02572131], [-0.18377037, 0.92768921, 0.80025967, 1.63431864], [ 2.05365743, -0.13690236, -0.84462678, 1.96340251]]) in : result = np.where(arr > 0, 2, arr)out: array([[-1.14810005, -1.26020793, -0.88391974, 2. ], [-0.37743466, 2. , -2.08884266, 2. ], [-0.18377037, 2. , 2. , 2. ], [ 2. , -0.13690236, -0.84462678, 2. ]])2.3.2 数学和统计办法
NumPy 能够对整个数组进行数学统计，举例如下：
in : arr = np.random.randn(3,2) arrout: array([[ 0.39769436, -0.8714971 ], [-1.98139244, -0.91648828], [-0.61709608, 0.82630001]])in : arr.mean() # 求均值 np.mean(arr) # 和上式是等价的out: -0.527079921854901in : arr.std() # 求标准差out: 0.9201661620576673in : arr.sum() # 求和out: -3.1624795311294065in : arr.mean(axis=0) # 计算每列的均值out: array([-0.73359805, -0.32056179])in : arr.sum(axis=1) # 计算每行的和out: array([-0.47380273, -2.89788073, 0.20920393])2.3.3 用于布尔型数组的办法
上一节的办法也能够利用到布尔型数组里，此时 True = 1，False = 0。
in : arr = np.random.randn(100) (arr > 0).sum() # 能够利用 sum() 对布尔型数组中的 True 值计数out: 52对于布尔型数组而言，也有一些非凡的罕用办法。
in : bools = np.array([False, False, True, False]) bools.any() # 数组中是否存在一个或多个 Trueout: Truein : bools.all() # 数组中是否都是 Trueout: False2.3.4 排序
如何对数组中的值排序呢？
in : arr = np.random.randn(6) arrout: array([-0.30308892, -1.18380195, -1.06029921, -0.92172841, -0.25920488, -0.53782583])# 将数组原地排序in : arr.sort() arrout: array([-1.18380195, -1.06029921, -0.92172841, -0.53782583, -0.30308892, -0.25920488])对于多维数组来说，指明 sort() 中的轴参数，能够按轴对数组进行排序。
in : arr = np.array([[1, 6, 2], [8, 2, 0], [5, 7, 9]]) arrout: array([[1, 6, 2], [8, 2, 0], [5, 7, 9]])in : arr.sort(1) arrout: array([[1, 2, 6], [0, 2, 8], [5, 7, 9]])in : arr.sort(0) arrout: array([[0, 2, 6], [1, 2, 8], [5, 7, 9]])2.3.5 惟一化和其余的汇合逻辑
在数据分析中，经常须要从一个蕴含反复值的数组中，提取出惟一值。这时，咱们能够应用 np.unique()。
in : names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe']) np.unique(names) # 返回不蕴含反复值、已排序的后果数组out: array(['Bob', 'Joe', 'Will'], dtype='<U4')in : ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4]) np.unique(ints)out: array([1, 2, 3, 4])有时，还须要判断一个数组中的值，是否蕴含在另一个数组中。
in : 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])2.4 伪随机数生成
本节以上的局部，咱们应用了很屡次 np.random.randn() 函数来创立一个随机数构建的数组，它示意依照规范正态分布取随机值。NumPy 生成的随机数并非真正的随机数，而是依据一个随机种子通过算法计算失去的，被称为伪随机数。如果你违心，也能够更改随机种子。
其余的函数能够用于生成不同的伪随机数数组：
2.5 示例：随机散步
学习了很多零散的常识，接下来咱们来看一个综合使用的例子。
假如咱们的初始地位是 0，往前走一步记为 1，往后走一步记为 -1。咱们开始随机散步，即步长为 1 和 -1 呈现的概率相等，每次咱们都能够往前走一步，或者往后走一步，一共走 1000 步。
nsteps = 1000draws = np.random.randint(0, 2, size=nsteps) # np.random.randint() 是从给定上上限的范畴内随机选取整数steps = np.where(draws > 0, 1, -1)walk = steps.cumsum() # 生成散步门路：累加，返回每一步的累加值形成的后果数组接下来，让咱们沿着散步门路做一些统计工作。
往后最远走到哪里？
walk.min()往前最远走到哪里？
walk.max()第一次走到第 10 步远是什么时候？
for i, walk_len in enumerate(np.abs(walk) >= 10): if walk_len == True: print(i) break# 或者，用上面的形式更简洁：(np.abs(walk) >= 10).argmax() # argmax() 返回第一个最大值的索引（True 就是布尔型数组中的最大值）注：转载请注明出处。
本文属于《利用 Python 进行数据分析》读书笔记系列：
- 利用 Python 进行数据分析 —— 1 数据结构、函数和文件