python中numpy的介绍

介绍numpy

NumPy是一个开源的Python科学计算库，它提供了一个强大的多维数组对象（例如数组和矩阵）以及用于处理这些数组的各种函数。NumPy的核心是ndarray（N-dimensional array）对象，它是一个快速而灵活的大数据集容器。

以下是NumPy的一些主要特点和功能：
1. **多维数组对象**：NumPy提供了ndarray对象，可以存储多维数组，这些数组可以是一维、二维甚至更高维。
   
2. **广播功能**：NumPy支持广播功能，使得在不同形状的数组上进行数学运算变得更加方便和高效。
   
3. **数学函数**：NumPy包含许多内置的数学函数，用于数组的操作，如求和、平均值、最小值、最大值、标准差等。
   
4. **线性代数运算**：NumPy提供了丰富的线性代数函数库，包括矩阵乘法、求逆、特征值等。
   
5. **随机数生成**：NumPy有强大的随机数生成功能，可以用于模拟和生成随机数据。
   
6. **索引和切片**：NumPy提供了灵活的索引和切片功能，可以方便地访问数组中的元素。
   
7. **性能优化**：NumPy的底层实现是用C语言编写的，因此在处理大型数据集时具有很高的性能。

总的来说，NumPy是Python科学计算领域中不可或缺的工具之一，许多其他科学计算库（如SciPy、Pandas等）都是基于NumPy构建的。通过NumPy，用户可以高效地进行数据处理、数学计算、统计分析等操作。

import numpy as np
print(np.__version__)

查看numpy版本。

numpy的用法

生成数组

array()函数

用于生成数组。

函数格式

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

参数解释

1. 列表或元组：最常见的用法是将Python的列表或元组作为参数传递给numpy.array()函数。这些列表或元组中的元素将会被转换为NumPy数组的元素。

2. dtype参数：dtype参数用于指定所创建数组的数据类型。例如，dtype=np.float32表示创建一个数据类型为单精度浮点数的数组。如果不指定dtype，则NumPy会根据输入数据自动推断数据类型。

3. ndmin参数：ndmin参数用于指定数组的最小维度。例如，ndmin=2表示至少创建一个二维数组。如果输入数据的维度小于ndmin指定的值，NumPy会自动添加轴来满足最小维度要求。

4. copy参数：copy参数默认为True，表示会复制输入的数据以避免原始数据被修改。如果设置为False，则创建的数组与输入数据共享相同的内存，对数组的操作可能会影响原始数据。

5. order参数：order参数用于指定创建数组时使用的内存布局。常用的取值有'C'和'F'，分别表示按行（C顺序）和按列（Fortran顺序）存储。这个参数在处理多维数组时尤为重要。

6. subok参数：subok参数用于控制是否返回子类数组。如果subok为True，则返回一个子类数组，否则返回一个基类数组。这对于需要返回特定类型的数组对象时很有用。

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

np.asarray函数

该函数将python序列转换为数组。

函数结构

numpy.asarray(a, dtype = None, order = None)

参数及描述

1.a 任意形式的输入参数，比如列表、列表的元组、元组、元组的元组、元组的列表

2.dtype 通常，输入数据的类型会应用到返回的ndarray

3.order 'C'为按行的 C 风格数组，'F'为按列的 Fortran 风格数组

arange()函数

函数格式

arange(start, stop, step, dtype)

• start：序列的起始值，生成的数列从该值开始。
• stop：序列的结束值，生成的数列不包含该值，即在数列中不会出现等于stop的元素。
• step：两个相邻值之间的差值，也称为步长。step可以是正数、负数或零，控制数列中相邻元素之间的间隔。
• dtype：可选参数，指定所创建数组的数据类型。如果不指定dtype，则NumPy会根据输入参数自动推断数据类型。

arr3=np.arange(10)
print(arr3)
arr4=np.arange(1,10)
print(arr4)
arr5=np.arange(1,10,2)
print(arr5)

 linspace()函数

函数的作用：在指定区间内生成指定个数的数组。

函数格式

linspace(start,stop,num)

1. start：数列的起始值。
2. stop：数列的结束值。
3. num：生成的等差数列中包含的元素个数。

该函数的数据区间为闭区间。 endpoint=False，使生成数据区间变为左闭右开区间。

arr6=np.linspace(1,10,20)
print(arr6)

linspace(0, 10, 5, endpoint=False)

zeros()和ones()函数

np.zeros()函数生成的数组由0来填充，
np.ones()生成的数组由1来填。

arr7=np.zeros((3,4))
print(arr7)
arr8=np.ones((3,4))
print(arr8)

zeros_like和ones()函数

这两个函数需要借助别的数组进行操作，生成一个新的数组不对原来的数组进行修改。

arr9=np.ones_like(arr7)
print(arr9)
print(arr7)

数组的属性

np.ndim

返回int。表示数组的维数。

print(np.ndim(arr7))
结果是2

np.shape

返回tuple，表示数组的尺寸，对于n行m列的矩阵，形状为(n,m)

print(np.shape(arr7))
(3,4)

np.size

返回int，表示数组的元素总数，等于数组形状的乘积。

print(np.size(arr7))
12

np.dtype

函数结构

numpy.dtype(object, align, copy)

Object：被转换为数据类型的对象。

Align：如果为true，则向字段添加间隔，使其类似 C 的结构体。

Copy ：生成dtype对象的新副本，如果为flase，结果是内建数据类型对象的引用。

可以使用 np.dtype 来指定数组的数据类型，或者通过已有数组的 dtype 属性来获取其数据类型

import numpy as np

# 指定数组的数据类型为整数
arr_int = np.array([1, 2, 3, 4], dtype=np.int32)

# 获取数组的数据类型
arr_float = np.array([1.1, 2.2, 3.3])
dtype_float = arr_float.dtype

print(arr_int)
print(dtype_float)

print(arr7.dtype)
float64

数据类型

数据类型及描述

1.bool_ 存储为一个字节的布尔值（真或假）

2.int_ 默认整数，相当于 C 的long，通常为int32或int64

3.intc 相当于 C 的int，通常为int32或int64

4.intp 用于索引的整数，相当于 C 的size_t，通常为int32或int64

5.int8 字节（-128 ~ 127）

6.int16 16 位整数（-32768 ~ 32767）

7.int32 32 位整数（-2147483648 ~ 2147483647）

8.int64 64 位整数（-9223372036854775808 ~ 9223372036854775807）

9.uint8 8 位无符号整数（0 ~ 255）

10.uint16 16 位无符号整数（0 ~ 65535）

11.uint32 32 位无符号整数（0 ~ 4294967295）

12.uint64 64 位无符号整数（0 ~ 18446744073709551615）

13.float_ float64的简写

14.float16 半精度浮点：符号位，5 位指数，10 位尾数

15.float32 单精度浮点：符号位，8 位指数，23 位尾数

16.float64 双精度浮点：符号位，11 位指数，52 位尾数

17.complex_ complex128的简写

18.complex64 复数，由两个 32 位浮点表示（实部和虚部）

19.complex128 复数，由两个 64 位浮点表示（实部和虚部）

np.itemsize

返回int。表示数组的每一个元素的大小。

print(arr7.itemsize)
8

np.reshape()

可以对原数组进行重构。但生成的是一个新的数组，原数组不变。

print(arr1.reshape(3,1))
print(arr1)
[[1]
 [2]
 [3]]
[1 2 3]

numpy.resize

该函数返回指定大小的新数组。如果新数组大于原数组大小，则包含原数组的重复副本

numpy.resize(arr, shape)

arr：要修改大小的输入数组

shape：返回数组的新形状

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

numpy.append()

该函数在输入数组的末尾添加值。

 
numpy.append(arr, values, axis)

 arr：输入数组

values：要向arr添加的值，比如和arr形状相同（除了要添加的轴）

axis：沿着它完成操作的轴。如果没有提供，两个参数都会被展开，0是行，1是列。

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.shape)
print(a)
b=np.append(a,[7,8,9])
print(b)
c=np.append(a,[[7,8,9]],axis=0)
print(c)
d=np.append(a,[[1,1,1],[2,2,2]],axis=1)
print(d)
(2, 3)
[[1 2 3]
 [4 5 6]]
[1 2 3 4 5 6 7 8 9]
[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[1 2 3 1 1 1]
 [4 5 6 2 2 2]]

数组的运算

一维数组被称为向量，二维数组被称为矩阵。

np.sin(), np.cos(), np.tan(): 三角函数

# 数学函数示例
arr = np.array([0, np.pi/4, np.pi/2, 3*np.pi/4, np.pi])
sin_arr = np.sin(arr)
print(sin_arr)  # 计算数组中每个元素的正弦值

np.exp(), np.log(), np.log10(): 指数和对数函数

np.sqrt(), np.power(): 平方根和幂函数

np.abs(): 绝对值函数

exp_value = np.exp(2)  # 计算 e 的幂次方
log_value = np.log(10)  # 计算自然对数
sqrt_value = np.sqrt(16)  # 计算平方根
abs_value = np.abs(-5)  # 计算绝对值
print(exp_value, log_value, sqrt_value, abs_value)
7.38905609893065 2.302585092994046 4.0 5

np.sum(), np.mean(), np.max(), np.min(): 求和、均值、最大值、最小值 矩阵操作：

data = np.array([1, 2, 3, 4, 5])
sum_value = np.sum(data)
mean_value = np.mean(data)
max_value = np.max(data)
min_value = np.min(data)
print(sum_value, mean_value, max_value, min_value)
15 3.0 5 1

np.dot(): 矩阵乘法

matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6], [7, 8]])
product = np.dot(matrix1, matrix2)
print(product)  # 计算两个矩阵的乘积
[[19 22]
 [43 50]]

np.transpose(), np.reshape(): 转置和改变数组形状

即将矩阵的行和列互换位置，得到的转置矩阵

transposed_matrix = np.transpose(matrix1)
reshaped_matrix = np.reshape(matrix1, (1, 4))
print(transposed_matrix, reshaped_matrix)
[[1 3]
 [2 4]] 
[[1 2 3 4]]

np.linalg.inv(), np.linalg.det(): 求逆矩阵和行列式

逆矩阵是指对于矩阵 A，存在一个矩阵 B，使得 A * B = B * A = I，其中 I 是单位矩阵。

行列式是一个与方阵相关的标量值，可以用来判断矩阵是否可逆以及计算变换的缩放比例等信息。对于 2x2 矩阵，行列式的计算方法为 ad - bc。

inv_matrix = np.linalg.inv(matrix1)
det_value = np.linalg.det(matrix1)
print(inv_matrix, det_value)
[[-2.   1. ]
 [ 1.5 -0.5]]
 -2.0000000000000004

np.logical_and(), np.logical_or(), np.logical_not(): 逻辑与、或、非

np.all(), np.any(): 全部为真和任意为真

bool_arr1 = np.array([True, False, True])
bool_arr2 = np.array([False, False, True])
result_and = np.logical_and(bool_arr1, bool_arr2)
result_or = np.logical_or(bool_arr1, bool_arr2)
result_not = np.logical_not(bool_arr1)
print(result_and, result_or, result_not)
[False False  True] [ True False  True] [False  True False]

np.concatenate(), np.vstack(), np.hstack(): 数组拼接

np.split(), np.hsplit(), np.vsplit(): 数组分割

arr1 = np.array([[1, 2], [3, 4]])
arr2 = np.array([[5, 6]])
concatenated = np.concatenate((arr1, arr2), axis=0)
split_array = np.split(arr1, 2)
print(concatenated, split_array)
[[1 2]
 [3 4]
 [5 6]] 
[array([[1, 2]]), array([[3, 4]])]

1. `np.concatenate((arr1, arr2), axis=0)`:
   - `arr1` 和 `arr2`：这是要连接的两个数组。
   - `axis=0`：这是指定连接的轴方向。在这里，`axis=0` 表示沿着行的方向进行连接。如果 `axis=1`，则表示沿着列的方向进行连接。

2. `np.split(arr1, 2)`:
   - `arr1`：这是要分割的数组。
   - `2`：这是指定分割的位置或分割成几部分。在这里，`2` 表示将数组分割为两部分。如果想要分割成不同大小的部分，可以传递一个数组作为参数，其中包含分割点的索引。

广播

广播（broadcasting）是 NumPy 中一种强大的机制，它允许不同形状的数组在算术运算时表现得好像它们的形状相同。这样我们可以直接对数组进行运算，而不需要手动扩展数组的形状。广播的原则如下：

1. 如果两个数组的维度不相同，那么小维度数组的形状会在最左边补1，直到形状一致。
2. 如果两个数组的形状在任何维度上不匹配且不为1，那么会引发错误。

   加法
   # 创建一个二维数组
   a = np.array([[1, 2, 3], [4, 5, 6]])
   b = np.array([10, 20, 30])
   
   # 对数组 a 和 b 进行加法运算（b会被自动扩展为与a相同的形状）
   result = a + b
   
   print(result)
   乘法
   A = np.array([[1, 2, 3], [4, 5, 6]])
   B = np.array([[10, 20, 30]])
   
   result = A * B
   
   print(result)
   [[11 22 33]
    [14 25 36]]
   [[ 10  40  90]
    [ 40 100 180]]

   numpy切片

1. 基本切片：

   • 使用 : 分隔起始索引和结束索引，如 array[start:end]。
   • 可以使用负数索引，表示从末尾开始计数。

2. 多维数组切片：

   • 对于多维数组，可以使用逗号 , 分隔不同维度的切片。
   • 例如，array[start_row:end_row, start_col:end_col] 可以同时对行和列进行切片。

3. 步长切片：

   • 使用 start:end:step 的形式，可以指定切片的步长。
   • 例如，array[::2] 表示从头到尾，步长为 2 进行切片。

import numpy as np

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

# 切片操作示例
print("原始数组：\n", arr)

# 获取第一行
print("第一行：", arr[0])

# 获取第一列
print("第一列：", arr[:, 0])

# 获取子矩阵：第一行到第二行，第一列到第二列
print("子矩阵：\n", arr[0:2, 0:2])

# 按步长切片
print("按步长切片：", arr[::2])

# 使用负数索引
print("负数索引切片：", arr[-2:, -2:])

原始数组：
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
第一行： [1 2 3]
第一列： [1 4 7]
子矩阵：
 [[1 2]
 [4 5]]
按步长切片： [[1 2 3]
 [7 8 9]]
负数索引切片： [[5 6]
 [8 9]]

 numpy索引

1. 基本索引：

   • 使用整数索引来访问数组中的单个元素，如 array[index]。
   • 对于多维数组，可以使用逗号 , 分隔不同维度的索引。

2. 切片索引：

   • 使用切片操作来获取数组的子集，如 array[start:end]。
   • 可以针对单个维度或多个维度同时进行切片索引。

3. 布尔索引：

   • 使用布尔数组作为索引，可以根据条件选择数组中的元素。
   • 布尔数组的长度必须与原数组对应维度的长度相匹配。

import numpy as np

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

# 基本索引示例
print("一维数组第三个元素：", arr1d[2])
print("二维数组第二行第三列元素：", arr2d[1, 2])

# 切片索引示例
print("一维数组切片：", arr1d[1:4])
print("二维数组切片：\n", arr2d[:2, 1:])

# 布尔索引示例
mask = arr1d > 2
mask1 = arr2d > 2
print("一维数组大于2的元素：", arr1d[mask])
print("二维数组", arr2d[mask1])

一维数组第三个元素： 3
二维数组第二行第三列元素： 6
一维数组切片： [2 3 4]
二维数组切片：
 [[2 3]
 [5 6]]
一维数组大于2的元素： [3 4 5]
二维数组 [3 4 5 6 7 8 9]