Question 1

What are traits in Scala, and how are they different from classes?

Accepted Answer

**Traits**: Interface-like constructs that can define abstract and concrete methods/fields. Support multiple inheritance of type. Mixed in via `with`.

**Classes**: Define objects with state and behavior. Single inheritance; one superclass.

**Key Differences**: Traits enable composition; classes define core logic. Traits can be partially implemented; classes hold primary behavior....

Question 2

Explain the difference between args and kwargs in Python.

Accepted Answer

*args: Variable positional args, received as tuple. **kwargs: Variable keyword args, received as dict. Why: Flexible signatures—wrappers, decorators, config-driven functions. Example: def run_pipeline(*sources, **config): ... allows run_pipeline('s3://a','s3://b', parallelism=4). Order: (regular, *args, keyword-only, **kwargs). Pitfall: Passing through—func(*args, **kwargs)—preserves interface. In data pipelines: **kwargs for optional connector params (region, timeout, retries)....

Question 3

Explain the difference between shallow copy and deep copy in Python.

Accepted Answer

Shallow (copy.copy()): New top-level object; nested objects are references. Nested mutations affect original. Deep (copy.deepcopy()): Recursive copy; fully independent. Why it matters: Shallow is O(n) for top level only; deep is O(n) for entire structure—can be slow for large nested dicts. Use shallow when: No nested mutables or shared refs OK. Use deep when: Need full isolation (e.g., config that will be modified)....

Question 4

What are decorators in Python, and how do they work?

Accepted Answer

Decorator: Higher-order function that wraps another function; @decorator syntax. Implementation: def timer(f): def wrapper(*args, **kwargs): start=time(); r=f(*args,**kwargs); print(time()-start); return r; return wrapper. Why: Cross-cutting concerns—logging, retries, auth, caching—without cluttering business logic. In data pipelines: @retry, @logged, @rate_limited on API fetchers. Scalability: Decorators add indirection; overuse can make stack traces deep....

Question 5

What is the difference between a list and a tuple in Python?

Accepted Answer

List: Mutable, []; tuple: immutable, (). Why it matters: Mutability drives use—lists for collections that change; tuples for fixed data, dict keys (hashable), multiple return values. Performance: Tuples are slightly faster (less overhead, fixed size). Hashability: Tuples can be dict keys/set members; lists cannot. In data pipelines: Tuples for schema-like rows (column names); lists for buffers, accumulators....

Question 6

Write a Python function to check if a string is a palindrome.

Accepted Answer

**Architectural logic**: A palindrome reads the same forwards and backwards. We need to normalize (case, non-alphanumeric) and compare. **Approach 1 (string ops)**: `cleaned = "".join(c.lower() for c in s if c.isalnum()); return cleaned == cleaned[::-1]`—O(n) time, O(n) space. **Approach 2 (two-pointer)**: Compare from both ends; O(n) time, O(1) space if not normalizing....

Question 7

Write a Python function to find the first non-repeating character in a string.

Accepted Answer

Approach: Two-pass—count chars, then find first with count 1. Code: def first_non_repeating(s): counts = {}; [counts.update({c: counts.get(c, 0) + 1}) for c in s]; return next((c for c in s if counts[c] == 1), None). Or: from collections import Counter; counts = Counter(s); return next((c for c in s if counts[c] == 1), None). Complexity: O(n) time, O(k) space. Why: Single pass can't know if char is unique until full scan....

Question 8

Explain the difference between a list and a tuple in Python.

Accepted Answer

**List**: Mutable; defined with `[]`; elements can be added, removed, or changed. **Tuple**: Immutable; defined with `()`; elements cannot be changed after creation. **Why it matters architecturally**: Tuples are hashable (if elements are hashable)—usable as dict keys and in sets; lists are not. Tuples have lower memory overhead and faster iteration....

Question 9

Explain the difference between args and kwargs in Python.

Accepted Answer

**`*args`**: Variable positional arguments; received as a tuple. **`**kwargs`**: Variable keyword arguments; received as a dict. **Example**: `def f(*args, **kwargs): print(args, kwargs)` → `f(1,2,a=3)` → `(1, 2) {'a': 3}`. **Why it matters**: Enables flexible APIs (delegation, wrappers, logging). **Architectural use**: Pass-through to other functions; optional parameters without exploding the signature....

Question 10

How do you handle exceptions in Python? Provide an example.

Accepted Answer

Use `try` / `except` / `else` / `finally`. **Example**: `try: x = 1/0
except ZeroDivisionError as e: logging.error(e)
else: print("ok")
finally: resource.close()` **Why it matters**: Proper handling avoids cascading failures and enables cleanup. **Architectural implication**: Bare `except:` swallows all exceptions including `KeyboardInterrupt`—dangerous in production. Use specific exceptions and re-raise when needed....

Top Python Interview Questions for Data Engineers

Companies asking these questions

All 50 Questions

More Interview Prep Guides

Get All Answers in PDF Format

Top Python Interview Questions for Data Engineers

Companies asking these questions

All 50 Questions

More Interview Prep Guides

Get All Answers in PDF Format