Free PCEP-30-02 sample questions

Correct answer: 40

The loop proceeds as follows: - `items[0]` is 10. It's not > 30. It's not divisible by 20. `result` becomes 10. - `items[1]` is 20. It's not > 30. It IS divisible by 20, so `continue` is executed, skipping the rest of the loop body. `result` remains 10. - `items[2]` is 30. It's not > 30. It's not divisible by 20. `result` becomes 10 + 30 = 40. - `items[3]` is 40. It IS > 30, so `break` is executed, terminating the loop. The final value of `result` is 40.

Correct answer: The code executes successfully and prints `(1, 2, [99, 4])`.

This is correct. Tuples are immutable, meaning you cannot change the references to the objects they contain. However, if one of those objects is mutable (like a list), you can modify the internal state of that object. The tuple still holds a reference to the *same list*, but the list's content has changed.

Correct answer: `def calculate_price(base_price, discount=0.1):`

This is the correct syntax. The required parameter `base_price` is listed first, followed by the optional parameter `discount` with its default value. This allows the function to be called as `calculate_price(100)` or `calculate_price(100, 0.2)`.

Correct answer: `lengths = [len(w) for w in words if len(w) > 3]`

This list comprehension is the most concise and Pythonic solution. It iterates through the `words` list, applies a filter (`if len(w) > 3`), and then applies a transformation (`len(w)`) to each item that passes the filter, all in one readable line.

Correct answer: False

This statement is False. Due to the nature of binary floating-point representation, numbers like 0.1 and 0.2 cannot be stored with perfect precision. The result of `0.1 + 0.2` is a value extremely close to, but not exactly, 0.3. This is a fundamental concept in computer science regarding floating-point arithmetic.

Correct answer: `50 <= number <= 100`

Python supports chained comparisons, which allows for a more readable and mathematically intuitive way to check if a value falls within a range. This expression is equivalent to `(50 <= number) and (number <= 100)` and is the most concise and 'Pythonic' way to write the check.

Correct answer: 0 1 2 3 4 5 6 Found it!

This is the correct output. The loop iterates from 0 up to 6, printing each number. When the loop variable becomes 7, the condition `if number == 7` is met, 'Found it!' is printed, and the `break` statement terminates the loop before it can process any further numbers.

Correct answer: `theme = preferences.get('theme', 'light')`

The `.get()` method is the correct and safest way to achieve this. It attempts to retrieve the value for the given key. If the key is not found, it returns the default value provided as the second argument ('light' in this case) instead of raising a `KeyError`. It does not modify the dictionary.

Correct answer: Inside function: 50 Outside function: 100

This is correct. The variable `value` defined outside the function has a global scope. Inside `my_func`, the line `value = 50` creates a *new* local variable named `value` that exists only within the function's scope (this is called shadowing). This local variable does not affect the global variable of the same name. Therefore, 50 is printed inside the function, and the original global value of 100 is printed outside.

Correct answers: `new_list = list1 + list2`; `new_list = [*list1, *list2]`

The `+` operator, when used with lists, performs concatenation. It creates and returns a completely new list containing the elements of both operands, leaving the original lists unchanged.

The iterable unpacking operator (`*`) can be used within a list literal to create a new list. `*list1` unpacks all elements of `list1`, and `*list2` unpacks all elements of `list2`, creating a new combined list without altering the originals.