Python Programming: 50+ Fresher Interview Questions & Answers (2026)

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)  # True (same values)
print(a is b)  # False (different objects)
print(a is c)  # True (same object)

def timer_decorator(func):
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"Function {func.__name__} took {end-start:.2f} seconds")
        return result
    return wrapper

@timer_decorator
def long_running_function():
    time.sleep(2)
    return "Done"

long_running_function()

# Traditional approach
squares = []
for x in range(10):
    squares.append(x**2)

# Using list comprehension
squares = [x**2 for x in range(10)]

# With condition
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# Nested comprehension
matrix = [[i*j for j in range(3)] for i in range(3)]

# Syntax: lambda arguments: expression
add = lambda x, y: x + y

# Common use cases
# 1. With map()
numbers = [1, 2, 3, 4]
squared = list(map(lambda x: x**2, numbers))

# 2. With filter()
even = list(filter(lambda x: x % 2 == 0, numbers))

# 3. With sorted()
students = [{'name': 'Alice', 'grade': 85},
           {'name': 'Bob', 'grade': 90}]
sorted_students = sorted(students, key=lambda x: x['grade'])

def example_function(arg1, *args, **kwargs):
    print(f"First argument: {arg1}")
    print(f"Additional args: {args}")
    print(f"Keyword args: {kwargs}")

example_function(1, 2, 3, 4, name="John", age=25)

import copy

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

# Shallow copy - Only copies references to nested objects
shallow = copy.copy(original)
shallow[0][0] = 99  # Affects original
print(original)  # [[99, 2], [3, 4]]

# Deep copy - Creates new copies of all nested objects
deep = copy.deepcopy(original)
deep[0][0] = 100  # Doesn't affect original
print(original)  # [[99, 2], [3, 4]]

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"{self.name}, {self.age} years old"
    
    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

p = Person("Alice", 25)
print(str(p))   # Alice, 25 years old
print(repr(p))  # Person('Alice', 25)

class A:
    def method(self):
        print("A")

class B(A):
    def method(self):
        print("B")

class C(A):
    def method(self):
        print("C")

class D(B, C):
    pass

d = D()
d.method()  # Output: B (follows MRO: D -> B -> C -> A)
print(D.__mro__)  # Shows method resolution order

def fibonacci_generator(n):
    a, b = 0, 1
    count = 0
    while count < n:
        yield a
        a, b = b, a + b
        count += 1

# Usage
for num in fibonacci_generator(10):
    print(num)

# Memory efficient - generates values on the fly

# Creation
student = {'name': 'John', 'age': 21, 'grade': 'A'}

# Access
print(student['name'])  # John
print(student.get('age', 'Not found'))  # Safe access

# Operations
student['age'] = 22  # Update
student['city'] = 'NYC'  # Add
del student['grade']  # Delete

# Methods
keys = student.keys()
values = student.values()
items = student.items()

# Dictionary comprehension
squares = {x: x**2 for x in range(5)}

# Creation
fruits = {'apple', 'banana', 'orange'}

# Operations
fruits.add('grape')
fruits.remove('apple')

# Set operations
set1 = {1, 2, 3}
set2 = {3, 4, 5}

union = set1 | set2  # {1, 2, 3, 4, 5}
intersection = set1 & set2  # {3}
difference = set1 - set2  # {1, 2}
symmetric_diff = set1 ^ set2  # {1, 2, 4, 5}

# Use cases: Remove duplicates, membership testing

from collections import defaultdict, Counter, deque, namedtuple

# 1. defaultdict - Dictionary with default values
word_count = defaultdict(int)

# 2. Counter - Count hashable objects
words = ['apple', 'banana', 'apple']
counter = Counter(words)

# 3. deque - Double-ended queue
queue = deque([1, 2, 3])
queue.append(4)  # Right end
queue.appendleft(0)  # Left end

# 4. namedtuple - Tuple with named fields
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)

# 1. Using get() method
value = my_dict.get('key', 'default')

# 2. Using setdefault()
value = my_dict.setdefault('key', 'default')

# 3. Using defaultdict
from collections import defaultdict
my_dict = defaultdict(list)
my_dict['key'].append('value')

# 4. Using try-except
try:
    value = my_dict['key']
except KeyError:
    value = 'default'

text = "Hello World"

# Basic slicing
print(text[0:5])    # Hello
print(text[6:])     # World
print(text[:5])     # Hello
print(text[-5:])    # World

# With step
print(text[::2])    # HloWrd
print(text[::-1])   # dlroW olleH (reverse)

# For lists
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4])    # [1, 2, 3]
print(numbers[::2])    # [0, 2, 4]

import array

# List
my_list = [1, 2, 3, 'hello']

# Array
my_array = array.array('i', [1, 2, 3])  # 'i' for integers

# append() - Adds element as single item
list1 = [1, 2, 3]
list1.append([4, 5])  # [1, 2, 3, [4, 5]]

# extend() - Adds elements individually
list2 = [1, 2, 3]
list2.extend([4, 5])  # [1, 2, 3, 4, 5]

scores = {'Alice': 85, 'Bob': 90, 'Charlie': 78}

# Sort by value, ascending
sorted_by_value = dict(sorted(scores.items(), key=lambda x: x[1]))

# Sort by value, descending
sorted_desc = dict(sorted(scores.items(), key=lambda x: x[1], reverse=True))

# Using itemgetter
from operator import itemgetter
sorted_scores = dict(sorted(scores.items(), key=itemgetter(1)))

class Counter:
    def __init__(self, low, high):
        self.current = low
        self.high = high
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current > self.high:
            raise StopIteration
        else:
            self.current += 1
            return self.current - 1

for num in Counter(1, 5):
    print(num)

# enumerate() - Get index and value
fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# zip() - Combine multiple iterables
names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

# Unzipping
zipped = zip(names, ages)
names_unzipped, ages_unzipped = zip(*zipped)

# Using with statement (automatic file closing)
with open('file.txt', 'r') as file:
    content = file.read()

# Creating custom context manager
class Timer:
    def __enter__(self):
        import time
        self.start = time.time()
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        import time
        self.end = time.time()
        print(f"Time taken: {self.end - self.start:.2f}s")

with Timer():
    # Code to time
    time.sleep(2)

numbers = [3, 1, 4, 1, 5, 9]

# sorted() - Returns new sorted list
sorted_numbers = sorted(numbers)  # New list
print(numbers)  # Original unchanged

# sort() - Sorts list in place
numbers.sort()  # Original list modified
print(numbers)  # Sorted

# Both accept key and reverse parameters
sorted_numbers = sorted(numbers, reverse=True)
numbers.sort(key=lambda x: str(x))  # Sort by string representation

class Student:
    def __init__(self):
        self.public = "Public"      # Accessible anywhere
        self._protected = "Protect" # Convention only
        self.__private = "Private"  # Name mangled to _Student__private

class Parent:
    def show(self):
        print("Parent method")

class Child(Parent):
    def show(self):  # Overriding
        print("Child method")

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    
    def description(self):
        return "This is a shape"

class MyClass:
    class_var = "Class Variable"
    
    def __init__(self, value):
        self.instance_var = value
    
    @classmethod
    def class_method(cls):
        return f"Accessing {cls.class_var}"
    
    @staticmethod
    def static_method():
        return "No access to class or instance"
    
    def instance_method(self):
        return f"Accessing {self.instance_var}"

class Circle:
    def __init__(self, radius):
        self._radius = radius
    
    @property
    def radius(self):  # Getter
        return self._radius
    
    @radius.setter
    def radius(self, value):  # Setter
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value
    
    @property
    def area(self):  # Read-only property
        return 3.14 * self._radius ** 2

circle = Circle(5)
circle.radius = 10  # Uses setter
print(circle.area)  # Uses getter

class A:
    def method(self):
        print("A")

class B(A):
    def method(self):
        print("B")

class C(A):
    def method(self):
        print("C")

class D(B, C):
    pass

d = D()
d.method()  # Uses B's method (MRO: D -> B -> C -> A)

# Inheritance
class Vehicle:
    pass

class Car(Vehicle):  # Car IS-A Vehicle
    pass

# Composition
class Engine:
    pass

class Car:
    def __init__(self):
        self.engine = Engine()  # Car HAS-A Engine

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):  # Overload +
        return Vector(self.x + other.x, self.y + other.y)
    
    def __str__(self):  # String representation
        return f"Vector({self.x}, {self.y})"
    
    def __len__(self):  # Overload len()
        return 2
    
    def __getitem__(self, index):  # Overload []
        if index == 0: return self.x
        if index == 1: return self.y
        raise IndexError

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private variable
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
    
    def get_balance(self):  # Controlled access
        return self.__balance

account = BankAccount(1000)
# account.__balance  # Error: AttributeError
print(account.get_balance())  # Correct way

x = "global"

def outer():
    x = "enclosing"
    
    def inner():
        x = "local"
        print(x)  # local
    
    inner()
    print(x)  # enclosing

outer()
print(x)  # global

# Import methods
import math  # Import entire module
from math import sqrt  # Import specific function
import math as m  # Import with alias
from math import *  # Import all (not recommended)

# Package structure
# mypackage/
#   __init__.py
#   module1.py
#   module2.py
#   subpackage/
#     __init__.py
#     module3.py

# mymodule.py
def hello():
    print("Hello from module")

if __name__ == "__main__":
    # Executes only when run directly
    print("Module run directly")
    hello()
else:
    print("Module imported")

try:
    result = 10 / 0
    file = open("nonexistent.txt")
except ZeroDivisionError:
    print("Cannot divide by zero")
except FileNotFoundError as e:
    print(f"File not found: {e}")
except Exception as e:  # Catch-all
    print(f"Error occurred: {e}")
else:
    print("No exceptions occurred")
finally:
    print("This always executes")
    
# Raising exceptions
def validate_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative")

def outer_function(x):
    def inner_function(y):
        return x + y  # Remembers x from outer scope
    return inner_function

adder = outer_function(10)
print(adder(5))  # 15 (remembers x=10)

from functools import lru_cache, partial, reduce

# 1. lru_cache - Memoization
@lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 2. partial - Fix certain arguments
def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
print(square(5))  # 25

# 3. reduce - Cumulative operation
numbers = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, numbers)  # 24

class Singleton:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance
    
    def __init__(self):
        print("Initializing...")

s1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # True (same instance)

import asyncio

async def fetch_data(url):
    print(f"Fetching {url}")
    await asyncio.sleep(2)  # Simulate I/O operation
    return f"Data from {url}"

async def main():
    # Run concurrently
    tasks = [
        fetch_data("url1.com"),
        fetch_data("url2.com"),
        fetch_data("url3.com")
    ]
    
    results = await asyncio.gather(*tasks)
    print(results)

# Run
asyncio.run(main())

from typing import List, Dict, Optional, Union, Tuple

def process_data(
    data: List[int],
    settings: Optional[Dict[str, str]] = None
) -> Tuple[bool, str]:
    
    if settings is None:
        settings = {}
    
    # Function logic
    return True, "Success"

# Union types
def handle_input(value: Union[int, str]) -> None:
    pass

# Type aliases
Vector = List[float]
Matrix = List[Vector]

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

class SingletonClass(metaclass=SingletonMeta):
    def __init__(self, value):
        self.value = value

a = SingletonClass(10)
b = SingletonClass(20)
print(a is b)  # True (same instance)
print(a.value)  # 10 (initial value preserved)

import threading
import multiprocessing
import time

# Threading example
def worker_thread():
    time.sleep(1)
    print("Thread done")

# Multiprocessing example
def worker_process():
    time.sleep(1)
    print("Process done")

# Create memory view
data = bytearray(b'Hello World')
view = memoryview(data)

# Slice without copying
slice_view = view[6:11]
print(bytes(slice_view))  # b'World'

# Modify through view
view[0] = 72  # ASCII for 'H'
print(data)  # bytearray(b'Hello World')

class PositiveNumber:
    def __init__(self, name):
        self.name = name
    
    def __get__(self, obj, objtype=None):
        return obj.__dict__.get(self.name)
    
    def __set__(self, obj, value):
        if value < 0:
            raise ValueError("Must be positive")
        obj.__dict__[self.name] = value

class BankAccount:
    balance = PositiveNumber('balance')
    
    def __init__(self, balance):
        self.balance = balance

account = BankAccount(100)
account.balance = -50  # Raises ValueError

import weakref

class Data:
    def __init__(self, value):
        self.value = value

obj = Data(10)
weak_ref = weakref.ref(obj)

print(weak_ref())  # <__main__.Data object>

del obj
print(weak_ref())  # None (object was garbage collected)

import gc

# Manual control
gc.disable()
gc.enable()

# Get statistics
print(gc.get_count())
print(gc.get_threshold())

# Force collection
collected = gc.collect()
print(f"Collected {collected} objects")

class RegularClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class SlotsClass:
    __slots__ = ['x', 'y']
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

# SlotsClass uses less memory but:
# - Cannot add new attributes
# - No __dict__ created

def reverse_string(s: str) -> str:
    # Method 1: Slicing
    return s[::-1]
    
    # Method 2: Using reversed
    return ''.join(reversed(s))
    
    # Method 3: Manual
    result = ''
    for char in s:
        result = char + result
    return result

def is_palindrome(s: str) -> bool:
    # Clean string and check
    cleaned = ''.join(char.lower() for char in s if char.isalnum())
    return cleaned == cleaned[::-1]

# Test cases
print(is_palindrome("A man, a plan, a canal: Panama"))  # True
print(is_palindrome("race a car"))  # False

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

# Alternative
def second_largest_simple(numbers):
    unique = list(set(numbers))
    if len(unique) < 2:
        return None
    return sorted(unique)[-2]

def fibonacci(n: int):
    # Method 1: Simple recursion (inefficient)
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)
    
    # Method 2: Dynamic programming
    fib = [0, 1]
    for i in range(2, n+1):
        fib.append(fib[i-1] + fib[i-2])
    return fib[n]
    
    # Method 3: Space optimized
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

def word_frequency(text: str) -> dict:
    from collections import Counter
    import re
    
    # Clean and split
    words = re.findall(r'\b\w+\b', text.lower())
    return dict(Counter(words))

# Manual implementation
def word_frequency_manual(text):
    words = text.lower().split()
    freq = {}
    
    for word in words:
        # Remove punctuation
        word = word.strip('.,!?;:"')
        freq[word] = freq.get(word, 0) + 1
    
    return freq

def find_pairs(nums: list, target: int) -> list:
    seen = set()
    pairs = []
    
    for num in nums:
        complement = target - num
        
        if complement in seen:
            pairs.append((complement, num))
        
        seen.add(num)
    
    return pairs

# Example
print(find_pairs([1, 2, 3, 4, 5], 6))  
# [(2, 4), (1, 5)]

class Stack:
    def __init__(self):
        self.items = []
    
    def push(self, item):
        self.items.append(item)
    
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        raise IndexError("Pop from empty stack")
    
    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        return None
    
    def is_empty(self):
        return len(self.items) == 0
    
    def size(self):
        return len(self.items)

def are_anagrams(str1: str, str2: str) -> bool:
    # Method 1: Sort and compare
    return sorted(str1.lower()) == sorted(str2.lower())
    
    # Method 2: Using Counter
    from collections import Counter
    return Counter(str1.lower()) == Counter(str2.lower())
    
    # Method 3: Manual count
    if len(str1) != len(str2):
        return False
    
    count = [0] * 26
    
    for char in str1.lower():
        if char.isalpha():
            count[ord(char) - ord('a')] += 1
    
    for char in str2.lower():
        if char.isalpha():
            count[ord(char) - ord('a')] -= 1
    
    return all(c == 0 for c in count)

def longest_common_prefix(strs: list) -> str:
    if not strs:
        return ""
    
    # Method 1: Horizontal scanning
    prefix = strs[0]
    
    for string in strs[1:]:
        while not string.startswith(prefix):
            prefix = prefix[:-1]
            if not prefix:
                return ""
    
    return prefix
    
    # Method 2: Vertical scanning
    for i, char in enumerate(strs[0]):
        for string in strs[1:]:
            if i >= len(string) or string[i] != char:
                return strs[0][:i]
    
    return strs[0]

def merge_sorted_lists(list1: list, list2: list) -> list:
    # Method 1: Using heapq
    import heapq
    return list(heapq.merge(list1, list2))
    
    # Method 2: Manual merge
    result = []
    i = j = 0
    
    while i < len(list1) and j < len(list2):
        if list1[i] <= list2[j]:
            result.append(list1[i])
            i += 1
        else:
            result.append(list2[j])
            j += 1
    
    # Add remaining elements
    result.extend(list1[i:])
    result.extend(list2[j:])
    
    return result

import requests

# GET request
response = requests.get('https://api.example.com/data')
data = response.json()

# POST request
payload = {'key': 'value'}
response = requests.post('https://api.example.com/data', json=payload)

# With authentication
headers = {'Authorization': 'Bearer token'}
response = requests.get(url, headers=headers)

# Error handling
try:
    response.raise_for_status()
except requests.exceptions.HTTPError as e:
    print(f"Error: {e}")

# SQLite (built-in)
import sqlite3
conn = sqlite3.connect('database.db')
cursor = conn.cursor()
cursor.execute('SELECT * FROM users')
conn.close()

# PostgreSQL (psycopg2)
import psycopg2
conn = psycopg2.connect(
    host="localhost",
    database="mydb",
    user="user",
    password="pass"
)

# MySQL (mysql-connector)
import mysql.connector
conn = mysql.connector.connect(
    host="localhost",
    user="root",
    password="password",
    database="mydb"
)