HTML ஐ எளிய உரையாக மாற்றவும், உரையின் இரண்டு பத்திகள் ஒன்றாக ஒட்டிக்கொள்வதை எவ்வாறு தடுப்பது

HTML ஐ எளிய உரைக்கு மாற்றும் போது, உரையின் இரண்டு பத்திகள் ஒன்றாக ஒட்டிக்கொள்கின்றன, பெரும்பாலும் get_text() ஒரு பிரிப்பு உத்தியைக் குறிப்பிடாமல் நேரடியாக அழைக்கப்படுகிறது. அழகான சூப் முன்னிருப்பாக அனைத்து உரை முனைகளையும் தடையின்றி தைக்கிறது, மேலும் தொகுதி-நிலை உறுப்புகளுக்கு இடையிலான எல்லைகள் மறைந்துவிடும். வலை உள்ளடக்கத்தைப் பிரித்தெடுக்க அழகான சூப்பைப் பயன்படுத்தும் போது இந்தச் சிக்கல் பொதுவானது.

பிரித்தெடுத்த பிறகு எங்கு உடைக்க வேண்டும் என்பதை யூகிக்க வழக்கமான வெளிப்பாடுகளைப் பயன்படுத்துவதற்குப் பதிலாக, பிரித்தெடுக்கும் போது separator மற்றும் strip அளவுருக்களை நீங்கள் சரியாக இணைக்கலாம். இந்தக் கட்டுரை இந்த முறையைக் காட்ட செயற்கை மாதிரிகளைப் பயன்படுத்துகிறது, இயங்கக்கூடிய உறுதிமொழிக் குறியீட்டைக் கொடுக்கிறது மற்றும் எந்தச் சூழ்நிலைகளுக்கு கைமுறையாக மதிப்பாய்வு தேவைப்படுகிறது என்பதை விளக்குகிறது.

இந்தக் கட்டுரையைப் படித்த பிறகு, உங்கள் பிரித்தெடுத்தல் முடிவுகள் சிக்கியுள்ளதா என்பதை நீங்கள் தீர்மானிக்கலாம், வெளியீட்டைச் சரிபார்க்க வலியுறுத்தல் ஸ்கிரிப்ட்களைப் பயன்படுத்தலாம் மற்றும் அளவுருக்கள் மூலம் எந்த சிக்கல்களைத் தீர்க்கலாம் மற்றும் மாற்றப்பட வேண்டும் என்பதைத் தெளிவுபடுத்தலாம்.

HTML ஐ எளிய உரையாக மாற்றினால் நான் என்ன செய்ய வேண்டும்? ஒரு வாக்கியத்தின் முடிவு

get_text() ஐ அழைக்க முதலில் separator='\n' மற்றும் strip=True ஆகியவற்றின் கலவையைப் பயன்படுத்தவும், பின்னர் பக்கச் சூழ்நிலைக்கு ஏற்ப பொருத்தமற்ற குறிச்சொற்கள் மற்றும் கட்டமைப்பு சிக்கல்களைக் கையாளவும்.

இயல்புநிலை நடத்தையின் பொறிகள் மற்றும் அளவுரு சொற்பொருள்

ஏன் ஒட்டிக்கொள்கிறது?

get_text() முறை இரண்டு முக்கிய அளவுருக்களை ஏற்றுக்கொள்கிறது: separator மற்றும் strip. எந்த அளவுருவும் அனுப்பப்படவில்லை என்றால், அது டேக் ட்ரீயில் உள்ள அனைத்து உரை முனைகளையும் நேரடியாக இணைக்கும்.

இந்த இயல்புநிலை நடத்தை div, p மற்றும் li போன்ற தொகுதி-நிலை கூறுகளுக்கு மிகவும் சிக்கலாக உள்ளது. HTML மூலக் குறியீட்டில் உள்ள வரி முறிவுகள் மற்றும் உள்தள்ளல்கள் பெரும்பாலும் வெற்று சரங்களாக மாற்றப்படுகின்றன அல்லது பாகுபடுத்திய பின் புறக்கணிக்கப்படுகின்றன, மேலும் சொற்பொருள் எல்லைகள் மறைந்துவிடும்.

பிரிப்பான் மற்றும் துண்டு என்ன செய்கிறது?

• பிரிப்பான்: உரை முனைகளுக்கு இடையே உள்ள செருகலை வரையறுக்கிறது. '\n' க்கு அமைப்பது பொதுவான நடைமுறை, ஆனால் சரியானது அல்ல. HTML ஆழமாக உள்ளமைக்கப்பட்டிருந்தால், உலகளாவிய மடக்குதல் அதிக எண்ணிக்கையிலான வெற்று வரிகளை ஏற்படுத்தக்கூடும்.
• ஸ்ட்ரிப்: ஒவ்வொரு உரை துண்டின் தொடக்கத்திலும் முடிவிலும் உள்ள வெற்று இடத்தை அகற்ற வேண்டுமா என்பதைக் கட்டுப்படுத்தவும். strip=True போது, அழகான சூப் ஒவ்வொரு சுயாதீன NavigableString இல் முதலில் .strip() செய்யும், பின்னர் பிரிப்பானைப் பயன்படுத்தி அவற்றைப் பிரிக்கும்.

எடுத்துக்காட்டாக, \n Hello \n க்கு பதிலாக <p> Hello </p> சுத்தமான Hello ஐ அழுக்கு தரவு வெளியீட்டில் பெறும்.

இரண்டையும் ஒன்றாகப் பயன்படுத்த வேண்டும்:

• ஸ்டிரிப் இல்லாமல் பிரிப்பானை மட்டும் பயன்படுத்துவது அர்த்தமற்ற உள்தள்ளப்பட்ட இடைவெளிகளைத் தக்க வைத்துக் கொள்ளும்.
• ஒரே துண்டு மற்றும் பிரிப்பான் இல்லாமல், ஒற்றை வரி சுத்தமாக இருக்கும், ஆனால் கோடுகளுக்கு இடையே ஒட்டுதல் இருக்கலாம்.

கூடுதல் அளவுரு விளக்கங்களுக்கு, தயவுசெய்து அழகான சூப் அதிகாரப்பூர்வ ஆவணம்: get_text() ஐப் பார்க்கவும்.

செயற்கை DOM எல்லை சோதனை வழக்குகள்

பிரித்தெடுத்தல் தர்க்கத்தை சரிபார்க்க, நிலையற்ற உண்மையான வலைப்பக்கங்களை நம்புவதற்கு பதிலாக வழக்கமான எல்லை சிக்கல்களைக் கொண்ட செயற்கை HTML மாதிரிகள் உருவாக்கப்பட வேண்டும். பின்வரும் சோதனை வழக்குகள் மூன்று சூழ்நிலைகளை உள்ளடக்கியது: தொகுதி-நிலை உறுப்பு ஒட்டுதல், இன்லைன் உறுப்பு இடைவெளி மற்றும் அதிகப்படியான வெள்ளை இடம்.

உள்ளீட்டு மாதிரி (செயற்கை எடுத்துக்காட்டு):

<div>
    <p>第一段文字</p>
    <p>第二段文字<span>内联补充</span></p>
    <ul>
        <li> 列表项A </li>
        <li>列表项B</li>
    </ul>
</div>

எதிர்பார்க்கப்படும் சரியான வெளியீடு:

第一段文字

第二段文字
内联补充

列表项A
列表项B

separator='\n' பிரித்தெடுக்கப்பட்ட உரை முனைகளில் செயல்படுகிறது மற்றும் தொகுதி-நிலை குறிச்சொற்களின் அடிப்படையில் தானாக இரட்டை வரி முறிவுகளை உருவாக்காது என்பதை கவனத்தில் கொள்ள வேண்டும். பத்திகள் மற்றும் பட்டியல் உருப்படிகளுக்கு இடையே தெளிவான வரி இடைவெளிகள் இருக்க வேண்டும், மேலும் பட்டியல் உருப்படிகளுக்கு முன்னும் பின்னும் கூடுதல் இடைவெளிகள் அகற்றப்பட வேண்டும். "இரண்டாவது உரை" மற்றும் "இன்லைன் சப்ளிமெண்ட்" ஆகியவை வெவ்வேறு லேபிள்களில் அமைந்துள்ளன, மேலும் அவை உரை முனைகளாகும், எனவே அவை பிரிப்பான்களால் பிரிக்கப்படும்.

பிழைகள் மற்றும் எல்லை உள்ளீடு

உள்ளீடு <p>End</p><script>alert(1)</script><p>Start</p> ஆகி ஸ்கிரிப்ட் டேக் வடிகட்டப்படாவிட்டால், வெளியீட்டில் alert(1) இருக்கும். பிரிப்பான் அமைக்கப்பட்டாலும் இது உண்மைதான். ஸ்கிரிப்ட் முனைகள் உரையில் சேர்க்கப்பட்டுள்ளதா என்பது பாகுபடுத்தி மற்றும் முனை வகையைப் பொறுத்தது.

get_text ஐ அழைப்பதற்கு முன் பொருத்தமற்ற குறிச்சொற்களை அகற்ற soup.find_all('script') ஐப் பயன்படுத்துவது அல்லது பயணிக்கும் போது குறிப்பிட்ட குறிச்சொல் வகைகளைத் தவிர்ப்பது இதைக் கையாள சரியான வழி. get_text இன் அளவுருக்கள் வடிவமைப்பு சிக்கலை மட்டுமே தீர்க்கின்றன, உள்ளடக்கத்தை சுத்தம் செய்யும் சிக்கலை அல்ல.

பைதான் செயல்படுத்தல் மற்றும் உறுதிப்படுத்தல் சரிபார்ப்பு

கீழே உள்ள குறியீடு மேலே உள்ள மாதிரியை நினைவகத்தில் உருவாக்குகிறது மற்றும் உறுதியான சரிபார்ப்பைச் செய்கிறது. எடுத்துக்காட்டு beautifulsoup4 ஐப் பொறுத்தது, மேலும் பதிப்பு 4.9.0 மற்றும் அதற்கு மேல் பரிந்துரைக்கப்படுகிறது.

வெளிப்புறக் கோப்புகளைச் சோதிக்க, முதலில் HTML ஐ UTF-8 குறியாக்கமாகச் சேமிக்கவும், பின்னர் open('file.html', encoding='utf-8') ஐப் பயன்படுத்தி, பாகுபடுத்தும் விதிவிலக்குகளை ஏற்படுத்தும் குறியாக்கப் பிழைகளைத் தவிர்க்க அதைப் படிக்கவும். குறியீட்டில் பிணைய கோரிக்கைகள் இல்லை மற்றும் முற்றிலும் தன்னிறைவு கொண்டது.

from bs4 import BeautifulSoup

# 合成示例：模拟常见的HTML文本边界问题
html_content = """
<div>
    <p>第一段文字</p>
    <p>第二段文字<span>内联补充</span></p>
    <ul>
        <li> 列表项A </li>
        <li>列表项B</li>
    </ul>
</div>
"""

soup = BeautifulSoup(html_content, 'html.parser')

# 关键配置：separator定义边界，strip清理碎片空白
text_result = soup.get_text(separator='\n', strip=True)

# 过滤空行以获得干净的语义行
lines = [line for line in text_result.split('\n') if line]

# 验收断言：确保边界清晰且无脏数据
assert lines[0] == '第一段文字', f"段落粘连或内容错误: {lines[0]}"
assert lines[1] == '第二段文字', "块级元素间未正确分隔"
assert lines[2] == '内联补充', "内联元素文本节点被错误合并"
assert lines[3] == '列表项A', f"列表项前置空格未清除: '{lines[3]}'"
assert lines[4] == '列表项B', "列表项间边界丢失"

print("提取结果预览:")
for i, line in enumerate(lines):
    print(f"{i}: [{line}]")

இந்தக் குறியீட்டின் எதிர்பார்க்கப்படும் வெளியீடு சுத்தமான உரையின் ஐந்து வரிகள் ஆகும். உங்கள் சூழல் அதிக வெற்றுக் கோடுகளை வெளியிட்டால், DOM இல் துண்டிக்கப்படாத சுத்தமான வெற்று NavigableString முனைகள் உள்ளன என்று அர்த்தம். இது html.parser இன் இயல்பான நடத்தை மற்றும் பிரித்த பிறகு பட்டியல் புரிதல்களுடன் வடிகட்டலாம்.

இந்த குறியீடு அளவுரு கலவையின் கொள்கையை நிரூபிக்க மட்டுமே பயன்படுத்தப்படுகிறது மற்றும் உற்பத்தி சூழலில் சிக்கலான பக்கங்களில் நேரடியாகப் பயன்படுத்தப்படக்கூடாது.

📊 முக்கிய ஒப்பீடு

ஏற்றுக்கொள்ளும் அளவுகோல்கள் மற்றும் கைமுறை மதிப்பாய்வு எல்லைகள்

தானியங்கு பிரித்தெடுத்தல் 100% காட்சி மீட்டமைப்பை அடைய முடியாது. "குறியீடு சரிசெய்யக்கூடியது" மற்றும் "மனித தலையீடு தேவைப்படும்" சூழ்நிலைகளை எவ்வாறு வேறுபடுத்துவது என்பதை பின்வரும் அட்டவணை பட்டியலிடுகிறது. தீர்ப்பு DOM கட்டமைப்பை அடிப்படையாகக் கொண்டது, அகநிலை உணர்வு அல்ல.

பொருந்தாத தன்மையின் வெளிப்படையான நோக்கம்: HTML ஆனது CSS போலி கூறுகள், கேன்வாஸ்-ரெண்டர் செய்யப்பட்ட உள்ளடக்கம் அல்லது நிழல் DOM மூலம் உருவாக்கப்பட்ட உரையின் பெரிய அளவைக் கொண்டிருக்கும் போது, அழகான சூப் சரியான தகவலைப் பெற முடியாது. இந்த நேரத்தில், அளவுருக்கள் பிழைத்திருத்தத்தைத் தொடரக்கூடாது, ஆனால் கையகப்படுத்தல் திட்டத்தை மாற்ற வேண்டும் அல்லது விடுபட்ட தகவல் ஏற்றுக்கொள்ளப்பட வேண்டும்.

🎯 எந்த முறை உங்களுக்கு ஏற்றது?

நீங்கள் என்றால்....

பத்திகள் மற்றும் பட்டியல் உருப்படிகளின் எளிய உரையைப் பிரித்தெடுக்க வேண்டும்

separator='\n' மற்றும் strip=True இரண்டையும் அமைத்து, உறுதிப்படுத்தல் ஸ்கிரிப்ட் மூலம் வெளியீட்டைச் சரிபார்க்கவும்.

பக்கத்தில் பல ஸ்கிரிப்ட் அல்லது ஸ்டைல் குறிச்சொற்கள் உள்ளன

get_text ஐ அழைப்பதற்கு முன் இந்தக் குறிச்சொற்களை அகற்றவும், மேலும் அளவுருக்கள் உள்ளடக்கச் சிக்கல்களைத் தீர்க்கும் என எதிர்பார்க்க வேண்டாம்.

அட்டவணையின் வரிசை மற்றும் நெடுவரிசை அமைப்பைத் தக்கவைக்க வேண்டும்

get_text ஐ மட்டும் நம்பாமல், அட்டவணை அமைப்பைத் தனியாகக் கையாளவும்.

பக்கம் உலாவி ரெண்டரிங் அல்லது நிழல் DOM ஐ நம்பியுள்ளது

சேகரிப்பு திட்டத்தை மாற்றவும் அல்லது ஏற்றுக்கொள்ளும் போது சேகரிப்பு இடைவெளிகளை தெளிவாக பதிவு செய்யவும்.

❓ அடிக்கடி கேட்கப்படும் கேள்விகள் (FAQ)

1. பிரிப்பான் மட்டும் அமைத்தால் போதுமா?

போதாது. பிரிப்பானை மட்டும் அமைப்பது அர்த்தமற்ற உள்தள்ளல் இடைவெளிகளைப் பாதுகாக்கும், மேலும் strip=True ஐச் சேர்க்க வேண்டும்.

2. வெளியீட்டில் ஏன் வெற்று கோடுகள் உள்ளன?

DOM இல் அகற்றப்படாத வெற்று NavigableString முனைகள் இருக்கலாம். இது html.parser இன் இயல்பான நடத்தை மற்றும் பிரித்த பிறகு பட்டியல் புரிதல்களுடன் வடிகட்டலாம்.

3. முடிவுகளில் ஸ்கிரிப்ட் டேக் ஏன் தோன்றும்?

get_text இன் அளவுருக்கள் வடிவமைப்பு சிக்கலை மட்டுமே தீர்க்கும். அழைப்பதற்கு முன் soup.find_all('script') உடன் அகற்றப்பட வேண்டும் அல்லது பயணத்தின் போது தவிர்க்கப்பட வேண்டும்.

4. பிரித்தெடுத்தல் முடிவு சரியானதா என்பதை எவ்வாறு சரிபார்க்கலாம்?

5-10 வழக்கமான எட்ஜ் கேஸ்களைக் கொண்ட செயற்கை சோதனைத் தொகுப்பை உருவாக்கி, உறுதிமொழி ஸ்கிரிப்ட்களை இயக்கவும். தேர்ச்சி விகிதம் எதிர்பார்த்ததை விட குறைவாக இருந்தால், பிரித்தெடுப்பதற்கு முன், DOMஐ முன்கூட்டியே செயலாக்க வேண்டுமா என்பதைச் சரிபார்க்கவும்.

📝 சுருக்கம்

ஒட்டுதல் சிக்கலின் மையமானது பிரித்தெடுக்கும் போது அளவுரு கலவையில் உள்ளது, பிரித்தெடுத்த பிறகு சரம் பழுது இல்லை. முதலில் செயற்கை மாதிரிகள் மற்றும் உறுதிமொழிகள் மூலம் இயக்கவும், பின்னர் உண்மையான பக்கத்தில் உள்ள பொருத்தமற்ற குறிச்சொற்கள் மற்றும் கட்டமைப்பு சிக்கல்களைக் கையாளவும்.

இப்போது முயற்சிக்கவும்: அசல் தளவமைப்பைத் தக்கவைத்து, மொழிபெயர்ப்பைத் தொடங்க ஆவணத்தைப் பதிவேற்றவும்