numpy - array(5)

np.random.seed(1)
arr1 = np.random.randint(0, 50, (2, 3, 5))

(1) def sort(a, axis=-1, kind=None, order=None)
        返回目标array在指定轴上的数据按自然序（从小到大）进行排序组成的array

属于快速排序，操作不对原array进行更改
a:目标array
axis 接受单个int或者None，默认值为-1，即对最深维度/最大维度进行排序，传None则将原array转成向量再进行操作
        arr_sort1 = np.sort(arr1)
        arr_sort2 = np.sort(arr1, 0)
        arr_sort3 = np.sort(arr1, axis=None)

（2）def argsort(a, axis=-1, kind=None, order=None)
        返回原array排序后的元素在原array上的索引组成的array

 a, axis用法同sort方法
        arr_argsort1 = np.argsort(a=arr1, axis=1)

（3）ndRRy.sort()
         排序操作直接对原array进行排序更改，没有返回值

 axis用法同sort方法
        np.random.seed(2)
        arr2 = np.random.randint(0, 50, (2, 3, 5))
        np.ndarray.sort(arr2, 1)
        print(arr2)

(4) array[::-1] 切片逆序:可指定维度进行逆序操作

        arr_reverse1 = arr_sort1[:, :, ::-1]

(5) def flip(m, axis=None) 返回目标array沿给定轴反转数组中元素的顺序的新array

 m:目标array
 axis:接受int或int数组或者None。默认值为None，沿所有轴进行反转

        arr_flip1 = np.flip(arr1)
        arr_flip2 = np.flip(arr1, 0)
        arr_flip3 = np.flip(arr1, (2, 1))

 (6) " == "  同型（结构相同）array进行逐个比对得到一个元素都是bool值的array（严格意义上的比对）,或者array的每个元素与一个常数进行比对

        arr_bool1 = arr1 == arr_sort1
        arr_bool2 = arr1 == 23

(7) def allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)
 按照规则对两个array的元素进行逐个近似比对，如果所有比对值都为True 返回True，比对值有False则 返回False

 比对规则：满足|e1 - e2| <= (atol + rtol *|e2|) 则为True
 a, b：要比较的两个数组。
 rtol：相对容差，默认值为 1e-05。它是相对于 arr2 数组元素大小的容差。
 atol：绝对容差，默认值为 1e-08。它是无论 arr2 元素大小如何都适用的容差。
 equal_nan：布尔值，指示是否将 NaN视为相等。默认为 False。

        arr3 = np.array([(1, 2, 3), (4, 5, 6)])
        arr4 = np.array([(2, 3, 4), (5, 6, 7)])
        bool1 = np.allclose(arr3, arr4, atol=1)
        bool2 = np.allclose(arr3, arr4)

（8）def where(condition, x=None, y=None)

condition（条件）：接受元素为bool值的array或者单个bool值。如果只传单个bool值，则会被转化为array进行操作。（bool以外其他类型值遵循强转原则，使用前需先确认）
 x，y：接受array或者None，根据condition的判断返回x或y

(1)当where参数只传了condition = target_array，则返回target_array的元素中为True的元素的各维度索引组成的元组（index_tuple）组成的元组（res_tuple）
 res_tuple的尺寸 = target_array的维度（个数）且 res_tuple的索引 与 target_array的维度一一对应
 index_tuple存储了target_array对应维度上的所有为True的元素的索引

        np.random.seed(1)
        arr5 = np.random.randint(-50, 50, (2, 3, 5))
        dim0s_1, dim1s_1, dim2s_1 = np.where(arr5)  
        arr6 = arr5 > 0
        dims2 = np.where(arr6)
        dim0s_2, dim1s_2, dim2s_2 = np.where(arr6)

        arr7 = np.array([True, 'a', False, True, False, False])
        arr8 = np.array([[True, 'a', '', False]])
        dims3 = np.where(arr7)[0]
        dims4 = np.where(arr8)

 (2)当where参数传了condition，又传了X,Y
    (2.1)当condition传单个值的时候，可接受bool、数字、None,不接受str
    (2.1.1)当X,Y都传单个值，condition为True返回X，condition为False返回Y
        
        res_single1 = np.where(None, None, 6)

    (2.1.2)当X,Y都传Array，那么X,Y必须是同形的。
    condition为True返回X，condition为False返回Y，（传元组或列表会自动转成array操作）

        res_single3 = np.where(2.5, (1, None), (5, 6))

    (2.1.3)当X,Y传不同形的array,那么会根据维度高的array进行同形转换，
    即维度低的array会作为元素填充到维度高的array结构中取代自己。

        res_single2 = np.where(2.5, None, arr8)
        res_single4 = np.where(0, arr5, 'x')
        res_single5 = np.where(2.5, (1, 2), [(5, 6), (7, 8)])

    (2.2)当condition传array的时候，array的元素不能是str
    (2.2.1)X,Y传单个值的时候，根据condition的元素判断进行填充，
    condition元素为True填充X，为False填充Y，
    得到一个condition同形的array并返回

        arr9 = np.array([True, None, False, True, False, False])
        res_arr1 = np.where(arr9, 1, None)

    (2.2.2)X,Y传array的时候,X,Y必须与condition同形，或者condition形状包含X,Y形状，
    根据condition的元素判断进行填充，condition元素为True填充X中位置相对应的元素，
    condition元素为False填充Y中位置相对应的元素，得到一个array并返回

        res_arr2 = np.where(arr6, arr5, arr1)
        res_arr3 = np.where(arr6, arr5, 0)

（9）numpy.linalg.norm(x, ord=None, axis=None, keepdims=False)  用于计算向量或矩阵的范数。范数是衡量向量“大小”的一种方式，也可以用来衡量矩阵的“大小”。

 x：输入的数组，可以是向量或矩阵。
 ord：可选参数，指定范数的类型。默认值为 None，表示二范数（欧几里得范数）。
 其他常见的范数还包括：
     np.inf：无穷范数（最大绝对值）。
     1：一范数（绝对值之和）。
     -1：负一范数（最小绝对值）。
     2：二范数（欧几里得范数）。
     其他正整数：p范数（Lp范数）。
 axis：可选参数，指定计算范数的轴。对于矩阵，这可以用来计算行范数或列范数。
 keepdims：布尔值，指示是否保持数组的维度。默认为 False。

        arr10 = np.array([1, 2, 3])
 计算二范数
        print(np.linalg.norm(arr10))
 计算一范数
        print(np.linalg.norm(arr10, ord=1))
 计算无穷范数
        print(np.linalg.norm(arr10, ord=np.inf))

        arr11 = np.array([[1, 2], [3, 4]])
 计算矩阵的Frobenius范数（相当于计算矩阵元素平方和的平方根）
        print(np.linalg.norm(arr11))  # 输出：5.477225575051661
 计算矩阵的列范数
        print(np.linalg.norm(arr11, ord=2, axis=0))