Python Programming — C20 DCME Fifth Semester (Board Exam Scope): 18 MCQs with answers

A name that refers to a value in memory

A Python variable is a name bound to a value in memory. No type declaration is required, and the name can later refer to a value of a different type.

Types are determined at runtime, not declared in advance

Python uses dynamic typing: the type of a value is determined at runtime, so the same name can later refer to a value of a different type.

It runs fine; `x` now refers to a string

Because of dynamic typing, reassigning `x` to a string is perfectly legal. The name simply points to a new value.

`=`

`=` is the assignment operator. `==` compares two values for equality, and `!=` and `is` are also comparison-style operators.

Membership

`in` and `not in` are membership operators; they check whether a value is present in a sequence or collection.

0, 1, 2, 3, 4

`range(5)` starts at 0 and stops before 5, producing 0, 1, 2, 3, 4.

True

Python uses dynamic typing, so variable types are determined at runtime rather than declared in advance.

A `while` loop

A `while` loop repeats as long as its condition stays true, which suits condition-driven repetition. A `for` loop is meant for iterating over a sequence.

`continue`

`continue` skips the rest of the current iteration and moves to the next one, so even numbers are skipped while the loop keeps running.

Extra positional arguments, as a tuple

`*args` gathers extra positional arguments into a tuple. It is `**kwargs` that gathers extra keyword arguments into a dictionary.

Lists and tuples

Lists and tuples are both ordered and allow duplicate values. Sets are unordered with no duplicates, and dictionary keys must be unique.

`b = a[:]`

`b = a[:]` (or `b = list(a)`) makes an independent copy. `b = a` only creates a second name for the same list, so changes show up in both.

Strings are immutable sequences of characters

A string is an immutable sequence of characters. Methods like `upper()` return new strings rather than changing the original.

`break` exits the loop; `continue` skips to the next iteration

`break` leaves the loop entirely, while `continue` abandons only the current iteration and proceeds to the next one.

`try` with `except` and `finally`

Exception handling with `try`, `except`, and `finally` lets the program catch the runtime error and continue instead of crashing. `assert` only raises an error; it does not handle one.

A leading underscore signals restricted access by convention

Python uses naming conventions: `_name` signals internal use and `__name` triggers name mangling. The restriction is by convention and mangling, not a hard access block.

```python def filter_odds(numbers): odds = [] for n in numbers: if n % 2 == 0: continue odds.append(n) return odds ```

The correct option uses a `for` loop with a `continue` statement to skip even numbers and append only odd integers to the list. This effectively filters out the even numbers.

150

The output is 150 because the `deposit` method successfully adds 50 to the initial balance of 100, demonstrating correct encapsulation and method functionality in the class.