Class Components: Methods and Properties

Regular Instance Methods: A Quick Recap

So far, every method we've written has been an instance method.

class Employee:
    def __init__(self, first, last):
        self.first = first
        self.last = last

    # This is an instance method
    def fullname(self):
        return f'{self.first} {self.last}'

The fullname method needs a specific instance (via self) to do its job. You can't call Employee.fullname() because it wouldn't know which employee's name to return.

But what if a method's logic is related to the class as a whole?

Class Methods: Working with the Class

A class method is bound to the class, not the object. Instead of the instance (self), it implicitly receives the class itself as the first argument, conventionally named cls.

You create one using the @classmethod decorator.

Class methods have two primary use cases:

1. Modifying class-level state.
2. Serving as alternative constructors (factory methods).

Let's see this in action. The following video continues with the Employee class example from our previous lessons.

As the video showed, using a class method as an alternative constructor is an extremely powerful pattern. Imagine you need to create objects from various data sources like a string, a dictionary from a JSON file, or a row from a database. Instead of cluttering your __init__ with complex logic, you can provide clean, separate class methods for each case.

class Employee:
    # ... __init__ and other methods ...

    @classmethod
    def from_string(cls, emp_str):
        # Parses a string like "John-Doe-70000"
        first, last, pay = emp_str.split('-')
        # 'cls' here refers to the Employee class
        return cls(first, last, int(pay)) 

# Now we can create an instance directly from a string
new_emp = Employee.from_string('Jane-Doe-90000')
print(new_emp.email) # Output: Jane.Doe@company.com

Static Methods: Logically Grouped Functions

What if a method doesn't need access to the instance (self) or the class (cls)? That's when you use a static method.

A static method is essentially a regular function that lives inside a class's namespace, usually because it's logically related to the class. You create one using the @staticmethod decorator.

Let's continue with the video to see a practical example.

A good rule of thumb for deciding between method types is:

• Does it need the instance's data (self)? Use an instance method. (Most common)
• Does it need the class's data (cls), like for an alternative constructor? Use a class method.
• Does it need neither? Use a static method for organizational purposes.

Properties: Accessing Methods Like Attributes

Let's revisit our Employee class. We have a problem with dependent attributes.

emp_1 = Employee('John', 'Smith', 50000)
print(emp_1.first)    # John
print(emp_1.email)    # John.Smith@company.com

# Let's change the first name
emp_1.first = 'Jim'

print(emp_1.first)    # Jim
print(emp_1.email)    # John.Smith@company.com  <- PROBLEM! The email did not update.

The email was created once in __init__ and is now out of sync. We could turn email into a method (emp_1.email()), but that would force anyone using our class to change their code from emp_1.email to emp_1.email(). This is not ideal.

The @property decorator provides a solution. It lets us "wrap" a method so that it can be accessed like an attribute. This is often called a "getter".

Let's summarize the three parts of a property:

1. Getter (@property): Makes a method accessible as an attribute. It computes and returns a value on the fly.

   @property
   def email(self):
       return f'{self.first}.{self.last}@email.com'
   
   # Now emp_1.email always returns the up-to-date email
   

2. Setter (@<property_name>.setter): Allows you to assign a value to the property, running custom code in the process.

   @fullname.setter
   def fullname(self, name):
       first, last = name.split(' ')
       self.first = first
       self.last = last
   
   # emp_1.fullname = 'Corey Schafer' now works and updates self.first and self.last
   

3. Deleter (@<property_name>.deleter): Defines custom behavior for when the attribute is deleted with del.

   @fullname.deleter
   def fullname(self):
       print('Deleting name!')
       self.first = None
       self.last = None
   

For a deeper dive and more examples of when to use each of these decorators, the following article is an excellent resource.

Conclusion

In this lesson, you've significantly upgraded your OOP toolkit. You now have fine-grained control over how methods and attributes behave in your classes.

Key Takeaways:

• Instance Methods operate on an object's state (self).
• @classmethod methods operate on the class itself (cls) and are ideal for alternative constructors or modifying class-level variables.
• @staticmethod methods are utility functions that don't depend on instance or class state but belong logically within the class.
• @property allows you to create getters, setters, and deleters, enabling computed attributes and controlled access while maintaining a clean, attribute-like interface.

Preview of the Next Lesson:
Properties are a Pythonic way to manage access to an object's internal data. This is a core part of a broader OOP principle called encapsulation. In our next lesson, "Apply encapsulation principles using private and protected attributes," we will explore how Python signals that certain attributes are for internal use and should not be modified directly from outside the class.