(8) python numpy

作者: 小黄不头秃 | 来源:发表于2022-10-23 02:51 被阅读0次

(一)numpy 简介

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

一个强大的N为数组对象 ndarray
广播的功能
整合 C/C++/Fortran 代码的工具
线性代数，傅里叶变换，随机数生成等功能

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

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

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

N维数组对象 ndarray

有一个只想数据的指针，同类型的数据集合，多维数组
每个元素在内存中都有相同的存储空间
具有矢量计算能力
对象连续存储，查询效率高

import numpy as np

x1 = np.array([[],[]])
print(x1.ndim) # 2
print(x1.size) # 0

x2 = np.array([1,2,3],ndmin=5, dtype=np.float32)
print(x2, x2.ndim) # [[[[[1. 2. 3.]]]]] 5
print(x2.size) # 3

x3 = np.arange(24).reshape(1,4,6)
print(x3)
print(x3.ndim,x3.size,x3.shape) # 3 24 (1, 4, 6)

x4 = x3.transpose(0,2,1) # 将第一维和第二维转换
print(x4.ndim,x4.size,x4.shape) # 3 24 (1, 6, 4)
x5 = np.resize(x3,(6,4))
print(x5.ndim,x5.size,x5.shape) # 2 24 (6, 4)

x9 = np.array([1,2,3],dtype=np.string_)
print(x9) # [b'1' b'2' b'3']
y9 = x9.astype(np.uint8)
print(y9) # [1 2 3]

print(np.array([1,2,3],dtype=np.bytes_)) # [b'1' b'2' b'3']
print(np.array([1,2,3],dtype=np.str)) # ['1' '2' '3']

list 和 array之间的转换


# 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) # 生成空矩阵，但是他不是真正的空，他主要看前面的矩阵是什么类型的就生成什么类型的。如果前面没有的话，就生成随机的。
eyes = np.eye(4,4,dtype=np.int32) # 生成对角矩阵

print(ones,zeros,nulls,eyes)

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("-----------------------------------------------------------------")
# （6）mean求平均值
x = np.random.randn(24)
y = x.reshape((2,3,4))
print(y.mean(axis=0))

print("-----------------------------------------------------------------")
# (7) power求指数
x = np.array([1,2])
y = np.power(x,2)
print(x, y) # [1 2] [1 4]

print("-----------------------------------------------------------------")
# (8) subtract 求差
x = np.array([1,2])
y = np.array([4,5])
print(np.subtract(x,y)) # [-3 -3]

print("-----------------------------------------------------------------")
# （9）divide 求商
x = np.array([1,2])
y = np.array([4,5])
print(np.divide(x,y)) # [0.25 0.4 ]

print("-----------------------------------------------------------------")
# （10）multiply 求点乘
x = np.array([1,2])
y = np.array([4,5])
print(np.multiply(x,y)) # [ 4 10]

print("-----------------------------------------------------------------")
# （11）add 求和
x = np.array([1,2])
y = np.array([4,5])
print(np.add(x,y)) # [5 7]

print("-----------------------------------------------------------------")
# (12)统计函数
x = np.arange(12).reshape(3,4)
print(np.amax(x)) # 11
print(np.amax(x,axis=0)) # [ 8  9 10 11]
print(np.amax(x,axis=1)) # [ 3  7 11]
print(np.amin(x)) # 0
print(np.amin(x,axis=0)) # [0 1 2 3]
print(np.amin(x,axis=1)) # [0 4 8]
print(np.nonzero(x)) # (array([0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
print(np.sort(x)) # 升序
print(np.sort(x)[::-1]) # 降序

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)

# 解决方案3
x5 = np.arange(10)
x6 = x5.view()
x7 = x5
x8 = x5.copy()
print(id(x5), id(x6), id(x7), id(x8)) # 2324684169424 2324684173104 2324684169424 2324684235040

矩阵拼接

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