Python----数据分析（Numpy：安装，数组创建，切片和索引，数组的属性，数据类型，数组形状，数组的运算，基本函数）

一、 Numpy库简介

1.1、概念

NumPy(Numerical Python)是一个开源的Python科学计算库，旨在为Python提供高性能的多维数组对象和一系列工具。NumPy数组是Python数据分析的基础，许多其他的数据处理库（如Pandas、SciPy）都依赖于NumPy。

NumPy的一些主要特点：

1. 高性能：NumPy底层主要采用C语言编写，相比于python来说运算速度快，性能优越，并且保留了python的易用性。

2. 多维数组：NumPy提供了强大的n维数组对象ndarray，可进行高效的数据处理，这是Numpy进行数据处理的核心对象。

3. 丰富的函数：NumPy内置了大量数学、统计和线性代数函数，方便进行数据计算，除此之外还具有广播功能，可以允许不同形状的数组进行算术运算。

4. 广泛的接口：NumPy与许多其他科学计算库（如Matplotlib、SciPy）兼容，可轻松实现数据交换和集成，此外，在人工智能领域中也可以很方便的和神经网络中使用的张量进行结构转换。

1.2、安装

pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple/

二、Numpy-array与list的区别

Python中的list虽然可以灵活的处理多个元素，但它的效率很低，一般情况下的科学运算的数据量是非常庞大的，所以list的效率低会导致整个科学运算的过程变得非常慢。与之相比，Ndarray数组具有以下特点：

1. Ndarray数组所有元素的数据类型相同、数据地址连续，批量操作数组元素时速度更快，而list中元素的数据类型可能不同，需要通过寻址的方式找到下一个元素。

2. Ndarray数组支持广播机制，矩阵运算时不需要写for循环。

3. 底层主要使用C语言实现，运行速度远高于Python代码。

三、数组的创建

3.1、array创建数组

创建一个数组，可以转换任何形式的序列（如列表或元组）为NumPy数组。

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

名称	描述
object	数组或嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

import numpy as np

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

print(arr1)
print(arr2)

'''
[1 2 3 4 5 6]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
'''

3.2、arange创建数组

创建一个均匀间隔的数值数组，类似于Python的内置 range 函数。

numpy.arange([start,] stop[, step,], dtype=None)

参数	描述
start	起始值，默认为0
stop	终止值（不包含）
step	步长，默认为1
dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

import numpy as np

arr1=np.arange(1,10,1)

print(arr1)

'''
[1 2 3 4 5 6 7 8 9]
'''

3.3、zeros函数

创建一个指定形状的数组，所有元素初始化为0。

numpy.zeros(shape, dtype=float, order='C')

参数	描述
shape	一个整数或整数元组，用于指定输出数组的形状
dtype	可选参数，指定数组元素的数据类型。默认为 float
order	可选参数，指定数组数据在内存中的存储顺序。‘C’ 表示按行（C语言风格），‘F’ 表示按列（Fortran风格）

import numpy as np

arr1=np.zeros(10)

print(arr1)

'''
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
'''

import numpy as np

arr2=np.zeros((3,3))

print(arr2)

'''
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
'''

3.4、ones函数

创建一个指定形状的数组，所有元素初始化为1。

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

参数	描述
shape	一个整数或整数元组，用于指定输出数组的形状
dtype	可选参数，指定数组元素的数据类型。默认为 float
order	可选参数，指定数组数据在内存中的存储顺序。‘C’ 表示按行（C语言风格），‘F’ 表示按列（Fortran风格）

import numpy as np

arr1=np.ones(10)
arr2=np.ones((3,3))

print(f'arr1==={arr1}')
print()
print(f'arr2==={arr2}')

'''
arr1===[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

arr2===[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
'''

3.5、empty函数

创建一个指定形状的数组，未初始化，元素值可能是随机的。

numpy.empty(shape, dtype=float, order='C')

参数	描述
shape	一个整数或整数元组，用于指定输出数组的形状
dtype	可选参数，指定数组元素的数据类型。默认为 float
order	可选参数，指定数组数据在内存中的存储顺序。‘C’ 表示按行（C语言风格），‘F’ 表示按列（Fortran风格）

import numpy as np

arr1=np.empty(10)
arr2=np.empty((3,3))

print(f'arr1==={arr1}')
print()
print(f'arr2==={arr2}')

'''
arr1===[2.09197419e-076 1.87725413e-009 1.41866238e+161 3.56792062e-057
 5.42801934e-096 5.98147383e-154 3.98454986e+252 5.12981117e-115
 1.02245668e-259 2.25563609e-153]

arr2===[[0.0000000e+000 0.0000000e+000 0.0000000e+000]
 [0.0000000e+000 0.0000000e+000 3.1224949e-321]
 [0.0000000e+000 0.0000000e+000 3.2845213e-287]]
'''

3.6、full函数

创建一个指定形状的数组，所有元素初始化为用户定义的值。

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

参数	描述
shape	一个整数或整数元组，用于指定输出数组的形状
fill_value	用于填充数组的值
dtype	可选，指定数组元素的数据类型。如果未指定，则从 fill_value 推断。
order	可选，指定数组数据在内存中的存储顺序。‘C’ 表示按行优先顺序；‘F’ 表示按列优先顺序。

import numpy as np

arr1=np.full(10,10)
arr2=np.full((3,3),3)

print(f'arr1==={arr1}')
print()
print(f'arr2==={arr2}')

'''
arr1===[10 10 10 10 10 10 10 10 10 10]

arr2===[[3 3 3]
 [3 3 3]
 [3 3 3]]
'''

3.7、eye函数

创建一个单位矩阵（对角线为1，其余为0）。

eye(N, M=None, k=0, dtype=<class 'float'>, order='C')

参数	描述
N	矩阵的行数。如果只指定 N，则返回一个 N×N 的单位矩阵
M	矩阵的列数。如果指定，返回一个形状为 (N, M) 的矩阵
k	对角线的偏移量。k 为 0 时返回主对角线的单位矩阵；k > 0 时返回主对角线上方的对角线；k < 0 时返回主对角线下方的对角线
dtype	可选，指定数组元素的数据类型。如果未指定，则从 fill_value 推断。
order	可选，指定数组数据在内存中的存储顺序。‘C’ 表示按行优先顺序；‘F’ 表示按列优先顺序。

import numpy as np

arr1=np.eye(10)
arr2=np.eye(3,3)

print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')

'''
arr1===
[[1. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 1. 0. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 1. 0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 1. 0. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]]

arr2===
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
'''

3.8、linspace函数

创建一个均匀分布的数组，包含指定数量的值。

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

参数	描述
start	序列的起始值
stop	序列的终止值，如果endpoint为true，该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
retstep	如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype	ndarray 的数据类型

import numpy as np

arr1=np.linspace(10,100,20)
arr2=np.linspace(3,3)

print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')

'''
arr1===
[ 10.          14.73684211  19.47368421  24.21052632  28.94736842
  33.68421053  38.42105263  43.15789474  47.89473684  52.63157895
  57.36842105  62.10526316  66.84210526  71.57894737  76.31578947
  81.05263158  85.78947368  90.52631579  95.26315789 100.        ]

arr2===
[3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3.
 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3. 3.
 3. 3.]
'''

3.9、logspace函数

创建一个对数均匀分布的数组，指定范围的对数数值。

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

参数	描述
start	序列的起始值为：base ** start
stop	序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	该值为 ture 时，数列中中包含stop值，反之不包含，默认是True。
base	对数 log 的底数。
dtype	ndarray 的数据类型

import numpy as np

arr1=np.logspace(10,100,10)
arr2=np.logspace(3,3)

print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')

'''
arr1===
[1.e+010 1.e+020 1.e+030 1.e+040 1.e+050 1.e+060 1.e+070 1.e+080 1.e+090
 1.e+100]

arr2===
[1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.
 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.
 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.
 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000. 1000.
 1000. 1000.]
'''

四、随机数组的创建

函数	说明
seed	确定随机生成器种子
rand	产生均匀分布的样本值
random(size=None)	该方法返回[0.0, 1.0)范围的随机数。
randn(d0,d1,…,dn)	randn函数返回一个或一组样本，具有标准正态分布（期望为0，方差为1）。dn表格每个维度，返回值为指定维度的array
normal	用于从具有指定平均值（mean）和标准差（standard deviation）的正态分布（也称为高斯分布）中抽取样本。
randint	该方法有三个参数low、high、size三个参数。默认high是None,如果只有low，那范围就是[0,low)。如果有high，范围就是[low,high)。
uniform	该函数用于从均匀分布中抽取一个浮点数
shuffle	对一个序列就地随机排列

4.1、seed函数

随机数种子（random seed）是一个用于初始化随机数生成器（random number generator, RNG）的值。在计算机科学中，大多数的随机数生成器实际上是伪随机数生成器（pseudo-random number generators, PRNGs），它们通过一个算法来生成一系列看似随机的数字。伪随机数生成器的特点是可以重现生成的随机数序列，这是通过设置相同的随机数种子来实现的。

设置随机数种子，种子值可以是任何整数，通常是正整数。

特点：

        1. 可重现性：通过设置相同的随机数种子，每次程序运行时生成的随机数序列都是相同的。这对于调试程序、进行科学计算或模拟时保持实验结果的一致性非常有用。

        2. 算法确定性：伪随机数生成器是确定性的，这意味着给定的种子会总是产生相同的随机数序列，这与真正的随机数生成器不同，后者总会生成不同的随机数。

        3. 种子来源：随机数种子的值可以是任意的。在许多编程环境中，如果不显式设置种子，通常会使用当前时间作为种子，这样每次程序运行时都会产生不同的随机数序列。

        4. 跨平台差异：不同的操作系统或硬件平台可能会产生不同的随机数序列，即使种子相同。这是因为不同的平台可能有不同的PRNG算法。

import numpy as np
np.random.seed(42)

4.2、rand函数

生成均匀分布的随机数（0到1之间），可以指定形状。

numpy.random.rand(d0, d1, ..., dn)

函数	说明
d0, d1, ..., dn	这些参数定义了输出数组的形状。它们是整数，指定了每个维度的大小。例如，d0 是第一个维度的大小，d1 是第二个维度的大小，依此类推。

import numpy as np

arr1=np.random.rand(10)

print(f'arr1===\n{arr1}')

'''
arr1===
[0.92463939 0.94486905 0.74476479 0.25784553 0.85425486 0.57160725
 0.95990865 0.36395052 0.41709035 0.82599918]
'''

4.3、random函数

与 rand 类似，但提供更灵活的随机数生成。

numpy.random.random(size=None)

函数	说明
size	这是一个可选参数，用于指定输出数组的形状。它可以是一个整数，也可以是一个元组。如果 size 是一个整数，则返回一个一维数组；如果一个元组，则返回一个多维数组，其形状与元组指定的一致

import numpy as np

arr1=np.random.random(10)

arr2=np.random.random((3,3))

print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')

'''
arr1===
[0.62721499 0.21350623 0.83140219 0.41729457 0.70818569 0.55075353
 0.57016909 0.42416555 0.11372102 0.7405065 ]

arr2===
[[0.96151613 0.96612422 0.49951694]
 [0.9377553  0.61001206 0.88551393]
 [0.22225505 0.51794861 0.36731721]]
'''

4.4、randn函数

生成标准正态分布（均值为0，标准差为1）的随机数。

numpy.random.randn(d0, d1, ..., dn)

函数	说明
d0, d1, ..., dn	这些参数指定了输出数组的维度。如果你只提供一个数字，它将返回一个一维数组；如果你提供多个数字，它将返回一个多维数组，其中每个维度的大小由对应的参数指定

import numpy as np

arr1=np.random.randn(10)

arr2=np.random.randn(3,4)

print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')

'''
arr1===
[-0.49202485 -0.26029324  0.46349285 -1.4871595  -1.15332575  0.48229266
 -1.04077328  0.52712378 -0.40422044  1.82175024]

arr2===
[[ 0.0348239   0.96843211  0.41392382  0.51399037]
 [ 1.13157601 -1.35735621 -2.2765836  -0.52266114]
 [-0.8062335  -0.55222009 -1.00520723 -1.84433436]]
'''

4.5、normal函数

生成给定均值和标准差的正态分布随机数。

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

函数	说明
loc	正态分布的均值，对应于分布的中心位置，默认值为 0.0
scale	正态分布的标准差，对应于分布的宽度，默认值为 1.0
size	输出数组的形状。如果是一个整数，返回一维数组。如果是一个元组，返回多维数组。默认为None返回一个随机数

import numpy as np

arr1=np.random.normal(size=10)

arr2=np.random.normal(size=(3,4))

print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')

'''
arr1===
[-0.23383662  0.97632058  0.48245764 -1.71405263  0.0625902   2.32371938
 -1.16770879  0.20876465 -2.16149186 -0.05048533]

arr2===
[[-0.68925419 -2.12716386 -1.06562238  1.11568077]
 [ 0.02078178 -0.31270599 -1.90545882 -0.850884  ]
 [ 0.66213069  2.28670915 -0.88748761  0.13641803]]
'''

4.6、randint函数

生成指定范围内的随机整数。

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

函数	说明
low	生成随机数的起始点（包含）。如果只提供了low参数而没有提供high参数，那么随机整数的范围将是从 0 到low （不包含 low本身）
high	生成随机数的结束点（不包含）
size	定义输出数组形状的整数或元组。例如，size(m，n)将生成一个 m 行 n 列的数组
dtype	指定返回数组的数据类型，默认为int

import numpy as np

arr1=np.random.randint(0,10,size=10)

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

print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')

'''
arr1===
[3 1 3 7 2 7 0 5 4 8]

arr2===
[[4 7 9 6]
 [3 8 2 0]
 [2 0 4 5]]
 '''

4.7、uniform函数

生成指定范围内的均匀分布随机数。

numpy.random.uniform(low=0.0, high=1.0, size=None)

函数	说明
low	浮点数或类似浮点数的数组，表示样本抽取区间的下限，默认值为 0
high	浮点数或类似浮点数的数组，表示样本抽取区间的上限，默认值为 1
size	整数或元组，可选参数，表示输出的形状。如果未提供，则返回单个浮点数。如果提供了一个整数，则返回一个一维数组；如果提供了一个元组，则返回一个多维数组

import numpy as np

arr1=np.random.uniform(0,10,size=5)

arr2=np.random.uniform(0,10,size=(3,4))

print(f'arr1===\n{arr1}')
print()
print(f'arr2===\n{arr2}')

'''
arr1===
[7.96891358 0.19647614 5.42047937 1.49001317 9.04060667]

arr2===
[[3.44988119 0.82911361 7.53272753 2.65165757]
 [6.13385131 2.30715477 0.73983801 7.05093042]
 [5.82714561 2.25635848 3.37875838 8.62424195]]
'''

4.8、shuffle函数

对数组进行随机重排，原地改变数组顺序。

numpy.random.shuffle(x)

函数	说明
x	要打乱的数组

import numpy as np

arr1=np.array([
    [1,2,3],
    [4,5,6],
    [7,8,9]
])
print('改变之前')
print(f'arr1===\n{arr1}')

np.random.shuffle(arr1)

print('改变之后')
print(f'arr1===\n{arr1}')

'''
arr1===
改变之前
arr1===
[[1 2 3]
 [4 5 6]
 [7 8 9]]
改变之后
arr1===
[[1 2 3]
 [7 8 9]
 [4 5 6]]
 '''

五、数组的索引和切片

Ndarray数组中的元素是可以被修改的，如果需要访问或者修改Ndarray数组某个位置的元素，则需要使用Ndarray数组的索引来完成；如果需要访问或者修改一些区域的元素，则需要使用Ndarray数组的切片。

5.1、一维数组的索引与切片

5.1.1、索引

一维数组的索引方式与Python列表的索引方式类似，Ndarray数组使用方括号行索引，索引值从左向右从0开始，从右向左从-1开始。

# 一维数组的索引方式
import numpy as np

# 创建了一个一维数组
arr = np.array([1, 2, 3, 4, 5])
print(arr[0])
print(arr[4])
print(arr[-1])
print(arr[-3])
arr[0] = 10
print(arr)
'''
1
5
5
3
[10  2  3  4  5]
'''

5.1.2、切片

与Python列表的切片方式类似，使用冒号:进行切片，格式为 start:stop:step，其中start、stop、step可根据情况省略。

# 一维数组的切片方式
import numpy as np

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

arr1 = arr[4:7]
print('arr1数组元素为', arr1)

arr2 = arr[1:6:2]
print('arr2数组元素为', arr2)

# 将一个标量值赋值给一个切片时，该值会自动传播到整个选区。
arr[4:7] = 6
print('arr数组元素为：', arr)

# 也可以使用:代表全部元素
arr[:] = 10
print('arr数组元素为：', arr)

arr[:4] = 1
print(arr)

'''
arr1数组元素为 [5 6 7]
arr2数组元素为 [2 4 6]
arr数组元素为： [ 1  2  3  4  6  6  6  8  9 10]
arr数组元素为： [10 10 10 10 10 10 10 10 10 10]
[ 1  1  1  1 10 10 10 10 10 10]
'''

5.2、多维数组的索引与切片

5.2.1、索引

对于多维数组，可以通过逗号分隔的索引来访问特定元素，也可以使用连续的[]来访问特定元素，例如，对于一个二维数组，第一个索引表示行，第二个索引表示列。

# 二维数组的索引
import numpy as np

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

print('arr数组为：\n', arr)

# 只有一个索引指标时，会在第0维上索引，后面的维度保持不变
print('arr[0]为：', arr[0])

# 两个索引指标
print('arr[0][0]为：', arr[0][0])
print(arr[0][0])

# 两个索引指标
print('arr[0, 1]为：', arr[0, 1])

arr[0][2] = 5
print(arr)
'''
arr数组为：
 [[1 2 3]
 [4 5 6]]
arr[0]为： [1 2 3]
arr[0][0]为： 1
1
arr[0, 1]为： 2
[[1 2 5]
 [4 5 6]]
'''

5.2.2、切片

多维数组切片时，可以分别为每个维度指定切片。

# 二维数组的切片
import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print('arr: \n', arr)

# 选择特定的一行
row1 = arr[1]
print(row1)

# 选择连续的多行
rows = arr[1:3]
print(rows)

# 选择不连续的多行
rows = arr[[0, 2]]
print(rows)

# 选择特定的一列
col1 = arr[:, 1]
print(col1)

# 选择连续的多列
cols = arr[:, 1:3]
print(cols)

# 选择不连续的多列
cols = arr[:, [0, 2]]
print(cols)

# 同时选择行和列
subset = arr[1:3, 1:3]
print(subset)
'''

arr: 
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
[4 5 6]
[[4 5 6]
 [7 8 9]]
[[1 2 3]
 [7 8 9]]
[2 5 8]
[[2 3]
 [5 6]
 [8 9]]
[[1 3]
 [4 6]
 [7 9]]
[[5 6]
 [8 9]]
 '''

六、数组的属性

6.1、shape

通过调用Ndarray.shape即可返回一个表示数组维度大小的元组。

import numpy as np

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

print(arr1)
print(arr1.shape)

'''
[[1 2 3]
 [4 5 6]]
(2, 3)
'''

6.2、dtype

通过调用Ndarray.dtype即可返回一个Ndarray数组中元素的数据类型。

import numpy as np

# 可以在创建的时候去指定数据类型
arr1 = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)

print(arr1)
print(arr1.dtype)

'''
[[1. 2. 3.]
 [4. 5. 6.]]
float32
'''

6.3、size

该属性是指数组中包含的元素个数，其大小等于调用shape函数返回的元组中的所有元素的乘积。

import numpy as np

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

print(arr1)
print(arr1.shape)
print(arr1.size)

'''
[[1 2 3]
 [4 5 6]]
(2, 3)
6
'''

6.4、ndim

该属性是指数组的维度大小，其大小等于调用shape函数返回的元组中的元素的个数。

import numpy as np

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

print(arr1)
print(arr1.shape)
print(arr1.ndim)
'''
[[[[1 2 3]
   [4 5 6]]]]
(1, 1, 2, 3)
4
'''

七、改变数组的数据类型和形状

7.1、数据类型的修改

numpy.ndarray.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)

函数	说明
dtype	表示新数据类型的对象。这可以是 NumPy 的 dtype 对象，也可以是 Python 的数据类型，例如 int 或 float
order	一个字符，指定结果的内存布局。按列（Fortran风格）， 'C' 表示按行（C风格）， 'F' 表示 'A' 或 'K' 表示在内存中的顺序与原数组保持一致
casting	控制数据类型转换的安全性。它可以是 'no'、 'equiv'、 'safe'、 'same_kind' 或 'unsafe' 之一。
subok	如果为True，子类将被传递，否则返回的数组将强制转换为基类数组
copy	布尔值，指定是否复制数据。

casting参数说明：

        'no'：表示根本不应该进行转换数据类型。

        'equiv'：允许数值上等价的类型转换，即转换前后数据的位表示相同。这意味着转换不会导致数据丢失。

        'safe'：允许安全的类型转换，即转换过程中不会丢失信息。

        'same_kind'：允许相同数据类型类别内的转换。例如，允许整型和整型之间、浮点型和浮点型之间的转换，但是不允许整型和浮点型之间的转换。

        'unsafe'：允许任何类型的转换，不考虑是否会导致数据丢失或改变。这是最不安全的选项，因为它可能会静默地丢弃数据。

比如：

        从 int64 到 int32 的转换：

                'no'：不允许。

                'equiv'：不允许。

                'safe'：不允许。

                'same_kind'：允许。

                'unsafe'：允许。

        从 float64 到 int32 的转换：

                'no'：不允许，因为会丢失小数部分。

                'equiv'、'safe'、'same_kind'：不允许，因为这不是数值上等价或安全的转换。

                 'unsafe'：允许，但会丢失小数部分。

import numpy as np

# 创建一个浮点数数组
arr = np.array([1.1, 2.2, 3.3])

# 使用 astype 方法将数组转换为整数类型
new_arr = arr.astype(np.int32)

print("Original array:", arr)
print("old type:", arr.dtype)
print("New array:", new_arr)
print("new type:", new_arr.dtype)
'''
Original array: [1.1 2.2 3.3]
old type: float64
New array: [1 2 3]
new type: int32
'''

7.2、形状的修改

7.2.1、reshape

reshape方法用于给数组一个新的形状而不改变其数据，它返回一个新的数组，但是如果给定的形状与原始数组的数据不兼容，会抛出异常

numpy.ndarray.reshape(newshape, order='C')

函数	说明
newshape	整数或整数元组，新的形状应该与原始数组中的元素数量相匹配
order	可选参数，‘C’ 表示按行（C-style），‘F’ 表示按列（Fortran-style），‘A’ 表示原数组内存顺序，‘K’ 表示元素在内存中的出现顺序

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print('shape--a', a.shape)

b = a.reshape((3, 2))
print(a)
print(b)
print('shape--b',b.shape)
'''
[[1 2 3]
 [4 5 6]]
shape--a (2, 3)
[[1 2 3]
 [4 5 6]]
[[1 2]
 [3 4]
 [5 6]]
shape--b (3, 2)

'''

7.2.2、resize

resize 方法用于改变数组的大小，与 reshape类似，但它会直接修改调用它的原始数组。如果新形状大于原始形状，则会在数组的末尾添加新的元素，这些元素的值未定义；如果新形状小于原始形状，则会截断数组。

numpy.ndarray.resize(newshape)

函数	说明
newshape	整数或整数元组，新的形状。

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print('before:', a.shape)

a.resize((3, 2))

print('after:', a.shape)
print(a)

a.resize((2, 2))
print(a)

a.resize((5, 5))
print(a)

'''
[[1 2 3]
 [4 5 6]]
before: (2, 3)
after: (3, 2)
[[1 2]
 [3 4]
 [5 6]]
[[1 2]
 [3 4]]
[[1 2 3 4 0]
 [0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]
 [0 0 0 0 0]]

'''

7.2.3、flatten

flatten方法返回一个一维数组，它是原始数组的拷贝，它默认按行顺序展平数组，但可以通过参数 order 来指定展平顺序。

numpy.ndarray.flatten(order='C')

函数	说明
order	可选参数，‘C’ 表示按行，‘F’ 表示按列，‘A’ 或 ‘K’ 表示与原数组相同的顺序

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
print(a)
b = a.flatten()
print(b)
b[0] = 10
print(a)
print(b)
'''
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[ 1  2  3  4  5  6  7  8  9 10 11 12]
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[10  2  3  4  5  6  7  8  9 10 11 12]
'''

7.2.4、ravel

ravel方法返回一个连续的数组，它尝试以最低的复制操作来返回展平后的数组

numpy.ndarray.ravel(order='C')

函数	说明
order	可选参数，‘C’ 表示按行，‘F’ 表示按列

ravel和flatten的区别：

flatten 方法返回的是原数组的副本。这意味着返回的新数组与原数组是两个独立的对象，对新数组的修改不会影响原数组。

ravel 方法返回的是原数组的视图（view）或副本（copy），这取决于数组的顺序。如果数组是连续的（C-style，行优先），则 ravel 返回的是视图，这意味着对返回数组的修改会影响到原数组。如果数组不是连续的，则的是副本。可以通过传递 order='F' 参数来请求列优先的视图。

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = a.flatten()
c = a.ravel()
d = a.ravel(order='F')

a[0][0] = 100
a[1][0] = 50
print('a', a)
print('b', b)
print('c', c)
print('d', d)

'''
a [[100   2   3]
 [ 50   5   6]]
b [1 2 3 4 5 6]
c [100   2   3  50   5   6]
d [1 4 2 5 3 6]
'''

7.2.5、T

Ndarray 对象的 T 属性是一个特殊的属性，它返回数组的转置（transpose）。

转置是一个操作，它将数组的维度进行交换。对于二维数组，这意味着行变为列，列变为行。对于更高维度的数组，转置操作涉及到交换数组的轴。

import numpy as np

# 创建一个二维数组
arr_2d = np.array([[1, 2], [3, 4], [5, 6]])

# 获取转置
transposed_arr = arr_2d.T

print(" array:")
print(arr_2d)
print("T array:")
print(transposed_arr)

'''
 array:
[[1 2]
 [3 4]
 [5 6]]
T array:
[[1 3 5]
 [2 4 6]]
'''

八、数组的运算

8.1、标量和数组的运算

8.1.1、加法运算

import numpy as np

# 生成一个2行3列的Ndarray数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 数组加上标量，会使数组的每一个元素都加上该标量得到一个新数组
b = arr + 2

print('original: \n', arr)
print('new: \n', b)

'''
original: 
 [[1 2 3]
 [4 5 6]]
new: 
 [[3 4 5]
 [6 7 8]]
'''

8.1.2、减法运算

import numpy as np

# 生成一个2行3列的Ndarray数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 数组加上标量，会使数组的每一个元素都加上该标量得到一个新数组
b = arr - 2

print('original: \n', arr)
print('new: \n', b)

'''
original: 
 [[1 2 3]
 [4 5 6]]
new: 
 [[-1  0  1]
 [ 2  3  4]]
'''

8.1.3、乘法运算

import numpy as np

# 生成一个2行3列的Ndarray数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 数组加上标量，会使数组的每一个元素都加上该标量得到一个新数组
b = arr * 2

print('original: \n', arr)
print('new: \n', b)

'''
original: 
 [[1 2 3]
 [4 5 6]]
new: 
 [[ 2  4  6]
 [ 8 10 12]]
'''

8.1.4、除法运算

import numpy as np

# 生成一个2行3列的Ndarray数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 数组加上标量，会使数组的每一个元素都加上该标量得到一个新数组
b = arr / 2

print('original: \n', arr)
print('new: \n', b)

'''
original: 
 [[1 2 3]
 [4 5 6]]
new: 
 [[0.5 1.  1.5]
 [2.  2.5 3. ]]
'''

8.2、数组和数组的运算

8.2.1、加法运算

8.2.1.1、符号

import numpy as np


arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])


arr3 = arr1 + arr2

print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)

'''
[[11 12 13]
 [14 15 16]]
[[1 2 3]
 [4 5 6]]
运算的结果为：
 [[12 14 16]
 [18 20 22]]
'''

8.2.1.2、函数

numpy.add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)

函数	说明
x1	第一个输入数组或标量
x2	第二个输入数组或标量
out	输出数组，数据类型必须与预期输出相符。如果提供，它必须具有与输出相同形状的适当类型来接收结果
where	表示计算加法的条件，如果设置为True，则在相应位置进行计算；如果设置为False，则在相应位置不进行计算
casting	定义如何处理数据类型转换，例如 ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’
order	指定结果的内存布局，‘C’ 表示 C 风格，‘F’ 表示 Fortran 风格，‘A’ 表示原数组样式，‘K’ 表示元素在内存中的出现顺序
dtype	指定输出数组的类型
subok	控制返回数组是否可以是输入数组的子类

import numpy as np


arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])


arr3 = np.add(arr1,arr2)

print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)

'''
[[11 12 13]
 [14 15 16]]
[[1 2 3]
 [4 5 6]]
运算的结果为：
 [[12 14 16]
 [18 20 22]]
'''

8.2.2、减法运算

8.2.2.1、符号

import numpy as np


arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])


arr3 = arr1 - arr2

print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)

'''
[[11 12 13]
 [14 15 16]]
[[1 2 3]
 [4 5 6]]
运算的结果为：
 [[10 10 10]
 [10 10 10]]
 '''

8.2.2.2、函数

numpy.subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)

函数	说明
x1	第一个输入数组或标量
x2	第二个输入数组或标量
out	输出数组，数据类型必须与预期输出相符。如果提供，它必须具有与输出相同形状的适当类型来接收结果
where	表示计算加法的条件，如果设置为True，则在相应位置进行计算；如果设置为False，则在相应位置不进行计算
casting	定义如何处理数据类型转换，例如 ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’
order	指定结果的内存布局，‘C’ 表示 C 风格，‘F’ 表示 Fortran 风格，‘A’ 表示原数组样式，‘K’ 表示元素在内存中的出现顺序
dtype	指定输出数组的类型
subok	控制返回数组是否可以是输入数组的子类

import numpy as np


arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])


arr3 = np.subtract(arr1,arr2)

print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)

'''
[[11 12 13]
 [14 15 16]]
[[1 2 3]
 [4 5 6]]
运算的结果为：
 [[10 10 10]
 [10 10 10]]
'''

8.2.3、乘法运算

8.2.3.1、符号

import numpy as np


arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])


arr3 = arr1 * arr2

print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)

'''
[[11 12 13]
 [14 15 16]]
[[1 2 3]
 [4 5 6]]
运算的结果为：
 [[11 24 39]
 [56 75 96]]'''

8.2.3.2、函数

numpy.multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)

函数	说明
x1	第一个输入数组或标量
x2	第二个输入数组或标量
out	输出数组，数据类型必须与预期输出相符。如果提供，它必须具有与输出相同形状的适当类型来接收结果
where	表示计算加法的条件，如果设置为True，则在相应位置进行计算；如果设置为False，则在相应位置不进行计算
casting	定义如何处理数据类型转换，例如 ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’
order	指定结果的内存布局，‘C’ 表示 C 风格，‘F’ 表示 Fortran 风格，‘A’ 表示原数组样式，‘K’ 表示元素在内存中的出现顺序
dtype	指定输出数组的类型
subok	控制返回数组是否可以是输入数组的子类

import numpy as np


arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])


arr3 = np.multiply(arr1,arr2)

print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)

'''
[[11 12 13]
 [14 15 16]]
[[1 2 3]
 [4 5 6]]
运算的结果为：
 [[11 24 39]
 [56 75 96]]
'''

8.2.4、除法运算

8.2.4.1、符号

import numpy as np


arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])


arr3 = arr1 / arr2

print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)

'''
[[11 12 13]
 [14 15 16]]
[[1 2 3]
 [4 5 6]]
运算的结果为：
 [[11.          6.          4.33333333]
 [ 3.5         3.          2.66666667]]
'''

8.2.4.2、函数

numpy.divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True)

函数	说明
x1	第一个输入数组或标量
x2	第二个输入数组或标量
out	输出数组，数据类型必须与预期输出相符。如果提供，它必须具有与输出相同形状的适当类型来接收结果
where	表示计算加法的条件，如果设置为True，则在相应位置进行计算；如果设置为False，则在相应位置不进行计算
casting	定义如何处理数据类型转换，例如 ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’
order	指定结果的内存布局，‘C’ 表示 C 风格，‘F’ 表示 Fortran 风格，‘A’ 表示原数组样式，‘K’ 表示元素在内存中的出现顺序
dtype	指定输出数组的类型
subok	控制返回数组是否可以是输入数组的子类

import numpy as np


arr1 = np.array([[11, 12, 13], [14, 15, 16]])
arr2 = np.array([[1, 2, 3], [4, 5, 6]])


arr3 = np.divide(arr1,arr2)

print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)

'''
[[11 12 13]
 [14 15 16]]
[[1 2 3]
 [4 5 6]]
运算的结果为：
 [[11.          6.          4.33333333]
 [ 3.5         3.          2.66666667]]
'''

8.2.5、开根号

8.2.5.1、符号

import numpy as np

# 生成一个2行3列的数组
arr1 = np.array([[4, 9, 16], [25, 36, 49]])

# 开根号操作就是让一个数组进行0.5次方的幂运算
arr2 = arr1 ** 0.5

print(arr1)
print('运算的结果为：\n', arr2)

'''
[[ 4  9 16]
 [25 36 49]]
运算的结果为：
 [[2. 3. 4.]
 [5. 6. 7.]]
'''

8.2.5.2、函数

函数	说明
x1	第一个输入数组或标量
x2	第二个输入数组或标量
out	输出数组，数据类型必须与预期输出相符。如果提供，它必须具有与输出相同形状的适当类型来接收结果
where	表示计算加法的条件，如果设置为True，则在相应位置进行计算；如果设置为False，则在相应位置不进行计算
casting	定义如何处理数据类型转换，例如 ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’
order	指定结果的内存布局，‘C’ 表示 C 风格，‘F’ 表示 Fortran 风格，‘A’ 表示原数组样式，‘K’ 表示元素在内存中的出现顺序
dtype	指定输出数组的类型
subok	控制返回数组是否可以是输入数组的子类

import numpy as np

# 生成一个2行3列的数组
arr1 = np.array([[4, 9, 16], [25, 36, 49]])

# 开根号操作就是让一个数组进行0.5次方的幂运算
arr2 = np.pow(arr1,0.5)

print(arr1)
print('运算的结果为：\n', arr2)

'''
[[ 4  9 16]
 [25 36 49]]
运算的结果为：
 [[2. 3. 4.]
 [5. 6. 7.]]
'''

8.2.6、点积

行*列

函数	说明
a	第一个输入数组
b	第二个输入数组
out	可选输出数组，用于放置运算结果

import numpy as np

# 生成两个2行3列的数组
arr1 = np.array(
    [
        [1,2,3],
        [4,5,6],
        [7,8,9]
    ]
)
arr2 = np.array(
    [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]
)

# power会使arr1中的每个元素为底数，arr2中的对应位置的元素为指数进行运算
arr3 = np.dot(arr1, arr2)

print(arr1)
print(arr2)
print('运算的结果为：\n', arr3)

'''
[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
运算的结果为：
 [[ 30  36  42]
 [ 66  81  96]
 [102 126 150]]
'''

九、数组的广播机制

通常情况下，为了进行元素级的算术运算，两个数组的形状必须完全一致，Numpy的广播机制，它提供了一种规则，能够将不同形状的两个计算数组广播到相同形状，然后再去进行元素级的算术运算，这种规则使得形状不完全匹配的数组也能相互运算。通过这个机制，Numpy能够在保持效率的同时，扩展数组的操作范围，从而无需显式地扩展数组维度或进行循环遍历以实现元素级的计算，极大的增强了数组的处理能力。

具体规则为：

        1. 如果两个数组的维数不同，形状较小的数组会在前面补1。

        2. 如果两个数组的形状在某个维度上不匹配，且其中一个维度长度为1，则会沿该维度复制扩展以匹配另一个数组的形状。

        3. 如果在任一维度上不匹配且没有维度等于1，则会引发异常。

举例：

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

        arr和标量2进行相加

标量 2 的形状可以看作是（），而二维数组 arr的形状是（2, 3）。根据广播规则，维度较低的标量会在其形状左边添加与高维数组相同的维度数，使其维度与高维数组相同。这里标量 2 被扩展为形状（1,1）的数组，再进一步扩展为形状（2,3）的数组，即 [[2,2,2],[2,2,2]]。然后，这个扩展后的数组与原二维数组 arr进行对应元素的运算。所以最终结果为：

        arr + 2 = [[1+2,2+2,3+2],[4+2,5+2,6+2]] = [[3,4,5],[6,7,8]]

十、修改维度

10.1、squeeze

该函数的作用是从数组形状中删除所有单维度的条目，即把形状中为1的维度去掉。

numpy.squeeze(a, axis=None)

函数	说明
a	输入数组。它可以是任何形状的数组，但至少有一个维度的大小为1。
axis	可选参数。一个整数或整数元组。如果指定了该参数，则只压缩指定的轴。如果该轴在数组 a 中不是单维度的，则不会进行压缩。如果未指定，则所有单维度的轴都将被压缩。

# squeeze: 降维
import numpy as np

# 创建一个具有单维度的数组
arr = np.array([[[1], [2], [3]]])
print(arr)
print("原始数组形状:", arr.shape)

# 使用squeeze函数去掉所有单维度的条目
squeezed_arr = np.squeeze(arr, axis=(0, 2))
print(squeezed_arr)
print("压缩后的数组形状:", squeezed_arr.shape)

'''
[[[1]
  [2]
  [3]]]
原始数组形状: (1, 3, 1)
[1 2 3]
压缩后的数组形状: (3,)
'''

10.2、expand_dims

该函数的作用是在指定的位置增加一个单一维度，即在指定的位置增加一个形状为1 的维度。

numpy.expand_dims(a, axis)

函数	说明
a	输入数组。它可以是任何形状的数组，但至少有一个维度的大小为1。
axis	可选参数。一个整数或整数元组。如果指定了该参数，则只压缩指定的轴。如果该轴在数组 a 中不是单维度的，则不会进行压缩。如果未指定，则所有单维度的轴都将被压缩。

# expand_dims:升维
import numpy as np

# 创建一个一维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("原始数组形状:", arr.shape)
print(arr)

# 在位置0增加一个维度
expanded_arr = np.expand_dims(arr, axis=2)
print("增加维度后的数组形状:", expanded_arr.shape)
print(expanded_arr)

# 在位置1增加一个维度
expanded_arr = np.expand_dims(arr, axis=(0, 1))
print("增加维度后的数组形状:", expanded_arr.shape)
print(expanded_arr)
'''
原始数组形状: (2, 3)
[[1 2 3]
 [4 5 6]]
增加维度后的数组形状: (2, 3, 1)
[[[1]
  [2]
  [3]]

 [[4]
  [5]
  [6]]]
增加维度后的数组形状: (1, 1, 2, 3)
[[[[1 2 3]
   [4 5 6]]]]
'''

十一、连接数组

11.1、concatenate

该函数用于将多个数组沿指定的轴连接起来，形成一个更大的数组

numpy.concatenate((a1, a2, ..., arr_n), axis=0, out=None)

函数	说明
(a1, a2, ..., arr_n)	这是一个包含数组的元组，这些数组需要被连接。所有数组在除了连接轴之外的其他维度上必须有相同的形状
axis	整数，指定沿着哪个轴进行连接。如果不指定，默认为 0，表示第一个轴。
out	可选参数，如果提供，结果将直接存储在这个数组中。这个数组必须具有与输入数组相同的形状和数据类型。

工作原理：

1. 输入验证： concatenate 接受一个元组或列表作为输入，其中包含一系列数组。这些数组可以是任意维度，但它们在除了要连接的轴之外的所有维度上必须具有相同的形状。

2. 轴参数： concatenate 有一个必需的参数 axis，它指定了沿着哪个轴进行连接。轴的编号从 0 开始，对于一维数组，只有一个轴（轴 0）。对于二维数组，轴 0 是行，轴 1 是列。

3. 形状兼容性检查：所有输入数组在 axis 参数指定的轴上的维度大小可以不同，但在其他轴上的维度大小必须相同。例如，如果 axis=1，则所有输入数组的行数必须相同。

4. 内存分配：在连接之前， concatenate 会计算输出数组的大小，并分配足够的内存空间来存储结果。

5. 数据复制： concatenate 会将输入数组的数据复制到新分配的内存空间中。具体来说，它将沿着指定的轴顺序地复制每个数组的数据，从而形成一个新的数组。

6. 结果数组：输出结果是一个新的数组，它在 axis 指定的轴上的维度大小是所有输入数组在该轴上维度大小的总和，而在其他轴上则与输入数组相同。

import numpy as np

# 创建两个数组
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])

print(f'数组a的形状为{a.shape}, 数组a为：\n', a)
print(f'数组b的形状为{b.shape}, 数组b为：\n', b)

# 沿着第一个轴（垂直方向）连接数组
c = np.concatenate((b, a), axis=0)
print(f'数组c的形状为{c.shape}, 数组c为：\n', c)

# 沿着第二个轴（水平方向）连接数组
d = np.concatenate((a, b.T), axis=1)
print(f'数组b的转置的形状为{b.T.shape}, 数组b的转置为：\n', b.T)
print(f'数组d的形状为{d.shape}, 数组d为：\n', d)

'''
数组a的形状为(2, 2), 数组a为：
 [[1 2]
 [3 4]]
数组b的形状为(1, 2), 数组b为：
 [[5 6]]
数组c的形状为(3, 2), 数组c为：
 [[5 6]
 [1 2]
 [3 4]]
数组b的转置的形状为(2, 1), 数组b的转置为：
 [[5]
 [6]]
数组d的形状为(2, 3), 数组d为：
 [[1 2 5]
 [3 4 6]]
'''

11.2、stack

该函数用于沿着新的轴连接一系列数组。与 numpy.concatenate 不同， numpy.stack 总是创建一个新的轴，而numpy.concatenate则是在现有轴上进行数组的连接

numpy.stack(arrays, axis=0, out=None)

函数	说明
arrays	一系列数组，它们将被堆叠在一起。所有数组必须具有相同的形状
axis	整数，表示新轴的位置。默认值为 0
out	可选参数，如果提供，结果将直接存储在这个数组中。这个数组必须具有与输出数组相同的形状和数据类型

工作原理：

1. 输入验证： stack 接受一个数组序列（例如一个列表或元组）作为输入。所有输入数组必须具有相同的形状。

2. 轴参数： stack 有一个必需的参数 axis，它指定了新轴的位置。

3. 形状兼容性检查：所有输入数组在除了要创建的新轴外的所有维度上必须具有相同的形状。

4. 内存分配： stack 会计算输出数组的形状，并在内存中为这个新数组分配空间。新数组的形状将比输入数组的形状多一个维度，这个新增的维度的大小等于输入数组的数量。

5. 数据复制： stack 将输入数组的数据复制到新分配的内存空间中，每个输入数组在新轴上占据一个位置。

6. 结果数组：输出结果是一个新的数组，其形状在一个维度。

import numpy as np

# 创建两个一维数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.array([7, 8, 9])

print(f'数组a的形状为{a.shape}, 数组a为：\n', a)
print(f'数组b的形状为{b.shape}, 数组b为：\n', b)

# # 沿着新的轴堆叠数组
d = np.stack((a, c, b), axis=0)
print(f'数组d的形状为{d.shape}, 数组d为：\n', d)

# 沿着第二个轴堆叠数组
e = np.stack((a, b), axis=1)
print(f'数组e的形状为{e.shape}, 数组e为：\n', e)

'''
数组a的形状为(3,), 数组a为：
 [1 2 3]
数组b的形状为(3,), 数组b为：
 [4 5 6]
数组d的形状为(3, 3), 数组d为：
 [[1 2 3]
 [7 8 9]
 [4 5 6]]
数组e的形状为(3, 2), 数组e为：
 [[1 4]
 [2 5]
 [3 6]]
'''

11.3、hstack

在 NumPy 中， numpy.hstack（水平堆叠）函数用于沿着水平方向堆叠数组序列。

numpy.hstack(tup)

函数	说明
tup	一个数组序列，它们将被水平堆叠在一起。所有数组在除了第二个轴之外的轴上必须具有相同的形状。

工作原理：

1. 输入验证：首先， hstack 会检查所有输入数组是否都是二维的，或者至少可以被视为二维的。如果输入数组是多维的，它们将被重新塑造为二维数组。

2. 形状兼容性检查：所有输入数组在除了第二个轴（列）之外的所有其他轴上必须有相同的形状。这意味着，如果输入数组是一系列的矩阵，那么这些矩阵的行数必须相同。例如，如果你有两个矩阵 A 和 B，它们分别是 3x2 和 3x3 的，那么它们可以在水平方向上堆叠，因为它们都有 3 行。

3. 堆叠操作：如果输入数组通过了形状兼容性检查， hstack 将沿着第二个轴（列）将它们连接起来。这意味着，对于每个输入数组，它们的列将被依次排列在一起。

4. 结果数组：输出结果是一个新的二维数组，其列数是所有输入数组列数的总和，而行数与输入数组中的任何一个相同。

import numpy as np

# 创建两个 2x2 的矩阵
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

print(f'数组a的形状为{a.shape}, 数组a为：\n', a)
print(f'数组b的形状为{b.shape}, 数组b为：\n', b)

# 使用 hstack 进行水平堆叠
c = np.hstack((a, b))

# 输出结果
print(f'数组c的形状为{c.shape}, 数组c为：\n', c)

'''
数组a的形状为(2, 2), 数组a为：
 [[1 2]
 [3 4]]
数组b的形状为(2, 2), 数组b为：
 [[5 6]
 [7 8]]
数组c的形状为(2, 4), 数组c为：
 [[1 2 5 6]
 [3 4 7 8]]

'''

11.4、vstack

numpy.vstack函数用于将多个数组沿垂直方向（即沿着第一个轴，axis=0）堆叠成一个单一的数组

numpy.vstack(tup)

函数	说明
tup	一个包含数组的元组或列表。所有数组在除了第一个轴外的维度上必须具有相同的形状

工作原理：

1. 输入验证： vstack 接受一个数组序列（例如一个列表或元组）作为输入。所有输入数组在除了第一个轴外的所有其他维度上必须具有相同的形状。

2. 内存分配： vstack 会计算输出数组的形状，并在内存中为这个新数组分配空间。输出数组的第一个维度将是所有输入数组第一个维度大小的总和，其他维度与输入数组相同。

3. 数据复制： vstack 将输入数组的数据复制到新分配的内存空间中，每个输入数组在新数组中占据连续的块。

4. 结果数组：输出结果是一个新的数组，其中输入数组沿第一个轴（垂直方向）堆叠。

import numpy as np

# 创建两个二维数组
a = np.array([[1, 2, 3],
              [4, 5, 6]])
b = np.array([[7, 8, 9]])

print(f'数组a的形状为{a.shape}, 数组a为：\n', a)
print(f'数组b的形状为{b.shape}, 数组b为：\n', b)

# 使用 vstack 进行垂直堆叠
c = np.vstack((a, b))

# 输出结果
print(f'数组c的形状为{c.shape}, 数组c为：\n', c)

'''
数组a的形状为(2, 3), 数组a为：
 [[1 2 3]
 [4 5 6]]
数组b的形状为(1, 3), 数组b为：
 [[7 8 9]]
数组c的形状为(3, 3), 数组c为：
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

'''

十二、分割数组

12.1、split

该函数用于沿着指定的轴将数组分割成多个子数组，可以指定要分割的数组、分割的位置或子数组的数量。

numpy.split(ary, indices_or_sections, axis=0)

函数	说明
ary	要分割的数组
indices_or_sections	可以是一个整数，表示要将数组平均分割成多少个子数组；也可以是一个整数数组，表示分割的位置
axis	沿着哪个轴进行分割，默认为 0，即第一个轴

工作原理：

1. 输入验证： split 接受一个数组参数 ary 作为输入，以及一个指示如何分割数组的 indices_or_sections。如果提供了 axis 参数，它指定了沿哪个轴分割数组，默认为 0。

2. 解析分割参数：如果 indices_or_sections 是一个整数，它表示要将数组分割成多少个大小相等的子数组。如果是一个序列，它表示沿指定轴的分割点。

3. 计算分割点：如果indices_or_sections是整数，split 会计算每个子数组应该包含的元素数量。如果indices_or_sections是一个序列，则直接使用这些值作为分割点。

4. 执行分割：split 使用计算出的分割点在指定轴上将原始数组分割成多个子数组。这通常涉及到创建原始数组的视图，而不是复制数据。

5. 返回结果： split 返回一个列表，其中包含所有分割后的子数组。

# split
import numpy as np

# 创建一个一维数组
a = np.array([1, 2, 3, 4, 5, 6])

# 使用 split 平均分割数组为 3 个子数组
result1 = np.split(a, 3, axis=0)

# 使用 split 按位置分割数组
result2 = np.split(a, [1, 2, 4])

# 输出结果
print("平均分割为 3 个子数组：", result1)
print("按位置分割：", result2)

'''
平均分割为 3 个子数组： [array([1, 2]), array([3, 4]), array([5, 6])]
按位置分割： [array([1]), array([2]), array([3, 4]), array([5, 6])]
'''

12.2、hsplit

numpy.hsplit 用于沿着横向（水平方向）将数组分割成多个子数组。这个函数是 numpy.split 的一个特化版本，专门用于沿着第二个轴（axis=1）进行分割。

numpy.hsplit(ary, indices_or_sections)

函数	说明
ary	要分割的数组
indices_or_sections	可以是一个整数，表示要将数组平均分割成多少个子数组；也可以是一个整数数组，表示分割的位置

工作原理：

1. 输入验证： hsplit 接受一个数组ary作为输入，以及一个指示如何分割数组的参数indices_or_sections。与 split 不同，hsplit 不接受axis 参数，因为它默认沿着第二个轴（axis=1）进行分割。

2. 解析分割参数：如果 indices_or_sections 是一个整数，它表示要将数组分割成多少个大小相等的子数组。如果是一个序列，它表示沿指定轴的分割点。

3. 计算分割点：如果 indices_or_sections 是整数， hsplit 会计算每个子数组在水平方向上应该包含的列数。如果 indices_or_sections 是一个序列，则直接使用这些值作为分割点。

4. 执行分割： hsplit 使用计算出的分割点在第二个轴上将原始数组分割成多个子数组。与 split 类似，这通常涉及到创建原始数组的视图，而不是复制数据。

5. 返回结果： hsplit 返回一个列表，其中包含所有分割后的子数组。每个子数组都是原始数组的一部分，沿第二个轴分割而成。

import numpy as np

# 创建一个 6x4 的二维数组
arr = np.arange(24).reshape(6, 4)



# 打印原始数组
print("原始数组:")
print(arr)

# 指定每部分应该包含的列数
col_counts = [1, 2]

# 使用 hsplit 分割数组
subarrays = np.hsplit(arr, col_counts)

# 打印分割后的子数组
print("\n分割后的子数组:")
print(subarrays)
'''
原始数组:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]
 [20 21 22 23]]

分割后的子数组:
[array([[ 0],
       [ 4],
       [ 8],
       [12],
       [16],
       [20]]), array([[ 1],
       [ 5],
       [ 9],
       [13],
       [17],
       [21]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15],
       [18, 19],
       [22, 23]])]
'''

12.3、vsplit

numpy.vsplit 用于沿着纵向（垂直方向）将数组分割成多个子数组。这个函数是 numpy.split 的一个特化版本，专门用于沿着第一个轴（axis=0）进行分割。

numpy.vsplit(ary, indices_or_sections)

函数	说明
ary	要分割的数组
indices_or_sections	可以是一个整数，表示要将数组平均分割成多少个子数组；也可以是一个整数数组，表示分割的位置

工作原理：

1. 输入验证： vsplit 接受一个数组参数 ary 作为输入，以及一个指示如何分割数组的 indices_or_sections。与 split 不同， vsplit 不接受为它默认沿着第一个轴（axis=0）进行分割。

2. 解析分割参数：如果 axis 参数，因 indices_or_sections 是一个整数，它表示要将数组在垂直方向上平均分割成多少个子数组。如果是一个序列，它表示沿第一个轴的分割点。

3. 计算分割点：如果 indices_or_sections 是整数， vsplit 会计算每个子数组在垂直方向上应该包含的行数。如果 indices_or_sections 是一个序列，则直接使用这些值作为分割点。

4. 执行分割： vsplit 使用计算出的分割点在第一个轴上将原始数组分割成多个子数组。与 split 类似，这通常涉及到创建原始数组的视图，而不是复制数据。

5. 返回结果： vsplit 返回一个列表，其中包含所有分割后的子数组。每个子数组都是原始数组的一部分，沿第一个轴分割而成。

import numpy as np

# 创建一个 6x4 的二维数组
arr = np.arange(24).reshape(6, 4)

# 打印原始数组
print("原始数组:")
print(arr)

# 指定每部分应该包含的列数
col_counts = [1, 2]

# 使用 hsplit 分割数组
subarrays = np.vsplit(arr, col_counts)

# 打印分割后的子数组
print("\n分割后的子数组:")
print(subarrays)

'''
原始数组:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]
 [20 21 22 23]]

分割后的子数组:
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23]])]
'''

十三、元素的添加与删除

13.1、append

numpy.append(arr, values, axis=None)

函数	说明
arr	原始数组，可以是任何形状
values	要追加的值，它们会被追加到arr的末尾。values的形状必须与arr 在除了要追加的轴之外的所有轴上兼容。
axis	可选参数，指定要追加值的轴。如果axis没有被指定， arr 会被展平，values 会被追加到结果数组的末尾。

注意事项：

1、numpy.append 在追加元素时，如果 arr 的形状。

2、如果 values 是一个数组，它的形状必须与 values 是一个标量，它会自动广播以匹配 arr 在除了要追加的轴之外的所有轴上匹配。

3、numpy.append 可能不是最高效的操作，因为它涉及到创建一个新的数组。如果频繁追加元素，考虑使用 numpy.concatenate 或 numpy.append 的替代方法，如使用 numpy.resize 和直接赋值。

import numpy as np

# 创建一个一维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 要追加的值
values = np.array([[1, 2, 3]])

# 使用 numpy.append 追加值
result = np.append(arr, values, axis=0)

# 输出结果
print(result)
'''
[[1 2 3]
 [4 5 6]
 [1 2 3]]

'''

import numpy as np

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

# 要追加的值
values_2d = np.array([[5], [6]])

# 使用 numpy.append 追加值，沿着列方向
result_2d = np.append(arr_2d, values_2d, axis=1)

# 输出结果
print(result_2d)
'''
[[1 2 5]
 [3 4 6]]
'''

13.2、insert

该函数用于在数组的指定位置插入元素。与 numpy.append 不同的是， numpy.insert 允许用户在数组的任意位置插入元素，而不仅仅是数组的末尾。

numpy.insert(arr, obj, values, axis=None)

函数	说明
arr	原始数组，可以是任何形状。
obj	表示插入位置的索引。它可以是整数或者整数数组。如果是整数，则表示在哪个位置插入。如果是整数数组，则表示在哪些位置插入。
values	要插入的值。如果 arr 是多维数组，则 axis 指定的轴以外的所有轴上与 arr 保持一致。
axis	可选参数，指定插入操作的轴。如果未指定，则 values 会被插入到一维数组中。

注意事项：

1、如果 obj 是一个整数数组，values也会被分割成多个部分每个部分被插入到对应的索引位置。

2、如果 values 是一个标量，它会自动广播以匹配需要插入的位置。

3、插入操作可能会比追加操作更加低效，因为它涉及到数组元素的移动。

import numpy as np

# 创建一个一维数组
arr = np.array([1, 2, 3, 4, 5])
print(arr)


result = np.insert(arr, 2, 10)

print(result)


# 在索引 [1, 3] 的位置插入值 [20, 30]
result_2 = np.insert(arr, [1, 3], [20, 10])

# 输出结果
print(result_2)
'''
[1 2 3 4 5]
[ 1  2 10  3  4  5]
[ 1 20  2  3 10  4  5]
'''

import numpy as np
# 在二维数组中插入值
arr_2d = np.array([[1, 2], [3, 4], [5, 6]])
print(arr_2d)

values = np.array([[5], [6], [7]])

# 在索引 0 的位置沿着列方向插入值 [10]
result_2d = np.insert(arr_2d, [0], values, 1)

# 输出结果
print(result_2d)
'''
[[1 2]
 [3 4]
 [5 6]]
[[5 1 2]
 [6 3 4]
 [7 5 6]]
'''

13.3、delete

该函数用于从数组中删除指定的子数组，并返回一个新的数组。这个函数允许用户删除数组中的单个元素或多个连续的元素。

numpy.delete(arr, obj, axis=None)

函数	说明
arr	原始数组，可以是任何形状。
obj	表示要删除的子数组的索引。它可以是单个整数、一个整数列表或一个整数数组。如果是一个整数，它表示要删除单个元素的位置；如果是列表或数组，则表示要删除多个元素的位置。
axis	可选参数，指定删除操作的轴。如果未指定，则 arr 会被展平，然后根据 obj 指定的索引删除元素。

注意事项：

1、如果 obj 是一个列表或数组，删除操作会按照索引的顺序进行，这意味着删除操作可能会影响后续索引的位置。

2、如果 obj 中的索引超出数组的范围， numpy.delete 会抛出一个异常。

import numpy as np


# 创建一个一维数组
arr = np.array([1, 2, 3, 4, 5])

# 删除索引 2 的元素
result = np.delete(arr, 2)

# 输出结果
print(result)


# 删除索引 [1, 3] 的元素
result_2 = np.delete(arr, [1, 3])

# 输出结果
print(result_2)
'''
[1 2 4 5]
[1 3 5]
'''

import numpy as np

# 在二维数组中删除元素
arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 删除索引 1 的列
result_2d = np.delete(arr_2d, 0, axis=0)

# 输出结果
print(result_2d)
'''
[[4 5 6]
 [7 8 9]]
'''

# 删除索引 [0, 2] 的行
result_2d_row = np.delete(arr_2d, [0, 2], axis=0)

# 输出结果
print(result_2d_row)
'''
[[4 5 6]]
'''

十四、统计计算

14.1、mean

该函数用于计算数组中元素的平均值。它可以计算整个数组的平均值，也可以沿着指定的轴（axis）计算平均值。

numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>)

函数	说明
a	输入数组，可以是任何形状的数组。
axis	可选参数，用于指定计算平均值的轴。如果没有指定，则计算整个数组的平均值。如果指定了轴，则计算该轴上元素的平均值。
dtype	可选参数，用于指定返回的平均值的数据类型。如果没有指定，则通常返回与输入数组相同的数据类型。
out	可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有正确的形状。
keepdims	可选参数，如果设置为 True，则计算后的和会保留原始数组的维度，其值默认为False

import numpy as np

# 创建一个一维数组
arr = np.array([1, 2, 3, 4, 5])

# 计算整个数组的平均值
mean_arr = np.mean(arr)

# 输出结果
print(mean_arr)

# 创建一个二维数组
arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr_2d)

# 计算整个二维数组的平均值
mean_arr_2d = np.mean(arr_2d)

# 输出结果
print(mean_arr_2d)

# 计算二维数组沿着列的平均值
mean_arr_2d_col = np.mean(arr_2d, axis=0)

# 输出结果
print(mean_arr_2d_col)

# 计算二维数组沿着行的平均值
mean_arr_2d_row = np.mean(arr_2d, axis=1)

# 输出结果
print(mean_arr_2d_row)

# 使用 keepdims=True 保留维度
mean_arr_2d_row_keepdims = np.mean(arr_2d, axis=1, keepdims=True)

# 输出结果
print(mean_arr_2d_row_keepdims)

a = np.array([np.nan, 1, 2, 3])
b = np.mean(a)
print(b)

'''
3.0
[[1 2 3]
 [4 5 6]
 [7 8 9]]
5.0
[4. 5. 6.]
[2. 5. 8.]
[[2.]
 [5.]
 [8.]]
nan
'''

14.2、sum

该函数用于计算数组中所有元素的和，或者沿指定轴计算元素的和。

numpy.sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)

函数	说明
a	输入数组，可以是任何形状的数组。
axis	可选参数，用于指定计算和的轴。如果没有指定，则计算整个数组的和。如果指定了轴，则计算该轴上元素的和。可以是整数或元组，用于指定多个轴。
dtype	可选参数，指定返回和的数据类型。如果未指定，则通常与输入数组的类型相同，除非输入数组为布尔型，此时默认返回 int64 或 int32。
out	可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有正确的形状。
keepdims	可选参数，如果设置为 True，则计算后的和会保留原始数组的维度，其值默认为False
initial	可选参数，如果提供，则用于指定当数组为空时的初始值。
where	可选参数，用于指定计算和的条件。

import numpy as np

arr = np.array([[1, 2, 3], [4, 0, 6], [7, 8, 9]])
print(arr)

# 计算整个数组的和
total_sum = np.sum(arr)
print(total_sum)

# 计算每一列的和
sum_col = np.sum(arr, axis=0, keepdims=True)
print(sum_col)

# 计算每一行的和
sum_row = np.sum(arr, axis=1)
print(sum_row)

# 保留原始维度
sum_row_keep = np.sum(arr, axis=1, keepdims=True)
print(sum_row_keep)
'''
[[1 2 3]
 [4 0 6]
 [7 8 9]]
40
[[12 10 18]]
[ 6 10 24]
[[ 6]
 [10]
 [24]]
'''

14.3、max和min

numpy.max 和 numpy.min 是 NumPy 库中用于计算数组中元素最大值和最小值的函数

numpy.max(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
numpy.min(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)

函数	说明
a	输入数组，可以是任何形状的数组。
axis	可选参数，用于指定计算最小值、最大值的轴。如果没有指定，则计算整个数组的最小值、最大值。如果指定了轴，则计算该轴上元素的最小值、最大值。
out	可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有正确的形状。
keepdims	可选参数，如果设置为 True，则计算后的最小值、最大值会保留原始数组的维度，其默认值为False
initial	可选参数，如果提供，则用于指定当数组为空时的初始值。
where	可选参数，用于指定计算最小值、最大值的条件。

import numpy as np

arr = np.array([[1, 2, 3], [4, 0, 6], [7, 8, 9]])
print(arr)

# 计算整个数组的最大值
max_val = np.min(arr)
print(max_val)



# 计算每一列的最大值
max_val_col = np.min(arr, axis=0)
print(max_val_col)


# 计算每一行的最大值
max_val_row = np.min(arr, axis=1)
print(max_val_row)
'''
[[1 2 3]
 [4 0 6]
 [7 8 9]]
0
[1 0 3]
[1 0 7]
'''

14.4、var

numpy.var 用于计算数组中所有元素或沿指定轴的方差。方差是衡量一组数值分散程度的统计量，它是各个数值与其平均数差的平方的平均数。

numpy.var(a, axis=None, dtype=None, out=None, keepdims=<no value>)

函数	说明
a	输入数组，可以是任何形状的数组。
axis	可选参数，用于指定计算方差的轴。如果没有指定，则计算整个数组的方差。如果指定了轴，则计算该轴上元素的方差。可以是整数或元组，用于指定多个轴。
dtype	可选参数，指定返回方差的数据类型。如果未指定，则通常与输入数组的类型相同。
out	可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有正确的形状。
keepdims	可选参数，如果设置为True,则计算后的方差会保留原始数组的维度，其值默认为False

import numpy as np

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

# 计算整个数组的方差
total_var = np.var(arr)
print(total_var)

# 计算每一列的方差
var_col = np.var(arr, axis=0)
print(var_col)
# 计算每一行的方差
var_row = np.var(arr, axis=1)
print(var_row)
'''
[[1 2 3]
 [4 5 6]
 [7 8 9]]
6.666666666666667
[6. 6. 6.]
[0.66666667 0.66666667 0.66666667]
'''

14.5、std

numpy.std 用于计算数组中所有元素的标准差，或者沿着指定轴计算标准差。标准差是方差的平方根，它也是一种衡量数据分散程度的统计量。

numpy.std(a, axis=None, dtype=None, out=None, keepdims=<no value>)

函数	说明
a	输入数组，可以是任何形状的数组。
axis	可选参数，用于指定计算标准差的轴。如果没有指定，则计算整个数组的标准差。如果指定了轴，则计算该轴上元素的标准差。可以是整数或元组，用于指定多个轴。
dtype	可选参数，指定返回标准差的数据类型。如果未指定，则通常与输入数组的类型相同。
out	可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有正确的形状。
keepdims	可选参数，如果设置为True,则计算后的标准差会保留原始数组的维度，其值默认为False

import numpy as np

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

total_var = np.var(arr)
print(total_var)
# 计算整个数组的标准差
total_std = np.std(arr)
print(total_std)
# 计算每一列的标准差
std_col = np.std(arr, axis=0)

# 计算每一行的标准差
std_row = np.std(arr, axis=1)


print(std_col)
print(std_row)
'''
0.6666666666666666
0.816496580927726
[0. 0. 0.]
[0.81649658]
'''

14.6、argmax和argmin

numpy.argmax 和 numpy.argmin 是 NumPy 库中的两个函数，它们分别用于找出数组中最大值和最小值的索引位置。

numpy.argmax(a, axis=None, out=None)
numpy.argmin(a, axis=None, out=None)

函数	说明
a	输入数组。如果数组是多维的，则沿着指定的轴搜索最大值或最小值。
axis	可选参数，用于指定搜索最大值或最小值的轴。如果没有指定，则在展平的数组中进行搜索。如果指定了轴，则沿着该轴搜索，并返回该轴上的索引位置。
out	可选参数，如果提供，结果会直接写入到这个数组中。这个数组必须具有正确的形状。

import numpy as np

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

# 找出整个数组中的最大值和最小值的索引位置
max_index = np.argmax(arr)
min_index = np.argmin(arr)

print(max_index)
print(min_index)

# 找出每一列中的最大值和最小值的索引位置
max_index_col = np.argmax(arr, axis=0)
min_index_col = np.argmin(arr, axis=0)


print(max_index_col)
print(min_index_col)


# 找出每一行中的最大值和最小值的索引位置
max_index_row = np.argmax(arr, axis=1)
min_index_row = np.argmin(arr, axis=1)

print(max_index_row)
print(min_index_row)

'''
8
4
[2 2 2]
[0 1 0]
[2 2 2]
[0 1 0]
'''

十五、where函数

numpy.where 是 NumPy 库中的一个非常有用的函数，它可以根据指定的条件返回满足该条件的元素的索引。

当 numpy.where 接受一个条件作为参数时，它会返回一个元组，其中包含满足该条件的元素的索引。

numpy.where(condition)

函数	说明
condition	一个布尔数组或条件表达式。

返回值
一个元组，其中包含满足条件的元素的索引。

import numpy as np

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

result = np.where(condition)
print(result)
'''
[1 2 3 4 5 6 7 8 9]
(array([5, 6, 7, 8]),)
'''