Object-Oriented Programming Part - 1 | 9/100 Days of Python Algo trading

Congratulations on reaching this stage!

If you’re here, it means you’re truly dedicated to mastering Python. Directly below, you’ll find a quiz designed to help you reinforce what you’ve just learned. This isn’t just about recalling facts; it’s about deeply understanding the concepts. Take a moment to answer the questions and see how well you can apply the knowledge from the video. You’re doing great—every question you tackle brings you one step closer to becoming a Python expert!

Day 9: OOP Part1

1. Consider these code snippets: Snippet A: class A: ..., Snippet B: def func_a(): .... Which statement is true in Python, and why?

Snippet A defines a type 'A', while Snippet B defines a function that returns type 'A'.

Both snippets are invalid, as Python is not a strongly-typed language.

Snippet A defines a class, a blueprint for objects, while Snippet B defines a function, a block of reusable code.

Both snippets are equivalent, as classes are essentially functions in Python.

2. Which OOP feature enables code like this: class Shape: ... , class Square(Shape): ..., class Circle(Shape): ... , my_shape = Square(). Explain the mechanism involved.

Polymorphism

Encapsulation

Inheritance

Abstract classes

3. Suppose you have a Person class. Instead of storing 'age' as a regular attribute, you decide to calculate it on the fly based on the current date and birthdate. Discuss how this embodies OOP principles.

Demonstrates the limitations of encapsulation, as it prevents direct access to 'age'.

Leverages encapsulation and abstraction, hiding calculation details and presenting 'age' as a concept.

Violates polymorphism principles, as the age calculation would need to change for subclasses of Person.

Implements inheritance, as age calculation would need to be overridden in any future subclasses.

4. You have a function calculate_area(shape), and you want to include this behavior within your various shape classes (e.g. Square, Circle). What's the most OOP-centric way to do this, and why?

Keep the function as-is for flexibility, but have class methods call it.

Convert calculate_area into a method in an abstract base class Shape.

Copy and paste the code into each shape class to optimize for performance.

There's no real difference between a method inside a class and a standalone function.

5. You're designing a system where you have a Vehicle class, Car and Truck inheriting from it, and a Manufacturer class. An association needs to exist between Manufacturer and Vehicle. Which is most accurate and why?

One-to-one: A manufacturer makes only one type of vehicle.

One-to-many: A manufacturer makes many vehicles, but a vehicle belongs to one manufacturer.

Many-to-many: A manufacturer can make multiple vehicle types, and vehicles can be from multiple manufacturers.

Class diagrams cannot represent the 'makes' relationship.

6. What's the potential pitfall of only defining __eq__ for a custom class without also considering __hash__?

You cannot compare objects for inequality.

Objects of your class cannot be used as keys in dictionaries.

The __str__ method may not output the expected representation.

There's no real disadvantage, defining just __eq__ is often sufficient.

7. Could you explain a scenario where defining __setattr__ could be useful over manipulating object attributes directly?

To convert all attribute values into uppercase automatically.

To implement validation logic before allowing a value to be assigned.

To log changes made to an object's attributes over time.

All of the above

8. Describe a situation where using @classmethod would be more appropriate than @staticmethod within a class.

When you need to access or modify class-level state.

For utility functions that conceptually relate to the class but don't require class or object state.

To provide alternative constructors for a class.

Both @classmethod and @staticmethod can be used interchangeably.

9. Why does Python need the explicit self reference within object methods, compared to implicit 'this' in languages like Java or C++?

Because Python's concept of 'self' is dynamically bound, requiring explicitness.

To prevent accidental namespace collisions with local variables.

To improve code readability and avoid potential ambiguity.

All of the above.

10. Your custom Number class needs to support the unary minus operator (e.g., -my_number). Which magic method is responsible for this?

__minus__

__neg__

__invert__

__opposite__ pen_spark

11. What's the difference between implementing __add__ vs. implementing __radd__ for your custom Number class?

__add__ is for when your object is on the left of the + operator, __radd__ is for when it's on the right (e.g., 1 + my_number).

__add__ handles in-place addition, __radd__ is for creating a new object.

They are equivalent; you only need to implement one.

__add__ handles numbers, __radd__ is for adding strings.

12. You want your Number class to support += augmented assignment. Do you need to implement a special method for this, and if so, which one?

No, Python handles this automatically.

Yes, you need to implement __iadd__.

Yes, you need to implement __augadd__.

Yes, you need to implement __plus_equals__.

13. To make your Number class participate in mixed-type arithmetic (e.g., my_number * 2.5), what's a key strategy?

Implement magic methods with numeric types in mind for both left-hand and right-hand operations.

Convert all other types into Number objects before performing operations.

Implement a custom __coerce__ method to handle type negotiation.

This functionality is not directly supported in Python.

14. Metaclasses can be used for which advanced technique?

Controlling how classes themselves are created.

Automating the creation of class diagrams during development.

Enforcing strict typing within classes at runtime.

Implementing the Singleton pattern to restrict class instantiation.

15. Which of the following is NOT a common downside of using inheritance heavily in practice?

Increased code complexity and potential for tight coupling.

Difficulty in testing or modifying classes within a deep hierarchy.

Performance overhead compared to purely functional approaches.

Inability to model real-world scenarios effectively.

16. Consider the task of modeling 'shapes'. Which scenario might make you hesitate in favor of an OOP approach using inheritance, and why?

If your primary goal is efficient geometric calculations.

If the shape taxonomy is well-defined and unlikely to change in the future.

If you need to represent a very large number of individual shapes.

If you want maximum flexibility in how shapes can be displayed.

17. What might be an OOP alternative to deep inheritance hierarchies?

Using @classmethod extensively for polymorphism

Relying solely on magic methods without traditional inheritance

Composition - building complex objects from combinations of smaller classes.

Using the Visitor pattern to externalize operations on objects.

18. What's a key use case for abstract classes in Python using the abc module?

To define a blueprint that concrete classes must implement, enforcing structure.

To prevent instantiation of specific classes, allowing use only through subclassing.

To provide default implementations for common methods.

To mimic interface-like behavior in Python.

19. When modeling something like file I/O, where there are common operations (open, close, read, write) but the underlying implementation varies significantly, how could OOP help?

Abstract classes to define the interface, with concrete subclasses for file types (text, CSV, etc.).

A single flexible class using conditional logic based on the file type.

Using multiple inheritance for maximum code reuse.

OOP is not the ideal approach modeling file I/O.

20. Which design pattern is commonly seen in Python's standard library and makes heavy use of the __iter__ and __next__ magic methods?

Iterator pattern

Observer pattern

Decorator pattern

Singleton pattern