Class Attributes and Class Methods: Python OOP Complete Course — Part 5

Before we start let me tell you that:

• This article is a part of The Complete Course in Object Oriented Programming in Python which you can find it here.
• All resources are available in the “Resources” section below.
• This article is also available as a YouTube video Part 1- Part 2- Part 3.

Introduction

So far, we have seen how we can create an instance attribute in which each object has its own value for this attribute. BUT, what if I have an attribute that has one and common value among all the class objects? For example, the bank name for bank accounts that belong to the same bank. In this case, the bank name would be the same for all the bank accounts.

So, is there a smarter way to define this attribute rather than copy and paste its value again and again for each object created for this Bank Account class?

So…

This article will cover the following outlines:

1. Attributes Types and Methods Types Reminder.
2. Class Attributes
3. Class Attributes Syntax
4. Class Methods
5. Class Methods Syntax

1. Attributes Types and Methods Types Reminder

We know that the class is the umbrella that has attributes and methods and for the attributes, we have two types:

• Instance Attributes
• Class Attributes

Whereas for the methods we have, three types which are:

• Instance Methods
• Class Methods
• Static Methods

(If you like to remember the first type from the previous article, Just click here).

In this article, we will learn about the second type of attributes and methods.

2. Class Attributes

Class attributes are the attributes that belong to the class itself rather than to a particular object.

In other words, these attributes do not belong to a specific object, whereas it belongs to the class itself. Therefore, if one of the objects changes the value of this attribute, it will be changed for all the other objects.

The question now, is how we can create class attributes?

3. Class Attributes Syntax

To add class attributes to our class, first of all, we create the class itself and give it a name ClassName.

Next, we list all the class attributes that belong to the class.

class ClassName:

    class_atrr1 = var1
    class_atrr2 = var2

In the previous code snippet, we have two class attributes:class_atrr1, and class_atrr2 and their values are var1 and var2.

As we learned before, instance attributes have been defined within the constructor method, whereas in the case of class attributes, no need to do that, and directly they will be listed below the class name.

Going back to the Student example which has been implemented in the previous article:

class Student:

    def __init__(self, _id, first_name, last_name, age):
        self.id = _id
        self.first_name = first_name
        self.last_name = last_name
        self.full_name = self.first_name + " " + self.last_name
        self.age = age
        self.class = [ ]

   def enrol(self, class_name):
       print(self.full_name)
       self.classes.append(class_name)

Let us upgrade it by adding the following attributes:

1. Define two counters:

• num_undergraduates: to count the number of undergraduate students.
• num_postgraduates: to count the number of postgraduates students.

2. Define two age ranges:

• undergraduates_age_range = range(19, 24)
• postgraduates_age_range = range(24, 30)

These age ranges will be used to figure out if the student is an undergraduate student or a postgraduate student.

Hint to help you:

• These attributes belong to the class itself, so they should be defined as class attributes.
• The initial values of the counters should be 0 when the class is defined.
• To define a variable class attribute you should use small letters only. Otherwise, if there are more than two words, there should be an underscore between them.

class Student:

    num_undergraduates = 0
    num_postgraduates = 0
 
    undergraduates_age_range = range(19, 24)
    postgraduates_age_range = range(24, 30)

    def __init__(self, _id, first_name, last_name, age):
        self.id = _id
        self.first_name = first_name
        self.last_name = last_name
        self.full_name = self.first_name + " " + self.last_name
        self.age = age
        self.class = [ ]

   def enrol(self, class_name):
       print(self.full_name)
       self.classes.append(class_name)

So far, we have created four-class attributes.

Now, each time you define a new Student object, you should use its age to increase one of the predefined students’ counters, to solve this issue, you should add an if,elif, else statements to test the Student object’s age range and update the appropriate counter.

Note:

In case the student object age does not belong to any of the predefined age ranges you should raise an exception about an invalid age.

Hint to help you:

When you try to access the class attributes inside __init__, you should use the class name for this purpose.

Solution Input:

class Student:

    num_undergraduates = 0
    num_postgraduates = 0

    undergraduates_age_range = range(19, 24)
    postgraduates_age_range = range(24, 30)

    def __init__(self, _id, first_name, last_name, age):

        self.id = _id
        self.first_name = first_name
        self.last_name = last_name
        self.full_name = self.first_name + " " + self.last_name
        self.age = age

        if self.age in Student.undergraduates_age_range:
            Student.num_undergraduates += 1

        elif self.age in Student.postgraduates_age_range:
             Student.num_postgraduates += 1
 
        else:
            raise Exception('Invalid Age')

        self.classes = []

     def enrol(self, class_name):
         print(self.full_name)
         self.classes.append(class_name)

As you can see from the previous code snippet if the student's age does not belong to any of the age ranges, the code will raise an exception to tell you that this student's age is not valid.

Define a Student object:

student1 = Student(1, 'Jack', 'Ma', 40)

Output:

Exception: Invalid Age

Now, let us test our code:

1. Define two students' objects, one undergraduate student and the other is a postgraduate student.
2. To understand the results, print the number of undergraduate and postgraduate students before and after defining these two objects.

Solution Input:

print(Student.num_undergraduates)
print(Student.num_postgraduates)

student1 = Student(1, 'Jack', 'Ma', 23)
student2 = Student(19, 'John', 'Doe', 27)

print(Student.num_undergraduates)
print(Student.num_postgraduates)

Output:

0
0
1
1

You get “0, 0” because before you have Student objects, the counter value is just “0”. However, once you define one undergraduate and one postgraduate student, each counter will be increased by “1”.

In this case, the class attributes have been accessed via the class not via the object.

Also, you can access the value of the class attributes using the object itself, as follows:

Solution Input:

student1 = Student(1, 'Jack', 'Ma', 23)
print(student1.num_undergraduates)

Output:

2

OK great, now you know how to define class attributes and how to access them. But, the question now is how to process these class attributes?

The answer is simple, we can do that using class methods.

4. Class Methods

Class Methods are the methods that have access to the class attributes, but they can’t access specific instance attributes.

In other words, these methods are used to handle and process class attributes. However, they are not used on the object level, they are used on the class level.

Usually, the first parameter of any class method is (cls) and this name is a convention in the Python community where you can use any name, but it’s highly recommended to use the same name.

(cls) represents a reference to the class itself. In short, when you define a class method, the first parameter cls will be passed automatically to the class method and it’s going to be a reference to your class.

Next, how we can define a class method in Python?

5. Class Methods Syntax

To define class methods:

1. Create the class and give it a name ClassName.
2. Next add two class attributes class_atrr1, class_atrr2 and their values are var1, var2.
3. Then define the class methods by using the keyword def and give each class method a name for example class_method1, class_method2, and as usual, between brackets add the method’s parameters. The first parameter should be cls then different positional arguments and arbitrary arguments arg1,.., argn could be added like any other function in Python.

Important Note: In order to make this method a class method, the decorator @classmethod should be used, without this decorator, the method will be a normal instance method. Even though there is (cls) as the first parameter, it will be considered as the object itself, not the class itself without the decorator.

class ClassName:

   class_atrr1 = var1
   class_atrr2 = var2

   @classmethod

   def class_method1(cls, arg1,.., argn, *args, **kwargs):
       # do something related to class_attr1, class_attr2

   @classmethod

   def class_method2(cls, arg1,.., argn, *args, **kwargs):
       # do something related to class_attr1, class_attr2

As usual, do not forget the colon when you define your functions. Otherwise, you will get a syntax error.

Now, assume that we want to define a class method to calculate the percentage of the number of undergraduate students to the total number of students.

Hint to help you:

To access the class attribute inside the class method you can use cls.class_attribute_name.

Solution Input:

class Student:

    num_undergraduates = 0
    num_postgraduates = 0

    undergraduates_age_range = range(19, 24)
    postgraduates_age_range = range(24, 30)

    def __init__(self, _id, first_name, last_name, age):

        self.id = _id
        self.first_name = first_name
        self.last_name = last_name
        self.full_name = self.first_name + " " + self.last_name
        self.age = age

        if self.age in Student.undergraduates_age_range:
           Student.num_undergraduates += 1

        elif self.age in Student.postgraduates_age_range:
             Student.num_postgraduates += 1

        else:
          raise Exception('Invalid Age')

        self.classes = []

   def enrol(self, class_name):
      print(self.full_name)
      self.classes.append(class_name)

   @classmethod
   def get_undergraduates_percentage(cls):
       num_students = cls.num_undergraduates + cls.num_postgraduates

       return cls.num_undergraduates/num_students

Now, let us test the code by:

1. Define two Student objects (undergraduate student and postgraduate student).
2. Call the class method get_undergraduates_percentage using the class name.

Solution Input:

student1 = Student(1, 'Jack', 'Ma', 23)
student2 = Student(19, 'John', 'Doe', 27)

Student.get_undergraduates_percentage()

Output:

0.5

Note:

Sometimes we can use the class method as what we call an alternative constructor.

Alternative Constructor

Sometimes the input parameters to your __init__ method could have a different shape from the expected one.

Does it seem confusing? Do not worry, let us take the following use case to make things more clear:

Assume we have an age instance attribute, but the student doesn’t want to enter his age, and he wants to enter his birthday instead. In other words, from his birthday, you can know his age. However, my class accepts age only. To solve this issue, you could define a class method that will take the birthday and it will transform it into the student age. Then the object will be defined and returned, refer to the last method in the class:

Solution Input:

from datetime import datetime

class Student:

    num_undergraduates = 0
    num_ postgraduates = 0

    undergraduates_age_range = range(19, 24)
    postgraduates_age_range = range(24, 30)

    def __init__(self, _id, first_name, last_name, age):

       self.id = _id
       self.first_name = first_name
       self.last_name = last_name
       self.full_name = self.first_name + " " + self.last_name
       self.age = age

       if self.age in Student.undergraduates_age_range:
          Student.num_undergraduates += 1

       elif self.age in Student.postgraduates_age_range:
            Student.num_postgraduates += 1

       else:
          raise Exception('Invalid Age')

       self.classes = []

    def enrol(self, class_name):
        print(self.full_name)
        self.classes.append(class_name)

    @classmethod
    def get_undergraduates_percentage(cls):
       num_students = cls.num_undergraduates + cls.num_postgraduates

       return cls.num_undergraduates / num_students

    @classmethod
    def create_student_from_birthday(cls, student_id, first_name,
        last_name,birthday):

        age = round((datetime.now() - birthday).days / 365)
        return cls(student_id, first_name, last_name, age)

Why this will work, because cls is just a reference to your class, which means cls represents your class and here in our method cls is just a Student class.

After we define the class method create_student_from_birthday, let us use it as an alternative constructor as follows:

Solution Input:

student = Student.create_student_from_birthday(1, 'Jack', 'Ma', datetime(1992, 5,30))

print(type(student))
print(student.full_name)
print()

As you can see we don’t pass the age whereas we pass the birthday of our Student object. And to make sure everything goes well, let us print the type of that student object and his full name.

Output:

<class '__main__.Student'>

Jack Ma

Note: for more information about datetime module and how to deal with it, refer to the datetime module article (the link will be added once it is published)

Now, let us summarize what we have learned in this article:

In this article we have talked about:

• Class Attributes are the attributes that belong to the class itself rather than a particular object.
• Usually, we use class attributes to define the attributes that have a common value among all the objects inside the class.
• Class Methods are the methods that have access to the class attributes. They can process, handle and update these attributes but they can’t access specific instance attributes.
• To define the class attributes, we list all the attributes below the class name, and these attributes belong to the class itself.
• To define a class method, we define it as any normal method in Python, but we use the decorator “@classmethod” and usually, the first parameter that is passed to the class method is cls, which is a reference to the class itself. Refer to Figure 1.

• You can use class methods as an alternative constructor.

P.S.: A million thanks for your time reading my story. Before you leave let me mention quickly two points:

• First, to get my posts in your inbox directly, would you please subscribe here, and you can follow me here.
• Second, writers made thousands of $$ on Medium. To get unlimited access to Medium stories and start earning, sign up now for Medium membership which only costs $5 per month. By signing up with this link, you can directly support me at no extra cost to you.

To get back to the previous article, you can use the following link:

Part 4:Instance Attributes and Instance Methods

To move on to the next article, you can use the following link:

Part 6:Static Methods

Resources:

• GitHub here.