In Python, you define a class by using the class
keyword followed by a name and a colon. Then you use .__init__()
to declare which attributes each instance of the class should have:
# dog.py
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
In the body of .__init__()
, there are two statements using the self
variable:
self.name = name
creates an attribute called name
and assigns the value of the name
parameter to it.self.age = age
creates an attribute called age
and assigns the value of the age
parameter to it.
To instantiate this Dog
class, you need to provide values for name
and age
. If you don’t, then Python raises a TypeError
:
>>> Dog()
Traceback (most recent call last):
...
TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'
To pass arguments to the name
and age
parameters, put values into the parentheses after the class name:
>>> miles = Dog("Miles", 4)
>>> buddy = Dog("Buddy", 9)
When you instantiate the Dog
class, Python creates a new instance of Dog
and passes it to the first parameter of .__init__()
. This essentially removes the self
parameter, so you only need to worry about the name
and age
parameters.
What is the use of self in Python
When working with classes in Python, the term “self” refers to the instance of the class that is currently being used. It is customary to use “self” as the first parameter in instance methods of a class. Whenever you call a method of an object created from a class, the object is automatically passed as the first argument using the “self” parameter. This enables you to modify the object’s properties and execute tasks unique to that particular instance.
The __init()___ is similar to constructors in C++ or JAVA. When you instantiate the Dog
class, Python creates a new instance of Dog
and passes it to the first parameter of .__init__()
. This essentially removes the self
parameter, so you only need to worry about the name
and age
parameters.
Instance methods are functions that you define inside a class and can only call on an instance of that class. Just like .__init__()
, an instance method always takes self
as its first parameter.
# dog.py
class Dog:
species = "Canis familiaris"
def __init__(self, name, age):
self.name = name
self.age = age
# Instance method
def description(self):
return f"{self.name} is {self.age} years old"
# Another instance method
def speak(self, sound):
return f"{self.name} says {sound}"
Creating object and calling the methods
>>> miles = Dog("Miles", 4)
>>> miles.description()
'Miles is 4 years old'
>>> miles.speak("Woof Woof")
'Miles says Woof Woof'
>>> miles.speak("Bow Wow")
'Miles says Bow Wow'
Inheritance
The Base class Dog can be inherited by the child classes as below:
# dog.py
# ...
class JackRussellTerrier(Dog):
def speak(self, sound="Arf"):
return f"{self.name} says {sound}"
# ...
Child class objects can be created as
>>> miles = JackRussellTerrier("Miles", 4)
>>> miles.speak()
'Miles says Arf'
Instances of child classes inherit all of the attributes and methods of the parent class
Parent Class functionality extension
# dog.py
# ...
class JackRussellTerrier(Dog):
def speak(self, sound="Arf"):
return f"{self.name} says {sound}"
# ...
Here, speak() is overrided in the derived class
You can access the parent class from inside a method of a child class by using super()
: # dog.py
# ...
class JackRussellTerrier(Dog):
def speak(self, sound="Arf"):
return super().speak(sound)
# ...
When you call super().speak(sound)
inside JackRussellTerrier
, Python searches the parent class, Dog
, for a .speak()
method and calls it with the variable sound
.
Garbage Collection in Python
Python’s memory allocation and deallocation method is automatic. The user does not have to preallocate or deallocate memory similar to using dynamic memory allocation in languages such as C or C++ variables declared in heap.
Python automatically schedules garbage collection based upon a threshold of object allocations and object deallocations. When the number of allocations minus the number of deallocations is greater than the threshold number, the garbage collector is run.
The garbage collection can be invoked manually in the following way:
import gc
collected = gc.collect()
print ( "Garbage collector: collected" ,
"%d objects." % collected)
|