Python Interview Questions

# Clean and expressive syntax in Python:
name = "Think IT Telugu"
role = "AI Engineer"
print(f"Welcome to {name}! Role: {role}")
# Output: Welcome to Think IT Telugu! Role: AI Engineer

x = 100          # x references an integer object
print(type(x))   # Output: <class 'int'>

x = "Telugu"     # x is rebound to a string object
print(type(x))   # Output: <class 'str'>

# Strong typing prevents invalid operations:
try:
    result = "Score: " + 100
except TypeError as e:
    print(f"Error caught: {e}")
    # Output: Error caught: can only concatenate str (not "int") to str

print("Step 1: Processing data...")  # Executes immediately
print("Step 2: Connecting...")       # Executes immediately

# Uncommenting the next line would stop execution at Step 3:
# print(10 / 0)  # ZeroDivisionError occurs here

print("Step 3: Complete!")
# Output:
# Step 1: Processing data...
# Step 2: Connecting...
# Step 3: Complete!

# Immutable Example (String):
s = "hello"
print(f"Original ID: {id(s)}")
s = s + " world"
print(f"New ID:      {id(s)}")  # Different ID! New object created

# Mutable Example (List):
nums = [1, 2, 3]
print(f"List ID before: {id(nums)}")
nums.append(4)
print(f"List ID after:  {id(nums)}")  # Same ID! Modified in-place
# Output shows List ID remains identical, while String ID changes

import sys

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)

print("List Size (bytes): ", sys.getsizeof(my_list))   # e.g. 104 bytes
print("Tuple Size (bytes):", sys.getsizeof(my_tuple))  # e.g. 80 bytes (more lightweight)

# Lists can be modified:
my_list[0] = 99
print("Updated List:", my_list)  # Output: [99, 2, 3, 4, 5]

# Tuples throw TypeError if modified:
try:
    my_tuple[0] = 99
except TypeError as e:
    print("Tuple Error:", e)
    # Output: Tuple Error: 'tuple' object does not support item assignment

a = [1, 2, 3]
b = [1, 2, 3]
c = a  # c points to the exact same memory address as a

print("a == b:", a == b)  # Output: True  (Values are identical)
print("a is b:", a is b)  # Output: False (Distinct objects in memory)
print("a is c:", a is c)  # Output: True  (Same memory address)

# Comparing with None:
result = None
print("is None check:", result is None)  # Output: True

# 1. Break Example: Stops at 3
for i in range(1, 6):
    if i == 3:
        break
    print(f"Break loop: {i}")
# Output: Break loop: 1, Break loop: 2

# 2. Continue Example: Skips 3
for i in range(1, 5):
    if i == 3:
        continue
    print(f"Continue loop: {i}")
# Output: Continue loop: 1, Continue loop: 2, Continue loop: 4

# 3. Pass Example: Placeholder
def future_feature():
    pass  # Syntactically valid without error

x = "Global X"  # Global Scope

def outer():
    x = "Enclosing X"  # Enclosing Scope
    
    def inner():
        x = "Local X"  # Local Scope
        print("Inner sees:", x)
    
    inner()
    print("Outer sees:", x)

outer()
print("Module sees:", x)
# Output:
# Inner sees: Local X
# Outer sees: Enclosing X
# Module sees: Global X

def is_prime(n):
    if n <= 1:
        return False
    # Check divisors up to square root of n:
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

# Test single numbers:
print("is_prime(29):", is_prime(29))  # Output: True
print("is_prime(10):", is_prime(10))  # Output: False

# Find all primes in range [1, 20]:
primes = [num for num in range(1, 21) if is_prime(num)]
print("Primes (1-20):", primes)
# Output: Primes (1-20): [2, 3, 5, 7, 11, 13, 17, 19]

# 1. Iterative List Generation:
def fibonacci_list(n):
    if n <= 0:
        return []
    series = []
    a, b = 0, 1
    for _ in range(n):
        series.append(a)
        a, b = b, a + b
    return series

print("First 8 Fibonacci terms:", fibonacci_list(8))
# Output: First 8 Fibonacci terms: [0, 1, 1, 2, 3, 5, 8, 13]

# 2. Memory-Efficient Generator:
def fibonacci_gen(limit):
    a, b = 0, 1
    while a <= limit:
        yield a
        a, b = b, a + b

print("Fibonacci numbers <= 20:", list(fibonacci_gen(20)))
# Output: Fibonacci numbers <= 20: [0, 1, 1, 2, 3, 5, 8, 13]

# Method 1: String Two-Pointer Check
def is_palindrome_str(s):
    cleaned = "".join(c.lower() for c in s if c.isalnum())
    return cleaned == cleaned[::-1]

print(is_palindrome_str("Race Car"))  # Output: True
print(is_palindrome_str("Python"))    # Output: False

# Method 2: Number Palindrome WITHOUT str() conversion
def is_palindrome_number(num):
    if num < 0:
        return False  # Negative numbers like -121 are not palindromes
    original = num
    reversed_num = 0
    while num > 0:
        digit = num % 10
        reversed_num = (reversed_num * 10) + digit
        num = num // 10
    return original == reversed_num

print("121 is palindrome:", is_palindrome_number(121))  # Output: True
print("123 is palindrome:", is_palindrome_number(123))  # Output: False

from collections import Counter

# Method 1: Optimal O(N) using Counter / Dictionary
def is_anagram(str1, str2):
    # Clean spaces and convert to lowercase
    s1 = str1.replace(" ", "").lower()
    s2 = str2.replace(" ", "").lower()
    return Counter(s1) == Counter(s2)

# Method 2: Using standard dictionary
def is_anagram_manual(str1, str2):
    s1 = str1.replace(" ", "").lower()
    s2 = str2.replace(" ", "").lower()
    if len(s1) != len(s2):
        return False
    counts = {}
    for char in s1:
        counts[char] = counts.get(char, 0) + 1
    for char in s2:
        if char not in counts or counts[char] == 0:
            return False
        counts[char] -= 1
    return True

print(is_anagram("listen", "silent"))    # Output: True
print(is_anagram("Triangle", "Integral")) # Output: True
print(is_anagram("hello", "world"))      # Output: False

def is_armstrong(num):
    num_str = str(num)
    num_digits = len(num_str)
    
    total = sum(int(digit) ** num_digits for digit in num_str)
    return total == num

print("153 is Armstrong:", is_armstrong(153))    # Output: True (1^3 + 5^3 + 3^3 = 153)
print("9474 is Armstrong:", is_armstrong(9474))  # Output: True (9^4 + 4^4 + 7^4 + 4^4 = 9474)
print("123 is Armstrong:", is_armstrong(123))    # Output: False (1^3 + 2^3 + 3^3 = 36 != 123)

# Find Armstrong numbers up to 1000:
armstrongs = [n for n in range(1, 1000) if is_armstrong(n)]
print("Armstrong numbers (1-1000):", armstrongs)
# Output: Armstrong numbers (1-1000): [1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407]

def find_second_largest(numbers):
    if len(numbers) < 2:
        return None
    
    first = second = float('-inf')
    for num in numbers:
        if num > first:
            second = first
            first = num
        elif num > second and num != first:
            second = num
            
    return second if second != float('-inf') else None

print(find_second_largest([12, 35, 1, 10, 34, 1]))  # Output: 34
print(find_second_largest([10, 10, 10]))           # Output: None (No unique 2nd largest)
print(find_second_largest([-5, -1, -10, -2]))      # Output: -2 (Works with negative numbers)

raw_list = [3, 1, 2, 3, 4, 1, 5, 2]

# Method 1: Pythonic O(N) preserving order (Python 3.7+)
unique_ordered = list(dict.fromkeys(raw_list))
print("Preserved Order:", unique_ordered)
# Output: Preserved Order: [3, 1, 2, 4, 5]

# Method 2: Explicit seen set loop (Clean and universal)
def remove_duplicates(lst):
    seen = set()
    result = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            result.append(item)
    return result

print("Seen Set Method:", remove_duplicates(raw_list))
# Output: Seen Set Method: [3, 1, 2, 4, 5]

from collections import Counter

sentence = "apple banana apple orange banana apple"
words = sentence.split()

# Method 1: Standard Dictionary with .get()
word_counts = {}
for word in words:
    word_counts[word] = word_counts.get(word, 0) + 1

print("Word Counts:", word_counts)
# Output: Word Counts: {'apple': 3, 'banana': 2, 'orange': 1}

# Method 2: Using Counter & most_common()
counter = Counter(words)
print("Most Common 2 words:", counter.most_common(2))
# Output: Most Common 2 words: [('apple', 3), ('banana', 2)]

n = 5
for i in range(1, n + 1):
    print("* " * i)

# Output:
# * 
# * * 
# * * * 
# * * * * 
# * * * * *

n = 5
for i in range(n, 0, -1):
    print("* " * i)

# Output:
# * * * * * 
# * * * * 
# * * * 
# * * 
# *

n = 5
for i in range(1, n + 1):
    spaces = " " * (n - i)
    stars = "*" * (2 * i - 1)
    print(spaces + stars)

# Output:
#     *
#    ***
#   *****
#  *******
# *********

n = 5

# Upper Pyramid
for i in range(1, n + 1):
    print(" " * (n - i) + "*" * (2 * i - 1))

# Lower Inverted Pyramid
for i in range(n - 1, 0, -1):
    print(" " * (n - i) + "*" * (2 * i - 1))

# Output:
#     *
#    ***
#   *****
#  *******
# *********
#  *******
#   *****
#    ***
#     *

# 1. Hollow Square:
n = 5
print("Hollow Square:")
for i in range(1, n + 1):
    for j in range(1, n + 1):
        if i == 1 or i == n or j == 1 or j == n:
            print("*", end=" ")
        else:
            print(" ", end=" ")
    print()

# Output:
# * * * * * 
# *       * 
# *       * 
# *       * 
# * * * * * 

# 2. Hollow Right Triangle:
print("\nHollow Triangle:")
for i in range(1, n + 1):
    for j in range(1, i + 1):
        if j == 1 or j == i or i == n:
            print("*", end=" ")
        else:
            print(" ", end=" ")
    print()

# Output:
# * 
# * * 
# *   * 
# *     * 
# * * * * *

n = 4
num = 1

for i in range(1, n + 1):
    for j in range(1, i + 1):
        print(num, end=" ")
        num += 1
    print()

# Output:
# 1 
# 2 3 
# 4 5 6 
# 7 8 9 10

# Sample code that triggers a traceback:
def calculate_average(scores):
    total = sum(scores)
    return total / len(scores)

# Passing an empty list triggers ZeroDivisionError:
try:
    calculate_average([])
except ZeroDivisionError as e:
    import traceback
    print("--- TRACEBACK OUTPUT ---")
    traceback.print_exc()

# Simulated Output:
# Traceback (most recent call last):
#   File "script.py", line 4, in calculate_average
#     return total / len(scores)
# ZeroDivisionError: division by zero

# 1. Python 3.8+ Self-documenting f-strings:
total = 150
discount = 0.2
final_price = total * (1 - discount)
print(f"{total=}, {discount=}, {final_price=}")
# Output: total=150, discount=0.2, final_price=120.0

# 2. Interactive Breakpoint (Uncomment in local terminal):
def process_order(price, tax):
    # breakpoint()  # Pauses execution and opens interactive PDB shell!
    return price + (price * tax)

print("Order Total:", process_order(100, 0.05))
# Output: Order Total: 105.0

# THE BUG:
def add_item_buggy(item, cart=[]):
    cart.append(item)
    return cart

print(add_item_buggy("Apple"))   # Output: ['Apple']
print(add_item_buggy("Banana"))  # Output: ['Apple', 'Banana'] (Oops! Cart was shared!)

# THE FIX:
def add_item_fixed(item, cart=None):
    if cart is None:
        cart = []  # Creates a fresh list on EVERY call
    cart.append(item)
    return cart

print(add_item_fixed("Apple"))   # Output: ['Apple']
print(add_item_fixed("Banana"))  # Output: ['Banana'] (Clean and independent!)

# THE BUG:
nums = [1, 2, 2, 3, 4]
for num in nums:
    if num == 2:
        nums.remove(num)
print("Buggy result:", nums)
# Output: Buggy result: [1, 2, 3, 4]  (One '2' was SKIPPED!)

# THE FIX (Method 1: List Comprehension):
nums2 = [1, 2, 2, 3, 4]
filtered_nums = [x for x in nums2 if x != 2]
print("Fixed result:", filtered_nums)
# Output: Fixed result: [1, 3, 4]

# THE FIX (Method 2: Iterate over copy):
nums3 = [1, 2, 2, 3, 4]
for num in nums3[:]:  # Slicing creates a snapshot copy
    if num == 2:
        nums3.remove(num)
print("Copy loop result:", nums3)
# Output: Copy loop result: [1, 3, 4]

counter = 0

# THE BUG:
def increment_buggy():
    # counter += 1  # UnboundLocalError: local variable 'counter' referenced before assignment
    pass

# THE FIX (Method 1: Global Keyword):
def increment_fixed():
    global counter
    counter += 1

increment_fixed()
print("Counter after global fix:", counter)  # Output: Counter after global fix: 1

# THE FIX (Method 2: Pure Function - Recommended):
def increment_pure(val):
    return val + 1

score = increment_pure(10)
print("Pure function score:", score)  # Output: Pure function score: 11

class Animal:
    def speak(self):
        return "Some sound"

class Dog(Animal):  # Inheritance
    def speak(self):  # Polymorphism (Method Overriding)
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

# Polymorphic iteration:
animals = [Dog(), Cat()]
for a in animals:
    print(f"{a.__class__.__name__}: {a.speak()}")
# Output:
# Dog: Woof!
# Cat: Meow!

class Student:
    def __init__(self, name, marks):
        self.name = name    # Instance variable bound to self
        self.marks = marks

    def get_result(self):
        return "Pass" if self.marks >= 40 else "Fail"

s1 = Student("Sai", 85)
s2 = Student("Rahul", 32)

print(f"{s1.name}: {s1.get_result()}")  # Output: Sai: Pass
print(f"{s2.name}: {s2.get_result()}")  # Output: Rahul: Fail

import copy

original = [[1, 2, 3], [4, 5, 6]]

# 1. Shallow Copy
shallow = copy.copy(original)
shallow[0][0] = 999  # Modifies nested list!
print("Original after shallow edit:", original)
# Output: Original after shallow edit: [[999, 2, 3], [4, 5, 6]] (Changed!)

# 2. Deep Copy
original2 = [[1, 2, 3], [4, 5, 6]]
deep = copy.deepcopy(original2)
deep[0][0] = 999
print("Original after deep edit:   ", original2)
# Output: Original after deep edit:    [[1, 2, 3], [4, 5, 6]] (Protected!)

import time

# Decorator to measure execution time:
def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        duration = time.time() - start
        print(f"[{func.__name__}] Execution Time: {duration:.5f}s")
        return result
    return wrapper

@timer_decorator
def compute_squares():
    return sum(i * i for i in range(100_000))

total = compute_squares()
# Output:
# [compute_squares] Execution Time: 0.00612s

import sys

# 1. List (Eager Evaluation - Uses Memory):
num_list = [i for i in range(1_000_000)]
print("List Memory (bytes):", sys.getsizeof(num_list))  # ~8.4 MB in RAM

# 2. Generator Expression (Lazy Evaluation - O(1) Memory):
num_gen = (i for i in range(1_000_000))
print("Gen Memory (bytes): ", sys.getsizeof(num_gen))   # ~104 bytes in RAM!

# Fetch first 3 values from generator:
print("Next 1:", next(num_gen))  # Output: 0
print("Next 2:", next(num_gen))  # Output: 1
print("Next 3:", next(num_gen))  # Output: 2

# CPU-bound tasks should use multiprocessing, not threading:
from multiprocessing import Process

def heavy_calculation(n):
    return sum(i * i for i in range(n))

if __name__ == "__main__":
    p1 = Process(target=heavy_calculation, args=(10_000_000,))
    p2 = Process(target=heavy_calculation, args=(10_000_000,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print("Multiprocessing finished utilizing multi-core CPU!")
# Output: Multiprocessing finished utilizing multi-core CPU!

import sys
import gc

# 1. Reference Counting:
a = [1, 2, 3]
print("Initial refcount:", sys.getrefcount(a) - 1)  # 1 reference

b = a  # 2nd reference
print("Refcount after b=a:", sys.getrefcount(a) - 1)  # 2 references

del b  # Decrement count
print("Refcount after del b:", sys.getrefcount(a) - 1)  # 1 reference

# 2. Circular Reference Example:
node1 = {}
node2 = {}
node1["next"] = node2
node2["prev"] = node1  # Circular loop!

del node1
del node2  # Reference count is 1, but objects are unreachable!
# Python's cyclic GC runs in background to collect them:
collected = gc.collect()
print(f"Cyclic GC collected {collected} unreachable objects.")
# Output: Cyclic GC collected unreachable objects

def introduce_team(team_name, *members, **details):
    print(f"Team: {team_name}")
    print("Members (Tuple):", members)
    print("Details (Dict):  ", details)

introduce_team(
    "Think IT AI",
    "Sai", "Kiran", "Divya",
    project="Docs Platform",
    version=2.0
)

# Output:
# Team: Think IT AI
# Members (Tuple): ('Sai', 'Kiran', 'Divya')
# Details (Dict):   {'project': 'Docs Platform', 'version': 2.0}