我需要在numpy.array.
例如：
>>> a # I have
array([[1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
>>> new_a # I want to get to
array([[1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[1, 1, 1, 1, 1, 0]])
我知道我可以创建一个集合并在数组上循环，但我正在寻找一个有效的纯numpy解决方案。我相信有一种方法可以将数据类型设置为 void 然后我可以使用numpy.unique，但我不知道如何使它工作。
从 NumPy 1.13 开始，可以简单地选择轴来选择任何 N-dim 数组中的唯一值。要获得唯一的行，可以这样做：
unique_rows = np.unique(original_array, axis=0)
另一种可能的解决方案
np.vstack({tuple(row) for row in a})
使用结构化数组的另一种选择是使用void将整行连接成单个项目的类型的视图：
a = np.array([[1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
b = np.ascontiguousarray(a).view(np.dtype((np.void, a.dtype.itemsize * a.shape[1])))
_, idx = np.unique(b, return_index=True)
unique_a = a[idx]
>>> unique_a
array([[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
编辑np.ascontiguousarray按照@seberg 的建议
添加。如果数组不是连续的，这将减慢方法的速度。
编辑 上面可以稍微加快，也许以清晰为代价，通过这样做：
unique_a = np.unique(b).view(a.dtype).reshape(-1, a.shape[1])
此外，至少在我的系统上，它的性能与 lexsort 方法相当，甚至更好：
a = np.random.randint(2, size=(10000, 6))
%timeit np.unique(a.view(np.dtype((np.void, a.dtype.itemsize*a.shape[1])))).view(a.dtype).reshape(-1, a.shape[1])
100 loops, best of 3: 3.17 ms per loop
%timeit ind = np.lexsort(a.T); a[np.concatenate(([True],np.any(a[ind[1:]]!=a[ind[:-1]],axis=1)))]
100 loops, best of 3: 5.93 ms per loop
a = np.random.randint(2, size=(10000, 100))
%timeit np.unique(a.view(np.dtype((np.void, a.dtype.itemsize*a.shape[1])))).view(a.dtype).reshape(-1, a.shape[1])
10 loops, best of 3: 29.9 ms per loop
%timeit ind = np.lexsort(a.T); a[np.concatenate(([True],np.any(a[ind[1:]]!=a[ind[:-1]],axis=1)))]
10 loops, best of 3: 116 ms per loop
如果您想避免转换为一系列元组或其他类似数据结构的内存开销，您可以利用 numpy 的结构化数组。
诀窍是将原始数组视为结构化数组，其中每个项目对应于原始数组的一行。这不会复制，并且非常有效。
举个简单的例子：
import numpy as np
data = np.array([[1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
ncols = data.shape[1]
dtype = data.dtype.descr * ncols
struct = data.view(dtype)
uniq = np.unique(struct)
uniq = uniq.view(data.dtype).reshape(-1, ncols)
print uniq
要了解发生了什么，请查看中间结果。
一旦我们将事物视为结构化数组，数组中的每个元素都是原始数组中的一行。（基本上，它是一个类似于元组列表的数据结构。）
In [71]: struct
Out[71]:
array([[(1, 1, 1, 0, 0, 0)],
[(0, 1, 1, 1, 0, 0)],
[(0, 1, 1, 1, 0, 0)],
[(1, 1, 1, 0, 0, 0)],
[(1, 1, 1, 1, 1, 0)]],
dtype=[('f0', '<i8'), ('f1', '<i8'), ('f2', '<i8'), ('f3', '<i8'), ('f4', '<i8'), ('f5', '<i8')])
In [72]: struct[0]
Out[72]:
array([(1, 1, 1, 0, 0, 0)],
dtype=[('f0', '<i8'), ('f1', '<i8'), ('f2', '<i8'), ('f3', '<i8'), ('f4', '<i8'), ('f5', '<i8')])
一旦我们运行numpy.unique，我们将得到一个结构化数组：
In [73]: np.unique(struct)
Out[73]:
array([(0, 1, 1, 1, 0, 0), (1, 1, 1, 0, 0, 0), (1, 1, 1, 1, 1, 0)],
dtype=[('f0', '<i8'), ('f1', '<i8'), ('f2', '<i8'), ('f3', '<i8'), ('f4', '<i8'), ('f5', '<i8')])
然后我们需要将其视为“正常”数组（_将最后一次计算的结果存储在 中ipython，这就是您看到的原因_.view...）：
In [74]: _.view(data.dtype)
Out[74]: array([0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0])
然后重新整形为二维数组（-1是一个占位符，告诉 numpy 计算正确的行数，给出列数）：
In [75]: _.reshape(-1, ncols)
Out[75]:
array([[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
显然，如果你想更简洁，你可以写成：
import numpy as np
def unique_rows(data):
uniq = np.unique(data.view(data.dtype.descr * data.shape[1]))
return uniq.view(data.dtype).reshape(-1, data.shape[1])
data = np.array([[1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
print unique_rows(data)
结果是：
[[0 1 1 1 0 0]
[1 1 1 0 0 0]
[1 1 1 1 1 0]]
np.unique当我运行它时np.random.random(100).reshape(10,10)返回所有唯一的单个元素，但你想要唯一的行，所以首先你需要将它们放入元组中：
array = #your numpy array of lists
new_array = [tuple(row) for row in array]
uniques = np.unique(new_array)
这是我看到您更改类型以执行您想要的操作的唯一方法，而且我不确定更改为元组的列表迭代是否适合您的“不循环”
np.unique 通过对扁平数组进行排序，然后查看每个项目是否等于前一个来工作。这可以手动完成而无需展平：
ind = np.lexsort(a.T)
a[ind[np.concatenate(([True],np.any(a[ind[1:]]!=a[ind[:-1]],axis=1)))]]
此方法不使用元组，并且应该比此处给出的其他方法更快、更简单。
注意：以前的版本在 a[ 之后没有 ind，这意味着使用了错误的索引。此外，Joe Kington 提出了一个很好的观点，即这确实制作了各种中间副本。以下方法通过制作排序副本然后使用它的视图来减少：
b = a[np.lexsort(a.T)]
b[np.concatenate(([True], np.any(b[1:] != b[:-1],axis=1)))]
这更快并且使用更少的内存。
此外，如果您想在 ndarray 中找到唯一的行，而不管数组中有多少维，以下将起作用：
b = a[lexsort(a.reshape((a.shape[0],-1)).T)];
b[np.concatenate(([True], np.any(b[1:]!=b[:-1],axis=tuple(range(1,a.ndim)))))]
一个有趣的剩余问题是，如果您想沿着任意维度数组的任意轴排序/唯一，这将更加困难。
编辑：
为了证明速度差异，我在 ipython 中对答案中描述的三种不同方法进行了一些测试。使用您的确切 a，没有太大区别，尽管此版本更快一些：
In [87]: %timeit unique(a.view(dtype)).view('<i8')
10000 loops, best of 3: 48.4 us per loop
In [88]: %timeit ind = np.lexsort(a.T); a[np.concatenate(([True], np.any(a[ind[1:]]!= a[ind[:-1]], axis=1)))]
10000 loops, best of 3: 37.6 us per loop
In [89]: %timeit b = [tuple(row) for row in a]; np.unique(b)
10000 loops, best of 3: 41.6 us per loop
然而，有了更大的 a，这个版本最终会快得多：
In [96]: a = np.random.randint(0,2,size=(10000,6))
In [97]: %timeit unique(a.view(dtype)).view('<i8')
10 loops, best of 3: 24.4 ms per loop
In [98]: %timeit b = [tuple(row) for row in a]; np.unique(b)
10 loops, best of 3: 28.2 ms per loop
In [99]: %timeit ind = np.lexsort(a.T); a[np.concatenate(([True],np.any(a[ind[1:]]!= a[ind[:-1]],axis=1)))]
100 loops, best of 3: 3.25 ms per loop
我比较了建议的速度替代方案，发现令人惊讶的是，void 视图unique解决方案甚至比 numpy 的原生解决方案还要快unique一点axis。如果你正在寻找速度，你会想要
numpy.unique(
a.view(numpy.dtype((numpy.void, a.dtype.itemsize*a.shape[1])))
).view(a.dtype).reshape(-1, a.shape[1])
我已经在npx.unique_rows中实现了最快的变体。
GitHub 上也有一个错误报告。
重现情节的代码：
import numpy
import perfplot
def unique_void_view(a):
return (
numpy.unique(a.view(numpy.dtype((numpy.void, a.dtype.itemsize * a.shape[1]))))
.view(a.dtype)
.reshape(-1, a.shape[1])
)
def lexsort(a):
ind = numpy.lexsort(a.T)
return a[
ind[numpy.concatenate(([True], numpy.any(a[ind[1:]] != a[ind[:-1]], axis=1)))]
]
def vstack(a):
return numpy.vstack([tuple(row) for row in a])
def unique_axis(a):
return numpy.unique(a, axis=0)
perfplot.show(
setup=lambda n: numpy.random.randint(2, size=(n, 20)),
kernels=[unique_void_view, lexsort, vstack, unique_axis],
n_range=[2 ** k for k in range(15)],
xlabel="len(a)",
equality_check=None,
)
这是@Greg pythonic 答案的另一个变体
np.vstack(set(map(tuple, a)))
我不喜欢这些答案中的任何一个，因为没有一个在线性代数或向量空间意义上处理浮点数组，其中两行“相等”意味着“在某个范围内”。具有容差阈值的一个答案https://stackoverflow.com/a/26867764/500207将阈值设为元素精度和小数精度，这适用于某些情况，但在数学上不如真正的向量距离。
这是我的版本：
from scipy.spatial.distance import squareform, pdist
def uniqueRows(arr, thresh=0.0, metric='euclidean'):
"Returns subset of rows that are unique, in terms of Euclidean distance"
distances = squareform(pdist(arr, metric=metric))
idxset = {tuple(np.nonzero(v)[0]) for v in distances <= thresh}
return arr[[x[0] for x in idxset]]
# With this, unique columns are super-easy:
def uniqueColumns(arr, *args, **kwargs):
return uniqueRows(arr.T, *args, **kwargs)
上面的公共域函数用于查找每对行scipy.spatial.distance.pdist之间的欧几里得（可自定义）距离。然后它将每个距离与旧的距离进行比较，以找到彼此之间的行，并从每个-cluster仅返回一行。threshthreshthresh
正如所暗示的，距离metric不必是欧几里得——<code>pdist 可以计算各种距离，包括cityblock(Manhattan-norm) 和cosine(向量之间的角度)。
如果thresh=0（默认），那么行必须是位精确的才能被认为是“唯一的”。其他适合使用缩放机器精度的好值thresh，即thresh=np.spacing(1)*1e3.
为什么不使用drop_duplicates熊猫：
>>> timeit pd.DataFrame(image.reshape(-1,3)).drop_duplicates().values
1 loops, best of 3: 3.08 s per loop
>>> timeit np.vstack({tuple(r) for r in image.reshape(-1,3)})
1 loops, best of 3: 51 s per loop
numpy_indexed包（免责声明：我是它的作者）将 Jaime 发布的解决方案包装在一个经过测试的漂亮界面中，以及更多功能：
import numpy_indexed as npi
new_a = npi.unique(a) # unique elements over axis=0 (rows) by default
给定元组列表的 np.unique 作品：
>>> np.unique([(1, 1), (2, 2), (3, 3), (4, 4), (2, 2)])
Out[9]:
array([[1, 1],
[2, 2],
[3, 3],
[4, 4]])
使用列表列表，它会引发TypeError: unhashable type: 'list'
根据本页中的答案，我编写了一个函数，该函数复制了 MATLAB 函数的unique(input,'rows')功能，并具有接受检查唯一性的容差的附加功能。它还返回 和 的c = data[ia,:]索引data = c[ic,:]。如果您发现任何差异或错误，请报告。
def unique_rows(data, prec=5):
import numpy as np
d_r = np.fix(data * 10 ** prec) / 10 ** prec + 0.0
b = np.ascontiguousarray(d_r).view(np.dtype((np.void, d_r.dtype.itemsize * d_r.shape[1])))
_, ia = np.unique(b, return_index=True)
_, ic = np.unique(b, return_inverse=True)
return np.unique(b).view(d_r.dtype).reshape(-1, d_r.shape[1]), ia, ic
除了@Jaime 出色的答案之外，另一种折叠行的方法是使用a.strides[0]（假设a是 C 连续的）等于a.dtype.itemsize*a.shape[0]. 此外void(n)是dtype((void,n)). 我们终于到了这个最短的版本：
a[unique(a.view(void(a.strides[0])),1)[1]]
为了
[[0 1 1 1 0 0]
[1 1 1 0 0 0]
[1 1 1 1 1 0]]
对于像 3D 或更高的多维嵌套数组这样的一般用途，试试这个：
import numpy as np
def unique_nested_arrays(ar):
origin_shape = ar.shape
origin_dtype = ar.dtype
ar = ar.reshape(origin_shape[0], np.prod(origin_shape[1:]))
ar = np.ascontiguousarray(ar)
unique_ar = np.unique(ar.view([('', origin_dtype)]*np.prod(origin_shape[1:])))
return unique_ar.view(origin_dtype).reshape((unique_ar.shape[0], ) + origin_shape[1:])
满足您的 2D 数据集：
a = np.array([[1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
unique_nested_arrays(a)
给出：
array([[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
但也有 3D 数组，例如：
b = np.array([[[1, 1, 1], [0, 1, 1]],
[[0, 1, 1], [1, 1, 1]],
[[1, 1, 1], [0, 1, 1]],
[[1, 1, 1], [1, 1, 1]]])
unique_nested_arrays(b)
给出：
array([[[0, 1, 1], [1, 1, 1]],
[[1, 1, 1], [0, 1, 1]],
[[1, 1, 1], [1, 1, 1]]])
这些答案都不适合我。我假设我的唯一行包含字符串而不是数字。然而，来自另一个线程的这个答案确实有效：
来源：https ://stackoverflow.com/a/38461043/5402386
您可以使用 .count() 和 .index() 列表的方法
coor = np.array([[10, 10], [12, 9], [10, 5], [12, 9]])
coor_tuple = [tuple(x) for x in coor]
unique_coor = sorted(set(coor_tuple), key=lambda x: coor_tuple.index(x))
unique_count = [coor_tuple.count(x) for x in unique_coor]
unique_index = [coor_tuple.index(x) for x in unique_coor]
我们实际上可以将 mxn 数字 numpy 数组转换为 mx 1 numpy 字符串数组，请尝试使用以下函数，它提供count、inverse_idx等，就像 numpy.unique 一样：
import numpy as np
def uniqueRow(a):
#This function turn m x n numpy array into m x 1 numpy array storing
#string, and so the np.unique can be used
#Input: an m x n numpy array (a)
#Output unique m' x n numpy array (unique), inverse_indx, and counts
s = np.chararray((a.shape[0],1))
s[:] = '-'
b = (a).astype(np.str)
s2 = np.expand_dims(b[:,0],axis=1) + s + np.expand_dims(b[:,1],axis=1)
n = a.shape[1] - 2
for i in range(0,n):
s2 = s2 + s + np.expand_dims(b[:,i+2],axis=1)
s3, idx, inv_, c = np.unique(s2,return_index = True, return_inverse = True, return_counts = True)
return a[idx], inv_, c
例子：
A = np.array([[ 3.17 9.502 3.291],
[ 9.984 2.773 6.852],
[ 1.172 8.885 4.258],
[ 9.73 7.518 3.227],
[ 8.113 9.563 9.117],
[ 9.984 2.773 6.852],
[ 9.73 7.518 3.227]])
B, inv_, c = uniqueRow(A)
Results:
B:
[[ 1.172 8.885 4.258]
[ 3.17 9.502 3.291]
[ 8.113 9.563 9.117]
[ 9.73 7.518 3.227]
[ 9.984 2.773 6.852]]
inv_:
[3 4 1 0 2 4 0]
c:
[2 1 1 1 2]
让我们将整个 numpy 矩阵作为一个列表，然后从该列表中删除重复项，最后将我们的唯一列表返回到一个 numpy 矩阵：
matrix_as_list=data.tolist()
matrix_as_list:
[[1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 0, 0], [1, 1, 1, 0, 0, 0], [1, 1, 1, 1, 1, 0]]
uniq_list=list()
uniq_list.append(matrix_as_list[0])
[uniq_list.append(item) for item in matrix_as_list if item not in uniq_list]
unique_matrix=np.array(uniq_list)
unique_matrix:
array([[1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[1, 1, 1, 1, 1, 0]])
最直接的解决方案是通过使行成为字符串来使它们成为单个项目。然后可以使用 numpy 将每一行作为一个整体进行比较，以确定其唯一性。这个解决方案是通用的，您只需要为其他组合重塑和转置您的数组。这是提供的问题的解决方案。
import numpy as np
original = np.array([[1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
uniques, index = np.unique([str(i) for i in original], return_index=True)
cleaned = original[index]
print(cleaned)
会给：
array([[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
通过邮件发送我的诺贝尔奖
import numpy as np
original = np.array([[1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 0],
[0, 1, 1, 1, 0, 0],
[1, 1, 1, 0, 0, 0],
[1, 1, 1, 1, 1, 0]])
# create a view that the subarray as tuple and return unique indeies.
_, unique_index = np.unique(original.view(original.dtype.descr * original.shape[1]),
return_index=True)
# get unique set
print(original[unique_index])