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的类型

查看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)

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]]