HCL Python Interview Questions and Answers

Python is an interpreted, high-level, dynamically typed language with simple syntax, rich standard library, and strong ecosystem. It supports multiple paradigms (procedural, OOP, functional). Common uses: web backends, scripting/automation, data science, ML, testing, DevOps, and quick prototyping.

Python 3 improved Unicode support (strings are Unicode), changed print to a function, integer division (/ returns float, // floor-divides), and removed old constructs. Python 2 is end-of-life—use Python 3 for new projects.

PEP 8 is the official Python style guide recommending naming, indentation, line length, imports ordering, etc. Following it improves code readability, maintainability, and team consistency.

Mutable types (can change in place): list, dict, set, bytearray.
Immutable types (cannot change): int, float, str, tuple, frozenset.
Mutability affects aliasing and function behavior (in-place modifications vs returning new objects).

CPython uses reference counting plus a cyclic garbage collector for unreachable cycles. Objects are on a private heap; small-object allocators and memory pools reduce fragmentation. You can tune/inspect via the gc module.

GIL is a mutex in CPython that allows only one thread to execute Python bytecode at a time. It limits CPU-bound parallelism with threads; threads remain useful for I/O-bound tasks. Use multiprocessing or C extensions to bypass GIL for CPU-bound work.

== compares value equality (calls __eq__), while is compares object identity (same object in memory). Example: two equal lists == True but is False.

Create with python -m venv envname. Activate: source envname/bin/activate (Linux/macOS) or envname\Scripts\activate (Windows). Install packages inside with pip. Deactivate with deactivate. Use pip freeze > requirements.txt to capture deps.

Concise syntax to build lists from iterables with optional filtering.

evens = [x for x in range(10) if x % 2 == 0]

A decorator wraps a function to extend behavior without modifying it.

def log_calls(fn): def wrapper(*args, **kwargs): print(f"Calling {fn.__name__}") return fn(*args, **kwargs) return wrapper @log_calls def greet(name): return f"Hello, {name}" 

*args collects extra positional args as a tuple; **kwargs collects extra keyword args as a dict. Useful for flexible APIs and forwarding arguments.

try runs risky code; except handles exceptions; else runs if no exception; finally runs always (cleanup). Example flow: try → except (if error) → else (if no error) → finally (always).

A generator is a function that yields values one at a time and maintains internal state, enabling lazy, memory-efficient iteration. Use yield to emit values instead of returning a list.

Instance methods get self; operate on instance.

@classmethod gets cls; operate on class/state.

@staticmethod receives no implicit first arg; utility function inside class namespace.

map(fn, seq) applies fn to each item.

filter(fn, seq) keeps items where fn(item) True.

functools.reduce(fn, seq) reduces sequence to a single value by cumulative application.

Use with open(…) as f: to ensure files close automatically, even on errors.

with open('data.txt') as f: for line in f: process(line)

__repr__ should be unambiguous (developer-facing) and ideally evaluable; __str__ is user-friendly. If only __repr__ exists, it’s used as fallback.

Shallow copy copies top-level container but shares nested objects. Deep copy recursively copies nested objects. Use deepcopy when you need fully independent nested structures.

Use seen set:

def dedupe(seq): seen = set() out = [] for x in seq: if x not in seen: seen.add(x) out.append(x) return out

Or list(dict.fromkeys(seq)) (maintains insertion order).

Use sorted with a key:

sorted_items = sorted(d.items(), key=lambda kv: kv[1]) sorted_dict = {k: v for k, v in sorted_items}

A module is a .py file. A package is a directory (often with __init__.py). import module loads and executes the module, caching it in sys.modules. Use absolute or relative imports within packages.

Monkey patching modifies code at runtime (e.g., replacing a function in a library during tests). Useful for mocking, but risky in production—can create hidden side effects and maintenance issues.

Use pdb or ipdb, IDE debuggers, logging (logging module), print debugging when quick. For complex issues, use stack traces, unit tests, and profilers.

Use cProfile, profile, pyinstrument, line_profiler (for line-level), and visualization tools like snakeviz. Identify hotspots and optimize algorithms or use C-accelerated libraries.

import re def is_palindrome(s): cleaned = re.sub(r'[^A-Za-z0-9]', '', s).lower() return cleaned == cleaned[::-1]

list.sort() sorts in-place and returns None. sorted() returns a new list and leaves original intact. Both accept key and reverse.

def merge(a, b): i = j = 0 out = [] while i < len(a) and j < len(b): if a[i] <= b[j]: out.append(a[i]); i += 1 else: out.append(b[j]); j += 1 out.extend(a[i:]) out.extend(b[j:]) return out

Python uses C3 linearization to compute MRO, ensuring consistent order without duplicates. Inspect with Class.mro() or Class.__mro__. MRO determines which method is used in diamond patterns.

__slots__ declares fixed attributes for instances to avoid per-instance __dict__, saving memory and slightly speeding attribute access. Use for many small objects; complicates dynamic attribute addition and some inheritance.

Use a metaclass with a lock:

import threading class SingletonMeta(type): _instances = {} _lock = threading.Lock() def __call__(cls, *args, **kwargs): with cls._lock: if cls not in cls._instances: cls._instances[cls] = super().__call__(*args, **kwargs) return cls._instances[cls]

namedtuple: lightweight records.

deque: fast append/pop both ends.

defaultdict: auto default values for missing keys.

Counter: frequency counting with most_common().

A decorator that caches function results by arguments (LRU eviction). Great for expensive pure functions (e.g., recursive Fibonacci) to avoid recomputation.

async def defines coroutines; await suspends until awaitable completes. Use asyncio for high-concurrency I/O-bound applications (many open connections) with cooperative scheduling; use threads/processes for CPU-bound tasks.

threading shares memory, good for I/O-bound tasks. multiprocessing spawns processes (separate memory) to bypass GIL—use for CPU-bound parallelism.

Use collections.OrderedDict / dict (3.7+) and move_to_end() to track recency. On get, move key to end; on put, evict popitem(last=False) when over capacity.

Provide a custom encoder or convert fields before json.dumps():

import json, datetime class DateEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, datetime.datetime): return obj.isoformat() return super().default(obj)

Unpickling can execute arbitrary code from crafted byte streams. Never unpickle untrusted input. Prefer JSON or use restricted/untrusted-safe serializers or validate inputs strictly.

Read file line-by-line, parse code, update collections.Counter(); use most_common(k) at end. For extreme scale, use external map-reduce, partitioning, or approximate sketches (Count-Min Sketch).

Sort and use two pointers (left, right). Move pointers depending on sum relative to target. O(n log n) due to sort, O(n) two-pointer pass.

Closure: inner function captures variables from enclosing scope even after outer returns. Useful for factories and callbacks.

def make_multiplier(n): def mul(x): return x * n return mul times3 = make_multiplier(3) 

Descriptors implement __get__, __set__, __delete__ to control attribute access. property is a descriptor that wraps getter/setter methods for managed attributes (validation, computed properties).

Use a decorator that catches exceptions and sleeps base * 2**attempt (with jitter) between retries, up to max_attempts. Example pattern used for network calls.

Maintain two heaps: a max-heap for lower half and min-heap for upper half; balance sizes. Insertion O(log n), median retrieval O(1).

Use importlib:

import importlib m = importlib.import_module('mypkg.mymodule') Cls = getattr(m, 'MyClass') inst = Cls()

bytes immutable, bytearray mutable. memoryview views underlying buffer without copying—useful for slicing large binary buffers efficiently (zero-copy).

Use a DB driver (psycopg2 for Postgres), connection pooling (e.g., sqlalchemy.pool), and ORM (SQLAlchemy) or parameterized raw SQL. Use transactions, parameterized queries to prevent SQL injection.

Example unittest:

import unittest from mymodule import add class TestAdd(unittest.TestCase): def test_add(self): self.assertEqual(add(2, 3), 5) if __name__ == '__main__': unittest.main()

Structure answer with: context (what was slow), measurement (profiling tool and hotspot), action (algorithm change, caching, native libs), and result (performance improvement with numbers).

Sketch (FastAPI recommended for built-in validation with Pydantic):

from fastapi import FastAPI from pydantic import BaseModel app = FastAPI() class Item(BaseModel): name: str price: float @app.post("/items") def create_item(item: Item): return {"status": "ok", "item": item}

Production: add auth, rate-limit, input size checks, logging, and schema versioning.

Use HTTPS/TLS, validate & sanitize inputs, use parameterized DB queries to prevent SQL injection, implement proper auth/authorization (JWT/OAuth), manage secrets securely, enable rate-limiting, set secure headers, and use vulnerability scanning/patching.