Python MCQ

Explanation

print() is the built-in Python function for outputting text to the standard output.

Explanation

Python uses dynamic typing — you simply assign a value. No type keyword or declaration is required.

Explanation

In Python 3, / always returns a float (3.5). Use // for integer (floor) division.

Explanation

Python uses def to declare functions, followed by the function name and parameters.

Explanation

[1, 2, 3] is a list literal in Python. type() returns <class 'list'>.

Explanation

Python uses # for single-line comments. Multi-line comments are typically written as consecutive # lines or string literals.

Explanation

len() returns the number of elements in a list, string, tuple, dict, or other sequence/collection.

Explanation

Tuples are created with parentheses. They are immutable, unlike lists which use square brackets.

Explanation

Python if statements don't require parentheses around the condition, but require a colon at the end. Python is case-sensitive.

Explanation

PEP 8 is Python's official style guide covering naming conventions, indentation (4 spaces), line length, and more.

Explanation

Slicing [1:4] returns characters at indices 1, 2, 3 (exclusive of 4): 'y', 't', 'h' → "yth".

Explanation

break immediately exits the innermost enclosing for or while loop.

Explanation

Python dicts store key-value pairs with O(1) average lookup. Since Python 3.7, insertion order is maintained.

Explanation

import math loads the math module. You can also use from math import sqrt to import specific names.

Explanation

[x**2 for x in range(10) if x % 2 == 0] creates a list of even squares concisely.

Explanation

In Python, 0, empty strings, empty lists, empty dicts, and None are all falsy. bool(0) returns False.

Explanation

list.append(item) adds item to the end of the list in O(1) amortized time.

Explanation

range(5) generates numbers 0 through 4 (5 exclusive). It returns a lazy range object, not a list.

Explanation

lambda x: x * 2 creates an anonymous function. Lambdas are limited to a single expression.

Explanation

is checks identity (same memory address). == checks equality (same value). Use is for None checks: if x is None.

Explanation

pass is a no-op statement used as a placeholder where syntax requires a statement but no action is needed.

Explanation

Python uses try/except for exception handling, with optional else (no exception) and finally (always runs) blocks.

Explanation

!= is the not-equal operator in Python 3. The <> operator was removed in Python 3.

Explanation

** is the exponentiation operator in Python. 2 ** 3 = 2³ = 8.

Explanation

int("42") converts the string "42" to the integer 42. int(3.9) truncates to 3.

Explanation

3 in [1, 2, 3] returns True. For lists this is O(n); for sets and dict keys it is O(1).

Explanation

Lists can be modified after creation (append, remove, etc.). Tuples cannot be changed, making them hashable and usable as dict keys.

Explanation

" hello ".strip() returns "hello". Use lstrip() or rstrip() to strip only one side.

Explanation

Python uses the class keyword. The parentheses can optionally specify a base class (class Child(Parent):).

Explanation

__init__ is the constructor called automatically when you create an instance with MyClass().

Explanation

By convention, the first parameter of instance methods is named self and refers to the current instance. cls is used for class methods.

Explanation

Without global x, assigning x = value inside a function creates a local variable. global x tells Python to use the module-level x.

Explanation

Sets store unique elements with O(1) add/remove/lookup. They are unordered and do not support indexing.

Explanation

dict.keys() returns a view of all dictionary keys. dict.values() returns values, and dict.items() returns (key, value) pairs.

Explanation

None is the sole instance of NoneType in Python, representing the absence of a value.

Explanation

continue skips the rest of the loop body for the current iteration and proceeds to the next.

Explanation

Tuples, strings, integers, and frozensets are immutable. Lists, dicts, and sets are mutable.

Explanation

open("file.txt") opens a file in read mode ("r") by default. Use with open("file.txt") as f: for safe resource management.

Explanation

__str__ is called by str() and print(). Defining it makes your objects display meaningfully.

Explanation

for i, val in enumerate(["a","b","c"]) yields (0,"a"), (1,"b"), (2,"c"), avoiding manual index tracking.

Explanation

Generators use yield to lazily produce values, consuming O(1) memory regardless of the sequence length. They are iterable but not reusable.

Explanation

staticmethod has no access to instance or class. classmethod gets cls, useful for alternative constructors and factory methods.

Explanation

def f(*args) captures any number of positional arguments as a tuple. **kwargs captures keyword arguments as a dict.

Explanation

Decorators (using @syntax) are higher-order functions that take a function and return a modified version. Common uses: logging, caching, access control.

Explanation

__slots__ = ["x", "y"] prevents __dict__ creation per instance, saving memory when creating many small objects.

Explanation

The GIL means CPython threads can't run Python bytecode truly in parallel. I/O-bound tasks benefit from threading; CPU-bound tasks need multiprocessing.

Explanation

@lru_cache(maxsize=128) memoizes function results, making repeated calls with the same arguments O(1) instead of recomputing.

Explanation

copy.copy() creates a shallow copy; nested objects are still shared. copy.deepcopy() recursively creates independent copies of all nested objects.

Explanation

Python supports multiple inheritance. The Method Resolution Order (MRO) follows C3 linearization to determine which parent's method to call.

Explanation

with open("file") as f: calls __enter__ on entry and __exit__ on exit (even on exception), ensuring the file is always closed.

Explanation

yield from sub_gen() delegates iteration to sub_gen, forwarding sends and throws, simplifying generator composition.

Explanation

__repr__ should ideally return a string that can recreate the object. __str__ is for human-readable output. If __str__ is missing, Python falls back to __repr__.

Explanation

Metaclasses (usually type subclasses) intercept class creation. They're used by frameworks like Django ORM to add dynamic behavior to model classes.

Explanation

@property allows a method to be accessed like an attribute (obj.value instead of obj.value()). Use @name.setter and @name.deleter for write/delete access.

Explanation

Monkey patching modifies classes or modules at runtime (e.g., in tests). It's powerful but can make code hard to understand and maintain.

Explanation

__all__ = ["ClassA", "func_b"] controls what from module import * imports. Without it, all names not starting with _ are exported.

Explanation

CPython caches small integers (-5 to 256), so a is b may be True for them — but this is an implementation detail, not guaranteed. Always use == for value comparison.

Explanation

asyncio provides an event loop for async I/O. async def and await allow non-blocking I/O without threads, ideal for network servers and clients.

Explanation

defaultdict(list) returns an empty list for missing keys. This avoids explicit key existence checks when building dicts of lists.

Explanation

Descriptors power @property, classmethod, and staticmethod. They allow custom logic when an attribute is accessed, set, or deleted.

Explanation

Multiple processes each have their own GIL, enabling true parallelism for CPU-bound work. Threads share memory but the GIL prevents CPU-bound parallelism in CPython.

Explanation

Counter("banana") returns Counter({'a': 3, 'n': 2, 'b': 1}). It supports most_common() and arithmetic operations.

Explanation

while chunk := f.read(1024): processes and assigns in one step. Added in Python 3.8.

Explanation

frozenset({1, 2, 3}) is immutable and hashable. Regular sets are mutable and unhashable, so they can't be used as dict keys.

Explanation

__enter__ is called when entering a with block; __exit__ is called when leaving (even on exception), handling teardown and optional exception suppression.

Explanation

chain([1, 2], [3, 4]) yields 1, 2, 3, 4 without creating a new list. Useful for memory-efficient iteration over multiple sequences.

Explanation

zip([1,2],['a','b']) yields (1,'a'),(2,'b'). It stops at the shortest iterable. Use itertools.zip_longest to pad shorter ones.

Explanation

namedtuple("Point", ["x", "y"]) creates a tuple subclass whose fields are accessible as attributes (p.x) as well as by index (p[0]).

Explanation

nonlocal x in a nested function allows modifying x from the enclosing (not global) scope, enabling closures that mutate state.

Explanation

__slots__ = ["x", "y"] prevents __dict__ creation per instance, reducing memory significantly when creating many instances.

Explanation

partial(pow, 2) creates a callable equivalent to pow(2, x). Useful for adapting functions to expected signatures.

Explanation

A regular Lock deadlocks if the same thread acquires it twice. RLock (Reentrant Lock) tracks the owning thread and a count, allowing the same thread to acquire it multiple times.

Explanation

Override __getattribute__ to intercept all attribute access (risky). Override __getattr__ for a fallback when normal lookup fails — safer and more common.

Explanation

@property @abstractmethod def area(self) in an ABC forces subclasses to implement the area property.

Explanation

@contextmanager def managed(): setup(); try: yield value; finally: teardown() creates a context manager without writing a class.

Explanation

results = await asyncio.gather(fetch(url1), fetch(url2), fetch(url3)) runs all three concurrently and collects results in order.

Explanation

multiprocessing.Process creates separate OS processes with independent GILs, enabling true CPU parallelism. Threading shares memory but only one thread runs Python bytecode at a time.

Explanation

__new__(cls) is called first and must return an instance. __init__(self) is called on the returned instance. Subclassing int or str requires overriding __new__.

Explanation

deepcopy() handles circular references and complex objects in memory. pickle serializes to a byte stream. Both can handle custom objects but via different mechanisms.

Explanation

class MyList: def __class_getitem__(cls, item): return GenericAlias(cls, item) allows MyList[int] syntax used by the typing module.

Explanation

CPython uses reference counting as the primary mechanism. Because cycles prevent counts from reaching zero, a generational cyclic GC (gc module) handles them.

Explanation

When Python looks up an attribute and finds a descriptor (data descriptor: has __set__) in the class, it calls descriptor.__get__(instance, type). @property builds a data descriptor.

Explanation

MyClass.__mro__ is a tuple of the class itself and all ancestors in C3 linearization order. Python searches this sequence when resolving attribute names.

Explanation

Both generators and coroutines rely on the same suspension mechanism. Coroutines (PEP 492) are specialized for async I/O, using await to suspend on awaitables.

Explanation

__new__(cls) allocates and returns a new instance. You override it when subclassing immutable types (like int or str) or implementing singleton patterns.

Explanation

Magic methods like __add__, __len__, __iter__, __enter__ integrate custom objects into Python's syntax and built-in functions, following the data model.

Explanation

import triggers sys.meta_path finders (PathFinder, etc.). If the module is already in sys.modules it's returned immediately. Otherwise, a loader executes the module file.

Explanation

ABCs (from abc module) raise TypeError at instantiation if abstract methods aren't implemented. They also support virtual subclassing via register().

Explanation

The default limit is 1000. Increasing it allows deeper recursion but can crash the interpreter with a C stack overflow if pushed too far. Consider iteration or tail-call elimination instead.

Explanation

@dataclass(eq=True, order=False, frozen=False) generates common dunder methods from annotated fields, reducing boilerplate while remaining a regular class.

Explanation

Python attribute lookup: data descriptors (have __set__) take priority over instance __dict__, which takes priority over non-data descriptors and class attributes.

Explanation

Python 3.2+ uses a 5ms (sys.getswitchinterval()) interval. The GIL is released for I/O and C extensions. Multi-threaded pure-Python CPU code is effectively serialized.

Explanation

Each function call creates a PyFrameObject. The CPython bytecode eval loop (ceval.c) reads opcodes from f_code.co_code and uses f_localsplus for locals and the stack.

Explanation

importlib.import_module() is the recommended way to import by string name. importlib.util allows creating custom finders, loaders, and module specs.

Explanation

Python 3.13 introduces a --disable-gil build (PYTHON_GIL=0). It removes the GIL to allow true multi-core parallelism at the cost of some single-threaded performance and compatibility.

Explanation

sys.settrace(handler) installs a per-thread trace function called for "call", "line", "return", "exception" events. pdb, coverage.py, and pytest use this mechanism.

Explanation

a = 256; b = 256; a is b is True (same object). a = 257; b = 257; a is b may be False. This is a CPython implementation detail, not a language guarantee.

Explanation

__reduce__ returns (callable, args) tuple. pickle calls callable(*args) to reconstruct. __reduce_ex__ takes a protocol version. Useful for customizing pickling of C extension types.

Explanation

r = weakref.ref(obj); obj = None; r() returns None after GC. weakref.WeakValueDictionary automatically removes entries when values are GC'd.

Explanation

PEP 342 added send(value) and throw(exc) to generators. This enabled coroutine-like behavior before async/await. PEP 492 (Python 3.5) formalized native coroutines (async def).

Explanation

bytearray is mutable; bytes is immutable. Use bytearray when building binary protocols incrementally to avoid creating many immutable bytes objects.