File size: 8,933 Bytes
7fde9b9 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 | ## Python Basics
Definition: Python is a high-level, interpreted, dynamically-typed programming language known for its clean syntax and readability.
Explanation: Python uses indentation instead of braces for code blocks. It supports multiple paradigms: procedural, OOP, and functional. Everything in Python is an object. The standard library is extensive ("batteries included"). Python runs on CPython (the default), PyPy, Jython, and more.
Example: Print "Hello World" in Python: print("Hello, World!")
Code Example:
```python
# Basic Python syntax
name = "Alice"
age = 30
if age >= 18:
print(f"{name} is an adult")
else:
print(f"{name} is a minor")
# List comprehension
squares = [x**2 for x in range(10)]
print(squares) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
```
Best Practices: Follow PEP 8 style guide. Use f-strings for formatting. Prefer list comprehensions over loops for simple transformations. Use virtual environments (venv).
Common Errors: Mutable default arguments in functions. Forgetting that strings are immutable. Using == to compare None (use is None instead).
Interview Questions: What is the GIL in Python? Explain the difference between is and ==. What are *args and **kwargs?
## Python Decorators
Definition: Decorators are functions that wrap another function to modify or extend its behavior without changing its source code.
Explanation: A decorator takes a function as input, adds some functionality, and returns a new function. They use the @syntax as syntactic sugar. Common uses: logging, timing, authentication, caching, and validation. Python's built-in decorators include @staticmethod, @classmethod, and @property.
Example: A timer decorator measures function execution time.
Code Example:
```python
import time
from functools import wraps
def timer(func):
@wraps(func) # Preserves func metadata
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"{func.__name__} took {end-start:.4f}s")
return result
return wrapper
@timer
def slow_function():
time.sleep(1)
slow_function() # slow_function took 1.0012s
```
Best Practices: Always use @wraps to preserve function metadata. Stack decorators in the right order (they apply bottom-up). Use functools.lru_cache or functools.cache for memoization.
Common Errors: Forgetting @wraps causes __name__ to show the wrapper name. Applying decorators that return None instead of the wrapped function. Calling the decorated function instead of returning it.
Interview Questions: How does @wraps work? Explain the execution order of stacked decorators. How would you implement a rate-limiting decorator?
## Python List Comprehensions
Definition: List comprehensions provide a concise way to create lists from iterables with optional filtering.
Explanation: Syntax: [expression for item in iterable if condition]. They are faster than equivalent for-loops because they're optimized at the C level. Dict comprehensions {k:v for k,v in items}, set comprehensions {x for x in items}, and generator expressions (x for x in items) use similar syntax.
Example: Filter even numbers from a list and square them in one line.
Code Example:
```python
# List comprehension
evens_squared = [x**2 for x in range(20) if x % 2 == 0]
# [0, 4, 16, 36, 64, 100, 144, 196, 256, 324]
# Dict comprehension
word_lengths = {word: len(word) for word in ["python", "java", "go"]}
# {'python': 6, 'java': 4, 'go': 2}
# Generator (memory efficient)
gen = (x**2 for x in range(1000000))
print(next(gen)) # 0 - computed lazily
```
Best Practices: Keep comprehensions simple and readable. For complex logic, use a regular for loop. Use generators when working with large datasets to avoid loading all data into memory.
Common Errors: Nested comprehensions that become unreadable. Using comprehensions with side effects (e.g., printing inside). Forgetting that generator expressions are lazy.
Interview Questions: How do comprehensions differ from map/filter? When should you use a generator expression vs a list comprehension? What is a generator?
## Python Classes and OOP
Definition: Python classes are blueprints for creating objects. Python supports full OOP with inheritance, encapsulation, and polymorphism.
Explanation: __init__ is the constructor. __str__/__repr__ control string representation. Dunder (double underscore) methods allow operator overloading. Python supports multiple inheritance. @property creates computed attributes. @classmethod gets the class itself, @staticmethod is a plain utility function.
Example: A BankAccount class with deposit/withdraw methods and balance tracking.
Code Example:
```python
class BankAccount:
interest_rate = 0.05 # Class variable
def __init__(self, owner, balance=0):
self.owner = owner
self._balance = balance # Protected
@property
def balance(self):
return self._balance
def deposit(self, amount):
if amount > 0:
self._balance += amount
def __repr__(self):
return f"BankAccount({self.owner!r}, {self._balance})"
acc = BankAccount("Alice", 1000)
acc.deposit(500)
print(acc.balance) # 1500
print(acc) # BankAccount('Alice', 1500)
```
Best Practices: Use @property instead of getter/setter methods. Prefix private attributes with _ or __. Implement __repr__ for all classes for easier debugging.
Common Errors: Mutable class-level variables shared between instances. Not calling super().__init__() in subclasses. Confusing self with cls in class methods.
Interview Questions: What is the MRO (Method Resolution Order)? Explain metaclasses. What is the difference between __str__ and __repr__?
## Python Error Handling
Definition: Python uses try/except/finally blocks to handle exceptions gracefully without crashing the program.
Explanation: Exceptions are objects derived from BaseException. Python has many built-in exceptions (ValueError, TypeError, FileNotFoundError, etc.). You can create custom exception classes. raise re-raises the current exception or raises a new one. The else block runs if no exception occurs. finally always runs (for cleanup).
Example: Opening a file — handle cases where the file doesn't exist.
Code Example:
```python
class InsufficientFundsError(Exception):
"""Custom exception"""
pass
def withdraw(balance, amount):
if amount > balance:
raise InsufficientFundsError(
f"Cannot withdraw {amount}, balance is {balance}"
)
return balance - amount
try:
new_balance = withdraw(100, 200)
except InsufficientFundsError as e:
print(f"Error: {e}")
except (TypeError, ValueError) as e:
print(f"Invalid input: {e}")
else:
print(f"Success! New balance: {new_balance}")
finally:
print("Transaction complete")
```
Best Practices: Catch specific exceptions, not bare except. Create custom exception classes for domain-specific errors. Use context managers (with statement) for resource cleanup.
Common Errors: Using bare except: catches even KeyboardInterrupt. Swallowing exceptions silently. Raising Exception directly instead of a custom subclass.
Interview Questions: What is the difference between Exception and BaseException? When would you use raise from? How do context managers relate to exception handling?
## Python Async/Await
Definition: Python's asyncio library provides asynchronous I/O using coroutines with async/await syntax for high-concurrency I/O-bound tasks.
Explanation: async def defines a coroutine. await suspends execution until the awaited task completes, allowing other tasks to run. asyncio.gather() runs multiple coroutines concurrently. This is NOT parallelism — it's cooperative multitasking on a single thread. Best for I/O tasks (network calls, DB queries), not CPU-bound work.
Example: Fetch multiple URLs concurrently instead of sequentially for 10x speedup.
Code Example:
```python
import asyncio
import aiohttp
async def fetch_url(session, url):
async with session.get(url) as response:
return await response.text()
async def main():
urls = [
"https://api.example.com/data/1",
"https://api.example.com/data/2",
]
async with aiohttp.ClientSession() as session:
tasks = [fetch_url(session, url) for url in urls]
results = await asyncio.gather(*tasks)
return results
asyncio.run(main())
```
Best Practices: Use asyncio.gather() for concurrent tasks. Use aiohttp for async HTTP, asyncpg for async DB. Don't mix sync and async code (it blocks the event loop).
Common Errors: Calling time.sleep() instead of asyncio.sleep() in async code. Forgetting to await a coroutine (returns coroutine object, not result). Using CPU-bound tasks with asyncio (use multiprocessing instead).
Interview Questions: What is the difference between asyncio, threading, and multiprocessing? Explain the event loop. When should you NOT use async/await? |