This chapter is taken from the book A Primer on Scientific Programming with Python by H. P. Langtangen, 5th edition, Springer, 2016.
Up to now, each instance has its own copy of data attributes. Sometimes it can be natural to have data attributes that are shared among all instances. For example, we may have an attribute that counts how many instances that have been made so far. We can exemplify how to do this in a little class for points \( (x,y,z) \) in space:
>>> class SpacePoint(object): ... counter = 0 ... def __init__(self, x, y, z): ... self.p = (x, y, z) ... SpacePoint.counter += 1
counter data attribute is initialized at the same indentation level
as the methods in the class, and the attribute is not prefixed
self. Such attributes declared outside methods are shared among
all instances and called static attributes.
To access the
counter attribute, we must prefix
by the classname
SpacePoint instead of
In the constructor we increase this common counter by 1, i.e.,
every time a new instance is made the counter is updated to keep track
of how many objects we have created so far:
>>> p1 = SpacePoint(0,0,0) >>> SpacePoint.counter 1 >>> for i in range(400): ... p = SpacePoint(i*0.5, i, i+1) ... >>> SpacePoint.counter 401
The methods we have seen so far must be called through an instance, which is
fed in as the
self variable in the method.
We can also make class methods that can be called without having an
instance. The method is then similar to a plain Python function, except that
it is contained inside a class and the method name must be prefixed
by the classname. Such methods are known as static methods.
Let us illustrate the syntax by making a very simple
class with just one static method
>>> class A(object): ... @staticmethod ... def write(message): ... print message ... >>> A.write('Hello!') Hello!
As demonstrated, we can call
write without having any instance
A, we just prefix with the class name. Also note that
write does not take a
Since this argument is missing inside the method, we can never access
non-static attributes since these always must be prefixed by an instance
self). However, we can access static attributes, prefixed
by the classname.
If desired, we can make an instance and call
that instance too:
>>> a = A() >>> a.write('Hello again') Hello again
Static methods are used when you want a global function, but find it natural to let the function belong to a class and be prefixed with the classname.