One question at a time. Build your PCEP understanding.
First 50 of 200 questions. Each one lists the choices, the correct answer, and an explanation. The checker at the top of this page saves progress in this browser when it is available.
Continue in the practice tool above to load more questions, 50 at a time.
A Python identifier may contain letters, digits, and underscores, but it cannot begin with a digit, contain a hyphen, or be a reserved keyword. The name _total2 satisfies all of these rules.
Multiplying a string by an integer repeats the string that many times, with no separator inserted. Thus "py" * 3 produces the single string pypypy.
Calling int() on a float truncates the fractional part toward zero rather than rounding it. Therefore int(3.9) returns the integer 3.
Exponentiation is evaluated first, giving 4 ** 2 = 16. Then multiplication and floor division are evaluated left to right: 3 * 16 = 48 and 48 // 8 = 6, and finally 2 + 6 = 8.
The // operator gives the floor quotient 3, and the % operator gives the remainder 2. Adding those results produces 5.
The input() function always returns a string containing the characters the user typed. Numeric-looking input must be converted explicitly with int() or float() before arithmetic is performed.
The first condition x > 0 is true, so x becomes 15. Because an if/elif chain stops after the first true branch, the elif test is skipped even though x was originally 5.
The sep argument places a hyphen between the two printed values, and end="!" replaces the usual newline with an exclamation mark. The second print then continues on the same line and appends c.
The loop stops with break when n reaches 3. A while loop's else clause runs only when the loop ends normally, so the break skips it and only the final print executes.
Exponentiation and modulo are evaluated before comparison, so 3 ** 2 < 10 is True and 5 % 2 is 1. The not operator turns 1 into False, and False or True evaluates to True.
A tuple is immutable: once it is created, its elements cannot be replaced, added, or removed. Lists, dictionaries, and sets are mutable container types whose contents can be modified in place. Attempting to assign to a tuple element raises a TypeError.
Python treats numeric zero, empty containers, empty strings, None, and False as falsy. The string "0" is non-empty, the list [0] contains one element, and -1 is a nonzero integer, so all three are truthy.
The + operator requires operands of compatible types. A string and an integer cannot be added, so Python raises a TypeError instead of converting automatically. An explicit conversion such as "3" + str(3) would be required.
Assigning b = a copies the reference to the list, not the list itself, so both names refer to the same object. Calling append through b modifies that shared list. Printing a therefore shows the updated contents [1, 2, 3, 4].
Slicing uses a start index that is included and a stop index that is excluded, with indices counted from 0. In "programming", index 3 is g and index 6 is m, so s[3:7] returns "gram". The character at index 7 is not included.
range(start, stop, step) begins at 1, stops before 10, and increments by 3. The generated values are 1, 4, and 7; the next value, 10, is not less than the stop value. Converting the range with list() materializes those values.
The dict.get method returns the supplied default when the key is absent instead of raising an exception. Because "b" is not in the dictionary, the default 0 is printed. The existing key "a" would have returned 1.
The comprehension iterates over 0, 1, 2, and 3 and keeps only values for which x % 2 is nonzero. Those values are 1 and 3, and each is multiplied by 2. The resulting list is [2, 6].
Default argument values are evaluated once when the function is defined, so the same list object is reused on every call. The first call appends 1 and returns [1]. The second call appends 2 to that same list, returning [1, 2].
The list.sort method sorts the list in place and returns None rather than a new list. The variable result therefore receives None. The built-in sorted function would instead return a new sorted list.
In Python 3, the / operator performs true division, so it always returns a float. Even though 7 divided by 2 has no fractional remainder, the result is 3.5 with type float.
The augmented assignment x -= 3 subtracts 3 from the current value of x and rebinds x to the result. Starting from 10, the new value is 7.
String indexing is zero-based, so word[0] is 'P' and word[1] is the second character, 'y'. The print call displays only that single character.
Assigning x inside change creates a new local variable named x because there is no global declaration. The module-level x remains 5, so the final print shows 5.
list.extend adds each element of the iterable to the end of the list, so the numbers 3 and 4 become separate items. The original list is mutated to [1, 2, 3, 4].
Iterating over a dictionary yields its keys, not its values or key-value pairs. Wrapping the iteration in list produces a list of the keys in insertion order, ['a', 'b'].
Strings are immutable, so assigning to a single character position is not allowed. The statement s[0] = 'A' raises TypeError before any change can occur.
enumerate yields pairs of an index and the corresponding item. With start=1, the first pair is (1, 'a') and the second is (2, 'b'), and print displays each pair with a space.
The first positional argument 1 binds to a, the second argument 3 binds to b, and the remaining arguments 4 and 5 are collected in args. Thus len(args) is 2, and a + b + len(args) equals 1 + 3 + 2 = 6.
The == operator compares list contents, and both lists contain 1 and 2, so the first result is True. The is operator compares object identity; a and b are two distinct list objects, so the second result is False.
Python variable names must start with a letter or underscore and may contain letters, digits, and underscores. They cannot begin with a digit, use keywords such as class, or include hyphens.
The // operator performs floor division, so -7 divided by 2 is -3.5 and is rounded down to the next lower integer, -4. It does not truncate toward zero.
In a multiple assignment, the right-hand side is evaluated first as a tuple and then unpacked. The values b and a are therefore read before either variable is rebound, producing 2 1.
Binary floating-point cannot represent 0.1, 0.2, and 0.3 exactly, so 0.1 + 0.2 is slightly different from 0.3. The comparison therefore evaluates to False, and print displays False.
An if/elif chain tests conditions in order and executes only the first branch whose condition is true. Since 10 > 5 is true, the elif and else branches are skipped entirely, so only A is printed.
range(start, stop, step) begins at start and adds step until it reaches or passes stop, excluding stop itself. Starting at 2 with step 3 gives 2, 5, and 8, so the loop prints those values.
The condition is checked before each iteration. n takes the values 0, 2, 4, and then 6; when n becomes 6, 6 < 5 is false and the loop stops, leaving n equal to 6.
A loop's else clause runs only when the loop terminates normally, not when break exits it. The break occurs when i is 2, so the else block is skipped and the final value of i, 2, is printed.
The increment happens before the if, so the counter still advances when continue skips printing. The printed values are 1, 2, then 4 and 5 after 3 is skipped, and the loop ends when i reaches 6.
Python binds an else to the nearest if at the same indentation level, and here that is the outer if. The outer condition is true, the inner condition prints even, and the outer else is skipped.
A condition is true for non-zero numbers and non-empty containers, including strings and lists. The truthy values are 1, '0', and [0], giving a count of 3.
continue skips the rest of the current iteration, so even values are not added. The odd values from 1 through 5 are 1, 3, and 5, whose sum is 9.
break exits only the innermost loop that contains it, so the outer for loop continues with its next value. Counting increments before each inner break gives 0 + 1 + 2 = 3.
The and operator has higher precedence than or, so the expression groups as (x > 3 and y != 0) or (x == 5). The first part is false, but x == 5 is true, so the if block runs and prints yes.
A non-empty string is truthy in Python, and the text inside it does not change that. Because "False" contains characters, the if condition succeeds and the program prints truthy.
range(6, 1, -2) starts at 6 and stops before 1, decreasing by 2 each time. The generated values are 6, 4, and 2, printed with spaces.
pass is a null statement: it satisfies Python's need for an indented block but performs no action. The condition 7 > 10 is false, so that block is skipped anyway, and print("end") runs because it is outside the if.
The while condition is checked before the first iteration; since 5 < 3 is false, the loop body never runs. A while loop's else block runs when the loop ends without a break, so it prints else 5 with n unchanged.
The loop increments i to 1, then to 2 and breaks. break skips the loop's else block, and the final print outputs the current value 2.
These are two separate if statements, not an if/elif chain. For x = 10 both conditions are true, so A prints first and B prints second.