PDFMiner के साथ Python में PDF से पाठ निकालें

पाइथन के साथ पीडीएफ टेक्स्ट एक्सट्रैक्शन मास्टर करें

Page content

PDFMiner.six

PDF दस्तावेज़ों से पाठ, मेटाडेटा, और लेआउट जानकारी निकालने के लिए एक शक्तिशाली Python लाइब्रेरी है।

साधारण PDF पाठकों के विपरीत, यह PDF संरचना का गहन विश्लेषण प्रदान करता है और जटिल लेआउट को प्रभावी ढंग से संभालता है।

पाठ का निष्कर्षण PDF से मार्कडाउन में - IPAD विज़ुअलाइज़ेशन

PDFMiner क्या है और इसका उपयोग क्यों करें?

PDFMiner एक शुद्ध-Python लाइब्रेरी है जो PDF दस्तावेज़ों से पाठ निकालने और विश्लेषण करने के लिए डिज़ाइन की गई है। .six संस्करण वह सक्रिय रूप से बनाए रखा गया फोर्क है जो Python 3.x का समर्थन करता है, जबकि मूल PDFMiner परियोजना अब अपडेट नहीं की जाती है।

मुख्य विशेषताएं:

  • शुद्ध Python कार्यान्वयन (किसी बाहरी निर्भरता के बिना)
  • विस्तृत लेआउट विश्लेषण और पाठ स्थिति
  • फॉन्ट और अक्षर एन्कोडिंग पता लगाना
  • एन्क्रिप्टेड PDF का समर्थन
  • कमांड-लाइन टूल्स शामिल हैं
  • विस्तार योग्य आर्किटेक्चर कस्टम प्रोसेसिंग के लिए

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

इंस्टॉलेशन और सेटअप

PDFMiner.six का उपयोग करके pip इंस्टॉल करें:

pip install pdfminer.six

वर्चुअल एन्वायर्नमेंट्स के लिए (सिफारिश की जाती है):

python -m venv venv
source venv/bin/activate  # Windows पर: venv\Scripts\activate
pip install pdfminer.six

अगर आप Python पैकेज प्रबंधन के नए हैं, तो pip और वर्चुअल एन्वायर्नमेंट्स के बारे में अधिक विवरण के लिए हमारी Python चीटशीट देखें।

इंस्टॉलेशन की पुष्टि करें:

pdf2txt.py --version

लाइब्रेरी में कई कमांड-लाइन टूल्स शामिल हैं:

  • pdf2txt.py - PDF से पाठ निकालें
  • dumppdf.py - PDF आंतरिक संरचना डंप करें
  • latin2ascii.py - लैटिन अक्षरों को ASCII में बदलें

ये टूल्स अन्य PDF मैनिपुलेशन यूटिलिटीज जैसे Poppler को पूरक बनाते हैं जो पृष्ठ निकालने और फॉर्मेट कन्वर्जन जैसे अतिरिक्त कार्यक्षमताएं प्रदान करते हैं।

बुनियादी पाठ निकालना

साधारण पाठ निकालना

PDF से पाठ निकालने का सबसे सीधा तरीका:

from pdfminer.high_level import extract_text

# PDF से सभी पाठ निकालें
text = extract_text('document.pdf')
print(text)

यह उच्च-स्तरीय API अधिकांश सामान्य उपयोग के मामलों को संभालता है और पूरे दस्तावेज़ को एक एकल स्ट्रिंग के रूप में वापस करता है।

विशिष्ट पृष्ठों से पाठ निकालना

विशिष्ट पृष्ठों से पाठ निकालने के लिए:

from pdfminer.high_level import extract_text

# पृष्ठ 2-5 से पाठ निकालें (0-आधारित)
text = extract_text('document.pdf', page_numbers=[1, 2, 3, 4])
print(text)

यह विशेष रूप से बड़े दस्तावेज़ों के लिए उपयोगी है जहां आपको केवल कुछ सेक्शनों की आवश्यकता होती है, जिससे प्रदर्शन में महत्वपूर्ण सुधार होता है।

पृष्ठ इटरेशन के साथ पाठ निकालना

पृष्ठों को व्यक्तिगत रूप से प्रोसेस करने के लिए:

from pdfminer.high_level import extract_pages
from pdfminer.layout import LTTextContainer

for page_layout in extract_pages('document.pdf'):
    for element in page_layout:
        if isinstance(element, LTTextContainer):
            print(element.get_text())

इस दृष्टिकोण से आपको प्रत्येक पृष्ठ को कैसे प्रोसेस किया जाता है, इसके बारे में अधिक नियंत्रण मिलता है, जो उन दस्तावेज़ों के साथ काम करने के लिए उपयोगी है जहां पृष्ठ संरचना भिन्न होती है।

उन्नत लेआउट विश्लेषण

LAParams को समझना

LAParams (लेआउट विश्लेषण पैरामीटर्स) नियंत्रित करते हैं कि PDFMiner दस्तावेज़ लेआउट को कैसे व्याख्या करता है। यहां PDFMiner और साधारण लाइब्रेरीज के बीच अंतर को समझना महत्वपूर्ण है - PDFMiner वास्तव में पाठ तत्वों के बीच स्थानिक संबंधों का विश्लेषण करता है।

from pdfminer.high_level import extract_text
from pdfminer.layout import LAParams

# कस्टम LAParams बनाएं
laparams = LAParams(
    line_overlap=0.5,      # पाठ लाइनों के लिए न्यूनतम ओवरलैप
    char_margin=2.0,       # अक्षर मार्जिन
    line_margin=0.5,       # लाइन मार्जिन
    word_margin=0.1,       # शब्द स्पेसिंग
    boxes_flow=0.5,        # बॉक्स फ्लो थ्रेशहोल्ड
    detect_vertical=True,  # लंबवत पाठ पता लगाना
    all_texts=False        # केवल बॉक्सों में पाठ निकालें
)

text = extract_text('document.pdf', laparams=laparams)

पैरामीटर व्याख्या:

  • line_overlap: पाठ लाइनों को एक ही लाइन माना जाने के लिए कितना ओवरलैप होना चाहिए (0.0-1.0)
  • char_margin: एक ही शब्द में अक्षरों के बीच अधिकतम स्पेसिंग (अक्षर चौड़ाई के गुणक के रूप में)
  • line_margin: एक ही पैराग्राफ में लाइनों के बीच अधिकतम स्पेसिंग
  • word_margin: शब्दों को अलग करने के लिए स्पेसिंग थ्रेशहोल्ड
  • boxes_flow: पाठ बॉक्स फ्लो दिशा के लिए थ्रेशहोल्ड
  • detect_vertical: लंबवत पाठ पता लगाने को सक्षम करें (एशियाई भाषाओं में आम)

लेआउट जानकारी निकालना

विस्तृत स्थिति और फॉन्ट जानकारी प्राप्त करें:

from pdfminer.high_level import extract_pages
from pdfminer.layout import LTTextBox, LTTextLine, LTChar

for page_layout in extract_pages('document.pdf'):
    for element in page_layout:
        if isinstance(element, LTTextBox):
            # बाउंडिंग बॉक्स कोआर्डिनेट्स प्राप्त करें
            x0, y0, x1, y1 = element.bbox
            print(f"पाठ ({x0}, {y0}) पर: {element.get_text()}")

            # लाइनों में इटरेट करें
            for text_line in element:
                if isinstance(text_line, LTTextLine):
                    # अक्षर-स्तरीय विवरण प्राप्त करें
                    for char in text_line:
                        if isinstance(char, LTChar):
                            print(f"अक्षर: {char.get_text()}, "
                                  f"फॉन्ट: {char.fontname}, "
                                  f"आकार: {char.height}")

इस स्तर की विवरण दस्तावेज़ विश्लेषण, फॉर्म निकालने, या जब आपको दस्तावेज़ संरचना को प्रोग्रामेटिक रूप से समझने की आवश्यकता हो, के लिए अनमोल है।

विभिन्न PDF प्रकारों का सामना करना

एन्क्रिप्टेड PDFs

PDFMiner पासवर्ड-सुरक्षित PDFs को संभाल सकता है:

from pdfminer.high_level import extract_text

# पासवर्ड-सुरक्षित PDF से निकालें
text = extract_text('encrypted.pdf', password='your_password')

ध्यान दें कि PDFMiner केवल PDFs से पाठ निकाल सकता है - यह उन सुरक्षा प्रतिबंधों को बाईपास नहीं कर सकता जो PDF स्तर पर पाठ निकालने को रोकते हैं।

बहु-स्तंभ दस्तावेज़

बहु-स्तंभ लेआउट के लिए LAParams ट्यून करें:

from pdfminer.high_level import extract_text
from pdfminer.layout import LAParams

# बहु-स्तंभ लेआउट के लिए अनुकूलित करें
laparams = LAParams(
    detect_vertical=False,
    line_margin=0.3,
    word_margin=0.1,
    boxes_flow=0.3  # कम मान बेहतर स्तंभ पता लगाने के लिए
)

text = extract_text('multi_column.pdf', laparams=laparams)

boxes_flow पैरामीटर बहु-स्तंभ दस्तावेज़ों के लिए विशेष रूप से महत्वपूर्ण है - कम मान PDFMiner को अलग-अलग स्तंभों के बीच अंतर करने में मदद करते हैं।

गैर-इंग्लिश और यूनिकोड पाठ

PDFMiner यूनिकोड का अच्छा समर्थन करता है, लेकिन सही एन्कोडिंग सुनिश्चित करें:

from pdfminer.high_level import extract_text

# यूनिकोड समर्थन के साथ पाठ निकालें
text = extract_text('multilingual.pdf', codec='utf-8')

# UTF-8 एन्कोडिंग के साथ फाइल में सेव करें
with open('output.txt', 'w', encoding='utf-8') as f:
    f.write(text)

स्कैन किए गए PDFs के साथ काम करना

PDFMiner स्कैन किए गए PDFs (इमेजेस) से सीधे पाठ निकाल नहीं सकता। इनके लिए OCR (ऑप्टिकल कैरेक्टर रिकग्निशन) की आवश्यकता होती है। हालांकि, आप PDFMiner को OCR टूल्स के साथ एकीकृत कर सकते हैं।

स्कैन किए गए PDF पता लगाने और OCR की आवश्यकता होने का तरीका:

from pdfminer.high_level import extract_text
from pdfminer.high_level import extract_pages
from pdfminer.layout import LTFigure, LTImage

def is_scanned_pdf(pdf_path):
    """पता लगाएं कि PDF स्कैन किया गया है (mostly images)"""
    text_count = 0
    image_count = 0

    for page_layout in extract_pages(pdf_path):
        for element in page_layout:
            if isinstance(element, (LTFigure, LTImage)):
                image_count += 1
            elif hasattr(element, 'get_text'):
                if element.get_text().strip():
                    text_count += 1

    # अगर mostly images और कम पाठ, तो संभवतः स्कैन किया गया
    return image_count > text_count * 2

if is_scanned_pdf('document.pdf'):
    print("इस PDF को स्कैन किया गया प्रतीत होता है - OCR का उपयोग करें")
else:
    text = extract_text('document.pdf')
    print(text)

स्कैन किए गए PDFs के लिए, Tesseract OCR के साथ एकीकृत करने या PDFs से इमेजेस निकालने के टूल्स का उपयोग करने का विचार करें, फिर उन इमेजेस पर OCR लागू करें।

कमांड-लाइन उपयोग

PDFMiner में शक्तिशाली कमांड-लाइन टूल्स शामिल हैं:

कमांड-लाइन टूल्स के साथ पाठ निकालना

# पाठ को stdout में निकालें
pdf2txt.py document.pdf

# फाइल में सेव करें
pdf2txt.py -o output.txt document.pdf

# विशिष्ट पृष्ठ निकालें
pdf2txt.py -p 1,2,3 document.pdf

# HTML के रूप में निकालें
pdf2txt.py -t html -o output.html document.pdf

उन्नत विकल्प

# कस्टम लेआउट पैरामीटर्स
pdf2txt.py -L 0.3 -W 0.1 document.pdf

# विस्तृत लेआउट के साथ निकालें (XML)
pdf2txt.py -t xml -o layout.xml document.pdf

# एन्क्रिप्टेड PDF के लिए पासवर्ड सेट करें
pdf2txt.py -P mypassword encrypted.pdf

ये कमांड-लाइन टूल्स तेज़ परीक्षण, शेल स्क्रिप्ट्स, और स्वचालित वर्कफ्लो में एकीकृत करने के लिए उत्कृष्ट हैं।

प्रदर्शन अनुकूलन

बड़े पीडीएफ प्रोसेसिंग

बड़े दस्तावेज़ों के लिए, इन अनुकूलन रणनीतियों पर विचार करें:

from pdfminer.high_level import extract_pages
from pdfminer.layout import LAParams

# केवल आवश्यक पृष्ठों को प्रोसेस करें
def extract_page_range(pdf_path, start_page, end_page):
    text_content = []
    for i, page_layout in enumerate(extract_pages(pdf_path)):
        if i < start_page:
            continue
        if i >= end_page:
            break
        text_content.append(page_layout)
    return text_content

# गति के लिए लेआउट विश्लेषण को निष्क्रिय करें
from pdfminer.high_level import extract_text
text = extract_text('large.pdf', laparams=None)  # बहुत तेज़

बैच प्रोसेसिंग

बहुत सारे पीडीएफ को कुशलतापूर्वक प्रोसेस करने के लिए:

from multiprocessing import Pool
from pdfminer.high_level import extract_text
import os

def process_pdf(pdf_path):
    """एकल पीडीएफ फ़ाइल प्रोसेस करें"""
    try:
        text = extract_text(pdf_path)
        output_path = pdf_path.replace('.pdf', '.txt')
        with open(output_path, 'w', encoding='utf-8') as f:
            f.write(text)
        return f"प्रोसेस किया गया: {pdf_path}"
    except Exception as e:
        return f"एरर {pdf_path} प्रोसेस करने में: {str(e)}"

# पीडीएफ को समानांतर में प्रोसेस करें
def batch_process_pdfs(pdf_directory, num_workers=4):
    pdf_files = [os.path.join(pdf_directory, f)
                 for f in os.listdir(pdf_directory)
                 if f.endswith('.pdf')]

    with Pool(num_workers) as pool:
        results = pool.map(process_pdf, pdf_files)

    for result in results:
        print(result)

# उपयोग
batch_process_pdfs('/path/to/pdfs', num_workers=4)

सामान्य समस्याएं और समाधान

समस्या: गलत पाठ क्रम

समस्या: निकाला गया पाठ बिखरा हुआ या गलत क्रम में दिखाई देता है।

समाधान: LAParams को समायोजित करें, विशेष रूप से boxes_flow:

from pdfminer.layout import LAParams
laparams = LAParams(boxes_flow=0.3)  # विभिन्न मानों का परीक्षण करें
text = extract_text('document.pdf', laparams=laparams)

समस्या: शब्दों के बीच स्पेस का अभाव

समस्या: शब्द बिना स्पेस के एक साथ चलते हैं।

समाधान: word_margin बढ़ाएं:

laparams = LAParams(word_margin=0.2)  # डिफ़ॉल्ट 0.1 से बढ़ाएं
text = extract_text('document.pdf', laparams=laparams)

समस्या: एनकोडिंग त्रुटियां

समस्या: अजीब चिह्न या एनकोडिंग त्रुटियां।

समाधान: कोडेक स्पष्ट रूप से निर्दिष्ट करें:

text = extract_text('document.pdf', codec='utf-8')

समस्या: बड़े पीडीएफ के साथ मेमोरी त्रुटियां

समस्या: बड़े फ़ाइलों के साथ मेमोरी समाप्त हो जाती है।

समाधान: पृष्ठ द्वारा पृष्ठ प्रोसेस करें:

def extract_text_chunked(pdf_path, chunk_size=10):
    """मेमोरी उपयोग को कम करने के लिए पाठ को चंक में निकालें"""
    all_text = []
    page_count = 0

    for page_layout in extract_pages(pdf_path):
        page_text = []
        for element in page_layout:
            if hasattr(element, 'get_text'):
                page_text.append(element.get_text())

        all_text.append(''.join(page_text))
        page_count += 1

        # चंक में प्रोसेस करें
        if page_count % chunk_size == 0:
            yield ''.join(all_text)
            all_text = []

    # शेष पाठ प्रदान करें
    if all_text:
        yield ''.join(all_text)

PDFMiner को विकल्पों के साथ तुलना

PDFMiner का उपयोग कब करें और कब अन्य लाइब्रेरी का उपयोग करें, यह समझना महत्वपूर्ण है:

PDFMiner vs PyPDF2

PyPDF2 सरल और तेज़ है लेकिन कम सटीक:

  • PyPDF2 का उपयोग करें: सरल पीडीएफ, तेज़ निकास, पीडीएफ को मिलाना/बांटना
  • PDFMiner का उपयोग करें: जटिल लेआउट, सटीक पाठ स्थिति, विस्तृत विश्लेषण

PDFMiner vs pdfplumber

pdfplumber PDFMiner पर उच्च-स्तरीय API के साथ बनाया गया है:

  • pdfplumber का उपयोग करें: टेबल निकास, सरल API, तेज़ प्रोटोटाइपिंग
  • PDFMiner का उपयोग करें: अधिक नियंत्रण, कस्टम प्रोसेसिंग, उत्पादन प्रणालियाँ

PDFMiner vs PyMuPDF (fitz)

PyMuPDF काफी तेज़ है लेकिन सी डिपेंडेंसीज हैं:

  • PyMuPDF का उपयोग करें: प्रदर्शन-आधारित अनुप्रयोग, बड़े पैमाने पर प्रोसेसिंग
  • PDFMiner का उपयोग करें: शुद्ध Python आवश्यकता, विस्तृत लेआउट विश्लेषण

व्यावहारिक उदाहरण: दस्तावेज़ निकालें और विश्लेषण करें

यह एक पूर्ण उदाहरण है जो पाठ निकालता है और दस्तावेज़ सांख्यिकी प्रदान करता है:

from pdfminer.high_level import extract_pages, extract_text
from pdfminer.layout import LTTextBox, LTChar
from collections import Counter
import re

def analyze_pdf(pdf_path):
    """पाठ निकालें और दस्तावेज़ विश्लेषण प्रदान करें"""

    # पूर्ण पाठ निकालें
    full_text = extract_text(pdf_path)

    # सांख्यिकी
    stats = {
        'total_chars': len(full_text),
        'total_words': len(full_text.split()),
        'total_lines': full_text.count('\n'),
        'fonts': Counter(),
        'font_sizes': Counter(),
        'pages': 0
    }

    # विस्तृत विश्लेषण
    for page_layout in extract_pages(pdf_path):
        stats['pages'] += 1

        for element in page_layout:
            if isinstance(element, LTTextBox):
                for line in element:
                    for char in line:
                        if isinstance(char, LTChar):
                            stats['fonts'][char.fontname] += 1
                            stats['font_sizes'][round(char.height, 1)] += 1

    return {
        'text': full_text,
        'stats': stats,
        'most_common_font': stats['fonts'].most_common(1)[0] if stats['fonts'] else None,
        'most_common_size': stats['font_sizes'].most_common(1)[0] if stats['font_sizes'] else None
    }

# उपयोग
result = analyze_pdf('document.pdf')
print(f"पृष्ठ: {result['stats']['pages']}")
print(f"शब्द: {result['stats']['total_words']}")
print(f"मुख्य फ़ॉन्ट: {result['most_common_font']}")
print(f"मुख्य आकार: {result['most_common_size']}")

दस्तावेज़ प्रोसेसिंग पाइपलाइन्स के साथ एकीकरण

PDFMiner बड़े दस्तावेज़ प्रोसेसिंग वर्कफ़्लो में अच्छी तरह से काम करता है। उदाहरण के लिए, RAG (Retrieval-Augmented Generation) प्रणालियों या दस्तावेज़ प्रबंधन समाधानों को बनाने के लिए, आप इसे अन्य Python उपकरणों के साथ मिलाकर एक पूर्ण पाइपलाइन बना सकते हैं।

एक बार जब आप पीडीएफ से पाठ निकाल लेते हैं, तो आपको इसे अक्सर अन्य प्रारूपों में बदलना पड़ता है। आप Python लाइब्रेरी का उपयोग करके HTML सामग्री को Markdown में बदल सकते हैं या यहां तक कि Ollama के साथ LLM-सक्षम परिवर्तन के लिए बुद्धिमान दस्तावेज़ परिवर्तन के लिए भी लाभ उठा सकते हैं। ये तकनीकें विशेष रूप से उपयोगी होती हैं जब पीडीएफ निकास से HTML-जैसा संरचित पाठ प्राप्त होता है जिसे साफ़ और पुनः प्रारूपित करने की आवश्यकता होती है।

विस्तृत दस्तावेज़ परिवर्तन पाइपलाइन्स के लिए, आपको वर्ड दस्तावेज़ को Markdown में बदलने का भी प्रबंधन करना पड़ सकता है, एक एकीकृत वर्कफ़्लो बनाने के लिए जो कई दस्तावेज़ प्रारूपों को एक सामान्य आउटपुट प्रारूप में प्रोसेस करता है।

सर्वोत्तम प्रथाएं

  1. जटिल दस्तावेज़ों के लिए हमेशा LAParams का उपयोग करें - डिफ़ॉल्ट सेटिंग्स सरल दस्तावेज़ों के लिए काम करती हैं, लेकिन जटिल लेआउट के लिए LAParams को समायोजित करना परिणामों को महत्वपूर्ण रूप से बेहतर बनाता है।

  2. पहले नमूना पृष्ठों पर परीक्षण करें - बड़े बैच प्रोसेस करने से पहले, अपने निकास सेटिंग्स को प्रतिनिधित्वात्मक नमूनों पर परीक्षण करें।

  3. अपवादों को सुचारू रूप से संभालें - पीडीएफ फ़ाइलें भ्रष्ट या गलत रूप से बनाई जा सकती हैं। हमेशा निकास कोड को try-except ब्लॉक्स में रखें।

  4. निकाले गए पाठ को कैश करें - बार-बार प्रोसेसिंग के लिए निकाले गए पाठ को कैश करें ताकि पुनः प्रोसेसिंग से बचा जा सके।

  5. निकाले गए पाठ की पुष्टि करें - निकास गुणवत्ता की पुष्टि करने के लिए चेक लागू करें (उदाहरण के लिए, न्यूनतम पाठ लंबाई, अपेक्षित कीवर्ड्स)।

  6. विशिष्ट उपयोग मामलों के लिए विकल्पों पर विचार करें - जबकि PDFMiner शक्तिशाली है, कभी-कभी विशेषज्ञ उपकरण (जैसे tabula-py टेबल्स के लिए) अधिक उपयुक्त होते हैं।

  7. PDFMiner को अपडेट रखें - .six फोर्क सक्रिय रूप से बनाए रखा जाता है। बग फिक्स और सुधारों के लिए इसे अपडेट रखें।

  8. अपनी कोड को उचित रूप से दस्तावेज़ीकृत करें - जब पीडीएफ निकास स्क्रिप्ट साझा करें, तो बेहतर पठनीयता के लिए उचित Markdown कोड ब्लॉक्स के साथ सिंटैक्स हाइलाइटिंग का उपयोग करें।

निष्कर्ष

PDFMiner.six Python डेवलपर्स के लिए पीडीएफ दस्तावेज़ों के साथ काम करने के लिए एक आवश्यक उपकरण है। इसके शुद्ध-Python कार्यान्वयन, विस्तृत लेआउट विश्लेषण, और विस्तार योग्य वास्तुकला इसे उत्पादन दस्तावेज़ प्रोसेसिंग प्रणालियों के लिए आदर्श बनाते हैं। जबकि यह सरल लाइब्रेरीज की तुलना में अधिक सीखने की सीढ़ी हो सकती है, यह जटिल पीडीएफ निकास कार्यों के लिए प्रदान की गई सटीकता और नियंत्रण से अनुपम है।

चाहे आप एक दस्तावेज़ प्रबंधन प्रणाली बन रहे हों, वैज्ञानिक पत्रों का विश्लेषण कर रहे हों, या मशीन लर्निंग पाइपलाइन्स के लिए डेटा निकाल रहे हों, PDFMiner Python में विश्वसनीय पीडीएफ पाठ निकास के लिए आधार प्रदान करता है।

संबंधित संसाधन

इस साइट पर संबंधित लेख

  • Pdf manipulating tools in Ubuntu - Poppler - Ubuntu में PDF टूल्स की व्यापक गाइड जिसमें pdftotext, pdfimages, और अन्य poppler यूटिलिटीज शामिल हैं जो दस्तावेज़ प्रोसेसिंग वर्कफ्लो में PDFMiner के साथ काम करते हैं
  • How to extract images from PDF - Cheatsheet - सीखें कि poppler कमांड-लाइन टूल्स का उपयोग करके PDF से एम्बेडेड इमेजेज को निकालने का तरीका, जो PDFMiner के टेक्स्ट एक्सट्रैक्शन क्षमताओं को पूरक बनाता है
  • Generating PDF in Python - Libraries and examples - PDF जनरेशन के लिए Python लाइब्रेरीज का पता लगाएं जिसमें ReportLab, PyPDF2, और FPDF शामिल हैं जो PDF टेक्स्ट एक्सट्रैक्शन के विपरीत वर्कफ्लो को बनाते हैं
  • Python Cheatsheet - PDF प्रोसेसिंग स्क्रिप्ट्स लिखने के लिए फाइल हैंडलिंग, स्ट्रिंग ऑपरेशंस, और बेस्ट प्रैक्टिसेस सहित आवश्यक Python सिंटैक्स रेफरेंस
  • Converting HTML to Markdown with Python: A Comprehensive Guide - दस्तावेज़ कन्वर्जन पाइपलाइन्स बनाते समय, Python लाइब्रेरीज का उपयोग करके PDF या वेब से निकाले गए HTML को Markdown फॉर्मेट में कन्वर्ट करने का तरीका सीखें
  • Convert HTML content to Markdown using LLM and Ollama - निकाले गए PDF टेक्स्ट को साफ़ करने के लिए स्थानीय LLMs का उपयोग करके HTML सामग्री को बुद्धिमान तरीके से Markdown में कन्वर्ट करने का उन्नत तकनीक
  • Using Markdown Code Blocks - अपने PDF एक्सट्रैक्शन कोड को उचित फॉर्मेटिंग और सिंटैक्स हाइलाइटिंग के साथ दस्तावेज़ करने के लिए Markdown सिंटैक्स को मास्टर करें
  • Converting Word Documents to Markdown: A Complete Guide - क्रॉस-प्लेटफॉर्म दस्तावेज़ प्रोसेसिंग पाइपलाइन्स के लिए Word, PDF, और अन्य फॉर्मेट्स सहित पूर्ण दस्तावेज़ कन्वर्जन गाइड

बाहरी संदर्भ