Python class attribute access fails if attribute has no value

Question

Earlier today i stumbled upon a behaviour with python classes which i could not fully comprehend.

If we take this piece of code:

class A:
    a: str

When I test out the attribute access for a like so A.a or even A().a, I get an AttributeError: type object 'A' has no attribute 'a'.

On the contrary, if i just give A.a a value:

class A:
    a: str = 'attribute a'

then i can access it with A.a. # returns "attribute a".

I do not fully understand why the first case raised an AttributeError.

Answer 1

In the first case, you are telling the type checker that there will be an attribute called a of type str, but you are not setting it.

In the second case, you are actually giving a a value

Answer 2

In python, a class' attributes are not defined automatically. When you create the class "A" with attribute "a", you are declaring that there is this new data type, "A", and it will have a value that i will refer to as "a." You have not said what that value is yet.

In the second snippet, you have set a default value of 'attribute a' to A.a, so that if you were to create an instance of A and not define a, it will default to your input.

The first snippet is still valid, however. You would just need to create an instance of the class, like below:

#create a class
class A:
    a: str

#define your object, and set its parameters
myExample = A() 
myExample.a = "This is my input"

#printing the parameters of your object
print(myExample.a)

Answer 3

You are not declaring a variable, you are just hinting the type of the variable. Python does not create variable at this point. That's why you face error.

class A:
    a: str = 'attribute a'

Here you are creating an attribute and assigning it a value = 'attribute a'.
So type hinting does not affect the runtime behavior of the code. Actual attribute declaration requires assignment of a value

Answer 4

Here is a similar question about annotations in the global namespace:

Type hints without value assignment in Python

The answer I gave there essentially applies to names in a class namespace as well with just a few subtle differences.

---

What does annotation do?

Every user-defined class in Python has its own __annotations__ dictionary.

class A:
    pass

print(A.__annotations__)  # {}

When you add a type hint to some name in the class namespace, that name and type are added to the class' __annotations__.

class A:
    foo: str

print(A.__annotations__)  # {'foo': <class 'str'>}

---

What does attribute assignment do?

What is different from the global namespace is how attributes are created for classes. This is a fairly complex topic having to do with the specific metaclass in play, but in general anything you assign within the class namespace will end up in that class' __dict__ upon creation.

from pprint import pprint

class A:
    foo = "spam"

pprint(dict(A.__dict__))

{'__dict__': <attribute '__dict__' of 'A' objects>,
 ...,
 'foo': 'spam'}

In the Data Model documentation we can find the following explanation:

When a new class is created by type.__new__, the object provided as the namespace parameter is copied to a new ordered mapping and [...] wrapped in a read-only proxy, which becomes the __dict__ attribute of the class object.

This also includes any method definitions or inner class definitions within the class namespace by the way.

from pprint import pprint

class A:
    foo = "spam"

    def bar(self): ...

    class Inner: ...

pprint(dict(A.__dict__))

{'Inner': <class '__main__.A.Inner'>,
 ...
 'bar': <function A.bar at 0x...>,
 'foo': 'spam'}

---

How does attribute lookup work?

The attribute lookup mechanism is arguably even more complicated, but again in general it happens to look for the given name in the class' __dict__, then (if it does not find it) in its parent class' __dict__, and so on.

To quote from the relevant section of the Data Model documentation:

Class attribute references are translated to lookups in this dictionary, e.g., C.x is translated to C.__dict__["x"] (although there are a number of hooks which allow for other means of locating attributes). [...] Class attribute assignments update the class’s dictionary, never the dictionary of a base class.

During object attribute access the __getattribute__ method is called. This also applies to classes (because they are objects as well).

So the following lines after the class definition are almost equivalent:

class A:
    foo = "spam"

print(A.foo)
print(A.__dict__["foo"])
print(A.__getattribute__(A, "foo"))

They all print spam.

---

Annotation is independent of assignment

So what happens, when you just provide a type hint in a class namespace, but do not assign anything, is that an entry in its __annotations__ dictionary is added, but no corresponding key is added to the class' __dict__.

class A:
    foo: str

print("foo" in A.__annotations__)  # True
print("foo" in A.__dict__)         # False

And since A does not have a parent class with a foo attribute either, an attempt to access A.foo will cause an AttributeError. (That is analogous to the NameError for an unassigned name in the global namespace.)

The error tells you that there is literally no value that can be in any way associated with the name A.foo. Not None or any other special object! Literally no value.

When you do both, i.e. annotate and assign, you add that name to both the __annotations__ and the __dict__ of the class.