利用Python和NumPy创建高效数组

在进行科学计算和数据分析时，使用高效的数组操作非常重要。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中进行科学计算和数据分析的重要工具之一，熟练掌握其使用方式可以大大提高开发效率。