文章目录

• 1.argmax()函数
• 2.**numpy.random.choice**（）
• 3.shape[0]
• • 而对于矩阵来说：
• 4.ndim
• 5、axis=0
• • • 一维数组
    • 二维数组
    • 三维数组
• 6、np.reshape(-1)、np.reshape(-1, 1)、np.reshape(1, -1)详解
• 7、items(）
• 8、np.zeros_like（）
• 9、np.sqrt()

1.argmax()函数

语法格式：

numpy.argmax(a,axis)

作用：返回axis轴方向最大值的索引

a ：为所需处理的矩阵

axis ：为处理的轴向，axis=1为横轴方向，方向从左到右；axis=0为纵轴方向，方向从上到下

一维数组：

>>> a=np.array([1,2,3,4,5])
>>> print(np.argmax(a))
4

二维数组：

>>> b=np.array([[1,0,6,4],[9,8,2,3],[3,1,2,7]])
>>> print(np.argmax(b,axis=0))
[1 1 0 2]
>>> print(np.argmax(b,axis=1))
[2 0 3]

2.numpy.random.choice（）

用法：需要引用numpy库

numpy.random.choice(a, size=None, replace=True, p=None)

import numpy as np
numpy.random.choice(a, size=None, replace=True, p=None)

**用途：**从a(一维数据)中随机抽取数字，返回指定大小(size)的数组

**replace:**True表示可以取相同数字，False表示不可以取相同数字

数组p：与数组a相对应，表示取数组a中每个元素的概率，默认为选取每个元素的概率相同。

import numpy as np
 
pa = [0.3, 0.2, 0.1, 0.1, 0.3]
pa=np.array(pa)
 
a = np.random.choice(np.arange(5), size=5, replace=True, p=pa)
print(a) #[3 4 1 3 0]

3.shape[0]

在深度学习代码中遇到的问题-shape[0]、shape[1]、shape[2]的区别

对于图像来说：

​ img.shape[0]：图像的垂直尺寸（高度）

​ img.shape[1]：图像的水平尺寸（宽度）

​ img.shape[2]：图像的通道数

举例来说，下面是一张300X534X3的图像，

import matplotlib.image as mpimg  # mpimg 用于读取图片
 
if __name__ == '__main__':
    img = mpimg.imread('cat.jpg')  # 读取和代码处于同一目录下的 img.png
    # 此时 img 就已经是一个 np.array 了，可以对它进行任意处理
    print(img.shape)  #(300, 534, 3)
    print(img.shape[0])
    print(img.shape[1])
    print(img.shape[2])


(300, 534, 3)
300
534
3

而对于矩阵来说：

    shape[0]：表示矩阵的行数

    shape[1]：表示矩阵的列数

举例如下：

  import numpy as np
 
if __name__ == '__main__':
    w = np.array([[1, 2, 3], [4, 5, 6]])  # 2X3的矩阵
    print(w.shape)
    print(w.shape[0])
    print(w.shape[1])

(2, 3)
2
3

运行结果如下：

由此证明，上述结果是没有问题的。

4.ndim

ndim表示数组的维度，很明显，a是一个1行三列的数组，即1×3，在维度中，1是可以忽略的，即1x1x2的数组跟1×2的数组是一样的，所以，a是一维数组。

再来看b，b是一个2行3列的数组，也就是2×3，这是二维，没错。

再看c， c是一个3行3列的数组， 即3×3， 3×3依旧是二维哦，4×3, 5×4都是二维

到d的时候，我们发现d是一个2行3列但高为4的数组， 即2x3x4，这是3维数组。

a

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

b

array([[ 1.5, 2. , 3. ],

[ 4. , 5. , 6. ]])

c

array([[ 0., 0., 0., 0.],

[ 0., 0., 0., 0.],

[ 0., 0., 0., 0.]])

a.ndim

1

b.ndim

2

c.ndim

2

5、axis=0

实例

一维数组

# axis=0
#第一步：axis=0对应最外层[]，其内最大单位块为：1，2，3，并去掉[]
#第二步：单位块是数值，直接计算：1+2+3=6
>>> import numpy as np
>>> arr = np.array([1, 2, 3])
>>> arr.sum(axis = 0)
6

#axis=1  即：N维数组，最大能使用axis=N-1
>>> arr = np.array([1, 2, 3])
>>> arr.sum(axis = 1)  # 越界使用，报错

二维数组

#axis=0
#第一步：axis=0对应最外层[]，其内最大单位块为：[1，2] 和 [3，4]，并去掉最外层[]
#第二步：单位块是数组，两者对应下标元素进行计算，即：[1+3，2+4]=[4，6]
>>> arr = np.array([[1, 2], [3, 4]])
>>> arr.sum(axis = 0)
array([4, 6])

#axis=1
#第一步：axis=1对应第二层[]，其内最大单位块为：第一[]内： 1，2；第二[]内： 3，4，并去掉第二层[]
#第二步：单位块是数值，直接进行计算，即：[1+2，3+4]=[3，7]
>>> arr = np.array([[1, 2], [5, 6]])
>>> arr.sum(axis = 1)
array([3, 11]

三维数组

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

       [[5, 6],
        [7, 8]]])
>>> arr.sum(axis=0)
array([[ 6,  8],
       [10, 12]])


>>> arr = np.array([[[1, 2],[3, 4]], [[5, 6],[7, 8]]])
>>> arr.sum(axis=1)
array([[ 4,  6],
       [12, 14]])

>>> arr = np.array([[[1, 2],[3, 4]], [[5, 6],[7, 8]]])
>>> arr.sum(axis=2)
array([[ 3,  7],
       [11, 15]])

第一步：axis=1对应第三层[]，其内最大单位块为：第一个[]：1，2；第二个[]：3，4；第三个[]：5，6；第四个[]：7，8，并去掉第三层[]
第二步：单位块是数值，直接进行计算，即：[[1+2，3+4]，[5+6，7+8]] = [[3，7]，[11，15]]

Python的numpy中axis=0、axis=1、axis=2解释

numpy数组中：

• 一维数组拥有一个轴：axis=0；
• 二维数组拥有两个轴：axis=0，axis=1；
• 三维数组拥有三个轴：axis=0，axis=1，axis=2。
• 四维数组拥有三个轴：axis=0，axis=1，axis=2，axis=3。

2 数组维度

可以从左至右计算数组的方括号数目，一个方括号是一维数组，两个方括号是二维数组，三个方括号是三维数组。

如： [1, 2, 3]是一维数组、

[[1, 2, 3], [4, 5, 6]]是二维数组、

[ [[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]] ] 是三维数组。

0.3 axis(轴)与数组括号的对应关系

numpy数组都有[]标记，其对应关系：axis=0对应最外层的[]，axis=1对应第二外层的[]，…，axis=n对应第n外层的[]。

6、np.reshape(-1)、np.reshape(-1, 1)、np.reshape(1, -1)详解

np.reshape()规范：新的排布(shape)应与原始排布兼容

-1它指的是未知的维数

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

orginal.shape # (2, 4)

new_1 = orginal.reshape(-1)
print(new_1) # 新排布为（1，8）

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



# 设定新排布的列数为1，行数为未知
new_2 = orginal.reshape(-1, 1)
print(new_2)  # 新排布为（8，1）

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


# 设定新排布的行数为1，列数为未知
new_3 = orginal.reshape(1, -1)
print(new_3)  # 新排布为（1，8）
array([2, 4, 1, 3, 1, 2, 5, 2])

7、items(）

items():遍历字典中所有的key 以及value， items():遍历字典中所有的key 以及value返回“key，value"

def hello(**kwargs):
        for key,value in kwargs.items():
                print (key,value)
 
hello(name='zhaojinye' ,sex = "nv",husband = "yu")                                             
#输出：
name zhaojinye
sex nv
husband yu

8、np.zeros_like（）

输入为矩阵x

输出为形状和x一致的矩阵，其元素全部为0

>>> import numpy as np
>>> a=np.arange(12)

>>> a=a.reshape(2,2,3)
>>> a
array([[[ 0,  1,  2],
        [ 3,  4,  5]],

       [[ 6,  7,  8],
        [ 9, 10, 11]]])
>>> b=np.zeros_like(a)
>>> b
array([[[0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0]]])
>>> 

9、np.sqrt()

矩阵元素的平方根

import numpy
 
array_2d = numpy.array([[1, 4], [9, 16]], dtype=numpy.float)
 
print(array_2d)
 
array_2d_sqrt = numpy.sqrt(array_2d)
 
print(array_2d_sqrt)

#
[[ 1.  4.]
 [ 9. 16.]]
[[1. 2.]
 [3. 4.]]