numpy的简单操作

(一)numpy 简介

numpy（numerical python）系统是python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比python自身的嵌套列表结构要更加高效（可用于矩阵计算matrix）

numpy提供了python对多维数组对象的支持：ndarray，具有矢量计算的能力、快速、节省空间。numpy支持高级大量的维度数组与矩阵运算，此外对数组运算提供大量的数学函数库。

我们需要学习的两种数据类型就是array和matrix，但是，矩阵说白了就是一个二维数组，所以常用的还是array。但是区别在于进行矩阵计算的时候，矩阵乘法用的是*，但是如果使用的是array的画使用的是dot()这个方法。

更多内容可以到官网查看：
【1】https://numpy.net/
【2】https://numpy.org/

list 和 array之间的转换

import numpy as np

# list转array
list1 = [[1,2],[3,4],[5,6]]
array1 = np.array(list1)

# 可以通过输出的形式来判断是基本数据类型列表还是数组
print(type(list1),type(array1))
print(len(list1),array1.shape)

# array转list
list2 = array1.tolist()
print(type(list2),type(array1))

print(array1.size) # 输出数组内的元素个数
print(array1.dtype) # 查看数组的数据类型

生成随机数组

# 随即生成指定形状的多维数组
a = np.ndarray(shape=(3,2), dtype=float)

# 这里(3,2)叫做a的形状
# 可以通过.shape 来查看numpy变量的值
print("a的形状是：",a.shape)

# 形状的索引叫做轴，通过轴我们可以对矩阵进行一些列的操作
print("0轴：",a.shape[0])
print("1轴：",a.shape[1])

生成顺序数组

# 生成[0,12)的序列，步长为1
a = np.arange(12,dtype=float,step=1)
print(a)

a = a.reshape((3,4)) # 将数组的形状改变为(3,4)，要求元素的个数要对的上
print(a)

随机生成整数

start=0
end=10
num = 100
a = np.random.randint(start,end,num)
print(a)
print(a.shape())

正态分布和均匀分布的取点

a = np.random.normal(0,1,100) # N(0~1)正太分布,取100个点
c = np.random.randn(100) # N(0~1)正太分布,取100个点
b = np.random.rand(100) # 0~1均匀分布，取100个点
d = np.random.random(100) # 0~1均匀分布
e = np.random.ranf(100) # 0~1均匀分布
f = np.random.uniform(-1,1,100) # -1~1均匀分布

特殊矩阵的生成

ones = np.ones((3,4),dtype=int) # 生成单位阵
zeros = np.zeros((3,4),dtype=int) # 生成全零矩阵
nulls = np.empty((3,4),dtype=int) # 生成空矩阵，但是他不是真正的空，他主要看前面的矩阵是什么类型的就生成什么类型的。如果前面没有的话，就生成随机的。

print(ones,zeros,nulls)

one-hot编码的简单实现

# one-hot 编码，一位有效编码。某一个数据表示一类值。一行数据只有一个有效值。
# 假设一共有三类数据，分别为["动物","植物","微生物"]
# 动物:     [1,0,0]
# 植物:     [0,1,0]
# 微生物:   [0,0,1]
# 所以一个序列：[动物,动物,微生物,植物]经过one-hot编码之后变成了：
# [[1,0,0],
#  [1,0,0],
#  [0,0,1],
#  [0,1,0]]

animal =    [1,0,0]
plant =     [0,1,0]
bacteria =  [0,0,1]

label = ["animals","bacteria","animals","plant"]
one_hot_label = []

for i in label:
    if i == "animals":
        one_hot_label.append(animal)
    elif i == "plant":
        one_hot_label.append(plant)
    elif i == "bacteria":
        one_hot_label.append(bacteria)
    else:
        one_hot_label.append([0,0,0])
print(one_hot_label)

这里你可以试试，假设有[0-9]十类，编码实现[8,3,7,5,9]的one-hot 编码。

常用API（max,min,argmax,argmin，linspace,sum,mean）

x1 = np.random.randn(12)
x2 = x1.reshape((3,4))

# (1) argmax/argmin:一列数据中最大/小值的下标
print(x2)
print(np.argmax(x1)) # 由于是随机生成的值，每次的最大值下标都是不一样的
# 这里就用到了前面所说的轴(axis)，这行代码的意思是根据第0轴，求轴上的最大值下标。
# 关于轴理解一下：轴就是形状的下标。
# x2是一个二维向量，x2.shape = (3,4)。所以他有两个轴。我们可以简单的想成为，以某个运算，就是把某个轴变成去掉，维度-1
# 所以根据第0轴运算,就是去掉第0轴，然后降一个维度，x.shape就变成了(4)，前面那个维度就被拍扁了
# 再根据具体的操作内容，就是寻找最大值下表。
# 这里确实很抽象，需要多练习。
print(np.argmax(x2,axis=0)) 
print(np.argmax(x2,axis=1)) 
print(np.argmin(x2,axis=0)) 
print(np.argmin(x2,axis=1))
print("-----------------------------------------------------------------")

# (2)max/min
x = np.random.randn(12)
y = x.reshape((2,6))
print(np.max(x))

print(np.max(y,axis=0))
print(np.max(y,axis=1))

print("-----------------------------------------------------------------")

# （3）三维的轴 (轴就是形状的下标)
# axis = 0, 形状变化:(2,3,4)=>(3,4)
# axis = 1, 形状变化:(2,3,4)=>(2,4)
# axis = 2, 形状变化:(2,3,4)=>(2,3)
# axis = n, 把第n个维度去掉，知道结果了，再理解操作就会简单些
x = np.random.randn(24)
y = x.reshape((2,3,4))

print(np.max(y, axis=0),np.max(y, axis=0).shape)
print(np.max(y, axis=1),np.max(y, axis=1).shape)
print(np.max(y, axis=2),np.max(y, axis=2).shape)

print("-----------------------------------------------------------------")
# （4）linspace
print(np.linspace(0,99,100)) # 在区间[0,99]中取100个数

print("-----------------------------------------------------------------")
# （5）sum求和 
x = np.random.randn(24)
y = x.reshape((2,3,4))
print(y.sum(axis=0))

print("-----------------------------------------------------------------")
# （5）mean求平均值
x = np.random.randn(24)
y = x.reshape((2,3,4))
print(y.mean(axis=0))

array运算，广播机制

# python 的广播机制,就是说如果格式不匹配，python会自动将其调整为合适的格式
x = np.array([1,2,3,4,5]) +3
print(x) # [4 5 6 7 8] = [1,2,3,4,5] + [3,3,3,3,3]

x = np.arange(12).reshape((3,4))
y = [1,1,1,1]
print(x+y) # 多维度也能广播，但是如果行和列都不匹配，除了整数，一般不能广播

x = np.arange(12).reshape((3,4))
y = [1,1,1]
# print(x+y) # ValueError: operands could not be broadcast together with shapes (3,4) (3,) 

矩阵的转置

# 方式一：
x = np.arange(12).reshape((3,4))
y = x.T
print(x.shape,y.shape)

#方式二：axes的取值表示轴的位置
# [1,0],表示1轴和零轴交换位置
# [0,2,1],表示二轴和一轴交换位置
y = np.transpose(x,axes=[1,0])
print(x.shape,y.shape)

矩阵的点乘

m1 = np.arange(24).reshape((4,6))
m2 = np.arange(24).reshape((6,4))
print(np.dot(m1,m2))

copy()深拷贝

x = np.arange(24).reshape((4,6))
y = x
y[0][0] = 123 # 两者指向的是同一个数据，所以y改了，x就会改
print(x,y)

# 解决方案1
x = np.arange(24).reshape((4,6))
y = x.copy()
y[0][0] = 123 # 两者指向的是同一个数据，所以y改了，x就会改
print(x,y)

# 解决方案2
x = np.arange(24).reshape((4,6))
y = np.array(x.tolist())
y[0][0] = 123 # 两者指向的是同一个数据，所以y改了，x就会改
print(x,y)

矩阵拼接

a = np.arange(12).reshape((3,4))
b = np.arange(8).reshape((2,4))

# vertical 垂直拼接
print(np.vstack((a,b)))

#horizon 水平拼接
a = np.arange(12).reshape((3,4))
b = np.arange(9).reshape((3,3))
print(np.hstack((a,b)))