Numpy学习

Numpy介绍

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

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

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

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

用ndarray进行存储：

import numpy as np
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

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

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)

 可以看出ndarray运行效率快。

ndarray的优势

内存块风格

从图中我们可以看出ndarray在存储数据的时候，数据与数据的地址都是连续的，这样就给使得批量操作数组元素时速度更快。

这是因为ndarray中的所有元素的类型都是相同的，而Python列表中的元素类型是任意的，所以ndarray在存储元素时内存可以连续，而python原生list就只能通过寻址方式找到下一个元素，这虽然也导致了在通用性能方面Numpy的ndarray不及Python原生list，但在科学计算中，Numpy的ndarray就可以省掉很多循环语句，代码使用方面比Python原生list简单的多。

ndarray支持并行化运算（向量化运算）

numpy内置了并行运算功能，当系统有多个核心时，做某种计算时，numpy会自动做并行计算

效率远高于纯Python代码

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

ndarray的属性

ndarray的类型

名称	描述	简写
np.bool	用一个字节存储的布尔类型（True或False）	'b'
np.int8	一个字节大小，-128 至 127	'i'
np.int16	整数，-32768 至 32767	'i2'
np.int32	整数，-2^31​ 至 2^32 -1	'i4'
np.int64	整数，-2^63 至 2^63 - 1	'i8'
np.uint8	无符号整数，0 至 255	'u'
np.uint16	无符号整数，0 至 65535	'u2'
np.uint32	无符号整数，0 至 2^32 - 1	'u4'
np.uint64	无符号整数，0 至 2^64 - 1	'u8'
np.float16	半精度浮点数：16位，正负号1位，指数5位，精度10位	'f2'
np.float32	单精度浮点数：32位，正负号1位，指数8位，精度23位	'f4'
np.float64	双精度浮点数：64位，正负号1位，指数11位，精度52位	'f8'
np.complex64	复数，分别用两个32位浮点数表示实部和虚部	'c8'
np.complex128	复数，分别用两个64位浮点数表示实部和虚部	'c16'
np.object_	python对象	'O'
np.string_	字符串	'S'
np.unicode_	unicode类型	'U'

创建数组的时候指定类型

b = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
b

arr = np.array(["pythonI", "hello", "I"], dtype=np.string_)
arr

生成数组的方法

生成0和1的数组

• np.ones(shape, dtype)
• np.ones_like(a, dtype)
• np.zeros(shape, dtype)
• np.zeros_like(a, dtype)

例：

生成4行8列的，且每个元素都为1的数组

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

生成像上面数组结构一样的，且元素都为0的数组

np.zeros_like(ones)

从现有数组生成

生成方式

• np.array(a, dtype)     类似深拷贝

• np.asarray(a, dtype)         类似浅拷贝   -------   当a其中的元素改变时，随a改变而改变

生成固定范围的数组

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

• 创建等差数组 — 指定数量
• 参数:
  • start:序列的起始值
  • stop:序列的终止值
  • num:要生成的等间隔样例数量，默认为50
  • endpoint:序列中是否包含stop值，默认为ture

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

• 创建等差数组 — 指定步长
• 参数
  • step:步长,默认值为1

np.logspace(start,stop, num)

• 创建等比数列

• 参数:

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

生成随机数组

• np.random模块

正态分布

正态分布是一种概率分布。正态分布是具有两个参数μ和σ的连续型随机变量的分布，第一参数μ是服从正态分布的随机变量的均值，第二个参数σ是此随机变量的标准差，所以正态分布记作N(μ，σ )。

 μ决定了其位置，其标准差σ决定了分布的幅度。当μ = 0,σ = 1时的正态分布是标准正态分布。

方差：是在概率论和统计方差衡量一组数据时离散程度的度量

 其中M为平均值，n为数据总个数，σ 为标准差，σ ^2​可以理解一个整体为方差

调用：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.75，标准差为1的正态分布数数，100000000个

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

显示：

import numpy as np
import matplotlib.pyplot as plt
x1 = np.random.normal(1.75, 1, 100000000)
# 1.创建画布
plt.figure(figsize=(20, 8), dpi=100)

# 2.绘制图像
plt.hist(x1, 1000)

# 3.显示图像
plt.show()

 例：

随机生成4支股票1周的交易日涨幅数据

# 创建符合正态分布的4只股票5天的涨跌幅数据
stock_change = np.random.normal(0, 1, (4, 5))
stock_change

均匀分布

调用：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中描述一致。

例：

import numpy as np
import matplotlib.pyplot as plt
x2 = np.random.uniform(-1, 1, 100000000)
# 1.创建画布
plt.figure(figsize=(20, 8), dpi=100)

# 2.绘制图像
plt.hist(x2, 1000)

# 3.显示图像
plt.show()

数组的索引、切片

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

二维数组索引方式：

# 二维的数组，两个维度 
stock_change[0, 0:3]

三维数组索引方式：

形状修改

ndarray.reshape(shape, order)

• 返回一个具有相同数据域，但shape不一样的视图
• 行、列不进行互换

# 在转换形状的时候，一定要注意数组的元素匹配
stock_change.reshape([5, 4])    #修改为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)

类型修改

• 返回修改了类型之后的数组

stock_change.astype(np.int64)

ndarray.tostring([order])或者ndarray.tobytes([order])

• 构造包含数组中原始数据字节的Python字节

数组的去重

np.unique()

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

逻辑运算

import numpy as np
score = np.random.randint(40, 100, (10, 5))
test_score = score[6:, 0:5]
test_score > 60
test_score[test_score > 60] = 1
test_score

 

通用判断函数

np.all()

 np.any()

 

np.where（三元运算符）

通过使用np.where能够进行更加复杂的运算

 复合逻辑需要结合np.logical_and和np.logical_or使用

统计运算

统计指标

在数据挖掘/机器学习领域，统计指标的值也是我们分析问题的一种方式。常用的指标如下：

• min(a, axis)
  • Return the minimum of an array or minimum along an axis.
• max(a, axis])
  • Return the maximum of an array or maximum along an axis.
• median(a, axis)
  • Compute the median along the specified axis.
• mean(a, axis, dtype)
  • Compute the arithmetic mean along the specified axis.
• std(a, axis, dtype)
  • Compute the standard deviation along the specified axis.
• var(a, axis, dtype)
  • Compute the variance along the specified axis.
  • 

 案例：

学生成绩统计运算

进行统计的时候，axis 轴的取值并不一定，Numpy中不同的API轴的值都不一样，在这里，axis 0代表列, axis 1代表行去进行统计

 

数组间运算

数组与数的运算

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

a / 2

a = [1,2,3]
a * 3

数组与数组的运算

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

运算会报错

广播机制

数组在进行矢量化运算时，要求数组的形状是相等的。当形状不相等的数组执行算术运算的时候，就会出现广播机制，该机制会对数组进行扩展，使数组的shape属性值一样，这样，就可以进行矢量化运算了。

 

广播机制实现了时两个或两个以上数组的运算，即使这些数组的shape不是完全相同的，只需要满足如下任意一个条件即可。

• 1.数组的某一维度等长。
• 2.其中一个数组的某一维度为1 。

广播机制需要扩展维度小的数组，使得它与维度最大的数组的shape值相同，以便使用元素级函数或者运算符进行运算。

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

矩阵乘法api：

• np.matmul
• np.dot

>>> a = np.array([[80, 86],
[82, 80],
[85, 78],
[90, 90],
[86, 82],
[82, 90],
[78, 80],
[92, 94]])
>>> b = np.array([[0.7], [0.3]])

>>> np.matmul(a, b)
array([[81.8],
       [81.4],
       [82.9],
       [90. ],
       [84.8],
       [84.4],
       [78.6],
       [92.6]])

>>> np.dot(a,b)
array([[81.8],
       [81.4],
       [82.9],
       [90. ],
       [84.8],
       [84.4],
       [78.6],
       [92.6]])

np.matmul和np.dot的区别:

二者都是矩阵乘法。 np.matmul中禁止矩阵与标量的乘法。 在矢量乘矢量的內积运算中，np.matmul与np.dot没有区别。