python数据分析-Numpy库

numpy三剑客

import  numpy as np
import  pandas as pd
import matplotlib pyplot as plt

在数据分析中，NumPy、Pandas和Matplotlib是非常常用的三个库，它们各自扮演着不同的角色，提供了强大的功能和工具，可以方便地进行数据分析和可视化。

1. NumPy（Numerical Python）：

   • NumPy是Python中的一个核心库，提供了高性能的多维数组对象和一组函数，用于处理和操作大型数据集。
   • 它支持快速的数组运算和数值计算，包括向量化操作、广播功能和线性代数运算等。
   • NumPy的主要数据结构是ndarray（N-dimensional array），它可以表示多维数组，支持各种数据类型和维度操作。
   • 在数据分析中，NumPy常用于数据的预处理、数值计算、随机数生成等方面。

2. Pandas：

   • Pandas是建立在NumPy之上的一个数据处理和分析库，提供了高效的数据结构和数据操作工具。
   • 它的核心数据结构是DataFrame，类似于电子表格或数据库中的二维表，可以灵活地处理和分析结构化数据。
   • Pandas提供了丰富的数据处理功能，包括数据读取、清洗、筛选、聚合、合并等，以及灵活的索引和标签功能。
   • 它还支持将数据导入和导出多种格式，如CSV、Excel、SQL数据库等。
   • 在数据分析中，Pandas常用于数据的读取、处理、分析和转换等方面。

3. Matplotlib：

   • Matplotlib是一个强大的绘图库，用于创建各种静态、动态和交互式的图表和可视化。
   • 它可以生成多种类型的图表，如折线图、散点图、柱状图、饼图、箱线图、热力图等。
   • Matplotlib提供了丰富的绘图选项和样式设置，可以轻松地自定义图表的外观和布局。
   • 它与NumPy和Pandas密切结合，在数据分析中常用于数据的可视化、探索性数据分析（EDA）以及结果展示等方面。

综上所述，NumPy用于进行数值计算和数组操作，Pandas用于数据处理和分析，Matplotlib用于数据可视化。它们三者相互配合，为数据分析提供了完整的工具链

图片导入

students = plt.imread('图片.jpg')
students

Tip：图片要放在项目文件夹中。
 

type(students)

返回：numpy.ndarray
ndarray:表示多维数组

 

students.shape

在NumPy中，shape函数是一个用于获取数组形状（即维度）的函数。它返回一个表示数组各个维度大小的元组。

对于一维数组，shape函数返回一个整数元组，其中仅包含一个元素，表示数组的长度。 例如：对于数组 arr = np.array([1, 2, 3, 4, 5])，arr.shape 的结果为 (5,)。

对于多维数组，shape函数返回一个整数元组，其中每个元素表示对应维度的大小。 例如：对于二维数组 arr = np.array([[1, 2, 3], [4, 5, 6]])，arr.shape 的结果为 (2, 3)，表示该数组有两行三列。

在图像处理中，图像常表示为一个多维数组，其中的维度表示图像的高度、宽度和颜色通道等信息。因此，通过调用 image.shape 可以获取图像的形状信息。

例如：对于一张彩色图像，形状为 (height, width, channels)，其中 height 表示图像的高度，width 表示图像的宽度，channels 表示图像的颜色通道数（如 RGB 图像为 3）。

通过检查图像的形状，可以了解图像的尺寸信息，进而进行后续的图像处理、分析和可视化等操作。

总结来说，NumPy中的 shape 函数用于获取数组的形状信息，对于图像而言，image.shape 的结果表示图像的尺寸信息，包括高度、宽度和颜色通道数。

图片展示

plt.imshow(students)

创建多维数组-ndarray
 

numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

• object：必需，用于创建数组的输入数据，可以是列表、元组、其他数组等。
• dtype：可选，指定数组的数据类型，如int、float等，默认为None。如果未指定，NumPy将根据输入数据自动推断出合适的数据类型。
• copy：可选，指定是否在创建数组时复制数据，默认为True。如果设置为False，则将使用输入数据的引用创建数组，可能会影响原始数据的变化。
• order：可选，指定数组在内存中的存储顺序，默认为'K'。可选值有'C'（按行优先）和'F'（按列优先）。
• subok：可选，指定是否允许子类继承返回的数组类型，默认为False。如果设置为True，返回的数组可以是输入数据的子类。
• ndmin：可选，指定数组的最小维度，默认为0。如果指定为1，则返回的数组至少将具有一维。

array_list=[1,3,2,4,6,7]
n = np.array(array_list)
n

输出

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

Tip： numpy默认ndarray的所有元素类型要是一样的，如果不同则会强转成统一类型，优先级字符串>小数>整形
 

number = ['hello',23,0.322]  
num_1=np.array(number)
num_1

输出

array(['hello', '23', '0.322'], dtype='

numpy.ones()  | numpy.zero()  |   numpy.full(fill_value = value)
 

numpy.ones()函数是用于创建指定形状（尺寸）的全1数组的函数。它接受一个表示形状的元组作为输入，并返回一个由1构成的数组。

numpy.zeros() 函数用于创建指定形状（尺寸）的全零数组。它接受一个表示形状的元组作为输入，并返回一个由0构成的数组

numpy.full()函数用于创建指定形状（尺寸）且填充指定值的数组。它接受一个表示形状的元组和一个标量值作为输入，并返回一个由指定值填充的数组

基本语法：
 

numpy.ones(shape, dtype=None, order='C')

• shape：必需，表示数组的形状（维度），可以是整数或表示维度的元组。
• dtype：可选，指定数组的数据类型，如int、float等，默认为None。如果未指定，NumPy将默认使用浮点数类型（float64）。
• order：可选，指定数组在内存中的存储顺序，默认为'C'，即按行优先（C风格）。可选值有'C'（按行优先）和'F'（按列优先，即Fortran风格）。
   

import numpy as np

# 创建一维长度为5的全1数组
arr1 = np.ones(5)
print(arr1)  # 输出：[1. 1. 1. 1. 1.]

# 创建二维3x4的全1数组
arr2 = np.ones((3, 4))
print(arr2)
# 输出：
# [[1. 1. 1. 1.]
#  [1. 1. 1. 1.]
#  [1. 1. 1. 1.]]

# 指定数据类型创建数组
arr3 = np.ones((2, 3), dtype=int)
print(arr3)
# 输出：
# [[1 1 1]
#  [1 1 1]]

 基本语法：

numpy.full(shape, fill_value, dtype=None, order='C')

• shape：必需，表示数组的形状（维度），可以是整数或表示维度的元组。
• fill_value：必需，指定要填充的值。
• dtype：可选，指定数组的数据类型，如int、float等，默认为None。如果未指定，NumPy将根据fill_value的数据类型来决定数组的数据类型。
• order：可选，指定数组在内存中的存储顺序，默认为'C'，即按行优先（C风格）。可选值有'C'（按行优先）和'F'（按列优先，即Fortran风格）

import numpy as np

# 创建一维长度为5且元素全为7的数组
arr1 = np.full(5, 7)
print(arr1)  # 输出：[7 7 7 7 7]

# 创建二维3x4且元素全为2的数组
arr2 = np.full((3, 4), 2)
print(arr2)
# 输出：
# [[2 2 2 2]
#  [2 2 2 2]
#  [2 2 2 2]]

# 指定数据类型创建数组
arr3 = np.full((2, 3), 1.5, dtype=float)
print(arr3)
# 输出：
# [[1.5 1.5 1.5]
#  [1.5 1.5 1.5]]

 np.linspace()-----等差数列，也可以使用 np.arange(start,end,step)
 

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

• start：必需，表示等间隔序列的起始值。
• stop：必需，表示等间隔序列的终止值。
• num：可选，表示等间隔序列的元素个数，默认为50。
• endpoint：可选，表示是否包含终止值，如果设置为True，则结果将包含终止值；如果为False，则结果将不包含终止值，默认为True。
• retstep：可选，表示是否返回步长，如果设置为True，则在结果中返回步长；如果为False，则不返回步长，默认为False。
• dtype：可选，指定数组的数据类型，默认为None。如果未指定，NumPy将根据输入的数据类型来决定数组的数据类型。

import numpy as np

# 创建从0到10之间的5个等间隔的元素数组
arr1 = np.linspace(0, 10, 5)
print(arr1)  # 输出：[ 0.   2.5  5.   7.5 10. ]

# 创建从1到2之间的10个等间隔的元素数组，不包含终止值
arr2 = np.linspace(1, 2, 10, endpoint=False)
print(arr2)  # 输出：[1.  1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9]

# 创建包含步长信息的等间隔序列
arr3, step = np.linspace(0, 1, 5, retstep=True)
print(arr3)  # 输出：[0.   0.25 0.5  0.75 1.  ]
print(step)  # 输出：0.25

num_4 = np.linspace(0,100,num=51,retstep=True,dtype=np.int8)
num_4

输出
 

(array([  0,   2,   4,   6,   8,  10,  12,  14,  16,  18,  20,  22,  24,
         26,  28,  30,  32,  34,  36,  38,  40,  42,  44,  46,  48,  50,
         52,  54,  56,  58,  60,  62,  64,  66,  68,  70,  72,  74,  76,
         78,  80,  82,  84,  86,  88,  90,  92,  94,  96,  98, 100],
       dtype=int8),2.0)

np.random.randint() 创建随机整数的多维数组

 np.random.randint() 函数用于生成指定范围之间的随机整数。它接受一个或多个整数参数来指定生成随机整数的范围，可以生成一维数组或多维数组。

numpy.random.randint(low, high=None, size=None, dtype=int)

• low：必需，表示生成随机整数的最小值（包含）。
• high：可选，表示生成随机整数的最大值（不包含）。如果没有指定，high 默认为 None，生成的随机整数范围是 [0, low)。
• size：可选，表示返回的数组的形状（维度）。例如，size=5 将生成一个包含 5 个随机整数的一维数组；size=(2, 3) 将生成一个包含 2 行 3 列随机整数的二维数组。
• dtype：可选，表示返回的数组的数据类型，默认为整数类型。

numpy.random.normal()---随机正态分布的数组 

要创建一个随机的正态分布（高斯分布）的数组，可以使用 numpy.random.normal() 函数。该函数生成具有给定均值和标准差的元素的随机数组。 

numpy.random.normal(loc=0.0, scale=1.0, size=None)

• loc：可选，表示正态分布的均值，默认为0.0。
• scale: 可选，表示正态分布的标准差，默认为1.0。
• size: 可选，表示返回的数组的形状（维度）。例如，size=5 将生成一个包含 5 个随机数的一维数组；size=(2, 3) 将生成一个包含 2 行 3 列随机数的二维数组。

import numpy as np

# 生成一个具有标准正态分布的随机数
random_array = np.random.normal()
print(random_array)  # 输出：一个随机的符合标准正态分布的数

# 生成一个包含5个随机数的一维数组，均值为2，标准差为0.5
arr1 = np.random.normal(loc=2, scale=0.5, size=5)
print(arr1)  # 输出：一维数组，如 [1.8 2.3 2.5 2.1 1.9]

# 生成一个包含2行3列随机数的二维数组，均值为10，标准差为2
arr2 = np.random.normal(loc=10, scale=2, size=(2, 3))
print(arr2)
# 输出：
# [[ 9.5 12.8  9.7]
#  [ 9.9 11.1  9.4]]

 np.random.random() --随机0-1之间的小数的数组

np.random.random() 函数用于生成位于 [0, 1) 区间内的随机浮点数的数组。它返回一个具有特定形状的数组，数组中的元素是在均匀分布下生成的随机值。

numpy.random.random(size=None)

• size：可选，表示返回的数组的形状（维度）。例如，size=5 将生成一个包含 5 个随机数的一维数组；size=(2, 3) 将生成一个包含 2 行 3 列随机数的二维数组。

import numpy as np

# 生成一个在 [0, 1) 区间内的随机浮点数
random_float = np.random.random()
print(random_float)  # 输出：一个介于 0 到 1 之间的随机浮点数

# 生成一个包含 5 个随机浮点数的一维数组
arr1 = np.random.random(size=5)
print(arr1)  # 输出：一维数组，如 [0.1234 0.5678 0.9876 0.2468 0.5432]

# 生成一个包含 2 行 3 列随机浮点数的二维数组
arr2 = np.random.random(size=(2, 3))
print(arr2)
# 输出：
# [[0.3456 0.6789 0.9012]
#  [0.2345 0.7890 0.1234]]

ndarray--常见属性

NumPy中的ndarray（n维数组）是一个常用的数据结构，它具有许多属性（属性是ndarray对象的特性或元数据）。下面列出了一些常见的ndarray属性：

1. ndarray.shape：返回一个表示ndarray形状（维度）的元组。元组中的每个元素表示相应维度的大小。 示例：arr.shape 返回 (3, 4) 表示ndarray的形状是3行4列。

2. ndarray.ndim：返回ndarray的维度数（轴数）。 示例：arr.ndim 返回 2 表示ndarray是一个二维数组。

3. ndarray.size：返回ndarray的总元素个数。 示例：arr.size 返回 12 表示ndarray中总共有12个元素。

4. ndarray.dtype：返回ndarray中元素的数据类型。 示例：arr.dtype 返回 int32 表示ndarray中元素的数据类型是32位整数。

5. ndarray.itemsize：返回ndarray中每个元素的字节数。 示例：arr.itemsize 返回 4 表示ndarray中每个元素占4个字节。

6. ndarray.data：指向ndarray实际数据的缓冲区。 示例：arr.data 返回一个指向ndarray数据的缓冲区。

Numpy的基本操作 

索引 

arr = [1,2,3,4,5,6]
arr[0],arr[-1]

 输出

(1, 6)

num_17 = np.random.randint(1,10,size=(4,3,3))
num_17

##输出
array([[[8, 1, 3],
        [3, 1, 6],
        [2, 2, 3]],

       [[4, 8, 6],
        [2, 1, 3],
        [9, 9, 8]],

       [[2, 1, 7],
        [5, 4, 3],
        [2, 9, 8]],

       [[6, 8, 6],
        [6, 6, 3],
        [3, 5, 8]]])

输出

num_17[0]

#输出
array([[8, 1, 3],
       [3, 1, 6],
       [2, 2, 3]])


num_17[0][0][0]

#输出
    8

根据索引修改值：num_17[0][0][0]=9   直接赋值就可以修改数组当中的值

num_17[1][1]=100    给第二个数组第二行所有列赋值为100

num_17[0][0]=[0,0,0]    给第一个数组的第一行三列都赋值为0

切片

num_17 = [1,2,3,4,5,6,7]

num_17[::-1]       #数据翻转，[7, 6, 5, 4, 3, 2, 1]

num_18= np.random.randint(1,10,size=(3,4))

#输出：array([[2, 2, 6, 4],
             [8, 2, 4, 1],
             [8, 6, 6, 8]])

num_18[0:2]        ## array([[2, 2, 6, 4],
                            [8, 2, 4, 1]])

num_18[[0,1]] #取不连续的多行  array([[2, 2, 6, 4],
                                    [8, 2, 4, 1]])

num_19 = np.random.randint(0,10,size=(4,5))

输出：
     array([[6, 3, 0, 4, 2],
            [0, 6, 8, 2, 9],
            [6, 1, 9, 2, 9],
            [4, 0, 2, 0, 8]])

 
num_19[:,0]   #取第一列，可以看作[行处理，列处理]

输出：
     array([6, 0, 6, 4])


num_19[1:4,0]  #取第二行、第三行、第四行，第1列数据

输出：
    array([0, 6, 4])

num_19[:,[1,3]]#取不连续的1列,3列
  
输出：
     array([[3, 4],
           [6, 2],
           [1, 2],
           [0, 0]])

行翻转：num_20[::-1]

列翻转：num_20[:,::-1]

Ndarray

变形：reshape

级联：concatenate    /np.hstack     /np.vstack

拆分：np.split     /np.vsplit      /np.hsplit

1. 变形（Reshaping）：

   • 使用 arr.reshape(new_shape) 方法可以改变数组的形状，返回一个具有新形状的数组。新形状应该与原数组的总元素数量一致。
   • 通过指定 new_shape 中的维度大小，可以改变数组的形状，但是总元素数量不能改变。
   • 也可以使用 np.reshape(arr, new_shape) 进行变形操作。

import numpy as np

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

# 将一维数组变形为二维数组，形状为 (2, 3)
new_arr = arr.reshape((2, 3))
print(new_arr)
# 输出：
# [[1 2 3]
#  [4 5 6]]

# 可以使用 -1 来自动确定某一个维度的大小
new_arr2 = arr.reshape((3, -1))
print(new_arr2)
# 输出：
# [[1 2]
#  [3 4]
#  [5 6]]

1. 级联（Concatenation）：

   • 使用 np.concatenate() 函数可以沿指定轴将两个或多个数组进行级联操作。
   • 垂直级联（沿行方向级联）使用 np.vstack() 函数。
   • 水平级联（沿列方向级联）使用 np.hstack() 函数。

import numpy as np

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

# 垂直级联
concatenated_arr1 = np.vstack((arr1, arr2))
print(concatenated_arr1)
# 输出：
# [[1 2]
#  [3 4]
#  [5 6]]

arr3 = np.array([[7], [8]])

# 水平级联
concatenated_arr2 = np.hstack((arr1, arr3))
print(concatenated_arr2)
# 输出：
# [[1 2 7]
#  [3 4 8]]

 np.concatenate()

函数用于沿指定轴将两个或多个数组进行级联（拼接）操作。它接受一个包含要连接的数组序列的元组、列表或ndarray，然后沿指定的轴将它们连接在一起。

numpy.concatenate((array1, array2, ...), axis=0)

• (array1, array2, ...)：必需，传入要连接的数组序列，可以是元组、列表或ndarray。这些数组的维度应相同（除了沿连接轴之外的维度）。
• axis：可选，表示沿着哪个轴进行级联操作，默认为0。如果 axis = 0，则沿着第一个维度（行方向）进行级联；如果 axis = 1，则沿着第二个维度（列方向）进行级联。

import numpy as np

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

# 沿行方向（第一个维度）级联数组
concatenated_arr1 = np.concatenate((arr1, arr2, arr3))
print(concatenated_arr1)  # 输出：[1 2 3 4 5 6 7 8 9]

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

# 沿列方向（第二个维度）级联数组
concatenated_arr2 = np.concatenate((arr4, arr5), axis=1)
print(concatenated_arr2)
# 输出：
# [[1 2 5]
#  [3 4 6]]

 拆分

1. np.split() 函数：
   • np.split() 函数用于将一个数组沿指定轴拆分为多个子数组。
   • 它接受三个参数：ary 表示要拆分的数组，indices_or_sections 表示拆分位置或拆分的数量，axis 表示沿着哪个轴进行拆分操作。
   • 拆分后的子数组以列表形式返回。

import numpy as np

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

# 将一维数组拆分为两个子数组
split_arr = np.split(arr, 2)
print(split_arr)
# 输出：[array([1, 2, 3]), array([4, 5, 6])]

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

# 沿着行方向拆分为三个子数组
split_arr2 = np.split(arr2, 3, axis=0)
print(split_arr2)
# 输出：[array([[1, 2]]), array([[3, 4]]), array([[5, 6]])]

 np.hsplit() 和 np.vsplit() 函数：

• np.hsplit() 函数用于在水平方向（沿着列）拆分数组。
• np.vsplit() 函数用于在垂直方向（沿着行）拆分数组

num_30 = np.random.randint(1,10,size=(6,4))
num_30

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

np.vsplit(num_30,3)  #np.vsplit(数组名，3)按行平均分成三份

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


np.vsplit(num_30,(1,2,4)) #第一行前面拆，第二行前面拆，第四行拆

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

np.hsplit(num_30,4)#按列平均分成4份

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

# split 加上axis = 0是拆行 =1是拆列,不写的话默认拆行
np.split(num_30,4,axis=1),np.split(num_30,3,axis=0)

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

副本/拷贝/复制

copy()函数创建副本

#如果直接这样只能是赋值而不是拷贝，修改n2的值n也会发生改变
n = np.arange(10)
n2 = n
n2[0] = 100
display(n,n2)

输出
array([100,   1,   2,   3,   4,   5,   6,   7,   8,   9])
array([100,   1,   2,   3,   4,   5,   6,   7,   8,   9])

# 拷贝：copy
n1 = np.arange(10)
n2=n1.copy()
n2[0]=100
display(n1,n2)


输出
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
array([100,   1,   2,   3,   4,   5,   6,   7,   8,   9])

Numpy聚合操作

np.sum 求和

np.min 最小值

np.max 最大值

np.mean 平均值

np.average 平均值

np.median 中位数

np.percentile 百分位数

np.argmin最小值对应的下标

np.argmax最大值对应的下标

np.std 标准差

np.var 方差

np.power次方

np.argwhere按条件查找

 矩阵 ----  多维数组

n = np.random.randint(0,10,size=(3,4))
n

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

n+10

array([[10, 11, 11, 10],
       [16, 10, 15, 13],
       [17, 14, 11, 15]])

n-1

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

线性代数

矩阵积np.dot()

一个矩阵的列数等于一个矩阵的行数

逻辑：矩阵的第一行里面的元素和另一个矩阵的第一列元素先一一相乘再相加

（a1 a2 a3       (b1  b2

   a4 a5 a6）     b3  b4               =    (a1*b1+a2*b3+a3*b5   a1*b2+a2*b4+s3*b6

                          b5  b6   )                  a4*b1+a5*b3+a6*b5   a4*b2+a5*b4+a6*b6)

n1 = np.random.randint(0,10,size=(3,4))
n2 = np.random.randint(0,10,size=(3,4))
display(n1,n2)

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

np.dot(n1,n2)  #会报错，矩阵乘法必须一个矩阵行数和一个矩阵的列数要相等

n3 = np.random.randint(0,10,size=(4,3))
n3

array([[1, 6, 9],
       [4, 4, 7],
       [9, 9, 4],
       [9, 7, 4]])

np.dot(n1,n3)

array([[ 60,  52,  58],
       [124, 133, 124],
       [105, 133, 145]])

矩阵行列式----np.linalg.det(变量)

array([[ 60,  52,  58],
          [124, 133, 124],
          [105, 133, 145]])

主对角线相乘相加减去副对角线相乘相加

(60*133*145+52*124*105+58*124*133)-(58*133*105+52*124*145+60*124*133)

矩阵的逆----np.linalg.inv()

Numpy--广播机制（重要）

1.为缺失的维度补上维度

2缺失的元素用已有的元素填充

m = np.ones((2,3),dtype=np.int8)
n = np.arange(3)
display(m,n)

array([[1, 1, 1],
       [1, 1, 1]], dtype=int8)
array([0, 1, 2])

 广播机制：因为array([[1, 1, 1],
                                    [1, 1, 1]], dtype=int8)
 
                                 array([0, 1, 2])
 
    一个是二维数组另一个是一维数组计算时会尽可能自动补上相同的数据
                        array([0, 1, 2]，
                                [0, 1, 2])

m+n

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

a = np.arange(3).reshape((3,1))
b = np.arange(3)
display(a,b)

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

广播机制 ： 自动填充

array([[0，0，0], array([0, 1, 2]，

[1，1，1], [0, 1, 2]，

[2，2，2]]) [0, 1, 2])

a+b

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

排序--ndarray.sort()，np.sort()

 np.sort()不改变输入
 ndarray.sort()本地处理，不占用空间，但改变输入

保存：save、savez  、savetxt ---读取：np.load('name.npy')，np.load('xy.npz')['yarr']、np.loadtxt()

save：保存ndarray到一个npy文件

savez：将多个array保存到一个npz文件中

x = np.arange(5)
y = np.arange(10,20)
np.save('x',x)
np.savez('xy.npz',xarr=x,yarr=y)

#存储到csv或txt   delimiter=','分隔符
np.savetxt('arr.csv',n,delimiter=',') 

#读取csv或txt
np.loadtxt('arr.csv',delimiter=',')