Question

我正在寻找一种pythonic方式来更快地完成此操作

import numpy as np
von_knoten = np.array([0, 0, 1, 1, 1, 2, 2, 2, 3, 4])
zu_knoten =  np.array([1, 2, 0, 2, 3, 0, 1, 4, 1, 2])
try:
    for i in range(0,len(von_knoten)-1):
        for j in range(0,len(von_knoten)-1):
            if (i != j) & ([von_knoten[i],zu_knoten[i]] == [zu_knoten[j],von_knoten[j]]):
                    print(str(i)+".column equal " +str(j)+".column")
                    von_knoten = sp.delete(von_knoten , j)
                    zu_knoten = sp.delete(zu_knoten , j)
                    print(von_knoten)
                    print(zu_knoten)
except:
    print('end')

所以我需要以最快的方式获得

[0 0 1 1 4]
[1 2 2 3 2]

来自

[0 0 1 1 1 2 2 2 3 4]
[1 2 0 2 3 0 1 4 1 2]

谢谢;）

Answer 1

有关您的代码的一些评论;按原样，它不会做你想要的，它会打印一些东西，你甚至尝试运行它吗？你能告诉我们你得到了什么吗？

首先，只需做range(len(von_knoten));这将按照您的要求执行，因为range默认情况下从0开始，并在结束前结束一步。
如果您delete输入列表中的某些项目，并尝试访问其末尾的项目，您可能会获得IndexError s，这会耗尽对输入的分析列表。
你做了一些sp.delete但我们不知道那是什么（代码也没有），这会引发AttributeError。
唉，请不要使用except:。这将抓住你梦寐以求的异常，并解释为什么你不明白什么是错的。

然后，如何使用zip内置函数来获取已排序的二维元组，并删除重复项？类似的东西：

>>> von_knoten = [0, 0, 1, 1, 1, 2, 2, 2, 3, 4]
>>> zu_knoten =  [1, 2, 0, 2, 3, 0, 1, 4, 1, 2]
>>> set(tuple(sorted([m, n])) for m, n in zip(von_knoten, zu_knoten))
{(0, 1), (0, 2), (1, 2), (1, 3), (2, 4)}

我让你解决这个问题，以获得你正在寻找的东西。

Answer 2

您正在尝试建立一组您以前从未见过的对。您可以使用not in但需要检查此方法：

L = []
for x,y in zip(von_knoten, zu_knoten):
  if (x, y) not in L and (y, x ) not in L:
    L.append((x, y))

这给出了一个元组列表

[(0, 1), (0, 2), (1, 2), (1, 3), (2, 4)]

你可以重塑。

Answer 3

这是矢量化输出 -

def unique_pairs(von_knoten, zu_knoten):
    s = np.max([von_knoten, zu_knoten])+1
    p1 = zu_knoten*s + von_knoten
    p2 = von_knoten*s + zu_knoten
    p = np.maximum(p1,p2)
    sidx = p.argsort(kind='mergesort')
    ps = p[sidx]
    m = np.concatenate(([True],ps[1:] != ps[:-1]))
    sm = sidx[m]
    return von_knoten[sm],zu_knoten[sm]

示例运行 -

In [417]: von_knoten = np.array([0, 0, 1, 1, 1, 2, 2, 2, 3, 4])
     ...: zu_knoten =  np.array([1, 2, 0, 2, 3, 0, 1, 4, 1, 2])

In [418]: unique_pairs(von_knoten, zu_knoten)
Out[418]: (array([0, 0, 1, 1, 2]), array([1, 2, 2, 3, 4]))

Answer 4

使用np.unique和here

中的void查看方法

def unique_pairs(a, b):
    c = np.sort(np.stack([a, b], axis = 1), axis = 1)
    c_view = np.ascontiguousarray(c).view(np.dtype((np.void,
                                          c.dtype.itemsize * c.shape[1])))
    _, i = np.unique(c_view, return_index = True)
    return a[i], b[i]

使用Python查找唯一的数组对

4 个答案: