Как определить структуру данных со своим in?

a,b,c,d=MyClass(1,2,3), MyClass(1,2,3), MyClass(2,2,3), MyClass(2,2,3)
 
s1=set([a,d])
s2=set([c,d])
 
s1|=s2 # и все остальные операции с множествами

>>> class A:
...     def __init__(self, lst):
...         self._lst = lst
...     def __hash__(self):
...         return 0
...     def __eq__(self, a):
...         return self._lst == a._lst
...     def __repr__(self):
...         return '{}({})'.format('A', self._lst)
... 
>>> s1 = {A([1, 2, 3]), A([4, 5, 6])}
>>> s2 = {A([1, 1, 1]), A([2, 2, 2])}
>>> 
>>> union = s1 | s2
>>> print(union)
{A([4, 5, 6]), A([1, 2, 3]), A([2, 2, 2]), A([1, 1, 1])}
>>> print(union - {A([1, 1, 1])})
{A([4, 5, 6]), A([1, 2, 3]), A([2, 2, 2])}
>>>

In [2]: class Klass:
   ...:     def __eq__(self, b):
   ...:         return id(self) == id(b)
   ...:     def __hash__(self):
   ...:         return id(self) # или hash(id(self))

# -*- coding CP1251 -*-
 
class Pt:
    def __init__(self,x,y):
        self.x=x
        self.y=y
 
    def __eq__(self,y):
        return (self.x==y.x) and (self.y==y.y)
 
    def __repr__(self):
        return '({},{})'.format(self.x,self.y)
 
class Rib:      
    def __init__(self,pt1,pt2):
        self.pt1=pt1
        self.pt2=pt2
        self.mf=set()
        self.olf=set()
 
    def __hash__(self):
        return 0
    
    def __eq__(self,r2):
        return (self.pt1==r2.pt1) and (self.pt2==r2.pt2)
 
    def __repr__(self):
        return '{}({}-{})-({})'.format('Rib', self.pt1,self.pt2,self.mf)
 
a=Rib(Pt(1,1),Pt(2,3))
a.mf={1,2}
b=Rib(Pt(1,1),Pt(2,4))
 
c=Rib(Pt(1,1),Pt(2,3))
c.mf={0,1}
d=Rib(Pt(1,1),Pt(2,4))
 
s1=set([a,b])
s2=set([c,d])
 
print(s1==s2)
s1|=s2
 
for rib in s1:
    print(rib, end='\n')
 
print(c in s1)
print(c)

# -*- coding: utf-8 -*-
#!/usr/bin/env python3
 
class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
 
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
 
    def __hash__(self):
        return hash((self.x, self.y))
 
    def __repr__(self):
        return '({x},{y})'.format(x=self.x, y=self.y)
 
class Edge:
    def __init__(self, pt1, pt2):
        self.pt1, self.pt2 = pt1, pt2
 
    def __eq__(self, other):
        return self.pt1 == other.pt1 and self.pt2 == other.pt2
 
    def __hash__(self):
        return hash((self.pt1, self.pt2))
 
    def __repr__(self):
        return 'Edge({pt1}-{pt2})'.format(pt1=self.pt1, pt2=self.pt2)

>>> x = Point(1, 2)
>>> y = Point(2, 2)
>>> Edge(x, y) == Edge(x, x)
False
>>> Edge(x, y) == Edge(x, y)
True
>>> Edge(x, y) in {Edge(x, y)}
True
>>> Edge(x, x) in {Edge(x, y)}
False
>>>

>>> Edge(x, y) == Edge(y, x)
False
>>> Edge(x, y) in {Edge(y, x)}
False
>>>

        return (self.x, self.y) == (other.x, other.y)