PCAP Object-Oriented Programming Practice Test 6 — 15 Questions

Question 1

Refer to the exhibit. Which of the following is true about MyClass?

Accepted Answer

MyClass inherits from builtins.object.. In Python, every class implicitly inherits from `builtins.object` unless another base class is specified. Since the exhibit shows `class MyClass:` with no explicit parent, `MyClass` automatically inherits from `object`. This makes option D correct.

Answer

MyClass has an instance method called display.

Answer

MyClass has a class attribute called display.

Answer

MyClass has both __init__ and display as class methods.

Question 2

A company needs to model different types of employees. They have a base class `Employee` with a method `calculate_pay()`. For hourly employees, pay = hours * rate; for salaried employees, pay = salary. Which design approach is most appropriate?

Accepted Answer

Create subclasses `HourlyEmployee` and `SalariedEmployee` that override `calculate_pay()`.. Option C is correct because it applies polymorphism through method overriding: each subclass (`HourlyEmployee`, `SalariedEmployee`) provides its own implementation of `calculate_pay()`, allowing the calling code to treat all employees uniformly via the base class interface. This adheres to the Open/Closed Principle and keeps the design extensible without modifying existing code when new employee types are added.

Answer

Use a `@staticmethod` inside `Employee` to compute pay based on a type parameter.

Answer

Define a module-level function that takes an employee object and computes pay.

Answer

Use a single `Employee` class with conditional statements to differentiate pay types.

Question 3

A team is implementing a shape hierarchy with a base class `Shape` that should have an `area()` method. They want to ensure that every subclass must provide its own implementation of `area()`. Which approach should they use?

Accepted Answer

Use `@abstractmethod` from the `abc` module to declare `area()` as abstract.. Option D is correct because the `abc` module provides the `ABCMeta` metaclass and the `@abstractmethod` decorator, which together enforce that any concrete subclass must override the abstract method. If a subclass fails to implement `area()`, Python raises a `TypeError` at instantiation time, ensuring the design contract is upheld. This is the standard Pythonic way to define abstract base classes and enforce method implementation in subclasses.

Answer

Define `area()` in `Shape` and have it raise `NotImplementedError`.

Answer

Use a class method that must be overridden.

Answer

Define `area()` as a property that raises an error.

Question 4

A class `ServerConfig` has a class attribute `port = 8080`. After deployment, a developer runs `ServerConfig.port = 9090` in one module, and unexpectedly all existing instances now use port 9090. What concept explains this behavior?

Accepted Answer

Class attributes are shared among all instances of a class.. Option C is correct because class attributes in Python are shared across all instances of a class. When you modify `ServerConfig.port` on the class itself, every instance that accesses `port` via the class (or via an instance that hasn't overridden it) sees the new value. This is fundamental to Python's attribute lookup mechanism: instance attributes shadow class attributes, but if no instance attribute exists, the class attribute is used.

Answer

Instance attributes always override class attributes.

Answer

The attribute is immutable.

Answer

Python uses copy-on-write for attribute access.

Question 5

A developer wants to create a class that logs every attribute access on an instance. Which special method should they override?

Accepted Answer

`__getattribute__`. Option B is correct because `__getattribute__` is the special method that is called unconditionally for every attribute access on an instance, making it the appropriate choice for logging all attribute accesses. Overriding this method allows the developer to intercept and log each access before the attribute is retrieved, whereas `__getattr__` is only invoked when the attribute is not found via normal lookup.

Answer

`__getattr__`

Answer

`__setattr__`

Answer

`__delattr__`

Question 6

A class `Point` has an `__init__` that sets `self.x` and `self.y`. They want to compare points by equality (i.e., `p1 == p2` should work correctly). Which method should they implement?

Accepted Answer

`__eq__`. In Python, the `__eq__` method is the correct way to define equality comparison for objects. When you implement `__eq__(self, other)`, it is automatically called by the `==` operator, allowing `p1 == p2` to return a Boolean based on custom logic (e.g., comparing `self.x` and `self.y`). This is the standard Python protocol for equality testing.

Answer

`__same__`

Answer

`__compare__`

Answer

`__cmp__`

Question 7

A programmer uses a class method to create an alternative constructor for a `Point` class. The method should parse a string like "10,20" and return a `Point` instance with x=10, y=20. Which code snippet correctly implements this?

Accepted Answer

`@classmethod
def from_string(cls, s):
    parts = s.split(',')
    return cls(int(parts[0]), int(parts[1]))`. A class method receives the class as the first argument (`cls`) and can be used to create instances via `cls(...)`. The `@classmethod` decorator is required.

Answer

`def from_string(self, s):
    parts = s.split(',')
    return Point(int(parts[0]), int(parts[1]))`

Answer

`@staticmethod
def from_string(s):
    parts = s.split(',')
    return Point(int(parts[0]), int(parts[1]))`

Answer

`def from_string(cls, s):
    parts = s.split(',')
    return cls(int(parts[0]), int(parts[1]))`

Question 8

Consider a class `D` that inherits from multiple base classes `B` and `C`. The developer wants to call a method from a specific parent class while ensuring correct method resolution order (MRO). Which is the safest way?

Accepted Answer

`super().method()`. In Python, `super().method()` is the safest way to call a method from a parent class in a multiple inheritance scenario because it respects the Method Resolution Order (MRO) defined by the C3 linearization algorithm. This ensures that the method is resolved from the next class in the MRO, avoiding hard-coded references that could break if the inheritance hierarchy changes. It also correctly handles cooperative multiple inheritance, where each class in the MRO can collaborate via `super()` calls.

Answer

`self.method()`

Answer

`ParentClass.method(self)`

Answer

`BaseClass.method(self)`

Question 9

A class has a class attribute that is a list. A developer modifies this list via one instance, and the change is reflected in all other instances. What is the best practice to avoid this unintended sharing?

Accepted Answer

Initialize the list in `__init__` rather than as a class attribute.. Option B is correct because class attributes are shared across all instances. By initializing the list inside `__init__`, each instance gets its own independent list object, preventing unintended mutation from affecting other instances. This is the standard Python pattern for instance-specific mutable data.

Answer

Use a tuple instead of a list.

Answer

Use a class method to modify the list.

Answer

Use `deepcopy` when accessing the list.

Question 10

Which of the following correctly uses `__slots__` to restrict attribute creation to only `x` and `y`?

Accepted Answer

`class Foo: __slots__ = ('x', 'y')`. Option D is correct because `__slots__` must be assigned an iterable of strings, and a tuple of strings like `('x', 'y')` is a valid iterable that restricts attribute creation to exactly `x` and `y`. Any attempt to assign an attribute not in this tuple will raise an `AttributeError`.

Answer

`class Foo: __slots__ = 'x'`

Answer

`class Foo: __slots__ = ('x')`

Answer

`class Foo: __slots__ = ['x', 'y']`

Question 11

Which TWO of the following are special methods in Python?

Accepted Answer

`__init__`. Option C is correct because `__init__` is a predefined special method in Python used as a constructor to initialize an object's state when an instance of a class is created. It is automatically invoked by the Python runtime upon object instantiation, making it a core part of the object-oriented programming model in Python.

Answer

`__bar__`

Answer

`__main__`

Answer

`__foo__`

Question 12

Which TWO of the following are true about the `__init__` method in Python?

Accepted Answer

It can accept arguments.. Option C is correct because the `__init__` method can accept arguments, which are passed when creating an instance (e.g., `obj = MyClass(arg1, arg2)`). These arguments are forwarded to `__init__` by Python's instance creation machinery, allowing the method to initialize instance attributes with user-supplied values. This is a fundamental feature for parameterized object construction.

Answer

It can be called manually.

Answer

It must return a value.

Answer

It is not inherited.

Question 13

Which THREE of the following are true about method overriding in Python?

Accepted Answer

The subclass method must have the same name.. Option A is correct because method overriding in Python requires the subclass method to have the same name as the parent class method. This is the fundamental rule of overriding — without the same name, the method is not overriding but rather defining a new method. The subclass method replaces the inherited method when called on an instance of the subclass.

Answer

The `@override` decorator is required.

Answer

The subclass method can have a different number of parameters.

Question 14

Refer to the exhibit. Which statement correctly creates an instance of `Dog` and calls the `bark` method?

Accepted Answer

d = Dog("Rex"); d.bark(). The `__init__` method requires a `name` argument. Option B passes "Rex" and then calls `bark()` on the instance.

Answer

d = Dog(); d.bark()

Answer

Dog.bark()

Answer

d = Dog; d.bark()

Question 15

Refer to the exhibit. What will be the output?

Accepted Answer

AttributeError. Option C is correct because the code attempts to call `obj.get_value()` on an instance of `MyClass`, but `MyClass` does not define a `get_value` method. In Python, this raises an `AttributeError` since the attribute is not found on the object or its class. The error occurs at runtime, not during compilation, because Python dynamically looks up attributes.

Answer

None

Answer

0

Answer

10

PCAP Object-Oriented Programming Practice Test 6 — 15 Questions

Exhibit

PCAP Object-Oriented Programming Practice Test 6 — 15 Questions

Exhibit