Most Asked Python Interview Questions

Mutable types are objects whose content can be changed after creation without creating a new object. Examples include lists, dictionaries, and sets.

Immutable types cannot be modified after creation. Any modification creates a new object. Examples include integers, floats, strings, tuples, and frozensets.

Example:

Understanding mutability is crucial for avoiding bugs, especially when passing objects to functions or using them as dictionary keys.

Lists and tuples differ in several key ways:

Mutability:

1. Lists are mutable - you can add, remove, or modify elements
2. Tuples are immutable - once created, they cannot be changed

Syntax:

1. Lists use square brackets: [1, 2, 3]
2. Tuples use parentheses: (1, 2, 3)

Performance:

1. Tuples are slightly faster and use less memory
2. Lists have more overhead due to mutability

Use Cases:

1. Use lists for collections that need to change (shopping cart items, user inputs)
2. Use tuples for fixed data (coordinates, RGB colors, database records)

Example:

When copying objects in Python, understanding shallow vs deep copy is essential:

Shallow Copy:

1. Creates a new object but references the same nested objects
2. Changes to nested objects affect both copies
3. Created using copy.copy() or list.copy()

Deep Copy:

1. Creates a completely independent copy, including all nested objects
2. Changes to nested objects don't affect the original
3. Created using copy.deepcopy()

Example:

Use shallow copy for simple objects and deep copy when dealing with nested structures.

These special parameters allow functions to accept variable numbers of arguments:

*args (Non-Keyword Arguments):

1. Allows a function to accept any number of positional arguments
2. Arguments are received as a tuple

**kwargs (Keyword Arguments):

1. Allows a function to accept any number of keyword arguments
2. Arguments are received as a dictionary

Examples:

These are extremely useful for creating flexible APIs and wrapper functions.

Lambda functions are anonymous, single-expression functions with key differences from regular functions:

Lambda Functions:

1. Anonymous (no name required)
2. Single expression only
3. Automatically returns the result
4. Typically used for short, simple operations
5. Cannot contain statements (no assignments, loops, etc.)

Regular Functions (def):

1. Named and reusable
2. Can contain multiple statements and expressions
3. Requires explicit return statement
4. Can include documentation strings
5. Better for complex logic

Examples:

Use lambda for simple operations in places like map(), filter(), and sorted(). Use regular functions for anything more complex.

List comprehensions provide a concise way to create lists based on existing iterables.

Benefits:

1. More readable and Pythonic than traditional loops
2. Often faster than equivalent for-loops
3. Can include conditional logic
4. Reduce code verbosity

Basic Syntax:

Examples:

Note: Don't overuse them - if the logic becomes too complex, use a regular loop for better readability.

These operators serve different purposes in Python:

== Operator (Equality):

1. Compares the values of two objects
2. Returns True if values are equal
3. Can be overridden using __eq__() method

is Operator (Identity):

1. Compares the memory addresses (identity) of two objects
2. Returns True if both variables point to the same object
3. Cannot be overridden

Examples:

Rule of thumb: Use == for value comparison and is only when checking for None or comparing singleton objects.

The __init__() method is a special constructor method in Python classes that initializes object attributes.

Key Points:

1. Automatically called when a new object is created
2. Used to set initial values for object attributes
3. The first parameter is always self (reference to the instance)
4. Can accept additional parameters for initialization
5. Not required if no initialization is needed

Example:

With Default Parameters:

Note: __init__() is different from __new__(). The __new__() method creates the object, while __init__() initializes it.

Dunder methods (double underscore methods) are special methods in Python that enable operator overloading and customization of built-in behavior.

Common Dunder Methods:

Object Representation:

1. __init__() - Constructor
2. __str__() - String representation for users
3. __repr__() - Official representation for developers

Comparison Operators:

1. __eq__() - Equality (==)
2. __lt__() - Less than (<)
3. __gt__() - Greater than (>)

Arithmetic Operators:

1. __add__() - Addition (+)
2. __sub__() - Subtraction (-)
3. __mul__() - Multiplication (*)

Container Methods:

1. __len__() - Length
2. __getitem__() - Indexing
3. __setitem__() - Assignment

Example:

Dunder methods make your custom classes behave like built-in Python types.

These three method types serve different purposes in Python classes:

Instance Methods:

1. Default method type
2. First parameter is self (instance reference)
3. Can access and modify instance attributes
4. Can access class attributes through self

@classmethod:

1. First parameter is cls (class reference)
2. Can access and modify class attributes
3. Cannot access instance attributes
4. Often used for alternative constructors

@staticmethod:

1. No automatic first parameter
2. Cannot access instance or class attributes directly
3. Behaves like a regular function but belongs to the class namespace
4. Used for utility functions related to the class

Example:

Both iterators and generators provide ways to iterate over data, but they work differently:

Iterators:

1. Objects that implement __iter__() and __next__() methods
2. Must explicitly maintain state
3. Raise StopIteration when exhausted
4. Can be created from any iterable using iter()

Generators:

1. Special functions that use yield instead of return
2. Automatically maintain state between calls
3. More memory-efficient (lazy evaluation)
4. Simpler to write than iterators
5. Can only be iterated once

Examples:

Use generators when working with large datasets or infinite sequences to save memory.

Decorators are functions that modify the behavior of other functions or classes without changing their source code.

Key Concepts:

1. Functions are first-class objects in Python
2. Decorators wrap another function to extend its behavior
3. Denoted by @decorator_name syntax
4. Commonly used for logging, authentication, timing, caching

Simple Example:

Practical Example - Timing Functions:

Built-in Decorators:

1. @property - Converts method to attribute
2. @staticmethod - Defines static method
3. @classmethod - Defines class method

Python uses automatic memory management with several key mechanisms:

1. Private Heap Space:

1. All Python objects are stored in a private heap
2. Managed internally by Python Memory Manager
3. Not directly accessible to programmers

2. Reference Counting:

1. Each object has a reference count
2. Count increases when new reference is created
3. Count decreases when reference is deleted or goes out of scope
4. Object is deallocated when count reaches zero

3. Garbage Collection:

1. Handles circular references that reference counting can't
2. Uses generational garbage collection
3. Objects are divided into three generations (0, 1, 2)
4. Younger generations are collected more frequently

Example:

Best Practices:

1. Don't create unnecessary circular references
2. Use context managers (with statement) for resource management
3. Let Python handle memory automatically in most cases
4. Use __del__() method carefully (it's called on garbage collection)

Python's exception handling provides a robust way to handle errors gracefully:

Components:

1. try - Code that might raise an exception
2. except - Handles specific exceptions
3. else - Executes if no exception occurs
4. finally - Always executes (cleanup code)

Basic Syntax:

Practical Examples:

Best Practices:

1. Catch specific exceptions, not bare except
2. Use finally for cleanup (closing files, connections)
3. Don't use exceptions for normal flow control
4. Log exceptions for debugging

This statement checks whether a Python file is being run directly or being imported as a module.

How it Works:

1. When a file is run directly, Python sets __name__ to "__main__"
2. When a file is imported, __name__ is set to the module name
3. Allows you to have code that only runs when the script is executed directly

Use Cases:

1. Testing code in the same file as module definitions
2. Providing a CLI interface for modules
3. Running demonstrations or examples
4. Preventing code execution when importing

Example:

When Used:

Practical Pattern:

This pattern makes your code reusable as both a standalone script and an importable module.

These are functional programming tools that operate on iterables without explicit loops.

map():

1. Applies a function to every item in an iterable
2. Returns a map object (iterator)
3. Syntax: map(function, iterable)

filter():

1. Filters items based on a condition (function returns True/False)
2. Returns a filter object (iterator)
3. Syntax: filter(function, iterable)

reduce():

1. Applies a function cumulatively to reduce iterable to a single value
2. Must import from functools module
3. Syntax: reduce(function, iterable[, initializer])

Examples:

Comparison with List Comprehensions:

When to use:

1. Use map() and filter() with existing functions
2. Use list comprehensions for lambda-based transformations (more Pythonic)
3. Use reduce() for cumulative operations where built-in alternatives don't exist

Sets, lists, and dictionaries are all collection types but with distinct characteristics:

Lists:

1. Ordered collection
2. Allows duplicates
3. Mutable (can be modified)
4. Indexed by position
5. Syntax: [1, 2, 3]

Sets:

1. Unordered collection
2. No duplicates allowed
3. Mutable (elements must be immutable)
4. No indexing
5. Optimized for membership testing
6. Syntax: {1, 2, 3}

Dictionaries:

1. Ordered (Python 3.7+) key-value pairs
2. Keys must be unique and immutable
3. Values can be duplicates
4. Indexed by keys
5. Syntax: {'a': 1, 'b': 2}

Examples:

When to use:

1. List: Ordered collection, need indexing, allow duplicates
2. Set: Remove duplicates, membership testing, set operations
3. Dictionary: Key-value mapping, fast lookups by key

Inheritance and polymorphism are fundamental OOP concepts that work together but serve different purposes:

Inheritance:

1. Mechanism where a class derives properties and methods from another class
2. Enables code reusability
3. Creates a parent-child (is-a) relationship
4. Child class inherits all attributes and methods from parent

Polymorphism:

1. Ability of different objects to respond to the same method in different ways
2. Greek for "many forms"
3. Achieved through method overriding or duck typing
4. Enables writing flexible, reusable code

Inheritance Example:

Polymorphism Example:

Multiple Inheritance:

Key Differences:

1. Inheritance: About code reuse and creating relationships
2. Polymorphism: About interface flexibility and behavior variation
3. Inheritance is the mechanism; polymorphism is the result

The re module provides powerful pattern matching and text manipulation capabilities.

Common Functions:

1. re.search() - Find first match anywhere in string
2. re.match() - Match at beginning of string
3. re.findall() - Find all matches as a list
4. re.sub() - Replace matches
5. re.split() - Split string by pattern
6. re.compile() - Compile pattern for reuse

Common Pattern Elements:

1. \d - Digit (0-9)
2. \w - Word character (letter, digit, underscore)
3. \s - Whitespace
4. . - Any character except newline
5. * - 0 or more occurrences
6. + - 1 or more occurrences
7. ? - 0 or 1 occurrence
8. {n} - Exactly n occurrences
9. ^ - Start of string
10. $ - End of string

Practical Examples:

Best Practices:

1. Use raw strings (r"pattern") to avoid escape issues
2. Compile patterns that are used multiple times
3. Test regex patterns using tools like regex101.com
4. Don't over-complicate - sometimes simple string methods are better

The Global Interpreter Lock (GIL) is a mutex that protects access to Python objects, preventing multiple threads from executing Python bytecode simultaneously.

Key Points:

1. Only one thread can execute Python code at a time
2. Exists in CPython (the standard Python implementation)
3. Simplifies memory management but limits multi-threading performance
4. Affects CPU-bound tasks more than I/O-bound tasks

Why GIL Exists:

1. Makes memory management simpler and safer
2. Prevents race conditions with reference counting
3. Allows easy integration with C libraries
4. Simplifies implementation of CPython

Impact on Performance:

Workarounds:

When GIL Matters:

1. CPU-bound tasks: Use multiprocessing
2. I/O-bound tasks: Threading works fine (GIL released during I/O)
3. Network requests: async/await or threading
4. Data processing: NumPy/Pandas (release GIL internally)

The GIL is not a limitation for most applications, especially I/O-bound ones like web servers.

Python provides several ways to work with files, but the with statement is the recommended approach.

Basic File Operations:

1. 'r' - Read mode (default)
2. 'w' - Write mode (overwrites existing content)
3. 'a' - Append mode
4. 'r+' - Read and write mode

Why use with statement?

1. Automatically closes the file (even if exceptions occur)
2. Cleaner and more readable code
3. Prevents resource leaks
4. No need to explicitly call close()

Examples:

The with statement uses context managers (__enter__ and __exit__ methods) to ensure proper resource management.