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 PDF automation with Python using PyPDF2, reportlab, pdfplumber for reading, writing, merging, splitting PDFs, extracting text/tables, and generating PDF reports.
Introduction
You can read, write, merge, split, and generate PDFs using Python. Three main libraries are used:
- PyPDF2 — read, merge, split, rotate, encrypt
- pdfplumber — accurate text aur table extraction
- reportlab — professional PDF generation
bash example
pip install pypdf2 pdfplumber reportlab pillow2. Merging and Splitting PDFs
Example
import PyPDF2
def merge_pdfs(input_files, output_file):
"""Merge multiple PDFs into one"""
merger = PyPDF2.PdfMerger()
for pdf_path in input_files:
print(f"Adding: {pdf_path}")
merger.append(pdf_path)
with open(output_file, "wb") as output:
merger.write(output)
print(f"Merged {len(input_files)} PDFs -> {output_file}")
merger.close()
def merge_pdfs_with_bookmarks(pdf_files, output_file):
"""Merge with bookmarks"""
merger = PyPDF2.PdfMerger()
for i, (pdf_path, title) in enumerate(pdf_files):
merger.append(pdf_path, outline_item=title) # Bookmark add
with open(output_file, "wb") as f:
merger.write(f)
def split_pdf(input_file, output_dir, pages_per_chunk=5):
"""Split PDF into multiple parts"""
with open(input_file, "rb") as f:
reader = PyPDF2.PdfReader(f)
total_pages = len(reader.pages)
chunk_num = 1
for start in range(0, total_pages, pages_per_chunk):
end = min(start + pages_per_chunk, total_pages)
writer = PyPDF2.PdfWriter()
for page_num in range(start, end):
writer.add_page(reader.pages[page_num])
output_path = f"{output_dir}/chunk_{chunk_num:03d}_pages_{start+1}-{end}.pdf"
with open(output_path, "wb") as out_f:
writer.write(out_f)
print(f"Created: {output_path}")
chunk_num += 1
def extract_specific_pages(input_file, page_ranges, output_file):
"""Specific page ranges extract karo"""
with open(input_file, "rb") as f:
reader = PyPDF2.PdfReader(f)
writer = PyPDF2.PdfWriter()
for start, end in page_ranges:
for page_num in range(start - 1, min(end, len(reader.pages))):
writer.add_page(reader.pages[page_num])
with open(output_file, "wb") as out_f:
writer.write(out_f)
print(f"Extracted pages to {output_file}")
# Demo
import os, tempfile
# Create sample PDFs for demo
def create_sample_pdf(filepath, text):
"""Simple sample PDF create karo using reportlab"""
from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas
c = canvas.Canvas(filepath, pagesize=A4)
c.drawString(100, 750, text)
c.save()
with tempfile.TemporaryDirectory() as tmpdir:
pdf1 = os.path.join(tmpdir, "part1.pdf")
pdf2 = os.path.join(tmpdir, "part2.pdf")
merged = os.path.join(tmpdir, "merged.pdf")
create_sample_pdf(pdf1, "PDF Part 1 — WoHoTech Python Course")
create_sample_pdf(pdf2, "PDF Part 2 — Advanced Topics")
merge_pdfs([pdf1, pdf2], merged)
with open(merged, "rb") as f:
reader = PyPDF2.PdfReader(f)
print(f"Merged PDF pages: {len(reader.pages)}")
Output
Adding: /tmp/.../part1.pdf Adding: /tmp/.../part2.pdf Merged 2 PDFs -> /tmp/.../merged.pdf Merged PDF pages: 2
3. Rotation, Watermark, Encryption
Example
import PyPDF2
def rotate_pages(input_file, output_file, rotation=90, page_numbers=None):
"""Pages rotate karo"""
with open(input_file, "rb") as f:
reader = PyPDF2.PdfReader(f)
writer = PyPDF2.PdfWriter()
for i, page in enumerate(reader.pages):
if page_numbers is None or (i + 1) in page_numbers:
page.rotate(rotation) # 90, 180, 270
writer.add_page(page)
with open(output_file, "wb") as out_f:
writer.write(out_f)
def add_watermark(input_file, watermark_file, output_file):
"""PDF pe watermark add karo"""
with open(input_file, "rb") as f_in, open(watermark_file, "rb") as f_wm:
reader = PyPDF2.PdfReader(f_in)
watermark_reader = PyPDF2.PdfReader(f_wm)
watermark_page = watermark_reader.pages[0]
writer = PyPDF2.PdfWriter()
for page in reader.pages:
page.merge_page(watermark_page) # Watermark merge karo
writer.add_page(page)
with open(output_file, "wb") as f_out:
writer.write(f_out)
print(f"Watermarked PDF saved to {output_file}")
def encrypt_pdf(input_file, output_file, user_password, owner_password=None):
"""Password protect a PDF"""
with open(input_file, "rb") as f:
reader = PyPDF2.PdfReader(f)
writer = PyPDF2.PdfWriter()
for page in reader.pages:
writer.add_page(page)
# Encrypt with password
writer.encrypt(
user_password=user_password,
owner_password=owner_password or user_password,
use_128bit=True
)
with open(output_file, "wb") as f_out:
writer.write(f_out)
print(f"Encrypted PDF saved to {output_file}")
def decrypt_pdf(input_file, output_file, password):
"""Password protected PDF open karo"""
with open(input_file, "rb") as f:
reader = PyPDF2.PdfReader(f)
if reader.is_encrypted:
result = reader.decrypt(password)
if result == 0:
raise ValueError("Wrong password!")
print(f"Decrypted successfully!")
writer = PyPDF2.PdfWriter()
for page in reader.pages:
writer.add_page(page)
with open(output_file, "wb") as f_out:
writer.write(f_out)
Output
Watermarked PDF saved to output_watermarked.pdf Encrypted PDF saved to output_encrypted.pdf Decrypted successfully!
4. pdfplumber — Accurate Text Extraction
Example
import pdfplumber
import json
def extract_text_with_pdfplumber(filepath):
"""pdfplumber se accurate text extraction"""
results = []
with pdfplumber.open(filepath) as pdf:
print(f"Total pages: {len(pdf.pages)}")
print(f"Metadata: {pdf.metadata}")
for page_num, page in enumerate(pdf.pages):
# Full page text
text = page.extract_text()
# Specific region se text (crop)
# top_region = page.crop((0, 0, page.width, page.height * 0.3))
# top_text = top_region.extract_text()
results.append({
"page": page_num + 1,
"text": text,
"width": page.width,
"height": page.height,
})
return results
def extract_tables_from_pdf(filepath):
"""PDF tables extract karo"""
all_tables = []
with pdfplumber.open(filepath) as pdf:
for page_num, page in enumerate(pdf.pages):
tables = page.extract_tables()
for table_num, table in enumerate(tables):
if not table:
continue
# Convert to list of dicts
headers = table[0] # First row = headers
rows = table[1:] # Remaining rows = data
table_data = [
dict(zip(headers, row))
for row in rows
if any(cell for cell in row) # Skip empty rows
]
all_tables.append({
"page": page_num + 1,
"table_num": table_num + 1,
"headers": headers,
"rows": table_data,
"row_count": len(table_data),
})
print(f"Page {page_num+1}, Table {table_num+1}: {len(table_data)} rows")
return all_tables
# Advanced: Extract text from specific area
def extract_from_region(filepath, page_num, x0, y0, x1, y1):
"""Extract text from a specific region of PDF"""
with pdfplumber.open(filepath) as pdf:
page = pdf.pages[page_num - 1]
# Crop to bounding box
region = page.crop((x0, y0, x1, y1))
text = region.extract_text()
return text
Output
Total pages: 3
Metadata: {'Title': 'Invoice Report', 'Author': 'WoHoTech'}
Page 1, Table 1: 5 rows
Page 2, Table 1: 8 rows
Page 2, Table 2: 3 rows📝 Hindi Explanation
pdfplumber provides more accurate text extraction than PyPDF2, especially for tables. extract_tables() automatically detects table structure and returns data as a list of lists.5. ReportLab — Generate Professional PDFs
Example
from reportlab.lib.pagesizes import A4, letter
from reportlab.lib.units import inch, cm
from reportlab.lib.colors import HexColor, black, white, blue
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image
from reportlab.platypus import HRFlowable, PageBreak
from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_RIGHT
def generate_student_report(output_path, student_data):
"""Professional student report card generate karo"""
doc = SimpleDocTemplate(
output_path,
pagesize=A4,
rightMargin=2*cm,
leftMargin=2*cm,
topMargin=2*cm,
bottomMargin=2*cm,
)
styles = getSampleStyleSheet()
# Custom styles
title_style = ParagraphStyle(
"CustomTitle",
parent=styles["Heading1"],
fontSize=24,
textColor=HexColor("#667eea"),
spaceAfter=12,
alignment=TA_CENTER,
)
heading_style = ParagraphStyle(
"CustomHeading",
parent=styles["Heading2"],
fontSize=14,
textColor=HexColor("#333333"),
spaceBefore=12,
spaceAfter=6,
)
body_style = ParagraphStyle(
"CustomBody",
parent=styles["Normal"],
fontSize=11,
spaceAfter=8,
leading=16,
)
# Build content
story = []
# Header
story.append(Paragraph("WoHoTech Python Master Course", title_style))
story.append(Paragraph("Student Report Card", styles["Heading2"]))
story.append(HRFlowable(width="100%", thickness=2, color=HexColor("#667eea")))
story.append(Spacer(1, 12))
# Student Info
story.append(Paragraph("Student Information", heading_style))
info_data = [
["Name:", student_data["name"]],
["Email:", student_data["email"]],
["Course:", student_data["course"]],
["Date:", student_data["date"]],
]
info_table = Table(info_data, colWidths=[4*cm, 12*cm])
info_table.setStyle(TableStyle([
('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
('FONTSIZE', (0, 0), (-1, -1), 11),
('TOPPADDING', (0, 0), (-1, -1), 4),
('BOTTOMPADDING', (0, 0), (-1, -1), 4),
]))
story.append(info_table)
story.append(Spacer(1, 20))
# Scores Table
story.append(Paragraph("Subject Scores", heading_style))
score_headers = ["Subject", "Score", "Grade", "Remarks"]
score_data = [score_headers] + [
[s["subject"], f"{s['score']}%", s["grade"], s["remarks"]]
for s in student_data["subjects"]
]
score_table = Table(score_data, colWidths=[7*cm, 3*cm, 3*cm, 4*cm])
score_table.setStyle(TableStyle([
# Header row
('BACKGROUND', (0, 0), (-1, 0), HexColor("#667eea")),
('TEXTCOLOR', (0, 0), (-1, 0), white),
('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
('FONTSIZE', (0, 0), (-1, 0), 12),
('ALIGN', (0, 0), (-1, 0), 'CENTER'),
# Data rows
('FONTSIZE', (0, 1), (-1, -1), 10),
('ROWBACKGROUNDS', (0, 1), (-1, -1), [HexColor("#f8f9fa"), white]),
('ALIGN', (1, 1), (2, -1), 'CENTER'),
# Grid
('GRID', (0, 0), (-1, -1), 0.5, HexColor("#dee2e6")),
('BOX', (0, 0), (-1, -1), 1, HexColor("#667eea")),
# Padding
('TOPPADDING', (0, 0), (-1, -1), 8),
('BOTTOMPADDING', (0, 0), (-1, -1), 8),
('LEFTPADDING', (0, 0), (-1, -1), 8),
]))
story.append(score_table)
story.append(Spacer(1, 20))
# Overall result
overall = student_data.get("overall", {})
story.append(Paragraph(
f"<b>Overall Score:</b> {overall.get('score', 'N/A')}% | "
f"<b>Grade:</b> {overall.get('grade', 'N/A')} | "
f"<b>Rank:</b> {overall.get('rank', 'N/A')}",
body_style
))
doc.build(story)
print(f"Report generated: {output_path}")
# Test data
student = {
"name": "Alice Johnson",
"email": "alice@example.com",
"course": "Python Master Course",
"date": "June 12, 2026",
"subjects": [
{"subject": "Python Basics", "score": 95, "grade": "A", "remarks": "Excellent"},
{"subject": "Advanced Python", "score": 88, "grade": "A", "remarks": "Very Good"},
{"subject": "Databases", "score": 82, "grade": "B", "remarks": "Good"},
{"subject": "Automation", "score": 91, "grade": "A", "remarks": "Excellent"},
],
"overall": {"score": 89, "grade": "A", "rank": 3},
}
import tempfile, os
with tempfile.TemporaryDirectory() as tmpdir:
report_path = os.path.join(tmpdir, "student_report.pdf")
generate_student_report(report_path, student)
print(f"Report size: {os.path.getsize(report_path)} bytes")
Output
Report generated: /tmp/.../student_report.pdf Report size: 4523 bytes
6. Advanced ReportLab — Charts and Images
Example
from reportlab.graphics.shapes import Drawing
from reportlab.graphics.charts.barcharts import VerticalBarChart
from reportlab.graphics.charts.piecharts import Pie
from reportlab.lib.colors import HexColor
def create_bar_chart(data, labels, title, width=400, height=200):
"""Bar chart create karo"""
drawing = Drawing(width, height)
chart = VerticalBarChart()
chart.x = 50
chart.y = 50
chart.height = height - 75
chart.width = width - 75
chart.data = [data]
chart.categoryAxis.categoryNames = labels
chart.categoryAxis.labels.angle = 30
chart.valueAxis.valueMin = 0
chart.valueAxis.valueMax = 100
# Bar colors
chart.bars[0].fillColor = HexColor("#667eea")
drawing.add(chart)
return drawing
def create_pie_chart(data, labels, title, width=200, height=200):
"""Pie chart create karo"""
drawing = Drawing(width, height)
pie = Pie()
pie.x = width // 4
pie.y = 30
pie.width = width // 2
pie.height = height - 60
pie.data = data
pie.labels = [f"{l}\n{v}" for l, v in zip(labels, data)]
colors = [HexColor("#667eea"), HexColor("#764ba2"), HexColor("#f093fb"), HexColor("#f5576c")]
for i, color in enumerate(colors[:len(data)]):
pie.slices[i].fillColor = color
drawing.add(pie)
return drawing
# Add to PDF
from reportlab.platypus import SimpleDocTemplate, Spacer
def create_analytics_report(output_path):
doc = SimpleDocTemplate(output_path)
story = []
scores = [95, 88, 82, 91]
subjects = ["Python", "Advanced", "DB", "Automation"]
bar = create_bar_chart(scores, subjects, "Subject Scores")
pie = create_pie_chart(scores, subjects, "Score Distribution")
story.append(bar)
story.append(Spacer(1, 20))
story.append(pie)
doc.build(story)
Output
Bar chart created: Subject Scores Pie chart created: Score Distribution Analytics report saved to analytics_report.pdf
7. Best Practices
python example
import PyPDF2
from pathlib import Path
# ✅ Always use context managers
with open("file.pdf", "rb") as f:
reader = PyPDF2.PdfReader(f)
# ✅ Handle encrypted PDFs
with open("protected.pdf", "rb") as f:
reader = PyPDF2.PdfReader(f)
if reader.is_encrypted:
reader.decrypt("password")
# ✅ Check file existence
def safe_read_pdf(filepath):
if not Path(filepath).exists():
raise FileNotFoundError(f"PDF not found: {filepath}")
if Path(filepath).suffix.lower() != ".pdf":
raise ValueError("Not a PDF file!")
with open(filepath, "rb") as f:
return PyPDF2.PdfReader(f)
# ✅ pdfplumber for text extraction (better than PyPDF2)
import pdfplumber
with pdfplumber.open("document.pdf") as pdf:
text = "\n".join(page.extract_text() or "" for page in pdf.pages)
# ✅ ReportLab for generating (don't edit existing PDFs)| Library | Best For |
|---|---|
PyPDF2 | Merge, split, rotate, encrypt |
pdfplumber | Text/table extraction |
reportlab | Generate new PDFs |
pdf2image | PDF to images |
fpdf2 | Simple PDF generation |
Pro Tip: PyPDF2 and pdfplumber are for text extraction — PyPDF2 is fast, pdfplumber is more accurate. For complex tables, ALWAYS use pdfplumber!
⚠️ Common Mistakes
❌ Mistake 1: Opening a file in text mode
python example
# ❌ Wrong — PDF binary file hai, "r" mode se error aayega
with open("file.pdf", "r") as f:
reader = PyPDF2.PdfReader(f)
# ✅ Correct — Always use "rb" (read binary)
with open("file.pdf", "rb") as f:
reader = PyPDF2.PdfReader(f)PDF is a binary format; using"r"mode will give youUnicodeDecodeErroror corrupted data. Always use"rb"! 🔑
❌ Mistake 2: Reading an encrypted PDF without decrypting
Example
# ❌ Wrong — encrypted PDF pe directly pages access karna
reader = PyPDF2.PdfReader(open("protected.pdf", "rb"))
text = reader.pages[0].extract_text() # Error!
# ✅ Correct — decrypt first
reader = PyPDF2.PdfReader(open("protected.pdf", "rb"))
if reader.is_encrypted:
reader.decrypt("password")
text = reader.pages[0].extract_text()
You must calldecrypt()before performing any operation on an encrypted PDF, otherwise you'll getPdfReadError. 🔐
❌ Mistake 3: Not handling None return from extract_text()
python example
# ❌ Wrong — None pe string operations crash karengi
text = page.extract_text()
words = text.split() # TypeError if text is None!
# ✅ Correct — None check karo
text = page.extract_text() or ""
words = text.split()Some pages contain only images, no text —extract_text()will returnNone. Always provide a fallback! ⚡
❌ Mistake 4: Loading a large PDF entirely into memory without streaming
python example
# ❌ Wrong — puri PDF memory mein load for huge files
all_text = ""
for page in reader.pages:
all_text += page.extract_text() or "" # Memory blast! 💥
# ✅ Correct — page by page process karo
for page_num, page in enumerate(reader.pages):
text = page.extract_text() or ""
process_page(text) # Ek page process, fir nextStoring all content from a 1000+ page PDF in one string will cause memory overflow. Use page-by-page processing! 💾
❌ Mistake 5: Not closing the file in ReportLab
python example
# ❌ Wrong — canvas.save() bhoolna
from reportlab.pdfgen import canvas
c = canvas.Canvas("output.pdf")
c.drawString(100, 750, "Hello")
# File is incomplete without save()!
# ✅ Correct — always call save()
c = canvas.Canvas("output.pdf")
c.drawString(100, 750, "Hello")
c.save() # File finalize hota haiWithout canvas.save(), the PDF will remain corrupt. This properly closes and finalizes the file! 📄❌ Mistake 6: Extracting complex tables with PyPDF2
Example
# ❌ Wrong — PyPDF2 does not preserve table structure
text = reader.pages[0].extract_text()
# Table data sab mixed up aata hai
# ✅ Correct — pdfplumber use karo for tables
import pdfplumber
with pdfplumber.open("file.pdf") as pdf:
tables = pdf.pages[0].extract_tables() # Proper table structure!
PyPDF2 only gives raw text; table layout is lost. For tables, usepdfplumberorcamelot! 📊
❌ Mistake 7: PdfMerger close na karna
python example
# ❌ Wrong — merger.close() bhoolna
merger = PyPDF2.PdfMerger()
merger.append("file1.pdf")
merger.append("file2.pdf")
merger.write(open("output.pdf", "wb"))
# File handles leak ho jayenge!
# ✅ Correct — proper close karo
merger = PyPDF2.PdfMerger()
merger.append("file1.pdf")
merger.append("file2.pdf")
with open("output.pdf", "wb") as f:
merger.write(f)
merger.close() # Resources free!PdfMergerinternally keeps file handles open. Not callingclose()causes file locks and memory leaks! 🚫
✅ Key Takeaways
- 📌 PyPDF2 is best for PDF merge, split, rotate, and encrypt — limited in text extraction
- 📌 pdfplumber is the gold standard for accurate text and table extraction — especially for invoices and reports
- 📌 reportlab lets you generate professional PDFs with charts, tables, images, and custom styles
- 📌 Always open PDF files in binary mode (
"rb") — they are not text files - 📌 Always call
decrypt()before working with encrypted PDFs - 📌
extract_text()can returnNone— always use anor ""fallback - 📌 For large PDFs, use page-by-page processing — don't load the entire file into memory at once
- 📌 In ReportLab, calling
canvas.save()ordoc.build(story)is required — without it the PDF will be corrupt - 📌 Avoid PyPDF2 for table extraction — use
pdfplumberorcamelotinstead - 📌 Error handling is important in PDF automation — handle file not found, wrong password, and corrupted PDF scenarios
❓ FAQ
Q1: What is the difference between PyPDF2 and pdfplumber? 🤔
Answer: PyPDF2 is mainly for PDF manipulation (merge, split, rotate, encrypt). It can extract text but with limited accuracy. pdfplumber specializes in accurate text and table extraction — it understands page layout and coordinates.
Q2: Can you edit an existing PDF with Python? ✏️
Answer: Not directly — PDF format is not designed for editing. However, workarounds exist: (1) Extract text, modify it, generate a new PDF, (2) Use PyPDF2 to add watermarks/overlays, (3) Use pdf2docx to convert, edit in Word format, then convert back.
Q3: How do you extract images from a PDF? 🖼️
Answer: Use the pdf2image library which converts pages to images. After pip install pdf2image, use convert_from_path("file.pdf") to get PIL Image objects. For embedded images specifically, use fitz (PyMuPDF) library.
Q4: How do you add Hindi/Unicode text in ReportLab? 🇮🇳
Answer: For Unicode support in ReportLab, register a TTF font: pdfmetrics.registerFont(TTFont('Hindi', 'path/to/font.ttf')) and then use that font name in your styles/canvas.
Q5: How do you efficiently process a very large PDF (1000+ pages)? ⚡
Answer: Iterate page-by-page; don't keep everything in memory. Use a generator pattern. pdfplumber already uses lazy loading. If you only need specific pages, pass page numbers directly to avoid processing the entire document.
Q6: What are the best practices for PDF generation? 📋
Answer: (1) Use SimpleDocTemplate for complex layouts with Platypus flowables, (2) Define custom ParagraphStyle for reusability, (3) Use page margins and headers/footers for professional output, (4) Always test with various PDF viewers.
Q7: How do you extract text from scanned PDFs? 📸
Answer: Scanned PDFs contain text as images, so normal extraction won't work. You need OCR: use the pytesseract + pdf2image combination. Convert each page to an image, then apply OCR. For better accuracy, preprocess images (denoise, deskew).
Q8: How do you automate multiple PDF operations? 🤖
Answer: Use pathlib or glob in a Python script to iterate over all PDFs in a folder and apply operations (rename, merge, extract). Use the watchdog library to automatically trigger processing when new PDFs appear in a folder.
🎯 Interview Questions
Q1: What is the fundamental difference between PyPDF2, pdfplumber, and reportlab?
Answer: These three libraries serve different purposes: PyPDF2 is a PDF manipulation library — merge, split, rotate, encrypt/decrypt, read metadata. pdfplumber specializes in extraction — accurate text and table extraction with coordinate awareness. reportlab is for creation — generate new PDFs with charts, tables, custom layouts from scratch.
Q2: How does text extraction from PDFs work internally?
Answer: PDF internally stores text in "content streams" with positioning operators (Tm, Td, etc.). The extraction process: (1) Parse PDF structure, (2) Read content streams, (3) Map character codes to Unicode via CMap/Encoding, (4) Use positioning info to reconstruct text flow. That's why extraction isn't always perfect.
Q3: How do you manage memory when processing large PDF files?
Answer: Strategies: (1) Lazy iteration — PdfReader.pages is a list, but page content loads only when accessed, (2) Generator pattern — yield one page at a time to keep memory constant, (3) Process in chunks — split large PDFs first, process chunks independently.
Q4: PDF encryption levels explain karo — user password vs owner password?
Answer: PDF has two levels of encryption: User password — required to open the PDF; without it the PDF won't display. Owner password — restricts operations (print, copy, edit); the PDF opens but with limitations. Python can handle both via decrypt(password).
Q5: How does pdfplumber detect tables?
Answer: pdfplumber's table detection is a multi-step process: (1) Line detection — find horizontal and vertical lines on the page (explicit drawn lines), (2) Edge inference — where lines aren't drawn, infer edges from text alignment, (3) Cell identification — intersections of lines form cells, (4) Content extraction — text within each cell boundary.
Q6: What is the Platypus framework in ReportLab and when should you use it?
Answer: Platypus (Page Layout and Typography Using Scripts) is reportlab's high-level framework. It uses "flowable" objects — Paragraph, Table, Image, Spacer — that automatically flow across pages. Use it for multi-page documents; use Canvas for single-page or precise positioning needs.
Q7: What are the best practices for error handling in PDF automation?
Answer: Handle critical errors: (1) FileNotFoundError — check if file exists before opening, (2) PdfReadError — corrupted PDF, wrap in try-except, (3) PermissionError — file locked by another process, (4) Password errors — wrong decryption password. Always provide meaningful error messages and fallbacks.
Q8: Design a batch PDF processing system — you need to extract data from 1000 invoices.
Answer: Architecture: (1) Input — receive PDF paths from folder watch or queue, (2) Validation — check file exists, is PDF, not corrupted, size check, (3) Extraction — pdfplumber for tables, targeted area cropping for specific fields, (4) Parsing — regex/rules to structure raw text, (5) Storage — database insert with error logging, (6) Reporting — success/failure stats, problematic files flagged for manual review.
Q9: Explain the workflow of extracting structured data from PDFs and storing it in a database.
Answer: Step-by-step: (1) Open PDF with pdfplumber, (2) Use page.crop() to target relevant areas — header, line items, totals, (3) Use extract_text() for simple fields and extract_tables() for tabular data, (4) Parse and validate with regex/rules, (5) Map to database schema, (6) Insert with error handling and transaction management.
Q10: What are the limitations of Python PDF libraries and what are the alternatives?
Answer: Limitations: (1) PyPDF2 — wrong text order in complex layouts, no scanned PDF support, (2) pdfplumber — slow on very large files, no image extraction, (3) reportlab — steep learning curve, no PDF editing. Alternatives: Apache PDFBox (Java, very robust), MuPDF/PyMuPDF (fast, feature-rich), pdf2docx (editing workflow), Adobe PDF Services API (cloud-based, most accurate).
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for PDF Automation with Python.
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, automation, pdf, pdf automation with python
Related Python Master Course Topics
Continue learning this concept
AutomationEmail Automation with PythonComplete guide to email automation with Python using smtplib, email library, sending HTML emails, attachments, reading emails with IMAP, and scheduling email automation.AutomationSelenium Web Automation with PythonMaster Selenium WebDriver with Python for browser automation, form filling, clicking, screenshots, handling dynamic content, waits, and headless browsing with Hindi explanations.AutomationTask Scheduler with PythonComplete guide to task scheduling in Python using schedule library, APScheduler, cron jobs, threading timers, and building automated workflows with Hindi explanations.AutomationWeb Scraping with PythonComplete guide to web scraping with Python using requests, BeautifulSoup4, lxml, handling pagination, scraping APIs, and best practices with Hindi explanations.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.