Python MCQ Questions

DBM (Database Manager) in Python refers to simple key-value database modules: dbm.gnu (gdbm), dbm.ndbm, dbm.dumb. Persistent dict-like interface. Store strings as key-value. Fast simple storage. Open: db = dbm.open('filename', 'c'). Legacy interface. Modern alternatives: SQLite, JSON, pickle.

Any function checks if any element is truthy. Syntax: any(iterable). Example: any([False, False, True]) returns True. Short-circuits on first True. Empty iterable returns False. Boolean aggregation function.

Use sys.platform for platform identifier. Values: 'linux', 'darwin' (Mac), 'win32' (Windows). Example: if sys.platform == 'win32': windows_code. Platform-specific code branching. OS detection.

Check iterability: try: iter(myobject) except TypeError: not_iterable. Or isinstance(myobject, collections.abc.Iterable) with import collections.abc. Or hasattr(myobject, '__iter__') or hasattr(myobject, '__getitem__'). try-iter most Pythonic. Catches non-iterable objects safely. EAFP (Easier to Ask Forgiveness than Permission) approach.

Use itertools.dropwhile for conditional drop. Example: dropwhile(lambda x: x<5, [1,2,3,4,5,6]) yields 5,6. Drops until first False. Complementary to takewhile. Suffix extraction. Conditional skip.

Use json.loads(string) to parse JSON string. Example: data = json.loads('{"a": 1}'). Converts JSON to Python types. Reverse of dumps(). JSON parsing.

Use re.compile(pattern) to precompile regex. Example: regex = re.compile(r'\d+'); regex.findall(string). Reusable pattern object. Efficient for repeated use. Methods: match, search, findall, sub. Compiled regex pattern.

Use compile(source, filename, mode) to compile code. Modes: 'exec' (statements), 'eval' (expression), 'single' (interactive). Returns code object. Example: code = compile('x+1', '', 'eval'); eval(code). Pre-compile for repeated execution. Optimization for dynamic code.

del statement deletes variables, list elements, dictionary entries, object attributes. Syntax: del variable_name, del list[index], del dict[key]. Removes reference, object garbage collected if no references remain. Different from remove() method. Can delete multiple: del a, b, c. Cannot delete constants or non-existent names.

sys.argv[0] equals script filename. First command-line argument is script name itself. sys.argv is list: [script_name, arg1, arg2, ...]. Example: running 'python script.py' makes sys.argv[0]='script.py'. sys.argv[1:] contains actual arguments. Zero-indexed list with script as first element.

Use r'raw string' for regex patterns. Backslashes not escaped. Example: r'\d+' instead of '\\d+'. Essential for regex. Prevents double escaping. Raw string literals for patterns.

Difference: string.split() is deprecated string module function. text.split() is string method (modern). Both split string on newline. Method syntax preferred: text.split('\n'). string.split(text, '\n') older style. Modern Python uses methods. Functionality identical, syntax differs. Method approach recommended.

Use time.strptime(string, format) to parse time string. Returns struct_time. Example: time.strptime('2023-01-01', '%Y-%m-%d'). Inverse of strftime. Parse formatted time strings.

Value of var is 'hello world'. Original: 'dlrow olleh'. var[::-1] reverses string using slice notation with step -1. Reverses character order. 'dlrow olleh' backwards is 'hello world'. Slice syntax [start:stop:step] with negative step reverses. Common string reversal idiom.

Result: 'count'. x is itertools.count object (infinite counter). __class__.__name__ attribute returns class name as string. itertools.count generates infinite sequence. __name__ gives 'count'. Accessing class name via __class__ attribute. Type introspection.

Python 3: super().foo() calls base implementation. Simplified from Python 2. No class or self arguments needed. super() without parameters. Handles MRO properly. Modern Python 3 syntax cleaner than Python 2's super(Child, self).foo().

Feature is slicing (substring extraction). 'This is a string'[3:9] extracts characters from index 3 to 8 (9 exclusive). Result: 's is a'. Slice notation: [start:stop:step]. Works on strings, lists, tuples. Creates substring/subsequence. Negative indices allowed. Essential string manipulation technique.

The term is expression. 3 + 4 is arithmetic expression evaluating to 7. Expressions combine values and operators to produce result. Can be simple (literal) or complex (operations). Python evaluates expressions to values. Note: Question about Python syntax, not PHP. Expression is general programming concept.

Use math.ceil(x) and math.floor(x) for rounding. ceil() rounds up, floor() rounds down. Example: math.ceil(3.2) = 4, math.floor(3.8) = 3. Return integers. Directional rounding.

Generator expression creates lazy iterator. Syntax: (expression for item in iterable if condition). Example: (x**2 for x in range(1000000)). Parentheses instead of brackets. Memory efficient for large sequences. Values produced on-demand. One-time iteration.

Most flexible: subprocess.run(['ls', '-l'], capture_output=True). Or subprocess.Popen(['ls', '-l']). subprocess module recommended. Avoids shell injection vulnerabilities. List format separates command and arguments. More secure than os.system(). capture_output captures stdout/stderr. Modern Python subprocess preferred.

Use sys.modules to see loaded modules. Dict mapping names to module objects. Example: 'os' in sys.modules checks if imported. Rarely modified manually. Module cache inspection.

Returns '123'. Expression ('123',)[0] creates single-element tuple containing string '123', then accesses first element with [0]. Parentheses with comma make tuple. Result is the string '123'. Tuple indexing returns the element. Comma crucial: ('123') is just string, ('123',) is tuple.

Value of d is [1]. Initial d=[0]. d.pop() removes last element (0), d becomes []. Lambda function l(x) appends x to d. l(1) appends 1. Final d=[1]. Lambda modifies shared list reference. Closure captures d. Result after operations: [1].

Use staticmethod decorator for static methods. No self or cls parameter. Example: @staticmethod def func(): return 'result'. Called: Class.func(). Utility functions in class. No instance/class access needed. Organizational grouping.

Docstring is string literal as first statement in module/function/class/method. Documents code purpose. Accessed via __doc__ attribute. Triple quotes used: '''description'''. help() displays docstrings. Good practice for documentation. Example: def func(): '''This explains func'''. PEP 257 defines conventions.

Use itertools.cycle(iterable) for infinite repetition. Example: cycle([1, 2]) yields 1, 2, 1, 2, ... Repeats forever. Round-robin iteration. Infinite cycling.

Valid asyncio loop: loop = asyncio.get_event_loop(); loop.run_until_complete(coroutine), or loop.run_forever(), or asyncio.run(coroutine) (Python 3.7+). asyncio.run() simplest. get_event_loop() gets loop, run methods execute. Python 3.7+ asyncio.run() recommended high-level API.

filter((lambda s: re.search(r'xxx', s)), s) returns iterator of strings containing 'xxx'. Filters tuple keeping only elements matching regex pattern 'xxx'. Result: ('xxx', 'abcxxxabc', 'axxxxa') - strings with 'xxx'. filter() applies function, keeps truthy results. Lambda function tests regex match.

Maximum recursion limit in Python is typically 1000 by default (varies by implementation and platform). View: sys.getrecursionlimit(). Change: sys.setrecursionlimit(n) but risky - can cause crashes. Prevents infinite recursion stack overflow. Exceeding limit raises RecursionError. Most algorithms shouldn't need changing default. Use iteration for deep recursion.

Purpose of 'if' statement is conditional execution: execute code only when condition is true. Syntax: if condition: code. Optional else for alternative, elif for multiple conditions. Controls program flow based on boolean evaluation. Fundamental control structure. Enables decision-making in code logic.

Python has no switch statement. Question might be trick or reference to Python 3.10+ match statement. Match syntax: match value: case pattern:. Traditional switch doesn't exist in Python. Use if/elif/else or dict dispatch. Match statement (structural pattern matching) added Python 3.10.

Difference: def creates named function with __name__='double', exists in namespace. lambda creates anonymous function, __name__=''. def allows multiple statements, docstrings. Lambda single expression only. def more readable for complex functions. Lambda for simple inline functions. Functionality equivalent for simple cases.

Result: SyntaxError in Python 3. <> operator removed. Use != instead. Python 2 allowed <> as not-equal. Python 3 only supports !=. print(2 != 3) returns True. <> deprecated then removed. Use != for inequality.

len(d) is 5. set() removes duplicates from [0, 0, 1, 2, 2, 3, 4]. Unique elements: {0, 1, 2, 3, 4}. Sets contain only unique values. len() counts unique elements. Result: 5. Duplicate 0s and 2s collapsed to single instances. Sets enforce uniqueness automatically.

Use time.sleep(seconds) to pause execution. Blocks for specified duration. Float accepted: time.sleep(0.5) for half second. Example: time.sleep(2) waits 2 seconds. asyncio.sleep() for async code. Delay execution.

Main difference: tuples immutable (can't change after creation), lists mutable (modifiable). Tuples use (), lists use []. Tuples faster, hashable (dict keys, set elements). Lists have more methods (append, remove). Use tuples for fixed collections, lists for dynamic data. Immutability is key distinction.

A variable is named storage location holding value. In Python, variables are references to objects. Created by assignment: x = 5. No type declaration needed. Can reference any type, change types. Names follow rules: start with letter/underscore, contain letters/numbers/underscores, case-sensitive. Essential for storing and manipulating data.

Use pow(base, exp, mod=None) for exponentiation. Example: pow(2, 3) returns 8. Third parameter: pow(2, 3, 5) = (2**3) % 5 = 3. More efficient than ** for modular exponentiation. Built-in power function. Supports negative exponents.

Use itertools.repeat for repeated value. Example: repeat('A', 5) yields 'A' five times. Without count: infinite. Use with map() for constants. Constant value generation.

Single quotes in Python create literal strings, no variable interpolation or escape sequences (except \' and \\). Double quotes allow escape sequences (\n, \t) but also no interpolation. F-strings (f'') enable interpolation in Python 3.6+. Triple quotes (''' or """) for multi-line. Unlike PHP where double quotes interpolate variables. Python strings behave similarly for both quote types.

Correct way: super(Child, self).foo() or super().foo() (Python 3). super() calls parent implementation. Python 2 requires class and self arguments. Python 3 simplified: just super().foo(). Calls Base.foo(). super() properly handles MRO. Standard method override pattern.

Use multiprocessing for parallel execution: from multiprocessing import Process, Pool. Bypasses GIL. True parallelism. Example: p = Process(target=func); p.start(); p.join(). Pool for multiple workers. CPU-bound tasks. Alternative: concurrent.futures. Parallel processing module.

After del array[1:3], value is [1, 4, 5, 6]. Deletes elements at indices 1 and 2 (values 2 and 3). Slice [1:3] includes index 1,2 excludes 3. Remaining elements shift. Original [1,2,3,4,5,6] becomes [1,4,5,6]. del removes slice in-place.

Function definition header ends with colon (:). Syntax: def function_name(parameters): Colon marks start of function body. Subsequent lines must be indented. Example: def greet(name): return f'Hello {name}'. Colon required syntax, defines block start. Missing colon causes SyntaxError.

Delete non-empty directory: shutil.rmtree(path). Recursively removes directory and contents. os.rmdir() only works for empty directories. shutil.rmtree() handles non-empty. Example: shutil.rmtree('/temp_files'). Careful: permanent deletion. No recycle bin. Force remove entire tree.

List comprehension is concise syntax for creating lists. Format: [expression for item in iterable if condition]. Example: [x**2 for x in range(10) if x%2==0]. Creates list of squared even numbers. Combines map and filter operations. More readable than loops for simple transformations. Python syntactic sugar.

For accented characters, put u in front for Unicode string in Python 2: u'café'. Python 3 strings are Unicode by default, no prefix needed. Python 2: u prefix for Unicode, no prefix for ASCII. Python 3: all strings Unicode automatically. u prefix allowed but unnecessary in Python 3.

Use collections.ChainMap for combined dict views. Example: ChainMap(dict1, dict2). Searches dicts in sequence. Updates affect first dict. Combined dictionary view.

Use sys.version for Python version string. Example: '3.9.0 (default, ...)'. sys.version_info for tuple: (major, minor, micro, releaselevel, serial). Version checking: if sys.version_info >= (3, 8):. Python version information.