Python Class Members: Mastering Attributes and Methods

Introduction to Class Members

In our previous tutorial, we covered the basics of Python OOP. Now, let's explore the "members" of a class—the variables and methods that give your objects data and functionality.

Typically, a Python class consists of:

Docstrings: For documentation.
Built-in Attributes: Predefined metadata.
Variables: To store state (Instance, Class, Private).
Methods: To define behavior (Instance, Class, Static, Magic).

1. Docstrings & Built-in Attributes

Docstrings

A docstring is a string literal used to describe the purpose of your class or method. It’s accessed via the __doc__ attribute.

python

class Student:
    """This class represents a Student template for academic records."""
    pass

print(Student.__doc__)

Essential Built-in Attributes

Every Python class comes with several built-in attributes that provide metadata:

Attribute	Description
`__name__`	Returns the name of the class.
`__module__`	Returns the name of the module where the class is defined.
`__bases__`	Returns a tuple of base classes (parent classes).
`__dict__`	Returns a dictionary containing the class's namespace.

2. Types of Variables

Instance Variables

These are unique to each object. Every instance has its own copy, and changing one doesn't affect the others. They are usually defined inside the __init__ constructor.

python

class Student:
    def __init__(self, name, student_id):
        self.name = name  # Instance Variable
        self.id = student_id  # Instance Variable

s1 = Student("David", "001")
s2 = Student("Harry", "002")

Class Variables

These are shared by ALL instances of a class. They are defined outside the constructor.

python

class Student:
    school_name = "TopicTrick Academy" # Class Variable

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

print(Student.school_name) # Shared by all students

Avoid Altering Class Variables via Instances

If you do `instance.classvariable = newvalue`, Python creates a NEW instance variable for that specific object instead of changing the class-wide value. Always use `ClassName.variablename` to update class variables.

Private Variables (Name Mangling)

Python doesn't have true "private" variables, but it uses a convention called Name Mangling. Any attribute starting with __ (double underscore) is "hidden."

python

class Student:
    def __init__(self, grade):
        self.__grade = grade # Private-ish variable

s = Student("A+")
# print(s.__grade) -> Throws AttributeError
print(s._Student__grade) # Accessed via mangled name

3. Types of Methods

Instance Methods

The most common type. They take self as the first argument and can access/modify instance-specific data.

python

class Student:
    def introduce(self):
        print(f"Hi, I'm {self.name}")

Class Methods

Bound to the class itself, not the instance. They take cls as the first argument and are marked with the @classmethod decorator. Use them for factory methods or modifying class state.

python

class Student:
    count = 0
    @classmethod
    def increment_count(cls):
        cls.count += 1

Static Methods

These don't take self or cls. They act like regular functions but are grouped within the class for organization (Utility functions).

python

class Student:
    @staticmethod
    def validate_id(id_str):
        return len(id_str) == 5

Magic (Dunder) Methods

These have double underscores (e.g., __init__, __str__). They allow you to perform special operations like operator overloading.

Conclusion

Understanding the difference between these members is key to writing clean, efficient OOP code. You now know how to manage shared data with Class Variables, protect data with Private Variables, and organize logic with Static Methods.

What's Next?

Up next, we'll explore Inheritance and how to reuse code across multiple classes!