Numpy （Numerical Python）提供了两种基本对象：
Numpy 的主要特点：
import numpy as np
如何查看函数的帮助指令
np.add?
1.1.1 从已有数据中创建数组
（1）将列表转换成ndarray
import numpy as np
1st1 = [1.1, 2.2, 3, 4, 5, 6.6]
nd1 = np.array(1st1)
print(nd1)
# [1.1, 2.2, 3, 4, 5, 6.6]
print(type(nd1))
#
（2）嵌套列表可转换为多维ndarray
import numpy as np
1st2 = [[1.1, 2.2, 3, 4, 5, 6.6], [1,2,3,4]]
nd2 = np.array(1st2)
print(nd2)
# [[1.1, 2.2, 3, 4, 5, 6.6]
# [1,2,3,4]]
# [1.1, 2.2, 3, 4, 5, 6.6]
print(type(nd2))
#
1.1.2 利用random模块生成数组
np.random模块常用函数：
* np.random.random，生成0-1之间随机数
* np.random.uniform，生成均匀分布的随机数
* np.random.randn，生政标准正太分布的随机数
* np.random.randint，生成随机的证书
* np.random.normal，生成正态分布
* np.random.shuffle，随机打乱顺序
* np.random.seed，设置随机数粽子
* random_sample，生成随机的浮点数
具体使用
import numpy as np
nd3 = np.random.random([3,3])
print(nd3)
#[[]
# []
# []]
print("nd3的形状为："，nd3.shape)
# nd3的形状为：（3,3）
每次生成同一份数据，可以指定一个随机种子，使用shuffle函数打乱生成的随机数
import numpy as np
np.random.seed(123)
nd4 = np.random.randn(2,3)
print(nd4)
np.random.shuffle(nd4)
print("随机打乱后的数据：")
print(nd4)
print(type(nd4))
1.1.3 创建特定形状的多维数组
Numpy数组创建函数
* np.zeros（（3,4）） 创建3x4的元素全是0的数组
* np.ones（（3,4）） 创建3x4的元素全是1的数组
* np.empty（（2,3）） 创建2x3的空数组
* np.zeros_like（abc） 创建与abc相同纬度的全是0的数组
* np.ones_like（abc） 创建与abc相同纬度的全是1的数组
* np.empty_like（abc） 创建与abc相同纬度的空数组
* np.eye（5） 创建一个5x5的矩阵，对角线是1，其余是0
* np.full（（3,5），666） 创建3x5的元素全是666的数组
有时候还可以把数据保存起来方便后续使用
import numpy as np
nd9 = np.random.random([5,5])
np.savetxt(X=nd9, fname='./test1.txt')
nd10 = np.loadtxt('./test1.txt')
print(nd10)
1.1.4 利用arange、linspace函数生成数组
arange
arange([start,] stop[,step,], dtype=None)
start、stop指定范围，step设定步长
start默认是0开始。
import numpy as np
print(np.arange(10))
# [0 1 2 3 4 5 6 7 8 9]
print(np.arange(0,10))
# [0 1 2 3 4 5 6 7 8 9]
print(np.arange(1, 4, 0.5))
# [1 1.5 2 2.5 3 3.5]
print(np.arange(9,-1,-1))
# [9 8 7 6 5 4 3 2 1 0]
linspace
np.linspace(start, stop, num=50, endpoint=True, restep=False, dtype=None)
默认线性等分，默认等分为50
import numpy as np
print(np.linspace(0, 1, 10))
#[0 0.11111 0.22222 ...... 1]
# 这里没有像生成0.1，0.2这样规则的数据，是因为，这里需要包含0,1，所以最后除以了9
#（1-0）/0=0.111111，否则需要改起始位置为0.1即可
import numpy as np
np.random.seed(2019)
nd11 = np.random.random([10])
# 获取指定位置的数据，比如获取第5个元素
nd11[4]
# 获取一段数据
nd11[3:7]
# 获取固定间隔取数，比如每间隔2个取一个
nd11[1:6:2]
# 获取一个多维数组的一个区域内的数据
nd12 = np.arange(25).reshape([5,5])
nd12[1:3,1:3]
# 获取一个多维数组中，数值在一个值域内的数据
nd12[(nd12>3)&(nd12<12)]
# 截取指定的行，比如第2,3行
nd12[[1,2]] # 或 nd12[1:3,:]
# 截取指定的列，比如第2,3列
nd12[:,1:3]
random.choice 可以从指定的样本中随机抽取数据
import numpy as np
from numpy import random as nr
a = np.arange(1,25,dtype=float)
# size指定输出数组形状
c1=nr.choice(a,size=(3,4))
# replace缺省为TUre,即可重复抽取，False就是虽然随机但是不重复
c2=nr.choice(a,size=(3,4),replace=False)
# p这个参数，缺省时每个元素的抽取概率相同，否则按照规则进行
c3=nr.choice(a,size(3,4),p=a/np.sum(a))
print("随机可重复抽取：")
print(c1)
print("随机但不重复抽取:")
print(c2)
print("随机但按制度概率抽取:")
print(c3)
1.3.1 对应元素相乘(逐元相乘)
np.mutiply用于数组或者矩阵对应元素相乘
numpy.multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
举例子A与B矩阵相乘
A = np.array([[1, 2], [-1, 4]])
B = np.array([[2, 0], [3, 4]])
A*B
# 或者
numpy.multiply(A,B)
# array([[2, 0],
[-3, 16])
Numpy数组不仅可以与数组进行相乘，还可以进行标量运算
print(A*2.0)
print(A/2.0)
数组通过一些激活函数后，输出与输入的形状一致
X = np.random.rand(2,3)
def softmoid(x):
return 1/(1+np.exp(-x))
def relu(x):
return np.maximum(0,x)
def softmax(x):
return np.exp(x)/np.sum(np.exp(x))
print("输入参数X的形状：", X.shape)
print("激活函数softmoid输出形状：", softmoid(X).shape)
print("激活函数relu输出形状：", relu(X).shape)
print("激活函数softmax输出形状：", softmax(X).shape)
1.3.2 点积运算（矩阵乘法）
np.dot
numpy.dot(a, b, out=None)
这就是真正的矩阵乘法
X1=np.array([[1,2],[3,4]])
X2=np.array([[5,6,7],[8,9,10]])
X3=np.dot(X1,X2)
print(X3)
# 下标2x2*2x3=2x3
1.4.1 更改数组的形状
Numpy中改变向量的一些函数
* arr.reshape 重新将维度改变，不改变向量本身
* arr.resize 重新将维度改变，修改向量本身
* arr.T 转置
* arr.ravel 对向量展开成1维数组，不会产生原数组的副本
* arr.flatten 对向量展开成1维数组，会返回原数组的副本
* arr.squeeze 只能对1维降维，对多维不报错但是没有用
* arr.transpose 对高纬矩阵进行轴对换
reshape（不修改向量本身）
import numpy as np
arr = np.arrange(10)
print(arr)
# 变为2行5列
print(arr.reshape(2,5))
# 指定维度时可以只指定其中一个，剩下用-1代替
print(arr.reshape(5,-1))
print(arr.reshape(-1,2))
resize（修改向量本身）
import numpy as np
arr = np.arrage(10)
print(arr)
arr.resize(2,5)
print(arr)
T
import numpy as np
arr = np.arrange(12).reshape(3,4)
print(arr)
print(arr.T)
ravel 向量展平
import numpy as np
arr = np.arange(6).reshape(2,-1)
print(arr)
# 按照列优秀展平
print(arr.ravel('F'))
# 按照行优先，展平
print(arr.ravel())
flatten 矩阵转换为向量
常用在卷积网络与全连接层之间
import numpy as np
a = np.floor(10*np.random.random((3,4)))
print(a)
print(a.flatten())
squeeze 降维，含1的维度去掉
import numpy as np
arr = np.arange(3).reshape(3
,1)
print(arr.shape)
print(arr.squeeze().shape)
arr1 = np.arange(6).reshape(3,1,2,1)
print(arr1.shape)
print(arr1.squeeze().shape)
#(3, 1)
#(3,)
#(3, 1, 2, 1)
#(3, 2)
transpose
实际中经常把颜色顺序从RGB变为GBR就是一个应用
import numpy as np
arr2 = np.arange(24).reshape(2,3,4)
print(arr2)
print(arr2.shape)
print(arr2.transpose(0,1,2).shape)
print(arr2.transpose(1,2,0).shape)
print(arr2.transpose(2,1,0).shape)
# 结果
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
(2, 3, 4)
(2, 3, 4)
(3, 4, 2)
(4, 3, 2)
1.4.2 合并数组
Numpy数组合并方法
* np.append 内存占用大
* np.concatenate 没有内存问题
* np.stack 沿着新的轴加入一系列数组
* np.hstack 堆栈数组垂直顺序（行）
* np.vstack （列）
* np.dstack 按顺序深入（沿第3维）
* np.vsplit 数组分解成垂直的多个子数组列表
append
# 合并一维数组
import numpy as np
a = np.array([1,2,3])
b = np.array([4,5,6])
c = np.append(a,b)
print(c)
# [1 2 3 4 5 6]
# 合并多维数组
import numpy as np
a = np.arange(4).reshape(2,2)
b = np.arange(4).reshape(2,2)
# 按行处理
c = np.append(a,b,axis=0)
print("按行合并后的结果")
print(c)
print(c.shape)
d = np.append(a,b,axis=1)
print("按列合并后的结果")
print(d)
print(d.shape)
[[0 1]
[2 3]
[0 1]
[2 3]]
(4,2)
[[0 1 0 1]
[2 3 2 3]]
(2,4)
concatenate
沿着指定轴连接数组或者矩阵
import numpy as np
a = np.array([[1,2],[3,4]])
b = np.array([5,6])
c = np.concatenate((a,b), axis=0
) # 按照行加
print(c)
d = np.concatenate((a, b.T), axis=1)
print(d)
[[1 2]
[3 4]
[5 6]]
[[1 2 5]
[3 4 6]]
stack
import numpy as np
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
print(np.stack((a,b), axis=0))
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
如何把大数据拆分成多个批次呢？
拿到数据集
随机打乱数据
定义批大小
批处理数据集
import numpy as np
# 生成10000个形状为2x3的矩阵
data_train = np.random.randn(10000,2,3)
print(data_train.shape)
#(10000,2,3)
# 打乱这10000条数据
np.random.shuffle(data_train)
# 定义批量大小
batch_size = 100
# 进行批量处理
for i in range(0,len(data_train),batch_size):
x_batch_sum = np.sum(data_train[i:i+batch_size])
print("第{}批次，该批次数据的和：{}".format(i,x_batch_sum))
Numpy提供了两种基本的对象，ndarray和ufunc对象
ufunc 是universal function的缩写，对数组的每个元素进行操作的函数，运算速度快一些
常用的函数
* sqrt 平方根
* sin,cos
* abs
* dot 矩阵计算
* log,log10,log2
* exp
* cumsum,cumproduct 累计求和，累计求积
* sum
* mean 均值
* median 中位数
* std 标准差
* var 方差
* corrcoef 相关系数
1.6.1 math 与numpy函数性能比较
import time
import math
import numpy as np
x = [i * 0.001 for i in np.arange(1000000)]
start = time.clock()
for i, t in enumerate(x):
x[i] = match.sin(t)
print("math.sin:", time.clock() - start)
x = [i * 0.001 for i in np.arange(1000000)]
x = np.array(x)
start = time.clock()
np.sin(x)
print("numpy.sin:", time.clock() - start)
numpy.sin 比 math.sin 快10倍不止！
1.6.2 循环与向量运算比较
Numpy库中的内建函数使用了SIMD指令，比使用循环速度快很多！
GPU比Numpy更快，但是Numpy不支持GPU，Pytorch支持！
import time
import numpy as np
x1 = np.random.rand(1000000)
x2 = np.random.rand(1000000)
# 循环使用计算向量点积
tic = time.process_time()
dot = 0
for i in range(len(x1))
dot+=x1[i]*x2[i]
toc = time.process_time()
print ("dot = " + str(dot) + "\n 循环计算时间为：" + str(1000*(toc-tic)) + "ms")
# 使用numpy函数计算点积
tic = time.process_time()
dot = 0
dot = np.dot(x1,x2)
toc = time.process_time()
print ("dot = " + str(dot) + "\n Numpy计算时间为：" + str(1000*(toc-tic)) + "ms")
dot = 249895.7424207973
循环计算时间为：625.0ms
dot = 249895.7424208079
Numpy计算时间为：15.625ms
通常会要求输入的数组的shape是一致的，如果不一致时，需要使用广播机制
归纳为以下四条：
让所有数组向最长的数组看齐，不足的部分前面补1，举列子就是a:2x3x2,b:3x2,那么b:1x3x2
输出数组的shape是输入数组shape的各个轴上最大值
如果输入数组的某个轴和输出数组的对应轴的长度相同或者某个轴长度为1时，这个数组能用来被计算，否则出错
当输入数组的某个轴的长度为1时，沿此轴运算时都要复制此轴上的第一组值
import numpy as npA = np.arange(0, 40, 10).reshape(4,1)print(A)B = np.arange(0,3)print(B)print(“A的形状：{}，B的形状：{}”.format(A.shape,B.shape))C = A+Bprint(“C的形状：”+ C.shape)print(C)
[[ 0][10][20][30]][0 1 2]A的形状：(4, 1)，B的形状：(3,)C的形状：(4, 3)[[ 0 1 2][10 11 12][20 21 22][30 31 32]]
