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
Python ki features kya hain? Complete guide to Python
Introduction
What makes Python special among hundreds of programming languages? The answer lies in its carefully crafted set of features — design decisions made over three decades that collectively create a language that is simultaneously beginner-friendly and professional-grade. Python's features aren't accidents; each one was deliberately chosen to make code more readable, maintainable, and productive.
In this guide, we'll explore every major feature of Python — from its surface-level syntax design to its deeper runtime characteristics. We'll see each feature in action with code examples, understand *why* it exists, and appreciate how they work together to create the Python experience.
Hindi: Python ki features (visheshataen) use baaki languages se alag banati hain. Python ka syntax simple hai, isko seekhna aasaan hai, aur iska use har jagah hota hai. In features ki wajah se Python duniya ki most popular language bani hai.
Feature 1: Simple and Readable Syntax
Python's most celebrated feature is its readable, minimal syntax. The language was designed to look like pseudocode — the informal way programmers sketch out algorithms before writing real code.
Indentation as Structure
Python uses whitespace indentation to define code blocks instead of curly braces {}. This is controversial among some developers, but it forces consistent, readable formatting.
Example
# Python uses indentation — code structure is visible!
def check_temperature(temp):
if temp > 40:
status = "Dangerous Heat"
action = "Stay indoors"
elif temp > 30:
status = "Hot Day"
action = "Stay hydrated"
elif temp > 20:
status = "Comfortable"
action = "Enjoy the weather"
else:
status = "Cold"
action = "Wear warm clothes"
return f"{status}: {action}"
# The indentation makes the logic visually clear
temperatures = [45, 35, 25, 10]
for temp in temperatures:
print(f"{temp}°C → {check_temperature(temp)}")
Output
45°C → Dangerous Heat: Stay indoors 35°C → Hot Day: Stay hydrated 25°C → Comfortable: Enjoy the weather 10°C → Cold: Wear warm clothes
Hindi: Python mein curly braces {} ki jagah indentation (spaces/tabs) use hoti hai. Iska faida ye hai ki code automatically neat aur padha jaane wala hota hai. Agar aap indentation galat karein toh Python error deta hai — ye aapko clean code likhne ke liye majboor karta hai.Minimal Boilerplate
Python requires almost no "setup code." Compare reading a file:
python example
# Python — clean and simple
with open("data.txt", "r") as file:
content = file.read()
print(content)
# Java equivalent would require:
# try { BufferedReader reader = new BufferedReader(
# new FileReader("data.txt")); String line;
# StringBuilder sb = new StringBuilder();
# while ((line = reader.readLine()) != null) { ... }
# } catch (IOException e) { e.printStackTrace(); }
# — Python is about 4x fewer lines for the same task!
print("File reading complete!")Output
File reading complete!
Feature 2: Dynamically Typed
Python is dynamically typed: variable types are determined at runtime, not compile time. You don't declare types when creating variables.
Example
# No type declarations needed!
x = 42 # x is int
x = "Hello" # x is now str — no error!
x = [1, 2, 3] # x is now list — still no error!
x = 3.14 # x is now float
print(type(x)) # <class 'float'>
# Contrast with Java (static typing):
# int x = 42;
# x = "Hello"; // COMPILE ERROR in Java!
# Dynamic typing allows flexible, fast coding
def process(data):
"""Works with strings, lists, dicts — anything!"""
if isinstance(data, str):
return data.upper()
elif isinstance(data, list):
return sorted(data)
elif isinstance(data, dict):
return list(data.keys())
print(process("hello"))
print(process([3, 1, 4, 1, 5]))
print(process({"b": 2, "a": 1, "c": 3}))
Output
<class 'float'> HELLO [1, 1, 3, 4, 5] ['b', 'a', 'c']
Python 3.5+ Type Hints (Best of Both Worlds)
Python 3.5 added optional type hints — you can annotate types for tooling and documentation without losing dynamic flexibility:
Example
from typing import Union, List
# Type hints = documentation + tool support
# Python still runs even if types don't match (runtime)
# But editors and mypy can catch type errors before running
def calculate_bmi(weight_kg: float, height_m: float) -> float:
"""Calculate Body Mass Index"""
return weight_kg / (height_m ** 2)
def greet_all(names: List[str]) -> str:
"""Greet a list of people"""
return "Hello, " + ", ".join(names) + "!"
def flexible(value: Union[int, str]) -> str:
return str(value)
# Type hints in action
bmi = calculate_bmi(70.0, 1.75)
print(f"BMI: {bmi:.1f}")
print(greet_all(["Rahul", "Priya", "Amit"]))
Output
BMI: 22.9 Hello, Rahul, Priya, Amit!
Feature 3: Object-Oriented Programming (OOP)
Python is a full-featured OOP language with classes, inheritance, encapsulation, and polymorphism:
Example
# Python OOP — clean and powerful
class Animal:
"""Base class for all animals"""
def __init__(self, name: str, sound: str):
self.name = name
self.sound = sound
self._legs = None # Protected attribute
def speak(self) -> str:
return f"{self.name} says: {self.sound}!"
def __repr__(self) -> str:
return f"Animal(name='{self.name}')"
class Dog(Animal):
"""Dog inherits from Animal"""
def __init__(self, name: str, breed: str):
super().__init__(name, "Woof")
self.breed = breed
self._legs = 4
def fetch(self, item: str) -> str:
return f"{self.name} fetches the {item}! 🎾"
def speak(self) -> str:
# Polymorphism — overrides parent method
return f"{self.name} ({self.breed}) says: Woof woof! 🐶"
class Cat(Animal):
"""Cat inherits from Animal"""
def __init__(self, name: str):
super().__init__(name, "Meow")
self._legs = 4
def speak(self) -> str:
return f"{self.name} says: Purrr... Meow! 🐱"
# Create instances
dog = Dog("Bruno", "Labrador")
cat = Cat("Whiskers")
animals = [dog, cat]
# Polymorphism — same method, different behavior
for animal in animals:
print(animal.speak())
print(dog.fetch("ball"))
print(repr(dog))
Output
Bruno (Labrador) says: Woof woof! 🐶 Whiskers says: Purrr... Meow! 🐱 Bruno fetches the ball! 🎾 Animal(name='Bruno')
Hindi: Python mein OOP (Object-Oriented Programming) use karna bahut easy hai. Class banao, objects banao, inheritance use karo — sab kuch clearly aur simply likha jaata hai.
Feature 4: Functional Programming Support
Python supports functional programming with first-class functions, lambdas, map/filter/reduce:
Example
# First-class functions — functions as values
def apply_twice(func, value):
"""Apply a function twice to a value"""
return func(func(value))
def double(x):
return x * 2
result = apply_twice(double, 3)
print(f"apply_twice(double, 3) = {result}") # 12
# Lambda functions — anonymous one-liners
square = lambda x: x ** 2
cube = lambda x: x ** 3
numbers = [1, 2, 3, 4, 5]
# map() — apply function to each element
squares = list(map(square, numbers))
print(f"Squares: {squares}")
# filter() — keep elements where function returns True
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(f"Evens: {evens}")
# Sorted with key function
students = [("Rahul", 85), ("Priya", 95), ("Amit", 72), ("Sita", 91)]
by_marks = sorted(students, key=lambda s: s[1], reverse=True)
print(f"\nRanking:")
for i, (name, mark) in enumerate(by_marks, 1):
print(f" {i}. {name}: {mark}")
Output
apply_twice(double, 3) = 12 Squares: [1, 4, 9, 16, 25] Evens: [2, 4] Ranking: 1. Priya: 95 2. Sita: 91 3. Rahul: 85 4. Amit: 72
List Comprehensions — Python's Functional Crown Jewel
Example
# List comprehension — concise and Pythonic!
# Syntax: [expression for item in iterable if condition]
# Basic
squares = [x**2 for x in range(1, 11)]
print("Squares:", squares)
# With condition
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print("Even squares:", even_squares)
# Nested
matrix = [[i * j for j in range(1, 5)] for i in range(1, 5)]
print("\nMultiplication table (4x4):")
for row in matrix:
print(row)
# Dict comprehension
word_lengths = {word: len(word) for word in ["Python", "Java", "C++", "Go"]}
print("\nWord lengths:", word_lengths)
# Set comprehension
unique_remainders = {x % 5 for x in range(1, 21)}
print("Unique remainders mod 5:", sorted(unique_remainders))
Output
Squares: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Even squares: [4, 16, 36, 64, 100]
Multiplication table (4x4):
[1, 2, 3, 4]
[2, 4, 6, 8]
[3, 6, 9, 12]
[4, 8, 12, 16]
Word lengths: {'Python': 6, 'Java': 4, 'C++': 3, 'Go': 2}
Unique remainders mod 5: [0, 1, 2, 3, 4]Feature 5: Generators and Iterators
Python's generator feature allows lazy evaluation — computing values on demand rather than all at once, saving memory:
Example
# Regular function returns all values at once (memory heavy for large data)
def squares_list(n):
return [x**2 for x in range(n)]
# Generator function — computes one at a time (memory efficient!)
def squares_gen(n):
for x in range(n):
yield x**2 # 'yield' makes this a generator
# For small n, both work the same
for sq in squares_gen(5):
print(sq, end=" ")
print()
# For large n, generator wins massively!
import sys
list_size = sys.getsizeof(squares_list(10000))
gen_size = sys.getsizeof(squares_gen(10000))
print(f"\nList of 10,000 squares: {list_size:,} bytes")
print(f"Generator for 10,000 squares: {gen_size:,} bytes")
print(f"Memory saved: {list_size - gen_size:,} bytes ({(list_size/gen_size):.0f}x more efficient!)")
Output
0 1 4 9 16 List of 10,000 squares: 85,176 bytes Generator for 10,000 squares: 104 bytes Memory saved: 85,072 bytes (819x more efficient!)
Generator Expressions
python example
# Generator expression — like list comprehension but lazy
gen = (x**2 for x in range(1_000_000)) # No memory used yet!
# Get first 5 values
for i, val in enumerate(gen):
if i >= 5:
break
print(val, end=" ")
print("\n(Only computed what was needed)")Output
0 1 4 9 16 (Only computed what was needed)
Hindi: Generators Python ki ek powerful feature hai jisme hum values ko ek ek karke generate karte hain, saari ek saath nahi. Isse memory bachti hai. Jaise ek tap se pani — poora samundar ek saath nahi, ek ek drop aata hai jab zaroorat ho.
Feature 6: Decorators
Decorators allow you to modify or enhance functions/classes without changing their code — a powerful tool for logging, caching, access control, and more:
python example
import time
import functools
# Decorator that times how long a function takes
def timer(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print(f"⏱️ {func.__name__}() took {end - start:.4f} seconds")
return result
return wrapper
# Decorator that logs function calls
def logger(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
print(f"📞 Calling: {func.__name__}({args}, {kwargs})")
result = func(*args, **kwargs)
print(f"✅ Returned: {result}")
return result
return wrapper
# Stack multiple decorators!
@timer
@logger
def calculate_sum(n: int) -> int:
"""Calculate sum of first n numbers"""
return sum(range(n + 1))
# Call the decorated function
total = calculate_sum(100)Output
📞 Calling: calculate_sum((100,), {})
✅ Returned: 5050
⏱️ calculate_sum() took 0.0001 secondsExample
# Real-world: caching decorator
def memoize(func):
"""Cache expensive function results"""
cache = {}
@functools.wraps(func)
def wrapper(*args):
if args not in cache:
cache[args] = func(*args)
print(f" 💾 Cached result for {args}")
else:
print(f" ⚡ Cache hit for {args}")
return cache[args]
return wrapper
@memoize
def fibonacci(n):
if n < 2:
return n
return fibonacci(n-1) + fibonacci(n-2)
print("Fibonacci sequence:")
for i in range(8):
print(f" fib({i}) = {fibonacci(i)}")
Output
Fibonacci sequence: 💾 Cached result for (0,) fib(0) = 0 💾 Cached result for (1,) fib(1) = 1 💾 Cached result for (2,) fib(2) = 1 ⚡ Cache hit for (1,) 💾 Cached result for (3,) fib(3) = 2 ⚡ Cache hit for (2,) 💾 Cached result for (4,) fib(4) = 3 ...
Feature 7: Context Managers (with statement)
The with statement provides clean resource management — automatically handling setup and teardown:
python example
# Without context manager — error-prone
file = open("data.txt", "w")
try:
file.write("Hello, World!")
finally:
file.close() # Must remember to close!
# With context manager — clean and safe
with open("data.txt", "w") as file:
file.write("Hello, World!")
# File automatically closed here, even if an error occurs!
# Custom context manager
from contextlib import contextmanager
import time
@contextmanager
def timer_context(operation_name: str):
"""Context manager that times an operation"""
print(f"▶️ Starting: {operation_name}")
start = time.time()
try:
yield # Code inside the 'with' block runs here
finally:
elapsed = time.time() - start
print(f"⏹️ Finished: {operation_name} in {elapsed:.3f}s")
# Usage
with timer_context("Data Processing"):
data = list(range(1_000_000))
total = sum(data)
print(f" Sum of 1M numbers: {total:,}")Output
▶️ Starting: Data Processing Sum of 1M numbers: 499,999,500,000 ⏹️ Finished: Data Processing in 0.052s
Feature 8: Exception Handling
Python has comprehensive exception handling that makes error recovery clean and structured:
Example
# Python exception hierarchy
class DatabaseError(Exception):
"""Custom exception for database errors"""
pass
class ConnectionError(DatabaseError):
"""Raised when DB connection fails"""
def __init__(self, host, port):
self.host = host
self.port = port
super().__init__(f"Cannot connect to {host}:{port}")
def connect_database(host: str, port: int):
if port < 0 or port > 65535:
raise ValueError(f"Invalid port: {port}")
if host == "invalid":
raise ConnectionError(host, port)
return f"Connected to {host}:{port}"
# Comprehensive exception handling
hosts_to_try = [
("db.example.com", 5432),
("invalid", 5432),
("db.backup.com", -1),
("db.fallback.com", 5432),
]
for host, port in hosts_to_try:
try:
result = connect_database(host, port)
print(f"✅ {result}")
break # Success! Stop trying
except ConnectionError as e:
print(f"❌ Connection failed: {e}")
except ValueError as e:
print(f"⚠️ Invalid input: {e}")
except Exception as e:
print(f"💥 Unexpected error: {e}")
else:
print(" No exceptions — success!")
finally:
print(f" (Attempted: {host}:{port})")
Output
✅ Connected to db.example.com:5432 (Attempted: db.example.com:5432)
Hindi: Exception handling Python ka ek important feature hai jisse aap program ke errors ko gracefully handle kar sakte ho.trymein risky code dalte hain,exceptmein error hone pe kya karna hai ye batate hain.
Feature 9: Duck Typing
Python uses duck typing — if it walks like a duck and quacks like a duck, it's a duck. Python doesn't check *what type* an object is, it checks *what it can do*:
Example
# Duck typing in action
class Dog:
def speak(self): return "Woof!"
def move(self): return "Runs on 4 legs"
class Robot:
def speak(self): return "BEEP BOOP"
def move(self): return "Rolls on wheels"
class Human:
def speak(self): return "Hello!"
def move(self): return "Walks on 2 legs"
def make_it_speak(thing):
# We don't care WHAT 'thing' is
# We just care that it HAS a 'speak' method
print(f"It says: {thing.speak()}")
def make_it_move(thing):
print(f"It moves: {thing.move()}")
entities = [Dog(), Robot(), Human()]
for entity in entities:
make_it_speak(entity) # Works for all!
make_it_move(entity) # Works for all!
print()
Output
It says: Woof! It moves: Runs on 4 legs It says: BEEP BOOP It moves: Rolls on wheels It says: Hello! It moves: Walks on 2 legs
Feature 10: Comprehensive Standard Library
Python's "batteries included" standard library covers almost every common programming need:
Example
┌──────────────────────────────────────────────────────────────┐
│ PYTHON STANDARD LIBRARY HIGHLIGHTS │
├─────────────────────┬────────────────────────────────────────┤
│ Category │ Modules │
├─────────────────────┼────────────────────────────────────────┤
│ File & I/O │ os, pathlib, io, shutil, glob │
│ Data Formats │ json, csv, xml, html, sqlite3 │
│ Networking │ socket, http, urllib, email, ftplib │
│ Date & Time │ datetime, calendar, time, zoneinfo │
│ Math & Numbers │ math, decimal, fractions, statistics │
│ Text Processing │ re, string, difflib, textwrap │
│ Cryptography │ hashlib, hmac, secrets │
│ Compression │ gzip, zipfile, tarfile, zlib │
│ Testing │ unittest, doctest, mock │
│ Concurrency │ threading, multiprocessing, asyncio │
│ Debugging │ pdb, logging, traceback, inspect │
│ Data Structures │ collections, heapq, queue, array │
│ Internet │ urllib, http.client, xmlrpc │
└─────────────────────┴────────────────────────────────────────┘
Example
# Using the standard library — no installs needed!
import json
import pathlib
import hashlib
import statistics
# JSON handling
data = {"name": "Rahul", "score": 95, "subjects": ["Python", "SQL"]}
json_str = json.dumps(data, indent=2)
print("JSON output:")
print(json_str)
# Path manipulation
current_file = pathlib.Path(__file__).parent
print(f"\nCurrent directory: {current_file}")
# Cryptographic hashing
password = "my_secret_password"
hashed = hashlib.sha256(password.encode()).hexdigest()
print(f"\nSHA-256 hash: {hashed[:20]}...")
# Statistics
scores = [85, 92, 78, 95, 88, 76, 91, 83, 97, 79]
print(f"\nMean: {statistics.mean(scores):.1f}")
print(f"Median: {statistics.median(scores):.1f}")
print(f"Std Dev: {statistics.stdev(scores):.2f}")
Output
JSON output:
{
"name": "Rahul",
"score": 95,
"subjects": [
"Python",
"SQL"
]
}
Current directory: /home/user/project
SHA-256 hash: 89e01536ac207279409...
Mean: 86.4
Median: 86.5
Std Dev: 7.18Feature 11: Multi-paradigm Programming
Python supports multiple programming paradigms — use the style that best fits your problem:
Example
# Same task solved in three paradigms!
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
target = "sum of squares of even numbers"
# 1. PROCEDURAL approach
def sum_even_squares_procedural(nums):
total = 0
for n in nums:
if n % 2 == 0:
total += n ** 2
return total
# 2. FUNCTIONAL approach
from functools import reduce
def sum_even_squares_functional(nums):
evens = filter(lambda x: x % 2 == 0, nums)
squares = map(lambda x: x ** 2, evens)
return reduce(lambda a, b: a + b, squares)
# 3. PYTHONIC approach (list comprehension)
def sum_even_squares_pythonic(nums):
return sum(x**2 for x in nums if x % 2 == 0)
# All give the same answer!
r1 = sum_even_squares_procedural(numbers)
r2 = sum_even_squares_functional(numbers)
r3 = sum_even_squares_pythonic(numbers)
print(f"Procedural: {r1}")
print(f"Functional: {r2}")
print(f"Pythonic: {r3}")
print(f"All equal? {r1 == r2 == r3}")
Output
Procedural: 220 Functional: 220 Pythonic: 220 All equal? True
Feature 12: Interactive Mode (REPL)
Python's REPL (Read-Eval-Print Loop) allows you to test code interactively — essential for learning and debugging:
Example
┌──────────────────────────────────────────────────────────────┐
│ PYTHON REPL SESSION │
├──────────────────────────────────────────────────────────────┤
│ │
│ $ python3 │
│ Python 3.12.0 (default, Oct 2 2023) │
│ [GCC 11.4.0] on linux │
│ >>> 2 + 2 │
│ 4 │
│ >>> name = "WoHoTech" │
│ >>> f"Welcome to {name}!" │
│ 'Welcome to WoHoTech!' │
│ >>> [x**2 for x in range(5)] │
│ [0, 1, 4, 9, 16] │
│ >>> import math │
│ >>> math.sqrt(144) │
│ 12.0 │
│ >>> exit() │
│ $ │
│ │
└──────────────────────────────────────────────────────────────┘
Feature 13: Cross-Platform Compatibility
Python runs on virtually every platform without modification:
Example
┌─────────────────────────────────────────────────────────────┐
│ PYTHON PLATFORM SUPPORT │
├─────────────────────────────────────────────────────────────┤
│ │
│ Desktop OS: │
│ ✅ Windows (XP to 11+) │
│ ✅ macOS (10.9+) │
│ ✅ Linux (all distributions) │
│ ✅ FreeBSD, OpenBSD │
│ │
│ Mobile & Embedded: │
│ ✅ Android (via Kivy, BeeWare) │
│ ✅ iOS (via BeeWare) │
│ ✅ Raspberry Pi (MicroPython) │
│ ✅ Arduino-compatible (CircuitPython) │
│ │
│ Cloud & Server: │
│ ✅ AWS Lambda, Google Cloud Functions │
│ ✅ Docker containers │
│ ✅ Kubernetes pods │
│ │
│ Special Environments: │
│ ✅ Jupyter Notebooks (browser) │
│ ✅ Google Colab (cloud Python) │
│ ✅ PyScript (Python in browser via WASM) │
│ │
└─────────────────────────────────────────────────────────────┘
Feature 14: Automatic Memory Management (Garbage Collection)
Python manages memory automatically — you don't manually allocate or free memory:
Example
import gc
# Python handles memory automatically!
# No malloc/free like in C
# No 'delete' like in C++
class HeavyObject:
def __init__(self, name):
self.name = name
self.data = [0] * 100_000 # Allocate some memory
print(f" Created: {name}")
def __del__(self):
print(f" Garbage collected: {self.name}")
print("Creating objects...")
obj1 = HeavyObject("Obj1")
obj2 = HeavyObject("Obj2")
print("\nDeleting obj1 reference...")
del obj1 # Python GC may collect this
print("\nRunning garbage collector manually...")
collected = gc.collect()
print(f"Collected {collected} objects")
print("\nScript ending — obj2 will be collected automatically")
Output
Creating objects... Created: Obj1 Created: Obj2 Deleting obj1 reference... Garbage collected: Obj1 Running garbage collector manually... Collected 0 objects Script ending — obj2 will be collected automatically Garbage collected: Obj2
Hindi: Python mein memory management automatic hoti hai. C/C++ mein aapko khud memory allocate aur free karni padti thi, lekin Python mein ye sab automatically hota hai. Python ka Garbage Collector un objects ko automatically delete karta hai jo ab use nahi ho rahe.
Feature 15: Dataclasses (Python 3.7+)
Python 3.7 introduced dataclasses — a way to create clean data-holding classes with minimal code:
Example
from dataclasses import dataclass, field
from typing import List
@dataclass
class Student:
name: str
roll_no: int
marks: List[float] = field(default_factory=list)
@property
def average(self) -> float:
return sum(self.marks) / len(self.marks) if self.marks else 0.0
@property
def grade(self) -> str:
avg = self.average
return "A" if avg >= 90 else "B" if avg >= 75 else "C" if avg >= 60 else "F"
def __str__(self) -> str:
return f"Student({self.name}, Roll: {self.roll_no}, Grade: {self.grade})"
# Python auto-generates __init__, __repr__, __eq__!
s1 = Student("Rahul", 101, [85, 90, 88, 92, 87])
s2 = Student("Priya", 102, [95, 98, 96, 97, 94])
students = [s1, s2]
for student in students:
print(student)
print(f" Average: {student.average:.1f}")
print(f" Marks: {student.marks}")
Output
Student(Rahul, Roll: 101, Grade: B) Average: 88.4 Marks: [85, 90, 88, 92, 87] Student(Priya, Roll: 102, Grade: A) Average: 96.0 Marks: [95, 98, 96, 97, 94]
Key Points / Summary
- Simple syntax: Indentation-based, English-like, minimal boilerplate — most readable language.
- Dynamic typing: Variables don't need type declarations; types are checked at runtime.
- Type hints (3.5+): Optional annotations for documentation and tooling support.
- Object-oriented: Full OOP with classes, inheritance, polymorphism, and special methods.
- Functional features: First-class functions, lambdas, map/filter, list comprehensions.
- Generators: Memory-efficient lazy evaluation with the
yieldkeyword. - Decorators: Modify functions/classes without changing their code — AOP in Python.
- Context managers: Clean resource management via
withstatement. - Duck typing: Behavior matters more than type — flexible and powerful.
- Standard library: "Batteries included" — hundreds of built-in modules.
- Multi-paradigm: Supports procedural, OOP, and functional styles.
- REPL: Interactive mode for quick testing and learning.
- Cross-platform: Runs on Windows, macOS, Linux, mobile, cloud, and embedded devices.
- Automatic memory management: Garbage collector handles memory — no manual
malloc/free. - Dataclasses: Concise, auto-generated class boilerplate (Python 3.7+).
Interview Questions
Q1. What does "dynamically typed" mean? How is it different from "strongly typed"?
Dynamically typed means types are checked at *runtime*, not compile time — you don't declare variable types. Strongly typed means Python *enforces* type correctness — you can't silently concatenate an int and a string (unlike JavaScript). Python is *both* — dynamically AND strongly typed.
Q2. What is duck typing in Python?
Duck typing means Python doesn't check the type of an object, it checks what methods/attributes it has. The name comes from: "If it walks like a duck and quacks like a duck, it is a duck." Python'sforloop works on any object that has__iter__— whether it's a list, tuple, dict, generator, or custom class.
Q3. What is the difference between a list comprehension and a generator expression?
A list comprehension[x2 for x in range(n)]evaluates all values immediately and stores them in memory. A generator expression(x2 for x in range(n)) is lazy — it computes values one-by-one when requested. For large datasets, generators are much more memory-efficient.
Q4. What are decorators? Give a real-world use case.
Decorators are functions that wrap other functions to add functionality without changing the original code. Real-world uses: (1)@login_requiredin Django — checks if user is logged in before executing a view, (2)@cache— memoizes expensive function results, (3)@property— converts a method into a read-only attribute, (4)@staticmethod/@classmethod— modifies method behavior in classes.
Q5. How does Python manage memory? What is the GIL?
Python uses reference counting as its primary memory management strategy — objects are freed when their reference count drops to zero. A cyclic garbage collector handles circular references. The GIL (Global Interpreter Lock) is a mutex that prevents multiple native threads from executing Python bytecode simultaneously in CPython — this limits true parallelism. Python 3.13 introduces an experimental no-GIL mode to address this.
Next Steps
You now know Python's powerful features. Continue your journey:
- 🚀 Python Applications — See how all these features are used in real-world applications
- 💻 Install Python and practice each feature in the REPL
Practice Exercise:
Example
# Challenge: Create a Student management system using:
# ✅ Dataclass
# ✅ List comprehension
# ✅ Decorator (timer)
# ✅ Context manager (file I/O)
# ✅ Generator (for large student lists)
# ✅ Exception handling
# Start here:
from dataclasses import dataclass
from typing import List
@dataclass
class Student:
name: str
marks: List[float]
@property
def average(self):
return sum(self.marks) / len(self.marks)
# Add: save_to_file(), load_from_file(), top_students() generator
⚠️ Common Mistakes
Python ki features seekhte waqt beginners kuch common galtiyan karte hain. Inhe avoid karo! 🚫
❌ Mistake 1: Mixing Tabs and Spaces for Indentation
python example
# ❌ WRONG — tabs aur spaces mix karna
def greet():
print("Hello") # tab use kiya
print("World") # spaces use kiya — IndentationError!
# ✅ CORRECT — hamesha 4 spaces use karo
def greet():
print("Hello")
print("World")Hindi: Python mein tabs aur spaces ko mix karna allowed nahi hai. Hamesha 4 spaces ka consistent indentation use karo. Apne editor mein "spaces on tab" setting ON rakho.
❌ Mistake 2: Thinking Dynamic Typing Means No Type Errors
python example
# ❌ WRONG — dynamic typing ka matlab ye NAHI ki kuch bhi kar sakte ho
name = "Rahul"
age = 25
result = name + age # TypeError! str + int not allowed
# ✅ CORRECT — explicit conversion karo
result = name + str(age) # "Rahul25"
print(result)Output
Rahul25
Hindi: Python dynamically typed hai par strongly typed bhi hai. Matlab aap variable ka type change kar sakte ho, lekin incompatible types ko mix nahi kar sakte without conversion.
❌ Mistake 3: Modifying a List While Iterating Over It
Example
# ❌ WRONG — list iterate karte waqt modify karna
numbers = [1, 2, 3, 4, 5, 6]
for num in numbers:
if num % 2 == 0:
numbers.remove(num) # Unexpected behavior!
# ✅ CORRECT — list comprehension use karo
numbers = [1, 2, 3, 4, 5, 6]
numbers = [num for num in numbers if num % 2 != 0]
print(numbers)
Output
[1, 3, 5]
Hindi: Jab aap list ko iterate kar rahe ho tab usko modify mat karo — results unpredictable hote hain. List comprehension ya naya list banao.
❌ Mistake 4: Using Mutable Default Arguments
Example
# ❌ WRONG — mutable default argument shared hota hai between calls!
def add_item(item, items=[]):
items.append(item)
return items
print(add_item("a")) # ['a'] — correct
print(add_item("b")) # ['a', 'b'] — BUG! Expected ['b']
# ✅ CORRECT — None use karo as default
def add_item_fixed(item, items=None):
if items is None:
items = []
items.append(item)
return items
print(add_item_fixed("a")) # ['a']
print(add_item_fixed("b")) # ['b'] — correct!
Output
['a'] ['a', 'b'] ['a'] ['b']
Hindi: Python mein function ke default arguments sirf EK BAAR evaluate hote hain (jab function define hota hai). Mutable defaults (list, dict) ko avoid karo — None use karo instead.❌ Mistake 5: Confusing is with ==
Example
# ❌ WRONG — 'is' identity check hai, equality nahi!
a = [1, 2, 3]
b = [1, 2, 3]
print(a == b) # True — same values
print(a is b) # False — different objects in memory!
# ✅ CORRECT usage:
# == for value comparison
# is for identity (same object) — mainly use with None
x = None
if x is None: # ✅ Correct way to check None
print("x is None")
Output
True False x is None
Hindi:==values compare karta hai,ismemory location check karta hai (dono same object hain ya nahi).Nonecheck karne ke liye hameshais Noneuse karo,== Nonenahi.
❌ Mistake 6: Forgetting self in Class Methods
python example
# ❌ WRONG — self bhool gaye
class Calculator:
def add(a, b): # self missing!
return a + b
# calc = Calculator()
# calc.add(2, 3) # TypeError: add() takes 2 args but 3 were given
# ✅ CORRECT — self always first parameter
class Calculator:
def add(self, a, b):
return a + b
calc = Calculator()
print(calc.add(2, 3))Output
5
Hindi: Class ke instance methods mein self pehla parameter hona zaroori hai. Python automatically current object pass karta hai, isliye agar self miss karo toh argument count mismatch hoga.❌ Mistake 7: Not Using Context Managers for File Operations
python example
# ❌ WRONG — file close karna bhool sakte ho
f = open("data.txt", "w")
f.write("Hello")
# Agar yahan error aaye toh file close nahi hogi!
f.close()
# ✅ CORRECT — with statement use karo (auto-close)
with open("data.txt", "w") as f:
f.write("Hello")
# File automatically closed — even if error occurs! ✅Hindi: with statement (context manager) use karo file operations ke liye. Ye automatically file close kar deta hai chahe error aaye ya na aaye. Memory leaks aur data loss se bachata hai.✅ Key Takeaways
Is chapter se aapko ye important points yaad rakhne chahiye: 📝
- 🐍 Python ka syntax English jaisa hai — beginners ke liye perfect starting language hai, aur professionals ke liye bhi powerful enough hai
- 📐 Indentation mandatory hai — ye sirf style nahi, ye Python ka grammar hai. Clean code likhna majboori hai, choice nahi
- 🔄 Dynamic typing = flexibility — variables ka type runtime pe decide hota hai, lekin Python strongly typed bhi hai (implicit conversion nahi hoti)
- 🏗️ Multi-paradigm support — OOP, Functional, Procedural — teeno styles ek hi language mein use kar sakte ho. Project ke according choose karo
- ⚡ Generators memory bachate hain — large datasets ke saath kaam karte waqt
yielduse karo, poora data memory mein load mat karo - 🎭 Decorators = superpower — bina function ka code change kiye uski functionality enhance kar sakte ho (logging, caching, auth)
- 🦆 Duck typing = behavior matters — Python mein object ka type nahi, uska behavior check hota hai. "If it quacks like a duck..."
- 📚 Standard Library = batteries included — 200+ built-in modules hain, har cheez ke liye third-party package install karne ki zaroorat nahi
- 🌍 Cross-platform portability — ek baar likho, kahin bhi chalao (Windows, Mac, Linux, Cloud, Raspberry Pi)
- 🧹 Garbage Collection automatic hai — memory management ki tension nahi, Python khud handle karta hai reference counting + cyclic GC se
❓ FAQ
Q1: Python slow hai toh industry mein itna popular kyun hai? 🤔
Answer: Haan, Python raw execution speed mein C/C++ se slow hai. Lekin popularity ke reasons hain: (1) Developer productivity — Python mein 10 lines ka code Java mein 50 lines lagta hai, (2) Critical parts C mein likhe hain — NumPy, Pandas internally C use karte hain, (3) Time is money — fast development > fast execution for most applications, (4) AI/ML ecosystem — TensorFlow, PyTorch sabse pehle Python support karte hain.
Q2: Kya Python mein real private variables hain? 🔒
Answer: Nahi, Python mein TRUE private variables nahi hain (unlike Java/C++). _variable convention hai (protected), __variable name mangling karta hai (pseudo-private), lekin technically access ho sakta hai. Python ki philosophy hai: "We are all consenting adults here" — trust developers to follow conventions.
Q3: Type hints daalein toh Python slow ho jaata hai kya? ⚡
Answer: Bilkul nahi! Type hints sirf documentation aur tooling ke liye hain. Python runtime pe type hints ko completely IGNORE karta hai — koi performance impact nahi hota. Ye sirf editors (VS Code, PyCharm) aur type checkers (mypy, pyright) ke liye useful hain.
Q4: Generator aur Iterator mein kya difference hai? 🔄
Answer: Iterator ek protocol hai — koi bhi object jo __iter__() aur __next__() implement kare wo iterator hai. Generator iterator banane ka easy tarika hai — yield keyword use karke. Har generator ek iterator hai, lekin har iterator generator nahi hota. Generator functions automatically iterator protocol implement karti hain.
Q5: Python 2 aur Python 3 mein kya major differences hain? 🆚
Answer: Python 2 officially dead hai (2020 se EOL). Major differences: (1) print function vs statement, (2) Integer division: 3/2 = 1 (Py2) vs 1.5 (Py3), (3) Unicode by default in Py3, (4) range() returns iterator in Py3, (5) Type hints only in Py3. Always use Python 3.10+ for new projects.
Q6: Kya Python mein multi-threading properly kaam karti hai? 🧵
Answer: GIL (Global Interpreter Lock) ki wajah se CPU-bound tasks mein multi-threading effective nahi hai — ek time pe sirf ek thread Python bytecode execute karta hai. Solutions: (1) multiprocessing module use karo CPU-bound ke liye, (2) asyncio use karo I/O-bound ke liye, (3) Python 3.13+ mein experimental free-threading (no-GIL) mode available hai.
Q7: List comprehension aur map()/filter() mein kaunsa better hai? 📋
Answer: List comprehension zyada Pythonic aur readable hai — community mein preferred hai. map()/filter() functional programming style hai. Performance almost same hai. Rule of thumb: Agar logic simple hai toh list comprehension use karo, agar already ek function defined hai toh map() use kar sakte ho.
Q8: Python seekhne ke baad kaunsi field mein jaayein? 🎯
Answer: Python se multiple career paths open hote hain: (1) Web Development — Django, FastAPI, Flask, (2) Data Science/ML — Pandas, Scikit-learn, TensorFlow, (3) Automation/DevOps — scripting, Ansible, AWS Lambda, (4) Backend Engineering — APIs, microservices, (5) Cybersecurity — penetration testing tools. Apni interest ke according choose karo!
🎯 Interview Questions (Extended)
Pehle ke 5 questions ke alawa, ye additional important interview questions hain:
Q6. What are Python's key differences from Java and C++?
Python is interpreted (no compilation step), dynamically typed (no type declarations), uses indentation for blocks (no curly braces), has automatic memory management (no manual malloc/free), and supports multiple paradigms natively. Python trades raw speed for developer productivity — 3-5x fewer lines of code for equivalent programs.
Q7. Explain the difference between deepcopy and shallow copy in Python.
Shallow copy (copy.copy()orlist.copy()) creates a new object but references the same nested objects. Deep copy (copy.deepcopy()) recursively copies all nested objects too. Example: if you shallow copy a list of lists, modifying an inner list affects both copies. Deep copy creates completely independent objects.
Q8. What are context managers and how do you create a custom one?
Context managers handle setup/teardown viawithstatement. Create custom ones using: (1) A class with__enter__and__exit__methods, or (2)@contextlib.contextmanagerdecorator with a generator function containingyield. They ensure cleanup happens even if exceptions occur — used for files, database connections, locks, and temporary state changes.
Q9. What is the difference between @staticmethod and @classmethod?
@staticmethoddoesn't receive any implicit first argument — it's just a regular function that lives inside a class (no access toclsorself).@classmethodreceives the class itself as first argument (cls) — it can access/modify class state and is commonly used as an alternative constructor (factory method pattern).
Q10. How does Python's garbage collection work internally?
Python uses a two-pronged approach: (1) Reference counting — every object has a count of references pointing to it; when count reaches zero, memory is freed immediately. (2) Generational garbage collector — handles circular references that reference counting can't detect. Objects are grouped into 3 generations (0, 1, 2); newer objects are collected more frequently. You can control it via the gc module.Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Python Features - Complete Guide 2026.
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, introduction, features, python features - complete guide 2026
Related Python Master Course Topics
Continue learning this concept
IntroductionHistory of Python - Complete Guide 2026Python ka itihas jaano — Python ki history, Guido van Rossum ki kahani, Python 1.0 se Python 3.12 tak ka safar. Complete timeline with milestones, versions, and evolution of Python programming language.IntroductionPython Applications - Complete Guide 2026Python ke applications kya hain? Explore all real-world applications of Python — web development, data science, AI/ML, automation, cybersecurity, finance, gaming, and more. Complete guide with code examples in Hindi.IntroductionWhat is Python? - Complete Guide 2026Python kya hai? Learn what Python programming language is, its definition, working, and importance. Complete beginner guide with Hindi explanations, examples, and real-world use cases.IntroductionWhy Learn Python? - Complete Guide 2026Python kyun seekhein? Discover why Python is the best language to learn in 2026 — career opportunities, high salary, AI/ML dominance, job market demand, and beginner advantages. Hindi mein samjhein.Data ScienceNumPy IntroductionLearn NumPy, the foundational Python library for numerical computing. Master arrays, array operations, broadcasting, indexing, reshaping, linear algebra, and random number generation with practical examples.Data SciencePandas IntroductionLearn Pandas, the powerful Python data manipulation library. Master DataFrames, Series, data loading, selection, filtering, groupby, merging, and essential data operations for data analysis.