파이썬에서 PDFMiner를 사용하여 PDF에서 텍스트 추출하기

pip install pdfminer.six

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

pdf2txt.py --version

from pdfminer.high_level import extract_text

# PDF에서 모든 텍스트 추출
text = extract_text('document.pdf')
print(text)

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())

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)

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}")

from pdfminer.high_level import extract_text

# 암호가 걸린 PDF에서 텍스트 추출
text = extract_text('encrypted.pdf', password='your_password')

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)

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)

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가 스캔된 것인지 확인"""
    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
    
    # 대부분 이미지이고 텍스트가 적을 경우, 스캔된 것으로 간주
    return image_count > text_count * 2

if is_scanned_pdf('document.pdf'):
    print("이 PDF는 스캔된 것으로 보입니다 - OCR 사용")
else:
    text = extract_text('document.pdf')
    print(text)

# 텍스트를 표준 출력으로 추출
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):
    """단일 PDF 파일 처리"""
    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)

from pdfminer.layout import LAParams
laparams = LAParams(boxes_flow=0.3)  # 다른 값 시도
text = extract_text('document.pdf', laparam道=laparams)

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)

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']}")