一.Numpy简介
- NumPy（Numerical Python）是一个开源的Python库，用于进行高效的数值计算。它提供了支持多维数组和矩阵运算的功能，并包含大量的数学函数库，便于进行各种数学和科学计算。
核心特点：
-
N维数组对象（ndarray）：
- NumPy的核心是其强大的多维数组对象
ndarray，可以是任意维度的数组（1D、2D、3D等）。 - 数组元素可以是任意类型，但通常是数值类型。
- NumPy的核心是其强大的多维数组对象
-
高效的运算：
- NumPy使用C语言实现，能够处理大量数据时，比Python的本地数据结构快得多。
- 数组运算通常是基于元素的操作，可以避免显式的循环。
-
广播（Broadcasting）：
- NumPy支持广播，使得不同形状的数组能够进行运算，这在处理数据时非常方便。
-
丰富的数学函数：
- 提供了丰富的数学函数库，包括线性代数、傅里叶变换、随机数生成等。
-
数据处理和分析：
- 适合用于数据分析、科学计算、机器学习等领域，通常用于数据的预处理和特征工程。
-
与其他库的兼容性：
- NumPy是许多其他科学计算和数据科学库（如Pandas、SciPy、Matplotlib等）的基础，提供了高效的数组操作。
示例代码：
import numpy as np
# 创建一个一维数组
arr1 = np.array([1, 2, 3, 4])
# 创建一个二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
# 基本运算
arr3 = arr1 + 10 # 每个元素加10
arr4 = arr2 * 2 # 每个元素乘以2
# 数组的形状
print(arr2.shape) # 输出 (2, 3)
# 计算数组的均值
mean_value = np.mean(arr1)
print(arr3)
print(arr4)
print(mean_value)
二.Numpy数据类型
- NumPy支持多种数据类型，以便在进行数值计算时能高效地处理各种数据。以下是NumPy中常用的一些数据类型：
基本数据类型
-
整型（Integer）
np.int8：8位整数，范围从 -128 到 127np.int16：16位整数，范围从 -32,768 到 32,767np.int32：32位整数，范围从 -2,147,483,648 到 2,147,483,647np.int64：64位整数，范围从 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
-
浮点型（Float）
np.float16：16位浮点数np.float32：32位浮点数np.float64：64位浮点数（默认类型）
-
布尔型（Boolean）
np.bool_：表示真（True）或假（False）
-
复数型（Complex）
np.complex64：64位复数（32位实部和32位虚部）np.complex128：128位复数（64位实部和64位虚部）
-
字符串（String）
np.str_：用于表示字符串类型np.bytes_：用于表示字节类型
-
对象类型（Object）
np.object_：通用对象类型，允许存储Python对象。
数据类型转换
NumPy提供了方便的方法来转换数据类型。例如，可以使用astype方法来转换数组的数据类型：
import numpy as np
# 创建一个浮点数数组
arr = np.array([1.5, 2.5, 3.5])
# 转换为整型
arr_int = arr.astype(np.int32)
print(arr_int)
选择数据类型
在创建NumPy数组时，可以通过dtype参数指定所需的数据类型：
# 创建一个整型数组
arr_int = np.array([1, 2, 3], dtype=np.int32)
# 创建一个浮点型数组
arr_float = np.array([1, 2, 3], dtype=np.float64)
# 检查数组的数据类型
print(arr_int.dtype)
print(arr_float.dtype)
三.Numpy数组属性
NumPy数组具有多种属性，可以用于获取有关数组的基本信息。以下是一些常用的NumPy数组属性：
| 属性 | 说明 |
|---|---|
| ndarray.ndim | 秩，即轴的数量或维度的数量 |
| ndarray.shape | 数组的维度，对于矩阵，n 行 m 列 |
| ndarray.size | 数组元素的总个数，相当于 .shape 中 n*m 的值 |
| ndarray.dtype | ndarray 对象的元素类型 |
| ndarray.itemsize | ndarray 对象中每个元素的大小，以字节为单位 |
| ndarray.flags | ndarray 对象的内存信息 |
| ndarray.nbytes | 返回数组占用的内存总字节数，等于size * itemsize |
| ndarray.T | 返回数组的转置（对二维数组进行转置） |
| ndarray.reshape(new_shape) | 返回一个新数组，其形状为new_shape，原数组的数据会被保留。注意，新的形状必须与原数组的元素总数相同 |
| ndarray.astype(new_dtype)` | 返回一个新的数组，数据类型为new_dtype，可用作改变数组数据类型。 |
| ndarray.flatten() | -将多维数组降为一维数组。 |
1. ndarray.shape
- 返回数组的维度（即每个维度的大小），是一个元组。例如，对于二维数组，返回行数和列数。
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.shape) # 输出 (2, 3)
2. ndarray.ndim
- 返回数组的维度数，即数组的秩（rank）。
print(arr.ndim) # 输出 2
3. ndarray.size
- 返回数组的总元素数。
print(arr.size) # 输出 6
4. ndarray.dtype
- 返回数组中元素的数据类型（dtype）。
print(arr.dtype) # 输出 dtype('int64')，取决于创建数组时的数据类型
5. ndarray.itemsize
- 返回数组中元素的字节大小。例如，
int32类型的元素的itemsize为4。
print(arr.itemsize) # 输出 8，表示每个元素占8个字节（int64）
6. ndarray.nbytes
- 返回数组占用的内存总字节数，等于
size * itemsize。
print(arr.nbytes) # 输出 48，表示总共占用48个字节
7. ndarray.T
- 返回数组的转置（对二维数组进行转置）。
print(arr.T) # 输出 [[1 4]
# [2 5]
# [3 6]]
8. ndarray.reshape(new_shape)
- 返回一个新数组，其形状为
new_shape，原数组的数据会被保留。注意，新的形状必须与原数组的元素总数相同。
reshaped_arr = arr.reshape(3, 2)
print(reshaped_arr) # 输出 [[1 2]
# [3 4]
# [5 6]]
9. ndarray.astype(new_dtype)
- 返回一个新的数组，数据类型为
new_dtype，可用作改变数组数据类型。
float_arr = arr.astype(np.float32)
print(float_arr.dtype) # 输出 dtype('float32')
10. ndarray.flatten()
- 将多维数组降为一维数组。
flat_arr = arr.flatten()
print(flat_arr) # 输出 [1 2 3 4 5 6]
四.Numpy创建数组
1.ndarray.array
- 创建一个 ndarray 只需调用 NumPy 的 array 函数即可：
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
参数说明：
| 名称 | 描述 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型，可选 |
| copy | 对象是否需要复制，可选 |
| order | 创建数组的内存存储样式，C为行方向，F为列方向，A为任意方向（默认） |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指定生成数组的最小维度 |
2、numpy.empty
- numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：
numpy.empty(shape, dtype = float, order = 'C')
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
import numpy as np
empty_arr = np.empty((2, 2)) # 创建一个2行2列的数组
print(empty_arr)
- 创建一个指定形状的数组，但不初始化元素，内容是随机的。
3.使用 np.zeros
- 创建一个指定形状的数组，并用0填充,
默认为浮点数。
numpy.zeros(shape, dtype = float, order = 'C')
zeros_arr = np.zeros((2, 3),dtype=int) # 创建一个2行3列的零数组
print(zeros_arr)
[[0 0 0]
[0 0 0]]
4.使用 np.ones
- 创建一个指定形状的数组，并用1填充,
默认为浮点数。
numpy.ones(shape, dtype = None, order = 'C')
参数说明：
ones_arr = np.ones((3, 2)) # 创建一个3行2列的单位数组
print(ones_arr)
""""[[1. 1.]
[1. 1.]
[1. 1.]]
"""
5. numpy.ones_like
- ones_like作用
返回一个新数组，其形状与输入数组相同，所有元素均为1。 - 在需要通过复制现有数组的形状来初始化新的数组（如特征、权重矩阵等）时,
numpy.ones_like函数简化了数组初始化的过程，并确保新的数组与现有数组具有相同的结构。
语法
numpy.ones_like(a, dtype=None, order='K', subok=True)
参数
- a: 输入数组。要创建的数组的形状和数据类型将与此数组相匹配。
- dtype: 可选。输出数组的数据类型。如果未指定，将使用输入数组的dtype。
- order: 可选。指定多维数组的存储顺序，'C’表示行优先（C语言风格），而’F’表示列优先（Fortran语言风格）。
- subok: 可选。如果为True，则返回的数组将保留输入数组的子类。如果为False，将返回常规ndarray。
示例
import numpy as np
# 一个示例数组
arr = np.array([[2, 3], [4, 5]])
# 创建与arr相同形状的全1数组
ones_arr = np.ones_like(arr)
print(ones_arr) # 输出: [[1 1]
# [1 1]]
6. numpy.zeros_like
作用
- 返回一个新数组，其形状与输入数组相同，所有元素均为0。
语法
numpy.zeros_like(a, dtype=None, order='K', subok=True)
参数
- a: 输入数组。要创建的数组的形状和数据类型将与此数组相匹配。
- dtype: 可选。输出数组的数据类型。如果未指定，将使用输入数组的dtype。
- order: 可选。指定多维数组的存储顺序，'C’表示行优先（C语言风格），而’F’表示列优先（Fortran语言风格）。
- subok: 可选。如果为True，则返回的数组将保留输入数组的子类。如果为False，将返回常规ndarray。
示例
import numpy as np
# 一个示例数组
arr = np.array([[2, 3], [4, 5]])
# 创建与arr相同形状的全0数组
zeros_arr = np.zeros_like(arr)
print(zeros_arr) # 输出: [[0 0]
# [0 0]]
7. numpy.fromiter
作用
- 返回一个 NumPy 数组，其元素来自于给定的可迭代对象。
语法
numpy.fromiter(iterable, dtype, count=-1)
参数
- iterable: 可以是任何 iterable（可迭代对象），如列表、元组、生成器等。
- dtype: 要创建的输出数组的数据类型。可以是 NumPy 数据类型（如
np.int32、np.float64等）或类型字符串（如'int'、'float'）。 - count: 可选，整数，指定要从迭代器中读取的元素数量。如果设置为 -1，则读取所有元素，直到迭代结束。
示例
import numpy as np
# 创建一个生成器
gen = (x * x for x in range(5))
# 从生成器创建 NumPy 数组
arr = np.fromiter(gen, dtype=int)
print(arr) # 输出: [0 1 4 9 16]
numpy.fromiter: 主要用于从可迭代对象直接创建 NumPy 数组，适合用于生成器或大型数据流。
8. numpy.asarray
作用
- 返回一个 NumPy 数组。如果输入
a已经是 NumPy 数组，asarray会返回原数组，而不会进行复制。这与np.array()函数有所不同，后者总是会创建新数组。
语法
numpy.asarray(a, dtype=None, order=None)
参数
- a: 输入数据，可以是列表、元组、数组或其他可用数据结构。
- dtype: 可选，指定输出数组的数据类型。如果未指定，则根据输入的数据类型确定。
- order: 可选，指定多维数组的存储顺序，'C’表示行优先（C语言风格），而 ‘F’ 表示列优先（Fortran语言风格）。
示例
import numpy as np
# 创建一个列表
lst = [1, 2, 3, 4]
# 将列表转换为 NumPy 数组
a = np.asarray(lst)
print(a) # 输出: [1 2 3 4]
# 创建一个 NumPy 数组
b = np.array([5, 6, 7])
# 使用 asarray，不会复制原数组
a = np.asarray(b)
print(a is b) # 输出: True，表示没有复制
9. numpy.linspace
作用
- 返回一个包含从
start到stop的等间距值的 NumPy 数组（数量由num指定）。
语法
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
参数
- start: 序列的起始值。
- stop: 序列的结束值。
- num: 可选，生成的样本数量，默认值为 50。
- endpoint: 可选，布尔值，指示是否包括
stop值，默认值为True。 - retstep: 可选，布尔值，如果为
True，则返回样本之间的步长。 - dtype: 可选，指定返回数组的数据类型。
示例
import numpy as np
# 生成5个从0到1的等间距数
arr = np.linspace(0, 1, num=5)
print(arr) # 输出: [0. 0.25 0.5 0.75 1. ]
# 生成5个从0到1的等间距数，并返回步长
arr, step = np.linspace(0, 1, num=5, retstep=True)
print(arr) # 输出: [0. 0.25 0.5 0.75 1. ]
print(step) # 输出: 0.25
# 生成5个从0到1的等间距数，不包含stop值（末尾值），并返回步长
arr, step = np.linspace(0, 1, num=5, retstep=True,endpoint=False)
print(arr) # 输出: [0. 0.2 0.4 0.6 0.8]
print(step) # 输出: 0.2
- 如果需要在一个指定的范围内生成固定数量的值（例如绘图中），使用
linspace。
10. numpy.arange
作用
- 返回一个 NumPy 数组，包含从
start到stop的值，按step指定的间隔生成。
语法
numpy.arange(start, stop, step, dtype])
参数
- start: 可选，序列的起始值，默认为 0。
- stop: 生成序列的结束值（不包括该值）。
- step: 可选，生成序列的间隔，默认为 1。
- dtype: 可选，指定返回数组的数据类型。
示例
import numpy as np
# 生成从0到10的数（不包括10），步长为2
arr = np.arange(0, 10, step=2)
print(arr) # 输出: [0 2 4 6 8]
numpy.asarray: 用于将其他数据结构（如列表、元组等）转换为 NumPy 数组，能有效避免不必要的复制，尤其在处理已经是 NumPy 数组的情况时。numpy.arange: 通常用于生成指定范围和步长的数值序列，适合用在循环、索引等场景。
在 NumPy 中，切片和索引是对数组进行访问和操作的重要手段，与 Python 基础切片类似，但 NumPy 提供了更强大的功能。以下是 NumPy 中切片和索引的基本用法。
五. 数组索引
- 索引: 用来访问数组的单个元素，支持整数索引和多维索引。
可以通过索引直接访问数组的单个元素。
import numpy as np
arr = np.array([10, 20, 30, 40, 50])
print(arr[0]) # 输出: 10
print(arr[2]) # 输出: 30
1.2 多维数组索引
对于多维数组，可以使用元组指定每个维度的索引。
import numpy as np
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(matrix[1, 2]) # 输出: 6 (第二行第三列的元素)
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print (a[...,1]) # 第2列元素
print (a[1,...]) # 第2行元素
print (a[...,1:]) # 第2列及剩下的所有元素
六. 切片
- 切片: 用来选择数组的一个子集，支持一维和多维数组的切片。
- 布尔索引: 根据条件选择数组中的元素。
- 花式索引: 允许使用整数数组来选择特定位置的元素。
1.1 一维数组切片
可以通过 start:stop:step 的语法来切片。
arr = [10,20,30,40,50,60]
# 选择元素从索引1到4（不包括4）
sliced_arr = arr[1:4]
print(sliced_arr) # 输出: [20 30 40]
1.2 多维数组切片
对多维数组进行切片时，可以对每一维进行切片。
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 选取矩阵的前两行和前两列
b = a[:2, :2]
print(b)
# 输出:
# [[1 2]
# [4 5]]
1.3 省略某个维度的切片
- 当只对某一维进行切片时，可以使用冒号（
:）省略。
import numpy as np
# 选择第二行的所有元素
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a[1, :]) # 输出: [4 5 6]
- 获取数组中 (0,0)，(1,1) 和 (2,0) 位置处的元素。
import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]]
print(y)#[1 4 5]
2. 布尔索引
布尔索引允许根据条件选择数组的元素。
# 选择大于20的元素
arr =np.array([10,20,30,40,50,60])
bool_index = arr[arr > 20]
print(bool_index) # 输出: [30 40 50]
使用 ~（取补运算符）来过滤 NaN。
import numpy as np
a = np.array([np.nan, 1,2,np.nan,3,4,5])
print (a[~np.isnan(a)])
从数组中过滤掉非复数元素。
import numpy as np
a = np.array([1, 2+6j, 5, 3.5+5j])
print (a[np.iscomplex(a)])
3. 花式索引
花式索引允许使用整数数组来访问数组中的特定元素。
indices = np.array([0, 2, 4])
print(arr[indices]) # 输出: [10 30 50]
# 对于二维数组
row_indices = np.array([0, 1, 2])
col_indices = np.array([1, 0, 2])
print(matrix[row_indices, col_indices]) # 输出: [2 4 9]
4. 修改切片
在 NumPy 中，切片创建的视图是可变的，对切片的修改会影响原数组。
sliced_arr[0] = 100
print(arr) # 输出: [100 20 30 40 50]
作业：
- 取数列，x_train为不要最后一列的前80%数列，x_test为不要最后一列的后20%数列，y_train为最后一列前80%数列，y_text为最后一列后20%数列
import numpy as np
# 定义原始数组
arr = np.array([[12, 80, 0, 20, 6.0, 21, 100],
[12, 80, 0, 20, 6.0, 21, 200],
[12, 80, 0, 20, 6.0, 21, 300],
[12, 80, 0, 20, 6.0, 21, 400],
[12, 80, 0, 20, 6.0, 21, 500],
[12, 80, 0, 20, 6.0, 21, 600],
[12, 80, 0, 20, 6.0, 21, 700],
[12, 80, 0, 20, 6.0, 21, 800],
[12, 80, 0, 20, 6.0, 21, 900],
[12, 80, 0, 20, 6.0, 21, 1000]])
# 提取X和y
X = arr[:, :-1] # 不包括最后一列
y = arr[:, -1] # 只包括最后一列
# 计算80%索引
split_index = int(len(arr) * 0.8)
# 划分训练集和测试集
x_train = X[:split_index]
x_test = X[split_index:]
y_train = y[:split_index]
y_test = y[split_index:]
# 打印结果
print("x_train:\n", x_train)
print("x_test:\n", x_test)
print("y_train:\n", y_train)
print("y_test:\n", y_test)
结果如下：
x_train:
[[12. 80. 0. 20. 6. 21.]
[12. 80. 0. 20. 6. 21.]
[12. 80. 0. 20. 6. 21.]
[12. 80. 0. 20. 6. 21.]
[12. 80. 0. 20. 6. 21.]
[12. 80. 0. 20. 6. 21.]
[12. 80. 0. 20. 6. 21.]
[12. 80. 0. 20. 6. 21.]]
x_test:
[[12. 80. 0. 20. 6. 21.]
[12. 80. 0. 20. 6. 21.]]
y_train:
[100 200 300 400 500 600 700 800]
y_test:
[ 900 1000]
扫一扫
1184
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
