A class is more or less a fancy wrapper for a dict of attributes to objects. When you instantiate a class you can assign to its attributes, and those will be stored in foo.__dict__; likewise, you can look in foo.__dict__ for any attributes you have already written.

This means you can do some neat dynamic things like:

class Employee: pass
def foo(self): pass
Employee.foo = foo

as well as assigning to a particular instance. (EDIT: added self parameter)

When you create a new class, you are creating a new type. This newly created type may have some properties, or may not. These properties allow to hold data, methods etc.

Empty class that doesn't inherit any base class would be useful as placeholder.

class ServiceWrapper(object):
    pass

def sendMessage(svc:ServiceWrapper):
    #do something
    #pass

On the other hand, empty classes that inherit other classes is a very common pattern. Specially when defining user exceptions.

class Networkerror(RuntimeError):
    pass

try:
    raise Networkerror()
except Networkerror:
    #do something
    #pass

Also recently, the python collections.abc allows creating interface like functionalities.

class ServiceWrapper(ABC):
    @abstractmethod
    def send(self):...

def sendMessage(svc:ServiceWrapper):
    svc.send()
    #pass

Yes, in Python 3.3 SimpleNamespace was added

Unlike object, with SimpleNamespace you can add and remove attributes. If a SimpleNamespace object is initialized with keyword arguments, those are directly added to the underlying namespace.

Example:

import types

x = types.SimpleNamespace()
x.happy = True

print(x.happy) # True

del x.happy
print(x.happy) # AttributeError. object has no attribute 'happy'

types.SimpleNamespace was introduced with Python 3.3 to serve this exact purpose. The documentation also shows a simple way to implement it yourself in Python, so you can add it to your pre-Python 3.3 setup and use it as if it was there (note that the actual implementation is done in C):

class SimpleNamespace (object):
    def __init__ (self, **kwargs):
        self.__dict__.update(kwargs)
    def __repr__ (self):
        keys = sorted(self.__dict__)
        items = ("{}={!r}".format(k, self.__dict__[k]) for k in keys)
        return "{}({})".format(type(self).__name__, ", ".join(items))
    def __eq__ (self, other):
        return self.__dict__ == other.__dict__

But of course, if you don’t need its few features, a simple class Empty: pass does just the same.

Suppose you want to store some collection of named data. You could use a dict but you like the look of dotted attributes in a class object. Just create the most boring class possible and use python's native attribute assignment to do the trick. It is usually a question of aesthetics.

Since the parentObject member is of the same type as the class itself, I need to declare this as an empty variable of type "self".

No, you do not need to declare anything in Python. You just define things.

And self is not a type, but the conventional name for the first parameter of instance methods, which is set by the language to the object of the method.

Here's an example:

class Tree(object):

    def __init__(self, label=None):
        self.label = label
        self.parent = None
        self.children = []

    def append(self, node):
        self.children.append(node)
        node.parent = self

And here's how that could be used:

empty_tree = Tree()

simple_tree = Tree()
simple_tree.append(Tree('hello'))
simple_tree.append(Tree('world'))