我正在尝试执行以下操作
from numpy import *
x = array([[3,2,3],[711,4,104],.........,[4,4,782,7845]]) # large nparray
for item in x:
set(item)
而且与之相比，需要很长时间：
x = array([[3,2,3],[711,4,104],.........,[4,4,782,7845]]) # large nparray
for item in x:
item.tolist()
set比转换为list需要更长的时间？ 我的意思是两者复杂度基本相同，都为O（n）？set()函数使用Python迭代协议创建一个集合。但是，在Python级别上遍历NumPy数组非常慢，因此在进行迭代之前，使用tolist()将数组转换为Python列表会更快。ten = 10可能看起来像这样：
ten的“名称”，而下方的对象（实例）实际上表示整数（由于此处不重要，因此我在图像中忽略了它们的记录属性）。list只是Python对象的集合，例如mylist = [1, 2, 3]将被保存如下：
1，2和3以及名称mylist只是引用list实例。
但是一个数组myarray = np.array([1, 2, 3])不会将Python对象存储为元素：
array实例直接存储值1、2和3。
import numpy as np
arr = np.arange(100000)
lst = list(range(100000))
def iterateover(obj):
for item in obj:
pass
%timeit iterateover(arr)
# 20.2 ms ± 155 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit iterateover(lst)
# 3.96 ms ± 26.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
set 的“构造函数”只是对对象进行迭代。
有一件事情我无法确定，那就是为什么 tolist 方法更快。最终，结果 Python 列表中的每个值都需要在“Python 盒子”中，因此 tolist 无法避免太多工作。但其中一件确定的事情是，list(array) 比 array.tolist() 更慢：
arr = np.arange(100000)
%timeit list(arr)
# 20 ms ± 114 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit arr.tolist()
# 10.3 ms ± 253 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
arr = np.random.randint(0, 1000, (10000, 3))
def tosets(arr):
for line in arr:
set(line)
def tolists(arr):
for line in arr:
list(line)
def tolists_method(arr):
for line in arr:
line.tolist()
def tosets_intermediatelist(arr):
for line in arr:
set(line.tolist())
%timeit tosets(arr)
# 72.2 ms ± 2.68 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit tolists(arr)
# 80.5 ms ± 2.18 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit tolists_method(arr)
# 16.3 ms ± 140 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit tosets_intermediatelist(arr)
# 38.5 ms ± 200 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
set，最好使用set(arr.tolist())。对于更大的数组，使用np.unique可能会更有意义，但由于你的行只包含3个项目，所以这可能会更慢（对于数千个元素，它可能会快得多！）。
由于涉及到哈希和空槽（Python 在集合中使用开放地址法），因此集合比列表更加复杂。
与 NumPy 的 array 类似，numba 的 set 直接保存值。因此，当您将 NumPy 的 array 转换为 numba 的 set（或反之亦然）时，它根本不需要使用“Python boxes”，因此在 numba 的 nopython 函数中创建 set 会比 set(arr.tolist()) 操作快得多：
import numba as nb
@nb.njit
def tosets_numba(arr):
for lineno in range(arr.shape[0]):
set(arr[lineno])
tosets_numba(arr) # warmup
%timeit tosets_numba(arr)
# 6.55 ms ± 105 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
set(arr.tolist())方法快大约五倍。但需要强调的是，我没有从函数中返回set。当您从Numba nopython函数返回一个set到Python时，Numba会创建一个Python set——包括为集合中所有值“创建盒子”（这是Numba隐藏的内容）。
顺便说一下：如果您将list传递给Numba nopython函数或从这些函数返回列表，则会发生相同的装箱/拆箱操作。因此，在Numba中，Python中的O(1)操作变成了O(n)操作！这就是为什么通常最好将NumPy数组传递给numba nopython函数（这是O(1)）。
from numpy import *，因为这样会隐藏一些Python内置函数（例如sum、min、max等），并将大量内容放入全局变量中。最好使用import numpy as np。在函数调用前加上np.可以使代码更清晰，而且打字量也不多。％load_ext cython，然后使用%%cython编译一个块。我检查了答案中的4个函数，与纯Python相比，所有函数都快1.5-2倍。但这比numba慢得多。 - MSeifertobject 数组来说更为复杂。对于一维数组，它们的存储方式类似于列表。但对于多维数组，则会有所不同：使用嵌套列表时，外部列表引用内部列表，而最内层列表引用实际对象——对象数组将是一个包含对所有元素（作为不同对象）的引用的数组，但使用步幅“模拟”多维度。我认为，对于 array -> set 转换，tolist 方法会更快（至少我的电脑是这样说的）。 - MSeifert以下是一种加快速度的方法：避免使用循环，而是使用multiprocessing pool.map技巧。
from multiprocessing.dummy import Pool as ThreadPool
import multiprocessing
pool = ThreadPool(multiprocessing.cpu_count()) # get the number of CPU
y = pool.map(set,x) # apply the function to your iterable
pool.close()
pool.join()
set需要进行一些哈希和计算，以确定在集合中插入新元素的位置。转换为list可能只是一个简单的复制。 - Jean-François Fabrex是什么形状？数据类型是什么？我看到了3个和4个元素的子列表。但是，是的，set是一个类似于字典（只有键没有值）的Python对象。tolist是一个编译numpy方法。 - hpaulj