Intersezione personalizzata Python intersezione

Question

Quindi esiste un modo semplice per calcolare l'intersezione di due insiemi tramite set.intersection(). Tuttavia, ho il seguente problema:.

class Person(Object):      
    def __init__(self, name, age):              
     self.name = name                 
     self.age = age                 

l1 = [Person("Foo", 21), Person("Bar", 22)]            
l2 = [Person("Foo", 21), Person("Bar", 24)]            

union_list = list(set(l1).union(l2))           
# [Person("Foo", 21), Person("Bar", 22), Person("Bar", 24)] 

(Object è una base di classe fornito dal mio ORM che implementa funzionalità di base __hash__ e __eq__, che aggiunge, in sostanza ogni membro della classe per l'hash In altre parole, il __hash__ restituito sarà un hash di ogni elemento della classe)

a questo punto, vorrei eseguire un'operazione di impostazione di intersezione da solo .name, da trovare, per esempio, Person('Bar', -1).intersection(union_list) #= [Person("Bar", -1), Person("Bar", 22), Person("Bar", 24)]. (Il tipico .intersection() a questo punto non mi avrebbe dato qualsiasi cosa, non posso ignorare __hash__ o __eq__ sulla classe Person, poiché ciò sarebbe contrario l'unione serie originale (I credo)

Qual è il modo migliore per farlo questo in Python 2.x

EDIT:? si noti che la soluzione non hanno fare affidamento su un set Tuttavia, ho bisogno di trovare i sindacati e poi le intersezioni, così ci si sente come questo è suscettibile di un set. (ma sono disposto ad accettare soluzioni che usano qualunque magia tu ritenga degna, purché risolva il mio problema!)

Answer 1

Odio rispondere alle mie stesse domande, quindi rimarrò a contrassegnarlo come la "risposta" ancora per un po '.

scopre il modo per farlo è la seguente:

import types 
p = Person("Bar", -1) 
new_hash_method = lambda obj: hash(obj.name) 
p.__hash__ = types.MethodType(new_hash_method, p) 
for i in xrange(0, len(union_list)): 
    union_list[i].__hash__ = types.MethodType(new_hash_method, union_list[i]) 
set(union_list).intersection(p) 

E 'certamente sporco e si basa su types.MethodType, ma è meno intenso rispetto la soluzione migliore finora proposte (la soluzione di glglgl) come il mio attuale union_list può contenere potenzialmente nell'ordine di migliaia di elementi, quindi questo mi salverà ricreando oggetti ogni volta che eseguo questa procedura di intersezione.

Answer 2

È necessario eseguire l'override di __hash__ e i metodi di confronto se si desidera utilizzare set come questo.

Se non lo fai, allora

Person("Foo", 21) == Person("Foo", 21) 

sarà sempre falso.

Se i tuoi oggetti sono gestiti da un ORM, dovrai verificare come confronta gli oggetti. Solitamente guarda solo l'id dell'oggetto e la comparazione funziona solo se entrambi gli oggetti sono gestiti. Se si prova a confrontare un oggetto ottenuto dall'ORM con un'istanza creata dall'utente prima che sia persistente nel db, è probabile che siano diversi. Ad ogni modo, un ORM non dovrebbe avere problemi con te fornendo la tua logica di comparazione.

Ma se per alcuni motivi non è possibile ignorare __hash__ e __eq__, non è possibile utilizzare i set per l'intersezione e l'unione con gli oggetti originali. Si potrebbe:

• calcolare l'intersezione/unione te

• creare una classe wrapper che è paragonabile:

  class Person:      
      def __init__(self, name, age):              
       self.name = name                 
       self.age = age                 
  
  l1 = [Person("Foo", 21), Person("Bar", 22)]            
  l2 = [Person("Foo", 21), Person("Bar", 24)]            
  
  class ComparablePerson: 
      def __init__(self, person): 
       self.person = person 
  
      def __hash__(self): 
       return hash(self.person.name) + 31*hash(self.person.age) 
  
      def __eq__(self, other): 
       return (self.person.name == other.person.name and 
         self.person.age == other.person.age) 
      def __repr__(self): 
       return "<%s - %d>" % (self.person.name, self.person.age) 
  
  c1 = set(ComparablePerson(p) for p in l1) 
  c2 = set(ComparablePerson(p) for p in l2) 
  
  print c1 
  print c2 
  print c1.union(c2) 
  print c2.intersection(c1) 
  

Answer 3

Questo è goffo, ma ...

set(p for p in union_list for q in l2 if p.name == q.name and p.age != q.age) | (set(p for p in l2 for q in union_list if p.name == q.name and p.age != q.age)) 
# {person(name='Bar', age=22), person(name='Bar', age=24)} 

Answer 4

Suoni come

>>> class Person: 
...  def __init__(self, name, age): 
...   self.name = name 
...   self.age = age 
...  def __eq__(self, other): 
...   return self.name == other.name 
...  def __hash__(self): 
...   return hash(self.name) 
...  def __str__(self): 
...   return self.name 
... 
>>> l1 = [Person("Foo", 21), Person("Bar", 22)] 
>>> l2 = [Person("Foo", 21), Person("Bar", 24)] 
>>> union_list = list(set(l1).union(l2)) 
>>> [str(l) for l in union_list] 
['Foo', 'Bar'] 

è quello che vuoi, dal name è la tua chiave unica?

Answer 5

Se si desidera che il age irrilevante rispetto alla confrontando, si dovrebbe ignorare __hash__() e __eq__() in Person anche se lo avete nel vostro Object.

Se avete bisogno di questo comportamento solo in questo (e la classica) contesti, è possibile creare un oggetto wrapper che contiene il Person e si comporta in modo diverso, come ad esempio

class PersonWrapper(Object): 
    def __init__(self, person): 
     self.person = person 
    def __eq__(self, other): 
     if hasattr(other, 'person'): 
      return self.person.name == other.person.name 
     else: 
      return self.person.name == other.name 
    def __hash__(self): 
     return hash(self.person.name) 

e poi fare

union_list = list(set(PersonWrapper(i) for i in l1).union(PersonWrapper(i) for i in l2)) 
# [Person("Foo", 21), Person("Bar", 22), Person("Bar", 24)] 

(non testato)

Answer 6

ne dite:

d1 = {p.name:p for p in l1} 
d2 = {p.name:p for p in l2} 

intersectnames = set(d1.keys()).intersection(d2.keys) 
intersect = [d1[k] for k in intersectnames] 

Potrebbe essere più veloce di gettare intersectnames al vostro ORM, nel qual caso non sarebbe costruire dizionari, basta raccogliere i nomi nelle liste.