Python, similarly to other object-oriented allows the user to write short and beautiful code by enabling the developer to define classes to create objects.
The developer can define the prototype of an object class based on two types of members:
- Instance members
- Class members
In the real world, these may look similar in many ways but in actuality, these are a lot different in terms of their use cases.
To understand Class members, let us recall how the instance members work:
Instance members
Instance variables in python are such that when defined in the parent class of the object are instantiated and separately maintained for each and every object instance of the class. These are usually called using the self. Keyword. The self keyword is used to represent an instance of the class
Instance variables can be defined as following using self. with the variable
Python3
class Node:
def __init__( self ):
self .msg = "This is stored in an instance variable."
print (Node().msg)
|
Output:
This is stored in an instance variable.
Note: the instance variables can only be called once the class is instantiated into an object.
In order for a method to be an instance method it needs to be passed the self attribute. Instance methods can be defined as follows:
Python3
class Node:
def __init__( self ):
self .msg = "This is stored in an instance variable."
def func( self ):
print ( 'This was printed by an instance method.' )
return self .msg
print (Node().func())
|
Output:
This was printed by an instance method.
This is stored in an instance variable.
Now that we all understand the basics of instance members in Python, Let us now understand how the class members in python work and how they may be implemented.
Class members
Class members may be defined in the scope of the class. These may usually be used with the cls keyword. The cls keyword is similar to the self keyword but unlike the self keyword, it represents the class itself.
Class variables can be declared in the class outside the methods without using any keyword. The following is how to implement Class Variables:
Python3
class Node:
cls_msg = "This is stored in an class variable."
def __init__( self ):
self .msg = "This is stored in an instance variable."
print (Node.cls_msg)
print (Node().cls_msg)
|
Output:
This is stored in an class variable.
This is stored in an class variable.
Note: The Class members are available both in an instantiated object of a class as well as for an uninstantiated class.
Class methods need to be defined using the @classmethod decorator and need to be passed a cls attribute as follows:
Python3
class Node:
cls_msg = "This is stored in an class variable."
def __init__( self ):
self .msg = "This is stored in an instance variable."
@classmethod
def func( cls ):
print ( 'This was printed by a class method.' )
return cls .cls_msg
print (Node.func())
print (Node().func())
|
Output:
This was printed by a class method.
This is stored in an class variable.
This was printed by a class method.
This is stored in an class variable.
Self vs cls Python
Note: cls works a lot similar to self. Following are some major differences:
self
|
cls
|
self works in the scope of the instance.
|
cls works in the scope of the class.
|
self can be used to access both, the members of the
instance as well as that of the class.
|
cls can only be used to access the class members.
|
Modifying a class variable
We can not modify a class variable from an instance it can only be done from the class itself.
In case we try to modify a class variable from an instance of the class, an instance variable with the same name as the class variable will be created and prioritized by the attribute lookup.
Implementation
Following snippet shows an example of class attribute modification:
Python3
class Node:
cls_msg = "This is stored in an class variable."
instance1 = Node()
print ( 'Before any modification:' )
print (instance1.cls_msg)
print (Node.cls_msg)
print ( '\n' )
instance1.cls_msg = 'This was modified.'
print ( 'After modifying class variable through an instance:' )
print (instance1.cls_msg)
print (Node.cls_msg)
print ( '\n' )
instance1 = Node()
Node.cls_msg = 'This was modified.'
print ( 'After modifying class variable through a Class:' )
print (instance1.cls_msg)
print (Node.cls_msg)
|
Before any modification:
This is stored in an class variable.
This is stored in an class variable.
After modifying class variable through an instance:
This was modified.
This is stored in an class variable.
After modifying class variable through a Class:
This was modified.
This was modified.
Modifying a class variable containing mutable objects (list, dictionaries, etc.)
Modifying a class variable that contains mutable objects can yield interesting results.
let us see with an example:
Python3
class Node:
cls_msg = [ 'This was already here.' ]
instance1 = Node()
print ( 'Before any modification:' )
print (Node.cls_msg)
print ( '\n' )
instance1.cls_msg.append( 'This was added in from an instance.' )
print ( 'After modifying class variable through an instance:' )
print (Node.cls_msg)
print ( '\n' )
instance1 = Node()
Node.cls_msg.append( 'This was added in from the class.' )
print ( 'After modifying class variable through a Class:' )
print (Node.cls_msg)
|
Before any modification:
['This was already here.']
After modifying class variable through an instance:
['This was already here.', 'This was added in from an instance.']
After modifying class variable through a Class:
['This was already here.', 'This was added in from an instance.', 'This was added in from the class.']
Finally, This can be concluded that class members in python can be very helpful in the real world and can have a wide range of interesting use cases if implemented properly.
Last Updated :
17 Apr, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...