python机器学习入门——科学计算库（numpy）(代码片段)

Numpy优势

Numpy效率

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

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

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

ndarray介绍

NumPy provides an N-dimensional array type, the ndarray, which
describes a collection of “items” of the same type.

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

用ndarray进行存储：

import numpy as np

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

print(s)

输出结果：

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

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

import random
import time
import numpy as np
a = []
for i in range(10000000):
    a.append(random.random())
t=time.time()
sum1=sum(a)
print("list时间：",time.time()-t)

b=np.array(a)

t=time.time()
sum2=np.sum(b)
print("ndarray时间",time.time()-t)

从中我们看到ndarray的计算速度要快很多，节约了时间。机器学习的最大特点就是大量的数据运算，那么如果没有一个快速的解决方案，那可能现在python也在机器学习领域达不到好的效果。

N维数组-ndarray

ndarray的属性

数组属性反映了数组本身固有的信息。

import numpy as np

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

print(a.shape)
print(b.shape)
print(c.shape)
print('--------------------------')

print(a.ndim)
print(b.ndim)
print(c.ndim)
print('--------------------------')

print(a.size)
print(b.size)
print(c.size)
print('--------------------------')

print(a.itemsize)
print(b.itemsize)
print(c.itemsize)
print('--------------------------')

print(a.dtype)
print(b.dtype)
print(c.dtype)

ndarray的形状,

首先创建一些数组。

# 创建不同形状的数组,分别打印出形状
import numpy as np

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]]])

print(a.shape)
print(b.shape)
print(c.shape)

如何理解数组的形状？

二维数组：

三维数组：

ndarray的类型

dtype是numpy.dtype类型，先看看对于数组来说都有哪些类型

基本操作

生成数组的方法

生成0和1的数组:

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

例：

import numpy as np

one=np.ones([2,2,7])
zero=np.zeros_like(one)
print(one)
print('-------------------')
print(zero)

生成数组的方法

生成0和1的数组

np.array(object, dtype)

np.asarray(a, dtype)

从现有数组生成

    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)

生成固定范围的数组

1、创建等差数组 — 指定数量

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

参数：

start:序列的起始值
stop:序列的终止值
num:要生成的等间隔样例数量，默认为50
endpoint:序列中是否包含stop值，默认为ture

import numpy as np

a=np.linspace(0, 100, 11)
print(a)

2、创建等差数组 — 指定步长

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

参数

step:步长,默认值为1

import numpy as np

a=np.arange(-10,10,1,np.int32)
print(a)

3、创建等比数列

np.logspace(start,stop, num)

参数:

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

import numpy as np

a=np.logspace(0,3,4)
print(a)

生成随机数组

使用模块介绍

np.random模块

正态分布

什么是正态分布：

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

正态分布特点：

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

正态分布创建方式：

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

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

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，只输出一个值

3、np.random.standard_normal(size=None)

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

import numpy as np
import matplotlib.pyplot as plt

x=np.random.uniform(-1,1,10000000)

plt.figure(figsize=(20,8),dpi=100)

plt.hist(x,bins=10000)

plt.show()

均匀分布

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.
返回值：ndarray类型，其形状和参数size中描述一致。
参数介绍:

low: 采样下界，float类型，默认值为0；
high: 采样上界，float类型，默认值为1；
size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出mnk个样本，缺省时输出1个值。

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

从一个均匀分布中随机采样，生成一个整数或N维整数数组，
取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0,low)之间随机整数。

import numpy as np
import matplotlib.pyplot as plt

x=np.random.uniform(0,10,10000000)

plt.figure(figsize=(20,8),dpi=100)

plt.hist(x,1000)

plt.show()

数组的索引、切片

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

直接进行索引,切片
对象[:, :] – 先行后列

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

print(a1)
print('---------------')
print(a1[0, 0, 1])

形状修改

1、ndarray.reshape(shape, order)

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

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

构造包含数组中原始数据字节的Python字节
注意：tostring方法在最新python版本中已经过时。

数组的去重

np.unique()

import numpy as np

a=np.array([[1,2,3,4,3,21,0],[9,2,1,4,5,7,3]])

a=np.unique(a)
print(a)

注意：去重的结果是排序后的

ndarray运算

逻辑运算

# 生成10名同学，5门功课的数据
>>> score = np.random.randint(40, 100, (10, 5))

# 取出最后4名同学的成绩，用于逻辑判断
>>> test_score = score[6:, 0:5]

# 逻辑判断, 如果成绩大于60就标记为True 否则为False
>>> test_score > 60
array([[ True,  True,  True, False,  True],
       [ True,  True,  True, False,  True],
       [ True,  True, False, False,  True],
       [False,  True,  True,  True,  True]])

# BOOL赋值, 将满足条件的设置为指定的值-布尔索引
>>> test_score[test_score > 60] = 1
>>> test_score
array([[ 1,  1,  1, 52,  1],
       [ 1,  1,  1, 59,  1],
       [ 1,  1, 44, 44,  1],
       [59,  1,  1,  1,  1]])

通用判断函数

np.all()

# 判断前两名同学的成绩[0:2, :]是否全及格
np.all(score[0:2, :] > 60)

np.any()

# 判断前两名同学的成绩[0:2, :]是否有大于90分的
np.any(score[0:2, :] > 80)

np.where（三元运算符）

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

np.where()

#判断前四名学生,前四门课程中，成绩中大于60的置为1，否则为0 temp = score[:4, :4] np.where(temp > 60, 1, 0)

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

# 判断前四名学生,前四门课程中，成绩中大于60且小于90的换为1，否则为0
np.where(np.logical_and(temp > 60, temp < 90), 1, 0)

# 判断前四名学生,前四门课程中，成绩中大于90或小于60的换为1，否则为0
np.where(np.logical_or(temp > 90, temp < 60), 1, 0)

统计运算

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

min(a, axis) 最小值
max(a, axis]) 最大值
median(a, axis) 中位数
mean(a, axis, dtype) 算术平均数
std(a, axis, dtype) 标准差
var(a, axis,dtype) 方差
np.argmax(axis=) 最大元素对应的下标
np.argmin(axis=) 最小元素对应的下标

数组间运算

数组与数的运算

import numpy as np

arr = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]])
print(arr + 1)
print('----------------------------')
print(arr / 2)
print('----------------------------')
# 可以对比python列表的运算，看出区别
a = [1, 2, 3, 4, 5]
print(a * 3)

数组与数组的运算

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

import numpy as np

arr1 = np.array([[0],[1],[2],[3]])
print(arr1.shape)
# (4, 1)

arr2 = np.array([1,2,3])
arr2.shape
# (3,)

print(arr1+arr2)

上述代码中，数组arr1是4行1列，arr2是1行3列。这两个数组要进行相加，按照广播机制会对数组arr1和arr2都进行扩展，使得数组arr1和arr2都变成4行3列。

下面通过一张图来描述广播机制扩展数组的过程：
广播机制实现了时两个或两个以上数组的运算，即使这些数组的shape不是完全相同的，只需要满足如下任意一个条件即可。

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

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