PCAP Practice Test 35 — 15 Questions

Question 1

A developer is building a simulation of different types of vehicles. They have a base class Vehicle with an attribute speed initialized in __init__. They also have a subclass Car that inherits from Vehicle and adds an attribute fuel_type. The developer wants to ensure that every time a Car object is created, it also initializes the speed attribute from the Vehicle class. Which approach should the developer use?

Accepted Answer

In Car.__init__, call Vehicle.__init__(self) manually.. Option B is correct because in Python, when a subclass overrides __init__, the parent class's __init__ is not automatically called. To ensure the speed attribute from Vehicle is initialized, the developer must explicitly call Vehicle.__init__(self) inside Car.__init__. This is a fundamental requirement of Python's inheritance mechanism for proper initialization of inherited attributes.

Answer

Override the __new__ method of Vehicle.

Answer

Use the @staticmethod decorator for initialization.

Answer

In Car.__init__, define speed directly without calling parent's __init__.

Question 2

A programmer wants to ensure that a class attribute is the same for all instances and can be accessed via the class name. Which type of variable should be defined?

Accepted Answer

Class variable. Option D is correct because a class variable in Python is defined directly within the class body (outside any method) and is shared across all instances. It can be accessed via the class name (e.g., `ClassName.var`) or through any instance, ensuring the same value for all objects.

Answer

Global variable

Answer

Instance variable

Answer

Local variable inside a method

Question 3

Refer to the exhibit. What is the output and why?

Accepted Answer

2. Option C is correct because the code defines a class `A` with a class attribute `counter` set to 0, and an `__init__` method that increments `A.counter` (the class attribute) by 1 each time an instance is created. Creating two instances (`a1` and `a2`) increments the class attribute twice, so `A.counter` becomes 2. The `print(A.counter)` statement outputs the class attribute value, which is 2.

Answer

AttributeError

Answer

1

Answer

3

Question 4

A junior developer wrote a class representing a bank account with a private attribute balance. They used double underscore prefix (__balance) to make it private. However, in a test script, they are still able to access the attribute using the mangled name _Account__balance. The developer is confused about why encapsulation is not enforced. Which statement best explains this behavior?

Accepted Answer

Python's name mangling is only a convention and does not prevent access.. Option B is correct because Python's name mangling (triggered by a double underscore prefix) is not a security mechanism but a syntactic transformation that renames the attribute to _ClassName__attribute. This prevents accidental name clashes in subclasses but does not enforce true encapsulation; the attribute can still be accessed via the mangled name from outside the class. The developer's confusion stems from mistaking name mangling for a privacy guarantee, which Python intentionally does not provide.

Answer

The double underscore prefix actually makes the attribute completely inaccessible from outside the class.

Answer

The developer forgot to use the @property decorator.

Answer

The test script must have used a different class attribute name.

Question 5

When a class defines both __getattr__ and __getattribute__, which one is called when accessing an attribute that exists in the instance?

Accepted Answer

__getattribute__ is called, and __getattr__ is not called.. In Python, when both __getattr__ and __getattribute__ are defined in a class, __getattribute__ is always called first for every attribute access. If the attribute exists in the instance (e.g., in the instance dictionary or via a descriptor), __getattribute__ returns it directly, and __getattr__ is never invoked. __getattr__ is only called as a fallback when __getattribute__ raises an AttributeError. Therefore, for an existing attribute, only __getattribute__ runs, making option D correct.

Answer

__getattr__ always overrides __getattribute__.

Answer

Both __getattr__ and __getattribute__ are called, in that order.

Answer

Only __getattr__ is called.

Question 6

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 7

A developer creates a metaclass 'Meta' that modifies class creation by adding a class attribute 'created_by' set to 'Meta'. Which code snippet correctly defines and uses this metaclass?

Accepted Answer

class Meta(type): def __new__(cls, name, bases, dct): dct['created_by']='Meta'; return super().__new__(cls, name, bases, dct). Option D is correct because it defines a proper metaclass by subclassing `type` and overriding `__new__`, which is the correct method for modifying the class dictionary before the class is created. The `__new__` method must return the result of `super().__new__(cls, name, bases, dct)` to actually create the class object. Adding `dct['created_by']='Meta'` inside `__new__` ensures the attribute is set during class creation.

Answer

class Meta(type): def __new__(cls, name, bases, dct): dct['created_by']='Meta'

Answer

class Meta(type): def __init__(cls, name, bases, dct): dct['created_by']='Meta'

Answer

def Meta(name, bases, dct): dct['created_by']='Meta'; return type(name, bases, dct)

Question 8

Which THREE of the following are characteristics of Python's special methods (dunder methods)? (Select exactly three.)

Accepted Answer

They enable operator overloading for user-defined classes.. Option A is correct because special methods like `__add__` and `__eq__` allow user-defined classes to redefine the behavior of operators such as `+` and `==`. When Python encounters an operator expression, it looks up the corresponding dunder method on the object's class, enabling operator overloading in a clean, syntactic way.

Answer

Every class automatically has all special methods predefined.

Answer

They must be defined inside the class definition and cannot be added later.

Question 9

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 10

A class named Counter has a class variable count and an instance method increment. The method is defined as def increment(self): Counter.count += 1. What will be the output after executing the following code? c1 = Counter(); c2 = Counter(); c1.increment(); c2.increment(); print(Counter.count, c1.count, c2.count)

Accepted Answer

2 2 2. Option A is correct because the class variable `count` is shared across all instances of the `Counter` class. The `increment` method modifies `Counter.count` directly, so after two calls, `Counter.count` becomes 2. Since `c1.count` and `c2.count` refer to the same class variable (they do not have instance attributes shadowing it), both instances reflect the same value of 2.

Answer

2 1 1

Answer

1 1 1

Answer

0 0 0

Question 11

A developer is working on a class hierarchy for geometric shapes. They have a base class Shape with an abstract method area(). They also have a mixin class Drawable that provides a method draw(). They want to create a class Rectangle that inherits from both Shape and Drawable. However, they encounter a TypeError when trying to instantiate Rectangle because the abstract method area() is not implemented. Which action should they take to resolve this?

Accepted Answer

Implement the area() method in Rectangle.. Option B is correct because the abstract method area() declared in the Shape base class must be implemented in any concrete subclass. In Python, a class that inherits from an ABC (Abstract Base Class) with an abstract method cannot be instantiated until that method is overridden. By providing an implementation of area() in Rectangle, the class becomes concrete and can be instantiated without raising a TypeError.

Answer

Change the inheritance order to Drawable first, then Shape.

Answer

Use a class decorator @abstractmethod for Rectangle.

Answer

Remove the abstract method from Shape by removing the @abstractmethod decorator.

Question 12

Which of the following expressions returns the string 'Hello' repeated three times?

Accepted Answer

'Hello' * 3. In Python, the multiplication operator (*) when used with a string and an integer performs string repetition. 'Hello' * 3 returns the string 'HelloHelloHello' by concatenating three copies of the original string. This is a core feature of Python's sequence protocol, where strings are sequences of characters.

Answer

'Hello' + 3

Answer

'Hello' * '3'

Answer

'Hello' * 3.0

Question 13

Which THREE of the following are true about Python strings?

Accepted Answer

They support slicing.. Option A is correct because Python strings are sequences, and the slicing syntax (e.g., s[start:stop:step]) allows extracting substrings by specifying indices. This works because strings implement the sequence protocol, including __getitem__ with slice objects.

Answer

They are stored as arrays of ASCII characters.

Answer

They are mutable.

Question 14

A developer needs to extract the domain name (e.g., 'example.com') from an email address stored in the variable 'email'. The code currently uses `email.split('@')[1]`, which returns the domain part. However, it fails for addresses containing an '@' character in the local part (e.g., 'user@name@domain.com'). Which approach correctly extracts the domain assuming the email is valid?

Accepted Answer

email.rsplit('@', 1)[1]. Option B is correct because `rsplit('@', 1)` splits the string from the right, limiting the split to one occurrence, so it always returns the last part after the final '@' character. This correctly extracts the domain even when the local part contains an '@', as in 'user@name@domain.com', where the domain is 'domain.com'.

Answer

email.partition('@')[0]

Answer

email.split('@')[1]

Answer

email.split('@', 1)[1]

Question 15

A developer encounters an error: `ValueError: Unknown format code 's' for object of type 'int'` when running `print("{0:s}".format(42))`. What is the problem and how should it be fixed?

Accepted Answer

Change `{0:s}` to `{0:d}` because the value is an integer, not a string.. Option D is correct because the format specifier `s` in `{0:s}` expects a string argument, but the provided argument `42` is an integer. The `d` format specifier is designed for integers, so changing `{0:s}` to `{0:d}` resolves the `ValueError` by matching the format code to the data type.

Answer

Change `{0:s}` to `{0:str}` to explicitly specify string conversion.

Answer

Wrap 42 in str(): `print("{0:s}".format(str(42)))`

Answer

Change `{0:s}` to `{0:i}` to indicate integer.