利用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中進行科學計算和數據分析的重要工具之一，熟練掌握其使用方式可以大大提高開發效率。