Basic Python Interview Questions
1. What is Python?
Python is an interpreted, high-level programming language known for its clear syntax and readability. It supports multiple programming paradigms, including procedural, object-oriented, and functional programming. Python is widely used in various domains, such as web development, data science, artificial intelligence, machine learning, and automation.
2. What are Python’s built-in data types?
Python has several built-in data types, including:
- Integers: Whole numbers, e.g., `5`, `-10`.
- Floats: Decimal numbers, e.g., `3.14`, `-0.001`.
- Strings: Text data, e.g., `"Hello, world!"`.
- Booleans: Represents `True` or `False`.
- Lists: Ordered, mutable collections, e.g., `[1, 2, 3]`.
- Tuples: Ordered, immutable collections, e.g., `(1, 2, 3)`.
- Dictionaries: Key-value pairs, e.g., `{'key': 'value'}`.
- Sets: Unordered collections of unique elements, e.g., `{1, 2, 3}`.
3. What is the difference between lists and tuples?
- Mutability: Lists are mutable, meaning they can be changed after creation (elements can be added, removed, or modified). Tuples are immutable and cannot be altered once defined.
- Syntax: Lists use square brackets `[]`, while tuples use parentheses `()`.
- Performance: Tuples are generally faster than lists due to their immutability.
Intermediate Python Interview Questions
4. What are Python decorators?
Decorators are a powerful feature in Python that allows you to modify the behavior of a function or class method. They are higher-order functions that take another function as an argument and extend its functionality without modifying its structure. A common use case is for logging, enforcing access control, or modifying input/output.
Example of a simple decorator:
```python
def my_decorator(func):
def wrapper():
print("Something is happening before the function is called.")
func()
print("Something is happening after the function is called.")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
say_hello()
```
5. Explain the concept of list comprehensions in Python.
List comprehensions provide a concise way to create lists. They consist of brackets containing an expression followed by a `for` clause, and can include optional `if` statements to filter items.
Example:
```python
squares = [x2 for x in range(10) if x % 2 == 0]
print(squares) Output: [0, 4, 16, 36, 64]
```
This creates a list of squares for even numbers between 0 and 9.
6. What is the purpose of the `self` keyword in Python?
The `self` keyword in Python is used to represent the instance of the class. It allows access to the attributes and methods of the class in Python's object-oriented programming. It must be the first parameter of any function in the class, though it is not explicitly passed when a method is called on an instance.
Example:
```python
class MyClass:
def __init__(self, value):
self.value = value
def print_value(self):
print(self.value)
obj = MyClass(10)
obj.print_value() Output: 10
```
Advanced Python Interview Questions
7. What are iterators and generators in Python?
- Iterators: An iterator is an object that implements the iterator protocol, consisting of the `__iter__()` and `__next__()` methods. Iterators allow you to traverse through a collection without needing to know the underlying structure.
Example of an iterator:
```python
class MyIterator:
def __init__(self, limit):
self.limit = limit
self.current = 0
def __iter__(self):
return self
def __next__(self):
if self.current < self.limit:
self.current += 1
return self.current - 1
else:
raise StopIteration
for num in MyIterator(5):
print(num) Output: 0, 1, 2, 3, 4
```
- Generators: A generator is a simpler way to create iterators using the `yield` statement. When a function contains `yield`, it becomes a generator function. Each time `next()` is called on it, it resumes where it left off.
Example of a generator:
```python
def my_generator(limit):
current = 0
while current < limit:
yield current
current += 1
for num in my_generator(5):
print(num) Output: 0, 1, 2, 3, 4
```
8. Explain the difference between deep copy and shallow copy.
- Shallow Copy: Creates a new object, but inserts references into it to the objects found in the original. Changes to mutable objects in the copied object may reflect in the original.
Example of shallow copy:
```python
import copy
original = [[1, 2, 3], [4, 5, 6]]
shallow_copied = copy.copy(original)
shallow_copied[0][0] = 'X'
print(original) Output: [['X', 2, 3], [4, 5, 6]]
```
- Deep Copy: Creates a new object and recursively adds copies of nested objects found in the original. Changes to the copied object do not affect the original.
Example of deep copy:
```python
deep_copied = copy.deepcopy(original)
deep_copied[0][0] = 'Y'
print(original) Output: [['X', 2, 3], [4, 5, 6]]
```
9. What is the Global Interpreter Lock (GIL) in Python?
The Global Interpreter Lock (GIL) is a mutex that protects access to Python objects, preventing multiple threads from executing Python bytecode simultaneously. This can be a bottleneck in CPU-bound programs. However, I/O-bound programs can benefit from threading because they often spend time waiting for external resources.
10. How do you handle exceptions in Python?
Exceptions in Python can be handled using `try`, `except`, `finally`, and `else` blocks.
Example:
```python
try:
result = 10 / 0
except ZeroDivisionError:
print("You cannot divide by zero!")
else:
print("Division successful:", result)
finally:
print("Execution completed.")
```
This will output:
```
You cannot divide by zero!
Execution completed.
```
Conclusion
Preparing for Python interview questions and answers doesn't have to be daunting. By familiarizing yourself with the basic, intermediate, and advanced concepts outlined in this article, you'll be better equipped to tackle a range of questions during your interview. Remember to practice coding problems and understand the underlying principles of Python, as this will not only help you answer questions effectively but also demonstrate your problem-solving abilities to potential employers. Good luck!
Frequently Asked Questions
What is the difference between a list and a tuple in Python?
Lists are mutable, meaning they can be changed, whereas tuples are immutable, meaning once they are created, they cannot be modified.
How do you handle exceptions in Python?
You can handle exceptions using try and except blocks. For example: 'try: code that may raise an exception except ExceptionType: code to handle the exception'.
What is a lambda function in Python?
A lambda function is an anonymous function defined with the 'lambda' keyword. It can take any number of arguments but can only have one expression.
What are Python decorators?
Decorators are a way to modify or enhance functions or methods without changing their actual code. They are applied using the '@decorator_name' syntax above the function definition.
What is the purpose of the 'self' parameter in Python class methods?
'self' refers to the instance of the class and is used to access variables and methods associated with that instance.
Explain the difference between deep copy and shallow copy.
A shallow copy creates a new object but inserts references into it to the objects found in the original. A deep copy creates a new object and recursively copies all objects found in the original.
How can you read a file in Python?
You can read a file using the 'open()' function, followed by the 'read()', 'readline()', or 'readlines()' methods. For example: 'with open('file.txt', 'r') as f: data = f.read()'.
What is list comprehension in Python?
List comprehension is a concise way to create lists. It consists of brackets containing an expression followed by a 'for' clause. For example: '[x2 for x in range(10)]' creates a list of squares.
