Python Classes and Objects Exercises

In Object-Oriented Programming, if we consider a "Car" to be the Class, which of the following would best represent an Object?

The architectural drawing showing how to build the engine and frame.

A specific red Tesla parked in your driveway with a unique license plate.

The general idea or concept of transportation.

A list of parts required to build any vehicle.

To master classes and objects, you must first understand the relationship between a template and an instance.

The Class (The Blueprint): This is the "Car" definition. It defines that all cars have a color, a brand, and a speed, but it doesn't represent a specific car you can drive.
The Object (The Instance): This is a concrete realization of the class. Your neighbor's Red Tesla is a specific "Object" built from the "Car" class. It has its own unique data (Red color, Tesla brand).

Think of it this way:

Concept	Example
Class	Cookie Cutter
Object	An actual Cookie

Key Takeaway: You define the logic once in a Class, but you can create thousands of Objects from that single definition, each holding its own specific information.

Review the following code snippet. Which line contains a mistake that will prevent the `greet` method from accessing the `name` attribute?

class User:
    def __init__(self, username):
        self.name = username

    def greet():
        print(f"Hello, my name is {self.name}")

u1 = User("Alice")
u1.greet()

self.name = username — You cannot assign a parameter to a self-attribute.

u1 = User("Alice") — You must use the keyword new to create an object.

def greet(): — The method is missing the self parameter in its definition.

print(f"Hello...") — Python does not support f-strings inside class methods.

In Python, instance methods have a specific requirement regarding their parameters that differs from regular functions.

The Requirement: Every instance method must accept the instance itself as its first argument. By convention, we name this parameter self.
What happened here: The definition def greet(): tells Python that this method accepts zero arguments. However, when you call u1.greet(), Python automatically tries to pass the u1 object into the method.
The Error: This code would result in a TypeError, stating that greet() takes 0 positional arguments but 1 was given.

Corrected Code:

class User:
    def __init__(self, username):
        self.name = username

    def greet(self): # Added self here
        print(f"Hello, my name is {self.name}")

Key Takeaway: Even if you don't plan on using any other arguments, the self parameter is mandatory for any method intended to be called on an object instance. It is the "bridge" that connects the function to the object's data.

You are creating a `Product` class for an e-commerce site. Which of the following code snippets correctly completes the `init` method so that each product object stores its own `price` and `brand`?

class Product:
    def __init__(self, price, brand):
        # <YOUR CODE HERE>

p1 = Product(999, "Solviyo")

price = price
brand = brand

Product.price = price
Product.brand = brand

self.price = price
self.brand = brand

set.price = price
set.brand = brand

To store data within a specific object, we must use attribute assignment via the self keyword.

The Role of self: Inside the __init__ method, self represents the specific object being created. By writing self.price = price, you are telling Python: "Take the value passed into the price parameter and save it inside this specific object's memory."
Why Option 1 Fails: Simply writing price = price creates a local variable that disappears as soon as the __init__ method finishes. The object would end up "empty" with no stored data.
Why Option 2 is problematic: Using Product.price would create a Class Attribute. This would mean every single product you create would share the exact same price, and changing one would change them all!

Step-by-Step Visualization:

p1 = Product(999, "Solviyo") is called.
Python creates a new empty object and passes it to __init__ as self.
The values 999 and "Solviyo" are assigned to self.price and self.brand.
Now, p1 "owns" that data.

Key Takeaway: Always use self.variable_name to ensure that data stays attached to the object instance for later use.

What is the effect of using Dot Notation (e.g., `my_object.attribute_name`) in Python?

It is used to define a new class inheritance hierarchy.

It is used to delete an object and remove it from the computer's memory.

It is used to access the variables (attributes) and functions (methods) that belong to a specific object.

It is used to encrypt the data stored inside an object for security purposes.

Dot Notation is the standard syntax for interacting with objects in Python. It acts like a "path" that leads into the object's data.

Accessing Data: If an object car has an attribute color, you use car.color to retrieve it.
Invoking Behavior: If the object has a method drive(), you use car.drive() to run that specific behavior.
Setting Values: You can also use it to update data, such as car.color = "Blue".

Analogy:

Think of the "Dot" as the word 's. Instead of saying "the color of the car," you are saying car.color (Car's color).

Key Takeaway: Dot notation is how you bridge the gap between the variable name and the internal contents of the class instance. Without the dot, Python would look for a global variable instead of a property inside your object.

Identify why the following code will cause an error when you try to run it.

class Smartphone:
    def __init__(self, model):
        self.model = model

phone1 = Smartphone("iPhone")
print(phone1.battery_life)

The class name Smartphone must be written in all lowercase letters.

The variable phone1 must be declared as a global variable before it can be printed.

You must use phone1.__init__.battery_life to access any data inside the class.

You are trying to access an attribute (battery_life) that was never defined or assigned in the class.

One of the most common errors for beginners is the AttributeError. This happens when you try to access data that doesn't exist inside an object.

Object State: In this example, the __init__ method only creates and assigns self.model. The object phone1 knows its model is "iPhone", but it has no knowledge of battery_life.
The Error: Python will look inside phone1's memory, fail to find battery_life, and stop the program with an AttributeError.
The Solution: You must either define the attribute inside __init__ or assign it manually after creating the object.

Example Solution:

class Smartphone:
    def __init__(self, model):
        self.model = model
        self.battery_life = "100%" # Now it is defined!

phone1 = Smartphone("iPhone")
print(phone1.battery_life) # Works!

Key Takeaway: A Class is a strict blueprint. If the blueprint doesn't mention a specific piece of data, the object created from it won't have it unless you add it explicitly later.

What will be the output of the following code, and what does it reveal about how Python handles class-level variables?

class Employee:
    company_name = "Solviyo Corp"

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

emp1 = Employee("Alice")
emp2 = Employee("Bob")

Employee.company_name = "Global Tech"

print(emp1.company_name)

Solviyo Corp

Because the attribute was set when the object emp1 was created.

Global Tech
Because company_name is a class attribute shared by all instances.

None
Because company_name was not defined inside the __init__ method.

An AttributeError is raised.

This exercise highlights the difference between Instance Attributes and Class Attributes.

Class Attributes: Variables defined directly inside the class but outside any methods (like company_name) are shared by all instances of that class. They represent data that is common to every object.
Instance Attributes: Variables defined with self inside __init__ (like self.name) are unique to each individual object.
The Update Logic: When we update Employee.company_name, we are changing the value at the class level. Since emp1 and emp2 do not have their own individual company_name, they "look up" to the class to find the value.

Step-by-Step Execution:

company_name is initially "Solviyo Corp" for the whole class.
Employee.company_name is updated to "Global Tech".
When print(emp1.company_name) is called, Python checks if emp1 has a local company_name. It doesn't.
Python then checks the Employee class, finds "Global Tech", and prints it.

Key Takeaway: Use class attributes for data that should be consistent across all objects. If you change a class attribute using the Class name, that change is reflected in every instance.

You are designing a `BankAccount` class. The goal is to create a method that allows a user to add money to their balance. Which implementation correctly updates the object's state?

def deposit(self, amount):
    balance += amount

def deposit(self, amount):
    self.balance = self.balance + amount

def deposit(amount):
    self.balance += amount

def deposit(self, amount):
    new_balance = self.balance + amount
    return new_balance

To modify the internal state of an object from within a method, you must explicitly reference the instance using the self keyword.

State Persistence: In Option 2, self.balance = self.balance + amount (or self.balance += amount) takes the existing value stored in that specific object and overwrites it with the new total. This change persists after the method finishes.
The Problem with Option 1: Writing balance += amount without self tells Python to look for a local variable named balance inside the function. Since it hasn't been defined there, it will raise an UnboundLocalError.
The Problem with Option 3: This method is missing self in the parameter list. Even if the logic inside were correct, Python wouldn't know which object's balance to update.
The Problem with Option 4: While this calculates the correct total, it stores it in a temporary local variable (new_balance) and returns it, but it never updates the actual self.balance attribute. The account balance would remain unchanged.

Step-by-Step Logic:

The method is called on an instance: my_account.deposit(100).
self becomes a reference to my_account.
Python looks up self.balance (e.g., 500).
It adds the amount (100) to get 600.
It assigns 600 back into self.balance.

Key Takeaway: Methods that are meant to "change" an object must reassign the new value back to self.attribute_name. Simply calculating a value or using a local variable is not enough to update the object's permanent state.

In Python, we often use the special methods `str` and `repr`. Which of the following correctly describes the difference between these two "dunder" methods?

__str__ is intended to provide a user-friendly, readable string for end-users, while __repr__ is intended to provide an unambiguous representation of the object, primarily for developers and debugging.

__str__ is used to convert an object into an integer, whereas __repr__ is used to convert an object into a boolean value.

__repr__ is called automatically when the object is first created, while __str__ is only called when the object is deleted from memory.

__str__ is mandatory for every class, but __repr__ can only be used if the class inherits from the math library.

Python provides "dunder" (double underscore) methods to define how an object should be represented as a string. Choosing between __str__ and __repr__ depends on who the intended audience is.

__str__ (String): This is called by the print() function and the str() constructor. Its goal is to be readable. For a Book object, it might return: " 'The Great Gatsby' by F. Scott Fitzgerald".
__repr__ (Representation): This is called when you inspect an object in the console or use repr(). Its goal is to be unambiguous. Ideally, it should look like the code used to create the object, such as: "Book(title='The Great Gatsby', author='F. Scott Fitzgerald')".
Fallback Logic: If you define __repr__ but not __str__, Python will use __repr__ for both. However, if you only define __str__, inspecting the object in the console will still show the default memory address.

Code Example:

class Car:
    def __init__(self, brand, year):
        self.brand = brand
        self.year = year

    def __str__(self):
        return f"{self.brand} ({self.year})"

    def __repr__(self):
        return f"Car(brand='{self.brand}', year={self.year})"

my_car = Car("Toyota", 2022)
print(my_car)        # Calls __str__ -> Toyota (2022)
print(repr(my_car))  # Calls __repr__ -> Car(brand='Toyota', year=2022)

Key Takeaway: As a rule of thumb, always implement __repr__ first because it is invaluable for debugging. Add __str__ later if you need a "pretty" version for your application's users.

In Python, how does a developer signal that a class attribute or method is "private" and should not be accessed directly from outside the class?

By using the private keyword before the variable name, similar to Java or C++.

By wrapping the entire class in a protected decorator to lock its attributes.

By defining the attribute inside a separate file named private.py.

By prefixing the name with a single underscore (e.g., _balance) or a double underscore (e.g., __balance).

Python handles Encapsulation (hiding data) differently than many other languages. It relies more on naming conventions than strict enforced barriers.

The Single Underscore (_name): This is a "weak" internal indicator. It tells other developers: "This is meant for internal use; please don't touch it directly." However, Python will still allow you to access it if you try.
The Double Underscore (__name): This triggers Name Mangling. Python internally changes the name of the attribute (e.g., to _ClassName__name) to make it harder to access accidentally from outside the class.
Philosophy: Python follows the principle of "We are all consenting adults here." It provides tools to signal privacy, but it rarely uses hard locks to stop a programmer from accessing data if they really want to.

Code Example:

class Account:
    def __init__(self):
        self._internal_id = 123  # Protected hint
        self.__balance = 500     # Private (mangled)

a = Account()
print(a._internal_id)  # Works, but discouraged
# print(a.__balance)   # This would raise an AttributeError

Key Takeaway: Use a single underscore for internal "protected" variables. Use double underscores only when you specifically want to avoid name clashes in inheritance or make it more difficult for external code to modify sensitive data.

Identify the logical flaw in the following code. What will happen if you create two different `Team` objects and add a member to the first one?

class Team:
    members = []  # A class-level list

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

    def add_member(self, person):
        self.members.append(person)

t1 = Team("Alpha")
t2 = Team("Beta")

t1.add_member("Alice")

print(t2.members)

An AttributeError is raised because members was not initialized with self.

t2.members will be [] because t1 and t2 are independent objects.

The code will crash because you cannot append strings to a list defined outside __init__.

t2.members will contain ['Alice'] because the list is shared across all instances.

This is one of the most famous "gotchas" in Python's Object-Oriented Programming: the Shared Mutable Class Attribute trap.

The Problem: When you define a mutable object (like a list or dictionary) directly under the class line, it becomes a Class Attribute. This means only ONE list is created in memory, and every instance of the class points to that same list.
The Symptom: Adding a member to t1 actually modifies the list that t2 is also looking at. This is rarely the intended behavior for things like "team members" or "user carts."
The Solution: To ensure every object has its own unique list, you must initialize the list inside the __init__ method using self.

Step-by-Step Logic:

Python creates the Team class and initializes one empty members list in memory.
t1 and t2 are created. Neither has a local members attribute, so they both look at the Class attribute.
t1.add_member("Alice") finds the shared list and appends the string.
When you check t2.members, it looks at that same shared list, which now contains "Alice".

Corrected Implementation:

class Team:
    def __init__(self, name):
        self.name = name
        self.members = [] # Now each team gets its own private list!

Key Takeaway: Never use mutable objects (lists, dicts) as class attributes unless you explicitly want every single instance to share and modify the same data. Always move instance-specific data into the __init__ method.

Review the following inheritance structure. What will be the output when `Child().show()` is executed, and why?

class Parent:
    def __init__(self):
        self.value = 10

    def show(self):
        print(f"Value is {self.value}")

class Child(Parent):
    def __init__(self):
        self.value = 20

    def show(self):
        super().show()
        print("Child show executed")

Child().show()

Value is 10
Child show executed

Value is 10
Value is 20
Child show executed

Value is 20
Child show executed

A TypeError is raised because super() can only be used inside __init__.

This exercise tests your understanding of Method Overriding and how super() interacts with the object's current state.

Attribute Overwriting: When Child() is instantiated, its own __init__ runs, setting self.value = 20. Since the child's constructor does not call the parent's constructor, the parent's initial value (10) is never even set; it is completely replaced by 20.
Super Behavior: The super().show() call tells Python to look for the show method in the parent class. However, even though the logic of the method comes from the Parent class, the data (self) still refers to the Child instance.
The Execution Flow:
1. super().show() jumps to the Parent's show method.
2. Inside that method, it looks for self.value.
3. Because self is a Child object, self.value is 20.
4. It prints "Value is 20".
5. Control returns to the Child's method, which prints "Child show executed".

Code Analysis:

# Inside Parent
def show(self):
    print(f"Value is {self.value}") # self is the Child instance here!

Key Takeaway: super() allows you to delegate behavior to a parent class, but the state (the data stored in attributes) remains tied to the specific instance that initiated the call. If a child overrides an attribute, the parent's methods will see that new value.

You want to ensure that the `price` attribute of your `Product` class can never be set to a negative value. Which approach is the most "Pythonic" way to implement this validation while keeping the syntax `obj.price = value` for the user?

class Product:
    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("Price cannot be negative")
        self._price = value

class Product:
    def set_price(self, value):
        if value < 0:
            return "Error"
        self.price = value

class Product:
    def __init__(self, price):
        if price < 0:
            self.price = 0
        else:
            self.price = price

class Product:
    def __validate__(self, attr, value):
        if attr == "price" and value < 0:
            stop_execution()

In Python, the most professional and "Pythonic" way to handle attribute validation is by using the @property decorator.

The Getter (@property): This turns a method into a "read-only" attribute. When the user types obj.price, this method is called automatically behind the scenes.
The Setter (@price.setter): This allows you to intercept the assignment operation (obj.price = 100). It provides a perfect place to put logic, like checking if the number is negative, before actually saving the data.
Encapsulation: Notice we use self._price (with an underscore) inside the class. This stores the actual data, while price (without the underscore) acts as the public "gatekeeper" method.

Why not use Getters/Setters like Java?

While Option 2 (set_price) works, it forces the user to change how they interact with the object. Python prefers keeping the simple object.attribute syntax while using decorators to handle the complexity internally.

Key Takeaway: Use properties when you need to add logic, validation, or transformation to an attribute without breaking the way external code interacts with your object.

When designing a class, you may need to define methods that don't necessarily need to access the specific instance (`self`). Which of the following correctly describes the difference between a `@classmethod` and a `@staticmethod`?

Both are identical; the only difference is that @classmethod is a newer syntax introduced in Python 3.10.

A @staticmethod can modify the class state, whereas a @classmethod can only modify the instance state.

A @classmethod receives the class itself as the first argument (usually named cls), allowing it to access class attributes, while a @staticmethod receives no implicit first argument and behaves like a regular function defined inside the class namespace.

A @classmethod can only be called on the Class name, while a @staticmethod can only be called on an object instance.

In Python, not every method inside a class needs to interact with an individual object instance. Understanding when to use @classmethod versus @staticmethod is a hallmark of an advanced developer.

@classmethod: These methods are often used as "factory methods." Because they receive the class (cls) as an argument, they can create new instances of the class or modify class-level attributes. They are aware of the class's identity.
@staticmethod: These methods have no access to self (the instance) or cls (the class). They are essentially just utility functions that happen to live inside the class because they are conceptually related to it.

Code Comparison:

class Utility:
    version = "1.0"

    @classmethod
    def get_version(cls):
        return cls.version  # Accesses the class variable

    @staticmethod
    def add(x, y):
        return x + y  # Independent logic

Key Takeaway: Use @classmethod when you need to access or modify something about the class as a whole. Use @staticmethod when the method is purely functional and doesn't need to know anything about the object or the class it belongs to.

In a scenario where you want to track how many total objects have been created from a specific class, which of the following implementations correctly uses a class attribute to maintain an accurate count?

class Robot:
    count = 0
    def __init__(self):
        self.count += 1

class Robot:
    count = 0
    def __init__(self):
        Robot.count += 1

class Robot:
    def __init__(self, count=0):
        self.count = count + 1

class Robot:
    @staticmethod
    def increment():
        count += 1

To keep a running total across all instances of a class, you must modify the attribute at the Class level, not the Instance level.

Why Option 2 is Correct: By using Robot.count += 1, you are explicitly telling Python to find the variable attached to the Robot class definition and increment it. Every time a new robot is built, this global-to-the-class counter goes up.
Why Option 1 Fails: self.count += 1 is tricky. It first looks for an instance attribute named count. Since it doesn't find one, it looks at the class attribute (0), adds 1, and then creates a new instance attribute self.count = 1. The class attribute remains 0, and every robot will simply report its own count as 1.
Why Option 3 Fails: This just creates a local instance variable that resets or starts at 1 for every single object created. It has no memory of other objects.

Visualizing the difference:

Key Takeaway: When you want to share data or state among all instances (like a database connection pool or an object counter), always refer to the variable using the ClassName.variable_name syntax inside your methods.

Study the following code carefully. What will be the final state of the `count` values printed at the end?

class Counter:
    count = 10

    def __init__(self, val):
        self.count = val

c1 = Counter(5)
c2 = Counter(20)

# Deleting the instance attribute
del c1.count

print(c1.count)
print(c2.count)

10
20

None
20

5
20

An AttributeError is raised on the first print statement.

This exercise tests your deep understanding of the Attribute Lookup Chain. In Python, looking up an attribute isn't a single step; it's a search through different layers.

Layer 1 (Instance): When you call c1.count, Python first checks the instance's own dictionary (c1.__dict__). Initially, this contains 5.
The Deletion: The command del c1.count removes the "count" key from the instance only. It does not affect the Class definition.
Layer 2 (Class): After deletion, when print(c1.count) is called, Python fails to find "count" in the instance. Instead of crashing, it moves up the chain to the Class (Counter).
The Result: Since Counter.count still exists and equals 10, that is the value returned for c1. Meanwhile, c2 still has its own instance attribute of 20, which is found immediately.

Key Takeaway: Deleting an attribute from an instance "unmasks" the class attribute of the same name. This lookup hierarchy is what allows all objects to share default values from the class while still maintaining their own unique overrides.

In Python’s object lifecycle, what is the fundamental difference between the `new` method and the `init` method?

__new__ is used to initialize the object's attributes, while __init__ is used to define the class's memory address.

__new__ is the actual constructor that creates and returns the new instance, while __init__ is the initializer that sets up the object after it has been created.

__new__ is only called when using multiple inheritance, whereas __init__ is called only in single inheritance scenarios.

__init__ is called by the Python interpreter, but __new__ must be called manually by the developer inside the code.

Most developers think of __init__ as the "constructor," but in Python, the object creation process is actually split into two distinct steps.

__new__ (The Creator): This is a static method that is called before __init__. Its primary job is to allocate memory and return a new instance of the class. It is the method that actually "builds" the object.
__init__ (The Decorator): Once __new__ returns the instance, __init__ is called to "initialize" it (adding names, ages, balances, etc.). It doesn't return anything; it simply modifies the object that was just created.
Usage: You rarely need to override __new__ unless you are working with Immutable types (like inheriting from str or int) or implementing a Singleton pattern (where you want to ensure only one instance of a class ever exists).

The Workflow:

obj = MyClass() is executed.
Python calls MyClass.__new__(MyClass).
__new__ returns the raw instance.
Python calls instance.__init__(...) to set up the data.

Key Takeaway: If __new__ does not return an instance of the class, the __init__ method will not be called at all. This distinction is vital for advanced architectural patterns in Python.

Consider the following code where we manipulate attributes dynamically. What will be the final output when we attempt to print the object's `score`?

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

p1 = Player("Aris")

# Dynamically adding a method to a single instance
def boost_score(self):
    self.score = 100

import types
p1.boost = types.MethodType(boost_score, p1)

p1.boost()
print(p1.score)

0 Because score was not initialized in the __init__ method.

AttributeError Because you cannot add new attributes to an object after it has been instantiated.

NameError Because self inside boost_score does not recognize the Player class scope.

100 Because the function was bound to the instance as a method, allowing it to modify the object's state.

This exercise explores Monkey Patching and dynamic method binding, which demonstrates just how flexible Python objects are.

Instance Flexibility: In Python, objects are not fixed at creation. You can add new attributes or even new methods to a specific instance at runtime without affecting the original class.
The Role of types.MethodType: If you simply did p1.boost = boost_score, the function wouldn't know to pass the object as the self argument. Using types.MethodType manually "binds" the function to p1, turning it into a real instance method.
State Change: When p1.boost() is executed, the self inside the function refers to p1. The line self.score = 100 creates a new key in p1.__dict__ and assigns it the value 100.

Step-by-Step Execution:

The Player object p1 is created with only a name attribute.
A standalone function boost_score is defined.
The function is bound to p1 using MethodType.
Calling p1.boost() triggers the function, which adds the score attribute directly to p1.

Key Takeaway: Python objects are essentially "live" dictionaries. While it is rarely recommended for production code due to readability concerns, you can inject behavior and data into objects dynamically whenever needed.

What happens when you define the `del` method (the destructor) in a class that contains a circular reference (two objects pointing to each other), and how does it affect Python's memory management?

Python automatically detects the circle and calls __del__ for both objects immediately after the script finishes.

The __del__ method will be called infinitely in a loop, causing a RecursionError.

The presence of __del__ prevents the objects from ever being deleted, even if the program is closed.

In older versions of Python (pre-3.4), objects in a circular reference with a __del__ method could become "uncollectable," leading to a memory leak because the garbage collector didn't know which destructor to run first.

This exercise covers the Garbage Collection (GC) internals and the dangers of the __del__ method.

The __del__ Method: This is a destructor called when an object's reference count reaches zero. It is intended for cleanup tasks like closing file handles or network sockets.
Circular References: This occurs when Object A has a reference to Object B, and Object B has a reference back to Object A. Their reference counts will never naturally reach zero.
The Pitfall: Historically, if these objects had __del__ methods, Python's GC would place them in a special list called gc.garbage and leave them there. Why? Because if the GC deleted Object A first, Object B's __del__ might try to access Object A and crash. Python played it safe by doing nothing, resulting in a memory leak.
Modern Python: Since PEP 442 (Python 3.4+), the garbage collector is smart enough to handle this, but using __del__ is still generally discouraged in favor of "context managers" (the with statement).

Key Takeaway: Avoid using __del__ for critical logic. If you have objects that point to each other, rely on weakref or explicit cleanup methods to ensure memory is freed correctly.

In Python, what is the effect of defining `slots` in a class definition, and how does it change the way objects of that class behave?

It prevents the class from being inherited by any other class, effectively making it a "final" class.

It restricts the creation of instance attributes to only those listed in the slots, and it removes the __dict__ from each instance to save memory.

It allows the class to automatically synchronize its attributes with an external SQL database.

It forces the class to use 128-bit encryption for all data stored within its attributes.

By default, Python objects are flexible because they use a dictionary (__dict__) to store attributes. However, this flexibility comes with a high memory cost. __slots__ is the expert's tool for optimizing large-scale applications.

Memory Efficiency: When you define __slots__ = ['name', 'age'], Python allocates a fixed amount of space for exactly those two attributes. It does not create a __dict__ for the object. This can reduce memory usage by 40-50% when creating millions of instances.
Strictness: Because there is no __dict__, you cannot dynamically add new attributes to the object at runtime. If you try to run obj.new_attr = 10 and 'new_attr' isn't in __slots__, Python will raise an AttributeError.
Speed: Accessing attributes stored in __slots__ is slightly faster than looking them up in a dictionary.

Example Code:

class Point:
    __slots__ = ('x', 'y')

p = Point()
p.x = 10  # Works
# p.z = 20 # Raises AttributeError: 'Point' object has no attribute 'z'

Key Takeaway: Use __slots__ only when you are absolutely certain about the attributes an object will have and when you need to optimize memory for a massive number of instances. It is a trade-off: you gain performance but lose the "dynamic" nature of Python.

Consider a scenario where you want to implement a Singleton pattern—ensuring that a class only ever has one instance. Which of the following implementations of `new` correctly achieves this?

class Singleton:
    _instance = None
    def __init__(self):
        if not self._instance:
            self._instance = self

class Singleton:
    _instance = None
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

class Singleton:
    def __new__(cls):
        return cls()

class Singleton:
    _instance = None
    @staticmethod
    def get_instance():
        return Singleton()

This exercise tests your ability to intercept the object creation process at its earliest stage using __new__. This is the classic way to implement the Singleton Pattern in Python.

The Logic of __new__: Because __new__ is responsible for returning an instance, we can add logic to check if an instance already exists.
Step-by-Step Flow:
1. The first time Singleton() is called, cls._instance is None.
2. Python executes super().__new__(cls), which creates the object and stores it in the class variable _instance.
3. Every subsequent time Singleton() is called, the condition if cls._instance is None is false.
4. Instead of creating a new object, the method simply returns the exact same instance created the first time.
Why Option 1 Fails: __init__ is called after the object is already created. By the time you reach __init__, a new piece of memory has already been allocated, so it's too late to prevent multiple instances.
Why Option 3 Fails: This creates an infinite recursion! cls() calls __new__, which calls cls(), and so on until the program crashes.

Key Takeaway: __new__ is the only place where you can effectively control which instance is returned to the user. This is critical for managing shared resources like database connections or configuration managers.

Aspect	Class	Object
Definition	Blueprint or template	Real instance of a class
Memory	Not allocated	Allocated when object is created
Data	None (definition only)	Holds actual values
Behavior	Defined in methods	Can execute methods
Quantity	One class definition	Many objects possible

Python Classes and Objects Practice Questions

In Object-Oriented Programming, if we consider a "Car" to be the Class, which of the following would best represent an Object?

Review the following code snippet. Which line contains a mistake that will prevent the greet method from accessing the name attribute?

You are creating a Product class for an e-commerce site. Which of the following code snippets correctly completes the __init__ method so that each product object stores its own price and brand?

What is the effect of using Dot Notation (e.g., my_object.attribute_name) in Python?

Identify why the following code will cause an error when you try to run it.

What will be the output of the following code, and what does it reveal about how Python handles class-level variables?

You are designing a BankAccount class. The goal is to create a method that allows a user to add money to their balance. Which implementation correctly updates the object's state?

In Python, we often use the special methods __str__ and __repr__. Which of the following correctly describes the difference between these two "dunder" methods?

In Python, how does a developer signal that a class attribute or method is "private" and should not be accessed directly from outside the class?

Identify the logical flaw in the following code. What will happen if you create two different Team objects and add a member to the first one?

Review the following inheritance structure. What will be the output when Child().show() is executed, and why?

You want to ensure that the price attribute of your Product class can never be set to a negative value. Which approach is the most "Pythonic" way to implement this validation while keeping the syntax obj.price = value for the user?

When designing a class, you may need to define methods that don't necessarily need to access the specific instance (self). Which of the following correctly describes the difference between a @classmethod and a @staticmethod?

In a scenario where you want to track how many total objects have been created from a specific class, which of the following implementations correctly uses a class attribute to maintain an accurate count?

Study the following code carefully. What will be the final state of the count values printed at the end?

In Python’s object lifecycle, what is the fundamental difference between the __new__ method and the __init__ method?

Consider the following code where we manipulate attributes dynamically. What will be the final output when we attempt to print the object's score?

What happens when you define the __del__ method (the destructor) in a class that contains a circular reference (two objects pointing to each other), and how does it affect Python's memory management?

In Python, what is the effect of defining __slots__ in a class definition, and how does it change the way objects of that class behave?

Consider a scenario where you want to implement a Singleton pattern—ensuring that a class only ever has one instance. Which of the following implementations of __new__ correctly achieves this?

Quick Recap of Python Classes and Objects Concepts