Numpy入门练习与理解20210903

Numpy入门练习与理解

目录索引

一、灵活的Array

二、广播机制

三、数组拆分

四、取行操作

五、矩阵删除、插入、尾部添加操作(delete,insert,append)

六、按要求生成数组和计算成绩

七、返回轴的最大值的索引值

八、星号(*)的作用与乘法之间的区别

九、拉平操作 ravel()和faltten()及reshape(1,-1)的区别联系(补充[None,:]操作)

十、把矩阵大于或小于N的元素置M的技巧

十一、几种random生成随机数的区别

十二、numpy.empty() 创建指定形状和数据类型且未初始化的数组

十三、判断两个矩阵元素完全相等&&存在相等

十四、关于 np.mat() 和np.full()的使用¶

十五、堆叠矩阵np.hstack() 和 np.vstack()

十六、numpy 取整与特定位置增加维度

---

一、灵活的Array

Array数组的创建与运算非常便捷。

创建数组时候的注意事项:
a.输入的数组要工整，否则会出现后续一系列处理问题。 虽然创建的过程不会提示出错。如果创建的对象不工整，建议选择创建列表对象。
b.输入数组里面的元素最好是同一类型，如果不是同一类型，最好指dtype=“object”,否则如果既不是同一类型，又没有指定数组类型为object,那么生成数组之后可能被强制转化为字符串。

import numpy as np
date = np.array([1,2,3])
ones = np.ones(3)
print(ones)
print(date + ones)

date.max()

[1. 1. 1.]
[2. 3. 4.]





3

二、广播机制

broadcasting可以这样理解：如果你有一个m×n的矩阵1，让它加减乘除一个1×n的矩阵2，矩阵2会被复制m次，成为一个m×n的新矩阵，然后再逐元素地进行加减乘除操作。同样地对m×1的矩阵成立。当然，对应运算均为位与位之间的运算。广播主要发生在两种情况，一种是两个数组的维数不相等，但是它们的后缘维度的轴长相符，另外一种是有一方的长度为1。

广播机制的四条规则如下：

1、让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐

2、输出数组的shape是输入数组shape的各个轴上的最大值

3、如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错

4、当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值

a = np.array([1,1,1,1])
b = np.array([[1],[1],[1],[1]])
a+b
# 这叫python的广播机制

array([[2, 2, 2, 2],
       [2, 2, 2, 2],
       [2, 2, 2, 2],
       [2, 2, 2, 2]])

三、数组拆分

垂直拆分：numpy.vsplit(数组，份数)->(数组片段)

水平拆分：numpy.hsplit(数组，份数)->(数组片段)

numpy.dsplit(数组，份数)->(数组片段)

 c = np.arange(1,13).reshape(6,2)
 print(c)
np.vsplit(c,3)

[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]





[array([[1, 2],
        [3, 4]]),
 array([[5, 6],
        [7, 8]]),
 array([[ 9, 10],
        [11, 12]])]

d =c.T
print(d)
np.hsplit(d,3)

[[ 1  3  5  7  9 11]
 [ 2  4  6  8 10 12]]





[array([[1, 3],
        [2, 4]]),
 array([[5, 7],
        [6, 8]]),
 array([[ 9, 11],
        [10, 12]])]

dstack是轴2合并。dstack([a,b])把a和b摞在一起，像摞扑克牌一样。

a = np.array([1,2,3,4])
b = np.array([5,6,7,8])
e = np.dstack((a,b))
print(e)
np.dsplit(e,2)

[[[1 5]
  [2 6]
  [3 7]
  [4 8]]]





[array([[[1],
         [2],
         [3],
         [4]]]),
 array([[[5],
         [6],
         [7],
         [8]]])]

四、取行操作

W = np.array([[1,1,1],[2,2,2]])
W[:,1]
 # W[:,1]取的是W的第一列，返回的是一维数组

array([1, 2])

W[1]
# 取的是W第一行，返回的也是一维数组

array([2, 2, 2])

W[:,1] = np.array([5,5])
W
 # 这里用array[5,5]这样的一维数组直接可以把W矩阵的第1列替换(维度符合即可)

array([[1, 5, 1],
       [2, 5, 2]])

五、矩阵删除、插入、尾部添加操作(delete,insert,append)

numpy矩阵操作主要有delete()、insert()、append()等函数，分别执行删除、插入和添加的操作，注意append可以看为insert函数的特殊情况，即在尾部补充可以看为插入最后一行或列。

delete()函数：

numpy.delete(arr,obj,axis=None)
axis 表明哪个维度的向量应该被移除
axis 如果为None，则需要先将矩阵拉平，在删去第obj的元素
obj 表明axis维度的哪一行(或列)应该被移除。

insert()函数

#numpy.insert(arr,obj,value,axis=None)
#value 为插入的数值
#arr 为目标向量
#obj 为目标向量的axis维度的目标位置
#axis 为想要插入的维

append()函数

#numpy.append(arr,values,axis=None)
#将values插入到目标arr的最后，其中values与arr应该有相同维度。

六、按要求生成数组和计算成绩

np.random.choice(a, size, replace, p)

其作用是按要求生成一个一维数组
a是生成一维数组的来源，可以是int类型，可以是数组，也可以是list
size 数组的维度replace 表示从a中是否不重复抽取，默认可重复 p 给出抽取概率，默认随机
注意 ：这里是围绕数组展开的，如果提取的也是list，可以用 from random import choice 的 choice，可用 from random import sample 随机抽取一组元素

np.prod() 计算元素乘积

默认计算矩阵所有元素的乘积，也可以通过axis计算指定轴的乘积

import numpy as np
a1 = np.random.choice(7,5) # 从0~7中随机选择5个数组成一维数组
a1

array([2, 2, 4, 2, 3])

a2 = np.random.choice([0,1,2,3,4,5,6],5) # 从给定list中随机选择5个数组成一维数组
a2

array([2, 2, 1, 0, 5])

x = np.array([[1,2,3],[2,3,4]]) #计算元素乘积
np.prod(x)

144

七、返回轴的最大值的索引值

np.argmax(a, axis=None, out=None)

a：需要操作的数组或者矩阵，默认情况拉平成数组
axis：默认将a拉平，当axis=0对a按列取最大值索引，axis=1则对a按行取最大值索引
out：将结果写到a中

import numpy as np
a = np.array([[1,1,1],[2,2,2],[0,3,6]])
b1 = np.argmax(a, axis=0) # 按列选取最大值的索引
b1

array([1, 2, 2], dtype=int64)

b2 = np.argmax(a, axis=1) # 按行选取最大值的索引
b2

array([0, 0, 2], dtype=int64)

八、星号(*)的作用与乘法之间的区别

星号( * ) 和 .dot 和 np.multiply 的区别联系
A * B 表示 A 和 B 的对应元素相乘，其中 A 和 B 大小一致
np.multiply 与星号用法一致，均表示对应元素相乘
而 .dot 是矩阵运算中的点乘， A 的列数需要等于 B 的行数。

列表前加星号作用是将列表解开成两个独立的参数，输入函数。
字典前加两个星号，是将字典解开成独立的元素作为形参。

九、拉平操作 ravel()和faltten()及reshape(1,-1)的区别联系(补充[None,:]操作)

都是对numpy矩阵进行拉平处理，区别在于flatten()返回的仅仅是copy值，而ravel()返回的是实际的值，有点返回地址的意思。而x.reshape(1,-1)表示把向量 x reshape成一个行向量，注意的它仍然保持x的维度。
另外，Numpy中的 一维向量 有个特殊的用法，将行或者列设置成None，用来将矩阵转换成行或者列。偶尔会看到np.newaxis，这与None用法一致。

import numpy as np
x = np.array([[1,2,3],[4,5,6],[1,2,3]])
x.flatten()

array([1, 2, 3, 4, 5, 6, 1, 2, 3])

x[:,None] # 转成列向量(二维矩阵)***

array([[[1, 2, 3]],

       [[4, 5, 6]],

       [[1, 2, 3]]])

十、把矩阵大于或小于N的元素置M的技巧

包括 maximum() 函数 、minimum() 函数，以及 矩阵操作的技巧

import numpy as np
x = np.array([[1,2,3],[-3,2,4],[5,-2,9]])
x

array([[ 1,  2,  3],
       [-3,  2,  4],
       [ 5, -2,  9]])

y1 = np.maximum(0,x) # 把小于0的元素置0，不改变x的值
y1

array([[1, 2, 3],
       [0, 2, 4],
       [5, 0, 9]])

y2 = np.minimum(0,x) # 把大于0的元素置0，不改变x的值
y2

array([[ 0,  0,  0],
       [-3,  0,  0],
       [ 0, -2,  0]])

不可变对象： 该对象所指向的内存中的值不能被改变。当改变某个变量的时候，由于其所指的值不能被改变，相当于把原来的值复制一份后再改变，这会开辟一个新的地址，变量再指向这个地址。
不可变对象包括 int string float tuple None
可变对象： 该对象所指向的内存中的值可以被改变。变量（准确说是引用）被改变后，实际上是其所指的值直接发生改变，并没有发生复制行为，也没有开辟新的地址，通俗点说就是原地改变。
可变对象包括 list dictionary set
numpy的narray用法就类似于可变对象，直接等于并不会开辟新的地址，改变赋值对象也就改变了原来的值。

import numpy as np
x = np.array([[1,2,3],[-3,2,4],[5,-2,9]])
x1 = x.copy()  #矩阵copy问题
x1

array([[ 1,  2,  3],
       [-3,  2,  4],
       [ 5, -2,  9]])

x1 = x.copy() # copy()，开辟新地址
x1[x1 > 0] = 0
x1

array([[ 0,  0,  0],
       [-3,  0,  0],
       [ 0, -2,  0]])

x2 = x # 直接等于，未开辟新地址，x2与x相关联
x2

array([[ 1,  2,  3],
       [-3,  2,  4],
       [ 5, -2,  9]])

x = np.array([[1,2,3],[-3,2,4],[5,-2,9]])
x3 = x[2] # 取x的第3行
x3

array([ 5, -2,  9])

x3[2] = 100 # 将x3第3个元素置100
x # x中对应的元素置也被置成100了

array([[  1,   2,   3],
       [ -3,   2,   4],
       [  5,  -2, 100]])

np.zeros_like()构造全零矩阵，无需指定大小

import numpy as np
x = np.array([[1,2,3],[4,5,6]])
np.zeros_like(x) # 生成一个和x大小相同的全零矩阵

array([[0, 0, 0],
       [0, 0, 0]])

十一、几种random生成随机数的区别

np.random.random() 生成一个随机数，产生 0~1 之间的随机浮点数，无输入参数

np.random.uniform()产生随机浮点数

np.random.rand() 生成均匀分布矩阵，创建一个矩阵，服从[0,1]随机分布

np.random.randn() 生成正太分布矩阵

np.randm.randint() 生成离散均匀分布的整数值组成的矩阵

十二、numpy.empty() 创建指定形状和数据类型且未初始化的数组

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组

numpy.empty(shape, dtype = float, order = ‘C’)
1
shape数组形状
dtype数据类型，可选
order有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。

十三、判断两个矩阵元素完全相等&&存在相等

(ab).all() 判断是否完全相等
(ab).any() 判断是否存在元素相等

a = np.array([[1,2,3][1,2,3]])
b = np.array([[1,2,3][1,2,3]])
c = np.array([[1,4,3][1,2,3]])
print((ab).all()) # 是否完全相等 True
print((ac).all()) # False
print((a==c).any()) # 是否存在元素相等 True

十四、关于 np.mat() 和np.full()的使用

np.array() 更具有通用性，np.mat 只适用于二维矩阵
np.mat() 和 np.matrix() 都可以将 list 转换为 numpy.matrix 类型的矩阵，而 np.array() 不行

np.full 用于形成元素全为某元素的矩阵
np.full(shape, val): 生成形为 shape 的元素全为 val 的矩阵

astype 转换数据类型

import numpy as np
c = np.array([[1,2],[3,4]])
c.astype(np.float32)

array([[1., 2.],
       [3., 4.]], dtype=float32)

十五、堆叠矩阵np.hstack() 和 np.vstack()

注意下面的 M 是 tuple 形式，如 (x,y)，x和y均为 np.array 形式的矩阵
np.vstack(M) 用于沿着竖直方向将矩阵堆叠起来
np.hstack(M) 用于沿着水平方向将矩阵堆叠起来

import numpy as np
x = np.array([[3,4,5],[1,3,4]])
y = np.array([[1,1,1],[2,2,2]])
np.hstack((x,y)) # 水平堆叠

array([[3, 4, 5, 1, 1, 1],
       [1, 3, 4, 2, 2, 2]])

np.vstack((x,y)) # 竖直堆叠

array([[3, 4, 5],
       [1, 3, 4],
       [1, 1, 1],
       [2, 2, 2]])

十六、numpy 取整与特定位置增加维度

np.round 和 np.around 一致，均是四舍五入运算，默认取整，可通过 decimals 调整小数位数
np.floor 是向下取整操作
np.ceil 是向上取整操作

import numpy as np
a = np.array([0.125,0.568,5.688])
np.round(a) # 四舍五入取整， np.around 和 round 用法一致

array([0., 1., 6.])

np.round(a,decimals = 2) # 四舍五入保留2位小数

array([0.12, 0.57, 5.69])

np.floor(a) # 向下取整

array([0., 0., 5.])

np.ceil(a) # 向上取整

array([1., 1., 6.])

np.newaxis 在特定位置增加一个维度
记着 c[:,np.newaxis] 是将矩阵c再加一个维度，如果c是一维的，那么这个表达式是将 c 变成列向量， c[np.newaxis,:] 是将矩阵 c 变成行向量。

import numpy as np
c = np.array([1,2,5,4])
c[:,np.newaxis]

array([[1],
       [2],
       [5],
       [4]])