numpy学习笔记和心得

numpy的运算机制：这个概念叫做广播机制（broadcasting），它非常有用。

1. numpy基本加减和取行操作
2. 矩阵删除、插入、尾部添加操作(delete,insert,append)
3. delete()函数
4. insert()函数
5. append()函数
6. np.random.choice(a, size, replace, p)
7. np.argmax(a, axis=None, out=None)
8. 星号(*)的作用
9. ndarray.ndim代表的就是shape元组的长度。
10. numpy.linspace用法
11.拉平操作 ravel()和faltten()及reshape(1,-1)的区别联系(补充[None,:]操作)
12.np.prod() 计算元素乘积
13.把矩阵大于或小于N的元素置M的技巧
14. numpy中的矩阵copy问题
15. np.zeros_like()构造全零矩阵，无需指定大小
random.rand和random.rand和random.randint区别
np.random.random() 生成一个随机数
np.random.uniform()
np.random.rand() 生成均匀分布矩阵
np.random.randn() 生成正太分布矩阵
np.randm.randint() 生成离散均匀分布的整数值组成的矩阵
python 断言 assert
星号( * ) 和 .dot 和 np.multiply 的区别联系
np.pad()函数进行padding操作
numpy.empty() 创建指定形状和数据类型且未初始化的数组
判断两个矩阵元素完全相等&&存在相等
关于 np.mat() 的使用
np.full 用于形成元素全为某元素的矩阵
astype 转换数据类型
np.meshgrid() 快速生成网格
np.hstack() 和 np.vstack() 用于堆叠矩阵
numpy 取整
np.newaxis 在特定位置增加一个维度
python 广播机制
numpy.transpose()转置
numpy 中双冒号的用法
 

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 为想要插入的维

举例如下

import numpy as np
matrix = [
[1,2,3,4],
[5,6,7,8],
[9,10,11,12]
]
q1 = np.insert(matrix, 1, [1,1,1,1], 0) # 第0维度(行)第1行添加[1,1,1,1]
print(’>>>>q1>>>>\n’,q1)
q2 = np.insert(matrix, 0, [1,1,1], 1) # 第1维度(列)第0列添加1,1,1
print(’>>>>q2>>>>\n’,q2)
q3 = np.insert(matrix, 3, [1,1,1,1], 0) # 第0维度(行)第3行添加[1,1,1,1]
print(’>>>>q3>>>>\n’,q3)
 

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

import numpy as np
matrix = [
[1,2,3,4],
[5,6,7,8],
[9,10,11,12]
]
m1 = np.append(matrix,[[1,1,1,1]],axis=0)

第0维度(行)尾部添加[[1,1,1,1]],注意两个[],相同维度
print(’>>>>m1>>>>\n’,m1)
m2 = np.append(matrix,[[1],[1],[1]],axis=1)

第1维度(列)尾部添加[[1],[1],[1]],注意两个[],相同维度
print(’>>>>m2>>>>\n’,m2)
m3 = np.append(matrix,[1,1,1,1])

拉平后再尾部添加[1,1,1,1]，这里可以[[1,1,1,1]]和[1,1,1,1]均可
print(’>>>>m3>>>>\n’,m3)
 

np.zeros_like()构造全零矩阵，无需指定大小
复制矩阵的维度，但是元素全是0

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]])
1
2
3
4
5

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

np.random.uniform()

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

import numpy as np
n = np.random.rand(3,4)
n
array([[0.11502462, 0.3503468 , 0.6206656 , 0.35172063],
[0.66367565, 0.10195004, 0.22708003, 0.9318615 ],
[0.77946053, 0.81804715, 0.2272248 , 0.17736476]])

np.random.randn() 生成正太分布矩阵
创建一个矩阵，服从N(0,1)标准正太分布。
一般正太分布N = ( μ , σ 2 ) N=(\mu ,\sigma^2)N=(μ,σ 2 )可通过 sigma * np.random.randn(…) + m 实现

import numpy as np
x = np.random.randn(2,3)
x
array([[-0.09382672, -0.97939614, 0.0222352 ],
[ 0.15060188, -0.01107968, 1.08374427]])

y = np.multiply(0.1,np.random.randn(2,3))+0.5 # 一般正太分布
y
array([[0.49305173, 0.36802044, 0.48699281],
[0.45197275, 0.53837051, 0.60022348]])

np.randm.randint() 生成离散均匀分布的整数值组成的矩阵
numpy.random.randint(low,high=None,size=None,dtype)
生成半开半闭区间[low, high)上离散均匀分布的整数值，未给出high时，区间变为[0, low)

import numpy as np
z = np.random.randint(2,9,(2,3))
z
array([[2, 3, 6],
[8, 2, 8]])

m = np.random.randint(9,size = (2,3))
m
array([[4, 0, 2],
[5, 2, 8]])

python 断言 assert
x = ‘You are right’
type(x)
<class ‘str’>

assert type(x)==str, ‘x is not str’
x = [1,2,3]
type(x)
<class ‘list’>

assert type(x)==str, ‘x is not str’
Traceback (most recent call last):
File “”, line 1, in
AssertionError: x is not str
 

np.pad()函数进行padding操作
语法：

pad(array, pad_width, mode, **kwargs)返回值：数组

参数解释：

array——表示需要填充的数组；
pad_width——表示每个轴（axis）边缘需要填充的数值数目。
参数输入方式为：（(before_1, after_1), … (before_N, after_N)），其中(before_1, after_1)表示第1轴两边缘分别填充before_1个和after_1个数值。取值为：{sequence, array_like, int}
mode——表示填充的方式（取值：str字符串或用户提供的函数）,总共有11种填充模式；

填充方式：

‘constant’——表示连续填充相同的值，每个轴可以分别指定填充值，constant_values=（x, y）时前面用x填充，后面用y填充，缺省值填充0
‘edge’——表示用边缘值填充
‘linear_ramp’——表示用边缘递减的方式填充
‘maximum’——表示最大值填充
‘mean’——表示均值填充
‘median’——表示中位数填充
‘minimum’——表示最小值填充
‘reflect’——表示对称填充
‘symmetric’——表示对称填充
‘wrap’——表示用原数组后面的值填充前面，前面的值填充后面

#在数组A的边缘填充constant_values指定的数值
#（3,2）表示在A的第[0]轴填充（二维数组中，0轴表示行），即在0轴前面填充3个宽度的0，比如数组A中的95,96两个元素前面各填充了3个0；在后面填充2个0，比如数组A中的97,98两个元素后面各填充了2个0
#（2,3）表示在A的第[1]轴填充（二维数组中，1轴表示列），即在1轴前面填充2个宽度的0，后面填充3个宽度的0
np.pad(A,((3,2),(2,3)),‘constant’,constant_values = (0,0)) #constant_values表示填充值，且(before，after)的填充值等于（0,0）
 

判断两个矩阵元素完全相等&&存在相等
(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
 

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

记着 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]])
>>> c[np.newaxis,:]
array([[1, 2, 5, 4]])
 

Numpy要求输入的数组shape一致，当shape不一致的时候，则会使用广播机制，调整数组的shape一致，否则出错。
广播的原则：如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符，或其中的一方的长度为1，则认为它们是广播兼容的。广播会在缺失和（或）长度为1的维度上进行。

这句话乃是理解广播的核心。广播主要发生在两种情况，一种是两个数组的维数不相等，但是它们的后缘维度的轴长相符，另外一种是有一方的长度为1。
 

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

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

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

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

4、当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值
————————————————
版权声明：本文为CSDN博主「PhyiscsLogical」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/phyiscslogical/article/details/119982566

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
a = np.array([[1,2,3,6],[4,5,6,6]])
a1 = a.reshape((1,2,4))
a1
array([[[1, 2, 3, 6],
[4, 5, 6, 6]]])

b = np.array([[3,4,5,6],[1,2,3,4],[4,5,5,5]])
b
array([[3, 4, 5, 6],
[1, 2, 3, 4],
[4, 5, 5, 5]])

b1 = b.reshape((1,3,4)).transpose((1,0,2))
b1
array([[[3, 4, 5, 6]],

   [[1, 2, 3, 4]],

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

a1+b1
array([[[ 4, 6, 8, 12],
[ 7, 9, 11, 12]],

   [[ 2,  4,  6, 10],
    [ 5,  7,  9, 10]],

   [[ 5,  7,  8, 11],
    [ 8, 10, 11, 11]]])
1
2
3
4
5
上面这个例子中，a1 是 [1,2,4] 维度的数组，b1 是 [3,1,4] 维度的数组，可以如此理解，他们相加后由于广播机制的作用应该生成 [3,2,4] 大小的数组。那么我们将 a1 扩展成 [3,2,4] 成

[[[1, 2, 3, 6],
[4, 5, 6, 6]],
[[1, 2, 3, 6],
[4, 5, 6, 6]],
[[1, 2, 3, 6],
[4, 5, 6, 6]]]

将 b1 扩展成 [3,2,4] 成

[[[3, 4, 5, 6],
[3, 4, 5, 6]],
[[1, 2, 3, 4],
[1, 2, 3, 4]],
[[4, 5, 5, 5],
[4, 5, 5, 5]]]

扩展后的 a1 和 b1 相加得到

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

即为通过广播机制相加的结果。
 

numpy.transpose()转置
transpose()是以交换维度的方式进行转置。如

c = np.array([[[1,2,5],[3,4,6]],[[4,5,6],[7,8,9]]])
c
array([[[1, 2, 5],
[3, 4, 6]],

   [[4, 5, 6],
    [7, 8, 9]]])
1
2
c.transpose(1,0,2) # 将c的维度按照 第1维度，第0维度，第2维度的排序排成 第0,1,2维度
array([[[1, 2, 5],
[4, 5, 6]],
 

如原来的 4 （4,5,6的4）本是 (1,0,0), 转换后变为 (0,1,0)

c.transpose(1,2,0) # 将c的维度按照 第1维度，第2维度，第0维度的排序排成 第0,1,2维度
array([[[1, 4],
[2, 5],
[5, 6]],
 

常用来对 numpy 图片矩阵作转换

在opencv中，图片格式为 H W C，即长宽和维度，而一般图像处理的时候习惯用 C H W，故可以用 transpose 对维度进行变换
img = cv2.imread(“111.jpg”)
img_ = img[:,:,::-1] # cv2 读取的是 BGR，::-1 将C通道按照RGB取反
img_convet = img_.transpose((2,0,1)) # 将 H W C 转为 C H W

numpy 中双冒号的用法
numpy 中 ndarray 对象内容可以索引或切片来访问和修改。可以通过 start:stop:step 来进行切片操作
import numpy as np
a = np.array([2,2,3,4,5,5,6,7])
a[0:7:2]
array([2, 3, 5, 6])

而双冒号实则是两个冒号之间缺省了必要的值，它省略的是 stop 值，那么 stop 值就默认尾部

import numpy as np
a = np.array([2,2,3,4,5,5,6,7])
a[0::2]
array([2, 3, 5, 6])

除了一般的切片用法，也常用 [::-1] 来将序列按倒序排列。

一般而言，python 的内置函数 slice 就实现了此功能，用法是 slice(start, stop, step)。

import numpy as np
a = np.array([2,2,3,4,5,5,6,7])
s = slice(0,7,2)
a[s]
array([2, 3, 5, 6])