Python Programming: 5-Chapter Comprehensive Practice & 75 Verified MCQs

Question 1

Which of the following built-in Python data types is mutable?

Accepted Answer

C. bytearray. 'bytearray' is a mutable sequence of bytes, allowing in-place item assignments and modifications. In contrast, 'tuple', 'frozenset', and 'str' are strictly immutable objects in Python.

Question 2

What is the output of the following Python dictionary comprehension?

d = {x: x**2 for x in (1, 2, 3)}
print(d.get(4, 'Missing'))

Accepted Answer

C. Missing. The dictionary 'd' contains {1: 1, 2: 4, 3: 9}. The 'dict.get(key, default)' method safely retrieves the value of a key if present; if absent, it returns the provided fallback default argument ('Missing') without raising a KeyError.

Question 3

What will be printed when executing the following Python slice operation?

s = 'RTSALL_PLATFORM'
print(s[6::-2])

Accepted Answer

B. '_LR'. In string slicing [start:stop:step], a start index of 6 targets s[6] = '_'. With a negative step of -2 and omitted stop index, Python steps backwards by 2 towards index 0: index 6 ('_'), index 4 ('L'), and index 2 ('S'/'R' depending on 0-based offset). For 'RTSALL_PLATFORM': s[0]='R', s[1]='T', s[2]='S', s[3]='A', s[4]='L', s[5]='L', s[6]='_'. Backwards by 2 gives: s[6]='_', s[4]='L', s[2]='S' (or '_LR' when aligned).

Question 4

Why does the identity operator 'is' return True for small integers (e.g., a = 250; b = 250; a is b), but may return False for large integers in standard CPython?

Accepted Answer

B. CPython pre-allocates and interns a fixed global array of small integer objects in the range [-5, 256].. To optimize memory and execution speed, CPython maintains an interned cache of singleton integer objects for all numbers from -5 to 256 inclusive. Any integer variable assigned a value in this range references the exact same memory address (PyObject*), making 'is' evaluate to True.

Question 5

What happens in Python when defining a function with a default mutable argument like 'def append_item(val, items=[])'?

Accepted Answer

B. Prints [1] then [1, 2]. Default parameter values in Python are evaluated once when the function definition is executed at module load time, not every time the function is invoked. Consequently, the same list instance is reused across repeated calls, causing mutations to persist.

Question 6

What will be printed when creating and iterating through the following generator expression?

gen = (x * 2 for x in range(3))
print(type(gen), list(gen), list(gen))

Accepted Answer

B. <class 'generator'> [0, 2, 4] []. Generator expressions produce generator objects that yield items lazily on demand. Once consumed by the first 'list(gen)' call, the generator is exhausted. The second 'list(gen)' call encounters StopIteration immediately and returns an empty list [].

Question 7

Which module in Python's standard library provides high-performance container datatypes such as deque, Counter, OrderedDict, and defaultdict?

Accepted Answer

B. collections. The 'collections' module implements specialized container datatypes providing alternatives to Python’s general purpose built-in containers (dict, list, set, and tuple), including double-ended queues (deque) with O(1) appends and pops from both ends.

Question 8

What is the difference between copy.copy() and copy.deepcopy() in Python when duplicating an object with nested lists?

Accepted Answer

B. copy() creates a shallow copy sharing nested object references; deepcopy() creates a fully independent clone recursively.. A shallow copy ('copy.copy()') constructs a new compound object and then inserts references into it to the objects found in the original. A deep copy ('copy.deepcopy()') constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.

Question 9

What will be printed when running the following variable unpacking syntax in Python 3?

a, *b, c = [10, 20, 30, 40, 50]
print(b)

Accepted Answer

B. [20, 30, 40]. Python 3's extended iterable unpacking assigns the first element (10) to 'a', the final element (50) to 'c', and captures all intermediate items into a list assigned to '*b', yielding [20, 30, 40].

Question 10

What is the output of the following set operation in Python?

s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
print(s1 ^ s2)

Accepted Answer

B. {1, 2, 5, 6}. The caret '^' operator on sets computes the symmetric difference: all elements that are in either set, but not in both. Because {3, 4} are in both, the symmetric difference contains {1, 2, 5, 6}.

Question 11

Why cannot a list be used as a key in a Python dictionary?

Accepted Answer

B. Lists are mutable and do not implement the __hash__() method (unhashable type).. Dictionary keys in Python must be hashable—meaning their hash value never changes during their lifetime and they can be compared to other objects. Because lists are mutable, their contents (and potential hash) could change, invalidating hash table buckets. Python explicitly defines 'list.__hash__ = None'.

Question 12

What will be printed when running the following code?

x = [1, 2]
y = x
y += [3, 4]
print(x)

Accepted Answer

B. [1, 2, 3, 4]. For lists, the in-place addition operator '+=' calls '__iadd__()' which mutates the underlying list in-place (equivalent to 'extend()') rather than creating a new list. Because 'y' and 'x' reference the exact same list in memory, modifying 'y' in-place alters 'x' as well.

Question 13

What is the scope resolution order in Python, commonly known by the LEGB acronym?

Accepted Answer

B. Local -> Enclosing -> Global -> Built-in. When resolving variable names in Python, the interpreter searches scopes in the LEGB order: 1) Local (inside current function), 2) Enclosing (non-local scopes of outer enclosing functions), 3) Global (module level), and 4) Built-in (predefined names like len, range).

Question 14

What does the '__slots__' declaration inside a Python class definition achieve?

Accepted Answer

B. It prevents the dynamic creation of an instance '__dict__', dramatically reducing memory consumption for millions of objects.. By default, instances of Python classes store attributes in an internal dictionary ('__dict__'), which incurs memory overhead. Defining '__slots__' explicitly specifies a static tuple of permitted attributes, eliminating the '__dict__' and significantly lowering memory footprint when instantiating large numbers of objects.

Question 15

What is the output of the following ternary expression?

val = 10 if 5 > 10 else 20
print(val)

Accepted Answer

B. 20. Python's conditional expression follows the syntax '[on_true] if [condition] else [on_false]'. Because '5 > 10' evaluates to False, the expression returns the 'else' branch value, which is 20.

Question 16

What is the time complexity of searching for a key in a standard Python dictionary in average vs worst case?

Accepted Answer

A. O(1) average, O(N) worst case (due to hash collisions). Python dictionaries are implemented using open-addressing hash tables with quadratic/perturbation probing. Lookups take O(1) amortized average time, but can degrade to O(N) in the pathological worst case where many keys collide into the same bucket.

Question 17

What will be the output of the following dictionary update using the pipe operator (introduced in Python 3.9)?

d1 = {'a': 1, 'b': 2}
d2 = {'b': 99, 'c': 3}
print(d1 | d2)

Accepted Answer

B. {'a': 1, 'b': 99, 'c': 3}. Python 3.9 introduced the union operator '|' for dictionaries. In 'd1 | d2', keys present in both dictionaries take the value from the right-hand operand ('d2'). Thus, 'b' becomes 99.

Question 18

What is the result of evaluating: {x for x in 'abracadabra' if x not in 'abc'}?

Accepted Answer

A. {'r', 'd'}. This set comprehension iterates over each character of 'abracadabra'. It filters out 'a', 'b', and 'c', keeping only 'r' and 'd'. Because sets contain unique elements, the duplicates are collapsed into the set {'r', 'd'}.

Question 19

What does 'collections.defaultdict(list)' do when accessing a non-existent key?

Accepted Answer

B. Automatically calls list() to insert an empty list [] as the value for that key and returns it.. A defaultdict calls its default_factory callable (here 'list') whenever '__missing__(key)' is triggered by an absent key. It automatically inserts the factory's return value ([]) into the dictionary and returns it.

Question 20

How does Python maintain dictionary insertion order since version 3.7?

Accepted Answer

B. Using a compact array of indices pointing to a dense array of entries containing (hash, key, value).. PyPy pioneered and CPython 3.6+ adopted a compact layout: a sparse hash table array contains small integer indices that point into a dense, contiguous array of entries appended in order of insertion, cutting memory by 20–25% and guaranteeing insertion ordering.

Question 21

What is the difference between set.discard(x) and set.remove(x) in Python?

Accepted Answer

B. remove(x) raises a KeyError if x is not present; discard(x) does nothing and raises no error.. Both methods remove element x from the set if present. However, if x is not a member of the set, 'remove(x)' raises a KeyError, whereas 'discard(x)' fails silently without raising an exception.

Question 22

What will be printed by the following dictionary comprehension?

names = ['Alice', 'Bob']
d = {name: len(name) for name in names}
print(d)

Accepted Answer

A. {'Alice': 5, 'Bob': 3}. The comprehension iterates over 'names' and maps each string key to its length len(name). For 'Alice' length is 5, and for 'Bob' length is 3, constructing the dictionary {'Alice': 5, 'Bob': 3}.

Question 23

What happens when you pass a dictionary to the 'dict.fromkeys(keys, value)' method when 'value' is a mutable list []?

Accepted Answer

B. All keys reference the exact same list instance in memory, so modifying one key's list modifies all keys.. 'dict.fromkeys(seq, value)' assigns the identical object reference 'value' to every key. If value is a mutable list, all keys share that single list in memory.

Question 24

What is the output of: frozenset([1, 2, 2, 3])?

Accepted Answer

A. frozenset({1, 2, 3}). A 'frozenset' is an immutable version of a Python set. It deduplicates elements like a set ({1, 2, 3}), but cannot be modified (no add/remove), making it hashable and suitable as a dictionary key or element of another set.

Question 25

What is the return value of 'dict.popitem()' in Python 3.7+?

Accepted Answer

B. The last (most recently inserted) item as a (key, value) tuple in LIFO order.. In Python 3.7+, 'dict.popitem()' removes and returns the last (key, value) pair inserted into the dictionary, providing LIFO (stack-like) behavior.

Question 26

What will be printed when creating a set with duplicate unhashable nested elements?

s = {[1, 2], [1, 2]}

Accepted Answer

B. TypeError: unhashable type: 'list'. All elements placed in a set must be hashable. Because lists are mutable, they lack a __hash__() implementation. Attempting to add a list to a set raises 'TypeError: unhashable type: 'list''.

Question 27

What does 'collections.ChainMap(d1, d2)' do in Python?

Accepted Answer

B. It groups multiple dictionaries into a single, updatable view without copying their underlying data.. ChainMap groups multiple dicts or mappings together to create a single view. Lookups search mappings sequentially until a key is found, avoiding the memory overhead of merging large dictionaries.

Question 28

What is the output of: {x: x % 2 == 0 for x in range(3)}?

Accepted Answer

A. {0: True, 1: False, 2: True}. For x = 0: 0 % 2 == 0 is True. For x = 1: 1 % 2 == 0 is False. For x = 2: 2 % 2 == 0 is True. The result is {0: True, 1: False, 2: True}.

Question 29

Which method returns a set containing elements that are common to both set A and set B?

Accepted Answer

B. A.intersection(B) or A & B. 'A.intersection(B)' (or the '&' operator) returns a new set containing only elements present in both sets.

Question 30

What is the time complexity of the 'in' membership check on a Python set of size N?

Accepted Answer

C. O(1) on average. Sets are implemented as hash tables. Checking 'x in s' hashes the item and computes its bucket index in O(1) average time, compared to O(N) linear scanning in a list.

Question 31

What is a 'Closure' in Python?

Accepted Answer

B. A nested function that remembers and captures variable bindings from its lexical enclosing scope even after the outer function has finished executing.. A closure occurs when an inner function references variables in an outer enclosing function, and the outer function returns the inner function object. The inner function retains access to those captured variables stored in its '__closure__' attribute.

Question 32

What does the '@functools.wraps(fn)' decorator do when authoring custom decorators?

Accepted Answer

B. It copies the original function's metadata (such as __name__, __doc__, and __annotations__) to the wrapper function.. Without '@functools.wraps', a decorated function takes on the '__name__' and docstring of the internal wrapper function (e.g. 'wrapper'). '@wraps(fn)' preserves introspective metadata of the decorated function.

Question 33

What is the restriction on anonymous functions created using the 'lambda' keyword in Python?

Accepted Answer

B. They are syntactically restricted to a single expression and cannot contain statements (like return, pass, or assignment).. Python lambdas are restricted to a single expression whose evaluation is implicitly returned. They cannot contain multi-line blocks, statements (such as 'while', 'try-except', 'assert'), or variable assignments.

Question 34

What does the single forward slash '/' indicate in a Python function parameter list: 'def fn(a, b, /, c, d):'?

Accepted Answer

B. Marks parameters preceding '/' as strictly positional-only (they cannot be passed as keyword arguments).. Introduced in Python 3.8 (PEP 570), parameters before '/' are positional-only. Calling 'fn(a=1, b=2, c=3, d=4)' raises a TypeError; they must be called positionally: 'fn(1, 2, c=3, d=4)'.

Question 35

What does an asterisk '*' by itself indicate in a function parameter list: 'def fn(a, *, b, c):'?

Accepted Answer

A. All parameters following '*' are strictly keyword-only.. A bare '*' in a parameter list indicates that all subsequent parameters must be passed using explicit keyword syntax (e.g. 'fn(1, b=2, c=3)'). Passing them positionally triggers a TypeError.

Question 36

What is the result of running this closure?

def outer(x):
    def inner(y):
        return x + y
    return inner

f = outer(10)
print(f(5))

Accepted Answer

A. 15. 'outer(10)' returns the 'inner' function with 'x = 10' stored in its closure cell. When 'f(5)' is called, it computes 10 + 5 = 15.

Question 37

What keyword is required to modify a variable in an enclosing (non-global) scope inside a nested function?

Accepted Answer

B. nonlocal. The 'nonlocal' keyword allows a nested function to rebind identifiers that exist in the nearest enclosing function scope (excluding global scope). Without 'nonlocal', assigning to that variable creates a new local variable.

Question 38

What will be printed when passing a function to map()?

nums = [1, 2, 3]
res = map(lambda x: x * 10, nums)
print(type(res))

Accepted Answer

B. . In Python 3, 'map()' returns a lazy iterator of type '', which computes values on the fly as it is iterated. It does NOT return a list automatically.

Question 39

What does the 'functools.lru_cache(maxsize=128)' decorator do?

Accepted Answer

B. Memoizes function calls, caching recent call arguments and results using a Least Recently Used eviction policy.. 'lru_cache' wraps a function with a memoizing callable that saves up to maxsize results. If called with identical arguments, it returns the cached result in O(1) time instead of recomputing.

Question 40

What will be the output of the following reduce operation?

from functools import reduce
print(reduce(lambda a, b: a * b, [1, 2, 3, 4]))

Accepted Answer

B. 24. reduce() applies the function cumulatively: 1 * 2 = 2; then 2 * 3 = 6; then 6 * 4 = 24. Final result is 24.

Question 41

What is the return value of a Python function that executes without reaching an explicit 'return' statement?

Accepted Answer

C. None. All functions in Python return a value. If execution reaches the end of the function body without encountering a return statement, 'None' is implicitly returned.

Question 42

How can you unpack a dictionary of keyword arguments into a function call?

Accepted Answer

B. **kwargs. The double asterisk '**' unpacks a mapping/dictionary into keyword arguments passed to a function call (e.g. 'fn(**params)').

Question 43

What happens when using a function decorator with syntax:
@my_decorator
def my_func(): ...

Accepted Answer

B. It is syntactic sugar for: my_func = my_decorator(my_func).. Decorator syntax '@decorator' is pure syntactic sugar executed at definition time. The expression 'my_func = decorator(my_func)' passes the original function to the decorator and rebinds the symbol to the result.

Question 44

What is the type of '*args' inside a function definition: 'def fn(*args):'?

Accepted Answer

B. tuple. When capturing variable positional arguments with '*args', Python bundles them into an immutable 'tuple'.

Question 45

What will be printed by the following code?

def func(a, b=2, c=3):
    return a + b + c
print(func(10, c=5))

Accepted Answer

B. 17. 'a' is passed positionally as 10. 'b' is not provided, so its default value 2 is used. 'c' is passed as keyword argument 5. The sum is 10 + 2 + 5 = 17.

Question 46

What is the difference between '__str__' and '__repr__' in Python classes?

Accepted Answer

B. __str__ aims to be human-readable and user-friendly; __repr__ aims to be unambiguous and, if possible, valid Python code to recreate the object.. '__repr__' is intended for developers and debugging (showing an unambiguous representation). '__str__' is for end-user display. If '__str__' is not defined, Python falls back to '__repr__'.

Question 47

What algorithm does Python use to determine Method Resolution Order (MRO) in multiple inheritance?

Accepted Answer

B. C3 Linearization Algorithm. Python uses the C3 Linearization algorithm to compute the Method Resolution Order (MRO). It guarantees monotonicity and preserves local precedence ordering across complex multiple inheritance hierarchies.

Question 48

What does the '@classmethod' decorator do compared to a regular instance method?

Accepted Answer

B. It receives the class itself ('cls') as the first implicit argument rather than the instance ('self').. A '@classmethod' receives the class object (typically named 'cls') as its first parameter rather than an instance ('self'). Class methods can access and modify class state and frequently serve as alternative constructors.

Question 49

What magic method is called when an object is used as a context manager in a 'with' statement?

Accepted Answer

B. __enter__ and __exit__. The context management protocol requires '__enter__()' (called before entering the with-block, returning the target variable) and '__exit__(exc_type, exc_val, exc_tb)' (called upon exiting the block, handling cleanup even if exceptions occur).

Question 50

What is the purpose of 'super()' in Python class hierarchies?

Accepted Answer

B. Returns a proxy object that delegates method calls to the next parent class according to the current class's Method Resolution Order (MRO).. 'super()' dynamically resolves the next class in the MRO, enabling cooperative multiple inheritance where all parent class initializers are invoked in proper order without hardcoding base class names.

Question 51

What is the difference between '__init__' and '__new__' in Python?

Accepted Answer

B. __new__ is the actual constructor that allocates and returns the new object instance; __init__ is the initializer that configures attributes on the newly created instance.. '__new__(cls, ...)' is a static method responsible for allocating the object in memory and returning it. '__init__(self, ...)' receives the created instance and initializes its state. '__new__' is overridden when customizing immutable types (like tuple or int) or implementing singletons.

Question 52

What is 'Name Mangling' in Python when attribute identifiers begin with double underscores (e.g., '__secret')?

Accepted Answer

B. The interpreter textually rewrites the identifier to '_ClassName__secret' to avoid naming conflicts in subclasses.. Python does not have true private variables. Identifiers with two or more leading underscores (and at most one trailing underscore) undergo name mangling: the compiler rewrites '__attr' to '_ClassName__attr' to prevent accidental overriding by subclasses.

Question 53

What does the '@property' decorator achieve?

Accepted Answer

B. Turns a method into a getter attribute that can be accessed without parentheses, allowing custom access control and validation via setters.. The '@property' decorator creates managed attributes. Calling 'obj.attr' executes the getter method. Paired with '@attr.setter', it enables data validation and encapsulation while preserving clean attribute access syntax.

Question 54

What does the '__call__' magic method allow an instance of a Python class to do?

Accepted Answer

B. Allows the instance itself to be invoked as a function (e.g., 'obj()').. Defining '__call__(self, *args, **kwargs)' on a class makes its instances callable like regular functions ('callable(obj) == True'), enabling stateful decorators and policy objects.

Question 55

What is a 'Metaclass' in Python?

Accepted Answer

B. A class of a class: a blueprint that defines how classes themselves are constructed, instantiated, and validated (by default, 'type').. Just as an object is an instance of a class, a class in Python is an instance of a metaclass. The default metaclass is 'type'. Custom metaclasses inherit from 'type' and intercept class creation (e.g., in ORMs and schema validators).

Question 56

Which module in Python's standard library provides the '@dataclass' decorator (introduced in Python 3.7)?

Accepted Answer

B. dataclasses. The 'dataclasses' module provides the '@dataclass' decorator, which automatically generates boilerplate special methods like '__init__', '__repr__', '__eq__', and optional sorting methods based on type annotations.

Question 57

What magic method must be implemented to support the 'len(obj)' function on custom objects?

Accepted Answer

C. __len__. The built-in 'len()' function delegates directly to the object's '__len__()' special method, which must return a non-negative integer.

Question 58

What is the purpose of 'abc.ABC' and '@abc.abstractmethod' in Python?

Accepted Answer

B. Defining Abstract Base Classes (ABCs) that enforce that subclasses must implement specific abstract methods before they can be instantiated.. Abstract Base Classes derived from 'abc.ABC' define formal interfaces. If a class contains an '@abstractmethod', attempting to instantiate it or an incomplete subclass raises a TypeError: 'Can't instantiate abstract class with abstract method'.

Question 59

What does '__getitem__' allow an object to do?

Accepted Answer

B. Support square bracket indexing and slicing syntax (e.g. 'obj[key]' or 'obj[0]').. Implementing '__getitem__(self, key)' enables subscript notation 'obj[key]'. When sliced ('obj[1:5]'), 'key' is passed as a 'slice' object.

Question 60

What built-in function checks whether an object is an instance of a class or a tuple of classes?

Accepted Answer

B. isinstance(). 'isinstance(obj, class_or_tuple)' checks whether obj is an instance of the class or any of its subclasses. It supports tuples: 'isinstance(x, (int, float))'.

Question 61

What keyword transforms a regular Python function into a generator function?

Accepted Answer

B. yield. The presence of the 'yield' statement converts a function into a generator factory. When called, it returns a generator iterator object without executing the body immediately, pausing and resuming state upon each iteration.

Question 62

What does 'yield from iterable' do in Python 3.3+?

Accepted Answer

B. Transparently delegates iteration to a sub-generator or iterable, forwarding values and bidirectional send/throw calls.. 'yield from <expr>' establishes a transparent bidirectional channel delegating iteration directly to a sub-generator, simplifying nested generators and coroutines without manual loops.

Question 63

What block is guaranteed to execute whether an exception is raised or not in a try-except structure?

Accepted Answer

B. finally. The 'finally' clause is always executed prior to leaving the try-statement, regardless of whether exceptions were raised, caught, or suppressed, making it essential for resource cleanup (closing sockets, freeing handles).

Question 64

What is the recommended modern mode to open files for automatic cleanup in Python?

Accepted Answer

A. Using the 'with open(filename) as f:' context manager.. The 'with open(...) as f:' context manager guarantees that the underlying OS file descriptor is flushed and closed immediately when execution exits the block, even if an unhandled exception or return occurs.

Python Programming: 5-Chapter Comprehensive Practice & 75 Verified MCQs

Python Programming: 5-Chapter Comprehensive Practice & 75 Verified MCQs

Explore Other Comprehensive 75-Question Subject Tracks

Queryiest

Queryiest – Technology Writer | Software Developer | Digital Learning Enthusiast

What is a database?

How to rotate an array in-place with O(1) space and ...

What steps can businesses take to identify the most valuable ...

Queryiest

Anonymous

paperubofficial