Use isinstance to check if o is an instance of str or any subclass of str:

if isinstance(o, str):

To check if the type of o is exactly str, excluding subclasses of str:

if type(o) is str:

See Built-in Functions in the Python Library Reference for relevant information.

Checking for strings in Python 2

For Python 2, this is a better way to check if o is a string:

if isinstance(o, basestring):

because this will also catch Unicode strings. unicode is not a subclass of str; both str and unicode are subclasses of basestring. In Python 3, basestring no longer exists since there's a strict separation of strings (str) and binary data (bytes).

Alternatively, isinstance accepts a tuple of classes. This will return True if o is an instance of any subclass of any of (str, unicode):

if isinstance(o, (str, unicode)):

The problem is that in changing a tag name attribute, you change its hash in the class above: and the hash of an object must not change after it is added to a set or as dictionary as a key.

The thing is that if two objects are "equal" they must have the same hash value - since you want your tags to be comparable by name, this implies that they can't have their name changed at all: if an object compares equal to another, their hash values must also be the equal: i.e. you can't simply add another immutable attribute to your class and base your hash value on that instead of the name.

The workaround I see in this case is to have a special "add_to_set" method on your Tag class; it would then track the sets it belongs to, and turn name into a property instance, so that whenever name is changed, it removes and re-adds the Tag itself from all sets it belongs to. The newly re-inserted tag would behave accordingly.

Making this work properly in parallel code would take somewhatmore work: as one could make use of the sets in another thread during the renaming - but if that is not a problem, then what is needed is:

class Tag:

    def __init__(self, name, description=""):
        self.sets = []
        self.name = name
        self.description = description

    ...  # other methods as in your code 

    def __hash__(self):
        return hash(self.name)

    def add_to_set(self, set_):
        self.sets.append(set_)
        set_.add(self)

    def remove_from_set(self, set_):
        self.sets.remove(set_)
        set_.remove(self)

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        # WARNING: this is as thread unsafe as it gets! Do not use this class
        # in multi-threaded code. (async is ok)
        
        try:
            for set_ in self.sets:
                set_.remove(self)
            self._name = value
        finally:
            for set_ in self.sets:
                set_.add(self)

And now:

In [17]: a = Tag("blue")

In [18]: b = set()

In [19]: a.add_to_set(b)

In [20]: a in b
Out[20]: True

In [21]: b
Out[21]: {blue}

In [22]: a.name = "mauve"

In [23]: b
Out[23]: {mauve}

In [24]: a in b
Out[24]: True

It is possible to specialize a set class that would automatically call the add_to_set and remove_from_set methods for you as well, but this is likely enough.