PCAP Practice Test 19 — 15 Questions

Question 1

Which TWO of the following are valid ways to define a class attribute that is shared among all instances?

Accepted Answer

Assign the attribute inside a classmethod using cls.. A classmethod receives the class (cls) as its first argument, allowing you to assign or modify a class attribute via `cls.attribute = value`. This assignment affects the class itself, making the attribute shared among all instances, as the attribute is stored on the class object, not on instance dictionaries.

Answer

Assign the attribute inside a staticmethod.

Answer

Use the @property decorator.

Answer

Assign the attribute inside __init__ using self.

Question 2

What is the output of 'hello'.count('l')?

Accepted Answer

2. The string method `count('l')` returns the number of non-overlapping occurrences of the substring `'l'` in the string `'hello'`. The string `'hello'` contains the character `'l'` at indices 2 and 3, so the count is 2. Therefore, option D is correct.

Answer

1

Answer

3

Answer

0

Question 3

Drag and drop the steps to create and activate a virtual environment in Python into the correct order.

Accepted Answer

Create virtual environment, Activate virtual environment, Install packages, Deactivate virtual environment. Virtual environments isolate project dependencies. The typical workflow is install virtualenv, create environment, activate it, install packages, and deactivate when finished.

Answer

Activate virtual environment, Create virtual environment, Install packages, Deactivate virtual environment

Answer

Create virtual environment, Install packages, Activate virtual environment, Deactivate virtual environment

Answer

Create virtual environment, Activate virtual environment, Deactivate virtual environment, Install packages

Question 4

A developer is implementing a simple counter class. The class should start at 0 and increment by 1 each time the 'increment' method is called. Which implementation is correct?

Accepted Answer

class Counter:
    def __init__(self):
        self.count = 0
    def increment(self):
        self.count += 1. It properly initializes an instance variable `self.count` to 0 in the `__init__` method and then uses `self.count += 1` in the `increment` method to modify the instance variable in place. The `+=` operator is a shorthand for `self.count = self.count + 1`, which correctly updates the counter each time `increment` is called.

Answer

class Counter:
    def __init__(self):
        self.count = 0
    def increment(self):
        count = self.count + 1

Answer

class Counter:
    def __init__(self):
        count = 0
    def increment(self):
        count += 1

Answer

class Counter:
    def __init__(self):
        self.count = 0
    def increment():
        self.count += 1

Question 5

Under CPython, what is the result of the following code? a = 'hello'; b = 'hello'; print(a is b)

Accepted Answer

True. CPython interns short strings as an optimization, meaning both variables 'a' and 'b' reference the same immutable string object in memory. The 'is' operator checks object identity, not value equality, so it returns True when both variables point to the same interned object.

Answer

False

Answer

NameError

Answer

None

Question 6

A developer is building a large string by concatenating many substrings in a loop using '+'. What is the main performance issue?

Accepted Answer

Each concatenation creates a new string object, leading to quadratic time complexity. In Python, strings are immutable, so the '+' operator does not modify an existing string but creates a new string object each time it is used. In a loop, this results in O(n²) time complexity because each concatenation copies the entire accumulated string, making it highly inefficient for large or many substrings.

Answer

String concatenation is not allowed in loops

Answer

Strings are immutable, so concatenation is impossible

Answer

The '+' operator works only for characters, not strings

Question 7

Which TWO of the following operations can be performed on a string?

Accepted Answer

Slicing with [::]. String slicing with the syntax `[start:stop:step]` (e.g., `[::]`) is a built-in operation for strings in Python, allowing extraction of substrings. Option E is correct because the `+` operator performs string concatenation, creating a new string by joining two strings together.

Answer

Extend with .extend()

Answer

Append with .append()

Answer

Pop with .pop()

Question 8

What is the output of the following code?

try:
    raise ValueError('a')
except ValueError as e:
    print(e.args[0])
finally:
    print('b')

Accepted Answer

a
b. The `finally` block always executes after the `try` block, even when an exception is raised. The `except` block catches the `ValueError` and prints the first argument of the exception (`'a'`), then the `finally` block prints `'b'`. The output is `a` on one line and `b` on the next, matching `a
b`.

Answer

a b

Answer

b a

Answer

b

Question 9

In a performance-critical application, you need to concatenate many strings in a loop. Which TWO approaches are most efficient?

Accepted Answer

Using the join() method on a list. The `join()` method on a list (Option B) is efficient because it allocates memory once for the final concatenated string, avoiding repeated reallocation and copying that occurs with immutable strings. `StringIO` (Option E) provides a mutable buffer that accumulates string fragments efficiently, making it suitable for high-performance concatenation in loops.

Answer

Using the % formatting operator

Answer

Using the += operator

Answer

Using the + operator

Question 10

Which of the following expressions raises a ValueError?

Accepted Answer

'abc'.index('d'). Calling `'abc'.index('d')` raises a `ValueError` when the substring is not found. The `str.index()` method in Python is designed to raise this exception for missing substrings, unlike `str.find()` and `str.rfind()`, which return -1.

Answer

'abc'.index('a')

Answer

'abc'.find('d')

Answer

'abc'.rfind('d')

Question 11

Refer to the exhibit. What is the output of the last line?

Accepted Answer

{'name': 'John', '_Employee__salary': 50000}. Python uses name mangling for attributes starting with double underscores (like `__salary`). When accessed via `vars()`, the mangled name `_Employee__salary` is shown, not the original `__salary`. The `vars()` function returns the `__dict__` of the object, which contains the mangled attribute name.

Answer

{'name': 'John'}

Answer

AttributeError: 'Employee' object has no attribute '__salary'

Answer

{'name': 'John', '__salary': 50000}

Question 12

What is the result of the expression '123'.zfill(5)?

Accepted Answer

'00123'. The `zfill()` method in Python pads the string on the left with zeros until it reaches the specified width. For the string '123' and width 5, it adds two zeros to the left, resulting in '00123'. This is the correct behavior as defined in Python's string methods.

Answer

'123'

Answer

'000123'

Answer

'12300'

Question 13

Refer to the exhibit. What happens when the last command is executed?

Accepted Answer

It raises TypeError: Can't instantiate abstract class Circle with abstract methods area. The last command attempts to instantiate an abstract class `Circle` that has an abstract method `area` which has not been implemented. In Python, abstract classes defined with `ABC` and decorated with `@abstractmethod` cannot be instantiated directly; attempting to do so raises `TypeError` with the message 'Can't instantiate abstract class Circle with abstract methods area'.

Answer

It creates a Circle object successfully

Answer

It prints nothing and exits with code 0

Answer

It raises AttributeError: 'Circle' object has no attribute 'area'

Question 14

A programmer wants to catch both `FileNotFoundError` and `PermissionError` with a single except clause. Which tuple is correct?

Accepted Answer

except (FileNotFoundError, PermissionError):. Python's exception handling syntax allows a tuple of exception types in a single `except` clause, enabling the programmer to catch multiple exception types with the same handler. Both `FileNotFoundError` and `PermissionError` are subclasses of `OSError`, but using the tuple explicitly catches only those two specific exceptions, not all `OSError` subtypes.

Answer

except FileNotFoundError, PermissionError:

Answer

except OSError:

Answer

except [FileNotFoundError, PermissionError]:

Question 15

A module 'config.py' contains a variable 'settings' that is a dictionary. Another script does: from config import settings. Then the script modifies settings['key'] = 'new_value'. What happens?

Accepted Answer

The change is reflected in config.settings because it is the same object.. Python's import statement binds the name 'settings' in the importing module's namespace to the same dictionary object that exists in config.py. Since dictionaries are mutable, modifying settings['key'] directly mutates the shared object, and the change is visible through config.settings as well.

Answer

The config module is reloaded and the change is lost.

Answer

The script gets a copy of the dictionary, so config.settings is unchanged.

Answer

An error occurs because settings is read-only.