Python 商务数据分析—— NumPy 学习笔记Ⅰ

NumPy是高性能科学计算库，专为多维数组设计，采用C语言实现，运算速度远超Python列表。主要特性包括矢量运算、广播机制和丰富的数学函数库，广泛应用于数据分析、机器学习和科学计算领域。核心数据结构ndarray要求元素类型一致，支持高效向量化运算。创建数组方式多样，包括从列表/元组转换(np.array)、生成序列(np.arange)、随机数组(np.random)以及特殊函数(zeros/

幻奏岚音

1176人浏览 · 2025-06-22 20:45:09

幻奏岚音 · 2025-06-22 20:45:09 发布

一、NumPy 简介

1.1 NumPy 特性

高性能科学计算库：专为处理多维数组设计，底层用 C 语言实现，运算速度远超 Python 原生列表。

矢量运算：支持批量数据操作，避免显式循环，代码更简洁高效。

广播机制：自动处理不同形状数组间的运算。

丰富函数库：包含线性代数、傅里叶变换、随机数等功能。

1.2 应用场景

数据分析：处理大规模结构化数据。

机器学习：作为 TensorFlow/PyTorch 等框架的底层支持。

科学计算：物理模拟、统计学分析。

图像处理：多维数组表示像素数据。

1.3 安装与导入

pip install numpy

import numpy as np

二、NumPy 基础 —— 数组对象

2.1 数组与列表对比

特性	NumPy 数组 (ndarray)	Python 列表 (list)
数据类型	元素类型必须一致	可包含任意类型元素
内存存储	连续内存空间，访问速度快	非连续存储，访问较慢
运算效率	支持向量化运算，速度快	需显式循环，速度慢
维度支持	支持 n 维数组	仅支持一维结构

2.2 创建数组的四种方式

方法	语法	示例
np.array()	从列表 / 元组创建	arr1 = np.array([10, 20, 30, 40])
np.arange()	生成等差数列	arr2 = np.arange(0, 10, 2)
np.random	生成随机数组	arr3 = np.random.random((2, 3))
特殊函数	zeros/ones/full/eye	arr_zeros = np.zeros((3, 3))

代码示例

通过`np.array`创建数组

import numpy as np
a = np.array([1, 2, 3, 4])
print(a)  # 输出结果: [1 2 3 4]

通过`np.arange`创建数组

import numpy as np
a = np.arange(0, 10, 2)  # 创建0-10,步数为2的数组
print(a)  # 输出结果: [0 2 4 6 8]

通过`np.random.random`创建数组

import numpy as np
a = np.random.random((2, 3))
print(a)  # 输出类似于: [[0.04631855 0.21257259 0.73199394]
                     #          [0.59865848 0.15601864 0.15599452]]

通过特殊函数创建数组

import numpy as np
array_zeros = np.zeros((3, 3))  # 3行3列全零数组
array_ones = np.ones((4, 4))   # 4行4列全一数组
array_full = np.full((2, 3), 9)  # 值为9的2行3列数组
array_eye = np.eye(4)  # 生成一个在斜方形上元素为1,其他元素都为0的4行4列矩阵
print(array_zeros)  # 输出: [[0. 0. 0.]
                     #               [0. 0. 0.]
                     #               [0. 0. 0.]]
print(array_ones)  # 输出: [[1. 1. 1. 1.]
                     #               [1. 1. 1. 1.]
                     #               [1. 1. 1. 1.]
                     #               [1. 1. 1. 1.]]
print(array_full)  # 输出: [[9 9 9]
                     #                [9 9 9]]
print(array_eye)  # 输出: [[1. 0. 0. 0.]
                     #               [0. 1. 0. 0.]
                     #               [0. 0. 1. 0.]
                     #               [0. 0. 0. 1.]]

三、数组数据类型

3.1 核心数据类型

类型	描述	标识符	示例
bool	布尔值	b	True/False
int8	1 字节整数	i1	-128~127
int32	4 字节整数	i4	-2147483648~2147483647
float16	半精度浮点数	f2	16 位，精度约 3 位小数
float64	双精度浮点数	f8	标准浮点数
object	Python 对象	O	存储类实例等

3.2 类型操作

查询数据类型

import numpy as np

class Person:  # 定义Person类
    def __init__(self, name, age):
        self.name = name
        self.age = age

zs = Person('张三', 18)  # 产生对象
ls = Person('李四', 20)
d = np.array([zs, ls])
print(d)  # 输出: [__main__.Person object at 0x00000176CB4F2208 __main__.Person object at 0x00000176CB4F2288]
print(d.dtype)  # 输出: dtype('O')

创建数组指定数据类型

import numpy as np
a = np.array([1, 2, 3, 4, 5], dtype='int32')  # 使用dtype指定创建数组的数据类型
print(a)  # 输出结果: [1 2 3 4 5]
print(a.dtype)  # 输出: int32

修改数据类型

import numpy as np
a = np.array([1, 2, 3, 4, 5])
f = a.astype('float16')  # 使用astype改变数组的数据类型
print(f.dtype)  # 输出结果: float16

四、多维数组操作

4.1 维度与形状

数组	维度 (ndim)	形状 (shape)	含义
[1,2,3]	1	(3,)	一维数组，3 个元素
[[1,2],[3,4]]	2	(2,2)	2 行 2 列二维数组
[[[1,2],[3,4]],[[5,6],[7,8]]]	3	(2,2,2)	3 维数组，2 个 2x2 矩阵

4.2 基本操作

数组维度查询

import numpy as np
a1 = np.array([1, 2, 3])
a2 = np.array([[1, 2, 3], [4, 5, 6]])
a3 = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(a1.ndim)  # 输出: 1
print(a2.ndim)  # 输出: 2
print(a3.ndim)  # 输出: 3

数组形状查询

import numpy as np
a1 = np.array([1, 2, 3])
a2 = np.array([[1, 2, 3], [4, 5, 6]])
a3 = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print(a1.shape)  # 输出: (3,)
print(a2.shape)  # 输出: (2, 3)
print(a3.shape)  # 输出: (2, 2, 3)

修改数组形状

import numpy as np
a1 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
a2 = a1.reshape((2, 6))  # reshape是将数组转换成指定的形状，然后返回转换后的结果，原数组的形状不会发生改变
print(a2)  # 输出: [[ 1  2  3  4  5  6]
             #          [ 7  8  9 10 11 12]]
print(a1.shape)  # 输出: (4, 3)
a1.resize((4, 3))  # resize是将数组转换成指定的形状，会直接修改数组本身，并且不会返回任何值
print(a1)  # 输出: [[1 2 3]
            #          [4 5 6]
            #          [7 8 9]
            #          [10 11 12]]

通过特殊函数创建数组

import numpy as np
array_zeros = np.zeros((3, 3))  # 3行3列全零数组
array_ones = np.ones((4, 4))   # 4行4列全一数组
array_full = np.full((2, 3), 9)  # 值为9的2行3列数组
array_eye = np.eye(4)  # 生成一个在斜方形上元素为1,其他元素都为0的4行4列矩阵
print(array_zeros)  # 输出: [[0. 0. 0.]
                     #               [0. 0. 0.]
                     #               [0. 0. 0.]]
print(array_ones)  # 输出: [[1. 1. 1. 1.]
                     #               [1. 1. 1. 1.]
                     #               [1. 1. 1. 1.]
                     #               [1. 1. 1. 1.]]
print(array_full)  # 输出: [[9 9 9]
                     #                [9 9 9]]
print(array_eye)  # 输出: [[1. 0. 0. 0.]
                     #               [0. 1. 0. 0.]
                     #               [0. 0. 1. 0.]
                     #               [0. 0. 0. 1.]]

4.3 素组索引

下标索引

import numpy as np
a = np.arange(6)  # 一维数组
print(a)  # 输出: [0 1 2 3 4 5]
print(a[2])  # 输出: 2
print(a[-2])  # 输出: 4（从后往前数第2个）

a = np.arange(9).reshape(3, 3)  # 二维数组
print(a)  # 输出: [[0 1 2]
           #          [3 4 5]
           #          [6 7 8]]
print(a[0][1])  # 输出: 1
print(a[0, 1])  # 输出: 1

切片索引

import numpy as np
a = np.arange(6)  # 一维数组
print(a)  # 输出: [0 1 2 3 4 5]
print(a[1:5])  # 输出: [1 2 3 4]
print(a[1:5:2])  # 输出: [1 3]
print(a[::2])  # 输出: [0 2 4]
print(a[::-1])  # 输出: [5 4 3 2 1 0]

a = np.arange(9).reshape(3, 3)  # 二维数组
print(a)  # 输出: [[0 1 2]
           #          [3 4 5]
           #          [6 7 8]]
print(a[1:3, 1:2])  # 输出: [[4]
                     #               [7]]
print(a[1, :])  # 输出: [3 4 5]
print(a[1, ...])  # 输出: [3 4 5]
print(a[:, 1])  # 输出: [1 4 7]

花式索引

import numpy as np
a = np.arange(6)  # 一维数组
print(a)  # 输出: [0 1 2 3 4 5]
print(a[[1, 2, 5]])  # 输出: [1 2 5]
print(a[np.array([(0, 1, 3), (1, 4, 5)])])  # 输出: [[0 1 3]
                                                #                [1 4 5]]

a = np.arange(9).reshape(3, 3)  # 二维数组
print(a)  # 输出: [[0 1 2]
           #          [3 4 5]
           #          [6 7 8]]
print(a[[1, 0]])  # 输出: [[3 4 5]
                   #                [0 1 2]]
print(a[[0, 2], 1])  # 输出: [1 7]
print(a[np.ix_([0, 1], [0, 1])])  # 输出: [[0 1]
                                   #                [3 4]]

布尔索引

import numpy as np
a = np.arange(6)  # 一维数组
print(a)  # 输出: [0 1 2 3 4 5]
print(a > 3)  # 输出: [False False False False  True  True]
print(a[a > 3])  # 输出: [4 5]

a = np.arange(9).reshape(3, 3)  # 二维数组
print(a)  # 输出: [[0 1 2]
           #          [3 4 5]
           #          [6 7 8]]
print(a > 3)  # 输出: [[False False False]
               #               [False  True  True]
               #               [ True  True  True]]
print(a[a > 3])  # 输出: [4 5 6 7 8]