Python NumPy - 数组的算术运算 加减乘除的向量化操作

👋 大家好，欢迎来到我的技术博客！ 📚 在这里，我会分享学习笔记、实战经验与技术思考，力求用简单的方式讲清楚复杂的问题。 🎯 本文将围绕NumPy这个话题展开，希望能为你带来一些启发或实用的参考。 🌱 无论你是刚入门的新手，还是正在进阶的开发者，希望你都能有所收获！

文章目录

• Python NumPy 数组的算术运算：加减乘除的向量化操作 🚀
• • 什么是向量化操作？🧠
  • NumPy 数组的基本创建 🛠️
  • 基本算术运算 🔢
  • • 加法运算 ➕
    • 减法运算 ➖
    • 乘法运算 ✖️
    • 除法运算 ➗
  • 广播机制详解 📡
  • 特殊值处理 ⚠️
  • 高级算术运算 🧮
  • 性能比较 📊
  • 实际应用场景 💼
  • • 数据标准化 📈
    • 图像处理 🖼️
    • 金融数据分析 💰
  • 数组重塑与转置 🔁
  • 条件运算与掩码 🎭
  • 数学函数库 📚
  • 错误处理与调试 🛠️
  • 内存优化技巧 💾
  • 最佳实践总结 📋
  • 性能优化建议 ⚡
  • 结语 🎯

Python NumPy 数组的算术运算：加减乘除的向量化操作 🚀

NumPy 是 Python 中进行科学计算的核心库之一，它提供了高效的多维数组对象和丰富的数学函数库。在数据科学、机器学习和数值计算领域，NumPy 的向量化操作是提高计算效率的关键技术。本文将深入探讨 NumPy 数组的算术运算，包括加法、减法、乘法和除法等基本操作，并详细介绍其背后的向量化原理。

什么是向量化操作？🧠

向量化操作是 NumPy 的核心概念之一。与传统的循环遍历数组元素的方式不同，向量化操作允许我们对整个数组或数组的一部分同时执行相同的运算。这种方式不仅代码更加简洁易读，而且执行效率更高，因为底层使用了优化过的 C 语言实现。

import numpy as np

# 传统方式：使用循环
arr1 = [1, 2, 3, 4, 5]
arr2 = [6, 7, 8, 9, 10]
result_loop = []
for i in range(len(arr1)):
result_loop.append(arr1[i] + arr2[i])

# 向量化方式：使用 NumPy
np_arr1 = np.array([1, 2, 3, 4, 5])
np_arr2 = np.array([6, 7, 8, 9, 10])
result_vectorized = np_arr1 + np_arr2

print("循环结果:", result_loop)
print("向量化结果:", result_vectorized.tolist())

NumPy 数组的基本创建 🛠️

在深入了解算术运算之前，让我们先了解如何创建 NumPy 数组：

import numpy as np

# 创建一维数组
arr_1d = np.array([1, 2, 3, 4, 5])
print("一维数组:", arr_1d)

# 创建二维数组
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("二维数组:\\n", arr_2d)

# 创建零数组
zeros_array = np.zeros(5)
print("零数组:", zeros_array)

# 创建全一数组
ones_array = np.ones((3, 3))
print("全一数组:\\n", ones_array)

# 创建范围数组
range_array = np.arange(0, 10, 2)
print("范围数组:", range_array)

# 创建线性间隔数组
linspace_array = np.linspace(0, 1, 5)
print("线性间隔数组:", linspace_array)

基本算术运算 🔢

加法运算 ➕

加法是最基础的算术运算之一，在 NumPy 中可以通过多种方式实现：

import numpy as np

# 标量与数组相加
arr = np.array([1, 2, 3, 4, 5])
scalar_addition = arr + 10
print("标量加法:", scalar_addition)

# 数组与数组相加（相同形状）
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
array_addition = arr1 + arr2
print("数组加法:", array_addition)

# 不同维度数组的广播加法
matrix = np.array([[1, 2, 3], [4, 5, 6]])
vector = np.array([10, 20, 30])
broadcast_addition = matrix + vector
print("广播加法:\\n", broadcast_addition)

# 使用 np.add 函数
explicit_addition = np.add(arr1, arr2)
print("显式加法:", explicit_addition)

减法运算 ➖

减法运算同样支持多种形式：

import numpy as np

# 标量与数组相减
arr = np.array([10, 20, 30, 40, 50])
scalar_subtraction = arr – 5
print("标量减法:", scalar_subtraction)

# 数组与数组相减
arr1 = np.array([10, 20, 30])
arr2 = np.array([1, 2, 3])
array_subtraction = arr1 – arr2
print("数组减法:", array_subtraction)

# 负数运算
negative_arr = –arr1
print("负数运算:", negative_arr)

# 使用 np.subtract 函数
explicit_subtraction = np.subtract(arr1, arr2)
print("显式减法:", explicit_subtraction)

乘法运算 ✖️

乘法运算包括元素级乘法和矩阵乘法：

import numpy as np

# 元素级乘法（Hadamard 积）
arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([2, 3, 4, 5])
elementwise_multiplication = arr1 * arr2
print("元素级乘法:", elementwise_multiplication)

# 标量乘法
scalar_multiplication = arr1 * 3
print("标量乘法:", scalar_multiplication)

# 矩阵乘法
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[5, 6], [7, 8]])
matrix_multiplication = np.dot(matrix_a, matrix_b)
print("矩阵乘法 (np.dot):\\n", matrix_multiplication)

# 使用 @ 运算符进行矩阵乘法（Python 3.5+）
matrix_multiplication_at = matrix_a @ matrix_b
print("矩阵乘法 (@ 运算符):\\n", matrix_multiplication_at)

# 使用 np.multiply 进行元素级乘法
explicit_multiplication = np.multiply(arr1, arr2)
print("显式元素级乘法:", explicit_multiplication)

除法运算 ➗

除法运算也分为元素级除法和其他特殊形式：

import numpy as np

# 元素级除法
arr1 = np.array([10, 20, 30, 40])
arr2 = np.array([2, 4, 5, 8])
elementwise_division = arr1 / arr2
print("元素级除法:", elementwise_division)

# 标量除法
scalar_division = arr1 / 2
print("标量除法:", scalar_division)

# 整数除法
integer_division = arr1 // arr2
print("整数除法:", integer_division)

# 取模运算
modulo_operation = arr1 % arr2
print("取模运算:", modulo_operation)

# 幂运算
power_operation = arr1 ** 2
print("幂运算:", power_operation)

# 使用 np.divide 进行显式除法
explicit_division = np.divide(arr1, arr2)
print("显式除法:", explicit_division)

广播机制详解 📡

广播（Broadcasting）是 NumPy 中一个非常强大的特性，它允许不同形状的数组进行算术运算。理解广播机制对于高效使用 NumPy 至关重要。

import numpy as np

# 示例 1: 标量与数组的广播
scalar = 5
array_1d = np.array([1, 2, 3])
result1 = scalar + array_1d
print("标量与一维数组广播:", result1)

# 示例 2: 一维数组与二维数组的广播
array_1d = np.array([1, 2, 3])
array_2d = np.array([[10], [20], [30]])
result2 = array_1d + array_2d
print("一维与二维数组广播:\\n", result2)

# 示例 3: 复杂广播情况
a = np.array([1, 2, 3]) # 形状: (3,)
b = np.array([[1], [2], [3]]) # 形状: (3, 1)
c = np.array([[[1]], [[2]], [[3]]]) # 形状: (3, 1, 1)
result3 = a + b + c
print("复杂广播结果:\\n", result3)
print("结果形状:", result3.shape)

#mermaid-svg-zCUxs7C5Hn9ehVJD{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-zCUxs7C5Hn9ehVJD .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-zCUxs7C5Hn9ehVJD .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-zCUxs7C5Hn9ehVJD .error-icon{fill:#552222;}#mermaid-svg-zCUxs7C5Hn9ehVJD .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-zCUxs7C5Hn9ehVJD .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-zCUxs7C5Hn9ehVJD .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-zCUxs7C5Hn9ehVJD .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-zCUxs7C5Hn9ehVJD .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-zCUxs7C5Hn9ehVJD .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-zCUxs7C5Hn9ehVJD .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-zCUxs7C5Hn9ehVJD .marker{fill:#333333;stroke:#333333;}#mermaid-svg-zCUxs7C5Hn9ehVJD .marker.cross{stroke:#333333;}#mermaid-svg-zCUxs7C5Hn9ehVJD svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-zCUxs7C5Hn9ehVJD p{margin:0;}#mermaid-svg-zCUxs7C5Hn9ehVJD .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-zCUxs7C5Hn9ehVJD .cluster-label text{fill:#333;}#mermaid-svg-zCUxs7C5Hn9ehVJD .cluster-label span{color:#333;}#mermaid-svg-zCUxs7C5Hn9ehVJD .cluster-label span p{background-color:transparent;}#mermaid-svg-zCUxs7C5Hn9ehVJD .label text,#mermaid-svg-zCUxs7C5Hn9ehVJD span{fill:#333;color:#333;}#mermaid-svg-zCUxs7C5Hn9ehVJD .node rect,#mermaid-svg-zCUxs7C5Hn9ehVJD .node circle,#mermaid-svg-zCUxs7C5Hn9ehVJD .node ellipse,#mermaid-svg-zCUxs7C5Hn9ehVJD .node polygon,#mermaid-svg-zCUxs7C5Hn9ehVJD .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-zCUxs7C5Hn9ehVJD .rough-node .label text,#mermaid-svg-zCUxs7C5Hn9ehVJD .node .label text,#mermaid-svg-zCUxs7C5Hn9ehVJD .image-shape .label,#mermaid-svg-zCUxs7C5Hn9ehVJD .icon-shape .label{text-anchor:middle;}#mermaid-svg-zCUxs7C5Hn9ehVJD .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-zCUxs7C5Hn9ehVJD .rough-node .label,#mermaid-svg-zCUxs7C5Hn9ehVJD .node .label,#mermaid-svg-zCUxs7C5Hn9ehVJD .image-shape .label,#mermaid-svg-zCUxs7C5Hn9ehVJD .icon-shape .label{text-align:center;}#mermaid-svg-zCUxs7C5Hn9ehVJD .node.clickable{cursor:pointer;}#mermaid-svg-zCUxs7C5Hn9ehVJD .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-zCUxs7C5Hn9ehVJD .arrowheadPath{fill:#333333;}#mermaid-svg-zCUxs7C5Hn9ehVJD .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-zCUxs7C5Hn9ehVJD .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-zCUxs7C5Hn9ehVJD .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-zCUxs7C5Hn9ehVJD .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-zCUxs7C5Hn9ehVJD .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-zCUxs7C5Hn9ehVJD .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-zCUxs7C5Hn9ehVJD .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-zCUxs7C5Hn9ehVJD .cluster text{fill:#333;}#mermaid-svg-zCUxs7C5Hn9ehVJD .cluster span{color:#333;}#mermaid-svg-zCUxs7C5Hn9ehVJD div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-zCUxs7C5Hn9ehVJD .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-zCUxs7C5Hn9ehVJD rect.text{fill:none;stroke-width:0;}#mermaid-svg-zCUxs7C5Hn9ehVJD .icon-shape,#mermaid-svg-zCUxs7C5Hn9ehVJD .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-zCUxs7C5Hn9ehVJD .icon-shape p,#mermaid-svg-zCUxs7C5Hn9ehVJD .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-zCUxs7C5Hn9ehVJD .icon-shape .label rect,#mermaid-svg-zCUxs7C5Hn9ehVJD .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-zCUxs7C5Hn9ehVJD .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-zCUxs7C5Hn9ehVJD .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-zCUxs7C5Hn9ehVJD :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

是

否

是

否

广播规则检查

维度是否匹配?

直接运算

是否满足广播条件?

自动扩展维度

抛出错误

执行运算

特殊值处理 ⚠️

在实际应用中，我们经常遇到包含特殊值（如 NaN、无穷大）的数组，NumPy 提供了专门的函数来处理这些情况：

import numpy as np

# 包含特殊值的数组
arr_with_nan = np.array([1, 2, np.nan, 4, 5])
arr_with_inf = np.array([1, 2, np.inf, 4, 5])

# 检查特殊值
print("NaN 检查:", np.isnan(arr_with_nan))
print("无穷大检查:", np.isinf(arr_with_inf))

# 安全的算术运算
safe_addition = np.nansum([1, 2, np.nan, 4]) # 忽略 NaN
print("安全加法:", safe_addition)

# 处理除零错误
with np.errstate(divide='ignore'):
division_result = np.array([1, 2, 3]) / 0
print("除零结果:", division_result)

高级算术运算 🧮

除了基本的四则运算，NumPy 还提供了许多高级的数学运算：

import numpy as np

# 对数和指数运算
arr = np.array([1, 2, 3, 4, 5])
log_result = np.log(arr)
exp_result = np.exp(arr)
print("自然对数:", log_result)
print("自然指数:", exp_result)

# 幂运算和平方根
power_result = np.power(arr, 2)
sqrt_result = np.sqrt(arr)
print("平方运算:", power_result)
print("平方根:", sqrt_result)

# 三角函数
angles = np.array([0, np.pi/4, np.pi/2, np.pi])
sin_result = np.sin(angles)
cos_result = np.cos(angles)
tan_result = np.tan(angles)
print("正弦值:", sin_result)
print("余弦值:", cos_result)
print("正切值:", tan_result)

# 绝对值和符号函数
signed_arr = np.array([–3, –1, 0, 1, 3])
abs_result = np.abs(signed_arr)
sign_result = np.sign(signed_arr)
print("绝对值:", abs_result)
print("符号函数:", sign_result)

性能比较 📊

为了展示向量化操作的优势，让我们通过一个简单的性能测试来比较循环和向量化操作：

import numpy as np
import time

# 创建大型数组用于测试
size = 1000000
arr1 = np.random.rand(size)
arr2 = np.random.rand(size)

# 循环方式
start_time = time.time()
result_loop = []
for i in range(len(arr1)):
result_loop.append(arr1[i] + arr2[i])
loop_time = time.time() – start_time

# 向量化方式
start_time = time.time()
result_vectorized = arr1 + arr2
vectorized_time = time.time() – start_time

print(f"循环方式耗时: {loop_time:.4f} 秒")
print(f"向量化方式耗时: {vectorized_time:.4f} 秒")
print(f"性能提升倍数: {loop_time/vectorized_time:.2f}x")

实际应用场景 💼

数据标准化 📈

在机器学习和数据分析中，数据标准化是一个常见的预处理步骤：

import numpy as np

# 模拟数据集
data = np.random.randn(1000, 5) # 1000个样本，5个特征

# Z-score 标准化
mean = np.mean(data, axis=0)
std = np.std(data, axis=0)
normalized_data = (data – mean) / std

print("原始数据均值:", np.mean(data, axis=0))
print("标准化后均值:", np.mean(normalized_data, axis=0))
print("原始数据标准差:", np.std(data, axis=0))
print("标准化后标准差:", np.std(normalized_data, axis=0))

图像处理 🖼️

在图像处理中，像素值的操作经常需要用到数组算术运算：

import numpy as np

# 模拟图像数据 (高度 x 宽度 x 通道)
image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)

# 图像亮度调整
brightness_factor = 1.2
brightened_image = np.clip(image * brightness_factor, 0, 255).astype(np.uint8)

# 图像对比度调整
contrast_factor = 1.5
contrast_adjusted = np.clip(128 + contrast_factor * (image – 128), 0, 255).astype(np.uint8)

print("原图像形状:", image.shape)
print("亮度调整后形状:", brightened_image.shape)
print("对比度调整后形状:", contrast_adjusted.shape)

金融数据分析 💰

在金融分析中，收益率计算是基础操作：

import numpy as np

# 模拟股价数据
prices = np.array([100, 102, 98, 105, 110, 108, 112])

# 计算简单收益率
simple_returns = (prices[1:] – prices[:–1]) / prices[:–1]
print("简单收益率:", simple_returns)

# 计算对数收益率
log_returns = np.diff(np.log(prices))
print("对数收益率:", log_returns)

# 计算累计收益
cumulative_return = (prices[–1] – prices[0]) / prices[0]
print("累计收益率:", cumulative_return)

数组重塑与转置 🔁

在进行算术运算前，有时需要对数组进行重塑或转置操作：

import numpy as np

# 创建数组
original_array = np.arange(12)
print("原始数组:", original_array)

# 重塑数组
reshaped_array = original_array.reshape(3, 4)
print("重塑后数组:\\n", reshaped_array)

# 转置数组
transposed_array = reshaped_array.T
print("转置后数组:\\n", transposed_array)

# 扁平化数组
flattened_array = reshaped_array.flatten()
print("扁平化数组:", flattened_array)

# 在重塑后进行运算
matrix1 = np.array([[1, 2], [3, 4]])
matrix2 = np.array([[5, 6, 7], [8, 9, 10]])

# 尝试不兼容的运算
try:
incompatible_result = matrix1 + matrix2
except ValueError as e:
print("不兼容运算错误:", e)

# 通过广播进行兼容运算
compatible_matrix = np.array([[1], [2]])
broadcast_result = matrix1 + compatible_matrix
print("广播兼容运算结果:\\n", broadcast_result)

条件运算与掩码 🎭

NumPy 还支持基于条件的算术运算：

import numpy as np

# 创建示例数据
data = np.array([1, –2, 3, –4, 5, –6, 7, 8, –9, 10])

# 使用 where 进行条件运算
positive_data = np.where(data > 0, data, 0)
negative_data = np.where(data < 0, data, 0)
print("正值保留:", positive_data)
print("负值保留:", negative_data)

# 条件替换
replaced_data = np.where(data > 5, data * 2, data)
print("大于5的值翻倍:", replaced_data)

# 布尔掩码运算
mask = data > 0
masked_positive_sum = np.sum(data[mask])
print("正值求和:", masked_positive_sum)

# 复合条件
complex_mask = (data > 0) & (data < 6)
filtered_data = data[complex_mask]
print("0到6之间的值:", filtered_data)

数学函数库 📚

NumPy 提供了丰富的数学函数，这些函数都支持向量化操作：

import numpy as np

# 创建测试数据
x = np.linspace(–2*np.pi, 2*np.pi, 100)

# 基本数学函数
y_sin = np.sin(x)
y_cos = np.cos(x)
y_tan = np.tan(x)

# 指数和对数函数
y_exp = np.exp(x)
y_log = np.log(np.abs(x) + 1e-10) # 添加小值避免 log(0)

# 双曲函数
y_sinh = np.sinh(x)
y_cosh = np.cosh(x)

# 舍入函数
rounded_data = np.round(np.random.rand(10) * 10, 2)
floored_data = np.floor(rounded_data)
ceiled_data = np.ceil(rounded_data)

print("随机数据:", rounded_data[:5])
print("向下取整:", floored_data[:5])
print("向上取整:", ceiled_data[:5])

# 统计函数
statistics_data = np.random.randn(1000)
print("均值:", np.mean(statistics_data))
print("标准差:", np.std(statistics_data))
print("方差:", np.var(statistics_data))
print("中位数:", np.median(statistics_data))
print("最大值:", np.max(statistics_data))
print("最小值:", np.min(statistics_data))

错误处理与调试 🛠️

在使用 NumPy 进行算术运算时，可能会遇到各种错误，了解如何处理这些错误很重要：

import numpy as np

# 维度不匹配错误
try:
arr1 = np.array([1, 2, 3])
arr2 = np.array([[1, 2], [3, 4]])
result = arr1 + arr2
except ValueError as e:
print("维度不匹配错误:", e)

# 数据类型错误处理
try:
string_array = np.array(['a', 'b', 'c'])
numeric_result = string_array + 1
except TypeError as e:
print("数据类型错误:", e)

# 除零警告
with np.errstate(divide='warn', invalid='warn'):
zero_division = np.array([1, 2, 3]) / 0
print("除零结果:", zero_division)

# 自定义错误处理
def safe_divide(a, b):
"""安全除法函数"""
with np.errstate(divide='ignore', invalid='ignore'):
result = np.divide(a, b)
result[~np.isfinite(result)] = np.nan
return result

test_a = np.array([1, 2, 3, 4])
test_b = np.array([1, 0, 2, 0])
safe_result = safe_divide(test_a, test_b)
print("安全除法结果:", safe_result)

内存优化技巧 💾

在处理大型数组时，内存管理变得非常重要：

import numpy as np

# 使用 in-place 操作节省内存
large_array = np.random.rand(1000000)

# 非 in-place 操作（会创建新数组）
# new_array = large_array + 1 # 创建新的数组

# in-place 操作（修改原数组）
large_array += 1 # 直接修改原数组
print("in-place 操作完成")

# 使用视图而不是副本
original = np.arange(100)
view = original[::2] # 创建视图，不复制数据
copy = original[::2].copy() # 创建副本

print("视图共享内存:", np.shares_memory(original, view))
print("副本独立内存:", np.shares_memory(original, copy))

# 内存映射数组处理大文件
# mmap_array = np.memmap('large_file.dat', dtype='float32', mode='w+', shape=(10000, 10000))

最佳实践总结 📋

基于以上讨论，以下是一些使用 NumPy 进行算术运算的最佳实践：

import numpy as np

# 综合示例：股票价格分析
def analyze_stock_prices(prices):
"""
分析股票价格数据

参数:
prices: 股票价格数组

返回:
dict: 包含各种分析指标的字典
"""
# 确保输入是 numpy 数组
prices = np.asarray(prices)

if len(prices) < 2:
raise ValueError("至少需要两个价格点")

# 计算收益率
returns = np.diff(prices) / prices[:–1]

# 计算统计指标
analysis = {
'mean_price': np.mean(prices),
'price_std': np.std(prices),
'total_return': (prices[–1] – prices[0]) / prices[0],
'volatility': np.std(returns),
'max_drawdown': np.min(returns),
'sharpe_ratio': np.mean(returns) / (np.std(returns) + 1e-8) # 避免除零
}

return analysis

# 测试示例
sample_prices = np.array([100, 102, 98, 105, 110, 108, 112, 115, 113, 118])
results = analyze_stock_prices(sample_prices)

print("股票价格分析结果:")
for key, value in results.items():
print(f"{key}: {value:.4f}")

性能优化建议 ⚡

为了获得最佳性能，以下是一些额外的优化建议：

import numpy as np
import time

# 性能测试函数
def performance_test():
size = 1000000

# 测试不同的数据类型
float64_array = np.random.rand(size).astype(np.float64)
float32_array = np.random.rand(size).astype(np.float32)

# 测试运算速度
start = time.time()
result64 = np.sum(float64_array ** 2)
time64 = time.time() – start

start = time.time()
result32 = np.sum(float32_array ** 2)
time32 = time.time() – start

print(f"Float64 运算时间: {time64:.4f} 秒")
print(f"Float32 运算时间: {time32:.4f} 秒")
print(f"性能提升: {time64/time32:.2f}x")

performance_test()

# 使用 numba 进一步加速（如果可用）
try:
from numba import jit

@jit(nopython=True)
def fast_sum(arr):
total = 0.0
for i in range(len(arr)):
total += arr[i] * arr[i]
return total

test_array = np.random.rand(1000000)
start = time.time()
result_numba = fast_sum(test_array)
numba_time = time.time() – start

start = time.time()
result_numpy = np.sum(test_array ** 2)
numpy_time = time.time() – start

print(f"Numba 时间: {numba_time:.4f} 秒")
print(f"NumPy 时间: {numpy_time:.4f} 秒")

except ImportError:
print("Numba 未安装，跳过 JIT 编译测试")

结语 🎯

NumPy 的向量化算术运算是现代科学计算的基础。通过本文的学习，你应该已经掌握了：

• 基本的加减乘除运算
• 广播机制的工作原理
• 特殊值的处理方法
• 高级数学函数的应用
• 性能优化的技巧
• 实际应用场景

记住，熟练掌握 NumPy 的关键在于实践。建议你在日常工作中多尝试使用这些技术，逐渐培养对向量化思维的理解。随着经验的积累，你会发现 NumPy 不仅能让代码更加优雅，还能显著提升程序的执行效率。

更多关于 NumPy 的详细信息，可以参考 NumPy 官方文档，那里有最权威和完整的参考资料。如果你想深入了解 Python 科学计算生态系统，SciPy 和 pandas 也是值得学习的重要工具。

通过不断练习和探索，你将在数据科学和数值计算的道路上越走越远！🚀

🙌 感谢你读到这里！ 🔍 技术之路没有捷径，但每一次阅读、思考和实践，都在悄悄拉近你与目标的距离。 💡 如果本文对你有帮助，不妨 👍 点赞、📌 收藏、📤 分享 给更多需要的朋友！ 💬 欢迎在评论区留下你的想法、疑问或建议，我会一一回复，我们一起交流、共同成长 🌿 🔔 关注我，不错过下一篇干货！我们下期再见！✨