Attributes & Methods in Python

Attributes are variables associated with a class or an instance of a class. They store data or properties of the object.

Methods are functions defined inside a class and are used to perform operations related to the class's objects.

• Instance attributes: Defined within the __init__ method and are specific to an object.
• Class attributes: Shared across all instances of the class, defined directly within the class.

class Example:
    def __init__(self, value):
        self.value = value  # Instance attribute

class Example:
    shared_value = 10  # Class attribute

Using the dot . operator with the object:

obj = Example(5)
print(obj.value)  # Access attribute
obj.method()      # Call method

Through the class name or an instance:

print(Example.shared_value)
print(obj.shared_value)

self refers to the instance of the class and is used to access instance attributes and methods.

Class attributes can be accessed by instances, but modifications create an instance-specific attribute instead of changing the class attribute.

Special methods start and end with double underscores, e.g., __init__, __str__, and __len__, and provide functionality like object initialization, string representation, etc.

• @staticmethod: A method that does not access or modify instance or class-level data.
• @classmethod: A method that receives the class (cls) as its first parameter and can modify class attributes.

It initializes a new object by setting up instance attributes.

Provides a human-readable string representation of an object:

def __str__(self):
    return f"Object value: {self.value}"

Returns an official string representation, typically for debugging:

def __repr__(self):
    return f"Example(value={self.value})"

• __str__: For end-users, human-readable.
• __repr__: For developers, unambiguous and debugging-friendly.

obj.new_attr = "Dynamic Attribute"

hasattr(obj, 'value')

Using getattr:

getattr(obj, 'value', default_value)

Using setattr:

setattr(obj, 'new_value', 42)

Using delattr:

delattr(obj, 'value')

By using private attributes with a single or double underscore prefix:

class Example:
    def __init__(self):
        self._protected = 10
        self.__private = 20

A property is used to manage access to instance attributes using getter, setter, and deleter methods.

class Example:
    def __init__(self, value):
        self._value = value
    
    @property
    def value(self):
        return self._value
    
    @value.setter
    def value(self, new_value):
        self._value = new_value

• Bound methods: Called on an object and have access to its attributes.
• Unbound methods: Defined in the class and accessed without an object.

Yes, by redefining it in the subclass.

Use private attributes and provide controlled access via methods.

It lists all attributes and methods of an object.

It overrides the parent class method.

• Object methods operate on an instance (self).
• Class methods operate on the class (cls).

It restricts the attributes an object can have, saving memory:

class Example:
    __slots__ = ['name', 'age']

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
    
    def area(self):
        return self.length * self.width

class Counter:
    instance_count = 0
    
    def __init__(self):
        Counter.instance_count += 1

By defining the __call__ method:

class CallableExample:
    def __call__(self):
        print("Object called!")

Python does not support method overloading, but default parameters can achieve similar behavior.

Defining a method in a subclass with the same name as in the parent class.

It is called when an attribute that doesn?t exist in an object is accessed.

It is used to intercept and customize how attributes are set in an object.

It allows you to define custom behavior when deleting an attribute.

By defining only the getter method in a property and not a setter.

Special methods like __get__, __set__, and __delete__ that manage attributes at a low level.

To create managed attributes with getter, setter, and deleter methods.

By defining a __dir__ method in the class.

• hasattr: Checks if an attribute exists.
• getattr: Retrieves the value of an attribute or returns a default value.

It is a dictionary that stores all the writable attributes of an object.

• Instance attributes: Defined in the class or __init__ method.
• Dynamic attributes: Added to an object at runtime.

It allows a subclass to call a method from its parent class.

To check whether an object is an instance of a specific class or a subclass.

By using the __slots__ attribute.

It uses the Method Resolution Order (MRO), which is determined by the C3 linearization algorithm.

By using the ABC module and decorating the method with @abstractmethod.