Question 1

What is Python and what are its key features?

Accepted Answer

Python is a high-level, interpreted, dynamically typed, and object-oriented programming language. Key features include: simple and readable syntax (indentation-based), interpreted language (no compilation), dynamically typed (no need to declare variable types), extensive standard library, cross-platform compatibility, and support for multiple programming paradigms (OOP, functional, procedural). It is widely used in web development, data science, AI/ML, and automation.

Question 2

Explain the difference between Python 2 and Python 3.

Accepted Answer

Python 2 is legacy; Python 3 is the current and actively maintained version. Major differences: print is a function in Python 3 (vs. statement in Python 2), integer division returns float in Python 3, Unicode support is native in Python 3, syntax changes (raise, except, import), and many library changes. Python 2 is deprecated and no longer supported after 2020.

Question 3

What is a Python interpreter and how does it work?

Accepted Answer

The Python interpreter is a program that executes Python code. It reads Python source code, compiles it to bytecode (.pyc files), and then executes the bytecode on the Python Virtual Machine (PVM). The interpreter supports interactive mode (REPL) and can run scripts. It uses a reference counting garbage collector with cycle detection for memory management.

Question 4

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

Accepted Answer

Lists are mutable (can be modified), enclosed in square brackets [], and are dynamic. Tuples are immutable (cannot be modified), enclosed in parentheses (), and are fixed size. Lists use more memory and are slower; tuples are memory-efficient and faster. Use lists for dynamic collections and tuples for fixed data (like function returns).

Question 5

What is the difference between a 'list' and a 'dictionary' in Python?

Accepted Answer

A list is an ordered collection of items, accessed by integer indices, and holds elements of any type. A dictionary is an unordered collection of key-value pairs, accessed by keys (hashable types), and offers fast lookups. Lists are indexed; dictionaries are keyed. Lists are for ordered sequences; dicts are for mapping relationships.

Question 6

Explain the difference between '==', 'is', and 'is not' in Python.

Accepted Answer

'==' checks value equality (whether two objects have the same content). 'is' checks identity equality (whether two references point to the same object in memory). 'is not' checks that references point to different objects. Example: 1 == 1.0 is True (value), but 1 is 1.0 is False (different types). Use 'is' for comparing with None, True, False.

Question 7

What are Python decorators and how are they used?

Accepted Answer

Decorators are functions that modify the behavior of other functions or methods. They are used with the @decorator syntax. They enable code reuse, logging, access control, and performance measurement. Example: @staticmethod, @classmethod, @property. Decorators take a function as an argument, wrap it, and return the wrapped function.

Question 8

Explain the concept of generators in Python.

Accepted Answer

Generators are functions that yield values lazily using the 'yield' keyword. They produce items on the fly and maintain state between calls. They are memory-efficient for large datasets because they don't store all items in memory. They are used for infinite sequences, streaming data, and large file processing.

Question 9

What are list comprehensions in Python?

Accepted Answer

List comprehensions provide a concise way to create lists by applying an expression to each element in an iterable. Syntax: [expression for item in iterable if condition]. Example: [x**2 for x in range(10) if x % 2 == 0] returns squares of even numbers. They are faster and more readable than manual loops.

Question 10

Explain the difference between 'append' and 'extend' for lists.

Accepted Answer

append() adds its argument as a single element to the end of the list, even if it's another list. extend() iterates over its argument and adds each element to the end, flattening the iterable. Example: [1,2].append([3,4]) → [1,2,[3,4]]; [1,2].extend([3,4]) → [1,2,3,4].

Question 11

What is the Python Global Interpreter Lock (GIL) and how does it affect performance?

Accepted Answer

The GIL is a mutex that prevents multiple threads from executing Python bytecode simultaneously in a single process. It ensures thread-safety for memory management but limits multi-threaded performance for CPU-bound tasks. I/O-bound tasks can benefit from threading. For CPU-bound parallelism, use multiprocessing or subprocess.

Question 12

Explain the difference between 'multithreading' and 'multiprocessing' in Python.

Accepted Answer

Multithreading uses threads within a single process, sharing memory, and is limited by the GIL for CPU-bound tasks. It's suitable for I/O-bound operations. Multiprocessing uses separate processes, each with its own memory space, bypassing the GIL. It's suitable for CPU-bound parallelism. Multiprocessing is more resource-intensive.

Question 13

What is the purpose of the 'if __name__ == '__main__' idiom?

Accepted Answer

This condition checks if the module is being run directly (not imported). It allows a script to be executed as a standalone program or imported as a module. Code inside this block runs only when the script is executed directly, preventing it from running when imported.

Question 14

What are lambda functions in Python and when are they used?

Accepted Answer

Lambda functions are anonymous, single-expression functions defined with the 'lambda' keyword. Syntax: lambda args: expression. They are used for short, inline functions where a full function definition is unnecessary. Common use with functions like map(), filter(), sorted() key parameter.

Question 15

Explain the concept of 'duck typing' in Python.

Accepted Answer

Duck typing is a programming concept where an object's suitability is determined by its methods and properties, not its type. If it walks like a duck and quacks like a duck, it's a duck. Python uses this principle, allowing polymorphism without inheritance. It enables flexible code but requires careful design.

Question 16

What is the difference between 'deep copy' and 'shallow copy'?

Accepted Answer

Shallow copy creates a new object but inserts references to the original objects' elements (copy.copy()). Deep copy creates a new object with recursively copied elements, fully independent of the original (copy.deepcopy()). Shallow copy is faster but shares nested objects; deep copy ensures full independence.

Question 17

Explain the 'with' statement in Python and its use.

Accepted Answer

The 'with' statement simplifies resource management by ensuring that resources (like files, network connections, locks) are properly cleaned up after use. It uses context managers with __enter__ and __exit__ methods. Example: with open('file.txt') as f: content = f.read(). It automatically closes the file.

Question 18

What are Python exceptions and how are they handled?

Accepted Answer

Exceptions are errors that occur during program execution. They are handled using try-except blocks. Specific exceptions can be caught (except ValueError:). Use finally for cleanup and else for code that runs if no exception occurs. Raising exceptions with 'raise' allows custom error handling.

Question 19

Explain the difference between 'raise' and 'throw' in other languages.

Accepted Answer

Python uses 'raise' to raise exceptions (similar to 'throw' in Java/C++). There is no 'throw' in Python. Both terms mean the same: to signal an error condition. In Python, you raise an instance of an exception class, optionally with a message.

Question 20

What is the difference between a class variable and an instance variable?

Accepted Answer

Class variables are shared across all instances of a class, defined at the class level. Instance variables are specific to each instance, defined inside methods (usually __init__). Class variables are accessed using ClassName.variable; instance variables using self.variable.

Question 21

Explain the concepts of 'inheritance' and 'polymorphism' in Python.

Accepted Answer

Inheritance allows a class to derive attributes and methods from a parent class. Polymorphism allows objects of different classes to be treated as objects of a common superclass, enabling method overriding and interfaces. Python supports multiple inheritance and method resolution order (MRO).

Question 22

What are magic methods in Python and give some examples?

Accepted Answer

Magic methods (dunder methods) are special methods with double underscores (__method__). They enable operator overloading and define class behavior. Examples: __init__ (constructor), __str__ (string representation), __len__ (length), __add__ (addition), __getitem__ (indexing), __call__ (callable).

Question 23

Explain the difference between 'staticmethod' and 'classmethod'.

Accepted Answer

staticmethod does not receive an implicit first argument (self or cls). It behaves like a regular function but belongs to the class namespace. classmethod receives the class (cls) as the first argument. It can access class variables and is used for factory methods. Both are decorators.

Question 24

What is the 'super()' function and how is it used?

Accepted Answer

super() returns a proxy object that delegates method calls to a parent class. It is used to call parent class methods from a subclass, avoiding hardcoding parent class names. It handles multiple inheritance correctly. Example: super().__init__() calls the parent's __init__.

Question 25

Explain the Python 'property' decorator.

Accepted Answer

@property allows defining methods that are accessed like attributes. It enables getter, setter, and deleter functionality. It encapsulates instance variables and allows validation or computed values. Example: class Person: @property def name(self): return self._name.

Question 26

What are the different data types in Python?

Accepted Answer

Numeric: int, float, complex. Sequence: list, tuple, range, str, bytes, bytearray. Mapping: dict. Set: set, frozenset. Boolean: bool. None: NoneType. Also, type() and isinstance() are used for type checking.

Question 27

Explain the concept of 'mutable' vs 'immutable' in Python.

Accepted Answer

Immutable objects cannot be changed after creation: int, float, bool, str, tuple, frozenset. Mutable objects can be changed: list, dict, set, bytearray. When passing immutable objects to functions, changes create new objects; mutable objects are modified in place.

Question 28

What is the difference between 'sort()' and 'sorted()' in Python?

Accepted Answer

sort() is a list method that sorts the list in place and returns None. sorted() is a built-in function that creates a new sorted list from any iterable, leaving the original unchanged. Both accept key and reverse parameters.

Question 29

Explain the 'zip()' function in Python.

Accepted Answer

zip() aggregates elements from multiple iterables into tuples. It returns an iterator of tuples where the i-th tuple contains the i-th element from each iterable. It stops when the shortest iterable is exhausted. Example: list(zip([1,2], ['a','b'])) → [(1,'a'), (2,'b')].

Question 30

What is the 'map()' function in Python?

Accepted Answer

map() applies a given function to each item of an iterable and returns an iterator. Syntax: map(function, iterable). It can be used with lambda functions. Example: list(map(lambda x: x*2, [1,2,3])) → [2,4,6].

Question 31

Explain the 'filter()' function in Python.

Accepted Answer

filter() filters elements from an iterable based on a function that returns True/False. It returns an iterator of elements that pass the test. Example: list(filter(lambda x: x > 0, [-1, 2, -3, 4])) → [2, 4].

Question 32

What is the 'reduce()' function and how is it used?

Accepted Answer

reduce() from the 'functools' module applies a function cumulatively to the elements of an iterable, reducing it to a single value. Example: from functools import reduce; reduce(lambda a,b: a+b, [1,2,3]) → 6. It's useful for aggregations.

Question 33

Explain the purpose of the 'Enum' class in Python.

Accepted Answer

Enum is a class that defines a set of named constants. It provides better readability and type safety than using strings or integers. Example: from enum import Enum; class Color(Enum): RED = 1; GREEN = 2. Enums support iteration, comparison, and attribute access.

Question 34

What is the difference between '@staticmethod' and '@classmethod' in Python?

Accepted Answer

staticmethod does not receive self or cls; it's a regular function in the class namespace. classmethod receives cls as the first argument, allowing access to class state. classmethod can be called on the class or instance; staticmethod behaves like a plain function.

Question 35

Explain the 'assert' statement in Python.

Accepted Answer

The 'assert' statement is used for debugging and testing. It takes an expression and an optional message. If the expression is False, it raises an AssertionError. Example: assert x > 0, 'x must be positive'. Assertions can be disabled with the -O flag.

Question 36

What are Python modules and packages?

Accepted Answer

A module is a single .py file containing Python code. A package is a directory containing a special __init__.py file and multiple modules. Packages allow hierarchical organization. Modules and packages enable code reuse, namespacing, and maintainability.

Question 37

Explain the 'import' statement and its variations.

Accepted Answer

'import module' imports the entire module. 'from module import name' imports specific names into the current namespace. 'import module as alias' creates an alias. 'from module import *' imports all names (not recommended). The import system searches sys.path.

Question 38

What is the 'PYTHONPATH' environment variable?

Accepted Answer

PYTHONPATH is an environment variable that specifies additional directories for Python to search for modules and packages. It is added to sys.path, allowing custom module locations. It can be set to include third-party or project-specific code.

Question 39

Explain the concept of 'pickle' serialization in Python.

Accepted Answer

pickle is a module that serializes Python objects into a byte stream (pickling) and deserializes (unpickling). It supports most built-in types and custom classes. Use with caution due to security risks (untrusted data). It's useful for saving state, caching, and data transfer between Python processes.

Question 40

What is the difference between 'json' and 'pickle'?

Accepted Answer

json is a text-based, human-readable format for data interchange, supporting basic types (dict, list, str, int, float, bool, null). It is cross-platform and secure. pickle is binary, Python-specific, supports complex Python objects, but is not human-readable and has security risks. Use json for APIs and pickle for internal Python storage.

Question 41

Explain the 'Context Manager' and how to create one.

Accepted Answer

Context managers are used with the 'with' statement to manage resources. They define __enter__ and __exit__ methods. They can be created using class-based or using the 'contextlib' module with @contextmanager decorator. They ensure proper setup/teardown.

Question 42

What are Python's built-in decorators?

Accepted Answer

Built-in decorators: @staticmethod, @classmethod, @property, @abstractmethod (abc module), @functools.lru_cache (caching), @functools.wraps (preserving metadata), and @dataclass (dataclasses module). They enable common patterns without boilerplate.

Question 43

Explain the concept of 'asyncio' in Python.

Accepted Answer

asyncio is a library for writing concurrent code using the async/await syntax. It provides an event loop, coroutines, and tasks. It is used for high-level network I/O, web servers, and handling many connections with minimal overhead. It is asynchronous, not parallel.

Question 44

What is the difference between 'async' and 'await'?

Accepted Answer

async def defines a coroutine function. await suspends the coroutine until the awaited task completes, yielding control back to the event loop. async functions must be called within the event loop using asyncio.run() or await from another coroutine.

Question 45

Explain the 'dataclass' decorator and its benefits.

Accepted Answer

@dataclass automatically generates common methods (__init__, __repr__, __eq__, __hash__) for classes that primarily store data. It reduces boilerplate and provides optional features like default values, ordering, and frozen instances. It's ideal for data containers.

Question 46

What is the purpose of the 'typing' module?

Accepted Answer

The typing module provides type hints for static type checking, improving code readability and IDE support. It includes types like List, Dict, Tuple, Optional, Union, Any, and Callable. Type hints don't affect runtime but enable tools like mypy for static analysis.

Question 47

Explain the difference between 'type hints' and 'type checking'.

Accepted Answer

Type hints are annotations in the code (e.g., def add(a: int, b: int) -> int) that indicate expected types. They are not enforced at runtime. Type checking is the process of validating these hints using static analysis tools (mypy, Pyright) to catch type errors before runtime.

Question 48

What are the common uses of Python in data science?

Accepted Answer

Python is widely used in data science with libraries: NumPy (numerical computing), Pandas (data manipulation), Matplotlib/Seaborn (visualization), Scikit-learn (machine learning), TensorFlow/PyTorch (deep learning), and Jupyter (interactive notebooks). It is the language of choice for data analysis and AI.

Question 49

Explain the concept of 'virtual environments' in Python.

Accepted Answer

Virtual environments isolate project dependencies, preventing conflicts between projects. They create a separate Python installation with its own site-packages. Tools: venv (built-in), virtualenv, and conda environments. Activate with source env/bin/activate and deactivate.

Question 50

What is the future of Python?

Accepted Answer

Python continues to grow with strong adoption in AI/ML, data science, web development (Django/Flask), and automation. Future directions include improved performance (faster interpreter), better async support, enhanced type checking, and increased focus on security and tooling. Python remains one of the most popular languages.

Python Interview Q&A