PDFs को स्क्रैप करना पाइथन के साथ: लिंक खोज से लेकर निकाली गई तालिकाओं तक

TL;DR:

• एक PDF को स्क्रैपिंग के लिए HTML पृष्ठ पर शुरू करना है जो इसे लिंक करता है। एक लाइव इंडेक्स पृष्ठ ने किसी भी पार्सिंग से पहले चार दस्तावेज़ URL प्रदान किए, और यह खोज चरण वह हिस्सा है जिसे अधिकांश मार्गदर्शिकाएँ छोड़ देती हैं।
• एक PDF को बाइट्स के रूप में आना होता है। एक पाठ-प्रतिदान करने वाले अंतिम बिंदु के माध्यम से एक ही दस्तावेज़ को रूट करने पर 235,403 बाइट्स उत्पन्न हुए जबकि वास्तविक फ़ाइल 140,815 बाइट्स की थी, और न तो pypdf और न ही pdfplumber परिणाम से कोई पृष्ठ पढ़ सके।
• किसी फ़ाइल को खोलना उसे पढ़ना नहीं है। उन भ्रष्ट बाइट्स पर एक रीडर बनाने से कुछ भी नहीं उठा; केवल तब विफलता दिखाई दी जब एक पृष्ठ को छुआ गया।
• pdfplumber आपको पृष्ठ ज्यामिति देती है, pypdf आपको दस्तावेज़ संरचना देती है। एक लाइव पृष्ठ ने 5,659 वर्णों का पाठ, 4 पहचाने गए तालिकाएँ, और 933 निर्धारित शब्द लौटाए।
• हर पहचानी गई तालिका डेटा नहीं है। उन चार तालिकाओं में 1, 7, 2, और 10 कॉलम थे, और इनमें से अधिकांश लेआउट स्कैफोल्डिंग हैं न कि रिकॉर्ड।
• नि:शुल्क शुरू करें। लिंक-खोज फ़ेच यूनिवर्सल स्क्रैपिंग API के मुफ्त स्तर पर चलती है।

सार्वजनिक संस्थाएँ अपने सबसे उपयोगी डेटा को PDF के रूप में प्रकाशित करती हैं। बजट, फाइलिंग, सांख्यिकी, और निरीक्षण परिणाम ऐसे दस्तावेज़ के रूप में आते हैं जो प्रिंटिंग के लिए डिज़ाइन किए गए हैं, और एक स्क्रेपर जो HTML पर रुकता है, उसे इनमें से कोई भी नहीं दिखाई देता।

यह मार्गदर्शिका एक पृष्ठ पर शुरू होती है जो चार PDFs को लिंक करती है, एक को डाउनलोड करती है, और उसमें से टेक्स्ट, तालिकाएँ, और शब्द की स्थितियों को बाहर निकालती है — फिर यह बिल्कुल मापती है कि जब फ़ाइल वहाँ पहुँचने के लिए गलत तरीके से जाती है तो क्या होता है।

PDF क्या है, स्क्रैपिंग उद्देश्यों के लिए

PDF एक बाइनरी कंटेनर है जो बताता है कि चिन्ह कहाँ एक पृष्ठ पर जाएँ। इसमें किसी पैरा, शीर्षक, या तालिका का कोई सिद्धांत नहीं है — केवल समन्वय पर ग्लिफ़, एक पृष्ठ-विवरण मॉडल जो कॉंग्रेस पुस्तकालय के PDF परिवार के लिए प्रारूप विवरण में सूचीबद्ध है। इसका मीडिया प्रकार, जो अनुप्रयोग/pdf मीडिया प्रकार विनिर्देश में पंजीकृत है, बाइनरी है बिल्कुल इसलिए क्योंकि प्रारूप पाठ नहीं है।

यह एक तथ्य नीचे सब कुछ संचालित करता है। "पाठ" निकालना स्थिति से पढ़ने का क्रम फिर से बनाना है, और "तालिका" निकालना नियामक रेखाओं और संरेखण से पंक्तियाँ और कॉलम निकालना है। दो पुस्तकालयों ने काम को विभाजित किया है:

• pypdf दस्तावेज़ संरचना पढ़ता है — पृष्ठ की गणना, मेटाडेटा, एन्क्रिप्शन स्थिति, और पृष्ठ-स्तरीय पाठ।
• pdfplumber पृष्ठ ज्यामिति पढ़ता है — समन्वय के साथ वर्ण, पहचानी गई नियामक रेखाएँ, और उनसे बनी तालिकाएँ।

स्थापित करें

pip install pdfplumber pypdf beautifulsoup4

pdfplumber pdfminer.six को लाता है, जो निम्न-स्तरीय पार्सिंग करता है। यहाँ कुछ भी सिस्टम पैकेज या हेडलेस ब्राउज़र की आवश्यकता नहीं है।

चरण 1: लिंक खोजें

दस्तावेज़ सामान्य पृष्ठों से संदर्भित होते हैं, इसलिए पहला कदम HTML काम है। इंडेक्स पृष्ठ को फ़ेच करें और हर .pdf href को इकट्ठा करें, जो पूर्ण URLs में हल किया गया:

import urllib.parse

from bs4 import BeautifulSoup


def pdf_links(html, base_url):
    soup = BeautifulSoup(html, "html.parser")
    return sorted({
        urllib.parse.urljoin(base_url, a["href"])
        for a in soup.select('a[href$=".pdf"]')
    })

urljoin महत्वपूर्ण है क्योंकि ये hrefs आमतौर पर साइट-संबंधित होते हैं — परीक्षण के तहत पृष्ठ /pub/irs-pdf/fw9.pdf लौटाता है, जिसे अपने आप में फ़ेच नहीं किया जा सकता। set एक दस्तावेज़ को डेडुप्लिकेट करता है जो एक से अधिक बार लिंक किया गया है, जो इंडेक्स पृष्ठ लगातार करता है।

एक लाइव रन पर जिसने चार दस्तावेज़ लौटाए:

https://www.irs.gov/pub/irs-pdf/fw9.pdf
https://www.irs.gov/pub/irs-pdf/iw9.pdf
https://www.irs.gov/pub/irs-pdf/p1281.pdf
https://www.irs.gov/pub/irs-pdf/p5027.pdf

इंडेक्स पृष्ठ स्वयं यूनिवर्सल स्क्रैपिंग API के माध्यम से फ़ेच किया जाता है, जो HTML को एक स्ट्रिंग के रूप में प्रस्तुत करता है — बिल्कुल पृष्ठ के लिए सही, और जिन दस्तावेज़ों को यह लिंक करता है उनके लिए बिल्कुल गलत, जैसा कि अगला चरण दिखाता है।

चरण 2: बाइट्स के रूप में डाउनलोड करें

import urllib.request

BROWSER_UA = ("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
              "(KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36")


def fetch_bytes(url):
    """Fetch a binary file. PDFs must arrive as bytes, never as text."""
    request = urllib.request.Request(url, headers={"User-Agent": BROWSER_UA})
    with urllib.request.urlopen(request, timeout=120) as response:
        return response.read()

response.read() बिना .decode() के पूरी बात है। डाउनलोड की गई फ़ाइल 140,815 बाइट्स थी जो %PDF- हैडर के साथ शुरू होती है, जो हर वैध दस्तावेज़ की शुरुआत के लिए पांच-बाइट का हस्ताक्षर है — एक सस्ता утверждение जो पार्सिंग से पहले बनाना योग्य है।

चरण 3: दस्तावेज़ संरचना पढ़ें

import io

from pypdf import PdfReader

reader = PdfReader(io.BytesIO(raw))
print(len(reader.pages), reader.is_encrypted)

io.BytesIO एक अस्थायी फ़ाइल लिखने से बचता है। लाइव दस्तावेज़ ने 6 पृष्ठ और encrypted=False रिपोर्ट की। एन्क्रिप्शन की जल्दी जांच करना महत्वपूर्ण है: एक एन्क्रिप्टेड दस्तावेज़ ठीक खुलता है और खाली पाठ देता है, जो एक दस्तावेज़ के समान दिखता है जिसमें बस कोई पाठ परत नहीं होती।

चरण 4: पाठ निकालें

import pdfplumber

with pdfplumber.open(io.BytesIO(raw)) as pdf:
    page = pdf.pages[0]
    text = page.extract_text() or ""
    words = page.extract_words()

पृष्ठ एक ने 5,659 वर्ण लौटाए, जो लाइन 'W-9' पर खुलता है, और 933 निर्धारित शब्द।

or "" रक्षात्मक पैडिंग नहीं है। extract_text() तब None लौटाता है जब एक पृष्ठ में कोई पाठ परत नहीं होती — एक स्कैन की गई छवि, आम तौर पर — और वो None अन्यथा कहीं भी इसके कारण से दूर विफल हो जाएगा। इसे एक संकेत के रूप में मानें कि पृष्ठ को एक अलग उपकरण की आवश्यकता है, न कि एक खाली स्ट्रिंग के रूप में।
extract_words() वह है जो pdfplumber को निर्भरता के लिए मूल्यवान बनाता है। प्रत्येक शब्द x0, x1, top, और bottom समन्वय के साथ वापस आता है, इसलिए जब पढ़ने का क्रम एक बहु-स्तंभ लेआउट द्वारा उलझ जाता है, तो आप स्थिति के अनुसार चयन कर सकते हैं बजाय इसके कि पाठ स्ट्रीम समझदारी से हो।

चरण 5: तालिकाओं को निकालना

tables = page.extract_tables()
for index, table in enumerate(tables, 1):
    widest = max(len(row) for row in table)
    print(f"table {index}: {len(table)} rows x {widest} cols")

जीवित पृष्ठ ने चार तालिकाएँ उत्पन्न कीं:

table 1: 4 rows x 1 cols
table 2: 2 rows x 7 cols
table 3: 1 rows x 2 cols
table 4: 2 rows x 10 cols

एक एक-स्तंभ तालिका और एक एक-पंक्ति तालिका डेटा सेट नहीं हैं। ये फ़ॉर्म के लेआउट के वर्गीकृत क्षेत्र हैं जो एक वास्तविक तालिका के रूप में समान नियम-रेखा ह्यूरिस्टिक को संतुष्ट करते हैं। यह वह भाग है जिसे आत्मसात करने की आवश्यकता है: extract_tables() आयताकार संरचनाएँ रिपोर्ट करता है जो उसने पहचान ली हैं, और यह तय करना कि उनमें से कौन रिकॉर्ड ले जाता है, आपका काम है। किसी भी चीज़ पर विश्वास करने से पहले आकार पर फ़िल्टर करें — एक संभावित न्यूनतम है दो पंक्तियाँ और दो स्तंभ, जिसे आपके दस्तावेज़ द्वारा वास्तव में उपयोग किए गए के अनुसार संकीर्ण किया गया है।

शुरूआत के लिए किसी कार्ड की आवश्यकता नहीं है — फ्री प्लान खोज फ़ेच को कवर करता है।

जब एक पीडीएफ़ पाठ के रूप में यात्रा करता है तो क्या होता है

चरण 2 में stated नियम को प्रमाण की आवश्यकता है बजाय इसके कि सिर्फ दावा किया जाए, इसलिए एक ही दस्तावेज़ को दूसरे तरीके से फेच किया गया — अनुक्रमणिका पृष्ठ के लिए उपयोग किए गए पाठ-लौटाने वाले एंडपॉइंट के माध्यम से — और परिणाम को मापा गया:

same pdf through the text endpoint: 235403 bytes (real file is 140815)
  pypdf reads it: failed (PdfReadError)
  pdfplumber reads it: failed (PdfminerException)

फ़ाइल 67% बढ़ गई। मनमाने बाइट्स को पाठ के रूप में डिकोड करना और उन्हें फिर से एनकोड करना ASCII रेंज के बाहर किसी भी चीज़ का विस्तार करता है, जो कई-बाइट अनुक्रमों में बदल जाता है, यह मैकेनिज्म वर्णित किया गया है UTF-8 एनकोडिंग स्पेसिफिकेशन, और वो बाइट्स जो कभी भी मान्य पाठ नहीं थीं उन्हें पूरी तरह से बदल दिया जाता है। परिणाम अभी भी %PDF- से शुरू होता है, यही कारण है कि यह विफलता एक अपराह्न बर्बाद करने के लिए पर्याप्त विश्वसनीय है।

एक विवरण बाइट गिनती से अधिक महत्वपूर्ण है। उस डेटा पर एक PdfReader बनाना कुछ भी नहीं उठाता है — वस्तु बनाई जाती है, और केवल reader.pages को छूना विफल होता है। एक जांच जो "क्या यह खुला" पर रुकती है एक फ़ाइल पर सफलता की रिपोर्ट करती है जिसे पढ़ा नहीं जा सकता, इसलिए एक पृष्ठ पढ़कर सत्यापित करें:

def page_count(data):
    return len(PdfReader(io.BytesIO(data)).pages)

HTML के लिए एक पाठ-लौटाने वाले API का उपयोग करें और दस्तावेज़ों के लिए एक बाइट-लौटाने वाली फ़ेच। ये दोनों एक-दूसरे के स्थान पर उपयोग नहीं किए जा सकते, और विफलता मोड खामोश है।

पूरी पाइपलाइन

import io
import json
import logging
import os
import urllib.parse
import urllib.request

import pdfplumber
from bs4 import BeautifulSoup
from pypdf import PdfReader

logging.getLogger("pypdf").setLevel(logging.CRITICAL)
logging.getLogger("pdfminer").setLevel(logging.CRITICAL)

UNLOCKER = "https://api.scrapeless.com/api/v2/unlocker/request"
INDEX = "https://www.irs.gov/forms-pubs/about-form-w-9"
BROWSER_UA = ("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
              "(KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36")


def fetch_html(url):
    """Fetch a rendered HTML page as text."""
    payload = json.dumps({
        "actor": "unlocker.webunlocker",
        "input": {"url": url, "proxy_country": "US", "js_render": False},
    }).encode()
    request = urllib.request.Request(
        UNLOCKER, data=payload,
        headers={"Content-Type": "application/json",
                 "x-api-token": os.environ["SCRAPELESS_API_KEY"]},
    )
    with urllib.request.urlopen(request, timeout=120) as response:
        return json.loads(response.read().decode())["data"]


def fetch_bytes(url):
    """Fetch a binary file. PDFs must arrive as bytes, never as text."""
    request = urllib.request.Request(url, headers={"User-Agent": BROWSER_UA})
    with urllib.request.urlopen(request, timeout=120) as response:
        return response.read()


def pdf_links(html, base_url):
    soup = BeautifulSoup(html, "html.parser")
    return sorted({
        urllib.parse.urljoin(base_url, a["href"])
        for a in soup.select('a[href$=".pdf"]')
    })


def main():
    html = fetch_html(INDEX)
    links = pdf_links(html, INDEX)
    print(f"index page: {len(html)} chars")
    print(f"pdf links discovered: {len(links)}")
    for link in links:
        print(f"  {link}")

    target = next(link for link in links if link.endswith("fw9.pdf"))
    raw = fetch_bytes(target)
    print(f"downloaded: {len(raw)} bytes, header {raw[:5].decode('latin-1')!r}")

    reader = PdfReader(io.BytesIO(raw))
    print(f"pypdf: {len(reader.pages)} pages, encrypted={reader.is_encrypted}")

    with pdfplumber.open(io.BytesIO(raw)) as pdf:
        page = pdf.pages[0]
        text = page.extract_text() or ""
        print(f"pdfplumber page 1: {len(text)} chars of text")
        print(f"  first line: {text.splitlines()[0][:60]!r}")

        tables = page.extract_tables()
        print(f"tables on page 1: {len(tables)}")
        for index, table in enumerate(tables, 1):
            widest = max(len(row) for row in table)
            print(f"  table {index}: {len(table)} rows x {widest} cols")

        print(f"positioned words on page 1: {len(page.extract_words())}")

    # A PDF is binary. Prove what happens if it travels as text.
    as_text = fetch_html(target).encode("utf-8")
    print(f"same pdf through the text endpoint: {len(as_text)} bytes "
          f"(real file is {len(raw)})")

    # Open AND read a page — a lenient constructor is not proof the file is usable.
    def read_with_pypdf(data):
        return len(PdfReader(io.BytesIO(data)).pages)

    def read_with_pdfplumber(data):
        with pdfplumber.open(io.BytesIO(data)) as opened:
            return len(opened.pages)

    for name, read in (("pypdf", read_with_pypdf), ("pdfplumber", read_with_pdfplumber)):
        try:
            print(f"  {name} reads it: {read(as_text)} pages")
        except Exception as exc:
            print(f"  {name} reads it: failed ({type(exc).__name__})")


if __name__ == "__main__":
    main()

इसका आउटपुट:

index page: 99970 chars
pdf links discovered: 4
  https://www.irs.gov/pub/irs-pdf/fw9.pdf
  https://www.irs.gov/pub/irs-pdf/iw9.pdf
  https://www.irs.gov/pub/irs-pdf/p1281.pdf
  https://www.irs.gov/pub/irs-pdf/p5027.pdf
downloaded: 140815 bytes, header '%PDF-'
pypdf: 6 pages, encrypted=False
pdfplumber page 1: 5659 chars of text
  first line: 'W-9'
tables on page 1: 4
  table 1: 4 rows x 1 cols
  table 2: 2 rows x 7 cols
  table 3: 1 rows x 2 cols
  table 4: 2 rows x 10 cols
positioned words on page 1: 933
same pdf through the text endpoint: 235403 bytes (real file is 140815)
  pypdf reads it: failed (PdfReadError)
  pdfplumber reads it: failed (PdfminerException)

ऊपर की दोनों logging रेखाएँ сақтау योग्य हैं। दोनों पुस्तकालय क्षतिग्रस्त इनपुट पर पुनर्प्राप्ति चेतावनियाँ निकालते हैं, और उस भ्रष्ट दस्तावेज़ पर केवल एक रेखा है जो महत्वपूर्ण है।

समस्या निवारण

extract_text() None या एक खाली स्ट्रिंग लौटाता है। पृष्ठ में कोई पाठ परत नहीं है, जिसका अर्थ लगभग हमेशा यह होता है कि यह एक स्कैन की गई छवि है। कोई भी पैसर कॉन्फ़िगरेशन उस पाठ को पुनर्प्राप्त नहीं कर सकता जो कभी भी एनकोड नहीं किया गया था; उस कार्य के लिए ऑप्टिकल कैरेक्टर रिकग्निशन की आवश्यकता है, जो एक अलग पाइपलाइन है जिसमें विभिन्न सटीकता विशेषताएँ होती हैं।

पाठ स्तम्भों के बीच इंटरलीव किया गया आता है। पाठ स्ट्रीम उस क्रम का पालन करती है जिसमें ग्लिफ़ लिखे गए थे, न कि पढ़ने के क्रम का। extract_words() का उपयोग करें और top समन्वय के अनुसार समूह बनाएं, या page.crop((x0, top, x1, bottom)) के साथ पृष्ठ को काटें और प्रत्येक स्तंभ को अलग से निकालें।

extract_tables() स्पष्ट रूप से एक तालिका वाले पृष्ठ पर कुछ नहीं पाता। डिफ़ॉल्ट रणनीति नियम रेखाओं की तलाश करती है। केवल सफाई द्वारा अलग की गई तालिका को table_settings={"vertical_strategy": "text", "horizontal_strategy": "text"} की आवश्यकता होती है, जो संरेखण से स्तंभों का अनुमान लगाती है।

कोष्ठक में None होते हैं। विलय और खाली कोशिकाएँ None के रूप में लौटती हैं न कि "" के रूप में। कहीं भी लिखने से पहले सामान्य करें, और एक पंक्ति जो अधिकांशतः None है को रिकॉर्ड के बजाय एक पहचान कलाकृति के रूप में मानें।

हर दस्तावेज़ पार्स हो जाता है लेकिन संख्याएँ गलत होती हैं। जांचें कि क्या फ़ाइल बाइट के रूप में फेच की गई थी। संक्रमण में भ्रष्ट फ़ाइल अब भी %PDF- हैडर ले जा सकती है और एक रीडर ऑब्जेक्ट का निर्माण कर सकती है, इसलिए डाउनलोड की गई लंबाई की तुलना करें Content-Length उसके द्वारा रिपोर्ट की गई — HTTP सेमांटिक्स स्पेसिफिकेशन में परिभाषित फ़ील्ड।

निष्कर्ष

पीडीएफ़ स्क्रैपिंग का पीडीएफ़ हिस्सा आसान हिस्सा है। इसे ढकने के लिए दो पुस्तकालय हैं: संरचना के लिए पायपडीएफ़, कुछ भी जो उस पर निर्भर करता है उसके लिए pdfplumber।

जो हिस्से गलत जाते हैं वे दोनों पक्षों पर होते हैं। दस्तावेज़ खोजना HTML का कार्य है, और उन्हें सही रूप में प्राप्त करना एक परिवहन प्रश्न है जिसमें एक खामोश विफलता मोड है — एक फ़ाइल जो 67% बड़ी आती है, फिर भी %PDF- से शुरू होती है, फिर भी एक रीडर का निर्माण करती है, और नहीं पढ़ी जा सकती। बाइट गिनती पर जोर दें और किसी भी चीज़ पर विश्वास करने से पहले एक पृष्ठ पढ़ें।
क्या आप इसे अपने दस्तावेज़ों पर लागू करने के लिए तैयार हैं? एक मुफ्त Scrapeless खाता बनाएँ, अपनी कुंजी का निर्यात करें, और एक पृष्ठ के खिलाफ खोज चरण चलाएँ जिसे आप पहले से एकत्रित करते हैं। योजना सीमाएँ कीमत निर्धारण पृष्ठ पर हैं। यदि आपको मिश्रित दस्तावेज़ स्वरूपों में से केवल सामान्य पाठ की आवश्यकता है, न कि पृष्ठ ज्यामिति, तो दस्तावेज़-से-मार्कडाउन गाइड एक हल्का रास्ता कवर करता है।

FAQ

प्र: क्या मुझे pdfplumber या pypdf का उपयोग करना चाहिए?

आपको pypdf का उपयोग करना चाहिए जब आपको दस्तावेज़-स्तरीय तथ्य चाहिए — पृष्ठ गणना, मेटाडेटा, एन्क्रिप्शन स्थिति, फ़ाइलों को मिलाना या विभाजित करना — और pdfplumber का उपयोग करना चाहिए जब आपको यह जानने की आवश्यकता हो कि पृष्ठ पर चीजें कहाँ हैं, जो तालिका निष्कर्षण और किसी भी बहु-स्तंभ लेआउट को कवर करता है। वे खुशहाल सह-अस्तित्व में हैं; इस पोस्ट में पाइपलाइन दोनों का उपयोग करती है, और pdfplumber भारी निर्भरता है क्योंकि यह एक पूर्ण लेआउट इंजन ले जाती है।

प्र: मेरा PDF डाउनलोड सफल हुआ लेकिन पार्स करने में असफल रहा?

अधिकतर यह परिवहन में कहीं पाठ के रूप में डिकोड किया गया था। response.read() के साथ और कोई .decode() नहीं, फिर दो चीज़ें चेक करें: कि पहले पांच बाइट्स %PDF- हैं, और कि लंबाई सर्वर द्वारा विज्ञापित चीज़ों से मेल खाती है। एक पाठ राउंड ट्रिप फ़ाइल को बढ़ा देता है — 140,815 बाइट्स यहाँ माप में 235,403 हो गए — जबकि हेडर को बरकरार रखते हुए।

प्र: क्या मैं स्कैन की गई PDF से तालिकाएँ निकाल सकता हूँ?

इन पुस्तकालयों के साथ नहीं। एक स्कैन एक छवि है, और दोनों उपकरण उस पाठ और वेक्टर परतों को पढ़ते हैं जो एक दस्तावेज़ ले जाता है। extract_text() लौटाना None बताता है। उस सामग्री को पुनःप्राप्त करने के लिए OCR की आवश्यकता होती है, और आउटपुट को निकाले गए डेटा के बजाय सत्यापित करने के लिए एक अनुमान के रूप में माना जाना चाहिए।

प्र: जब PDF लिंक सामान्य एंकर नहीं होते हैं तो मैं उन्हें कैसे ढूँढूँ?

एक ब्राउज़र के लिए पहुँचने से पहले चयनकर्ता को चौड़ा करें: कई साइटें दस्तावेज़ों को बिना .pdf उपसर्ग के माध्यम से पुनर्निर्देश पथ के माध्यम से लिंक करती हैं, इसलिए URL पैटर्न या लिंक पाठ पर मेल करें बजाय फ़ाइल विस्तार के। यदि लिंक वास्तव में क्लाइंट-साइड JavaScript द्वारा लिखे गए हैं, तो इंडेक्स पृष्ठ को रेंडरिंग की आवश्यकता होती है — लेकिन पहले प्रारंभिक HTML की जाँच करें, क्योंकि URLs अक्सर पहले से वहाँ होते हैं।

प्र: क्या extract_tables() उत्पादन के लिए पर्याप्त विश्वसनीय है?

नियमित तालिकाओं और एक स्थिर लेआउट वाले दस्तावेज़ों के लिए, हाँ, बशर्ते आप जो वापस आता है उसके आकार की पुष्टि करें। यहाँ लाइव पृष्ठ ने चार तालिकाएँ लौटाईं जिनमें से अधिकांश लेआउट क्षेत्र थे, इसलिए न्यूनतम पंक्तियों और स्तंभों पर एक फ़िल्टर वैकल्पिक नहीं है। जब एक दस्तावेज़ की तालिकाएँ केवल सफेद स्थान द्वारा परिभाषित की जाती हैं, तो पाठ-आधारित रणनीति पर स्विच करें और आपके द्वारा स्वयं पढ़े गए पृष्ठ के खिलाफ परिणामों की फिर से जाँच करें।

प्र: मुझे बहुत बड़े दस्तावेज़ों को कैसे संभालना चाहिए?

pdf.pages पर पुनरावृत्ति करें बजाय कि सब कुछ सामग्री में लाना, और दस्तावेज़ को संदर्भ प्रबंधक के साथ बंद करें जैसे उदाहरण करते हैं। यदि आपको केवल फ़ाइल का एक भाग चाहिए, तो page.crop() काम को एक क्षेत्र तक सीमित करता है, और pypdf बड़े दस्तावेज़ को छोटे में विभाजित कर सकता है इससे पहले कि महंगा ज्यामिति कार्य शुरू हो।