Scenario practice questions

A Python class 'Shape' defines an abstract method 'area'. Subclasses 'Circle' and 'Square' implement 'area'. A function 'calculate_area(shape)' expects a 'Shape' instance. Which principle ensures that the function works correctly without knowing the specific subclass?

Trap 1: Interface Segregation Principle

ISP is about keeping interfaces small.

Trap 2: Single Responsibility Principle

SRP is about each class having one responsibility.

Trap 3: Dependency Inversion Principle

DIP is about high-level modules not depending on low-level modules.

A
Interface Segregation Principle
Why wrong: ISP is about keeping interfaces small.
B
Liskov Substitution Principle
LSP ensures that any subclass can replace the base class without breaking the function.
C
Single Responsibility Principle
Why wrong: SRP is about each class having one responsibility.
D
Dependency Inversion Principle
Why wrong: DIP is about high-level modules not depending on low-level modules.

Question 2mediummultiple choice

A Python class 'BankAccount' has a method 'withdraw(amount)' that deducts 'amount' from 'self.balance'. A developer writes a subclass 'SavingsAccount' that overrides 'withdraw' to add a penalty if balance drops below minimum. Which design pattern is being used?

Trap 1: Composition

Composition involves 'has-a' relationships, not overriding.

Trap 2: Aggregation

Aggregation is a form of composition.

Trap 3: Inheritance

Inheritance is the mechanism, but the question asks about the pattern.

A
Composition
Why wrong: Composition involves 'has-a' relationships, not overriding.
B
Aggregation
Why wrong: Aggregation is a form of composition.
C
Method overriding
The subclass provides a specific implementation of the inherited method.
D
Inheritance
Why wrong: Inheritance is the mechanism, but the question asks about the pattern.

Question 3easymultiple choice

A developer writes a function that reads a configuration file and returns its contents as a string. The file might not exist. Which exception should be caught to handle a missing file?

Trap 1: PermissionError

PermissionError is for access issues, not missing file.

Trap 2: IOError

IOError is an alias for OSError, not specific to missing file.

Trap 3: OSError

OSError is too broad; it includes other I/O errors.

A
FileNotFoundError
FileNotFoundError is specifically for missing files.
B
PermissionError
Why wrong: PermissionError is for access issues, not missing file.
C
IOError
Why wrong: IOError is an alias for OSError, not specific to missing file.
D
OSError
Why wrong: OSError is too broad; it includes other I/O errors.

Question 4easymultiple choice

A developer writes a function that reads a file and processes its content. The function should handle the case where the file does not exist without catching other I/O errors. Which exception should be caught?

Trap 1: PermissionError

PermissionError is raised for permission issues, not for missing files.

Trap 2: IOError

IOError is deprecated in Python 3 and too broad; it catches any I/O error, not just missing files.

Trap 3: OSError

OSError is the parent of FileNotFoundError and includes many other OS errors, making it too broad.

A
PermissionError
Why wrong: PermissionError is raised for permission issues, not for missing files.
B
IOError
Why wrong: IOError is deprecated in Python 3 and too broad; it catches any I/O error, not just missing files.
C
OSError
Why wrong: OSError is the parent of FileNotFoundError and includes many other OS errors, making it too broad.
D
FileNotFoundError
FileNotFoundError is the specific exception for a missing file, ideal for this scenario.

Question 5mediummulti select

Which TWO statements about inheritance in Python are true?

Trap 1: Abstract base classes can be instantiated if they have no abstract…

Although technically possible, it is not a recommended practice and not a typical statement about inheritance.

Trap 2: Private attributes (with double underscore) of the base class are…

Name mangling makes them inaccessible as original name.

Trap 3: The super() function returns a proxy object for method delegation.

While super() does return a proxy, the statement is not always considered true in the context of inheritance semantics; MRO is key.

A
Abstract base classes can be instantiated if they have no abstract methods.
Why wrong: Although technically possible, it is not a recommended practice and not a typical statement about inheritance.
B
The Method Resolution Order (MRO) is determined by the C3 linearization algorithm.
C3 linearization is used to compute MRO in Python.
C
Private attributes (with double underscore) of the base class are accessible in the subclass.
Why wrong: Name mangling makes them inaccessible as original name.
D
A class can inherit from multiple base classes.
Python supports multiple inheritance.
E
The super() function returns a proxy object for method delegation.
Why wrong: While super() does return a proxy, the statement is not always considered true in the context of inheritance semantics; MRO is key.

Question 6mediummultiple choice

A class inherits from two parent classes that both have a method with the same name. When calling the method on the child, only one parent's version is executed. What Python mechanism determines which one?

Trap 1: Method overloading by signature.

Python does not support method overloading.

Trap 2: Explicit super() call in the child class.

super() is used to call parent methods, but it follows MRO.

Trap 3: Inheritance depth (closest parent wins).

MRO considers multiple factors, not just depth.

A
Method overloading by signature.
Why wrong: Python does not support method overloading.
B
Explicit super() call in the child class.
Why wrong: super() is used to call parent methods, but it follows MRO.
C
Inheritance depth (closest parent wins).
Why wrong: MRO considers multiple factors, not just depth.
D
Method Resolution Order (MRO).
MRO determines the order of method lookup in multiple inheritance.

Question 7mediummultiple choice

A developer runs pip install package==1.0 and gets the above error. What is the most likely solution?

Exhibit

ERROR: Could not find a version that satisfies the requirement package==1.0 (from versions: 2.0, 2.1)
ERROR: No matching distribution found for package==1.0

Trap 1: Run pip update to upgrade pip.

Upgrading pip does not add missing versions.

Trap 2: Install from a different repository.

The repository has later versions, so no need to change.

Trap 3: Check if the package name is correct.

The error indicates versions exist, so the name is likely correct.

A
Run pip update to upgrade pip.
Why wrong: Upgrading pip does not add missing versions.
B
Install from a different repository.
Why wrong: The repository has later versions, so no need to change.
C
Use pip install package==2.0 instead.
Version 2.0 is available and satisfies the requirement.
D
Check if the package name is correct.
Why wrong: The error indicates versions exist, so the name is likely correct.

Question 8mediummultiple choice

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?

Trap 1: `self.method()`

This calls the method on the instance itself, which would be the most derived version, not necessarily from a specific parent.

Trap 2: `ParentClass.method(self)`

This bypasses the MRO and can lead to inconsistent behavior in diamond inheritance.

Trap 3: `BaseClass.method(self)`

Same as A, bypasses MRO.

A
`self.method()`
Why wrong: This calls the method on the instance itself, which would be the most derived version, not necessarily from a specific parent.
B
`ParentClass.method(self)`
Why wrong: This bypasses the MRO and can lead to inconsistent behavior in diamond inheritance.
C
`super().method()`
`super()` follows the MRO, calling the method from the next class in line.
D
`BaseClass.method(self)`
Why wrong: Same as A, bypasses MRO.

Question 9hardmultiple choice

Which of the following is true regarding Python's method resolution order (MRO) in multiple inheritance?

Trap 1: The MRO is always the same as the order of base classes specified…

In complex hierarchies, MRO may differ due to C3.

Trap 2: The MRO can be changed at runtime by modifying the __bases__…

__bases__ is read-only, and MRO is fixed after class creation.

Trap 3: The MRO is determined by the order of base classes in the class…

Python uses C3 linearization, which handles diamond inheritance properly.

A
The MRO is computed using the C3 linearization algorithm, ensuring that each class appears before its parents and that monotonicity is preserved.
C3 is correct.
B
The MRO is always the same as the order of base classes specified in the class statement.
Why wrong: In complex hierarchies, MRO may differ due to C3.
C
The MRO can be changed at runtime by modifying the __bases__ attribute of a class.
Why wrong: __bases__ is read-only, and MRO is fixed after class creation.
D
The MRO is determined by the order of base classes in the class definition, using a depth-first, left-to-right search without consideration of diamond inheritance.
Why wrong: Python uses C3 linearization, which handles diamond inheritance properly.

Question 10easymultiple choice

A developer is building an IoT application that reads temperature data from a sensor over a TCP socket. The sensor sends data as a stream of bytes encoded in UTF-8, with each reading terminated by a newline character. The developer uses the following code to receive data:

```python

import socket

s = socket.socket() s.connect(('sensor.local', 5000)) data = s.recv(1024) ```

The variable `data` is a bytes object. The developer needs to convert it to a string to parse the temperature value. Which of the following lines of code should the developer use to correctly obtain the string representation of the received data, assuming the data is valid UTF-8 and may contain non-ASCII characters?

Trap 1: data.encode('utf-8')

Encodes to bytes (but data is already bytes), would raise AttributeError or return bytes.

Trap 2: bytes(data)

Returns a copy of the bytes object, not a string.

Trap 3: str(data)

Returns a string like "b'...'" which includes the b prefix and escapes.

A
data.encode('utf-8')
Why wrong: Encodes to bytes (but data is already bytes), would raise AttributeError or return bytes.
B
data.decode('utf-8')
Correctly decodes UTF-8 bytes to a string.
C
bytes(data)
Why wrong: Returns a copy of the bytes object, not a string.
D
str(data)
Why wrong: Returns a string like "b'...'" which includes the b prefix and escapes.