Table of Contents
Whether you are new to programming or coming from another language, static class variables in Python can be a confusing concept. In this tutorial, you will learn how Python defines them and what you can do with those variables.
Static Or Class Variables In Python
An static variable in Python is a type of variable that is declared within a specified class but not within an method. Static or class variables can be referred to via a class within the class in which it is defined, but not directly. A static variable can also be known as a class variables. These variables are limited to a class, therefore they can’t alter the condition of the object.
This is a program that uses class or static variable in python
class fruits(object):
count = 0
def __init__(self, name, count):
self.name = name
self.count = count
fruits.count = fruits.count + count
def main():
cherry = fruits("cherry", 28);
pineapple = fruits("pineapple", 22);
print (cherry.count)
print (pineapple.count)
print (fruits.count)
print (cherry.__class__.count)
print (type(pineapple).count)
if __name__ == "__main__":
main()
Result
28
22
50
50
50
This is a program that uses variables defined at the class level
class vehicles: # Python static variable
static_Variable = 8
# Access through class
print (vehicles.static_Variable)
# Access through an instance
instance = vehicles()
print(instance.static_Variable)
# Change within an instance
instance.static_Variable = 17
print(instance.static_Variable)
print(vehicles.static_Variable)
Result
8
8
17
8
To Define Static Variables in Python
Use staticmethod()
To return a static variable in python we use the staticmethod() method. Here is sample
class Example_Static_Varicable:
def random(text_sample):
print(text_sample)
print("Define Static Variables in Python")
Example_Static_Varicable.random = staticmethod(Example_Static_Varicable.random)
Example_Static_Varicable.random("Use staticmethod to define")
Result:
Use staticmethod to define
Define Static Variables in Python
Use @staticmethod
A decorator is a way to add new functionality to an object without modifying its initial structure. Python has a built in decorator called @staticmethod which facilitates the process of defining one or more static variables in a class.
To define a static variable in python we use @staticmethod. Here is sample
class ExStaticVar1:
# @staticmethod
def random(text_sample1):
print(text_sample1)
print("Define Static Variables in Python")
ExStaticVar1.random("Use @staticmethod to define")
Output:
Use @staticmethod to define
Define Static Variables in Python
What is class variables in Python?
Python enables object-oriented programming (OOP) with both variables used at both instance and class levels. Class variables are defined directly within a class but outside of any constructor.
They are owned and become attributes of that class, not any specific instance. Instead, those variables are shared with all instances belonging to the class. When you modify a class variable, it affects every instance immediately.
C and C++ programmers typically use the static variable terms to indicate those associated with a class but not any instance of that class.
Python officially doesn’t have this keyword. But if your code is in need of variables that are static within a class and outside the scope of its instances, class variables are what you are looking for. They stand in stark contrast to instance variables, which are attributes of each instance itself.
Check out this example:
# Define a class, with a class and example variable
class vehicle:
type = "car"
def __init__(self, brand):
self.brand = brand
# Generate two examples of the class
X7 = vehicle("BMW")
GLS450 = vehicle("Mercedes")
print("Class variable:")
print(vehicle.type)
print("\nFirst example:")
print(X7.type)
print(X7.brand)
print("\nSecond example:")
print(GLS450.type)
print(GLS450.brand)
# Change the class variable
print("\nAfter changing the class variable:")
vehicle.type = "means of transports"
print("\nFirst example:")
print(X7.type)
print(X7.brand)
print("\nSecond example:")
print(GLS450.type)
print(GLS450.brand)
Output:
Class variable:
car
First example:
car
BMW
Second example:
car
Mercedes
After changing the class variable:
First example:
means of transports
BMW
Second example:
means of transports
Mercedes
We create a class named “vehicle” and assign a value to the type variable. As you can see, the “X7” and “GLS450” instances also inherit this variable. This is true even after we change its value.
Meanwhile, the brand instance variables can have different values for each instance.
When to use class variables in python
Class variables have a lot of use in Python, especially when you need to adhere to the DRY rule:
Store class-wide constants
When you need to define some specific constants that every instance should have access to, class or static variables in Python would come in handy.
Here is an example of using class variables to calculate the circumference of circles:
class Circle():
Pi = 3.1416
def __init__(self, diameter):
self.diameter = diameter
def circumference(self):
return self.Pi * self.diameter
perimeter = Circle(7)
print('The circumference of the circle is',perimeter.circumference())
Output:
The circumference of the circle is 21.9912
Define default values
Another common application of class variables is to create default values for all class instances.
This snippet verifies that each iPhone has the latest IOS version installed.
class IOS:
new_version = 16
def __init__(self, current_version):
self.current_version = current_version
def upgrade_check(self):
if self.current_version < self.new_version:
print("You are using the old iOS version. You need to upgrade to the latest version.")
else:
print("You are using the latest iOS version.")
iphone11 = IOS(14)
iphone12Pro = IOS(16)
iphone13 = IOS(16)
iphone11.upgrade_check()
iphone12Pro.upgrade_check()
iphone13.upgrade_check()
Output:
You are using the old iOS version. You need to upgrade to the latest version.
You are using the latest iOS version.
You are using the latest iOS version.
Final Words
You can define and access class or static variables in Python for different purposes. They are available to every instance of that class. Using these class-specific variables allows you to adopt the best OPP practices and reduce repetition.
Leave a comment