深入解析：Python进阶第三方库之Numpy

了解Numpy运算速度上的优势

知道数组的属性，形状、类型

应用Numpy实现数组的基本操作

应用随机数组的创建实现正态分布应用

应用Numpy实现数组的逻辑运算a

应用Numpy实现数组的统计运算

应用Numpy实现数组之间的运算

一、Numpy优势

Numpy（Numerical Python）是一个开源的Python科学计算库，用于快速处理任意维度的数组。

Numpy支持常见的数组和矩阵操作。对于同样的数值计算任务，使用Numpy比直接使用Python要简洁的多。

Numpy使用ndarray对象来处理多维数组，该对象是一个快速而灵活的大数据容器。

NumPy提供了一个N维数组类型ndarray，它描述了相同类型的“items”的集合。

用ndarray进行存储：

import numpy as np
# 创建ndarray
score = np.array(
[[80, 89, 86, 67, 79],
[78, 97, 89, 67, 81],
[90, 94, 78, 67, 74],
[91, 91, 90, 67, 69],
[76, 87, 75, 67, 86],
[70, 79, 84, 67, 84],
[94, 92, 93, 67, 64],
[86, 85, 83, 67, 80]])
score

返回结果：

array([[80, 89, 86, 67, 79],

[78, 97, 89, 67, 81],

[90, 94, 78, 67, 74],

[91, 91, 90, 67, 69],

[76, 87, 75, 67, 86],

[70, 79, 84, 67, 84],

[94, 92, 93, 67, 64],

[86, 85, 83, 67, 80]])

ndarray与Python原生list运算效率对比

在这里我们通过一段代码运行来体会到ndarray的好处

import random

import time

import numpy as np

a = []

for i in range(100000000):

a.append(random.random())

# 通过%time魔法方法, 查看当前行的代码运行一次所花费的时间

%time sum1=sum(a)

b=np.array(a)

%time sum2=np.sum(b)

其中第一个时间显示的是使用原生Python计算时间,第二个内容是使用numpy计算时间:

CPU times: user 852 ms, sys: 262 ms, total: 1.11 s

Wall time: 1.13 s

CPU times: user 133 ms, sys: 653 µs, total: 133 ms

Wall time: 134 ms

从中我们看到ndarray的计算速度要快很多，节约了时间。

Numpy专门针对ndarray的操作和运算进行了设计，所以数组的存储效率和输入输出性能远优于Python中的嵌套列表，数组越大，Numpy的优 势就越明显。

二、效率远高于纯Python代码

Numpy底层使用C语言编写，内部解除了GIL（全局解释器锁），其对数组的操作速度不受Python解释器的限制，所以，其效率远高于纯 Python代码。

ndarray的属性

属性名字 属性解释                                       

数组维度的元组                             ndarray.shape

数组维数                                       ndarray.ndim

数组中的元素数量                        ndarray.size

一个数组元素的长度（字节）       ndarray.itemsize

数组元素的类型                                ndarray.dtype

ndarray的形状

首先创建一些数组。

# 创建不同形状的数组
>>> a = np.array([[1,2,3],[4,5,6]])
>>> b = np.array([1,2,3,4])
>>> c = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])

分别打印出形状

>>> a.shape

>>> b.shape

>>> c.shape

(2, 3) # 二维数组

(4,) # 一维数组

(2, 2, 3) # 三维数组

ndarray的类型

>>> type(score.dtype)

<type 'numpy.dtype'>

创建数组的时候指定类型

注意：若不指定，整数默认int64，小数默认float64

三、生成数组的方法

生成0和1的数组

np.ones(shape, dtype)

np.ones_like(a, dtype)

np.zeros(shape, dtype)

np.zeros_like(a, dtype)

ones = np.ones([4,8])

ones

返回结果:

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.],

[1., 1., 1., 1., 1., 1., 1., 1.]])

np.zeros_like(ones)

返回结果:

array([[0., 0., 0., 0., 0., 0., 0., 0.],

[0., 0., 0., 0., 0., 0., 0., 0.],

[0., 0., 0., 0., 0., 0., 0., 0.],

[0., 0., 0., 0., 0., 0., 0., 0.]])

从现有数组生成

生成方式

np.array(object, dtype)

np.asarray(a, dtype)

a = np.array([[1,2,3],[4,5,6]])

# 从现有的数组当中创建

a1 = np.array(a)

# 相当于索引的形式，并没有真正的创建一个新的

a2 = np.asarray(a)

生成固定范围的数组

np.linspace (start, stop, num, endpoint)

创建等差数组 — 指定数量

参数:

start:序列的起始值

stop:序列的终止值

num:要生成的等间隔样例数量，默认为50

endpoint:序列中是否包含stop值，默认为ture

# 生成等间隔的数组

np.linspace(0, 100, 11)

返回结果：

array([ 0., 10., 20., 30., 40., 50., 60., 70., 80., 90., 100.])

np.arange(start,stop, step, dtype)

创建等差数组 — 指定步长

参数

step:步长,默认值为1

np.arange(10, 50, 2)

返回结果：

array([10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42,44, 46, 48])

np.logspace(start,stop, num)

创建等比数列

参数:

num:要生成的等比数列数量，默认为50

# 生成10^x

np.logspace(0, 2, 3)

返回结果:

array([ 1., 10., 100.])

生成随机数组

使用模块介绍

np.random模块

np.random.randn(d0, d1, …, dn)

功能：从标准正态分布中返回一个或多个样本值

np.random.normal(loc=0.0, scale=1.0, size=None)

loc：float

此概率分布的均值（对应着整个分布的中心centre）

scale：float

此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）

size：int or tuple of ints

输出的shape，默认为None，只输出一个值

np.random.standard_normal(size=None)

返回指定形状的标准正态分布的数组。

举例1：生成均值为1.75，标准差为1的正态分布数据，100000000个

x1 = np.random.normal(1.75, 1, 100000000)

返回结果：

array([2.90646763, 1.46737886, 2.21799024, ..., 1.56047411, 1.87969135,

0.9028096 ])

均匀分布

np.random.rand(d0, d1, ..., dn)

返回[0.0，1.0)内的一组均匀分布的数。

np.random.uniform(low=0.0, high=1.0, size=None)

功能：从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.

参数介绍:

low: 采样下界，float类型，默认值为0；

high: 采样上界，float类型，默认值为1；

size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出mnk个样本，缺省时输出1个值。

返回值：ndarray类型，其形状和参数size中描述一致。

np.random.randint(low, high=None, size=None, dtype='l')

从一个均匀分布中随机采样，生成一个整数或N维整数数组，

取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。

# 生成均匀分布的随机数

x2 = np.random.uniform(-1, 1, 100000000)

返回结果：

array([ 0.22411206, 0.31414671, 0.85655613, ..., -0.92972446,

0.95985223, 0.23197723])

四、数组的索引、切片

一维、二维、三维的数组如何索引？

直接进行索引,切片

对象[:, :] -- 先行后列

二维数组索引方式：

举例：获取第一个股票的前3个交易日的涨跌幅数据

# 二维的数组，两个维度

stock_change[0, 0:3]

返回结果：

array([-0.03862668, -1.46128096, -0.75596237])

三维数组索引方式：

# 三维

a1 = np.array([ [[1,2,3],[4,5,6]], [[12,3,34],[5,6,7]]])

# 返回结果

array([[[ 1, 2, 3],

[ 4, 5, 6]],

[[12, 3, 34],

[ 5, 6, 7]]])

# 索引、切片

>>> a1[0, 0, 1] # 输出:

形状修改

ndarray.reshape(shape, order)

返回一个具有相同数据域，但shape不一样的视图

行、列不进行互换

# 在转换形状的时候，一定要注意数组的元素匹配

stock_change.reshape([5, 4])

stock_change.reshape([-1,10]) # 数组的形状被修改为: (2, 10), -1: 表示通过待计算

ndarray.resize(new_shape)

修改数组本身的形状（需要保持元素个数前后相同）

行、列不进行互换

stock_change.resize([5, 4])

# 查看修改后结果

stock_change.shape

(5, 4)

ndarray.T

数组的转置

将数组的行、列进行互换

stock_change.T.shape

(4, 5)