How can I call a function within a class?

python

method-chaining

self

super

byAlex Kataev·Dec 28, 2024

To invoke a function within a class, use an instance or refer directly to the class for static/class methods. The dot notation (.) is used after the object or class name.

Instance method example:

class MyClass:
    def instance_method(self):
        print("Instance method")

obj = MyClass()
obj.instance_method()  # Output: "Instance method" No magic, just method calling!

Static method example:

class MyClass:
    @staticmethod
    def static_method():
        print("Static method")

MyClass.static_method()  # Output: "Static method" Static like a statue, kind of...

Class method example:

class MyClass:
    @classmethod
    def class_method(cls):
        print("Class method")

MyClass.class_method()  # Output: "Class method" Serving the class, not the instance.

Internal method calling using self

When you need to call a function within the same class, use self followed by the method's name and arguments enclosed in parentheses. This allows you to perform method chaining or reuse logic among methods, promoting DRY (Don't Repeat Yourself) principle.

Example of calling method within the class:

class MyClass:
    def first_method(self):
        return "Hello from the first method!"

    def second_method(self):
        # Calling another function within the same class using `self`
        message = self.first_method()
        print(message)  # Will print "Hello from the first method!"

obj = MyClass()
obj.second_method()  # Output: "Hello from the first method!", No parrots were involved in copying this message.

Supercharging your code with super()

In an inheritance scenario, super() enables the child class to call methods from the parent class. It's like asking your parent for an advice, but without the eye roll. It ensures adherence to the method resolution order (MRO) avoiding hard-coded parent class name.

Example of using super():

class ParentClass:
    def parent_method(self):
        print("Parent method")

class ChildClass(ParentClass):
    def child_method(self):
        # Calling a method from the parent class using `super()`
        super().parent_method()

child_obj = ChildClass()
child_obj.child_method()  # Output: "Parent method" Mom/Dad knows best!

Overriding with super() allows an extension of the method's functionality incorporating the parent method's logic. Think of it as upgrading from regular fries to cheese fries, yum!

Pitfalls and Conventions

You're embarking on the Python journey! Here are some do's and don'ts to help you avoid tripping:

📏 Rule of Thumb: Use self to call methods within a class instance like self.methodName(args). It's like taking a selfie; your reference is to yourself.
🌵 Avoid detailing: The class name with the instance ClassName.methodName(self, args) is like announcing your full name with every introduction. Let's avoid that awkwardness!
👷‍♂️ For static methods or class methods, which are independent of the instance data, call them directly on the class itself. Be static like the bearded wise man meditating on the mountain!
👶 Inheritance: Use super() to cherry-pick and extend the logic of parent methods. Because nobody wants a plain-old ice-cream; we all want the works: sauce, sprinkles and a cherry on top!

Leveraging advanced scenarios 👩‍💼

Going beyond the basics, there are several advanced strategies for method calling:

Decorators: Beautify and enhance your methods just like your home during festive seasons!
Method Chaining: When multiple operations are performed on the same object, it's called method chaining. Just like chaining your bikes together for safety.
Duck Typing: If it quacks like a duck, it's a duck! Work with methods and properties of an object, disregarding its actual class or type.
Monkey Patching: Changing classes or modules at runtime. You gain superpowers but use them responsibly.