根据属性匹配对象列表，并识别不可比较的对象

Question

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

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

作为错误 handling/warning 的一部分，我想识别找到的所有 "incomparable," 文件，即未找到预期 "partner" 对的文件。

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

这是一个愚蠢的简单例子

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]

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

现在我想识别不完整的对（可能在 leftovers 的列表中，这样我就可以错误或适当地发出警告，例如 "No Left lg blue glove found" "No Left med tan glove found."

我看过教如何从成对的列表中识别项目 "missing"，但我的应用程序有一些复杂性，我无法弄清楚如何解决：link针对一个对象的属性，link针对一个对象的多个属性。

我认为 for 循环和列表理解是可能的，但我不太清楚如何 link 将它们结合在一起。

Answer 1

如果您可以为您的 class 实施 equality/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)

    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，它实际上会为您完成这些工作。

这是一个不需要实现等号和散列，也不需要创建新对象的替代方案：

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/right 个子集。

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]

根据属性匹配对象列表，并识别不可比较的对象

matching lists of objects based on attributes, and identifying the incomparables

python

list-comprehension

list-comparison