在进行科学计算和数据分析时，使用高效的数组操作非常重要。Python作为一种高级编程语言，其内置的数组支持非常基础，导致在处理大型数据集时效率较低。而NumPy则是一款高性能的数组操作库，其基于C语言实现，可以在Python中高效地进行向量化计算。本文将从多个方面介绍NumPy的优势和使用方式。
一、NumPy数据结构
NumPy主要提供了两种数据结构：ndarray和ufuncs。
1、ndarray
ndarray是NumPy中最重要的数据结构，它是一个多维数组，可以用来表示向量、矩阵和更高维度的数组。相较于Python内置的列表，它在存储和操作上有很大的优势。
import numpy as np
# 创建ndarray数组
a = np.array([1, 2, 3])
b = np.array([[1, 2, 3], [4, 5, 6]])
c = np.zeros((2, 3))
d = np.ones((2, 3))
e = np.arange(start=1, stop=10, step=2)
# 数组属性
print(f'a: {a}')
print(f'b: {b}')
print(f'c: {c}')
print(f'd: {d}')
print(f'e: {e}')
print(f'a的类型: {type(a)}')
print(f'a的形状: {a.shape}')
print(f'b的元素类型: {b.dtype}')
print(f'b的元素个数: {b.size}')
print(f'c的第2行: {c[1]}')
print(f'd的第1列: {d[:, 0]}')
print(f'e[1:4]: {e[1:4]}')运行结果:
a: [1 2 3]
b: [[1 2 3]
[4 5 6]]
c: [[0. 0. 0.]
[0. 0. 0.]]
d: [[1. 1. 1.]
[1. 1. 1.]]
e: [1 3 5 7 9]
a的类型: <class 'numpy.ndarray'>
a的形状: (3,)
b的元素类型: int64
b的元素个数: 6
c的第2行: [0. 0. 0.]
d的第1列: [1. 1.]
e[1:4]: [3 5 7]2、ufuncs
ufuncs（universal functions）是一种特殊的函数，它可以对每个元素进行操作，相当于将该函数向量化。在NumPy中有很多内置的ufuncs，如abs()、exp()、log()、sin()等。
import numpy as np
# ufuncs
a = np.array([1, -2, 3])
b = np.abs(a)
c = np.exp(a)
print(f'a: {a}')
print(f'b: {b}')
print(f'c: {c}')运行结果：
a: [ 1 -2 3]
b: [1 2 3]
c: [ 2.71828183 0.13533528 20.08553692]二、NumPy高效操作数组
在进行科学计算和数据分析时，数组操作是绝大多数计算代码的核心代码。而Python的列表在处理大型数组时非常低效。下面通过几个例子来比较ndarray和Python列表在操作效率上的差别。
1、加法
比较Python列表和ndarray在同样大小的情况下进行相加的时间差别。
import timeit
import numpy as np
# Python列表加法
def python_list_add(a, b):
result = []
for i in range(len(a)):
result.append(a[i] + b[i])
return result
# ndarray加法
def numpy_array_add(a, b):
return a + b
size = 1000000
a = list(range(size))
b = list(range(size))
npa = np.array(range(size))
npb = np.array(range(size))
print(f'Python列表加法时间: {timeit.timeit(lambda: python_list_add(a, b), number=100)}')
print(f'ndarray加法时间: {timeit.timeit(lambda: npa + npb, number=100)}')运行结果：
Python列表加法时间: 3.3998023820000003
ndarray加法时间: 0.014122334999998903可以看出，ndarray加法的速度比Python列表加法快了很多倍。
2、数组索引
数组索引是数组操作中最常用的操作之一，下面来比较Python列表和ndarray在进行相同大小的数组索引时的时间消耗。
import timeit
import numpy as np
# Python列表索引
def python_list_index(a):
return a[int(len(a) / 2)]
# ndarray索引
def numpy_array_index(a):
return a[int(len(a) / 2)]
size = 1000000
a = list(range(size))
npa = np.array(range(size))
print(f'Python列表索引时间: {timeit.timeit(lambda: python_list_index(a), number=100)}')
print(f'ndarray索引时间: {timeit.timeit(lambda: numpy_array_index(npa), number=100)}')运行结果：
Python列表索引时间: 0.05845978399999844
ndarray索引时间: 0.0012145289999993452可以看出，ndarray的索引速度比Python列表快很多。
三、NumPy数组操作函数
NumPy提供了很多常用的数组操作函数，下面将介绍几个常用的函数。
1、reshape
reshape函数可以改变数组的形状，其参数为一个元组，每个元素表示该维度的大小。
import numpy as np
# reshape函数
a = np.array([[1, 2, 3], [4, 5, 6]])
b = a.reshape((3, 2))
print(f'a: {a}')
print(f'b: {b}')
print(f'a形状: {a.shape}')
print(f'b形状: {b.shape}')运行结果：
a: [[1 2 3]
[4 5 6]]
b: [[1 2]
[3 4]
[5 6]]
a形状: (2, 3)
b形状: (3, 2)2、transpose
transpose函数可以将数组进行转置。
import numpy as np
# transpose函数
a = np.array([[1, 2, 3], [4, 5, 6]])
b = a.transpose()
print(f'a: {a}')
print(f'b: {b}')
print(f'a形状：{a.shape}')
print(f'b形状：{b.shape}')运行结果：
a: [[1 2 3]
[4 5 6]]
b: [[1 4]
[2 5]
[3 6]]
a形状：(2, 3)
b形状：(3, 2)3、concatenate
concatenate函数可以将多个数组在某个维度上进行连接。其第一个参数为待连接的数组，在进行连接时要保证除了指定维度之外的其他维度大小相同。第二个参数为连接的维度。
import numpy as np
# concatenate函数
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
c = np.concatenate((a, b), axis=1)
print(f'a: {a}')
print(f'b: {b}')
print(f'c: {c}')
print(f'c形状: {c.shape}') 运行结果：
a: [[1 2]
[3 4]]
b: [[5 6]
[7 8]]
c: [[1 2 5 6]
[3 4 7 8]]
c形状: (2, 4)四、结语
本文介绍了NumPy的主要数据结构和优势，以及其在数组操作中的高效性和常用函数。NumPy是Python中进行科学计算和数据分析的重要工具之一，熟练掌握其使用方式可以大大提高开发效率。
