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 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 3

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....

Question 4

What is the difference between shallow copy and deep copy in Python?

Accepted Answer

**Shallow copy** (`copy.copy()`): New top-level object; nested objects are references. Mutating nested objects in the copy affects the original. **Deep copy** (`copy.deepcopy()`): Recursive copy of all nested objects; fully independent. **Why it matters**: Shallow copy is cheaper but can cause subtle bugs when sharing nested structures. **Scalability trade-off**: Deep copy is O(total objects) and can be slow/hung on cycles without special handling....

Question 5

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

Accepted Answer

**Approach**: Two passes—first to count, second to find first with count 1. **Code**: `def first_non_repeating(s): counts = {}; [counts.update({c: counts.get(c, 0) + 1}) or None for c in s]; return next((c for c in s if counts[c] == 1), None)`. Simpler: `for c in s: counts[c] = counts.get(c,0)+1; return next((c for c in s if counts[c]==1), None)`. **Complexity**: O(n) time, O(k) space (k = distinct chars)....

Question 6

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

Accepted Answer

**Decorators** are higher-order functions that wrap another function to add or change behavior. Syntax: `@decorator` before a function. Under the hood: `@deco` is equivalent to `func = deco(func)`. **Why it matters**: Cross-cutting concerns (logging, timing, retries, auth) without modifying core logic. **Architectural benefit**: Separation of concerns; reusable wrappers. **Example**: `def retry(n):
  def wrap(f):
    def inner(*a,**k): ... return f(*a,**k)
    return inner
  return wrap`....

Question 7

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 8

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

Accepted Answer

**Approach**: Normalize (lowercase, alphanumeric only) and compare with reverse. **Code**: `def is_palindrome(s): cleaned = "".join(c.lower() for c in s if c.isalnum()); return cleaned == cleaned[::-1]`. **Two-pointer** (O(1) space, early exit): `lo, hi = 0, len(s)-1; while lo < hi: ... if not s[lo].isalnum(): lo+=1; continue; ... if s[lo].lower() != s[hi].lower(): return False; lo, hi = lo+1, hi-1; return True`. **Clarify**: Case sensitivity? Non-alphanumeric? Empty string (usually True)....

Question 9

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

Accepted Answer

**List**: Ordered; allows duplicates; indexable; O(n) lookup. **Set**: Unordered; unique elements only; hash-based; O(1) average lookup. **Why it matters**: Set membership and deduplication are fast; lists preserve order and support duplicates. **Scalability trade-off**: Sets use more memory per element (hash + overhead); lists are compact. For large dedup, set wins on lookup; for ordered data, list is required. **Cost implication**: Repeated `x in list` is O(n) per check; `x in set` is O(1)....

Question 10

How do you handle memory management in Python?

Accepted Answer

**Mechanisms**: (1) Reference counting—object freed when refcount=0; (2) Cycle detector (gc)—handles circular refs; (3) PyMalloc—small object pools. **Manual tools**: `del` to drop refs; `gc.collect()` to force cycle detection; `gc.set_threshold()` to tune. **Why it matters**: Long-running services (ETL, APIs) can leak via cycles or unclosed resources. **Scalability trade-off**: Large heaps increase GC pause; generators/iterators reduce peak memory....

Infosys Python Interview Questions

Difficulty Breakdown

Key Topics Covered

How to Use This Guide

Companies asking these questions

All 12 Questions

More Interview Prep Guides

Unlock All Expert Answers