PCAP Practice Test 9 — 10 Questions

Question 1

A developer is working on a logging system where dynamic values are inserted into a template string. The template is 'User %s logged in at %s'. The developer has the username and timestamp as separate variables. Which approach is most Pythonic (PEP 498) and recommended for new code?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Use an f-string: f'User {username} logged in at {timestamp}'. PEP 498 introduced f-strings (formatted string literals) as the recommended approach for string formatting in Python 3.6+. They are concise, readable, and evaluated at runtime, allowing direct embedding of expressions. This aligns with the 'Pythonic' principle of simplicity and is the preferred style for new code according to the official Python documentation.

Answer

Use %-formatting: 'User %s logged in at %s' % (username, timestamp)

Answer

Use .format(): 'User {} logged in at {}'.format(username, timestamp)

Answer

Concatenate: 'User ' + username + ' logged in at ' + timestamp

Question 2

Which TWO of the following statements about class attributes in Python are true?

Accepted Answer

Class attributes are shared by all instances.. Class attributes are defined directly in the class body and are shared across all instances of that class. When you access a class attribute via any instance, Python looks up the attribute in the class's __dict__ if it is not shadowed by an instance attribute, ensuring all instances see the same value unless explicitly overridden.

Answer

Class attributes are always immutable.

Answer

Class attributes are defined inside methods.

Answer

Modifying a class attribute via an instance modifies it for all instances.

Question 3

You are a data analyst working with a dataset of customer reviews. Each review is stored as a string in a list. You need to count how many reviews contain the word 'excellent' (case-insensitive). However, the word might appear as 'Excellent', 'EXCELLENT', or even with punctuation like 'excellent!'. The current code uses 'excellent' in review.lower(), but this fails if 'excellent' is part of another word like 'unexcellent'. You need to ensure that only the whole word 'excellent' is counted. Which code modification will correctly count whole word occurrences?

Accepted Answer

Use re.search(r'\bexcellent\b', review, re.IGNORECASE). `re.search(r'\bexcellent\b', review, re.IGNORECASE)` uses the `\b` word boundary anchor to ensure that 'excellent' is matched as a whole word, not as part of another word like 'unexcellent'. The `re.IGNORECASE` flag handles case-insensitive matching, covering 'Excellent', 'EXCELLENT', etc. This approach also correctly handles punctuation attached to the word, such as 'excellent!', because the word boundary matches between a word character and a non-word character.

Answer

Use 'excellent' in review.lower().split()

Answer

Use review.lower().count('excellent') > 0

Answer

Use review.lower().find('excellent') != -1

Question 4

Refer to the exhibit. What is the output? (Note: actual MRO may vary; choose the one that matches Python 3 C3 linearization.)

Accepted Answer

(, , , , ). Python 3 uses C3 linearization to compute the Method Resolution Order (MRO). For class D inheriting from B and C, which both inherit from A, the MRO is D, B, C, A, object. This satisfies the monotonicity and local precedence order: B comes before C (as per D's bases), and A is last among the user-defined classes, with object always appended.

Answer

(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>)

Answer

(<class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

Answer

(<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>)

Question 5

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). 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 6

A developer writes code to display a floating-point number with exactly two decimal places. Which f-string expression is correct for value = 3.14159?

Accepted Answer

f"{value:.2f}". The format specifier `.2f` in an f-string explicitly instructs Python to format the floating-point number with exactly two digits after the decimal point. The `f` type ensures fixed-point notation, and the precision `.2` controls the number of decimal places. This is the standard way to achieve two-decimal-place output for a float in Python.

Answer

f"{value:0.2}"

Answer

f"{value:%2f}"

Answer

f"{value:2f}"

Question 7

A team is using f-strings to format a report. They have a variable `value = 0.123456789` and want to display it with exactly 3 significant digits. They write `f"{value:.3g}"`. The output is '0.123'. They expected '0.123'. Is the output correct? If not, what change would produce '0.123'?

Accepted Answer

The output is correct as is.. The format specifier `.3g` in an f-string instructs Python to format the number with 3 significant digits using general format. For `0.123456789`, the first three significant digits are '123', and the general format automatically switches to fixed-point notation when the exponent is small, producing '0.123' exactly as expected.

Answer

Use `f"{value:.3s}"`

Answer

Use `f"{value:.3f}"`

Answer

Use `f"{value:.3e}"`

Question 8

A module 'shapes.py' defines several classes: Circle, Square, Triangle. The developer wants to allow users to import only Circle and Square when they use 'from shapes import *'. Which mechanism should be used?

Accepted Answer

Define a list variable named __all__ containing the string names 'Circle' and 'Square'.. The `__all__` variable in a module explicitly controls which names are exported when a client uses `from shapes import *`. By setting `__all__ = ['Circle', 'Square']`, only those two classes are imported, while `Triangle` is excluded. This is the standard Python mechanism for restricting wildcard imports.

Answer

Prefix the Triangle class with an underscore to make it private.

Answer

Use the import_explicit function.

Answer

Create an __init__.py file in the same directory.

Question 9

Refer to the exhibit. What is printed?

Accepted Answer

3
3. The code defines a class `A` with a class attribute `x = 3`. Inside `__init__`, the first `print(self.x)` accesses the class attribute (since no instance attribute exists yet), printing `3`. The statement `self.x += 1` is equivalent to `self.x = self.x + 1`; it reads the class attribute for the right-hand side, evaluates to `4`, and then creates a new instance attribute `x` with value `4`, shadowing the class attribute. The second `print(A.x)` explicitly accesses the class attribute, which remains `3`. Hence the output is `3` and `3` on separate lines.

Answer

3
6

Answer

3
Error

Answer

Error
3

Question 10

Refer to the exhibit. What is the output?

Accepted Answer

2
2
2. The code defines a class `A` with a class variable `x = 2`, and a class `B` that inherits from `A`. The `display` method prints `self.x`, which first looks up the instance attribute `x`; since no instance attribute is set, it falls back to the class variable `x = 2` from class `A`. The loop creates three instances of `B` and calls `display` on each, so each prints `2` on a separate line, resulting in the output 2, 2, 2.

Answer

2
0
0

Answer

2
1
1

Answer

0
2
2