Methods

🐍 Python OOP Methods: Your Object’s Superpowers!

Imagine your Python objects are like robots. Each robot can do things—walk, talk, dance! But HOW does a robot know what to do? Through its methods—the special instructions inside it!

🎯 What Are We Learning?

We’ll discover 5 types of methods that give objects their powers:

1. Instance Methods – Personal skills for each robot
2. Class Methods – Skills shared by ALL robots of the same type
3. Static Methods – Helper skills that don’t need a robot at all
4. Property Decorator – Secret doors to peek inside robots
5. Getters and Setters – Guards that protect robot secrets

🤖 Our Story: The Robot Factory

Let’s imagine you own a Robot Factory. You build different robots, and each robot needs different abilities. Let’s see how Python methods help!

1️⃣ Instance Methods: Personal Robot Skills

The Simple Idea

An instance method is a skill that belongs to ONE specific robot. If you have Robot-A and Robot-B, each can use the skill differently based on their own data.

Think of it like this:

You and your friend can both say your name. But when YOU say your name, you say “I am Alex.” When your FRIEND says their name, they say “I am Sam.” Same skill, different result!

Example:

class Robot:
    def __init__(self, name):
        self.name = name

    def say_hello(self):
        return f"Hello! I am {self.name}"

# Create two robots
robot_a = Robot("Spark")
robot_b = Robot("Bolt")

print(robot_a.say_hello())
# Output: Hello! I am Spark

print(robot_b.say_hello())
# Output: Hello! I am Bolt

Key Points:

• self is the magic word. It means “THIS robot” or “ME”
• Every instance method gets self as its first friend
• Each robot uses its OWN data when the method runs

2️⃣ Class Methods: Skills for ALL Robots

The Simple Idea

A class method is a skill that works with the WHOLE robot family, not just one robot. It can change things that affect ALL robots at once!

Think of it like this:

Imagine the robot factory has a rule: “All robots must be blue.” A class method can change this rule to “All robots must be red.” Now EVERY new robot follows the new rule!

Example:

class Robot:
    factory_name = "RoboTech"

    def __init__(self, name):
        self.name = name

    @classmethod
    def change_factory(cls, new_name):
        cls.factory_name = new_name
        return f"Factory is now: {new_name}"

# Check current factory
print(Robot.factory_name)
# Output: RoboTech

# Change factory name for ALL robots
Robot.change_factory("MegaBots")
print(Robot.factory_name)
# Output: MegaBots

Key Points:

• Use @classmethod decorator above the method
• First parameter is cls (the class itself), not self
• Changes affect the WHOLE class, not just one robot

3️⃣ Static Methods: Helper Skills (No Robot Needed!)

The Simple Idea

A static method is like a helper tool in the factory. It doesn’t need a robot to work. It just does its job independently!

Think of it like this:

The calculator in your factory can add numbers. It doesn’t need to know anything about robots. It just adds 2 + 2 = 4. That’s it!

Example:

class Robot:
    def __init__(self, name):
        self.name = name

    @staticmethod
    def add_numbers(a, b):
        return a + b

    @staticmethod
    def is_valid_name(name):
        return len(name) >= 2

# Use without creating a robot!
result = Robot.add_numbers(5, 3)
print(result)
# Output: 8

valid = Robot.is_valid_name("X")
print(valid)
# Output: False

Key Points:

• Use @staticmethod decorator
• NO self or cls parameter needed
• Lives inside the class but works independently
• Great for utility functions related to the class

4️⃣ Property Decorator: Secret Windows

The Simple Idea

The @property decorator lets you peek at data inside a robot like you’re reading a simple value, but secretly there’s a method running behind the scenes!

Think of it like this:

Imagine asking a robot “What’s your power level?” The robot doesn’t just tell you a number. It secretly calculates: “My batteries are 80%, so my power is 80!” But to YOU, it looks like a simple answer.

Example:

class Robot:
    def __init__(self, name, battery):
        self.name = name
        self._battery = battery

    @property
    def power_level(self):
        if self._battery > 50:
            return "High Power!"
        return "Low Power!"

robot = Robot("Spark", 75)

# Looks like reading a value...
print(robot.power_level)
# Output: High Power!

# But it's actually a method calculating!

Key Points:

• Use @property decorator
• Access like an attribute: robot.power_level (no parentheses!)
• Behind the scenes, it runs a method
• Perfect for calculated or dynamic values

5️⃣ Getters and Setters: Robot Guards

The Simple Idea

Getters and Setters are like security guards. The Getter lets you READ a value. The Setter lets you CHANGE a value—but only if it’s safe!

Think of it like this:

A robot’s battery can’t be -50% (that’s impossible!). The Setter guard checks: “Is this a valid battery level? If yes, I’ll allow it. If no, I’ll reject it!”

Example:

class Robot:
    def __init__(self, name):
        self.name = name
        self._battery = 100

    # GETTER - reads the battery
    @property
    def battery(self):
        return self._battery

    # SETTER - changes the battery (with guard!)
    @battery.setter
    def battery(self, value):
        if value < 0:
            print("Error! Battery can't be negative!")
        elif value > 100:
            print("Error! Battery can't exceed 100!")
        else:
            self._battery = value

robot = Robot("Bolt")

# GETTER in action
print(robot.battery)
# Output: 100

# SETTER with valid value
robot.battery = 75
print(robot.battery)
# Output: 75

# SETTER blocking bad value
robot.battery = -10
# Output: Error! Battery can't be negative!
print(robot.battery)
# Output: 75 (unchanged!)

Key Points:

• Getter: @property decorator, returns the value
• Setter: @propertyname.setter decorator, validates and sets
• Convention: use _variable (underscore) for the “private” data
• Guards protect your data from bad values!

🗺️ The Big Picture

graph LR
    A["Python Methods"] --> B["Instance Methods"]
    A --> C["Class Methods"]
    A --> D["Static Methods"]
    A --> E["Property Decorator"]
    A --> F["Getters & Setters"]

    B --> B1["Uses self"]
    B --> B2["Works on ONE object"]

    C --> C1["Uses cls"]
    C --> C2["Works on WHOLE class"]

    D --> D1["No self or cls"]
    D --> D2["Independent helper"]

    E --> E1["Read like attribute"]
    E --> E2["Runs method secretly"]

    F --> F1["Getter reads"]
    F --> F2["Setter validates"]

🎭 Quick Comparison Table

🌟 Real-World Analogy Recap

🏭 The Robot Factory Story:

• Instance Method = Each robot’s personal skill (saying its own name)
• Class Method = Factory-wide rule changes (new paint color for all)
• Static Method = Factory calculator (works without any robot)
• Property = Smart display screen (shows calculated info)
• Getter/Setter = Security guards (protect robot data)

🚀 You Did It!

You now understand the 5 superpowers that Python methods give your objects:

1. ✅ Instance Methods – Personal actions using self
2. ✅ Class Methods – Class-wide actions using cls
3. ✅ Static Methods – Independent helpers
4. ✅ Property Decorator – Read-like-value, runs-like-method
5. ✅ Getters and Setters – Data protection guards

Your objects are now super-powered robots ready to take on the world! 🤖⚡

Remember: Every method type has its special purpose. Choose wisely, and your code will be clean, safe, and powerful!