Class Attribute and Instance Attribute of Python

Introduction

A Python object has two types of attributes: Class Attribute and Instance Attribute.

As the above example, class_attr is a class attribute and self.instance_attr is an instance attribute. Sometimes it’s really confusing. Why we have two types? Why not always define attributes as class attribute or instance attribute? What are differences of them? This post will uncover the mystery for you.

What’s the Differences

• A class attribute is a variable which belongs to a class rather than a particular instance. All instances of this class can access it and it is defined outside the constructor function, __init__(self,...), of the class.
• An instance attribute inside the constructor function is a variable belonging to a particular instance of a class. This variable is only accessible in this instance rather than the class. If we call a instance attribute by the class, there will be an AttributeError.

Why the Differences?

Because these two attributes are in different namespaces. The namespace means a dictionary which contains mappings of names and objects. It helps us call an object by its name conveniently. There is no relations between names in different namespaces. We can use print __dict__ to the namespace of an object.

As the above example shown, the namespace of the class doesn’t has instance_attr , so we can’t access it.

However, why can we access the class_attr by the instance even there is no class_attr in my_instance.__dict__ ? Because the rule of namespace is: searching the namespace of a instance first, if nothing found, searching its class namespace. It is a bottom up method rather than a top down method. Therefore, we can’t access the instance namespace by the class but we can access the class namespace by its instance.

There is an interesting problem: if the class attribute and instance attribute have the same name, what will happen?

Let’s look an example:

As shown above, namespace of instance has priority over namespace of class, so the guy.name is “Jack” at the beginning. After del guy.name , we don’t have name attribute in instance namespace, if we use the same name again, the class attributes will be accessed.

My suggestion is: when writing a program, do not use the same name for instance attributes and class attributes. It could result in unintended consequences because sometimes we could forget which type of attribute we are using if their names are the same.

By the way, Yang is really an handsome guy. If you don’t believe it, please look the example code again. 😄

Change Values of Class Attribute

The rules are:

• If we change the value of a class attribute by the class, we will get the new value of course when we access it by instances.
• However, if we change the value of a class attribute by an instance, the result is a little complicated, two different consequences for two situations:

1. If this attribute is immutable, the attribute will become a instance attribute within current instance, the value changes will not affect other instances and the class.

2. If this class attribute is mutable, the results depend on how we change it.

My suggestion is: always define class attributes as immutable objects to avoid unintended results. For this example, we can define like this:

class MyClass(object):
    data = None

    def __init__(self, value):
        self.instance_data = value

We define the data as None rather than list.

It looks like just a minor issue. But, actually it will avoid lots of hidden bugs in a big project. If you are in an interview, how you define the data will show whether you are Senior Python Developer or not.

When to Use Class Attribute

1. Define some constant or default value as class attribute which can use for every instances.

class Circle(object):
    PI = 3.14

    def __init__(self, value):
        self.radius = value

def area(self):
        return Circle.PI * self.radius * self.radius

Because class attributes are created during class definition, while instance attributes will be assigned again when a new instance is created. It’s not only more convenient but also more efficient if we define some constants/default values as class attributes.

2. Record some data which is across all instances.

class HandsomeGuy(object):
    all_names = []

    def __init__(self, name):
        self.name = name
        Person.all_names.append(name)

Conclusion

To be a Senior Python Developer, we should have a deeply understanding of some features and avoid unexpected bugs. The differences between class attributes and instance attributes are important but not everyone is totally clear with that. To summary, remember the two suggestions mentioned in this post:

• Do not use the same name for instance attributes and class attributes.
• Always define class attributes as immutable objects to avoid unintended results.

Thanks for reading. If you like it, please follow my publication TechToFreedom, where you can enjoy other Python tutorials and topics about programming, technology and investment.