Поведение объекта в операциях присвоения
Я пытаюсь создать пользовательский объект, который ведет себя правильно в операциях присвоения.
Я обычно получал его работа, но я хочу удостовериться, что я полностью понимаю последствия. В частности, я интересуюсь поведением, когда существуют дополнительные данные в объекте, который не включен в равное / методы хеша. Кажется, что в 'перекрестной' операции, это возвращает набор объектов, которые сравниваются, куда операции 'объединения' возвращают набор объектов, которые сравниваются.
Проиллюстрировать:
class MyObject:
def __init__(self,value,meta):
self.value = value
self.meta = meta
def __eq__(self,other):
return self.value == other.value
def __hash__(self):
return hash(self.value)
a = MyObject('1','left')
b = MyObject('1','right')
c = MyObject('2','left')
d = MyObject('2','right')
e = MyObject('3','left')
print a == b # True
print a == c # False
for i in set([a,c,e]).intersection(set([b,d])):
print "%s %s" % (i.value,i.meta)
#returns:
#1 right
#2 right
for i in set([a,c,e]).union(set([b,d])):
print "%s %s" % (i.value,i.meta)
#returns:
#1 left
#3 left
#2 left
Это поведение документируется где-нибудь и детерминированное? Если так, каков управляющий принцип?
3 ответа
Нет, это не детерминировано. Проблема в том, что вы нарушили инвариант равенства и хэша, что два объекта эквивалентны, когда они равны. Исправьте свой объект, не пытайтесь быть умным и злоупотреблять тем, как работает реализация набора. Если мета-значение является частью идентичности MyObject, оно должно быть включено в eq и hash.
Вы не можете полагаться на пересечение множества, чтобы следовать любому порядку, поэтому нет никакого способа легко делать то, что вы хотите. Что вы в конечном итоге сделаете, так это возьмете пересечение только по значению, а затем просмотрите все свои объекты в поисках более старого, чтобы заменить его, для каждого из них. Нет хорошего способа сделать это алгоритмически.
Объединения не так уж и плохи:
##fix the eq and hash to work correctly
class MyObject:
def __init__(self,value,meta):
self.value = value
self.meta = meta
def __eq__(self,other):
return self.value, self.meta == other.value, other.meta
def __hash__(self):
return hash((self.value, self.meta))
def __repr__(self):
return "%s %s" % (self.value,self.meta)
a = MyObject('1','left')
b = MyObject('1','right')
c = MyObject('2','left')
d = MyObject('2','right')
e = MyObject('3','left')
union = set([a,c,e]).union(set([b,d]))
print union
#set([2 left, 2 right, 1 left, 3 left, 1 right])
##sort the objects, so that older objs come before the newer equivalents
sl = sorted(union, key= lambda x: (x.value, x.meta) )
print sl
#[1 left, 1 right, 2 left, 2 right, 3 left]
import itertools
##group the objects by value, groupby needs the objs to be in order to do this
filtered = itertools.groupby(sl, lambda x: x.value)
##make a list of the oldest (first in group)
oldest = [ next(group) for key, group in filtered]
print oldest
#[1 left, 2 left, 3 left]
Допустим, у ваших объектов есть два разных типа атрибутов: ключевые атрибуты и атрибуты данных . В вашем примере MyObject.value является атрибутом ключа .
Сохраните все ваши объекты в виде значений в словаре, используя атрибуты key , убедившись, что в словарь введены только ваши предпочтения (например, с самой старой меткой времени). Выполните операции набора с тем же ключом, который используется в словаре, и получите фактические объекты из словаря:
result= [dict1[k] for k in set_operation_result]
Порядок не имеет значения:
>>> [ (u.value, u.meta) for u in set([b,d]).intersection(set([a,c,e])) ]
[('1', 'right'), ('2', 'right')]
>>> [ (u.value, u.meta) for u in set([a,c,e]).intersection(set([b,d])) ]
[('1', 'right'), ('2', 'right')]
Однако, если вы сделаете это:
>>> f = MyObject('3', 'right')
И добавьте f к «правильному» набору:
>>> [ (u.value, u.meta) for u in set([a,c,e]).intersection(set([b,d,f])) ]
[('1', 'right'), ('3', 'right'), ('2', 'right')]
>>> [ (u.value, u.meta) for u in set([b,d,f]).intersection(set([a,c,e])) ]
[('1', 'left'), ('3', 'left'), ('2', 'left')]
Итак, вы можете увидеть, что поведение зависит от размера наборов (тот же эффект произойдет, если вы объедините ). Это также может зависеть от других факторов. Я думаю, вы ищете источник Python, если хотите знать, почему.