NumPy概述

NumPy是Python中的一个常用开源数学计算扩展库，是Numerical Python的缩写。支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。这使得NumPy在科学计算、统计分析、数据挖掘、机器学习等领域中广泛使用。

Numpy支持常见的数组和矩阵操作。对于同样的数值计算任务，使用Numpy比直接使用Python要简洁的多。

Numpy使用ndarray对象来处理多维数组，该对象是一个快速而灵活的大数据容器。

总之，NumPy是Python中重要的扩展库之一，它对于支持高效的计算和数据分析非常有用。

NumPy官网：https://numpy.org/

NumPy源代码：https://github.com/numpy/numpy

Ndarray对象

Ndarray对象用于存储同一数据类型的多维数组。Ndarray可以支持基于数组的计算以及矢量化操作。

基本使用

# 导入NumPy模块并创建ndarray
import numpy as np
a = np.array([1,2,3,4,5])
print(a) # [1 2 3 4 5]

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

# 调整数组的形状
c = np.array([1,2,3,4,5,6,7,8])
print(c.reshape(2,4))
#[[1 2 3 4]
# [5 6 7 8]]

# 访问数组元素
print(b[2,1]) # 8


# 数组的基本运算
# 加法
print(a + a) # [ 2  4  6  8 10]

# 减法
print(a - a) # [0 0 0 0 0]

# 乘法
print(a * a) # [ 1  4  9 16 25]

# 除法
print(a / a) # [1. 1. 1. 1. 1.]

# 类型
type(a) # numpy.ndarray

Ndarray的属性

在NumPy中，ndarray是多维数组对象。 ndarray类具有各种属性。数组属性反映了数组本身固有的信息。

属性名字	属性解释
ndarray.shape	返回一个元组，其中包含ndarray对象的每个维度的大小
ndarray.ndim	返回数组的维数
ndarray.dtype	返回数组元素的数据类型
ndarray.size	返回数组中的总元素数
ndarray.itemsize	返回数组中每个元素的字节数
nbytes	返回数组中所有元素所占用的字节数
ndarray.T	返回数组的转置视图
ndarray.real	返回数组实部的视图
ndarray.imag	返回数组虚部的视图
ndarray.flat	返回一个数组元素迭代器
ndarray.flags	返回一个描述数组内存块信息的对象，例如是否为C或Fortran连续等
ndarray.strides	返回每个维度中相邻元素的字节数组成的元组，也可以用于判断数组是否是连续的
ndarray.base	如果数组是视图，则返回其基础数组，否则返回None
ndarray.data	返回指向数组内存块的Python缓冲区对象
ndarray.ctypes	返回表示数组内存块的ctypes对象

Ndarray的类型

查看Ndarray的类型

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

type(a.dtype)

创建数组的时候指定类型

a = np.array([[1,2,3],[4,5,6]], dtype=np.int8)

type(a.dtype)

名称	描述	简写
np.bool	用一个字节存储的布尔类型（True或False）	‘b’
np.int_	默认整数类型（通常为int32或int64）	‘i’
np.intc	等同于C语言中的int类型	‘i’
np.intp	用于表示索引的整数类型（通常为int32或int64）	‘i’
np.int8	一个字节大小，-128 至 127	‘i1’
np.int16	短整数，-32768 至 32767	‘i2’
np.int32	标准整数，-2^31​ 至 2^32 -1	‘i4’
np.int64	长整数，-2^63 至 2^63 - 1	‘i8’
np.uint8	无符号整数，0 至 255	‘u’
np.uint16	无符号短整数，0 至 65535	‘u2’
np.uint32	无符号标准整数，0 至 2^32 - 1	‘u4’
np.uint64	无符号长整数，0 至 2^64 - 1	‘u8’
np.float_	默认浮点数类型（通常为float64）	‘f’
np.float16	半精度浮点数：16位，正负号1位，指数5位，精度10位	‘f2’
np.float32	单精度浮点数：32位，正负号1位，指数8位，精度23位	‘f4’
np.float64	双精度浮点数：64位，正负号1位，指数11位，精度52位	‘f8’
np.complex_	默认复数类型，由两个32位浮点数组成，一个表示实部，一个表示虚部	‘c’
np.complex64	由两个32位浮点数组成的复数类型，一个表示实部，一个表示虚部	‘c8’
np.complex128	由两个64位浮点数组成的复数类型，一个表示实部，一个表示虚部	‘c16’
np.object_	python对象	‘O’
np.string_	字符串	‘S’
np.unicode_	unicode类型	‘U’

Ndarray的形状

在Python的NumPy库中，ndarray的形状是指数组的维度和大小。可以使用ndarray.shape属性来获取数组的形状。它返回一个元组，其中包含每个维度的大小。

# 导入NumPy模块并创建ndarray
import numpy as np

# 一维数组
a = np.array([1,2,3,4])
# 形状 (4,):(元素个数)
print(a.shape)
# 二维数组
b = np.array([[1,2,3],[4,5,6]])
# 形状 (2, 3):(行数,列数)
print(b.shape)
# 三维数组
c = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])
# 形状 (2, 2, 3):(层数,行数,列数)
print(c.shape)

形状

(4,)
(2, 3)
(2, 2, 3)

创建数组

NumPy是Python中用于科学计算的核心库之一，创建数组是NumPy最基本和常用的操作之一。

创建数组

import numpy as np 

arr1 = np.array([1, 2, 3]) # 一维数组
print(arr1)
print()

arr2 = np.array([[1, 2, 3], [4, 5, 6]]) # 二维数组
print(arr2)

[1 2 3]

[[1 2 3]
 [4 5 6]]

创建全1数组

使用numpy.zeros()函数创建全1数组

arr3 = np.zeros((3, 4)) # 创建一个3行4列的全零数组
print(arr3)

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

np.zeros(shape, dtype)

import numpy as np

# np.zeros((3, 2, 4), dtype=np.int8)
np.zeros((3, 2, 4))

创建全1数组

使用numpy.ones()函数创建全1数组

arr4 = np.ones((2, 3, 4)) # 创建一个2行3列4深度的全1数组
print(arr4)

[[[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]

 [[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]]

np.ones(shape, dtype)

import numpy as np

# np.ones((3, 2, 4), dtype=np.int8)
np.ones((3, 2, 4))

从已有数组创建新数组

np.zeros_like(a, dtype):创建一个与给定数组a相同形状的全0数组。

a: 输入的数组

dtype: 输出数组的数据类型，可选参数，默认为None，表示输出数组的数据类型与输入数组的数据类型相同。

import numpy as np

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

np.zeros_like(a)

np.ones_like(a, dtype):创建一个与给定数组a相同形状的全1数组。

import numpy as np

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

np.ones_like(a)

np.full_like(a, number):创建一个与给定数组a相同形状，且全是number相同值的数组。

import numpy as np

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

np.full_like(a, 3)

从现有数组生成

np.array(object, dtype) : 复杂形式生成新数组

np.asarray(a, dtype) ：引用形式生成新数组

import numpy as np

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

c = np.asarray(a)
print(c)
print()

# 复杂与引用
a[0,0]=8
print(b)
print()

print(c)

创建等差数列数组

使用numpy.arange()函数创建等差数列数组

arange函数: 用于创建一维等差数列

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

参数：

start表示数列的起始值
stop表示数列的结束值（不包括在数列内）
step表示数列的公差，默认值为1
dtype表示输出数组的数据类型，可选参数，默认为None

[0 2 4 6 8]

arr5 = np.arange(10) # 创建0~9的一维数组
print(arr5)
print()

arr6 = np.arange(10, 20, 2) # 创建10~19，步长为2的一维数组
print(arr6)

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

[10 12 14 16 18]

创建等比数列数组

logspace函数:它是NumPy中用于创建等比数列的函数

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

参数：

start表示数列起始值的对数
stop表示数列结束值的对数
num表示数列的元素个数，默认为50
endpoint表示数列是否包含stop，可选参数，默认为True，表示包含
base表示对数的底数，可选参数，默认为10.0
dtype表示输出数组的数据类型，可选参数，默认为None

start为0，stop为2，num为3，因此生成的数组包括10的0次方、10的1次方、10的2次方、这3个元素

import numpy as np

a = np.logspace(0, 2, 3)
print(a)

[  1.  10. 100.]

创建等间隔数列数组

使用numpy.linspace()函数创建等间隔数列数组

linspace函数: 用于创建一维等间隔数列

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

参数:

start表示数列的起始值
stop表示数列的结束值
num表示数列的元素个数，默认为50
endpoint表示数列是否包含stop，可选参数，默认为True，表示包含
retstep表示是否返回数列的公差，可选参数，默认为False
dtype表示输出数组的数据类型，可选参数，默认为None

[ 0.   2.5  5.   7.5 10. ]
```python
arr7 = np.linspace(0, 10, num=5) # 创建0~10，共5个元素的一维数组
print(arr7)

[ 0.   2.5  5.   7.5 10. ]

创建随机数数组

在NumPy中，可以使用random模块生成随机数组，它提供了许多生成随机数的函数

1.rand(d0, d1, ..., dn)：生成一个[0,1)之间的随机浮点数数组，形状为(d0, d1, …, dn)

import numpy as np

# 生成一个形状为(3,4)的二维随机浮点数数组
arr = np.random.rand(3,4)
print(arr)

[[0.26432437 0.77952426 0.48623514 0.30298591]
 [0.09537777 0.78211903 0.03010303 0.65959564]
 [0.59885643 0.45849452 0.62176301 0.98593692]]

2.randint(low, high=None, size=None, dtype='l')：生成一个指定范围内的随机整数数组，范围为[low, high)，形状为size

import numpy as np

# 生成一个形状为(3,4)的二维随机整数数组，范围在0~9之间
arr = np.random.randint(0, 10, size=(3,4))
print(arr)

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

3.randn(d0, d1, ..., dn)：生成一个符合标准正态分布的随机浮点数数组，形状为(d0, d1, …, dn)。

import numpy as np

# 生成一个形状为(3,4)的二维随机正态分布浮点数数组
arr = np.random.randn(3,4)
print(arr)

[[ 0.29336025 -0.25675439 -0.50450466 -0.4746103 ]
 [ 0.03172494  2.1259797  -0.74760344  0.3182968 ]
 [ 1.17818071 -0.04738495  0.96936186 -0.59401059]]

4.choice(a, size=None, replace=True, p=None)：从序列a中随机选择元素，形状为size。

import numpy as np

# 从序列[1,2,3,4,5]中随机选择3个元素，可以重复选择
arr = np.random.choice([1,2,3,4,5], size=3, replace=True)
print(arr)

[3 5 4]

5.shuffle(x)：将数组x中的元素随机打乱。

import numpy as np

# 将数组[1,2,3,4,5]的元素随机打乱
arr = np.array([1,2,3,4,5])
np.random.shuffle(arr)
print(arr)

[1 4 3 2 5]

6.permutation(x)：生成一个长度为x的随机排列。

import numpy as np

# 生成[1,2,3,4,5]的一个随机排列
arr = np.random.permutation([1,2,3,4,5])
print(arr)

[1 2 5 4 3]

7.uniform(low=0.0, high=1.0, size=None)：生成一个指定范围内的随机浮点数数组，范围为[low, high)，形状为size。

import numpy as np

# 生成范围在0~1之间，形状为(3,4)的随机浮点数数组
arr = np.random.uniform(0, 1, size=(3,4))
print(arr)

[[0.61168926 0.22624021 0.47425274 0.23939561]
 [0.46624301 0.47819303 0.94655511 0.54215361]
 [0.41453386 0.00867036 0.944361   0.21546454]]

8.normal(loc=0.0, scale=1.0, size=None)：生成一个符合正态分布的随机浮点数数组，均值为loc，标准差为scale，形状为size。

import numpy as np

# 生成符合正态分布，均值为2，标准差为0.5，形状为(3,4)的随机浮点数数组
arr = np.random.normal(2, 0.5, size=(3,4))
print(arr)

[[1.17987997 2.56549112 2.44398794 1.87356755]
 [2.32802641 1.48166655 1.83425736 2.19375628]
 [1.95532272 2.37164462 1.1235498  3.20875395]]

创建正态分布创建

在NumPy中，可以使用random模块生成符合正态分布的随机数组，也可以使用numpy.random.normal函数生成符合正态分布的随机数组。

1.使用numpy.random.randn函数生成符合标准正态分布的随机数组。该函数生成的随机数组的均值为0，标准差为1

randn(d0, d1, ..., dn)：生成一个符合标准正态分布的随机浮点数数组，形状为(d0, d1, …, dn)。

import numpy as np

# 生成一个形状为(3,4)的二维随机正态分布浮点数数组
arr = np.random.randn(3,4)
print(arr)

[[ 0.29336025 -0.25675439 -0.50450466 -0.4746103 ]
 [ 0.03172494  2.1259797  -0.74760344  0.3182968 ]
 [ 1.17818071 -0.04738495  0.96936186 -0.59401059]]

2.使用numpy.random.normal函数生成符合正态分布的随机数组

loc表示均值（对应着整个分布的中心centre）

scale表示标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）

size表示生成随机数组的形状，可以是一个整数，也可以是一个元组

import numpy as np

# 生成符合正态分布，均值为2，标准差为0.5，形状为(3,4)的随机浮点数数组
arr = np.random.normal(loc=2, scale=0.5, size=(3,4))
print(arr)

[[2.89275846 1.15803228 1.34008352 1.88054608]
 [1.66740778 1.63232764 2.94805734 1.98300664]
 [2.13753558 2.23281831 2.29074783 2.65143685]]

import numpy as np
# 生成符合正态分布，均值为2，标准差为0.5，形状为(10)的随机浮点数数组
arr = np.random.normal(loc=2, scale=0.5, size=10)
print(arr)

[2.01552148 1.8041927  1.88017211 2.25788431 1.89537179 1.42416331
 1.8956769  1.83538611 2.21150618 1.70890545]

查看分布状况

import numpy as np
# 导入matplotlib
import matplotlib.pyplot as plt

# 生成符合正态分布，均值为2，标准差为0.5，形状为(10)的随机浮点数数组
arr = np.random.normal(loc=2, scale=0.5, size=100)

# 创建画布
plt.figure(figsize=(20, 8), dpi=100)

# 绘制直方图
plt.hist(arr, 100)

# 显示图像
plt.show()

3.使用standard_normal生成符合标准正态分布的随机数组。所谓标准正态分布，是指均值为0，标准差为1的正态分布。

import numpy as np

# 生成符合标准正态分布，形状为(3,4)的随机浮点数数组
arr = np.random.standard_normal(size=(3,4))
print(arr)

[[ 1.12968206 -1.2614278  -0.62009164  0.70146956]
 [-0.10669066 -1.17190998 -0.41877638 -0.7174823 ]
 [ 0.63915822 -0.3381549  -1.89787523 -0.14796177]]

创建均匀分布

1.rand(d0, d1, ..., dn)：生成一个[0,1)之间的随机浮点数数组，形状为(d0, d1, …, dn)。

import numpy as np

# 生成形状为(3,4)的均匀分布随机浮点数数组
arr = np.random.rand(3,4)
print(arr)

2.randint(low, high=None, size=None, dtype='l')：生成一个指定范围内的随机整数数组，范围为[low, high)，形状为size。

# 生成范围在0~9之间，形状为(3,4)的均匀分布随机整数数组
arr = np.random.randint(0, 10, size=(3,4))
print(arr)

3.uniform(low=0.0, high=1.0, size=None)：生成一个指定范围内的随机浮点数数组，范围为[low, high)，形状为size。

import numpy as np

# 生成范围在0~1之间，形状为(3,4)的均匀分布随机浮点数数组
arr = np.random.uniform(0, 1, size=(3,4))
print(arr)

import numpy as np

# 生成范围在0~9之间，形状为(3,4)的均匀分布随机整数数组
arr = np.random.uniform(1, 2, size=(100000))

# 导入matplotlib
import matplotlib.pyplot as plt
# 创建画布
plt.figure(figsize=(20, 8), dpi=100)

# 绘制直方图
plt.hist(arr, 100)

# 显示图像
plt.show()

数组切片和索引

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。

ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作。

切片和索引示例：

a = np.array([1, 2, 3, 4, 5])
print(a[0])     # 输出1
print(a[1:3])   # 输出[2, 3]

b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(b[0, 1])   # 输出2
print(b[1:, :2]) # 输出[[4, 5], [7, 8]]

切片

NumPy数组切片是指从NumPy数组中选择一个子集的操作。

过冒号分隔切片，使用冒号 “:” 分隔起始和结束索引，还可以指定步长。

一维数组：例如 a[1:4] 表示获取数组 a 中从第二个元素到第四个元素的子数组

多维数组：例如 b[1:, :2] 表示获取二维数组 b 中从第二行到最后一行，第一列到第二列的子数组

1.简单数组通过内置的slice函数切片

import numpy as np
 
# 通过 arange() 函数创建 ndarray 对象
a = np.arange(10) # [0 1 2 3 4 5 6 7 8 9]

# 从索引 2 开始到索引 7 停止，间隔为2

s = slice(2,7,2)
print (a[s]) # [2 4 6]

2.基本切片

基本切片使用冒号（:）分隔[start:stop:step]，其中start表示起始位置，stop表示终止位置（不包括该位置），step表示步长。如果没有给定start和step，则默认为0和1。

import numpy as np

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

arr = np.array([0, 1, 2, 3, 4, 5, 6])
# 设置起始，终止和步长的参数
print(arr[:6:2])  # [0 2 4]

3.多维切片

可以使用逗号分隔多个索引值，以访问多维数组中的特定元素。

import numpy as np

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

# b[1:, :2]：表示获取第二行到最后一行，第一列到第二列的子数组
print(b[1:, :2])  #  [[4 5] [7 8]]
# b[:2, ::-1]：表示获取第一行到第二行，倒序获取每一列的子数组
print(b[:2, ::-1])  #  [[3 2 1] [6 5 4]]

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

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

4.切片赋值

可以使用切片运算符来改变数组的部分内容。

import numpy as np

arr = np.array([0, 1, 2, 3, 4, 5, 6])
arr[3:5] = 10
print(arr)  # [ 0  1  2 10 10  5  6]

arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
arr[:2, 1:] = 10
print(arr)  # [[ 0 10 10] [ 3 10 10] [ 6  7  8]]

索引

NumPy数组索引是指用于选择特定元素或子集的方法。

可以使用整数或布尔数组来索引 NumPy 数组。对于一维数组，可以使用一个整数作为索引，对于多维数组，需要使用一个元组来指定每个维度的索引。

一维数组：使用一个整数作为索引，例如 a[0] 表示获取数组 a 的第一个元素

多维数组：需要使用一个元组来指定每个维度的索引，例如 b[0, 1] 表示获取二维数组 b 的第一行的第一列元素

NumPy数组索引的汇总：

1.基本索引

基本索引使用整数索引值访问NumPy数组中的特定元素。

import numpy as np

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

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

2.多维索引

可以使用逗号分隔多个索引值，以访问多维数组中的特定元素。

import numpy as np

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

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

3.花式索引

花式索引是一种使用整数数组进行数组索引的方法，它允许同时获取数组的任意子集，可以是不连续的。

import numpy as np

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

arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
row_indices = [0, 1]
col_indices = [1, 2]
print(arr[row_indices, col_indices])  # [1 5]

4.布尔索引

布尔索引使用布尔值（True或False）来指示数组中的每个元素是否应该被选择。这种索引通常用于根据特定条件选择数组的子集。布尔数组的长度必须与被索引的轴的长度相同。

import numpy as np

arr = np.array([0, 1, 2, 3, 4, 5, 6])
bool_arr = arr > 3
print(arr[bool_arr])  # [4 5 6]

arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
bool_arr = np.array([[False, True, False], [True, False, True], [False, True, False]])
print(arr[bool_arr])  # [1 3 5 7]

a = np.array([1, 2, 3, 4, 5])
mask = np.array([True, False, True, False, True])
print(a[mask])  # 输出 [1 3 5]

b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
mask = np.array([True, False, True])
print(b[mask, :])  # 输出 [[1 2 3] [7 8 9]]

5.索引赋值

NumPy 数组的切片是原始数组的视图，即它们与原始数组共享数据。这意味着，在切片中的任何更改都会反映在原始数组中。

import numpy as np

a = np.array([1, 2, 3, 4, 5])
b = a[1:4]
b[1] = 0
print(a)  # 输出 [1 2 0 4 5]

综合应用示例：

import numpy as np

a = np.array([1, 2, 3, 4, 5])
print(a[0])  # 1
print(a[1])  # 2
print(a[2:])  # [3 4 5]

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

# b[0, 0] 表示获取第一行第一列的元素，即数组的第一个元素，结果为 1
print(b[0, 0])  # 1
print(b[0, 1])  # 2
print(b[0, 2])  # 3
print(b[1, 0])  # 4
print(b[1, 1])  # 5

# 表示获取第一行到最后一行，第二列的子数组
print(b[:, 1])  # [2 5 8]

import numpy as np
 
# 三维
a = np.array([ [[1,2,3],[4,5,6]], [[12,3,34],[5,6,7]]])
print(a)
# a[0, 0, 1] 表示获取第一维的第一个元素，第二维的第一个元素，第三维的第二个元素，即获取第一个二维数组中的第二个元素，结果为 2
# 获取第一维的第一个元素，即 a[0]，得到的是数组 [[1, 2, 3], [4, 5, 6]]。这个数组是原始三维数组 a 的第一个二维数组
# 获取第二维的第二个元素，即 a[0, 1]，得到的是数组 [4, 5, 6]。这个数组是原始三维数组 a 的第一个二维数组中的第二个一维数组。
# 获取第三维的第三个元素，即 a[0, 1, 2]，得到的是整数 6。这个整数是原始三维数组 a 的第一个二维数组中的第二个一维数组的第三个元
print(a[0, 0, 1])   #  2
print(a[0, 1, 2])   #  6
print(a[1, 1, 0])   #  5

高级索引

在索引和切片操作中，可以使用一些参数来指定更复杂的操作

1.整数数组索引

整数数组索引是指使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。

import numpy as np

a = np.array([1, 2, 3, 4, 5])
indices = np.array([0, 2, 4])
print(a[indices])  # 输出 [1 3 5]

b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# row_indices和col_indices分别为长度为2的一维数组，分别表示需要获取的行索引和列索引。
row_indices = np.array([0, 2])
col_indices = np.array([1, 2])
# b[row_indices, col_indices] 表示获取对应行列索引位置的元素，即获取 (0, 1) 和 (2, 2) 位置的元素，
print(b[row_indices, col_indices])  # 输出 [2 9]

2....：用于指定省略号表示在多维数组中使用完整切片

import numpy as np

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

# [[5 6]
#  [7 8]]]
# b[..., 0] 表示获取第三维的第一个元素，即获取每个二维数组中的第一列元素
print(b[..., 0])  # 输出 [[1 3] [5 7]]

3.布尔数组索引：使用布尔数组来获取满足条件的元素

import numpy as np

a = np.array([1, 2, 3, 4, 5])
mask = a > 2
print(a[mask])  # 输出 [3 4 5]

b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
mask = b > 5
print(b[mask])  # 输出 [6 7 8 9]

4.np.newaxis：用于增加数组的维度。

import numpy as np

a = np.array([1, 2, 3])
# [1 2 3]
# a[:, np.newaxis] 表示在行方向上增加一个维度，即将一维数组转换为二维数组
b = a[:, np.newaxis]
#[[1]
# [2]
# [3]]
print(b.shape)  # 输出 (3, 1)

5.where()函数

where()函数是一种将条件作为输入并返回满足条件的元素的索引的方法。

import numpy as np

arr = np.array([0, 1, 2, 3, 4, 5, 6])
indices = np.where(arr > 3)
print(indices)  # (array([4, 5, 6]),)

arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
indices = np.where(arr % 2 == 0)
print(indices)  # (array([0, 0, 1, 2]), array([0, 2, 1, 0]))

6.take()函数

take()函数是一种从数组中提取元素的方法，它使用整数索引值作为输入，并返回对应的元素值。

import numpy as np

arr = np.array([0, 1, 2, 3, 4, 5, 6])
indices = [1, 3, 5]
print(np.take(arr, indices))  # [1 3 5]

arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
indices = [1, 2]
print(np.take(arr, indices, axis=1))  # [[1 2] [4 5] [7 8]]

数组形状的修改

reshape函数

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

用于改变数组的形状，即改变数组的维度大小。它返回一个新的数组，而不改变原始数组。

参数：

a：要改变形状的数组

newshape：新的形状，可以是一个整数、元组或列表。如果为元组或列表，则表示每个维度的大小

order：可选参数，表示返回数组的元素在内存中的存储顺序。
       默认为 'C' 表示按行存储，'F' 表示按列存储，'A' 表示原顺序，'k' 表示元素在内存中的出现顺序。

a = np.array([[1, 2], [3, 4], [5, 6]])
print(a.shape)        # 输出(3, 2)
print(a.reshape(2, 3)) # 输出[[1, 2, 3], [4, 5, 6]]

b = np.array([1, 2, 3, 4, 5, 6])
print(b.reshape(2, -1))  # 输出[[1, 2, 3], [4, 5, 6]]

import numpy as np

a = np.array([[1, 2], [3, 4], [5, 6]])
b = np.reshape(a, (2, 3))  # 将 a 改为 2 行 3 列的数组
print(b)

a是一个 3 行 2 列的数组，使用 reshape() 函数将其改为 2 行 3 列的数组。注意，新的数组的元素顺序是按行存储的

[[1 2 3]
 [4 5 6]]

resize函数

ndarray.resize(new_shape)

用于修改数组的形状和大小，与 reshape() 不同，它会改变原始数组。如果新的大小比原始大小大，则新的数组将填充额外的空间，如果新的大小比原始大小小，则原始数组的一部分元素将被删除。

new_shape：新的形状，可以是一个整数、元组或列表。如果为元组或列表，则表示每个维度的大小。

import numpy as np
# a 是一个 3 行 2 列的数组，使用 resize() 函数将其改为 2 行 3 列的数组。注意，原始数组被修改了，而不是返回一个新的数组
a = np.array([[1, 2], [3, 4], [5, 6]])
a.resize((2, 3))  # 将 a 的大小改为 2 行 3 列
print(a)

[[1 2 3]
 [4 5 6]]

T属性

ndarray.T

用于返回数组的转置，即将数组的行和列交换。它不会修改原始数组，而是返回一个新的数组。

import numpy as np
# a是一个 3 行 2 列的数组，使用 T 属性返回其转置，即 2 行 3 列的数组。注意，原始数组 a 并没有被修改，而是返回了一个新的数组
a = np.array([[1, 2], [3, 4], [5, 6]])
b = a.T  # 返回 a 的转置
print(b)

[[1, 2]
 [3, 4]   
 [5, 6]]
  
[[1 3 5]
 [2 4 6]]

flat属性

numpy.ndarray.flat

用于返回一个数组的一维迭代器，即将数组展开成一个一维数组。它可以用于遍历数组中的每一个元素。

import numpy as np
# a 是一个 3 行 2 列的数组，使用 flat 属性返回一个一维迭代器，然后使用 for 循环遍历数组中的每一个元素
a = np.array([[1, 2], [3, 4], [5, 6]])
for x in a.flat:
    print(x)

1
2
3
4
5
6

flatten函数

ndarray.flatten(order='C')

用于将一个多维数组展开成一个一维数组。它返回一个新的数组，而不改变原始数组。

import numpy as np
# 使用 flatten() 函数将其展开成一个一维数组。注意，原始数组 a 并没有被修改，而是返回了一个新的数组。
a = np.array([[1, 2], [3, 4], [5, 6]])
b = a.flatten()  # 将 a 展开成一个一维数组
print(b) # [1 2 3 4 5 6]

ravel函数

numpy.ravel(a, order='C')

用于将一个多维数组展开成一个一维数组。它与 flatten() 函数类似，但是有一些不同之处。ravel() 函数返回的是原始数组的一个视图，而不是新的数组，如果修改返回的数组，原始数组也会发生改变。

import numpy as np

a = np.array([[1, 2], [3, 4], [5, 6]])
b = np.ravel(a)  # 将 a 展开成一个一维数组
print(b) [1 2 3 4 5 6]

数据类型的修改

astype()

ndarray.astype() ：用于将数组的数据类型转换为指定的数据类型。它返回一个新的数组，而不改变原始数组。

type：要转换成的数据类型，可以是 Python 的数据类型，也可以是 Numpy 的数据类型。

import numpy as np

a = np.array([1, 2, 3])
b = a.astype(float)  # 将 a 转换成浮点数类型
print(b) # [1. 2. 3.]

tobytes()

ndarray.tostring(order='C')
ndarray.tobytes(order='C')

ndarray.tostring() 和 ndarray.tobytes() 函数都用于将数组转换成字符串。它们的作用是相同的，两个函数的参数也相同。tostring()在新版中已弃用。

import numpy as np

a = np.array([1, 2, 3], dtype=np.int32)
b = a.tostring() 
c = a.tobytes()
# 返回的字符串是一个字节串（bytes），每个元素占用 4 个字节
print(b) # b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
print(c) # b'\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'

数组的其他操作

数组运算

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)   # 输出[5, 7, 9]
print(a * b)   # 输出[4, 10, 18]

c = np.array([[1, 2], [3, 4]])
d = np.array([[5, 6], [7, 8]])
print(np.dot(c, d))   # 输出[[19, 22], [43, 50]]

数组去重

1.unique()

np.unique() 函数用于去除数组中的重复元素，并返回一个有序的数组。它可以用于对数组进行去重操作。

np.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None)

参数：

ar：要去重的数组
return_index：可选参数，表示是否返回新数组元素在旧数组中的位置
return_inverse：可选参数，表示是否返回旧数组中元素在新数组中的位置
return_counts：可选参数，表示是否返回每个元素在数组中出现的次数
axis：可选参数，表示沿着哪个轴进行去重操作

import numpy as np
# a 是一个包含重复元素的数组，使用 np.unique() 函数将其去重，并返回一个有序的数组。注意，返回的数组是一个新的数组，原始数组 a 并没有被修改
a = np.array([1, 2, 3, 2, 1, 4, 5, 4])
b = np.unique(a)  # 返回去重后的有序数组
print(b) # [1 2 3 4 5]

2.set()

set() 函数可以将一个数组转换成一个集合，由于集合中不能包含重复元素，因此可以用它来进行数组去重操作。但是，使用 set() 函数会改变数组中元素的顺序。

a = [1, 2, 3, 2, 1, 4, 5, 4]
b = list(set(a))  # 使用 set() 函数进行数组去重
print(b) # [1, 2, 3, 4, 5]

翻转数组

要翻转一个NumPy数组，可以使用numpy.flip()函数。该函数接受一个数组和一个或多个轴参数，并返回按指定轴翻转后的数组。

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("原始数组：")
print(arr)

# 沿着第一个轴翻转数组（行）
arr_flipped = np.flip(arr, axis=0)
print("沿着第一个轴翻转后的数组：")
print(arr_flipped)

# 沿着第二个轴翻转数组（列）
arr_flipped = np.flip(arr, axis=1)
print("沿着第二个轴翻转后的数组：")
print(arr_flipped)

原始数组：
[[1 2 3]
 [4 5 6]]
沿着第一个轴翻转后的数组：
[[4 5 6]
 [1 2 3]]
沿着第二个轴翻转后的数组：
[[3 2 1]
 [6 5 4]]