Python NumPy - 第一个 NumPy 程序 创建并打印数组

/* MD / 富文本中的 .toc（含博客园搬家等嵌套结构）；.toc-box 在侧栏，不受影响 */
#content_views .toc,
/* 编辑器常在目录前后插入空 p（:empty 仍占 20px），一并去掉避免顶空隙 */
#content_views.markdown_views > p:empty:has(+ .toc),
#content_views.markdown_views > .toc + p:empty,
/* 富文本旧版目录标记 */
#content_views.htmledit_views #main-toc,
#content_views.htmledit_views #hr-toc,
#content_views.htmledit_views p[id*=\”-toc\”] {
display: none !important;
}
/* 目录去掉后，紧跟的首个标题不再多出一块上边距 */
#content_views.markdown_views > .toc + h1,
#content_views.markdown_views > .toc + h2,
#content_views.markdown_views > .toc + h3,
#content_views.markdown_views > .toc + h4,
#content_views.markdown_views > .toc + p:empty + h1,
#content_views.markdown_views > .toc + p:empty + h2,
#content_views.markdown_views > .toc + p:empty + h3,
#content_views.markdown_views > .toc + p:empty + h4 {
margin-top: 0 !important;
}

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

文章目录

• Python NumPy – 第一个 NumPy 程序：创建并打印数组 🐍🔢
• • 引言 🚀
  • 什么是NumPy？🤔
  • • NumPy的主要特点 ✨
  • 安装NumPy 💻
  • 导入NumPy库 📚
  • 创建NumPy数组的基本方法 🔧
  • • 1. 从Python列表创建数组
    • 2. 使用NumPy内置函数创建数组
    • • 创建全零数组
      • 创建全一数组
      • 创建指定值填充的数组
    • 3. 创建序列数组
    • • 使用arange函数
      • 使用linspace函数
    • 4. 创建特殊数组
    • • 单位矩阵
      • 对角矩阵
  • 数组属性详解 📊
  • 打印数组的不同方式 🖨️
  • • 1. 基本打印
    • 2. 自定义打印选项
    • 3. 格式化打印
  • 实际应用示例 🌟
  • • 示例1：学生成绩分析
    • 示例2：图像像素处理
    • 示例3：时间序列数据
  • 错误处理和调试技巧 🛠️
  • 性能比较 ⚡
  • 最佳实践和建议 💡
  • • 1. 数组创建最佳实践
    • 2. 打印和显示最佳实践
    • 3. 代码组织和文档
  • 高级主题探索 🔍
  • • 数组的内存布局
    • 数组的视图与复制
  • 实用工具函数 🛠️
  • mermaid 图表示例 📈
  • 与其他库的集成 🤝
  • 学习资源推荐 📚
  • 常见问题解答 ❓
  • • Q1: NumPy数组和Python列表有什么区别？
    • Q2: 如何选择合适的数据类型？
    • Q3: 什么时候应该使用视图而不是副本？
  • 总结 🎯

Python NumPy – 第一个 NumPy 程序：创建并打印数组 🐍🔢

引言 🚀

在数据科学和数值计算的世界中，NumPy（Numerical Python）是一个不可或缺的强大工具。它为Python提供了高性能的多维数组对象和处理这些数组的工具。对于任何想要深入学习机器学习、数据分析或科学计算的人来说，掌握NumPy是至关重要的第一步。

今天，我们将从最基础的内容开始——创建和打印NumPy数组。虽然这看起来很简单，但它是理解更复杂概念的基础。让我们一起踏上这段令人兴奋的NumPy之旅吧！🌟

什么是NumPy？🤔

NumPy是Python的一个开源库，专门用于处理大型多维数组和矩阵。它提供了大量的数学函数来操作这些数组，使得数值计算变得简单而高效。NumPy的核心是它的ndarray对象，这是一个强大的N维数组类型。

NumPy的主要特点 ✨

• 高效的数组操作：NumPy数组比Python原生列表快得多
• 广播功能：允许不同形状的数组进行算术运算
• 丰富的数学函数：提供线性代数、傅里叶变换等功能
• 内存效率：连续的内存存储提高了缓存局部性
• 集成性强：与其他科学计算库完美配合

安装NumPy 💻

在开始编写第一个NumPy程序之前，我们需要确保已经安装了NumPy库。如果你还没有安装，可以通过以下命令进行安装：

pip install numpy

或者如果你使用conda环境管理器：

conda install numpy

安装完成后，我们就可以开始我们的第一个NumPy程序了！

导入NumPy库 📚

在Python脚本中使用NumPy的第一步是导入它。通常我们会使用np作为别名，这是NumPy社区的标准约定：

import numpy as np

这个简单的导入语句为我们打开了通往强大数值计算世界的大门。现在我们可以开始创建我们的第一个数组了！

创建NumPy数组的基本方法 🔧

1. 从Python列表创建数组

最直接的方法是从现有的Python列表创建NumPy数组：

import numpy as np

# 从一维列表创建数组
list_1d = [1, 2, 3, 4, 5]
array_1d = np.array(list_1d)
print("一维数组:")
print(array_1d)
print(f"数组形状: {array_1d.shape}")
print(f"数组维度: {array_1d.ndim}")
print(f"数组元素类型: {array_1d.dtype}")

print("\\n" + "="*50 + "\\n")

# 从二维列表创建数组
list_2d = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
array_2d = np.array(list_2d)
print("二维数组:")
print(array_2d)
print(f"数组形状: {array_2d.shape}")
print(f"数组维度: {array_2d.ndim}")
print(f"数组元素类型: {array_2d.dtype}")

运行结果：

一维数组:
[1 2 3 4 5]
数组形状: (5,)
数组维度: 1
数组元素类型: int64

==================================================

二维数组:
[[1 2 3]
[4 5 6]
[7 8 9]]
数组形状: (3, 3)
数组维度: 2
数组元素类型: int64

2. 使用NumPy内置函数创建数组

NumPy提供了许多便捷的函数来创建特定类型的数组：

创建全零数组

import numpy as np

# 创建一维全零数组
zeros_1d = np.zeros(5)
print("一维全零数组:")
print(zeros_1d)

print("\\n" + "-"*30 + "\\n")

# 创建二维全零数组
zeros_2d = np.zeros((3, 4))
print("二维全零数组:")
print(zeros_2d)

print("\\n" + "-"*30 + "\\n")

# 指定数据类型
zeros_float = np.zeros(5, dtype=float)
print("浮点型全零数组:")
print(zeros_float)

运行结果：

一维全零数组:
[0. 0. 0. 0. 0.]

——————————

二维全零数组:
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]

——————————

浮点型全零数组:
[0. 0. 0. 0. 0.]

创建全一数组

import numpy as np

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

print("\\n" + "-"*30 + "\\n")

# 指定数据类型
ones_int = np.ones(4, dtype=int)
print("整型全一数组:")
print(ones_int)

运行结果：

全一数组:
[[1. 1. 1.]
[1. 1. 1.]]

——————————

整型全一数组:
[1 1 1 1]

创建指定值填充的数组

import numpy as np

# 创建用指定值填充的数组
filled_array = np.full((2, 3), 7)
print("用7填充的数组:")
print(filled_array)

print("\\n" + "-"*30 + "\\n")

# 使用浮点数
filled_float = np.full(5, 3.14)
print("用3.14填充的数组:")
print(filled_float)

运行结果：

用7填充的数组:
[[7 7 7]
[7 7 7]]

——————————

用3.14填充的数组:
[3.14 3.14 3.14 3.14 3.14]

3. 创建序列数组

NumPy提供了多种创建数字序列的方法：

使用arange函数

import numpy as np

# 创建从0到9的数组
range_array = np.arange(10)
print("从0到9的数组:")
print(range_array)

print("\\n" + "-"*30 + "\\n")

# 创建从2到10，步长为2的数组
step_array = np.arange(2, 11, 2)
print("步长为2的数组:")
print(step_array)

print("\\n" + "-"*30 + "\\n")

# 创建浮点数序列
float_range = np.arange(0, 1, 0.1)
print("浮点数序列:")
print(float_range)

运行结果：

从0到9的数组:
[0 1 2 3 4 5 6 7 8 9]

——————————

步长为2的数组:
[2 4 6 8 10]

——————————

浮点数序列:
[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

使用linspace函数

import numpy as np

# 在指定区间内创建等间距的数组
linear_space = np.linspace(0, 1, 5)
print("等间距数组:")
print(linear_space)

print("\\n" + "-"*30 + "\\n")

# 不包含终点
linear_no_end = np.linspace(0, 10, 5, endpoint=False)
print("不包含终点的等间距数组:")
print(linear_no_end)

运行结果：

等间距数组:
[0. 0.25 0.5 0.75 1. ]

——————————

不包含终点的等间距数组:
[0. 2. 4. 6. 8.]

4. 创建特殊数组

NumPy还提供了一些特殊的数组创建方法：

单位矩阵

import numpy as np

# 创建单位矩阵
identity_matrix = np.eye(3)
print("3×3单位矩阵:")
print(identity_matrix)

print("\\n" + "-"*30 + "\\n")

# 非方阵的单位矩阵
rect_identity = np.eye(3, 4)
print("3×4单位矩阵:")
print(rect_identity)

运行结果：

3×3单位矩阵:
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]

——————————

3×4单位矩阵:
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]]

对角矩阵

import numpy as np

# 创建对角矩阵
diagonal_elements = [1, 2, 3, 4]
diagonal_matrix = np.diag(diagonal_elements)
print("对角矩阵:")
print(diagonal_matrix)

print("\\n" + "-"*30 + "\\n")

# 从现有数组提取对角线
existing_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
diagonal_from_array = np.diag(existing_array)
print("从现有数组提取对角线:")
print(diagonal_from_array)

运行结果：

对角矩阵:
[[1 0 0 0]
[0 2 0 0]
[0 0 3 0]
[0 0 0 4]]

——————————

从现有数组提取对角线:
[1 5 9]

数组属性详解 📊

了解数组的各种属性对于有效地使用NumPy非常重要：

import numpy as np

# 创建一个复杂的多维数组
complex_array = np.array([[[1, 2, 3], [4, 5, 6]],
[[7, 8, 9], [10, 11, 12]]])

print("复杂三维数组:")
print(complex_array)
print()

# 基本属性
print(f"数组形状 (shape): {complex_array.shape}")
print(f"数组维度 (ndim): {complex_array.ndim}")
print(f"数组大小 (size): {complex_array.size}")
print(f"元素数据类型 (dtype): {complex_array.dtype}")
print(f"每个元素的字节大小 (itemsize): {complex_array.itemsize}")
print(f"总字节数 (nbytes): {complex_array.nbytes}")
print(f"数组的内存布局顺序 (flags):")
for flag in ['C_CONTIGUOUS', 'F_CONTIGUOUS', 'OWNDATA']:
print(f" {flag}: {getattr(complex_array.flags, flag)}")

运行结果：

复杂三维数组:
[[[ 1 2 3]
[ 4 5 6]]

[[ 7 8 9]
[10 11 12]]]

数组形状 (shape): (2, 2, 3)
数组维度 (ndim): 3
数组大小 (size): 12
元素数据类型 (dtype): int64
每个元素的字节大小 (itemsize): 8
总字节数 (nbytes): 96
数组的内存布局顺序 (flags):
C_CONTIGUOUS: True
F_CONTIGUOUS: False
OWNDATA: True

打印数组的不同方式 🖨️

NumPy提供了多种方式来打印和显示数组，每种方式都有其特定的用途：

1. 基本打印

import numpy as np

# 创建不同大小的数组
small_array = np.arange(10)
large_array = np.random.rand(100).reshape(10, 10)

print("小数组的默认打印:")
print(small_array)
print()

print("大数组的默认打印:")
print(large_array)
print()

2. 自定义打印选项

import numpy as np

# 创建测试数组
test_array = np.random.rand(6, 6) * 100

print("默认打印设置:")
print(test_array)
print()

# 修改打印精度
np.set_printoptions(precision=2)
print("修改精度后的打印:")
print(test_array)
print()

# 修改阈值以显示完整数组
original_threshold = np.get_printoptions()['threshold']
np.set_printoptions(threshold=np.inf)
print("显示完整数组:")
print(test_array)
print()

# 恢复原始设置
np.set_printoptions(threshold=original_threshold, precision=8)

3. 格式化打印

import numpy as np

# 创建示例数组
data_array = np.array([[1.23456789, 2.34567890],
[3.45678901, 4.56789012]])

print("标准打印:")
print(data_array)
print()

# 使用字符串格式化
print("使用字符串格式化的打印:")
formatted_strings = []
for row in data_array:
formatted_row = [f"{val:.3f}" for val in row]
formatted_strings.append(formatted_row)

for row in formatted_strings:
print(row)
print()

# 使用numpy的格式化函数
print("使用numpy格式化函数:")
np.set_printoptions(formatter={'float': '{:.3f}'.format})
print(data_array)
np.set_printoptions() # 恢复默认设置

实际应用示例 🌟

让我们通过一些实际的例子来展示如何创建和打印NumPy数组：

示例1：学生成绩分析

import numpy as np

# 模拟学生的考试成绩
students = ['Alice', 'Bob', 'Charlie', 'Diana', 'Eve']
subjects = ['Math', 'Science', 'English', 'History']

# 创建随机成绩数组 (5个学生, 4门科目)
np.random.seed(42) # 设置随机种子以便结果可重现
scores = np.random.randint(60, 101, size=(5, 4))

print("学生成绩表:")
print("="*50)
print(f"{'Name':<10}", end="")
for subject in subjects:
print(f"{subject:<10}", end="")
print()
print("-"*50)

for i, student in enumerate(students):
print(f"{student:<10}", end="")
for score in scores[i]:
print(f"{score:<10}", end="")
print()

print("\\n统计信息:")
print("-"*30)
print(f"平均分: {np.mean(scores):.2f}")
print(f"最高分: {np.max(scores)}")
print(f"最低分: {np.min(scores)}")
print(f"各科平均分: {np.mean(scores, axis=0)}")
print(f"各人平均分: {np.mean(scores, axis=1)}")

示例2：图像像素处理

import numpy as np

# 模拟一个简单的8×8黑白图像
def create_checkerboard():
"""创建一个棋盘图案"""
board = np.zeros((8, 8), dtype=int)
board[1::2, ::2] = 1 # 奇数行偶数列
board[::2, 1::2] = 1 # 偶数行奇数列
return board

checkerboard = create_checkerboard()

print("8×8棋盘图案:")
print("="*20)
for row in checkerboard:
print(' '.join(['██' if cell == 1 else ' ' for cell in row]))

print("\\n数组表示:")
print(checkerboard)

# 计算黑色和白色像素的数量
black_pixels = np.sum(checkerboard == 1)
white_pixels = np.sum(checkerboard == 0)
print(f"\\n黑色像素数量: {black_pixels}")
print(f"白色像素数量: {white_pixels}")

示例3：时间序列数据

import numpy as np

# 创建模拟的时间序列数据
days = 30
dates = np.arange(1, days + 1)
base_value = 100
trend = 0.5 * dates # 上升趋势
noise = np.random.normal(0, 5, days) # 随机噪声
values = base_value + trend + noise

print("时间序列数据:")
print("="*40)
print(f"{'日期':<6} {'数值':<10}")
print("-"*40)
for date, value in zip(dates[:10], values[:10]): # 只显示前10天
print(f"{date:<6} {value:<10.2f}")

print("…")
print(f"{'…':<6} {'…':<10}")
for date, value in zip(dates[–5:], values[–5:]): # 显示最后5天
print(f"{date:<6} {value:<10.2f}")

print(f"\\n统计摘要:")
print(f"最小值: {np.min(values):.2f}")
print(f"最大值: {np.max(values):.2f}")
print(f"平均值: {np.mean(values):.2f}")
print(f"标准差: {np.std(values):.2f}")

错误处理和调试技巧 🛠️

在使用NumPy时，可能会遇到各种错误。了解如何识别和解决这些问题是很重要的：

import numpy as np

# 常见错误示例和解决方案

# 1. 维度不匹配错误
try:
arr1 = np.array([1, 2, 3])
arr2 = np.array([[1, 2], [3, 4]])
result = arr1 + arr2 # 这会引发广播错误吗？
print("加法结果:", result)
except ValueError as e:
print(f"维度错误: {e}")

# 2. 数据类型问题
try:
# 尝试将字符串转换为数字数组
string_list = ['1', '2', '3', 'not_a_number']
numeric_array = np.array(string_list, dtype=float)
print("数值数组:", numeric_array)
except ValueError as e:
print(f"类型转换错误: {e}")
# 解决方案：使用更安全的转换方法
print("使用更安全的转换:")
safe_array = np.array([float(x) if x.replace('.', '').isdigit() else 0
for x in string_list])
print("安全转换后:", safe_array)

# 3. 内存不足错误
try:
# 尝试创建非常大的数组
huge_array = np.ones((1000000, 1000000)) # 这可能超出内存限制
print("大数组创建成功")
except MemoryError as e:
print(f"内存错误: {e}")
print("建议: 使用较小的数组或分块处理数据")

# 调试技巧
def debug_array(arr, name="Array"):
"""打印数组的详细调试信息"""
print(f"\\n{name} 调试信息:")
print(f" 类型: {type(arr)}")
print(f" 形状: {arr.shape}")
print(f" 维度: {arr.ndim}")
print(f" 大小: {arr.size}")
print(f" 数据类型: {arr.dtype}")
print(f" 是否连续: {arr.flags['C_CONTIGUOUS']}")
if arr.size <= 20: # 只有当数组不太大时才打印内容
print(f" 内容:\\n{arr}")
else:
print(f" 前5个元素: {arr.flat[:5]}")
print(f" 后5个元素: {arr.flat[–5:]}")

# 测试调试函数
test_arrays = [
np.array([1, 2, 3, 4, 5]),
np.array([[1, 2], [3, 4]]),
np.zeros((100, 100))
]

for i, arr in enumerate(test_arrays):
debug_array(arr, f"Test Array {i+1}")

性能比较 ⚡

让我们比较一下NumPy数组和Python原生列表在性能上的差异：

import numpy as np
import time

# 创建大型数据集进行性能测试
size = 1000000
python_list = list(range(size))
numpy_array = np.arange(size)

# 测试加法操作性能
def test_python_addition(lst):
return [x + 1 for x in lst]

def test_numpy_addition(arr):
return arr + 1

# Python列表加法
start_time = time.time()
result_list = test_python_addition(python_list)
python_time = time.time() – start_time

# NumPy数组加法
start_time = time.time()
result_array = test_numpy_addition(numpy_array)
numpy_time = time.time() – start_time

print("性能比较结果:")
print(f"Python列表加法耗时: {python_time:.4f} 秒")
print(f"NumPy数组加法耗时: {numpy_time:.4f} 秒")
print(f"NumPy比Python快 {python_time/numpy_time:.1f} 倍")

# 内存使用比较
import sys
print(f"\\n内存使用比较:")
print(f"Python列表内存占用: {sys.getsizeof(python_list)} 字节")
print(f"NumPy数组内存占用: {numpy_array.nbytes} 字节")
print(f"内存效率提升: {sys.getsizeof(python_list)/numpy_array.nbytes:.1f} 倍")

最佳实践和建议 💡

基于我们的学习和实践经验，以下是一些使用NumPy创建和打印数组的最佳实践：

1. 数组创建最佳实践

import numpy as np

# 推荐的做法
# 1. 明确指定数据类型
explicit_dtype = np.array([1, 2, 3], dtype=np.int32)
print("明确指定数据类型:", explicit_dtype.dtype)

# 2. 使用合适的初始化函数
# 对于已知大小的数组，预分配内存
pre_allocated = np.empty(1000) # 快速创建未初始化数组
zeros_array = np.zeros(1000) # 创建全零数组
ones_array = np.ones(1000) # 创建全一数组

# 3. 避免不必要的数组复制
original_array = np.arange(100)
view_array = original_array[::2] # 视图，不复制数据
copy_array = original_array[::2].copy() # 显式复制

print(f"视图共享数据: {np.shares_memory(original_array, view_array)}")
print(f"副本独立数据: {np.shares_memory(original_array, copy_array)}")

2. 打印和显示最佳实践

import numpy as np

# 设置全局打印选项
np.set_printoptions(
precision=3, # 浮点数精度
suppress=True, # 抑制科学记数法
linewidth=120, # 行宽
threshold=1000 # 超过此大小则省略显示
)

# 创建测试数据
test_data = np.random.rand(5, 8) * 1000

print("优化后的打印输出:")
print(test_data)

# 对于调试，临时修改打印选项
with np.printoptions(precision=6, suppress=False):
print("\\n临时高精度显示:")
print(test_data[0, :3]) # 只显示部分数据

# 恢复默认设置
np.set_printoptions() # 恢复默认值

3. 代码组织和文档

import numpy as np

def create_sample_dataset(rows, cols, seed=None):
"""
创建示例数据集

参数:
rows (int): 行数
cols (int): 列数
seed (int, optional): 随机种子

返回:
numpy.ndarray: 生成的数据数组

示例:
>>> data = create_sample_dataset(3, 4, seed=42)
>>> print(data.shape)
(3, 4)
"""
if seed is not None:
np.random.seed(seed)

return np.random.randn(rows, cols)

# 使用示例
sample_data = create_sample_dataset(5, 3, seed=123)
print("示例数据集:")
print(sample_data)

高级主题探索 🔍

数组的内存布局

import numpy as np

# 创建不同内存布局的数组
c_order = np.array([[1, 2, 3], [4, 5, 6]], order='C') # C风格（行优先）
f_order = np.array([[1, 2, 3], [4, 5, 6]], order='F') # Fortran风格（列优先）

print("C风格数组:")
print(f" 连续性: {c_order.flags['C_CONTIGUOUS']}")
print(f" Fortran连续性: {c_order.flags['F_CONTIGUOUS']}")

print("\\nFortran风格数组:")
print(f" 连续性: {f_order.flags['C_CONTIGUOUS']}")
print(f" Fortran连续性: {f_order.flags['F_CONTIGUOUS']}")

# 转置操作对内存布局的影响
transposed_c = c_order.T
print(f"\\n转置后的C风格数组:")
print(f" 连续性: {transposed_c.flags['C_CONTIGUOUS']}")
print(f" Fortran连续性: {transposed_c.flags['F_CONTIGUOUS']}")

数组的视图与复制

import numpy as np

# 理解视图和复制的区别
original = np.arange(12).reshape(3, 4)
print("原始数组:")
print(original)

# 创建视图
view_slice = original[1:, 1:] # 这是视图
print(f"\\n切片视图 (共享数据):")
print(view_slice)

# 修改视图会影响原始数组
view_slice[0, 0] = 999
print(f"\\n修改视图后原始数组:")
print(original)

# 恢复原始值
original[1, 1] = 5

# 创建副本
copy_slice = original[1:, 1:].copy() # 这是副本
print(f"\\n副本 (独立数据):")
print(copy_slice)

# 修改副本不会影响原始数组
copy_slice[0, 0] = 888
print(f"\\n修改副本后原始数组:")
print(original)

实用工具函数 🛠️

NumPy提供了许多实用的工具函数来帮助我们更好地理解和操作数组：

import numpy as np

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

print("示例数组:")
print(example_array)

# 数组信息工具
print(f"\\n数组基本信息:")
print(f" 扁平化数组: {example_array.flatten()}")
print(f" 转置数组:\\n{example_array.T}")
print(f" 数组重塑 (1×9): {example_array.reshape(1, 9)}")
print(f" 数组重塑 (9×1):\\n{example_array.reshape(9, 1)}")

# 条件选择
condition_result = np.where(example_array > 5, example_array, 0)
print(f"\\n条件选择 (大于5的元素保留，其余为0):")
print(condition_result)

# 数组连接
array1 = np.array([[1, 2], [3, 4]])
array2 = np.array([[5, 6], [7, 8]])

print(f"\\n水平连接:")
h_concat = np.hstack([array1, array2])
print(h_concat)

print(f"\\n垂直连接:")
v_concat = np.vstack([array1, array2])
print(v_concat)

# 数组分割
split_arrays = np.hsplit(example_array, 3)
print(f"\\n水平分割结果:")
for i, arr in enumerate(split_arrays):
print(f" 部分 {i+1}: {arr.flatten()}")

mermaid 图表示例 📈

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

成功

失败

是

否

开始

导入NumPy

创建数组

安装NumPy

选择创建方法

从列表创建

使用内置函数

创建特殊数组

打印数组

需要更多操作?

执行其他NumPy操作

结束

与其他库的集成 🤝

NumPy作为Python科学计算生态系统的核心，与其他库有着良好的集成：

import numpy as np

# 与matplotlib的集成示例
try:
import matplotlib.pyplot as plt

# 创建数据
x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)

# 如果需要可视化，可以这样使用
print("数据已准备就绪，可用于matplotlib绘图")
print(f"x轴数据点数: {len(x)}")
print(f"y轴数据范围: [{np.min(y):.2f}, {np.max(y):.2f}]")

except ImportError:
print("matplotlib未安装，跳过可视化示例")

# 与pandas的集成
try:
import pandas as pd

# 创建NumPy数组
data = np.random.rand(5, 3)

# 转换为pandas DataFrame
df = pd.DataFrame(data, columns=['A', 'B', 'C'])
print("\\nPandas DataFrame (来自NumPy数组):")
print(df.head())

except ImportError:
print("pandas未安装，跳过DataFrame示例")

学习资源推荐 📚

为了进一步学习NumPy，以下是一些优质的学习资源：

这些资源提供了从基础到高级的全面覆盖，可以帮助你深入理解NumPy的各种功能。

常见问题解答 ❓

Q1: NumPy数组和Python列表有什么区别？

NumPy数组相比Python列表具有以下优势：

• 更高的内存效率
• 更快的数值计算速度
• 支持向量化操作
• 提供丰富的数学函数

Q2: 如何选择合适的数据类型？

选择数据类型时应考虑：

• 精度要求：int32 vs int64，float32 vs float64
• 内存限制：较小的数据类型节省内存
• 兼容性：某些操作可能需要特定的数据类型

Q3: 什么时候应该使用视图而不是副本？

• 当你需要修改原始数据时使用视图
• 当你需要独立的数据副本时使用.copy()
• 视图节省内存，副本提供数据安全性

总结 🎯

通过这篇文章，我们深入了解了NumPy的第一个程序——创建和打印数组。我们学习了：

NumPy是数据科学和数值计算的基础工具，掌握它将为你打开通往更高级数据分析和机器学习的大门。从创建第一个简单的数组开始，你会逐渐发现NumPy的强大之处，并能够在各种项目中充分利用它的能力。

记住，编程学习是一个循序渐进的过程。今天的第一个NumPy程序只是开始，随着不断练习和探索，你会越来越熟练地使用这个强大的工具。继续前进，在NumPy的世界中发现更多的可能性吧！🚀✨

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