2. Python之Numpy

Numpy简介

Numpy是一个开源的Python科学计算库，Numerical Python简写，主要功能之一是用来操作数组和矩阵，是科学计算、深度学习等高端领域的必备工具
这个工具可以用来存储和处理大型矩阵，比Python自身的嵌套列表(nested list structure)结构要高效的多
优点

1. 内置高端函数，比直接使用python编码更高效
2. 稳定性和可扩展性好，容易集成到其他语言
3. 核心算法使用C语言编写，执行效率更高
4. 开源、免费，有广泛的社区支持

数组

数组创建

import numpy as np
# 一维数组的创建
a = np.array([2,3,4],dtype= int32)
# 多维数组的创建
a = np.array([[1,2,3],[4,5,6]])
# 创建全零数组
a = np.zeros((2,4))
# 创建全零数组，指定数据类型
a = np.zeros((2,3),dtype=complex)
# 创建全一数组，并指定数据类型
a = np.ones((2,3),dtype = int32)
a = np.ones((2,3),dtype = complex)
# 创建全空数组，每个数接近于0
a = np.empty((2,5))
# 1-10步长为2 即创建连续数组[1,3,5,7,9]
a = np.arange(1,10,2)

数组相关属性

• ndim 维度
  维度是指一维、二维、三维等
• shape 这是一个整数的元组
  元组中的每一个元素对应着每一维度的大小(size)。
• size 元素个数

先来看一段代码

import numpy as np
a = np.array([1,2,3,4])
print(a.ndim)
print(a.shape)
b = np.array([[1,2,3],[4,5,6]])
print(b.ndim)
print(b.shape)
c = np.array([[[1,2,3],[4,5,6]],[[2,3,4],[5,6,7]]])
print(c.ndim)
print(c.shape)

来看下数组a，对于数组a来说 a.ndim=1,a.shape=(4,)
输出的元组(4,)，这里的4表示的是第一个维度中元素的大小（size）
来看下数组b，对于数组b来说，b.ndim=2,b.shape=(2,3)
元组(2,3) 说明这是一个二维数组，其中第一个维度含有2个元素，第二个维度中每一个元素都含有3个元素
对于numpy中数组的shape属性输出的元组，可以得到如下结构：

1. 元组的元素的个数等于维度数
2. 元组中每一个元素又代表中每一维度元素的个数（从左到右，依次为第一维度中元素的个数，第二维度中元素的个数…第n维度元素的个数）

数组的运算

import numpy as np
a = np.array([1,2,3,4])
b = np.arange(4)
print(a)
print(b)
# 对应相减
c1 = a - b
print(c1)
# 对应相乘
c2 = a * b
print(c2)
# 矩阵相乘
c3 = a.dot(b)
print(c3)
# 对应位置平方
c4 = b ** 2
print(c4)
# 数学函数求sin
c5 = np.sin(a)
print(c5)

# 创建两个多维矩阵
e = np.array([[1,2],[0,1]])
f = np.arange(4).reshape(2,2)
# 矩阵乘
c6 = e.dot(f)
print(c6)

# 创建2*4的随机矩阵
g = np.random.random((2,4))
print(g)
# 矩阵数的和
print(np.sum(g))
# 矩阵中最小的值
print(np.min(g))
# 矩阵中元素的平均值
print(np.mean(g))
# 按列进行求和
print(np.sum(g,axis=0))
# 按行进行求和
print(np.sum(g,axis=1))

数组的基本操作

# 创建一个3*4的矩阵，矩阵元素为2-13
h = np.arange(2,14).reshape((3,4))
print(h)
# 最小值元素索引
print(np.argmin(h))
# 最大值元素索引
print(np.argmax(h))
# 整个矩阵的均值
# np.mean直接计算平均数
print(np.mean(h))
print(h.mean())
# np.average计算加权平均数（如果有权重weight的话）
print(np.average(h))
# 中位数
print(np.median(h))
# 累加，每个位置的数是前面位置的和，计算轴向元素累加和，返回由中间结果组成的数组
print(np.cumsum(h))
# 累差运算，每行的后一个值减去前一个，然后放到一个新的数组里面
print(np.diff(h))

j = np.arange(14,2,-1).reshape(3,4)
print(j)
# 对每行进行递增排序
print(np.sort(j))
# 矩阵转置
print(j.T)
print(np.transpose(j))
# numpy.clip(a, a_min, a_max, out=None)[source]
# 其中a是一个数组，后面两个参数分别表示最小和最大值
# clip这个函数将将数组中的元素限制在a_min, a_max之间，大于a_max的就使得它等于 a_max，小于a_min,的就使得它等于a_min。
print(np.clip(j,5,9))

索引和切片相关的操作

import numpy as np
a = np.arange(2,14)
b = a.reshape(3,4)
print(b)
# 输出第二行
print(b[1])
# 输出第二行第二个元素
print(b[1][1])
# 输出第一行第二个和第三个元素
print(b[1,1:3])
# 输出第一行和第二行的第一个位置和第二个位置的元素
print(b[0:2,0:2])
# 多维数组变成一维
c = a.reshape(3,4).flatten()
print(c)

数组的合并

import numpy as np
a = np.array([[1,1,1],[2,2,2]])
b = np.array([[3,3,3],[4,4,4]])
print(a.shape)
print(b.shape)
# vertical stack 上下合并
c = np.vstack((a,b))
print(c.shape)
print(c)
# hstack() 左右合并
d = np.hstack((a,b))
print(d.shape)
print(d)
# 深度合并
e = np.dstack((a,b))
print(e.shape)

矩阵的合并

import numpy as np
a = np.array([[1,1,1],[2,2,2]])
b = np.array([[3,3,3],[4,4,4]])
# 纵向合并
c = np.concatenate((a,b),axis=0)
print(c)
# 横向合并
d = np.concatenate((a,b),axis=1)
print(d)

数组拆分

# 构造矩阵
a = np.arange(12).reshape(3,4)
# 沿横向轴拆分(axis=1)
b = np.hsplit(a,2)
c = np.split(a,4,axis=1)
# 沿纵向轴拆分(axis=0)
d = np.vsplit(a,3)
e = np.split(a,3,axis=0)

f = np.array([[1,2,3,4,5,6],[7,8,9,10,11,12]])
g = f * 20
# 深度合并
h = np.dstack((f,g))
# 深度拆分
i = np.dsplit(h,2)
print(i)

copy 与 =

• =赋值方式会带有关联性
• copy赋值方式没有关联性
  看代码解释

# =号赋值有关联性
a = np.arange(4)
b = a
# a中元素发生改变，b中元素也发生改变
a[0] = 11
print(a)
print(b)
# b中元素发生改变，a中元素也发生改变
b[1:3] = [11,12]
print(a)
print(b)

# copy()赋值没有关联性
c = np.arange(4)
d = c.copy()
c[3] = 22
print(c)
print(d)

广播机制

当数组跟一个标量进行计算时，标量需要根据数组的形状进行扩展，然后执行运算，该过程称为“广播”
广播的原则：如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符，或其中的一方的长度为1，则认为它们是广播兼容的。广播会在缺失和（或）长度为1的维度上进行。
广播主要发生在两种情况,

1. 数组维度不同，后缘维度的轴长相符
2. 数组维度相同，其中有个轴为1

import numpy as np
a = np.array([[0,0,0],[10,10,10],[20,20,20],[30,30,30]])
b = np.array([[0,1,2],[0,1,2]])
# a b 维度不一样，在进行计算的时候会将b进行广播后计算
print(a + b)
# b行重复4次，列重复1次
b = np.tile([0,1,2],(4,1))

b = np.array([[0,1,2],[0,1,2]])
c = np.tile(b,(2,1))
print(c)

常用函数

函数	作用
bincount()	计算索引出现的次数
argmax()	返回最大元素的位置
around()	近似取整
floor()	向上取整
ceil()	向上取整

首先看下bincount()函数

import numpy as np
# 看下bincount函数
# bin的数量比x中的最大值大1，每个bin给出了它的索引值在x中出现的次数
x = np.array([1,2,3,3,0,1,4,0])
# x中最大数是4，因此bin的数量是5，索引是0-4
print(np.bincount(x))
# 看下weights这个参数，如果weights参数被指定，那么x会被它加权，也就是说，如果值n发现在位置i，那么out[n] += weight[i]而不是out[n] += 1，因此，weights的大小必须与x相同
w = np.array([0.3,0.5,0.7,0.6,0.1,-0.9,1,0.2])
print(np.bincount(x,weights=w))
# 看一下minlength这个参数。文档说，如果minlength被指定，那么输出数组中bin的数量至少为它指定的数（如果必要的话，bin的数量会更大，这取决于x）
# 我们可以看到x中最大的数为3，因此bin的数量为4，那么它的索引值为0->3
x = np.array([3, 2, 1, 3, 1])
# 本来bin的数量为4，现在我们指定了参数为7，因此现在bin的数量为7，所以现在它的索引值为0->6
np.bincount(x, minlength=7)
# 因此，输出结果为：array([0, 2, 1, 2, 0, 0, 0])

# 我们可以看到x中最大的数为3，因此bin的数量为4，那么它的索引值为0->3
x = np.array([3, 2, 1, 3, 1])
# 本来bin的数量为4，现在我们指定了参数为1，那么它指定的数量小于原本的数量，因此这个参数失去了作用，索引值还是0->3
np.bincount(x, minlength=1)
# 因此，输出结果为：array([0, 2, 1, 2])

接着看下argmax()函数

# axis = 0表示对最外层[]里的最大单位块做块与块之间的运算,同时移除最外层[]
# axis= 1表示对第二外层[]里的最大单位块做块与块之间的运算,同时移除第二外层[]
import numpy as np
a = np.array([
              [
                  [1, 5, 5, 2],
                  [9, -6, 2, 8],
                  [-3, 7, -9, 1]
              ],

              [
                  [-1, 5, -5, 2],
                  [9, 6, 2, 8],
                  [3, 7, 9, 1]
              ]
            ])
print(np.argmax(a, axis=0))
print(np.argmax(a, axis=1))
print(np.argmax(a, axis=2))
print("--------")
print(np.sum(a, axis=0))
print(np.sum(a, axis=1))
print(np.sum(a, axis=2))

接下来看看around()、floor()、ceil()函数

import numpy as np
# decimals指定保留有效数字的位数
print(np.around([-0.6,1.2798,2.357,9.67,13],decimals=0))
print(np.around([-0.6,1.2798,2.357,9.67,13],decimals=1))
print(np.around([-0.6,1.2798,2.357,9.67,13],decimals=2))
# -1表示看最后一位数决定是否进位，大于5进位，小于5省去
print(np.around([-0.6,1.2798,2.357,9.67,13],decimals=-1))
# -2表示看最后两位数决定是否进位，大于50进位，小于50省去
print(np.around([-0.6,1.2798,2.357,9.67,13],decimals=-2))

# 向下取整
print(np.floor([-0.6,1.2798,2.357,9.67,13]))
# 向上取整
print(np.ceil([-0.6,1.2798,2.357,9.67,13]))

import numpy as np

def get_closer_number(num):
    number_list = np.random.uniform(0,1,10)
    pos = np.argmin((number_list - num) ** 2)
    return number_list[pos]
print(get_closer_number(0.5))