Assuming that your object has only a title attribute which is relevant for equality, you have to implement the __eq__ method as follows:

class YourObject:
    [...]
    def __eq__(self, other):
        return self.title == other.title

Of course if you have more attributes that are relevant for equality, you must include those as well. You might also consider implementing __ne__ and __cmp__ for consistent behaviour.

your example works fine, the only problem you could have is a performance issue with the in operator for list which is O(n).

If you don't care about the order of the keys (which is likely), just do this:

self.key_vertices = set()

then:

if key not in self.key_vertices:
    # add a new key to the array
    self.key_vertices.add(key)
    # create a vertex object to store dependency information
    self.verteces.append(Vertex(key, children))

you'll save a lot of time in the in operator because set in is way faster due to key hashing.

And if you don't care about order in self.verteces, just do a dictionary, and in that case, you probably don't need the first key parameter to your Vertex structure.

self.verteces = dict()

if key not in self.verteces:
    # create a vertex object to store dependency information
    self.verteces[key] = Vertex(children)

Go through this. It's the page on operator overloading in classes. Find the function that you need!

Edit: You need to implement __eq__ to check if the members of two objects are equal. Eg:

class Foo:
    def __init__(self, val):
        self.val = val
    def __eq__(self, other):
        if self.val == other.val:
            return True
        return False

l = [Foo(i) for i in range(10)]
print(Foo(2) in l)
print(Foo(100) in l)

Output:

True
False

You can choose not to check all the members and compare only the ones that matter to you.

If you want to use your own flag, you could do:

for o in main_object_list:
    o.my_special_flag = True 

for o in main_object_list:
    obj_list = o.get_this_object_list()
    for i in obj_list:
        if hasattr(i, 'my_special_flag'):

Otherwise set.intersection is as fast as it gets:

main_object_set = set(main_object_list)

for o in main_object_list:
    obj_list = o.get_this_object_list()
    objs_in_main_list = main_object_set.intersection(obj_list)
    for i in objs_in_main_list:
        //do something with i

Or:

main_object_set = set(main_object_list)

objs_in_main_list = set().update(
                           *(o.get_this_object_list() for o in main_object_list))
objs_in_main_list.intersection_update(main_object_set)

As you can easily see from the documentation, the any() function short-circuits an returns True as soon as a match has been found.

any(x.name == "t2" for x in l)