How to forbid creation of new class attributes in Python?

@AlexisBRENON's answer works but if you want to emulate the behavior of a built-in class, where subclasses are allowed to override attributes, you can set the __frozen attribute to True only when the bases argument is empty:

class FrozenMeta(type):
    def __new__(cls, name, bases, dct):
        inst = super().__new__(cls, name, bases, {"_FrozenMeta__frozen": False, **dct})
        inst.__frozen = not bases
        return inst
    def __setattr__(self, key, value):
        if self.__frozen and not hasattr(self, key):
            raise TypeError("I am frozen")
        super().__setattr__(key, value)

class A(metaclass=FrozenMeta):
    a = 1
    b = 2

class B(A):
    pass

B.a = 2
B.c = 1 # this is OK
A.c = 1 # TypeError: I am frozen

Whenever you see built-in/extension type you are dealing with an object that was not created in Python. The built-in types of CPython were created with C, for example, and so the extra behavior of assigning new attributes was simply not written in.

You see similar behavior with __slots__:

>>> class Huh:
...    __slots__ = ('a', 'b')

>>> class Hah(Huh):
...    pass

>>> Huh().c = 5   # traceback
>>> Hah().c = 5   # works

As far as making Python classes immutable, or at least unable to have new attributes defined, a metaclass is the route to go -- although anything written in pure Python will be modifiable, it's just a matter of how much effort it will take:

>>> class A(metaclass=FrozenMeta):
...     a = 1
...     b = 2

>>> type.__setattr__(A, 'c', 9)
>>> A.c
9

A more complete metaclass:

class Locked(type):
    "support various levels of immutability"
    #
    def __new__(metacls, cls_name, bases, clsdict, create=False, change=False, delete=False):
        cls = super().__new__(metacls, cls_name, bases, {
                "_Locked__create": True,
                "_Locked__change": True,
                "_Locked__delete": True,
                **clsdict,
                })
        cls.__create = create
        cls.__change = change
        cls.__delete = delete
        return cls
    #
    def __setattr__(cls, name, value):
        if hasattr(cls, name):
            if cls.__change:
                super().__setattr__(name, value)
            else:
                raise TypeError('%s: cannot modify %r' % (cls.__name__, name))
        elif cls.__create:
            super().__setattr__(name, value)
        else:
            raise TypeError('%s: cannot create %r' % (cls.__name__, name))
    #
    def __delattr__(cls, name):
        if not hasattr(cls, name):
            raise AttributeError('%s: %r does not exist' % (cls.__name__, name))
        if not cls.__delete or name in (
                '_Locked__create', '_Locked__change', '_Locked_delete',
                ):
            raise TypeError('%s: cannot delete %r' % (cls.__name__, name))
        super().__delattr__(name)

and in use:

>>> class Changable(metaclass=Locked, change=True):
...     a = 1
...     b = 2
... 
>>> Changable.a = 9
>>> Changable.c = 7
Traceback (most recent call last):
    ...
TypeError: Changable: cannot create 'c'
>>> del Changable.b
Traceback (most recent call last):
    ...
TypeError: Changable: cannot delete 'b'