PCAP Practice Test 4 — 25 Questions

Question 1

A network engineer processes a configuration file containing MAC addresses in the format 'aa:bb:cc:dd:ee:ff'. They need to convert each MAC address into a 6-byte bytes object for use in packet crafting. The current code is: mac_bytes = bytes([int(x, 16) for x in mac_str.split(':')]). This works correctly, but they need to process thousands of MAC addresses and want to optimize performance. They also need to handle invalid MAC addresses (e.g., non-hex characters) without crashing. Which of the following approaches is the most efficient and robust?

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

Accepted Answer

Use bytes.fromhex(mac_str.replace(':', '')). `bytes.fromhex()` is implemented in C, making it significantly faster than a Python-level list comprehension for thousands of conversions. It also inherently validates that the input contains only hexadecimal characters (and colons, which are ignored after removal), raising a `ValueError` for invalid input, which can be caught for robustness. This approach avoids the overhead of splitting, iterating, and calling `int()` for each octet.

Answer

Use the same list comprehension but add a try-except block for ValueError

Answer

Use struct.pack('BBBBBB', *[int(x,16) for x in mac_str.split(':')])

Answer

Use a for loop to parse each pair and build a bytearray

Question 2

Refer to the exhibit. What is the output of the code?

Accepted Answer

Error. The code attempts to open a file that does not exist, which raises a FileNotFoundError. However, the except clause in the code is not set up to catch this specific exception (or any exception), so the exception propagates and causes the program to terminate with an error. Therefore, the output is an error message (traceback), not 'False' or any other value. Option A is correct.

Answer

True

Answer

False

Answer

None

Question 3

During development, a programmer modifies a module that is already imported in the current Python session. To see the changes without restarting the interpreter, which function from the importlib module should be called?

Accepted Answer

importlib.reload(). `importlib.reload()` is the official Python function to re-import a previously imported module, applying any changes made to its source code without restarting the interpreter. It is part of the `importlib` module and is the recommended way to reload modules in Python 3.

Answer

reload()

Answer

reload_module()

Answer

importlib.import_module()

Question 4

A developer is working on a data pipeline that processes files from untrusted sources. The pipeline should catch and log any exception, but also ensure that sensitive information from the exception (e.g., file paths) is not exposed to end users. Which approach balances security and debugging?

Accepted Answer

Catch the exception, log the full traceback, then raise a custom generic exception.. It balances security and debugging: the full traceback is logged for developers (preserving debugging details like file paths), while a custom generic exception is raised to end users, preventing sensitive information from being exposed. This approach follows the principle of least privilege for error handling, ensuring that internal details are not leaked to untrusted sources.

Answer

Catch the exception and re-raise the same exception.

Answer

Catch the exception, log it, and suppress it silently.

Answer

Catch the exception and print it to the console.

Question 5

Refer to the exhibit. Given the project structure, which of the following import statements in main.py would cause an ImportError?

Accepted Answer

from ..utils import helpers. Uses a relative import with '..' which is only valid inside a package (i.e., when the module is loaded as part of a package and has a __package__ attribute set). In a flat project structure where main.py is a top-level script, '..' attempts to go above the top-level package, which is not allowed and raises an ImportError. Python's import system requires that relative imports be used only within a package hierarchy.

Answer

from utils import strings

Answer

from utils import helpers

Answer

from utils.strings import format

Question 6

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?

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 7

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 8

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 9

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 10

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 11

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 12

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 13

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 14

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 15

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

Question 16

Drag and drop the steps to perform unit testing with the unittest framework in Python into the correct order.

Accepted Answer

Import unittest, then create a TestCase subclass, then define test methods (starting with 'test_'), then call unittest.main(). Unit testing with unittest requires importing, creating a TestCase subclass, writing test methods, and calling unittest.main().

Answer

Create a TestCase subclass, then import unittest, then define test methods, then call unittest.main()

Answer

Import unittest, then define test methods, then create a TestCase subclass, then call unittest.main()

Answer

Import unittest, then create a TestCase subclass, then call unittest.main(), then define test methods

Question 17

A script runs: import sys; print(sys.path[0]). The output is an empty string. What does this indicate?

Accepted Answer

The script is being read from stdin.. When a script is read from stdin (e.g., via `python < script.py` or `echo 'print(1)' | python`), Python sets `sys.path[0]` to an empty string because there is no script file path to derive the directory from. This is the documented behavior: `sys.path[0]` is the directory containing the script, or an empty string if the script is read from standard input.

Answer

Python was launched with the -I flag.

Answer

The current working directory is not in sys.path.

Answer

The script is running from an interactive shell.

Question 18

A QA engineer needs to verify that a user input string contains at least one uppercase letter, one lowercase letter, and one digit. Which regex pattern can be used with re.search() to achieve this?

Accepted Answer

r'(?=.*[A-Z])(?=.*[a-z])(?=.*\d)'. It uses lookahead assertions ((?=...)) to check for the presence of at least one uppercase letter, one lowercase letter, and one digit anywhere in the string, without consuming characters. This allows re.search() to return a match if all three conditions are met, regardless of order.

Answer

r'[A-Za-z0-9]'

Answer

r'([A-Z].*[a-z].*\d)|([a-z].*[A-Z].*\d)|...'

Answer

r'\d.*[a-z].*[A-Z]'

Question 19

Which TWO statements about Python's name mangling are correct?

Accepted Answer

The mangled name format is _ClassName__attribute.. Python's name mangling transforms an attribute name like `__attribute` defined in a class `MyClass` into `_MyClass__attribute`. This mechanism is specifically designed to avoid name clashes in subclasses, not to enforce privacy. The transformation is done by the compiler at definition time, not at runtime.

Answer

Name mangling applies to all method names that start with a single underscore.

Answer

Name mangling prevents external code from accessing the attribute entirely.

Answer

Name mangling occurs at runtime.

Question 20

Given s = 'a1b2c3', which TWO of the following expressions return the string '123'?

Accepted Answer

s[1::2]. Slicing with `s[1::2]` starts at index 1 (the character '1'), goes to the end of the string, and takes every second character, resulting in '1', '2', '3' concatenated as '123'. Option C is also correct because `s[1:6:2]` starts at index 1, stops before index 6 (the string length is 6, so index 6 is just past the last character), and steps by 2, yielding the same sequence of characters.

Answer

s[0:5:2]

Answer

s[0::2]

Answer

s[2:5:1]