2

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

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

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

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

这是一个愚蠢的简单示例

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一个是右，一个是左）。

现在我想识别不完整的对（也许到一个列表中，leftovers以便我可以适当地错误或警告，例如“没有找到左 lg blue glove”“没有找到左 med tan glove”。

我已经看到了教如何从成对的列表中识别“缺失”项目的答案，但是我的应用程序有一些我无法弄清楚如何解决的复杂性：链接对象的属性，以及链接多个属性的一个对象。

我想 for 循环和列表理解是可能的，但我不太清楚如何将它们链接在一起。

4

2 回答 2

2

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

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]
于 2018-03-26T17:26:28.577 回答
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]
于 2018-03-26T17:33:37.407 回答