Python Institute PCAP – Certified Associate in Python Programming (PCAP-31-03)

✅

Reasoning: The raise E("what a pity") statement creates an E exception object. When print(e) is executed in the except block, Python calls the custom __str__ method of class E, which always returns "it's nice to see you".

Reasoning: The print("I feel fine") statement is located at the beginning of the try block. It executes successfully before the raise E("what a pity") statement, printing "I feel fine" to the console. ❌ Why the other choices are incorrect:

• Option A is incorrect: The __str__ method of class E overrides the default exception message, so "what a pity" (the message passed to __init__) is not printed when print(e) is called.
• Option C is incorrect: The except E as e: block explicitly catches and handles the E exception. The exception is therefore handled, not unhandled.

✅

Reasoning: m starts at 0. foo(0) is called. Inside foo, 1/0 raises ZeroDivisionError. The inner except ArithmeticError catches it, m becomes 1, and the error is re-raised. The outer except ArithmeticError then catches it, and m becomes 1 + 2 = 3. Finally, print(m) outputs 3. ❌ Why the other choices are incorrect:

• Option B is incorrect: m changes multiple times due to exception handling. It's not 1.
• Option C is incorrect: The m += 2 block executes, making the value 3, not 2.
• Option D is incorrect: The code is syntactically correct and handles the ZeroDivisionError gracefully without terminating.

✅

Reasoning: The string '' contains two single-quote characters. The len function correctly counts these two characters, so len("''") evaluates to 2. Therefore, 2 == 2 is True.

Reasoning: ord('z') returns the ASCII/Unicode value of 'z' (122). ord('z') - 1 is 121. chr(121) converts this value back to the character 'y'. Thus, 'y' == 'y' is True. ❌ Why the other choices are incorrect:

• Option A is incorrect: ord("0") is 48 and ord("9") is 57. The expression 48 - 57 equals -9. Since -9 == 10 is False, this choice is incorrect.
• Option D is incorrect: The syntax ''1234'' is invalid in Python. It's interpreted as an empty string '' followed by the integer 1234 followed by another empty string '', leading to a SyntaxError.

✅

Reasoning: The try block attempts 1 / 0, raising a ZeroDivisionError. The subsequent except ZeroDivisionError: block specifically catches this exception. The pass statement handles it, preventing any unhandled exceptions from propagating.

Reasoning: The try block performs 1 / 1, which executes successfully without raising any exceptions. Since no ZeroDivisionError occurs, the except block is skipped entirely. The program continues normally without unhandled exceptions. ❌ Why the other choices are incorrect:

• Option C is incorrect: A ValueError is raised within the try block. The except TypeError: clause will not catch a ValueError because they are distinct, unrelated exception types. Thus, the ValueError remains unhandled.
• Option D is incorrect: The function f raises a general Exception. The except IOError: clause is too specific to catch a general Exception. IOError is a subclass of OSError, not Exception itself directly. The Exception is unhandled.

✅

Reasoning: The string s = '2A' cannot be converted to an integer by int(s), causing a ValueError. This specific exception is caught by the first except ValueError: block, which sets n to 2. The program then proceeds to print(n), outputting 2. ❌ Why the other choices are incorrect:

• Option A is incorrect: The code includes try...except blocks specifically to handle potential errors, preventing a crash and ensuring execution proceeds to print a value.
• Option B is incorrect: n would be 1 only if an ArithmeticError occurred. int('2A') raises a ValueError, not an ArithmeticError.
• Option D is incorrect: n would be 0 only if a general, uncaught exception (not ValueError or ArithmeticError) occurred. The ValueError is specifically handled.

✅

Reasoning: platform.platform returns a single string identifying the underlying platform, including OS, version, and architecture. It directly provides the comprehensive platform name. ❌ Why the other choices are incorrect:

• Option A is incorrect: platform.processor returns the processor's name (e.g., 'x86_64'), not the underlying platform's name.
• Option B is incorrect: platform.uname returns a named tuple containing system information. While uname.system gives the basic OS name, the function itself returns a tuple, not a direct platform name string.
• Option C is incorrect: platform.python_version returns the Python interpreter's version string, not the underlying platform's name.

✅

Reasoning: This directive correctly uses the from... import... statement. It specifies the full package path pypack.upper.lower to locate the lower subpackage, then imports the module_c module from within it.

Reasoning: This directive correctly uses the import... statement. It provides the absolute, fully qualified name for module_c by traversing the package hierarchy: pypack -> upper -> lower -> module_c. ❌ Why the other choices are incorrect:

• Option C is incorrect: import upper.module_c is incorrect because upper is not a top-level package; it's a subpackage of pypack. Furthermore, module_c is not directly inside upper, but rather inside upper.lower.
• Option D is incorrect: import upper.lower.module_c is incorrect because upper is not a top-level package; it's nested within pypack. Python requires the full path from a package in sys.path.

✅

Reasoning: random.choice([1,2,3]) will always return 1, 2, or 3. All these values are greater than 0. Therefore, the expression random.choice([1,2,3]) > 0 will always evaluate to True. ❌ Why the other choices are incorrect:

• Option A is incorrect: random.sample([1,2,3], 1) returns a list containing one element, so its len is always 1. 1 > 2 is False.
• Option B is incorrect: random.random generates pseudo-random floats. While theoretically possible, v1 == v2 is highly improbable and not guaranteed to be True.
• Option D is incorrect: random.random returns a float x where 0.0 <= x < 1.0. Thus, v1 can never be greater than 1. v1 > 1 is always False.

✅

Reasoning: The import pymod statement imports the module pymod. After importing, variables within the module are accessed using dot notation: pymod.pyvar. The snippet correctly accesses pyvar and assigns it a new value.

Reasoning: The from pymod import * statement imports all public names from pymod directly into the current namespace. This allows pyvar to be accessed directly by its name without a module prefix. The snippet then correctly accesses pyvar and assigns it a new value. ❌ Why the other choices are incorrect:

• Option A is incorrect: While from pymod import pyvar is correct, pyvar attempts to call pyvar as a function, which is incorrect for a variable, resulting in a TypeError.
• Option C is incorrect: The syntax import pyvar from pymod is invalid. The correct syntax for importing specific names is from pymod import pyvar.

✅

Reasoning: The open('existing_file', 'w') call on an existing file truncates it but does not raise an IOError. The try block completes successfully, printing 1. The except block is skipped. The else block then executes, printing 3. The final output is "1 3". ❌ Why the other choices are incorrect:

• Option A is incorrect: The except block is not executed because no IOError occurs; therefore, 2 is not printed.
• Option B is incorrect: 2 is in the except block, which is skipped. The else block, which prints 3, is executed.
• Option D is incorrect: The try block successfully prints 1. The except block, which prints 2, is skipped.