PCPP-32-101 1.8 Apply Subclassing of Built-In Classes PCPP-32-1 Practice Questions (Page 2)

Questions 6–10

1. 6application · medium

   A developer creates a subclass of str that overrides __add__ to return a new instance of the subclass. They write: class UpperStr(str): def __add__(self, other): return UpperStr(super().__add__(other).upper()) They test 'a' + 'b' and it works. However, when they use the .join() method on a list of UpperStr objects, the result is a plain str, not an UpperStr. Why?

   • AThe .join() method calls __add__ for each pair, but the override only works for two operands, not for multiple.
   • BThe .join() method returns a plain str because the subclass does not override __new__ to preserve the type.
   • CThe .join() method is implemented in C and returns a plain str, bypassing the subclass's __add__ override.
   • DThe .join() method works correctly, but the developer must cast the result back to UpperStr manually.
   Reveal Solution Discussion Select an answer first
2. 7application · medium

   A team maintains a custom list subclass that logs every modification. They override append(), extend(), and insert() to call a logger before delegating to super(). A colleague notices that the log is incomplete when code uses the += operator. What is the reason?

   • AThe += operator on a list subclass calls __iadd__, which by default falls back to __add__ and creates a new list, so the original object's append() is never called.
   • BThe += operator calls extend() internally, but since extend() is overridden, the log should be complete; the issue must be that the logger itself is failing silently.
   • CThe += operator mutates the list in place via __iadd__, which internally uses the C-level extend and bypasses the Python-level override; the team must also override __iadd__ to log the operation.
   • DThe += operator is not supported on list subclasses and raises TypeError, so the log is incomplete because the operation fails entirely.
   Reveal Solution Discussion Select an answer first
4. 8foundation · easy

   Which of the following is a valid reason to create a subclass of a built-in class in Python?

   • ATo add new methods or attributes to the built-in type while retaining its original behavior
   • BTo prevent any instance of the built-in type from being created elsewhere in the program
   • CTo change the fundamental memory layout of the built-in type for better performance
   • DTo make the built-in type compatible with third-party libraries that require a different base class
   Reveal Solution Discussion Select an answer first
5. 9application · medium

   A developer subclasses dict to add a timestamp attribute that records when the dictionary was created. They write: class TimedDict(dict): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.created_at = time.time() They create d = TimedDict({'a': 1}) and it works. However, when they copy the dictionary with d.copy(), the copy does not have the created_at attribute. Why?

   • AThe .copy() method raises an error because the subclass has a custom __init__ signature.
   • BThe .copy() method calls __init__ on the new object, but the created_at attribute is set after super().__init__(), so it is overwritten.
   • CThe .copy() method is implemented in C and creates a new plain dict, not a TimedDict, so the attribute is lost.
   • DThe .copy() method works correctly, but the developer must override __copy__ to preserve the attribute.
   Reveal Solution Discussion Select an answer first
6. 10foundation · easy

   What is the purpose of calling super() inside a method of a subclass of a built-in class?

   • ATo create a new instance of the parent class
   • BTo bypass all parent methods and call the built-in type's C implementation directly
   • CTo prevent the parent method from being called at all
   • DTo invoke the parent class's version of the method, preserving its original behavior
   Reveal Solution Discussion Select an answer first