Python - Objects

In Python, the __doc__ attribute is a special attribute that stores the documentation string (docstring) of a class, module, function, or method. The docstring is a string literal that provides information about the purpose and usage of the code, serving as documentation for developers.

Purpose of __doc__ Attribute:

• Stores the docstring associated with an object.
• Allows access to documentation at runtime.
• Facilitates code introspection and improves code readability.

Let's illustrate the purpose of __doc__ with a simple Python program:

# Define a class named 'Car' with a docstring
class Car:
    """
    This class represents a simple car with basic attributes.

    Attributes:
      - make (str): The make or manufacturer of the car.
      - model (str): The model name of the car.
      - year (int): The manufacturing year of the car.
    """

    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

# Access the docstring using the __doc__ attribute
car_class_docstring = Car.__doc__

In this example, we define a class 'Car' with a docstring that provides information about the class and its attributes. We then use the __doc__ attribute to access the docstring associated with the class.

Output:

Class docstring:
This class represents a simple car with basic attributes.

Attributes:
  - make (str): The make or manufacturer of the car.
  - model (str): The model name of the car.
  - year (int): The manufacturing year of the car.

The __doc__ attribute allows developers to access documentation at runtime, promoting good coding practices and making code more maintainable. Docstrings are an integral part of Python's documentation culture, providing essential information for understanding and using code effectively.

In Python, every object has a unique identity, which is determined by the memory address where the object is stored. The identity of an object can be obtained using the id() function. The identity is distinct from the object's value and type. Two objects with the same value may have different identities, and two objects with the same identity are the same object.

Concept of Object Identity:

• The identity of an object is its unique identifier, determined by the memory address.
• Object identity can be checked using the id() function.
• Identity is different from value and type.

Let's illustrate the concept of object identity with a simple Python program:

# Create two objects with the same value
object1 = "Hello"
object2 = "Hello"

# Check the identity of the objects using the 'id()' function
identity1 = id(object1)
identity2 = id(object2)

# Compare the identities to determine object identity
are_objects_identical = identity1 == identity2

In this example, we create two string objects ('object1' and 'object2') with the same value ("Hello"). We then use the id() function to obtain the identity of each object. Finally, we compare the identities to determine whether the two objects have the same identity.

Output:

Are objects identical: True

The key takeaway is that object identity is a fundamental concept in Python, allowing developers to distinguish between different instances of objects. It is crucial to understand that identity is not based on the object's value or type, and two objects with the same value may or may not have the same identity.

In Python, you can delete an attribute from an object using the del statement. The del statement removes the specified attribute, and attempting to access that attribute after deletion will result in an AttributeError.

Deleting an Attribute from an Object:

• Use the del statement followed by the object and attribute name to delete the attribute.
• After deletion, attempting to access the deleted attribute will raise an AttributeError.

Let's illustrate how to delete an attribute from an object with a simple Python program:

# Define a class named 'Person' with attributes
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Create an instance (object) of the 'Person' class
person_instance = Person(name="Alice", age=25)

# Print the attributes before deletion
attributes_before_deletion = f"Attributes before deletion: {person_instance.__dict__}"

# Delete the 'age' attribute using the 'del' statement
del person_instance.age

# Print the attributes after deletion
attributes_after_deletion = f"Attributes after deletion: {person_instance.__dict__}"

# Attempt to access the deleted attribute (will raise AttributeError)
try:
    access_deleted_attribute = person_instance.age
except AttributeError as e:
    access_deleted_attribute_error = str(e)

In this example, we define a class 'Person' with attributes 'name' and 'age'. We create an instance ('person_instance') of the 'Person' class, print the attributes before and after deleting the 'age' attribute, and attempt to access the deleted attribute.

Output:

Attributes before deletion: {'name': 'Alice', 'age': 25}
Attributes after deletion: {'name': 'Alice'}
AttributeError: 'Person' object has no attribute 'age'

The key takeaway is that the del statement allows developers to remove attributes from objects dynamically. It's important to handle potential AttributeError exceptions when attempting to access deleted attributes.

In Python, the __slots__ attribute is used to explicitly declare the attributes (instance variables) that an object can have. It provides a way to optimize memory usage and restrict the addition of new attributes dynamically. Objects with __slots__ consume less memory compared to objects without it.

Use of __slots__ Attribute:

• Optimizes memory usage by preallocating space for a fixed set of attributes.
• Restricts the addition of new attributes dynamically, improving performance.
• Defined as a tuple of attribute names within the class.

Let's illustrate the use of __slots__ with a simple Python program:

# Define a class named 'Person' with __slots__
class Person:
    __slots__ = ('name', 'age')

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

# Create an instance (object) of the 'Person' class
person_instance = Person(name="Alice", age=25)

# Attempt to add a new attribute (will raise AttributeError)
try:
    person_instance.address = "123 Main St"
except AttributeError as e:
    add_new_attribute_error = str(e)

In this example, we define a class 'Person' with __slots__ containing the attribute names 'name' and 'age'. We create an instance ('person_instance') of the 'Person' class and attempt to add a new attribute ('address') dynamically.

Output:

AttributeError: 'Person' object has no attribute 'address'

The key takeaway is that the __slots__ attribute allows developers to explicitly define the attributes of an object, reducing memory overhead and improving performance. However, it also restricts the dynamic addition of new attributes. It is suitable for situations where a fixed set of attributes is known in advance.