PCAP Object-Oriented Programming Practice Test 3 — 15 Questions

Question 1

Refer to the exhibit. What is the output?

Accepted Answer

10. The code defines a `__str__` method in `MyClass` that returns the string representation of `self.value`. When `print(obj)` is called, Python automatically invokes `__str__`, which returns `'10'` (the integer `10` converted to a string). The output is therefore `10`.

Answer

Error: 'MyClass' object has no attribute 'value'

Answer

<__main__.MyClass object at 0x...>

Answer

None

Question 2

Refer to the exhibit. Which of the following correctly shows the MRO of class D?

Accepted Answer

[D, B, C, A, object]. Python's Method Resolution Order (MRO) for class D, which inherits from B and C (where B inherits from A and C inherits from A), follows the C3 linearization algorithm. The MRO is computed as D -> B -> C -> A -> object, ensuring that each class appears before its parents and that the order respects the local precedence order of D's bases (B before C).

Answer

[D, A, B, C, object]

Answer

[D, B, A, C, object]

Answer

[D, C, B, A, object]

Question 3

A developer defines a class with a private attribute `_value` and wants to provide controlled access. Which approach is the most Pythonic?

Accepted Answer

Use @property to define getter and setter methods.. Using the `@property` decorator is the most Pythonic way to implement controlled access to a private attribute. It allows you to define getter and setter methods that can be called like regular attribute access (e.g., `obj.value`), preserving encapsulation while maintaining a clean, non-method-call interface. This approach aligns with Python's philosophy of 'we are all consenting adults' and avoids the verbosity of explicit getter/setter methods.

Answer

Use `__slots__` to restrict attribute creation.

Answer

Make `_value` public and rely on documentation.

Answer

Define `get_value()` and `set_value()` methods.

Question 4

A parent class defines a method `move()`. A child class overrides `move()` but also needs to call the parent's version inside it. Which syntax allows that?

Accepted Answer

`super().move()`. `super().move()` is the Python syntax for calling the parent class's `move()` method from within the child class's overridden version. The `super()` function returns a proxy object that delegates method calls to the parent class, following the MRO (Method Resolution Order). This allows the child to extend the parent's behavior without hardcoding the parent class name.

Answer

`self.move()`

Answer

`Parent.move()`

Answer

`ParentClass.move(self)`

Question 5

A programmer wants to restrict a class to only allow specific attribute names and reduce memory usage. Which feature should they use?

Accepted Answer

Define `__slots__` as a tuple of allowed attribute names.. Defining `__slots__` as a tuple of allowed attribute names restricts the class to only those attributes, preventing the creation of a per-instance `__dict__` and thereby reducing memory usage. This is a built-in Python mechanism that overrides the default dynamic attribute storage, making it ideal for memory-constrained applications.

Answer

Override `__init_subclass__` to enforce restrictions.

Answer

Use @property for every attribute.

Answer

Define `__dict__` as a class variable.

Question 6

A developer implements a descriptor class with `__get__` and `__set__` methods. When an instance attribute is accessed, what determines whether the descriptor is used?

Accepted Answer

The descriptor is used only if the attribute is a class variable and the descriptor protocol is implemented.. The descriptor protocol is only invoked for attributes that are class variables (i.e., stored in the class dictionary) and implement at least one of __get__, __set__, or __delete__. When accessing an attribute, Python first checks the instance __dict__. If the attribute is found there, the behavior depends on the descriptor type: data descriptors (those with __set__ or __delete__) take precedence over instance __dict__ and are always invoked, while non-data descriptors (only __get__) are shadowed by instance attributes. Therefore, the descriptor is used only if the attribute is a class variable and the descriptor protocol is implemented, but note that instance attributes can override non-data descriptors.

Answer

The descriptor's `__get__` is called only if `__getattr__` is not defined.

Answer

If the attribute exists in the instance's __dict__, the descriptor is ignored.

Answer

The descriptor must be defined in the class's metaclass.

Question 7

A class defines a variable `count = 0`. An instance modifies `self.count = 5`. What is the value of `count` in the class namespace?

Accepted Answer

0, because the class variable remains unchanged.. When an instance assigns `self.count = 5`, Python creates an instance attribute that shadows the class variable `count` in the instance's namespace. The class variable `count` remains unchanged at 0 in the class namespace, as instance attribute assignment does not modify class attributes.

Answer

5, because the instance modified the class variable.

Answer

0, but the assignment raises an AttributeError.

Answer

The class variable is deleted and the instance has 5.

Question 8

A developer is designing a system where a `Car` class needs to reuse functionality from `Engine` and `Transmission` without creating a deep hierarchy. Which OOP principle should be applied?

Accepted Answer

Composition over inheritance.. 'Composition over inheritance,' is correct because it advocates building the Car class by composing it with Engine and Transmission objects (has-a relationships) rather than inheriting from them. This avoids a deep class hierarchy and provides flexibility to change or swap components at runtime, which is a key design principle in Python and OOP.

Answer

Aggregation, where Car is part of Engine.

Answer

Singleton pattern for Engine.

Answer

Multiple inheritance to inherit from both.

Question 9

An abstract base class (ABC) defines an abstract method `process()`. Several subclasses implement it. A function accepts any subclass and calls `process()`. This demonstrates which OOP concept?

Accepted Answer

Polymorphism.. Polymorphism allows objects of different subclasses to be treated uniformly through their common interface. When a function accepts any subclass of the ABC and calls `process()`, the correct implementation is resolved at runtime via dynamic dispatch, which is the essence of polymorphism in Python.

Answer

Inheritance.

Answer

Encapsulation.

Answer

Method overloading.

Question 10

Which TWO of the following statements about Python classes are true? (Select exactly 2.)

Accepted Answer

Class variables are shared among all instances.. Class variables are defined directly in the class body and are shared across all instances of that class. When you modify a class variable through the class itself, the change is reflected in every instance, as the variable is stored in the class's __dict__ rather than in each instance's __dict__.

Answer

Class names should be written in snake_case per PEP 8.

Answer

Private attributes (starting with __) cannot be accessed outside the class.

Answer

__init__ is the constructor of a class.

Question 11

Which THREE statements about the Python method resolution order (MRO) are true? (Select exactly 3.)

Accepted Answer

The MRO of a class can be viewed using the __mro__ attribute.. The `__mro__` attribute on a class returns a tuple of classes in the exact order that Python uses to resolve methods and attributes. This attribute is computed at class definition time using the C3 linearization algorithm, and it provides a direct, read-only view of the resolution order for that class.

Answer

The MRO is determined at runtime when a method is called.

Answer

Python uses a depth-first left-to-right algorithm for MRO.

Question 12

Which TWO of the following are valid ways to define a property in a Python class? (Select exactly 2.)

Accepted Answer

Use `property(getter, setter)` as a class variable.. `property(getter, setter)` is a built-in function that returns a property object, which can be assigned as a class variable to define a managed attribute. Option E is correct because the `@property` decorator is the standard, concise way to define a read-only property by decorating a method that acts as the getter.

Answer

Define a method named `property` inside the class.

Answer

Override `__getattribute__` and check the attribute name.

Answer

Override `__getattr__` to simulate a property.

Question 13

Refer to the exhibit. What is the output when the code is executed?

Accepted Answer

HELLO. The code defines a class with a custom `__setattr__` method that converts any assigned value of attribute `x` to uppercase. When the object is created with `x = 'hello'`, the `__setattr__` method converts it to `'HELLO'`. Therefore, accessing or printing the object (which likely prints attribute `x`) yields `'HELLO'`. The class attribute (if any) is irrelevant because the instance attribute overrides it.

Answer

Default x

Answer

hello

Answer

AttributeError

Question 14

Refer to the exhibit. What is the output?

Accepted Answer

5. The code defines a class `A` with a class attribute `x = 5`. The `__init__` method sets an instance attribute `self.x = 0`, but the `print` statement accesses `A.x`, which refers to the class attribute, not the instance attribute. Therefore, the output is `5`.

Answer

0

Answer

-3

Answer

AttributeError

Question 15

A developer wants to ensure that a class attribute is shared across all instances. Which approach should be used?

Accepted Answer

Define the attribute in the class body, outside any methods.. Defining an attribute in the class body, outside any methods, creates a class attribute that is shared across all instances. Class attributes are stored in the class's __dict__ and are accessible via the class or any instance, unless shadowed by an instance attribute.

Answer

Use the @property decorator.

Answer

Define the attribute inside a method without using self.

Answer

Define the attribute inside __init__ using self.