基于属性匹配对象列表，并识别无与伦比的对象

Question

对于我正在开发的应用程序，我正在搜索文件目录，并希望找到匹配的文件对以执行进一步分析。

在这种情况下，一对被定义为在某些属性子集上匹配，但在某些其他属性上不同。

作为错误处理/警告的一部分，我想识别任何发现的“无法比较”的文件，即在配对中未找到预期“合作伙伴”的文件。

我有一类对象来存储结构化的属性信息，当我读取目录中的文件时，我将找到的每个文件都存储为这些对象列表中的一个元素。

这是一个愚蠢的简单示例

class glove(object):
    def __init__(self, size, color, is_right):
        self.size = size
        self.color = color
        self.is_right = is_right

    def __repr__(self):
        if self.is_right:
            hand = "right"
        else:
            hand = "left"
        s = "{} {} {}".format(self.size, self.color, hand)
        return(s)


gloves = [glove('med', 'black', False),
          glove('med', 'black', True),
          glove('lg', 'black', False),
          glove('lg', 'black', True),
          glove('med', 'brown', False),
          glove('med', 'brown', True),
          glove('lg', 'blue', False),
          glove('med', 'tan', False)]

left_gloves = [x for x in gloves if not x.is_right]
right_gloves = [x for x in gloves if x.is_right]

假设列表中没有重复元素，我们将“对”定义为两个 glove 对象，它们具有匹配的 glove.size 和 glove.color 但 glove.is_right 的值不同（即一个是 Right 和一个是左）。

现在我想识别不完整的配对（可能会出现在leftovers 的列表中，以便我可以适当地错误或警告，例如“未找到左侧 lg blue glove”“未找到左侧 med tan glove”。

我已经看到 answers 教授如何识别列表对中“丢失”的项目，但我的应用程序有一些我无法解决的复杂问题：链接对象的属性，并链接对象的多个属性。

我认为 for 循环和列表解析可以实现某些功能，但我无法完全弄清楚如何将它们链接在一起。

Answer 1

如果你可以为你的类实现相等/散列，那就很容易了：

class glove(object):
    def __init__(self, size, color, is_right):
        self.size = size
        self.color = color
        self.is_right = is_right

    def __repr__(self):
        if self.is_right:
            hand = "right"
        else:
            hand = "left"
        s = "{} {} {}".format(self.size, self.color, hand)
        return(s)

    def __eq__(self, other):
        return isinstance(other, glove) and \
            other.size == self.size and \
            other.color == self.color \
            and other.is_right == self.is_right

    def __hash__(self):
        return hash((self.size, self.color, self.is_right))


gloves = [glove('med', 'black', False),
          glove('med', 'black', True),
          glove('lg', 'black', False),
          glove('lg', 'black', True),
          glove('med', 'brown', False),
          glove('med', 'brown', True),
          glove('lg', 'blue', False),
          glove('med', 'tan', False)]

gloves_set = set(gloves)
unpaired = [g for g in gloves if glove(g.size, g.color, not g.is_right) not in gloves_set]
print(unpaired)

输出：

[lg blue left, med tan left]

您也可以考虑使用namedtuple，它实际上会为您完成这些工作。

---

这是一个不需要实现 equals 和 hash，也不需要创建新对象的替代方法：

class glove(object):
    def __init__(self, size, color, is_right):
        self.size = size
        self.color = color
        self.is_right = is_right

    def __repr__(self):
        if self.is_right:
            hand = "right"
        else:
            hand = "left"
        s = "{} {} {}".format(self.size, self.color, hand)
        return(s)


gloves = [glove('med', 'black', False),
          glove('med', 'black', True),
          glove('lg', 'black', False),
          glove('lg', 'black', True),
          glove('med', 'brown', False),
          glove('med', 'brown', True),
          glove('lg', 'blue', False),
          glove('med', 'tan', False)]

# With plain dict
glove_search = {}
for g in gloves:
    glove_search.setdefault(g.size, {}).setdefault(g.color, {})[g.is_right] = True
unpaired = [g for g in gloves
            if not glove_search.get(g.size, {}).get(g.color, {}).get(not g.is_right, False)]

# Or, more idiomatically, with defaultdict
from collections import defaultdict
glove_search = defaultdict(lambda: defaultdict(lambda: defaultdict(bool)))
for g in gloves:
    glove_search[g.size][g.color][g.is_right] = True
unpaired = [g for g in gloves if not glove_search[g.size][g.color][not g.is_right]]

print(unpaired)

输出：

[lg blue left, med tan left]

Answer 2

不允许重复，问题相对简单。 连接你的标识符：

self.ID = self.size + " " + self.color

仅在 ID 上构建左/右子集。

left  = {g.ID for g in gloves if not g.is_right)
right = {g.ID for g in gloves if     g.is_right)

unmatched_left  = left - right
unmatched_right = right - left

现在，只需逆向获取手套对象的关键过程：

unmatched = [g for g in glove_set \
             if g.ID in unmatched_left + unmatched_right]