510 questions total · 7pages · All types, answers revealed
Page 1 of 7
Page 2Which TWO of the following are valid variable names in Python? (Choose Two)
Underscore at start is allowed.
Why this answer
A and D are valid. B starts with a digit, C contains a hyphen, and E is a reserved keyword.
You are a junior developer at a logistics company. Your team maintains a Python script that processes daily shipment data from a CSV file. The script reads the file, computes total weight per shipment, and writes results to a new CSV. Recently, the script started crashing sporadically with a 'ValueError: invalid literal for int() with base 10: 'NULL''. The CSV file sometimes contains the string 'NULL' in the weight column for missing values. The current code reads the weight column as: weight = int(row['weight']). Your team lead wants a robust fix that handles missing data gracefully without crashing, and also logs the line number for any problematic rows for later review. Which of the following approaches best meets these requirements?
Catches all invalid literals, logs line number, and continues.
Why this answer
Option B is correct: it uses a try-except to catch ValueError, logs the line number (using a counter), sets weight to 0, and continues processing. Option A logs but still crashes because the exception is not caught. Option C catches error but doesn't log the line number.
Option D is overcomplicated and doesn't log line number explicitly.
What is the output of the following code? print(type(3.0) == float)
Correct; type returns <class 'float'>, which equals float.
Why this answer
The expression `type(3.0) == float` compares the result of `type(3.0)` (which is `<class 'float'>`) directly to the `float` class. In Python, `type()` returns the class object, and comparing it with `==` to the built-in class `float` yields `True` because they are the same object. Therefore, `print(True)` outputs `True`.
Exam trap
Python Institute often tests the distinction between `type()` returning a class object versus a string representation, and candidates mistakenly think `type(3.0)` returns the string `'float'`, leading them to choose `False` or `Error`.
How to eliminate wrong answers
Option A is wrong because `print()` outputs the value of the expression, not its type; the expression evaluates to `True`, which is a boolean, but the output is the string representation `True`, not `<class 'bool'>`. Option B is wrong because the comparison `type(3.0) == float` is `True`, not `False`; a common mistake is thinking `type()` returns a string like `'float'`, but it returns the actual class object. Option C is wrong because the code is syntactically valid and runs without any error; `type(3.0)` is a valid call, and comparing it with `==` to `float` is allowed.
What does the following code print? x = 10 if x > 5: if x > 15: print("A") else: print("B") else: print("C")
Correct output.
Why this answer
The code first checks if x > 5, which is true because x = 10. Then it checks if x > 15, which is false, so the else branch of the inner if-else executes, printing 'B'. The outer else is skipped entirely.
Exam trap
Python Institute often tests the misconception that the outer else (printing 'C') will execute when the inner condition fails, but candidates must remember that the outer else only runs if the outer condition is false.
How to eliminate wrong answers
Option A is wrong because the code does produce output; the inner else branch executes. Option B is wrong because 'C' would only print if the outer condition x > 5 were false, but it is true. Option D is wrong because 'A' would print only if x > 15 were true, but x = 10 is not greater than 15.
Which two of the following expressions return the value 5? (Choose two.)
Floor division yields 5
Why this answer
Option B (10 // 2) uses floor division, which divides 10 by 2 and returns the integer quotient 5. This is correct because floor division in Python discards any fractional remainder, yielding an exact integer result.
Exam trap
Python Institute often tests the difference between / (float division) and // (integer floor division), trapping candidates who assume / returns an integer when the division is exact.
Refer to the exhibit. What is the output?
Correct: 4 squared is 16.
Why this answer
The function square returns the square of its argument. 4**2 = 16. Option B is correct.
Which THREE of the following statements about Python exception handling are correct?
The finally clause executes regardless of whether an exception occurred or not.
Why this answer
Options B, C, and D are correct. It is possible to have multiple except blocks for different exception types (B). The else block runs if no exception occurred (C).
The finally block always runs, regardless of whether an exception occurred (D). Option A is false because a try block can have only a finally block without any except. Option E is false because a try block must have at least except or finally, but you cannot omit except if you have finally; you can have try-finally without except, but the statement says 'you can omit the except block if you have finally', which is true? Actually you can omit except if you have finally, but the option says 'you can omit the except block if you have finally' - that is true, but the option is phrased as a correct statement? Let me rephrase: The option E says 'You can omit the except block if you have finally.' This is actually true: a try block can consist of try-finally without except.
However, the intent is to test the requirement of at least one except? Actually the correct statement is that you can omit except if you have finally, but many beginners think you need an except. However, to avoid confusion, I'll make E false by stating it incorrectly. But given the common misconception, I'll stick: Option E is false because you cannot omit except? Actually you can.
Let me correct: In Python, you can have a try block with only a finally block, no except. So option E is a true statement. But then it would be a fourth correct option.
I need to adjust: The question asks for THREE correct. Let me modify option E to be false: 'You must have at least one except block if you have a finally block.' That is false. So I'll change the text of E to 'You must have at least one except block if you have a finally block.' Then correct options are B, C, D.
A function sometimes returns None. Which expression correctly checks if the return value is not None?
Correct and idiomatic.
Why this answer
Option C is correct because the `is not` operator is the proper way to check identity inequality in Python. Since `None` is a singleton, comparing with `is not` ensures you are checking whether the value is literally the `None` object, which is the recommended and most readable approach for `None` checks.
Exam trap
Python Institute often tests the distinction between identity (`is`) and equality (`==`) operators, and the trap here is that candidates mistakenly use `!= None` (value comparison) instead of `is not None` (identity comparison), or confuse truthiness checks with `None` checks.
How to eliminate wrong answers
Option A is wrong because `if not val is None:` is syntactically valid but confusing and non-idiomatic; it actually means `if not (val is None):` due to operator precedence, which is equivalent to `if val is not None:` but is discouraged for readability. Option B is wrong because `if val != None:` uses value equality (`!=`) instead of identity (`is not`); while it often works due to Python's implementation, it can fail if the object's `__eq__` method is overridden to return `True` when compared to `None`. Option D is wrong because `if val:` checks truthiness, not whether the value is `None`; many falsy values (e.g., `0`, `False`, empty list) would cause the condition to be `False` even though they are not `None`.
A developer writes the following code: result = (5 + 3) * 2 ** 3 // 4. What is the value of result?
Correct: follows precedence and left-associativity.
Why this answer
Option B is correct because Python follows the operator precedence rules: exponentiation (**) is evaluated before multiplication and division, and multiplication/division are evaluated before addition/subtraction. The expression evaluates as: 2 ** 3 = 8, then (5 + 3) = 8, then 8 * 8 = 64, then 64 // 4 = 16. The integer division (//) yields an integer result of 16.
Exam trap
Python Institute often tests the combination of exponentiation and floor division with parentheses, where candidates forget that ** binds tighter than * and //, leading them to compute (5+3)*2 = 16, then 16**3 = 4096, then 4096//4 = 1024, or they ignore the // and just compute 8*8=64.
How to eliminate wrong answers
Option A is wrong because it assumes the expression is evaluated left-to-right without precedence, e.g., (5+3)=8, then 8*2=16, then 16**3=4096, then 4096//4=1024, which is not 8; or it might incorrectly compute 2**3=8, then 8//4=2, then 8*2=16, but then subtract something incorrectly. Option C is wrong because it likely results from misapplying precedence, e.g., computing (5+3)=8, then 2**3=8, then 8*8=64, then 64/4=16.0 (float) but then rounding or truncating incorrectly to 13, or mixing // with / in a wrong order. Option D is wrong because it ignores the floor division (//) entirely, computing 8 * 8 = 64 and stopping, or it incorrectly treats // as exponentiation again.
Which two of the following are valid ways to create a list with elements 1, 2, 3? (Select two.)
Valid: range creates sequence, list() converts to list.
Why this answer
Option A is correct because `list(range(1, 4))` creates a list from the range object that generates numbers 1, 2, and 3 (the `range` function stops before the stop value 4). This is a common Python idiom for converting a range into a list.
Exam trap
Python Institute often tests the distinction between list literals (square brackets) and tuple literals (parentheses), and the requirement for commas as separators, to catch candidates who confuse syntax from other languages or misuse punctuation.
Which of the following is a valid Python variable name?
Underscore is allowed as first character.
Why this answer
Option D (_var) is correct because in Python, variable names must start with a letter or an underscore, and can contain letters, digits, and underscores. The underscore is explicitly allowed as the first character, making _var a valid identifier.
Exam trap
Python Institute often tests the misconception that hyphens or spaces are acceptable in variable names because they appear in other programming languages or file naming conventions, but Python strictly prohibits them.
How to eliminate wrong answers
Option A is wrong because variable names cannot start with a digit; '2var' begins with '2', which violates Python's identifier rules. Option B is wrong because variable names cannot contain spaces; 'var name' includes a space, which is not a valid character in identifiers. Option C is wrong because variable names cannot contain hyphens; 'var-name' uses a hyphen, which Python interprets as the subtraction operator, not part of a name.
Which TWO of the following are valid dictionary methods? (Select two.)
Correct; returns dict keys view.
Why this answer
keys() and values() are valid dictionary methods. entries(), pairs(), and keyset() are not.
A developer writes a function to calculate the average of a list of numbers, but the function sometimes returns a wrong result when the list contains non-numeric values. What is the best way to handle this?
Raising an exception is the standard way to handle invalid input.
Why this answer
Option D is correct because it explicitly validates that all items are numeric before performing the calculation, raising a TypeError if any non-numeric value is found. This follows Python's principle of explicit error handling and ensures the function's contract is clear: it only works with numeric data. Returning None (A) or silently ignoring values (B) can lead to subtle bugs, while converting to strings (C) would produce a concatenated string, not an average.
Exam trap
Python Institute often tests the distinction between silently handling errors (e.g., returning None or ignoring bad data) and explicitly raising exceptions, where candidates may mistakenly choose a 'graceful' option like ignoring non-numeric values, not realizing that it can lead to incorrect results without any warning.
How to eliminate wrong answers
Option A is wrong because returning None when encountering non-numeric values silently changes the return type, which can cause downstream code to fail unexpectedly (e.g., when trying to use the result in further arithmetic). Option B is wrong because using try-except to ignore non-numeric values silently discards data, producing an average that may be misleadingly incorrect without any indication of the omission. Option C is wrong because converting all values to strings and concatenating them produces a string, not a numeric average, which is a fundamental type error and completely misses the purpose of the function.
A program contains a nested while loop. The inner loop should run as long as a condition is True, but the outer loop should stop after 3 iterations. Which code structure is correct? (Assume the inner loop condition is inner < 5.)
Correct; outer increments after inner loop completes.
Why this answer
Option D correctly implements a nested while loop where the inner loop runs while `inner < 5` and the outer loop runs while `outer < 3`. The inner loop increments `inner` to control its own termination, and the outer loop increments `outer` after the inner loop completes, ensuring exactly 3 iterations of the outer loop. This matches the requirement that the outer loop stops after 3 iterations while the inner loop runs as long as its condition is True.
Exam trap
Python Institute often tests the misconception that incrementing a loop counter inside a nested loop will correctly control both loops, when in fact it causes the outer loop to terminate prematurely, as seen in options B and C.
How to eliminate wrong answers
Option A is wrong because it uses a `for` loop for the outer loop, not a `while` loop as specified in the question (the outer loop should be a `while` loop, not a `for` loop). Option B is wrong because it increments `outer` inside the inner `for` loop, causing the outer `while` loop to terminate prematurely after the first inner iteration (since `outer` becomes 3 after one pass through the inner loop). Option C is wrong because it increments `outer` inside the inner `while` loop, which also causes the outer loop to terminate early (after the first inner iteration) and disrupts the intended 3 outer iterations.
A developer needs to store the result of dividing two numbers, a/b, but only if b is not zero. They write: result = a / b if b != 0 else 'undefined'. What is the data type of result when b is zero?
The else clause returns a string literal, so result is a string.
Why this answer
When `b` is zero, the expression `a / b if b != 0 else 'undefined'` evaluates to the string literal `'undefined'`. Therefore, the variable `result` is assigned a value of type `str` (string). The conditional expression explicitly returns a string in the else branch, making option D correct.
Exam trap
Python Institute often tests the ternary conditional expression to see if candidates mistakenly think the else branch returns a special 'undefined' value (like in JavaScript) instead of recognizing it as a plain Python string literal.
How to eliminate wrong answers
Option A is wrong because a float is returned only when the division occurs (b != 0); when b is zero, no division happens, so no float is produced. Option B is wrong because NoneType would require the expression to evaluate to `None`, but the else clause explicitly returns the string `'undefined'`, not the Python `None` object. Option C is wrong because a bool would require the expression to evaluate to `True` or `False`, but the else clause returns a string, not a boolean.
Match each Python control flow statement to its purpose.
Drag a concept onto its matching description — or click a concept then click the description.
Exits the current loop immediately
Skips the rest of the current iteration and goes to the next
Does nothing; used as a placeholder
Short for else-if; checks another condition
Executes a block when no previous condition is true
Why these pairings
These statements control the execution flow in Python loops and conditionals.
Which THREE of the following statements about Python operators are true?
Correct.
Why this answer
Option A is correct because the `not` operator is a logical operator in Python that returns the Boolean negation of its operand: if the operand is `True`, `not` returns `False`, and vice versa. This is fundamental to Boolean logic and conditional expressions in Python.
Exam trap
Python Institute often tests the Python 3-specific change that the `/` operator always returns a float, trapping candidates who remember the Python 2 behavior where `/` performed integer division on integers.
A list of numbers is defined as nums = [1, 2, 3, 4, 5]. Which expression returns the last element?
Correct negative indexing.
Why this answer
Option B is correct because Python uses zero-based indexing, so the first element is at index 0 and the last element is at index -1. Negative indices count from the end of the list, so nums[-1] directly accesses the last element (5) without needing to know the list length.
Exam trap
The trap here is that candidates often forget Python's zero-based indexing and mistakenly think the last element is at index equal to the list length (e.g., nums[5]), or they confuse negative indexing and pick nums[-2] thinking it refers to the last element.
How to eliminate wrong answers
Option A is wrong because it attempts to access index 5, which is out of range for a list of length 5 (valid indices are 0 through 4), and will raise an IndexError. Option C is wrong because nums[0] returns the first element (1), not the last. Option D is wrong because nums[-2] returns the second-to-last element (4), not the last.
A program uses a for loop to double each element in a list: numbers = [1, 2, 3, 4, 5]; for num in numbers: num = num * 2. After execution, numbers remains unchanged. Why?
Correct: num = num * 2 just rebinds num, not the list.
Why this answer
The loop variable num is a reference to the element in the list, but reassigning num merely reassigns the variable, not the list element. Option B is correct.
A beginner writes: x = '10'; y = 20; print(x + y). What happens?
Incompatible types for +.
Why this answer
Option A is correct because Python's type system does not allow implicit concatenation of a string and an integer. The variable `x` is a string (`'10'`), and `y` is an integer (`20`). The `+` operator with these types triggers a `TypeError: unsupported operand type(s) for +: 'int' and 'str'` (or vice versa), as Python refuses to guess the programmer's intent.
Exam trap
The trap here is that candidates often expect Python to behave like JavaScript or PHP, which implicitly coerce types, but Python strictly requires explicit type conversion for mixed-type operations.
How to eliminate wrong answers
Option B is wrong because it assumes Python will implicitly convert the string to an integer and perform numeric addition, which Python does not do for mixed types. Option C is wrong because it treats the `+` operator as a literal string concatenation in the output, but Python evaluates expressions, not printing the source code. Option D is wrong because it assumes Python will implicitly convert the integer to a string and concatenate them as `'10' + '20'` → `'1020'`, but Python raises a TypeError instead of performing implicit type coercion.
A developer writes: num = input('Enter a number: '); result = num * 2; print(result). If the user enters 5, what is the output?
String '5' multiplied by 2 gives '55'.
Why this answer
Option D is correct because the `input()` function always returns a string. When the user enters '5', `num` is the string '5', not the integer 5. The `*` operator on a string performs repetition, so `'5' * 2` produces '55', which is printed as 55.
Exam trap
Python Institute often tests the misconception that `input()` returns a numeric type when the user types digits, leading candidates to expect arithmetic multiplication instead of string repetition.
How to eliminate wrong answers
Option A is wrong because Python does not raise an error when multiplying a string by an integer; it performs string repetition. Option B is wrong because it assumes `input()` returns an integer, but it returns a string, so numeric multiplication does not occur. Option C is wrong because it shows the raw expression `'5' * 2` as output, but `print()` outputs the resulting string '55', not the expression.
Which data type is the result of: value = 10 // 3?
Correct: // with two ints returns int.
Why this answer
The // operator in Python performs floor division, which divides the left operand by the right operand and returns the largest integer less than or equal to the result. Since both 10 and 3 are integers, the result is an integer (3), not a float. Therefore, the data type of value is int.
Exam trap
Python Institute often tests the distinction between / (true division returning float) and // (floor division returning int), trapping candidates who assume all division in Python returns a float.
How to eliminate wrong answers
Option A is wrong because floor division (//) with integer operands always returns an int, not a float; a float result would require the / operator (true division). Option B is wrong because the result is a numeric value, not a string; str would only be produced by explicit conversion or string concatenation. Option D is wrong because the result is a numeric integer, not a Boolean; bool would only be returned by comparison operators (e.g., ==, >) or logical operations.
Arrange the steps to read data from a text file in Python.
Drag steps to the numbered slots on the right, or tap a step then tap a slot.
Why this order
File reading involves opening, reading, processing, and closing the file.
What is the output of the following code? def greet(name, greeting='Hello'): print(greeting, name) greet('Alice')
Correct because the default greeting is used.
Why this answer
The function `greet` has a default parameter `greeting='Hello'`. When called with only one argument (`'Alice'`), the default value is used for `greeting`, so the output is `Hello Alice`. The `print` function outputs both arguments separated by a space.
Exam trap
Python Institute often tests whether candidates understand that default parameters are used when the corresponding argument is omitted, leading to the misconception that only the default value is printed or that a syntax error occurs.
How to eliminate wrong answers
Option A is wrong because it omits the name argument; the function prints both the greeting and the name, not just the greeting. Option C is wrong because the function definition is syntactically valid (default parameters are allowed in Python) and the call with one argument matches the required parameter. Option D is wrong because it only prints the name, ignoring the default greeting that is explicitly printed.
What does the following code print? text = 'Hello World'; print(text.replace('o', '0').upper())
String methods are applied left to right: replace then upper.
Why this answer
Option A is correct: replace 'o' with '0' gives 'Hell0 W0rld', then .upper() converts to uppercase: 'HELL0 W0RLD'. Option B does not replace o. Option C does not uppercase.
Option D is lowercase with replace.
What is the output of the following dictionary comprehension? {x: x**2 for x in range(3)}
Correct.
Why this answer
The dictionary comprehension `{x: x**2 for x in range(3)}` iterates over `x` values 0, 1, and 2 (from `range(3)`). For each `x`, it creates a key-value pair where the key is `x` and the value is `x**2` (x squared). This produces `{0: 0**2, 1: 1**2, 2: 2**2}`, which evaluates to `{0:0, 1:1, 2:4}`.
Exam trap
Python Institute often tests whether candidates remember that `range(3)` starts at 0, not 1, and that `0**2` equals 0, not an omitted or undefined value, causing many to drop the first key-value pair or miscalculate the square of 1.
How to eliminate wrong answers
Option B is wrong because it incorrectly maps each `x` to `x+1` (0→1, 1→2, 2→3), which is not what `x**2` computes. Option C is wrong because it shows `1:2` instead of `1:1`, likely confusing `x**2` with `x*2` (multiplication) or miscomputing `1**2` as 2. Option D is wrong because it omits the key `0` entirely, which would only happen if the comprehension started from `range(1,3)` or if the candidate mistakenly thought `0**2` is undefined or should be skipped.
Which THREE of the following are valid dictionary methods? (Choose three.)
values returns a view of dictionary values.
Why this answer
get, keys, and values are valid dictionary methods. push and append are not dictionary methods.
You are a developer in a company that runs a Python script daily to generate reports. The script uses the os module to list files in a directory and process each. Recently, after a server migration, the script fails with 'PermissionError: [Errno 13] Permission denied'. The script runs under a service account that has read/write access to most folders, but the migration changed the permissions on certain subdirectories. The error is intermittent, occurring only for some files. You need to fix the script to continue processing other files even if one fails. Which approach should you take?
Selective exception handling allows graceful continuation.
Why this answer
Option C is correct: embedding the file processing inside a try block and catching PermissionError specifically allows the loop to continue. Option A is wrong because checking permissions manually across all directories is error-prone and platform-dependent. Option B is wrong because ignoring all errors without distinction could mask other critical issues.
Option D is wrong because running the script as a different user may solve all permission issues but is an overreaction and may not be allowed.
A script uses the input() function to get a user's age: age = input('Enter age: '). Later it computes age > 18. This raises a TypeError. What is the root cause?
input() returns string; convert to int first.
Why this answer
Option C is correct because the `input()` function in Python always returns a string, regardless of what the user types. When the user enters their age, the variable `age` holds a string like '25', not an integer. Comparing a string to an integer with the `>` operator raises a `TypeError` because Python does not automatically convert strings to numbers for comparison.
Exam trap
Python Institute often tests the misconception that `input()` returns a numeric type when the user types a number, or that Python automatically converts strings to integers for comparison, leading candidates to overlook the need for explicit type conversion.
How to eliminate wrong answers
Option A is wrong because the `input()` function can read numbers, but it reads them as strings — it does not convert them to numeric types. Option B is wrong because the variable `age` is not automatically converted to `int`; Python requires explicit conversion using `int()` or `float()`. Option D is wrong because the `>` operator is valid for strings (it performs lexicographic comparison), but the error arises from comparing a string to an integer, not from the operator being invalid for strings.
Refer to the exhibit. What is the output when the following code is executed: print(calculate_discount(100, 0.6))
The print statement outputs the message, then the function returns 100 which is printed.
Why this answer
The discount 0.6 > 0.5, so it prints 'Discount too high' and returns price (100), then the print outputs 100.
Refer to the exhibit. What is the most likely cause of this error?
This is the typical cause of a NameError in Python.
Why this answer
A NameError occurs when a variable is referenced before it has been assigned a value. The variable 'x' has not been defined.
Which TWO of the following are valid Python data types?
String type.
Why this answer
Option B (str) is correct because Python uses 'str' as its built-in type for textual data, which is a sequence of Unicode characters. This is a fundamental data type in Python, distinct from other languages that might use 'string' or 'char'.
Exam trap
Python Institute often tests the distinction between Python's built-in types and types from other languages or modules, so candidates mistakenly choose 'real' (from mathematics) or 'char' (from C/Java) because they assume Python uses the same terminology.
A list contains strings and numbers: items = ['apple', 10, 'banana', 20]. A programmer wants to create a new list that contains only the strings. Which approach is correct?
Correct, though isinstance is preferred.
Why this answer
Option C is correct because `type(item) == str` directly compares the type of each item to the `str` type object, which returns `True` for strings and `False` for numbers. This is a valid and explicit way to filter the list comprehension to only include string elements.
Exam trap
Python Institute often tests the distinction between comparing a type object to a string literal (e.g., `type(item) is 'str'`) versus comparing to the actual type object (e.g., `type(item) == str`), trapping candidates who mistakenly think `'str'` is the same as `str`.
How to eliminate wrong answers
Option A is wrong because `isdigit()` is a string method that checks if a string consists only of digits; it would raise an `AttributeError` when called on an integer (e.g., 10) since integers do not have an `isdigit()` method. Option B is wrong because `type(item) is 'str'` compares the type object to a string literal `'str'`, which will always be `False` since `type(item)` returns a type object (e.g., `<class 'str'>`), not a string.
A developer writes the following code: x = 5; y = 2; print(x // y). What is the output?
Floor division of 5 by 2 yields 2.
Why this answer
The floor division operator (//) in Python returns the largest integer less than or equal to the result of the division. Since 5 divided by 2 equals 2.5, the floor is 2, and the result is an integer (int) because both operands are integers. Therefore, the output is 2.
Exam trap
Python Institute often tests the distinction between floor division (//) and true division (/), trapping candidates who confuse the two operators or forget that integer operands produce an integer result with //.
How to eliminate wrong answers
Option A is wrong because 1 would be the result of integer division only if the quotient were truncated toward zero (as in C/C++ with negative numbers) or if the calculation were 5 // 3; here 5 // 2 yields 2, not 1. Option C is wrong because floor division with two integers returns an integer, not a float; 2.0 would only appear if at least one operand were a float (e.g., 5.0 // 2). Option D is wrong because 2.5 is the result of true division (/) not floor division (//); the // operator always discards the fractional part.
A company stores employee data as a list of dictionaries. Each dictionary has keys 'name' and 'age'. Which code correctly counts employees older than 30?
Correctly increments count for each employee over 30.
Why this answer
Option C is correct because it uses a simple `for` loop to iterate directly over each dictionary in the `employees` list, checks if the value of the `'age'` key is greater than 30, and increments the counter accordingly. This is the most Pythonic and readable approach for counting elements that satisfy a condition.
Exam trap
Python Institute often tests the distinction between creating a filtered list and counting elements, so the trap here is that option D looks correct but produces a list instead of a numeric count, which is a subtle but critical difference.
How to eliminate wrong answers
Option A is wrong because it counts employees whose age is <= 30 (the condition is reversed) and uses an index-based loop, which is unnecessarily complex. Option B is wrong because it never initializes `count` to 0 (it would raise a `NameError` or use an undefined variable) and also uses a while loop with manual indexing, which is error-prone. Option D is wrong because it creates a list of dictionaries for employees older than 30, not a count; to get the count, you would need to wrap it in `len()`.
Which THREE of the following statements about Python operators are correct?
Correct; e.g., 2**3 = 8.
Why this answer
Option A is correct because the ** operator in Python is used for exponentiation, raising the left operand to the power of the right operand. For example, 2 ** 3 evaluates to 8. This is a fundamental arithmetic operator defined in Python's operator precedence.
Exam trap
Python Institute often tests the distinction between the / operator (always returns float) and the // operator (returns int when both operands are ints), and the misconception that % returns the quotient instead of the remainder.
A junior developer writes a Python script to sum all numbers greater than 10 from a list. The code is: numbers = [5, 12, 8, 15, 3] total = 0 for num in numbers: if num > 10: total = total + 1 print(total) The output is 2, but the expected sum is 27 (12+15). Which change will produce the correct output?
Adds the number value instead of 1, giving the correct sum.
Why this answer
Option B is correct because the original code increments `total` by 1 for each qualifying number, counting them instead of summing their values. Changing `total = total + 1` to `total += num` adds the actual number to the accumulator, producing the correct sum of 12 + 15 = 27.
Exam trap
The trap here is that candidates often confuse counting with summing — they see `total = total + 1` and think it's accumulating values, but it actually increments by a constant, not by the variable `num`.
How to eliminate wrong answers
Option A is wrong because changing `total = 0` to `total = []` makes `total` a list, and `total + 1` would cause a TypeError (cannot concatenate list and int). Option C is wrong because changing `if num > 10:` to `if num >= 10:` would include the number 10 (if present), but the list has no 10, so it does not fix the core issue of counting instead of summing. Option D is wrong because `range(numbers)` is invalid — `range()` expects integer arguments, not a list; this would raise a TypeError.
Which three of the following are true about Python lists? (Choose three.)
True; lists are heterogeneous.
Why this answer
Lists are mutable, can hold mixed data types, support slicing, and len() returns the number of elements. They cannot be used as dictionary keys because they are unhashable.
A developer writes: total = 2 ** 3 + 4. What is the value of total?
Correct: 2**3 = 8, 8+4 = 12.
Why this answer
In Python, the exponentiation operator (**) has higher precedence than addition (+). Therefore, 2 ** 3 is evaluated first, yielding 8. Then 8 + 4 equals 12.
Option B is correct.
Exam trap
Python Institute often tests operator precedence by combining exponentiation with addition, trapping candidates who mistakenly evaluate left-to-right or confuse ** with multiplication.
How to eliminate wrong answers
Option A is wrong because it incorrectly assumes that addition is performed before exponentiation, computing 2 ** (3 + 4) = 2 ** 7 = 128, or perhaps misinterprets the expression as (2 ** 3) * 2 = 16. Option C is wrong because it likely results from a miscalculation such as 2 ** 3 = 6 (instead of 8) plus 4 = 10, or from misapplying operator precedence. Option D is wrong because it represents the result of 2 * 3 + 4 = 10, confusing the exponentiation operator with multiplication.
What is the output of this code?
Modifying dict while iterating over its items raises RuntimeError.
Why this answer
Option A is correct because modifying a dictionary's size (adding or deleting keys) during iteration over its keys, values, or items raises a RuntimeError. In this code, the loop iterates over the dictionary's keys while deleting them, which changes the dictionary's size and triggers the exception.
Exam trap
Python Institute often tests the misconception that deleting keys during iteration will silently skip or partially modify the dictionary, but Python explicitly forbids size changes during iteration to enforce safe iteration contracts.
How to eliminate wrong answers
Option B is wrong because the code never completes execution to produce an empty dictionary; the RuntimeError is raised before any deletion finishes. Option C is wrong because the loop is interrupted by the exception before it can delete all keys except 'b', so no partial result is returned. Option D is wrong because the original dictionary is never returned; the iteration is aborted at the first deletion, and the exception prevents any output.
A junior developer created a Python script to calculate the average of three quiz scores entered by the user. The script reads three numbers using input(), converts them to float, calculates the sum, and divides by 3. However, when a user enters a non-numeric value like 'ten', the script crashes with a ValueError. The developer needs to modify the script to handle such errors gracefully, allowing the user to re-enter the invalid input until a valid number is provided. Which approach should the developer implement to meet this requirement most effectively while following Python best practices?
This is the standard pattern for input validation, handling both integers and floats.
Why this answer
Option A is correct because it uses a `while True` loop with a `try` block to repeatedly attempt conversion of user input to `float`. If a `ValueError` is raised (e.g., for non-numeric input like 'ten'), the exception is caught, an error message is printed, and the loop continues until valid input is provided. This pattern follows Python best practices for input validation by separating the conversion logic from the loop control and avoiding reliance on fragile string checks like `.isdigit()`.
Exam trap
Python Institute often tests the distinction between a single try-except (which only catches one error) and a looped try-except (which retries until valid input is given), leading candidates to pick Option C because it mentions 'try-except' and 'looping' but lacks the explicit `while True` structure required for repeated prompting.
How to eliminate wrong answers
Option B is wrong because `.isdigit()` only checks for digits (0-9) and will reject valid float inputs like '3.14' or '-5', causing false negatives; it also does not handle negative numbers or decimal points. Option C is wrong because it describes a generic try-except loop but lacks the explicit `while True` structure needed to repeatedly prompt the user until valid input is entered — without the loop, the script would only catch the error once and then continue, potentially crashing again. Option D is wrong because returning a default value of 0 silently masks invalid input, which can lead to incorrect calculations and does not meet the requirement of allowing the user to re-enter the invalid input.
Refer to the exhibit. What is the output?
Correct. The original dictionary is mutated.
Why this answer
In Python, dictionaries are mutable and passed by reference. The function modifies the original dictionary by setting d['key'] = 'new_value'. Then it reassigns the local variable d to a new dictionary, which does not affect the outer variable my_dict.
So my_dict becomes {'key': 'new_value'}.
A developer writes a loop to sum numbers from 1 to 10. The code outputs 55, but the expected sum is 55. However, the loop uses a range that includes 0. Which range should be used to achieve the correct sum?
Correctly generates 1..10
Why this answer
Option B (range(1,11)) is correct because range(start, stop) generates numbers from start inclusive to stop exclusive. To sum numbers 1 through 10, the range must start at 1 and end at 11 (so 10 is included). The loop that used range(0,11) included 0, but since adding 0 does not change the sum, the output was still 55 — however, the question asks for the range that achieves the correct sum without including unnecessary values.
Exam trap
Python Institute often tests the exclusive nature of range()'s stop parameter, tricking candidates into thinking range(1,10) includes 10 or that range(0,11) is equivalent to range(1,11) when the sum is unchanged by zero.
How to eliminate wrong answers
Option A is wrong because range(0,11) includes 0, which is unnecessary and could cause issues if the sum were expected to exclude zero (though here it didn't affect the result). Option C is wrong because range(0,101) would sum numbers 0 through 100, producing 5050, not 55. Option D is wrong because range(1,10) generates numbers 1 through 9, missing 10, so the sum would be 45, not 55.
Refer to the exhibit. What is the output?
Correct. First 'A', then 'C', then 'D'.
Why this answer
The function exception_test has a try-except-finally block. The division 1/0 raises ZeroDivisionError, which is caught by the first except clause, printing 'A'. Then the finally clause executes, printing 'C'.
After the function returns, the script prints 'D'. So the output is A, C, D each on separate lines.
Which THREE of the following expressions evaluate to the integer 1? (Select three.)
Truncates float to integer 1.
Why this answer
Option A is correct because `int(1.0)` explicitly converts the float `1.0` to an integer by truncating the decimal part, yielding the integer `1`. This is a standard type conversion function in Python.
Exam trap
Cisco often tests the distinction between Boolean `True` and the integer `1`, and the fact that arithmetic with a float operand always yields a float, not an integer.
What does the following code output? for i in range(3): if i == 1: continue; print(i, end=' ')
i=1 is skipped.
Why this answer
Option B is correct: range(3) gives 0,1,2. When i==1, continue skips the print, so prints 0 and 2. Option A prints all.
Option C prints only 1. Option D prints only 0.
Consider code: def outer(): x = 1 def inner(): nonlocal x x = 2 inner() print(x) outer() What is printed?
nonlocal allows modification.
Why this answer
Option D is correct: inner modifies x via nonlocal, so x becomes 2. Option A would be if inner had local x. Option B if x = 2 not executed.
Option C if inner didn't affect outer.
A junior developer is writing a script to process a list of user IDs: ids = [101, 102, 103, 104]. The goal is to create a new list where each ID is increased by 10, without modifying the original list. The developer writes: new_ids = ids.append(10). However, the output shows None. The developer needs to correctly create the new list. Which code should the developer use to achieve this?
List comprehension creates a new list with increments, original unchanged.
Why this answer
Option A uses a list comprehension to create a new list with each element incremented, leaving the original unchanged. Option B tries to add a list and integer, which raises TypeError. Option C returns a map object, not a list.
Option D modifies the original list in place, which is not desired.
A company is developing a data processing pipeline that must handle large datasets efficiently. They notice that using a list comprehension to filter data is slower than expected. Which alternative approach would likely improve performance?
Generators yield items one by one and avoid storing the entire list, reducing memory and often improving speed.
Why this answer
Generator expressions are memory efficient and can be faster for large datasets because they produce items lazily without building the entire list.
A company runs a Python script on a server that monitors network traffic. The script reads a configuration file containing a threshold value as a string, e.g., '0.85'. The script compares this threshold to a calculated load average (float). The developer writes: threshold = config['threshold']; if load > threshold: alert(). The alert never triggers even when load exceeds 0.85. The config file is correctly parsed. What is the most likely cause and solution?
Correct: string vs float comparison is false.
Why this answer
Option B is correct because the configuration file stores the threshold as a string ('0.85'), but the comparison operator (>) in Python compares strings lexicographically, not numerically. When load is a float (e.g., 0.9), comparing a float to a string always returns False in Python 3 (raising a TypeError in some contexts, but here the comparison silently fails because the string is not converted). The fix is to explicitly convert the threshold to a float using float(config['threshold']) before the comparison.
Exam trap
Python Institute often tests the misconception that Python will automatically coerce a string to a number in comparisons, or that a TypeError will be raised, when in fact the comparison silently fails due to type mismatch.
How to eliminate wrong answers
Option A is wrong because the question states 'The config file is correctly parsed,' so a misspelled key would cause a KeyError, not a silent failure of the comparison. Option C is wrong because a try-except block would catch a TypeError if one occurred, but the core issue is a logical error in data type handling, not an exception; the comparison simply returns False without raising an error. Option D is wrong because the load variable is explicitly described as a float (calculated load average), and converting it to a string would make the comparison even more incorrect (string vs. string comparison would still be lexicographic).
A developer writes code to calculate the area of a rectangle and prints it. The code is: length = 10 width = 5 area = length * width print('The area is', area) If the width is accidentally assigned a string '5', what error will occur?
Multiplying int and str causes TypeError.
Why this answer
Option A is correct because multiplying an integer by a string results in a TypeError. Option B is wrong because NameError occurs only when a variable is not defined. Option C is wrong because SyntaxError occurs for invalid syntax.
Option D is wrong because ValueError occurs for invalid value conversion.
Which of the following is a valid floating-point literal in Python?
Decimal floating-point literal.
Why this answer
Option C is correct because `3.14` is a literal decimal number with a fractional part, which Python interprets as a floating-point value. Floating-point literals in Python can be written in decimal notation with a dot, or in scientific notation (e.g., `1e3`), but `3.14` is the only option here that is both a numeric literal and explicitly a float.
Exam trap
Python Institute often tests the distinction between numeric literals and string literals, and the trap here is that candidates may confuse a string like `'3.14'` with a float, or think that hexadecimal `0xFF` is a float because it contains letters, when in fact it is an integer.
How to eliminate wrong answers
Option A is wrong because `1e3` is a valid floating-point literal (it represents 1000.0 in scientific notation), but the question asks for a valid floating-point literal and this option is not marked as correct; however, the trap is that `1e3` is actually valid, so candidates might think it is wrong when it is not—but in this set, C is the only one that is unambiguously a float literal without scientific notation. Option B is wrong because `'3.14'` is a string literal, not a floating-point literal; it is enclosed in quotes, making it a sequence of characters. Option D is wrong because `0xFF` is an integer literal in hexadecimal notation (255 in decimal), not a floating-point literal; Python does not allow hexadecimal notation for floats.
A programmer wants to iterate over a list of strings and print each string in uppercase. Which of the following code snippets will accomplish this?
Correct iteration and method call.
Why this answer
Option D is correct because it correctly calls the `upper()` method on each string `item` in the list `my_list` and prints the result. The `upper()` method returns a new string with all characters converted to uppercase, and the `print()` function outputs that value to the console.
Exam trap
The trap here is that candidates often forget to include parentheses when calling a method (e.g., `item.upper` vs `item.upper()`), or they mistakenly think `upper()` modifies the string in place, leading them to print the original variable instead of the returned value.
How to eliminate wrong answers
Option A is wrong because `item.upper` without parentheses does not call the method; it merely references the method object, so nothing is printed. Option B is wrong because `item.upper()` returns a new string but does not modify `item` in place, and the subsequent `print(item)` prints the original lowercase string, not the uppercase version. Option C is wrong because `my_list[i]` attempts to use an integer index `i` as a list index, but `i` is a string from the list, not an integer; this will raise a `TypeError`.
Given the code: x = [1, 2, 3] y = x y.append(4) print(x) What is the output?
Correct due to aliasing.
Why this answer
Option C is correct because in Python, variables hold references to objects, not the objects themselves. When `y = x` is executed, both `x` and `y` point to the same list object in memory. The `y.append(4)` method modifies that shared list in-place, so the change is reflected when `x` is printed, outputting `[1, 2, 3, 4]`.
Exam trap
Python Institute often tests the distinction between variable assignment and object copying, trapping candidates who mistakenly think `y = x` creates a separate copy of the list, leading them to choose option B.
How to eliminate wrong answers
Option A is wrong because no error occurs; the code runs successfully and produces a list. Option B is wrong because it assumes `y = x` creates a copy of the list, but Python does not copy objects on assignment; both variables reference the same mutable list. Option D is wrong because only one element (4) is appended, not two; the value 5 is never added.
Which TWO of the following are valid variable names in Python? (Choose two.)
Valid: letters and digits allowed.
Why this answer
Option B is correct because 'data1' starts with a letter and contains only letters and digits, which is allowed by Python's identifier rules. Python variable names must begin with a letter (a-z, A-Z) or underscore, and can be followed by letters, digits, or underscores.
Exam trap
Python Institute often tests the rule that variable names cannot start with a digit, and candidates mistakenly think digits are allowed anywhere, or they overlook that special characters like $ are invalid in Python (unlike in some other languages like PHP or Perl).
Given x = 5, which of the following assignments will cause a runtime error?
Integer division by zero raises ZeroDivisionError.
Why this answer
Option C is correct because division by zero is undefined in Python, and the floor division assignment operator `//=` with a divisor of 0 raises a `ZeroDivisionError` at runtime. The other operators (`**=`, `-=`, `+=`) perform valid arithmetic on the integer 5 and do not cause errors.
Exam trap
The trap here is that candidates may mistakenly think any operator can handle zero as a divisor or confuse floor division with modulo, but Cisco specifically tests that `//` with a zero divisor raises a runtime error, not a syntax error or silent failure.
How to eliminate wrong answers
Option A is wrong because `x **= 2` raises 5 to the power of 2, resulting in 25, which is a valid integer operation. Option B is wrong because `x -= 3` subtracts 3 from 5, yielding 2, a perfectly legal assignment. Option D is wrong because `x += 2` adds 2 to 5, producing 7, with no error.
Only division by zero triggers a runtime exception.
A system administrator has a Python script that uses a tuple to store immutable configuration parameters, such as server address and port. A new business requirement arises: one of these parameters (the port number) must be changeable at runtime without restarting the script. The other parameters must remain immutable. The administrator wants to minimize changes to the existing codebase and maintain clarity. Which approach best satisfies the requirement while keeping the code maintainable?
A dictionary is mutable and allows easy updates while clearly showing which parameters are changeable.
Why this answer
Option C replaces the tuple with a dictionary for all parameters. Dictionaries are mutable and can be updated easily. This is a clean solution that does not require converting back and forth.
Option A is inefficient and complex. Option B only changes one parameter to a list, but then the tuple still contains a list, which is mutable but awkward. Option D uses a namedtuple, which is still immutable and does not support updates.
A network configuration tool stores device settings in a dictionary where each setting key may have multiple values from different configuration sources. For example, the key 'dns_servers' might have values from the DHCP server and manual configuration. The current implementation simply assigns values: settings[key] = value. If the same key appears multiple times, only the last value is kept, losing previous values. The developer must modify the data structure so that all values for a key are preserved. The solution should be efficient for both adding new values and accessing all values for a key. Which modification is best?
defaultdict automatically creates a list for each new key, simplifying the code and preserving all values.
Why this answer
Option D uses a dictionary where each value is a list, and uses a default factory to create lists automatically. This efficiently preserves multiple values per key. Option A uses a tuple for each value, which is immutable and cannot be appended.
Option B uses a list but does not handle automatic creation; however, the description of option B 'Use a list for each value, appending new values' is essentially the same as D but without the default factory? Actually option B says 'Use a list for each value, appending new values' which is correct in concept, but D explicitly mentions 'with default factory' which is the Pythonic way using defaultdict. Option B may require manual checking if the key exists. So D is more complete.
Option C uses a set, which would eliminate duplicate values, which may not be desired.
Refer to the exhibit. What is the cause of the error?
Python cannot concatenate string and int without conversion.
Why this answer
The error occurs because the `+` operator is being used between a string and an integer, which are incompatible types in Python. Python does not implicitly convert the integer to a string for concatenation; it raises a `TypeError: unsupported operand type(s) for +: 'str' and 'int'`.
Exam trap
Python Institute often tests the misconception that Python will automatically convert types (like JavaScript does), leading candidates to think the code will run without error, when in fact Python raises a TypeError for mixed-type `+` operations.
How to eliminate wrong answers
Option B is wrong because division by zero would raise a `ZeroDivisionError`, not a type-related error. Option C is wrong because no import statement is required for basic arithmetic or string operations in Python; the error is purely about type mismatch. Option D is wrong because the variable is defined (the error message would be `NameError` if it were not), and the actual error is a `TypeError` from using `+` on incompatible types.
You are maintaining a legacy Python 2.7 script that calculates shipping costs. The script reads weight from user input, then calculates cost as weight * 1.5. Recently, the company upgraded to Python 3.9, and now the script raises a TypeError: can't multiply sequence by non-int of type 'float'. The input line is: weight = input('Enter weight: '). You need to fix the script minimally. Which action should you take?
Converts string to float, allowing multiplication.
Why this answer
In Python 3.9, `input()` returns a string, not a number. Multiplying a string by a float raises a TypeError. Option D converts the input to a float immediately, which is the minimal fix because it handles both integer and decimal weights correctly without changing the multiplication logic.
Exam trap
Python Institute often tests the difference between Python 2 and Python 3 `input()` behavior, and the trap here is that candidates might choose `int()` (Option C) thinking weights are always whole numbers, or choose `from __future__` (Option A) without realizing it does not fix the type mismatch in Python 3.
How to eliminate wrong answers
Option A is wrong because `from __future__` imports are for Python 2 compatibility in Python 3, but here the script is already running on Python 3.9 and the issue is type mismatch, not input behavior. Option B is wrong because it converts `weight` to float only in the multiplication line, but `weight` remains a string; this would still fail if `weight` is used elsewhere as a string, and it does not fix the root cause of the input being a string. Option C is wrong because using `int()` would reject decimal weights (e.g., 2.5), causing a ValueError, and the problem statement does not restrict weights to integers.
A program prints a greeting: name = input("Enter name: "); print("Hello, " + name + "!"). If user enters "Alice", what is output?
Correct; exact concatenation.
Why this answer
Option A is correct because the `print` function concatenates the string literals and the variable `name` using the `+` operator exactly as specified. When the user enters "Alice", the expression `"Hello, " + name + "!"` becomes `"Hello, Alice!"` — the space after the comma is part of the first string literal, and the exclamation mark is part of the last string literal, producing the output exactly as shown in option A.
Exam trap
Python Institute often tests whether candidates notice the exact placement of spaces and punctuation in string literals, exploiting the common assumption that Python automatically adds spaces around concatenated values.
How to eliminate wrong answers
Option B is wrong because it shows a space after the exclamation mark (`Alice !`), but the code has no space before the exclamation mark in the string literal `"!"`. Option C is wrong because it omits the space after the comma (`Hello,Alice!`), but the first string literal `"Hello, "` includes a trailing space. Option D is wrong because it adds an extra space before the exclamation mark (`Alice !`), which is not present in the concatenation; the code joins `name` directly to `"!"` with no intervening space.
What is the output of the following code? ```python print('Hello', 'World', sep='-') ```
Correct. The dash separates the two words.
Why this answer
The `print()` function's `sep` parameter specifies the separator between multiple arguments. By default, `sep` is a space, but here it is explicitly set to `'-'`, so the output joins 'Hello' and 'World' with a hyphen, producing 'Hello-World'. Option D is correct because the hyphen is placed directly between the two strings without any extra spaces.
Exam trap
The trap here is that candidates often assume the default space separator is used or misread the hyphen as a space, leading them to choose 'Hello World' instead of recognizing the explicit `sep='-'` override.
How to eliminate wrong answers
Option A is wrong because it omits the separator entirely, as if `sep=''` were used, but the default or specified separator is not empty. Option B is wrong because it adds spaces around the hyphen, which would only happen if the separator included spaces or if extra arguments were printed; the `sep` parameter does not add spaces unless they are part of the separator string. Option C is wrong because it uses a space as the separator, which is the default behavior, but the code explicitly overrides it with `sep='-`.
A beginner writes: x = 10; y = 3; print(x // y). What is the output?
Floor division returns the integer part, 3.
Why this answer
The // operator performs floor division, returning the integer quotient. 10 // 3 equals 3.
A developer needs to store a large collection of unique user IDs (integers) and quickly check if a new ID already exists. Which data type is most appropriate for this task?
Correct: set provides fast membership and uniqueness.
Why this answer
A set is the most appropriate data type because it stores unordered collections of unique elements and provides O(1) average-time complexity for membership testing using the `in` operator. This makes it ideal for quickly checking if a new user ID already exists without needing to manage keys or maintain order.
Exam trap
Python Institute often tests the misconception that a dict is required for any kind of lookup, when in fact a set is the correct choice for membership testing without associated data.
How to eliminate wrong answers
Option A is wrong because a dict stores key-value pairs, which adds unnecessary overhead when only the IDs themselves need to be stored and checked. Option B is wrong because a list requires O(n) linear search to check membership, which is inefficient for large collections. Option D is wrong because a tuple is immutable and does not support efficient membership testing; it also cannot be modified to add new IDs after creation.
A network engineer writes a script to validate IP addresses. The script checks each octet and prints 'Valid' if all octets are between 0 and 255, otherwise 'Invalid'. However, the script always prints 'Invalid' for valid IPs. The code uses a for loop with an else clause. Which logical error is likely?
Common misunderstanding of for-else; else runs on normal completion.
Why this answer
Option D is correct because in Python, a `for` loop's `else` clause executes only when the loop completes normally (i.e., without hitting a `break`). The engineer likely intended the `else` to run when an invalid octet is found (triggering a `break`), but instead the `else` runs when all octets are valid and the loop finishes without breaking, causing the script to always print 'Invalid' when the validation logic is inverted.
Exam trap
Python Institute often tests the `for...else` behavior by reversing the expected logic, trapping candidates who assume `else` runs only on error or break, rather than on normal loop completion.
How to eliminate wrong answers
Option A is wrong because if the list of octets were not properly split, the script would likely raise an error or produce incorrect comparisons, not consistently print 'Invalid' for valid IPs. Option B is wrong because using 'or' instead of 'and' in the condition would cause the check to pass if any octet is within range, leading to false 'Valid' prints, not always 'Invalid'. Option C is wrong because incorrect indentation of the `else` clause would cause a syntax error or change the block association, not a consistent logical error where the `else` always runs.
A developer is writing a simple number guessing game. The computer picks a random number between 1 and 100, and the user keeps guessing until correct. The developer implements: secret = random.randint(1,100) guess = 0 while guess != secret: guess = int(input("Guess: ")) if guess == secret: print("Correct!") else: print("Wrong, try again.") The game works, but the developer notices that if the user enters something that is not an integer, the program crashes. Which modification ensures the program handles non-integer input gracefully?
Catches ValueError and allows reprompt.
Why this answer
Option C is correct because wrapping the `int(input(...))` in a `try-except` block catches the `ValueError` that occurs when the user enters a non-integer string. This allows the program to handle the error gracefully (e.g., by printing a message and continuing the loop) instead of crashing. The other options do not prevent the crash when `int()` receives invalid input.
Exam trap
Python Institute often tests the distinction between input validation (like `isdigit()`) and exception handling (`try-except`), where candidates mistakenly believe checking for digits is sufficient, ignoring that `int()` can still fail on valid-looking strings like '-5' or ' 10'.
How to eliminate wrong answers
Option A is wrong because using a `while True` loop with `break` does not handle the `ValueError` from `int()`; it only changes the loop structure, not the input conversion safety. Option B is wrong because changing `guess` to a string would prevent integer comparison with `secret`, breaking the game logic entirely. Option D is wrong because checking if the input is a digit (e.g., `input().isdigit()`) only works for positive integers and fails for negative numbers, floats, or other valid integer representations like `-5` or `+3`, and still requires a conversion that could raise an error.
You are a developer in a data science team using Python for analysis. A colleague wrote a script that downloads a CSV file from a URL, parses it using csv.DictReader, and prints summary statistics. The script works on his machine but fails on yours with 'UnicodeDecodeError: 'utf-8' codec can't decode byte 0xe9 in position 100: invalid continuation byte'. The CSV file contains text in multiple languages, including French accents. The error occurs in the csv.DictReader call. You need to fix the script to work on any machine. Which approach is best?
latin-1 can decode any byte, preserving data, though may not be accurate for all characters.
Why this answer
Option C is correct: specifying encoding='latin-1' or another common encoding like 'ISO-8859-1' can handle the byte, but it's better to detect the encoding. However, among the options, opening with a different encoding (e.g., 'utf-8-sig' or 'latin-1') is practical. Option A is wrong because 'utf-8-sig' handles BOM but not arbitrary invalid bytes.
Option B is wrong because binary mode would require manual decoding. Option D is wrong because suppressing the error with 'replace' changes characters silently, potentially corrupting data. The best practice is to use the correct encoding (e.g., 'utf-8' if the file is actually UTF-8, but if it's not, using 'latin-1' is a fallback).
However, the most robust is to read with binary mode and then decode with error handling, but among the given, opening with a more permissive encoding like 'latin-1' is a reasonable fix if the data is from a Windows system. Option C is the closest.
Which THREE of the following are correct ways to create a list containing the numbers 1, 2, 3? (Choose three.)
List comprehension.
Why this answer
Options A, B, and D are correct. Option A uses square brackets. Option B uses the list() constructor with a tuple.
Option D uses a generator expression converted to list. Option C is wrong because (1,2,3) is a tuple, not a list. Option E is wrong because it creates a set.
A function is defined as: def func(*args, **kwargs): print(args, kwargs). It is called as func(1, 2, a=3, b=4). What is printed?
Correct: args becomes (1,2), kwargs becomes {'a':3,'b':4}.
Why this answer
*args collects positional arguments into a tuple, **kwargs collects keyword arguments into a dictionary. Option A is correct. Option B is incorrect because it mixes syntax.
Option C is incorrect because args is a tuple, not a list. Option D is incorrect because no TypeError occurs.
A developer is writing a script to process user input. The script should repeatedly ask for a number until a valid integer is entered. Which loop structure is most appropriate?
A while loop can run until a condition is met, ideal for input validation.
Why this answer
A while loop with a condition that checks if the input is valid is the standard approach for input validation.
Evaluate the expression: not (True or False) and (False or True). What is the result?
Step by step: not (True) and (True) = False.
Why this answer
The expression is evaluated step by step: first, `True or False` evaluates to `True`; then `False or True` evaluates to `True`; the `not` operator negates the first `True` to `False`; finally, `False and True` evaluates to `False`. Therefore, the correct answer is C.
Exam trap
The trap here is that candidates often forget the precedence of `not` over `and` and `or`, or misapply short-circuit evaluation, leading them to incorrectly compute the result as `True`.
How to eliminate wrong answers
Option A is wrong because the expression uses valid Python operators and boolean values, so no SyntaxError occurs. Option B is wrong because the result is not True; the `not` operator negates the first `True` to `False`, and the `and` operator then yields `False`. Option D is wrong because the expression does not involve any function or operation that returns `None`; it produces a boolean value.
Refer to the exhibit. What is the output?
Correct. First loop prints all three, second loop prints only first then breaks.
Why this answer
The first for loop iterates over all yielded values: 1,2,3 each on separate lines. Then '---' is printed. The second for loop starts a new generator, yields 1, prints it, then breaks.
So output is 1,2,3,---,1 each on separate lines.
A programmer needs to check if at least one element in a list of booleans flags is True. Which expression correctly does this?
Also correct but less Pythonic; however both A and C are correct. I need to make only one correct. Replace C with a wrong option.
Why this answer
Option A is correct because the `in` operator checks membership in a list; `True in flags` returns `True` if at least one element in the list `flags` is the boolean `True`. Option D is also correct because the built-in `any()` function returns `True` if any element in the iterable is truthy, which for a list of booleans means at least one `True`.
Exam trap
Python Institute often tests the distinction between `any()` and `all()` functions, and the trap here is that candidates may confuse `any()` with a list method (like `.any()` in NumPy) or incorrectly think `all()` checks for at least one `True`.
How to eliminate wrong answers
Option B is wrong because `all(flags)` returns `True` only if every element in the list is truthy (i.e., all are `True`), not if at least one is `True`. Option C is wrong because `flags.any()` is not a valid method for Python lists; the `any()` function is a built-in, not a list method, so this would raise an `AttributeError`.
A developer wrote: x = 10; y = 5; x += y * 2. What are the values of x and y after execution?
Correct: y*2=10, x+=10 yields 20, y unchanged.
Why this answer
Option C is correct because the expression `x += y * 2` is evaluated as `x = x + (y * 2)`. Given `x = 10` and `y = 5`, `y * 2` equals 10, then `x + 10` equals 20, so `x` becomes 20. The value of `y` remains unchanged at 5 because the assignment operator `+=` only modifies `x`.
Exam trap
Cisco often tests the misconception that `x += y * 2` means `(x + y) * 2`, leading candidates to pick 30, or that `y` is also modified, causing confusion with the assignment operator's scope.
How to eliminate wrong answers
Option A is wrong because it incorrectly assumes `x += y * 2` is evaluated as `(x + y) * 2`, which would give 30, but then mistakenly halves it to 15; the correct evaluation order gives 20. Option B is wrong because it assumes the multiplication applies to the entire right-hand side as `(x + y) * 2`, yielding 30, but Python's operator precedence dictates `*` binds tighter than `+=`, so only `y * 2` is multiplied. Option D is wrong because it incorrectly changes `y` to 10, but the `+=` operator only updates `x` and does not modify `y`.
Which TWO of the following are valid Python variable names?
Underscore allowed at start.
Why this answer
Option A (_count) is correct because Python allows variable names to start with an underscore, and it contains only letters, underscores, and digits. Underscore-prefixed names are commonly used for internal or private variables, but they are syntactically valid.
Exam trap
Python Institute often tests the rule that hyphens and spaces are invalid in variable names, as candidates may confuse Python with other languages (like Lisp or CSS) where hyphens are allowed, or mistakenly think spaces can be used for readability.
Page 1 of 7
Page 2Practice PCEP by domain
Target a specific domain to shore up weak areas.