Question

如果您在Python中创建1d数组，使用NumPy包有什么好处吗？

Answer 1

这完全取决于您打算如何处理数组。如果你所做的只是创建简单数据类型的数组并进行I / O，那么array模块就可以了。

另一方面，如果您想进行任何类型的数值计算，阵列模块不会提供任何帮助。 NumPy（和SciPy）为数组和特殊函数提供了各种各样的操作，这些操作不仅可用于科学工作，还可用于高级图像处理或一般需要执行高效操作的任何操作用大量数据计算。

Numpy也更灵活，例如它支持任何类型的Python对象的数组，并且如果它们符合array interface，它也能够与您自己的对象进行“本地”交互。

Answer 2

为了任何可能发现这个有用的人的利益而进行小型自举（遵循@dF的优秀答案）：

import numpy as np
from array import array

# Fixed size numpy array
def np_fixed(n):
    q = np.empty(n)
    for i in range(n):
        q[i] = i
    return q

# Resize with np.resize
def np_class_resize(isize, n):
    q = np.empty(isize)
    for i in range(n):
        if i>=q.shape[0]:
            q = np.resize(q, q.shape[0]*2)        
        q[i] = i
    return q    

# Resize with the numpy.array method
def np_method_resize(isize, n):
    q = np.empty(isize)
    for i in range(n):
        if i>=q.shape[0]:
            q.resize(q.shape[0]*2)
        q[i] = i
    return q

# Array.array append
def arr(n):
    q = array('d')
    for i in range(n):
        q.append(i)
    return q

isize = 1000
n = 10000000

输出结果为：

%timeit -r 10 a = np_fixed(n)
%timeit -r 10 a = np_class_resize(isize, n)
%timeit -r 10 a = np_method_resize(isize, n)
%timeit -r 10 a = arr(n)

1 loop, best of 10: 868 ms per loop
1 loop, best of 10: 2.03 s per loop
1 loop, best of 10: 2.02 s per loop
1 loop, best of 10: 1.89 s per loop

似乎array.array稍快一些，而'api'为你节省了一些麻烦，但如果你需要的不仅仅是存储双打，那么numpy.resize毕竟不是一个糟糕的选择（如果使用得当）。

Answer 3

您会发现Numpy的速度比Python数组快得多：

import time
import numpy as np

size_of_vec = 1000

def pure_python_version():
    t = time.time()
    X = range(size_of_vec)
    Y = range(size_of_vec)
    Z = [X[i] + Y[i] for i in range(len(X)) ]
    return time.time() - t

def numpy_version():
    t1 = time.time()
    X = np.arange(size_of_vec)
    Y = np.arange(size_of_vec)
    Z = X + Y
    return time.time() - t

t1 = pure_python_version()
t2 = numpy_version()
print(t1, t2)
print("Numpy is in this example " + str(t1/t2) + " faster!")

输出：

0.00024366378784179688 0.002840280532836914
Numpy is in this example 0.08578863426508856 faster!

Answer 4

出于存储目的，numpy 数组胜过 array.array。这是用于比较 4 字节无符号整数的存储大小的基准测试代码。其他数据类型也可用于比较。还添加了列表和元组的数据进行比较。对于小于 10 的数字，可以使用列表和元组。

a = [100400, 1004000, 10040, 100400, 100400, 100400, 400, 1006000, 8, 800999]
print("size per element for list, tuple, numpy array, array.array:===============")
for i in range(1, 15):
    aa = a*i#list size multiplier
    n = len(aa)
    list_size = getsizeof(aa)
    d = list_size
    tup_aa = tuple(aa)
    tup_size = getsizeof(tup_aa)
    nparr = np.array(aa, dtype='uint32')
    np_size = getsizeof(nparr)
    arr = array('L', aa)#4 byte unsigned integer
    arr_size = getsizeof(arr)
    print('number of element:%s, list %.2f, tuple %.2f, np.array %.2f, arr.array %.2f' % \
          (len(aa), list_size/n, tup_size/n, np_size/n, arr_size/n))

这在我的机器上产生了以下输出：

size per element for list, tuple, numpy array, array.array:===============
number of element:10, list 14.40, tuple 12.80, np.array 13.60, arr.array 14.40
number of element:20, list 11.20, tuple 10.40, np.array 8.80, arr.array 11.20
number of element:30, list 10.13, tuple 9.60, np.array 7.20, arr.array 10.13
number of element:40, list 9.60, tuple 9.20, np.array 6.40, arr.array 9.60
number of element:50, list 9.28, tuple 8.96, np.array 5.92, arr.array 9.28
number of element:60, list 9.07, tuple 8.80, np.array 5.60, arr.array 9.07
number of element:70, list 8.91, tuple 8.69, np.array 5.37, arr.array 8.91
number of element:80, list 8.80, tuple 8.60, np.array 5.20, arr.array 8.80
number of element:90, list 8.71, tuple 8.53, np.array 5.07, arr.array 8.71
number of element:100, list 8.64, tuple 8.48, np.array 4.96, arr.array 8.64
number of element:110, list 8.58, tuple 8.44, np.array 4.87, arr.array 8.58
number of element:120, list 8.53, tuple 8.40, np.array 4.80, arr.array 8.53
number of element:130, list 8.49, tuple 8.37, np.array 4.74, arr.array 8.49
number of element:140, list 8.46, tuple 8.34, np.array 4.69, arr.array 8.46

python.array与numpy.array

4 个答案: