简体中文 繁體中文 English Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français Japanese

开启辅助访问 切换到宽版

站内搜索

搜索
AI 风月

活动公告

通知：来制造点氛围！（增加进阶任务）
03-01 22:34
通知：版主招募中！来加入我们吧！
03-01 19:23
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

Python NumPy输出技巧全解析 从基础打印到高级数据展示助你轻松掌握科学计算结果的呈现方式

威震华夏关云长
SunJu_FaceMall

3万

主题

361

科技点

3万

积分

白金月票

碾压王

积分
32697

立华奏
发表于 2025-10-8 09:30:00 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

NumPy（Numerical Python）是Python科学计算的核心库，提供了高性能的多维数组对象以及用于处理这些数组的工具。在数据科学、机器学习、科学计算和工程领域，NumPy被广泛使用。然而，仅仅能够计算数据是不够的，如何有效地展示和呈现计算结果同样重要。本文将全面解析NumPy的输出技巧，从基础的打印方法到高级的数据展示技术，帮助你轻松掌握科学计算结果的呈现方式。

NumPy基础打印方法

基本打印函数

NumPy中最简单的输出方式是使用Python内置的print()函数。当你打印一个NumPy数组时，它会以可读的格式显示数组的结构和内容。
  2. import numpy as np
  4. # 创建一个简单的数组
  5. arr = np.array([1, 2, 3, 4, 5])
  6. print(arr)
  7. # 输出: [1 2 3 4 5]
  9. # 创建一个二维数组
  10. arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
  11. print(arr_2d)
  12. # 输出:
  13. # [[1 2 3]
  14. #  [4 5 6]]
复制代码

打印选项设置

NumPy提供了set_printoptions()函数，允许你控制数组的显示方式。这对于大型数组特别有用，因为默认情况下NumPy可能会截断数组的显示。
  2. # 创建一个大型数组
  3. large_arr = np.arange(1000)
  5. # 默认打印（会被截断）
  6. print(large_arr)
  7. # 输出: [  0   1   2 ... 997 998 999]
  9. # 设置打印选项显示更多元素
  10. np.set_printoptions(threshold=1000)  # 设置显示阈值为1000
  11. print(large_arr)  # 现在会显示所有元素
  13. # 重置为默认值
  14. np.set_printoptions(threshold=1000)  # 默认阈值是1000
复制代码

格式化输出

你可以使用set_printoptions()的formatter参数来自定义数组元素的显示格式。
  2. # 创建一个浮点数数组
  3. float_arr = np.array([0.123456789, 1.23456789, 12.3456789])
  5. # 默认打印
  6. print(float_arr)
  7. # 输出: [ 0.12345679  1.2345679  12.3456789 ]
  9. # 设置浮点数精度
  10. np.set_printoptions(precision=4)  # 设置小数点后4位
  11. print(float_arr)
  12. # 输出: [ 0.1235  1.2346 12.3457]
  14. # 使用formatter参数进行更复杂的格式化
  15. np.set_printoptions(formatter={'float': '{: 0.2f}'.format})
  16. print(float_arr)
  17. # 输出: [ 0.12  1.23 12.35]
复制代码

中级输出技巧

控制打印精度

在科学计算中，控制数值的显示精度非常重要。NumPy允许你通过set_printoptions()函数的precision参数来控制浮点数的显示精度。
  2. # 创建一个包含小数的数组
  3. precise_arr = np.array([3.141592653589793, 2.718281828459045, 1.4142135623730951])
  5. # 设置不同的精度
  6. np.set_printoptions(precision=2)
  7. print("精度为2:", precise_arr)
  8. # 输出: 精度为2: [3.14 2.72 1.41]
  10. np.set_printoptions(precision=4)
  11. print("精度为4:", precise_arr)
  12. # 输出: 精度为4: [3.1416 2.7183 1.4142]
  14. np.set_printoptions(precision=8)
  15. print("精度为8:", precise_arr)
  16. # 输出: 精度为8: [3.14159265 2.71828183 1.41421356]
复制代码

抑制科学计数法

对于非常大或非常小的数字，NumPy默认使用科学计数法。如果你想要抑制这种行为，可以使用suppress参数。
  2. # 创建包含极小值的数组
  3. small_arr = np.array([1e-10, 2e-15, 3e-20])
  5. # 默认打印（使用科学计数法）
  6. print("默认打印:", small_arr)
  7. # 输出: 默认打印: [1.e-10 2.e-15 3.e-20]
  9. # 抑制科学计数法
  10. np.set_printoptions(suppress=True)
  11. print("抑制科学计数法:", small_arr)
  12. # 输出: 抑制科学计数法: [0. 0. 0.]
  14. # 注意：当数值太小时，抑制科学计数法可能导致显示为0
  15. # 可以结合precision参数使用
  16. np.set_printoptions(suppress=True, precision=20)
  17. print("抑制科学计数法并设置高精度:", small_arr)
  18. # 输出: 抑制科学计数法并设置高精度: [0.00000000010000000 0.00000000000000200 0.00000000000000000003]
复制代码

数组截断显示

当处理大型数组时，你可能不希望打印所有元素。NumPy提供了几种方式来控制数组的显示长度。
  2. # 创建一个大型数组
  3. huge_arr = np.arange(10000)
  5. # 设置边缘元素显示数量
  6. np.set_printoptions(edgeitems=5)  # 在开头和结尾各显示5个元素
  7. print("边缘元素显示5个:", huge_arr)
  8. # 输出: 边缘元素显示5个: [   0    1    2    3    4 ... 9995 9996 9997 9998 9999]
  10. # 设置显示阈值
  11. np.set_printoptions(threshold=20)  # 如果数组元素超过20个，则截断显示
  12. print("阈值设置为20:", huge_arr)
  13. # 输出: 阈值设置为20: [ 0  1  2 ... 97 98 99]
  15. # 完全禁用截断
  16. np.set_printoptions(threshold=np.inf)  # np.inf表示无穷大
  17. # 注意：打印非常大的数组可能会导致性能问题
复制代码

高级数据展示

使用Matplotlib进行可视化

NumPy通常与Matplotlib库结合使用，以创建数据的可视化表示。
  2. import matplotlib.pyplot as plt
  4. # 创建数据
  5. x = np.linspace(0, 10, 100)
  6. y = np.sin(x)
  8. # 创建简单的线图
  9. plt.figure(figsize=(10, 6))
  10. plt.plot(x, y)
  11. plt.title('Sine Wave')
  12. plt.xlabel('X-axis')
  13. plt.ylabel('Y-axis')
  14. plt.grid(True)
  15. plt.show()
  17. # 创建散点图
  18. random_x = np.random.rand(50)
  19. random_y = np.random.rand(50)
  20. colors = np.random.rand(50)
  21. sizes = 1000 * np.random.rand(50)
  23. plt.figure(figsize=(10, 6))
  24. plt.scatter(random_x, random_y, c=colors, s=sizes, alpha=0.5)
  25. plt.title('Random Scatter Plot')
  26. plt.colorbar()
  27. plt.show()
  29. # 创建二维数组的热图
  30. data = np.random.rand(10, 10)
  31. plt.figure(figsize=(10, 6))
  32. plt.imshow(data, cmap='viridis')
  33. plt.colorbar()
  34. plt.title('Heatmap')
  35. plt.show()
复制代码

交互式数据展示

使用IPython或Jupyter Notebook，你可以创建交互式的数据展示。
  2. # 在Jupyter Notebook中运行的交互式示例
  3. # 首先确保安装了ipywidgets
  4. # !pip install ipywidgets
  6. import ipywidgets as widgets
  7. from IPython.display import display
  9. # 创建一个简单的交互式函数
  10. def plot_sine(frequency=1.0, amplitude=1.0):
  11.     x = np.linspace(0, 2*np.pi, 1000)
  12.     y = amplitude * np.sin(frequency * x)
  13.    
  14.     plt.figure(figsize=(10, 6))
  15.     plt.plot(x, y)
  16.     plt.title(f'Sine Wave (Frequency: {frequency}, Amplitude: {amplitude})')
  17.     plt.xlabel('X-axis')
  18.     plt.ylabel('Y-axis')
  19.     plt.grid(True)
  20.     plt.ylim(-5, 5)  # 固定y轴范围
  21.     plt.show()
  23. # 创建交互式控件
  24. freq_slider = widgets.FloatSlider(value=1.0, min=0.1, max=5.0, step=0.1, description='Frequency:')
  25. amp_slider = widgets.FloatSlider(value=1.0, min=0.1, max=5.0, step=0.1, description='Amplitude:')
  27. # 显示交互式控件
  28. widgets.interactive(plot_sine, frequency=freq_slider, amplitude=amp_slider)
复制代码

自定义格式化函数

你可以创建自定义的格式化函数来以特定方式显示NumPy数组。
  2. # 自定义格式化函数
  3. def custom_formatter(x):
  4.     if x == 0:
  5.         return "zero"
  6.     elif x > 0:
  7.         return f"+{x:.2f}"
  8.     else:
  9.         return f"-{abs(x):.2f}"
  11. # 应用自定义格式化
  12. arr = np.array([-1.234, 0, 3.456, -0.001, 7.89])
  13. np.set_printoptions(formatter={'float': custom_formatter})
  14. print(arr)
  15. # 输出: ['-1.23' 'zero' '+3.46' '-0.00' '+7.89']
  17. # 重置格式化
  18. np.set_printoptions(formatter=None)
  20. # 更复杂的自定义格式化
  21. def complex_formatter(x):
  22.     if isinstance(x, complex):
  23.         real = x.real
  24.         imag = x.imag
  25.         return f"{real:.2f}{imag:+.2f}j"
  26.     else:
  27.         return f"{x:.2f}"
  29. # 创建复数数组
  30. complex_arr = np.array([1+2j, 3-4j, 5+6j])
  31. np.set_printoptions(formatter={'all': complex_formatter})
  32. print(complex_arr)
  33. # 输出: [1.00+2.00j 3.00-4.00j 5.00+6.00j]
复制代码

特殊数据类型的输出处理

复数输出

NumPy支持复数，你可以自定义复数的显示方式。
  2. # 创建复数数组
  3. complex_arr = np.array([1+2j, 3-4j, 5+6j])
  5. # 默认打印
  6. print("默认打印:", complex_arr)
  7. # 输出: 默认打印: [1.+2.j 3.-4.j 5.+6.j]
  9. # 自定义复数格式化
  10. np.set_printoptions(formatter={'complex': lambda x: f"{x.real:.2f}{x.imag:+.2f}j"})
  11. print("自定义格式化:", complex_arr)
  12. # 输出: 自定义格式化: [1.00+2.00j 3.00-4.00j 5.00+6.00j]
  14. # 重置格式化
  15. np.set_printoptions(formatter=None)
复制代码

结构化数组输出

结构化数组类似于数据库中的表，每列可以有不同的数据类型。
  2. # 创建结构化数组
  3. dtype = [('name', 'U10'), ('age', 'i4'), ('weight', 'f4')]
  4. structured_arr = np.array([('Alice', 25, 55.5), ('Bob', 30, 70.2), ('Charlie', 35, 65.8)], dtype=dtype)
  6. # 默认打印
  7. print("默认打印:", structured_arr)
  8. # 输出: 默认打印: [('Alice', 25, 55.5) ('Bob', 30, 70.2) ('Charlie', 35, 65.8)]
  10. # 访问特定字段
  11. print("姓名:", structured_arr['name'])
  12. # 输出: 姓名: ['Alice' 'Bob' 'Charlie']
  14. print("年龄:", structured_arr['age'])
  15. # 输出: 年龄: [25 30 35]
  17. # 自定义结构化数组的格式化
  18. def structured_formatter(x):
  19.     if isinstance(x, np.void):
  20.         return f"{x['name']} (Age: {x['age']}, Weight: {x['weight']:.1f}kg)"
  21.     return str(x)
  23. np.set_printoptions(formatter={'all': structured_formatter})
  24. print("自定义格式化:", structured_arr)
  25. # 输出: 自定义格式化: ['Alice (Age: 25, Weight: 55.5kg)' 'Bob (Age: 30, Weight: 70.2kg)' 'Charlie (Age: 35, Weight: 65.8kg)']
  27. # 重置格式化
  28. np.set_printoptions(formatter=None)
复制代码

记录数组输出

记录数组是结构化数组的一种变体，允许通过属性访问字段。
  2. # 创建记录数组
  3. record_arr = np.rec.array([('Alice', 25, 55.5), ('Bob', 30, 70.2), ('Charlie', 35, 65.8)], dtype=dtype)
  5. # 默认打印
  6. print("默认打印:", record_arr)
  7. # 输出: 默认打印: [('Alice', 25, 55.5) ('Bob', 30, 70.2) ('Charlie', 35, 65.8)]
  9. # 通过属性访问字段
  10. print("姓名:", record_arr.name)
  11. # 输出: 姓名: ['Alice' 'Bob' 'Charlie']
  13. print("年龄:", record_arr.age)
  14. # 输出: 年龄: [25 30 35]
  16. # 自定义记录数组的格式化
  17. def record_formatter(x):
  18.     if isinstance(x, np.record):
  19.         return f"{x.name}: {x.age} years, {x.weight:.1f}kg"
  20.     return str(x)
  22. np.set_printoptions(formatter={'all': record_formatter})
  23. print("自定义格式化:", record_arr)
  24. # 输出: 自定义格式化: ['Alice: 25 years, 55.5kg' 'Bob: 30 years, 70.2kg' 'Charlie: 35 years, 65.8kg']
  26. # 重置格式化
  27. np.set_printoptions(formatter=None)
复制代码

性能优化与大数据展示

大数组分块显示

处理非常大的数组时，一次性显示所有元素可能会导致性能问题。分块显示是一个有效的解决方案。
  2. # 创建一个非常大的数组
  3. very_large_arr = np.random.rand(10000, 10000)
  5. # 定义分块显示函数
  6. def display_in_chunks(arr, chunk_size=1000):
  7.     n = arr.shape[0]
  8.     for i in range(0, n, chunk_size):
  9.         start = i
  10.         end = min(i + chunk_size, n)
  11.         print(f"Rows {start} to {end-1}:")
  12.         print(arr[start:end])
  13.         print("\n" + "-"*50 + "\n")
  15. # 显示大数组的前几行和后几行
  16. def display_edges(arr, edge_size=5):
  17.     if arr.ndim == 1:
  18.         print("First elements:", arr[:edge_size])
  19.         print("Last elements:", arr[-edge_size:])
  20.     elif arr.ndim == 2:
  21.         print("First rows:")
  22.         print(arr[:edge_size])
  23.         print("\nLast rows:")
  24.         print(arr[-edge_size:])
  25.     else:
  26.         print("Array dimension not supported for edge display")
  28. # 使用分块显示（谨慎使用，因为打印大量数据可能会影响性能）
  29. # display_in_chunks(very_large_arr, chunk_size=1000)
  31. # 使用边缘显示
  32. display_edges(very_large_arr, edge_size=3)
复制代码

内存高效的输出方法

在处理大型数据集时，内存效率至关重要。以下是一些内存高效的输出方法。
  2. # 使用生成器表达式逐行处理大型数组
  3. def process_large_array(arr, process_func):
  4.     for row in arr:
  5.         yield process_func(row)
  7. # 示例处理函数
  8. def sum_row(row):
  9.     return np.sum(row)
  11. # 创建大型数组
  12. large_arr = np.random.rand(1000, 1000)
  14. # 使用生成器处理数组
  15. row_sums = process_large_array(large_arr, sum_row)
  17. # 打印前10行的和
  18. for i, row_sum in enumerate(row_sums):
  19.     if i < 10:
  20.         print(f"Row {i} sum: {row_sum:.2f}")
  21.     else:
  22.         break
  24. # 使用np.memmap处理磁盘上的大型数组
  25. # 首先创建一个大型数组并保存到磁盘
  26. large_arr_path = 'large_array.npy'
  27. large_arr = np.random.rand(10000, 10000)
  28. np.save(large_arr_path, large_arr)
  30. # 使用memmap加载数组，而不完全读入内存
  31. memmap_arr = np.load(large_arr_path, mmap_mode='r')
  33. # 现在可以像普通数组一样访问memmap_arr，但数据在需要时才会从磁盘加载
  34. print("Shape of memmap array:", memmap_arr.shape)
  35. print("First row:", memmap_arr[0])
  37. # 清理文件
  38. import os
  39. os.remove(large_arr_path)
复制代码

并行计算结果的展示

当使用并行计算处理大型数据集时，有效地展示结果同样重要。
  2. from multiprocessing import Pool
  3. import time
  5. # 定义一个简单的处理函数
  6. def process_chunk(chunk):
  7.     # 模拟计算密集型任务
  8.     time.sleep(0.1)
  9.     return np.sum(chunk)
  11. # 创建大型数组
  12. data = np.random.rand(1000, 1000)
  14. # 将数组分割成多个块
  15. n_chunks = 4
  16. chunks = np.array_split(data, n_chunks)
  18. # 使用多进程处理
  19. with Pool(processes=n_chunks) as pool:
  20.     results = pool.map(process_chunk, chunks)
  22. # 显示结果
  23. for i, result in enumerate(results):
  24.     print(f"Chunk {i} sum: {result:.2f}")
  26. # 使用JobLib进行更高级的并行计算
  27. # 首先安装joblib: pip install joblib
  28. try:
  29.     from joblib import Parallel, delayed
  30.    
  31.     # 定义更复杂的处理函数
  32.     def complex_processing(chunk, power=2):
  33.         # 模拟更复杂的计算
  34.         result = np.sum(chunk ** power)
  35.         return result
  36.    
  37.     # 使用JobLib并行处理
  38.     results = Parallel(n_jobs=n_chunks)(delayed(complex_processing)(chunk, power=2) for chunk in chunks)
  39.    
  40.     # 显示结果
  41.     print("\nJobLib results:")
  42.     for i, result in enumerate(results):
  43.         print(f"Chunk {i} sum of squares: {result:.2f}")
  44. except ImportError:
  45.     print("\nJobLib not installed. Install with: pip install joblib")
复制代码

实际应用案例

科学研究中的数据展示

在科学研究中，数据展示是传达研究结果的关键部分。以下是一些科学研究中的数据展示示例。
  2. # 模拟实验数据
  3. time_points = np.linspace(0, 10, 100)
  4. control_group = np.sin(time_points) + np.random.normal(0, 0.1, len(time_points))
  5. treatment_group = np.sin(time_points + np.pi/4) + np.random.normal(0, 0.1, len(time_points))
  7. # 计算统计指标
  8. control_mean = np.mean(control_group)
  9. treatment_mean = np.mean(treatment_group)
  10. control_std = np.std(control_group)
  11. treatment_std = np.std(treatment_group)
  13. # 打印统计结果
  14. print("Control Group:")
  15. print(f"  Mean: {control_mean:.4f}")
  16. print(f"  Standard Deviation: {control_std:.4f}")
  17. print("\nTreatment Group:")
  18. print(f"  Mean: {treatment_mean:.4f}")
  19. print(f"  Standard Deviation: {treatment_std:.4f}")
  21. # 计算t检验
  22. from scipy import stats
  23. t_stat, p_value = stats.ttest_ind(control_group, treatment_group)
  24. print(f"\nT-test results:")
  25. print(f"  t-statistic: {t_stat:.4f}")
  26. print(f"  p-value: {p_value:.4f}")
  28. # 可视化结果
  29. plt.figure(figsize=(12, 6))
  30. plt.plot(time_points, control_group, 'b-', alpha=0.5, label='Control Group')
  31. plt.plot(time_points, treatment_group, 'r-', alpha=0.5, label='Treatment Group')
  32. plt.axhline(y=control_mean, color='b', linestyle='--', label=f'Control Mean: {control_mean:.2f}')
  33. plt.axhline(y=treatment_mean, color='r', linestyle='--', label=f'Treatment Mean: {treatment_mean:.2f}')
  34. plt.title('Control vs Treatment Group')
  35. plt.xlabel('Time')
  36. plt.ylabel('Response')
  37. plt.legend()
  38. plt.grid(True)
  39. plt.show()
复制代码

机器学习模型结果展示

在机器学习中，展示模型结果对于评估性能和进行决策至关重要。
  2. from sklearn.datasets import make_classification
  3. from sklearn.model_selection import train_test_split
  4. from sklearn.ensemble import RandomForestClassifier
  5. from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
  7. # 创建模拟数据
  8. X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=5, random_state=42)
  10. # 分割数据集
  11. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
  13. # 训练模型
  14. model = RandomForestClassifier(n_estimators=100, random_state=42)
  15. model.fit(X_train, y_train)
  17. # 预测
  18. y_pred = model.predict(X_test)
  20. # 计算准确率
  21. accuracy = accuracy_score(y_test, y_pred)
  22. print(f"Model Accuracy: {accuracy:.4f}")
  24. # 显示混淆矩阵
  25. conf_matrix = confusion_matrix(y_test, y_pred)
  26. print("\nConfusion Matrix:")
  27. print(conf_matrix)
  29. # 可视化混淆矩阵
  30. plt.figure(figsize=(8, 6))
  31. plt.imshow(conf_matrix, interpolation='nearest', cmap=plt.cm.Blues)
  32. plt.title('Confusion Matrix')
  33. plt.colorbar()
  34. plt.xlabel('Predicted Label')
  35. plt.ylabel('True Label')
  36. plt.show()
  38. # 显示分类报告
  39. print("\nClassification Report:")
  40. print(classification_report(y_test, y_pred))
  42. # 特征重要性
  43. feature_importance = model.feature_importances_
  44. sorted_idx = np.argsort(feature_importance)[::-1]
  46. print("\nFeature Importance:")
  47. for i, idx in enumerate(sorted_idx[:10]):  # 显示前10个最重要的特征
  48.     print(f"  Feature {idx}: {feature_importance[idx]:.4f}")
  50. # 可视化特征重要性
  51. plt.figure(figsize=(10, 6))
  52. plt.title("Feature Importance")
  53. plt.bar(range(10), feature_importance[sorted_idx[:10]], align="center")
  54. plt.xticks(range(10), sorted_idx[:10])
  55. plt.xlim([-1, 10])
  56. plt.show()
复制代码

金融数据分析展示

金融数据分析通常需要特定的展示方式，以突出趋势和模式。
  2. import pandas as pd
  3. import datetime
  5. # 生成模拟的股票价格数据
  6. np.random.seed(42)
  7. dates = pd.date_range(start='2020-01-01', end='2022-12-31')
  8. initial_price = 100
  9. returns = np.random.normal(0.001, 0.02, len(dates))
  10. prices = [initial_price]
  12. for ret in returns[1:]:
  13.     prices.append(prices[-1] * (1 + ret))
  15. prices = np.array(prices)
  17. # 创建DataFrame
  18. df = pd.DataFrame({'Date': dates, 'Price': prices})
  19. df.set_index('Date', inplace=True)
  21. # 计算移动平均
  22. df['MA_20'] = df['Price'].rolling(window=20).mean()
  23. df['MA_50'] = df['Price'].rolling(window=50).mean()
  25. # 计算日收益率
  26. df['Daily_Return'] = df['Price'].pct_change()
  28. # 显示基本统计信息
  29. print("Basic Statistics:")
  30. print(df['Price'].describe())
  32. # 显示年化收益率
  33. annual_return = (1 + df['Daily_Return'].mean()) ** 252 - 1
  34. print(f"\nAnnualized Return: {annual_return:.4f}")
  36. # 显示年化波动率
  37. annual_volatility = df['Daily_Return'].std() * np.sqrt(252)
  38. print(f"Annualized Volatility: {annual_volatility:.4f}")
  40. # 显示夏普比率（假设无风险利率为2%）
  41. risk_free_rate = 0.02
  42. sharpe_ratio = (annual_return - risk_free_rate) / annual_volatility
  43. print(f"Sharpe Ratio: {sharpe_ratio:.4f}")
  45. # 可视化价格和移动平均
  46. plt.figure(figsize=(12, 6))
  47. plt.plot(df.index, df['Price'], label='Price')
  48. plt.plot(df.index, df['MA_20'], label='20-Day MA')
  49. plt.plot(df.index, df['MA_50'], label='50-Day MA')
  50. plt.title('Stock Price with Moving Averages')
  51. plt.xlabel('Date')
  52. plt.ylabel('Price')
  53. plt.legend()
  54. plt.grid(True)
  55. plt.show()
  57. # 可视化日收益率分布
  58. plt.figure(figsize=(10, 6))
  59. plt.hist(df['Daily_Return'].dropna(), bins=50, alpha=0.75)
  60. plt.axvline(df['Daily_Return'].mean(), color='r', linestyle='dashed', linewidth=1, label='Mean')
  61. plt.title('Distribution of Daily Returns')
  62. plt.xlabel('Daily Return')
  63. plt.ylabel('Frequency')
  64. plt.legend()
  65. plt.grid(True)
  66. plt.show()
复制代码

总结与最佳实践

NumPy提供了丰富的输出和展示选项，从基本的打印函数到高级的可视化技术。以下是一些最佳实践，帮助你有效地展示科学计算结果：

1. 根据数据大小选择适当的显示方法：对于小型数组，可以使用完整的打印输出。对于大型数组，考虑使用边缘显示或分块显示。
2. 对于小型数组，可以使用完整的打印输出。
3. 对于大型数组，考虑使用边缘显示或分块显示。
4. 自定义格式化以提高可读性：使用set_printoptions()函数调整精度、抑制科学计数法等。创建自定义格式化函数，使数据更易于理解。
5. 使用set_printoptions()函数调整精度、抑制科学计数法等。
6. 创建自定义格式化函数，使数据更易于理解。
7. 结合可视化工具：使用Matplotlib、Seaborn等库创建图表。考虑使用交互式可视化工具，如Plotly或Bokeh。
8. 使用Matplotlib、Seaborn等库创建图表。
9. 考虑使用交互式可视化工具，如Plotly或Bokeh。
10. 考虑性能因素：对于大型数据集，使用内存高效的方法，如生成器或内存映射。考虑使用并行计算处理大型数据集。
11. 对于大型数据集，使用内存高效的方法，如生成器或内存映射。
12. 考虑使用并行计算处理大型数据集。
13. 根据受众调整展示方式：对于技术受众，可以显示详细的统计信息和原始数据。对于非技术受众，优先使用可视化图表和简洁的摘要。
14. 对于技术受众，可以显示详细的统计信息和原始数据。
15. 对于非技术受众，优先使用可视化图表和简洁的摘要。
16. 保持一致性：在整个项目中保持一致的格式和样式。使用相同的颜色方案和图表类型，以便于比较。
17. 在整个项目中保持一致的格式和样式。
18. 使用相同的颜色方案和图表类型，以便于比较。

根据数据大小选择适当的显示方法：

• 对于小型数组，可以使用完整的打印输出。
• 对于大型数组，考虑使用边缘显示或分块显示。

自定义格式化以提高可读性：

• 使用set_printoptions()函数调整精度、抑制科学计数法等。
• 创建自定义格式化函数，使数据更易于理解。

结合可视化工具：

• 使用Matplotlib、Seaborn等库创建图表。
• 考虑使用交互式可视化工具，如Plotly或Bokeh。

考虑性能因素：

• 对于大型数据集，使用内存高效的方法，如生成器或内存映射。
• 考虑使用并行计算处理大型数据集。

根据受众调整展示方式：

• 对于技术受众，可以显示详细的统计信息和原始数据。
• 对于非技术受众，优先使用可视化图表和简洁的摘要。

保持一致性：

• 在整个项目中保持一致的格式和样式。
• 使用相同的颜色方案和图表类型，以便于比较。

通过掌握这些NumPy输出技巧，你将能够更有效地展示科学计算结果，使你的数据分析和研究成果更具说服力和影响力。无论是简单的打印输出还是复杂的交互式可视化，NumPy都为你提供了必要的工具来呈现你的数据。
高性能
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

关闭

站长推荐上一条 /1 下一条

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
友链交换
友链交换
友链为随机排序，不代表本论坛观点
Telegram

Telegram

Discord

Discord

Tencent QQ

Tencent QQ

手机版|联系我们|小黑屋|TG频道|RSS |网站地图

Powered by Pixtech

© 2025-2026 Pixtech Team.

>