Python Notes
HubHistory of Python - Complete Guide 2026Python Applications - Complete Guide 2026Python Features - Complete Guide 2026What is Python? - Complete Guide 2026Why Learn Python? - Complete Guide 2026Your First Python Program – Hello World & Beyond 2026How to Install Python on Windows, Mac & Linux – Complete Guide 2026Install VS Code for Python – Complete Setup Guide with Extensions 2026Python Environment Setup – Virtual Environments, pip & Project Structure 2026Python IDLE – Complete Guide for Beginners 2026Python CommentsPython Data TypesPython Input and OutputPython OperatorsPython SyntaxPython Strings BasicsPython Type CastingPython VariablesBreak, Continue and Pass in PythonElif Statement in PythonFor Loop in PythonIf-Else Statement in PythonIf Statement in PythonNested If in PythonPattern Programs in PythonWhile Loop in PythonDecorators in PythonFunction Arguments in PythonFunctions Basics in PythonGenerators in PythonLambda Functions in PythonRecursive Functions in PythonReturn Statement in PythonScope of Variables in PythonAbstraction in PythonClasses and Objects in PythonConstructors in PythonEncapsulation in PythonInheritance in PythonMagic Methods (Dunder Methods) in PythonMethod Overriding in PythonPolymorphism in PythonPython Comprehensions – List, Dict, Set & GeneratorPython Dictionaries – Key-Value StorePython Dictionary Methods – Complete ReferencePython List Methods – All Built-in MethodsPython Lists – Complete GuidePython Set Methods – Complete ReferencePython Sets – Unordered Unique CollectionsPython Tuples – Immutable SequencesPython Asynchronous Programming with asyncioPython Context ManagersAdvanced Python DecoratorsAdvanced Python GeneratorsPython Iterators - Advanced GuidePython Memory ManagementPython MultiprocessingPython MultithreadingCRUD Operations in Python DatabasesMySQL with Python (mysql-connector-python)ORM Introduction with SQLAlchemyPostgreSQL with Python (psycopg2)SQLite3 with PythonIntroduction to DjangoDjango Models and ORMDjango REST API with DRFDjango ViewsIntroduction to FlaskFlask RoutingFlask Templates with Jinja2Email Automation with PythonPDF Automation with PythonSelenium Web Automation with PythonTask Scheduler with PythonWeb Scraping with PythonData Analysis with PythonData Cleaning with PythonData Visualization ProjectData Visualization with MatplotlibNumPy IntroductionPandas IntroductionStatistical Visualization with SeabornClassification AlgorithmsClustering AlgorithmsIntroduction to Machine LearningMachine Learning Project: Churn PredictionModel Evaluation and SelectionRegression AlgorithmsSave pipeline (includes preprocessing + model)AI Assistant ProjectCalculator ProjectChatbot ProjectExpense Tracker ProjectFace Detection ProjectPassword Generator ProjectWeather App ProjectPython Coding Interview QuestionsPython OOP Interview Questions and AnswersPython Master CheatsheetPython Interview Questions and AnswersPython Best PracticesCommon Python Errors and SolutionsPython Debugging TechniquesPython Learning Resources
Master Python best practices and coding standards — PEP 8 style guide, clean code principles, naming conventions, documentation, type hints, logging, testing, virtual environments, and professional Python patterns.
Writing Python code that works is one thing — writing Python code that is readable, maintainable, and professional is another. This guide covers the practices used by experienced Python developers.
PEP 8 — The Python Style Guide
PEP 8 is the official style guide for Python code. Most Python projects follow it.
Indentation and Spacing
python example
# ✅ Correct — 4 spaces per indent level
def calculate_area(length, width):
area = length * width
return area
# ❌ Wrong — 2 spaces or tabs
def calculate_area(length, width):
area = length * width
return area
# ✅ Blank lines: 2 between top-level, 1 between methods
class MyClass:
def method_one(self):
pass
def method_two(self):
pass
def standalone_function():
pass
another_function = lambda x: x * 2Naming Conventions
python example
# Variables and functions — snake_case
user_name = "Alice"
total_price = 99.99
max_retries = 3
def get_user_by_id(user_id):
return user_id
def calculate_monthly_payment(principal, rate, term):
return principal * rate / (1 - (1 + rate) ** -term)
# Classes — PascalCase
class UserAccount:
pass
class DatabaseConnection:
pass
class HTTPRequestHandler:
pass
# Constants — SCREAMING_SNAKE_CASE
MAX_CONNECTIONS = 100
API_BASE_URL = "https://api.example.com"
DEFAULT_TIMEOUT = 30
PI = 3.14159265
# Private (internal) — leading underscore
class MyClass:
def __init__(self):
self._internal_value = 42 # Convention: internal use
self.__name_mangled = "test" # Name mangling (avoid external access)
def _helper_method(self):
pass # Internal helper
# Modules — short, all lowercase
import os
import sys
import json
# Not: import MyModule, import MyModule_Utils
# Packages — lowercase, short, no hyphens
# mypackage/utils.py ✅
# MyPackage/Utils.py ❌Line Length and Wrapping
python example
# Max 79 characters (88 with Black formatter)
# PEP 8 recommends 79, Black uses 88
# ✅ Long function calls — use parentheses for implicit continuation
result = some_function(
argument_one,
argument_two,
argument_three,
keyword_arg=some_value,
)
# ✅ Long imports
from mypackage.module import (
ClassOne,
ClassTwo,
function_one,
function_two,
)
# ✅ Long conditions
if (condition_one
and condition_two
and condition_three):
do_something()
# ✅ Long strings
message = (
"This is a very long message that "
"needs to be split across multiple "
"lines for readability."
)Type Hints
Type hints make your code self-documenting and catch bugs early:
Example
from typing import Optional, List, Dict, Tuple, Union, Callable, Any
from collections.abc import Sequence
# Basic type hints
def greet(name: str) -> str:
return f"Hello, {name}!"
def add(a: int, b: int) -> int:
return a + b
def calculate_average(numbers: list[float]) -> float:
return sum(numbers) / len(numbers)
# Optional parameters
def find_user(user_id: int, default: Optional[str] = None) -> Optional[str]:
users = {1: "Alice", 2: "Bob"}
return users.get(user_id, default)
# Complex types
def process_data(
data: list[dict[str, Any]],
filters: dict[str, str],
max_results: int = 100,
) -> tuple[list[dict], int]:
filtered = [d for d in data if all(d.get(k) == v for k, v in filters.items())]
return filtered[:max_results], len(filtered)
# Union type (Python 3.10+ use X | Y)
def parse_value(value: str | int | float) -> float:
return float(value)
# Callable
def apply_transformation(
data: list[int],
transform: Callable[[int], int]
) -> list[int]:
return [transform(x) for x in data]
# Class type hints
from dataclasses import dataclass
@dataclass
class Point:
x: float
y: float
label: str = ""
def distance_to(self, other: 'Point') -> float:
return ((self.x - other.x)**2 + (self.y - other.y)**2) ** 0.5
# Using mypy to check types
# pip install mypy
# mypy your_file.py
Docstrings
Document your code properly:
python example
def calculate_compound_interest(
principal: float,
rate: float,
time: int,
n: int = 12
) -> float:
"""
Calculate compound interest.
The formula used is: A = P(1 + r/n)^(nt)
Args:
principal: Initial investment amount in dollars.
rate: Annual interest rate as a decimal (e.g., 0.05 for 5%).
time: Number of years.
n: Number of times interest compounds per year. Default is 12 (monthly).
Returns:
Final amount after compound interest.
Raises:
ValueError: If principal, rate, or time are negative.
Examples:
>>> calculate_compound_interest(1000, 0.05, 10)
1647.009...
>>> calculate_compound_interest(5000, 0.08, 20, 4) # Quarterly
24647.38...
"""
if principal < 0 or rate < 0 or time < 0:
raise ValueError("Principal, rate, and time must be non-negative")
return principal * (1 + rate / n) ** (n * time)
class DatabaseManager:
"""
Manage database connections and operations.
This class provides a high-level interface for database operations,
handling connection pooling, transactions, and error recovery.
Attributes:
host: Database server hostname.
port: Database server port.
database: Database name.
pool_size: Maximum number of pooled connections.
Example:
>>> db = DatabaseManager("localhost", 5432, "mydb")
>>> with db.connect() as conn:
... result = conn.execute("SELECT * FROM users")
"""
def __init__(self, host: str, port: int, database: str, pool_size: int = 5):
"""
Initialize the DatabaseManager.
Args:
host: Database server hostname.
port: Database server port.
database: Database name.
pool_size: Max connections in pool.
"""
self.host = host
self.port = port
self.database = database
self.pool_size = pool_sizeClean Code Principles
Single Responsibility
Example
# ❌ Function doing too much
def process_and_email_report(users, recipients):
# Fetch data
data = []
for user in users:
data.append(fetch_user_data(user.id))
# Process data
summary = {}
for d in data:
category = d.get('category', 'other')
summary[category] = summary.get(category, 0) + d.get('amount', 0)
# Format email
body = "Report:\n"
for cat, total in summary.items():
body += f"{cat}: ${total}\n"
# Send email
for recipient in recipients:
send_email(recipient, "Report", body)
# ✅ Each function has one responsibility
def fetch_users_data(users: list) -> list[dict]:
return [fetch_user_data(user.id) for user in users]
def summarize_by_category(data: list[dict]) -> dict[str, float]:
summary = {}
for d in data:
category = d.get('category', 'other')
summary[category] = summary.get(category, 0) + d.get('amount', 0)
return summary
def format_report(summary: dict[str, float]) -> str:
lines = ["Report:"]
for category, total in sorted(summary.items()):
lines.append(f" {category}: ${total:,.2f}")
return "\n".join(lines)
def send_report(recipients: list[str], report_body: str) -> None:
for recipient in recipients:
send_email(recipient, "Monthly Report", report_body)
def process_and_email_report(users, recipients):
"""Orchestrator — coordinates the steps."""
data = fetch_users_data(users)
summary = summarize_by_category(data)
body = format_report(summary)
send_report(recipients, body)
DRY — Don't Repeat Yourself
python example
# ❌ Repeated code
def validate_name(name):
if not name:
raise ValueError("Name cannot be empty")
if len(name) < 2:
raise ValueError("Name must be at least 2 characters")
if len(name) > 100:
raise ValueError("Name must be at most 100 characters")
return name.strip()
def validate_city(city):
if not city:
raise ValueError("City cannot be empty")
if len(city) < 2:
raise ValueError("City must be at least 2 characters")
if len(city) > 100:
raise ValueError("City must be at most 100 characters")
return city.strip()
# ✅ DRY — reusable validation
def validate_string_field(value: str, field_name: str, min_len=2, max_len=100) -> str:
"""Validate a string field with standard rules."""
if not value:
raise ValueError(f"{field_name} cannot be empty")
stripped = value.strip()
if len(stripped) < min_len:
raise ValueError(f"{field_name} must be at least {min_len} characters")
if len(stripped) > max_len:
raise ValueError(f"{field_name} must be at most {max_len} characters")
return stripped
validate_name = lambda n: validate_string_field(n, "Name")
validate_city = lambda c: validate_string_field(c, "City")
validate_bio = lambda b: validate_string_field(b, "Bio", min_len=10, max_len=500)Logging
Use logging instead of print statements:
Example
import logging
import sys
from pathlib import Path
def setup_logger(name: str, log_file: str = None, level=logging.INFO) -> logging.Logger:
"""Set up a named logger with file and console handlers."""
logger = logging.getLogger(name)
logger.setLevel(level)
if logger.handlers:
return logger # Already configured
formatter = logging.Formatter(
'%(asctime)s | %(name)s | %(levelname)s | %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
# Console handler
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)
# File handler (optional)
if log_file:
Path(log_file).parent.mkdir(parents=True, exist_ok=True)
file_handler = logging.FileHandler(log_file)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
return logger
# Usage
logger = setup_logger('my_app', log_file='logs/app.log')
def process_data(data: list) -> dict:
logger.info(f"Processing {len(data)} records")
if not data:
logger.warning("Empty data provided — returning empty result")
return {}
try:
result = {item['id']: item for item in data}
logger.debug(f"Processed {len(result)} unique records")
return result
except KeyError as e:
logger.error(f"Missing key {e} in data record")
raise
except Exception as e:
logger.exception(f"Unexpected error processing data: {e}") # Includes traceback
raise
# Log levels (from lowest to highest):
# DEBUG — Detailed diagnostic info
# INFO — General informational messages
# WARNING — Something unexpected but not an error
# ERROR — An error occurred but program continues
# CRITICAL — A serious error that may stop the program
Virtual Environments
bash example
# Create virtual environment
python -m venv venv
# Activate
# Windows:
venv\Scripts\activate
# macOS/Linux:
source venv/bin/activate
# Install dependencies
pip install -r requirements.txt
# Create requirements.txt
pip freeze > requirements.txt
# Install exact versions (reproducible)
pip install -r requirements.txt
# Using pip-tools (better dependency management)
pip install pip-tools
# requirements.in — direct dependencies (no versions)
# requirements.txt — pinned transitive deps (generated)
pip-compile requirements.in
# Using pyenv (manage multiple Python versions)
# brew install pyenv (macOS)
# pyenv install 3.12.3
# pyenv local 3.12.3Code Formatting Tools
Example
# Black — opinionated code formatter
pip install black
black my_file.py
black my_project/ # Format entire project
black --check my_file.py # Check without modifying
# isort — sort imports
pip install isort
isort my_file.py
isort --check-only my_file.py
# Flake8 — linting (style + errors)
pip install flake8
flake8 my_file.py
flake8 my_project/
# mypy — static type checking
pip install mypy
mypy my_file.py
mypy --strict my_project/
# Configure in pyproject.toml
# [tool.black]
# line-length = 88
# target-version = ['py312']
#
# [tool.isort]
# profile = "black"
#
# [tool.mypy]
# ignore_missing_imports = true
Project Structure
my_python_project/
├── src/
│ └── my_package/
│ ├── __init__.py
│ ├── core.py # Main business logic
│ ├── models.py # Data models
│ ├── utils.py # Utility functions
│ ├── config.py # Configuration
│ └── exceptions.py # Custom exceptions
├── tests/
│ ├── __init__.py
│ ├── conftest.py # pytest fixtures
│ ├── test_core.py
│ ├── test_models.py
│ └── test_utils.py
├── docs/
│ └── index.md
├── scripts/
│ └── setup_db.py
├── .env # Environment variables (not in git!)
├── .env.example # Template for .env
├── .gitignore
├── pyproject.toml # Modern config
├── requirements.txt
├── requirements-dev.txt # Dev dependencies
└── README.md
Summary
Key best practices covered:
- ✅ PEP 8 formatting (indentation, naming, line length)
- ✅ Type hints for self-documenting code
- ✅ Docstrings (Google/NumPy/Sphinx style)
- ✅ Single Responsibility Principle
- ✅ DRY — eliminating code duplication
- ✅ Proper logging (not print statements)
- ✅ Virtual environments for isolation
- ✅ Code formatting tools (Black, isort, flake8, mypy)
- ✅ Professional project structure
*Next: Common Errors →*
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Python Best Practices.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Python Master Course topic.
Search Terms
python-master-course, python master course, python, master, course, resources, best, practices
Related Python Master Course Topics
Continue learning this concept
ResourcesCommon Python Errors and SolutionsMaster Python error handling by understanding the most common errors — SyntaxError, IndentationError, NameError, TypeError, AttributeError, ImportError, ValueError, KeyError, IndexError, and how to fix them.ResourcesPython Debugging TechniquesMaster Python debugging — print debugging, pdb debugger, VS Code debugger, logging strategies, unit testing with pytest, profiling, and systematic debugging workflows for finding and fixing bugs quickly.ResourcesPython Learning ResourcesCurated list of the best Python learning resources — official documentation, books, online courses, YouTube channels, practice platforms, communities, cheat sheets, and a structured 6-month learning roadmap.Advanced PythonPython Asynchronous Programming with asyncioDeep dive into Python async/await, asyncio event loop, coroutines, tasks, async generators, aiohttp, and real-world asynchronous patterns with Hindi explanations.Advanced PythonPython Context ManagersComprehensive guide to Python context managers using with statement, __enter__ and __exit__ methods, contextlib module, nested context managers and custom resource management.Advanced PythonAdvanced Python DecoratorsMaster advanced Python decorators including decorator factories, class decorators, stacking decorators, functools.wraps, parameterized decorators, and real-world patterns.