Numpy常用方法扩展

1. numpy中常用的方法

• 获取最大值最小值的位置（索引）

  • numpy.argmax(ndarray,axis=None)
  • numpy.argmin(ndarray,axis=None)
  • 当查找的轴上有多个最大值或最小值，则会返回较小的索引

• 创建一个全0的数组：numpy.zeros()

• zeros_like(ndarray)，生成一个全是零的数组，形状与括号里的数组一样

• full_like(ndarray)，生成一个全是False的数组，形状与括号里的数组一样

• 创建一个全1的数组：numpy.ones()

• 创建一个对角线为1的正方形数组（方阵、矩阵）：numpy.eye()

# 获取最大值和最小值的位置
t = np.arange(12).reshape((3, 4))
print(t)

# axis=0 表示查找每个纵轴上的最大值的索引
print(np.argmax(t, axis=0))
# axis=1 表示查找每个横轴上的最大值、最小值的索引
print(np.argmax(t, axis=1))
print(np.argmin(t, axis=1))

# 创建一个全0或全1的数组
t1 = np.zeros((3, 4))
t2 = np.ones((3,4))
print("全0 全1数组")
print(t1)
print(t2)
print("*"*50)
print(np.argmax(t2, axis=1))  # 只返回每行中第一个最大值的索引
t2[0,1:3] = 2.1  # 将t2的第1行的第2、3列变为2.1
print('t2_改值后：')
print(t2)

# axis=1 表示查找每个横轴上的最大值的索引
print(np.argmax(t2, axis=1))  # t2的第一行有两个 2.1，但只返回了第一个2.1的索引
# 创建一个n维单位矩阵
t3 = np.eye(3)
print("创建n维矩阵")
print(t3)

# 查看每行最大的值的位置
print(np.argmax(t3, axis=1))

"""
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[2 2 2 2]
[3 3 3]
[0 0 0]
全0 全1数组
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
**************************************************
[0 0 0]
t2_改值后：
[[1.  2.1 2.1 1. ]
 [1.  1.  1.  1. ]
 [1.  1.  1.  1. ]]
[1 0 0]
创建n维矩阵
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
[0 1 2]
"""

2. np.all()和np.any()

（1）np.all()

• all()函数用于判断整个数组中的元素的值是否全部满足条件，如果满足条件返回True，否则返回False。本质上讲，all()实现了与(AND)运算
• 数组中全部为True，all()结果才返回True，否则为False

# 语法：
numpy.all(a, axis=None, out=None, keepdims=<no value>)

# 参数：
a ：输入可转换为数组的数组或对象
axis：None或int或int的元组，可选。沿轴或轴执行逻辑AND减少。 默认值（axis = None）是对输入数组的所有维度执行逻辑AND。 轴可以是负的，在这种情况下，它从最后一个轴到第一个轴计数。
out：ndarray，可选
keepdims：bool，可选

返回值：ndarray，bool。除非指定out，否则将返回一个新的布尔值或数组，在这种情况下，将返回对out的引用。


# 示例1
import numpy as np
 
# NumPy all() 判断矩阵中 所有元素 是否 都为True
a2 = np.arange(5)       # 生成一个矩阵 [0  1  2  3  4]
print("np.all(a2):", np.all(a2))    # 输出：False
 
a3 = np.array([0, 3, 0, 0, 0])  # 随手写一个矩阵  [0  3  0  0  0]
print("np.all(a3):", np.all(a3))  # 输出：False
 
a4 = np.zeros_like(a3)       # 生成一个全是零的矩阵，形状与a3一样 [0  0  0  0  0]
print("np.all(a4):", np.all(a4))  # 输出：False
 
a5 = np.full_like(a3, False)  # 生成一个全是False的矩阵，形状与a3一样
print("np.all(a5):", np.all(a5))  # 输出：False
 
a6 = np.full_like(a3, True)  # 生成一个全是True的矩阵，形状与a3一样
print("np.all(a6):", np.all(a6))  # 输出：True

# 示例2
import numpy as np
 
a = np.eye(5)
print(a)
print(((a == 0) | (a == 1)).all())
print((a == 0).all())
 
"""
[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]
True
False
"""

（2）np.any()

• np.array.any()是或操作，任意一个元素为True，输出为True。本质上讲，any()实现了或(OR)运算

# 语法：
numpy.any(a, axis=None, out=None, keepdims=<no value>)


# 示例1
import numpy as np
 
# NumPy any() 判断矩阵中 是否 有一个元素 为True
a2 = np.arange(5)       # 生成一个矩阵 [0  1  2  3  4]
print("np.any(a2):", np.any(a2))    # 输出：True
 
a3 = np.array([0, 3, 0, 0, 0])  # 随手写一个矩阵
print("np.any(a3):", np.any(a3))  # 输出：True
 
a4 = np.zeros_like(a3)       # 生成一个全是零的矩阵，形状与a3一样 [0  0  0  0  0]
print("np.any(a4):", np.any(a4))  # 输出：False
 
a5 = np.full_like(a3, False)  # 生成一个全是False的矩阵，形状与a3一样
print("np.any(a5):", np.any(a5))  # 输出：False
 
a6 = np.full_like(a3, True)  # 生成一个全是True的矩阵，形状与a3一样
print("np.any(a6):", np.any(a6))  # 输出：True

# 示例2
import numpy as np
 
a = np.eye(5)
print(a)
print((a == 0).all())
print((a == 0).any())
 
"""
[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]
False
True
"""

3. numpy生成随机数

• 常用的有下面的1、2、3点

# 创建随机数数组
# 1 创建随机浮点数的数组
# 语法：numpy.random.random(size=None)   
# 该方法返回 [ 0.0, 1.0 ) 范围的随机浮点数。参数 size 为随机数的数量，默认为None数量为1个

x = np.random.random(size=4)        # 生成4个[0.0,1.0)之间的随机数
y = np.random.random(size=(3,4))    # 生成3行4列个 [0.0,1.0)之间的随机数


# 2 创建随机整数数组
# 语法：numpy.random.randint()
# 该方法有三个参数 low、high、size 三个参数。默认 high 是None,如果只有low，那范围就是 [0,low) 。如果有 high，范围就是 [low,high)

x = np.random.randint(5,size=10)        # 生成10个[0,low)范围的随机整数
print(x)
y = np.random.randint(5,10,size=10)     # 生成10个[low,high)范围的整数
print(y)
z = np.random.randint(5,10,size=(2,4))   # 生成2行4列个 [low,high)范围的整数

# 3 numpy.random.seed(s)  随机数种子，s是给定的种子值，当我们指定了随机种子之后，后面生成的随机数的值就不会变化了，除非再指定另一个种子值
numpy.random.seed(2)
x = np.random.randint(5,10,size=(3,4)) 
print(x)  # 下面每次打印的x和第一次打印的都一样
print(x) 
print(x) 

# 均匀分布, 在相同的大小范围内的出现概率是相等的
# 正态分布, 呈钟型，两头低，中间高，左右对称，即类似完整左右对称的抛物线
# 4 numpy.random.rand(d0,d1,…,dn)
# 产生一个给定形状的浮点数数组，数组中的数值范围在[0, 1)的均匀分布
print("rand")
a = np.random.rand(2, 3)
print(a)
print("*"*50)


# 5 numpy.random.randn(d0,d1,…,dn)
# randn 函数返回一个或一组样本，具有标准正态分布（期望为0，方差为1）。dn 表示每个维度，返回值为指定维度的 array。（标准正态分布即半个抛物线）
x = np.random.randn()
print(x)
y = np.random.randn(2,4)
print(y)
z = np.random.randn(2,3,4)
print(z)


# 6 numpy.random.normal()  指定期望和方差的正太分布
x = np.random.normal(loc=3,scale=4,size=(2,2,3))
print(x)   


# 7 numpy.random.uniform(low, high, size)
# 产生一个数组，数组中的数值符合[low, high)的均匀分布
print("uniform")
d = np.random.uniform(1., 2., (2, 3))
print(d)
print("*"*50)

4. numpy中的copy和view

• 即数组的复制和视图

• 浅拷贝效果

  • 直接赋值：直接赋值只是创建了对原始数组的一个引用，而不是一个新的数组。因此，对赋值后的数组所做的任何更改都会影响原始数组，反之亦然

  • 视图

    • ‌影响‌：视图是原始数组的一个“窗口”，它不拥有自己的数据，只是原始数组的一个子集或子数组。对视图所做的任何更改都会影响原始数组，反之亦然
    • ‌创建‌：可以通过切片操作、布尔索引等方式创建视图。例如，b = a[1:3] 会创建一个 a 的子数组 b，这个 b 就是 a 的一个视图‌

• 深拷贝效果

  • ndarray.copy()这个方法，此方法复制后的两个数组直接互不影响。如a = b.copy()，a、b互不影响