நம்மில் பெரும்பாலானவர்கள் பொழுதுபோக்குவதற்காகவே இணையத்தில் மிக அதிக நேரம் உலாவருகின்றோம். ஆனால் இவ்வாறான இணய உலாவருவதற்கான ஒவ்வொரு செயலையும் நம்முடைய கையால் சொடுக்குதல் செய்வதன் வாயிலாக மட்டுமே இவ்வாறு இணைய உலாவரமுடியும் என்பது ஒரு மோசமான செயல்முறை, அல்லவா? இவ்வாறு இணைய உலாவருவதற்காக ஒரு இணைய உலாவியைத் செயல் படுத்திடவும். குறிப்பி்ட்டதொரு இணையதளத்திற்குச் செல்லவும். தேவையான பொத்தான்களை சொடுக்குதல் செய்தல், சுட்டியை நகர்த்தி செல்லுதல் ஆகிய. பணிகள் மிகஅதிகமானவைகளாகும் அதனால் . அதனை குறைத்து குறிமுறை வரிகளின் மூலம் இணையத்துடன் தொடர்புகொள்வது நன்றாக இருக்கும் அல்லவா? இதற்காக கைகொடுக்கு வருவதுதான் பைதானின் requestsஎனும் தகவமைவு(module) ஆகும் பைத்தானின் இந்த தகவமைவின் உதவியை பயன்படுத்தி இணையத்திலிருந்து தரவைப் பெறலாம் அதற்கான கட்டளைவரி பின்வருமாறு:
import requests
DATA=”https://opensource.com/article/22/5/document-source-code-doxygen-linux”
PAGE=requests.get(DATA)
print(PAGE.text)
இந்த மாதிரி குறிமுறைவரிகளில், முதலில்பைதானின் requestsஎனும் தகவமைவை பதிவிறக்கம் செய்கின்றோம். பின்னர் PAGE, DATAஆகிய இரண்டு மாறிகளை உருவாக்குகின்றோம்: நாம் பதிவிறக்க விரும்பும் URL ஐ வைத்திருக்க DATA எனப்படும் மாறி அவற்றில் ஒன்றாகும். இந்தக் குறிமுறைவரிகளின் பிந்தைய பதிப்புகளில், ஒவ்வொரு முறையும் நம்முடைய பயன்பாட்டை இயக்கும் போது நாம் இந்த மாறிக்கு வெவ்வேறு URL ஐ வழங்க முடியும். இருப்பினும், இப்போதைக்கு, பரிசோதனை URL ஐ “நிலையான குறியீடாக்குவது(hard code)” மிகவும் எளிதானது.
மற்றொரு மாறி PAGEஆகும், இது DATAவில் சேமிக்கப்பட்ட URL ஐப் படிக்கும் போது கோரிக்கைகள்.getfunction என்ற செயலிக்கு பதிலாக அமைக்கின்றோம். requestsஎனும் தகவமைவு, its.getfunction ஆகியவை இணைய முகவரியை (URL) “படிக்க(read)”, இணையத்தை அணுக , அந்த முகவரியில் உள்ளதை பதிவிறக்கம் செய்ய முன்கூட்டியே-நிரலாக்கம் செய்யப்பட்டுள்ளது. நாம் நமக்கு சொந்தமாக கண்டுபிடிக்க வேண்டிய பல படிமுறைகள் இதுவேயாகும். அதனை செயற்படுத்து வதற்காகத்தான் பைதானின் requestsஎனும் தகவமைவு உள்ளது, இறுதியாக, requests.get என்பதன் வாயிலாக PAGE எனும் மாறியின். textfield இல் சேமிக்கப்பட்டுள்ள அனைத்தையும் print என பைத்தானுக்கு சொல்கின்றோம். Beautiful Soup
மேலே கூறிய மாதிரிக் குறிமுறைவரிகளை இயக்கினால், எடுத்துக்காட்டில் குறிப்பிட்டுள்ள URL இன் உள்ளடக்கங்கள் நம்முடைய முனையத்தில் ஏராளமாக கொண்டுவந்து கொட்டிவிடும். ஏன் அவ்வாறு செய்கிறது, ஏனெனில் சேகரிக்கப்பட்ட கோரிக்கைகளின் தரவுகளுடன் நம்முடைய குறிமுறைவரிகள் செய்யும் ஒரே செயல் அதை அச்சிடுவதுதான். அவ்வாறாக கொண்டுவந்து கொட்டிடும் உரையை அலசி ஆய்வுசெய்வது மிகவும் சுவாரஸ்யமானது. பைத்தானானது அதன் மிக அடிப்படையான செயலிகளின் உதவியுடன் உரையை “படிக்க” முடியும், ஆனால் உரையை பாகுபடுத்தி ஆய்வுசெய்து வடிவமைப்புகள், குறிப்பிட்ட சொற்கள், HTML குறிச்சொற்கள்,போன்ற பலவற்றைத் தேடிடவும் அனுமதிக்கிறது. requestsஇன்படி திருப்பி அனுப்பிய உரையை நாமே அலசி ஆய்வு செய்திடலாம், ஆனால் அதற்காக ஒரு சிறப்பு தகவமைவினை பயன்படுத்துவது மிகவும் எளிதானது. HTML, XML, ஆகியவற்றில் Beautiful Soupஇன் நூலகம் உள்ளது. இந்தக் குறிமுறைவரிகள் அதையே நிறைவேற்றுகிறது, ஆனால் பதிவிறக்கம் செய்யப்பட்ட உரையை அலசி ஆய்வுசெய்வதற்காக இது Beautiful Soupஐ பயன்படுத்தி கொள்கிறது. Beautiful Soup ஆனதுHTML நிறுவனங்களை அங்கீகரிப்பதால், அதன் உள்ளமைக்கப்பட்ட வசதிகளைப் பயன்படுத்தி, மனிதக் கண்களால் அலசி ஆய்வுசெய்வதற்குஏற்ப வெளியீட்டை சிறிது எளிதாக்கலாம். எடுத்துகாட்டாக, நிரலின் முடிவில் மூல உரையை அச்சிடுவதற்குப் பதிலாக, அதனை Beautiful Soup என்பதன். prettify எனும்செயலி மூலம் இயக்கலாம்அதற்கான குறிமுறைவரிகள்
frombs4importBeautifulSoup
import requests
PAGE=requests.get(“https://opensource.com/article/22/5/document-source-code-doxygen-linux”)
SOUP=BeautifulSoup(PAGE.text,’html.parser’)
# உரைநிரலை இயக்குவதற்காக gutter இன் பச்சைவண்ண பொத்தானை அழுத்துக
if__name__==’__main__’:
# do a thing here
print(SOUP.prettify())
நிரலின் இந்தப் பதிப்பின் வெளியீடு, ஒவ்வொரு துவக்க HTML குறிச்சொல்லும் அதன் சொந்த வரியில் துவங்குவதை உறுதிசெய்கிறது, எந்தக் குறிச்சொல் மற்றொரு குறிச்சொல்லின் பெற்றோர் என்பதை நிரூபிக்க உதவும். Beautiful Soup இன் HTML குறிச்சொற்களை எப்படி அச்சிடுகிறது என்பதைக் காட்டிலும் பல வழிகளில் அறிந்திருக்கிறது. முழுப் பக்கத்தையும் அச்சிடுவதற்குப் பதிலாக, ஒரு குறிப்பிட்ட வகையான குறிச்சொல்லைமட்டும் தனிமைப்படுத்தலாம். எடுத்துக் காட்டாக, print எனும் தேர்வியை மாற்ற முயற்சித்திடுக
fromprint(SOUP.prettify()to this:
print(SOUP.p)
இது a<p>tag எனும்ஒரு குறிச்சொல்லை மட்டுமே அச்சிடுகிறது. குறிப்பாக, இது எதிர்கொண்ட முதல் a<p>tag எனும் குறிச்சொல்லை மட்டுமே அச்சிடுகிறது. அனைத்து a<p>tag எனும் குறிச்சொற்களையும் அச்சிட, நமக்கு ஒரு மடக்கி தேவை யாகும் . மடக்கியானது Beautiful Soup இன் find_all எனும் செயலியைப் பயன்படுத்தி, SOUP எனும் மாறியில் உள்ள முழு வலைப்பக்கத்திலும் சுழற்சிக்கான மடக்கியை உருவாக்கிடுக. <p>tag தவிர மற்ற குறிச்சொற்களுக்கு நம்முடைய மடக்கியை பயன்படுத்த விரும்புவது நியாயமற்றது அன்று, எனவே பைத்தானில் உள்ள defkeyword (“define” க்கு) என்பதன் மூலம் நியமிக்கப்பட்ட தனிப்பயன் செயலியாக இதை பைதானில்உருவாக்கிடுக அதற்கான குறிமுறைவரிகள்.
defloopit():
forTAGinSOUP.find_all(‘p’):
print(TAG)
தற்காலிக மாறியான TAG என்பது தன்னிச்சையானது. ITEM அல்லது i என்பது போன்ற எந்தவொரு குறிச் சொல்லையும் பயன்படுத்திகொள்ளலாம். மடக்கி இயங்குகின்ற ஒவ்வொரு முறையும்,TAG find_allfunction இன் தேடல் முடிவுகள் கிடைத்துகொண்டே இருக்கும். இந்தக் குறிமுறைவரிகளில், <p>tag எனும் குறிச்சொல்லானது தேடப்படுகிறது. ஒரு செயலியானது வெளிப்படையாக அழைக்கப்படும் வரை இயங்காது. தேவையெனில் குறிமுறைவரிகளின் முடிவில் செயலியை நாமே அழைக்கலாம்:
# உரைநிரலை இயக்க, gutter இல் உள்ள பச்சை வண்ணபொத்தானை அழுத்திடுக
if__name__==’__main__’:
# do a thing here
loopit()
அனைத்து l<p>tags எனும் குறிச்சொற்களையும் ஒவவொன்றின் உள்ளடக்கத்தையும் காண்பதற்குஇந்த குறிமுறைவரிகளை இயக்கிடுக
உள்ளடக்கத்தை மட்டும் பெறுதல்
“string ” (“சொற்களுக்கள் words” என்பதற்கான நிரலாக்க மொழி) என்று குறிப்பிடுவதன் மூலம் குறிச்சொற்களை அச்சிடுவதைத் தவிர்க்கலாம்.
defloopit():
forTAGinSOUP.find_all(‘p’):
print(TAG.string)
உண்மையில் ஒரு இணையப்பக்கத்தின் உரையைப் பெற்றவுடன், நிலையான பைதான் சரங்களின்நூலகங்களுடன் அதை மேலும் அலசிஆய்வுசெய்திடலாம். எடுத்துகாட்டாக, lenandsplit என்பதைப் பயன்படுத்தி உரையிலுள்ள சொற்களின் எண்ணிக்கையைப் பெறலாம்:
defloopit():
forTAGinSOUP.find_all(‘p’):
ifTAG.stringisnotNone:
print(len(TAG.string.split()))
இது ஒவ்வொரு பத்தியிலுள்ள உறுப்புகளுக்குள்ளும் உள்ள சரங்களின் எண்ணிக்கையை அச்சிடுகிறது, எந்த சரங்களும் இல்லாத பத்திகளைத் தவிர்க்கிறது. மொத்தத்தைப் பெற, மாறி , சில அடிப்படைக் கணிதம் ஆகியவற்றைப் பயன்படுத்திகொள்க:
defloopit():
NUM=0
forTAGinSOUP.find_all(‘p’):
ifTAG.stringisnotNone:
NUM=NUM +len(TAG.string.split())
print(“Grand total is “,NUM)
முடிவாக Beautiful Soup, Python ஆகியவற்றின் மூலம் பிரித்தெடுக்கக்கூடிய பல தகவல்கள் உள்ளன. நம்முடைய பயன்பாட்டை எவ்வாறு மேம்படுத்துவது என்பது குறித்த சில ஆலோசனைகள் கூட உள்ளன: உள்ளீட்டை ஏற்பதன் மூலம் பயன்பாட்டைத் துவங்கிடும் போது எந்த URL ஐ பதிவிறக்கம் செய்து பகுப்பாய்வு செய்ய வேண்டும் என்பதைக் குறிப்பிடலாம்., ஒரு பக்கத்தில் உள்ள படங்களின் எண்ணிக்கையை (<img>tags)
எனும் குறிச்சொல்லை பயன்படுத்தி எண்ணி கணக்கிடுக., மற்றொரு வகையாக படங்களின் எண்ணிக்கையை (<img>tags) எனும் குறிச் சொல்லை பயன்படுத்தி எண்ணி கணக்கிடுக ( எடுத்துக்காட்டாக,<main>div இல் தோன்றும் படங்கள் மட்டும், அல்லது a</p>tag ஐப் பின்பற்றும் படங்கள் மட்டும்).