Teknik Mengikis Web Asynchronous lanjutan dalam Python untuk Kepantasan dan Kecekapan

Sebagai pengarang terlaris, saya menjemput anda untuk menerokai buku saya di Amazon. Jangan lupa ikuti saya di Medium dan tunjukkan sokongan anda. terima kasih! Sokongan anda bermakna dunia!

Pengikisan web telah menjadi alat penting untuk pengekstrakan dan analisis data dalam era digital. Memandangkan jumlah maklumat dalam talian terus berkembang, keperluan untuk teknik mengikis yang cekap dan berskala telah menjadi yang terpenting. Python, dengan ekosistem perpustakaan dan rangka kerjanya yang kaya, menawarkan penyelesaian yang berkuasa untuk pengikisan web tak segerak. Dalam artikel ini, saya akan meneroka enam teknik lanjutan yang memanfaatkan pengaturcaraan tak segerak untuk meningkatkan kelajuan dan kecekapan operasi mengikis web.

Pengaturcaraan tak segerak membolehkan pelaksanaan serentak berbilang tugas, menjadikannya sesuai untuk mengikis web di mana kita sering perlu mengambil data daripada pelbagai sumber secara serentak. Dengan menggunakan teknik tak segerak, kami boleh mengurangkan dengan ketara masa yang diperlukan untuk mengumpul sejumlah besar data daripada web.

Mari kita mulakan dengan aiohttp, perpustakaan yang berkuasa untuk membuat permintaan HTTP tak segerak. aiohttp menyediakan cara yang cekap untuk menghantar berbilang permintaan secara serentak, yang penting untuk operasi mengikis web berskala besar. Berikut ialah contoh cara menggunakan aiohttp untuk mengambil berbilang halaman web secara serentak:

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = ['https://example.com', 'https://example.org', 'https://example.net']
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        responses = await asyncio.gather(*tasks)
        for response in responses:
            print(len(response))

asyncio.run(main())

Dalam contoh ini, kami mencipta pengambilan fungsi tak segerak yang mengambil sesi dan URL sebagai parameter. Fungsi utama mencipta senarai tugas menggunakan pemahaman senarai, dan kemudian menggunakan asyncio.gather untuk menjalankan semua tugas secara serentak. Pendekatan ini membolehkan kami mengambil berbilang halaman web secara selari, dengan ketara mengurangkan masa keseluruhan yang diperlukan untuk operasi.

Seterusnya, mari kita terokai cara kita boleh menyepadukan BeautifulSoup dengan persediaan mengikis tak segerak kami. BeautifulSoup ialah perpustakaan popular untuk menghuraikan dokumen HTML dan XML. Walaupun BeautifulSoup sendiri bukan tak segerak, kami boleh menggunakannya bersama dengan aiohttp untuk menghuraikan kandungan HTML yang kami ambil secara tidak segerak:

import aiohttp
import asyncio
from bs4 import BeautifulSoup

async def fetch_and_parse(session, url):
    async with session.get(url) as response:
        html = await response.text()
        soup = BeautifulSoup(html, 'html.parser')
        return soup.title.string if soup.title else "No title found"

async def main():
    urls = ['https://example.com', 'https://example.org', 'https://example.net']
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_and_parse(session, url) for url in urls]
        titles = await asyncio.gather(*tasks)
        for url, title in zip(urls, titles):
            print(f"{url}: {title}")

asyncio.run(main())

Dalam contoh ini, kami telah mengubah suai fungsi pengambilan kami untuk memasukkan penghuraian dengan BeautifulSoup. Fungsi fetch_and_parse kini mengembalikan tajuk setiap halaman web, menunjukkan cara kami boleh mengekstrak maklumat tertentu daripada kandungan HTML secara tidak segerak.

Apabila berurusan dengan sejumlah besar data yang dikikis, selalunya perlu untuk menyimpan maklumat ke fail. aiofiles ialah perpustakaan yang menyediakan antara muka tak segerak untuk operasi I/O fail. Begini cara kami boleh menggunakan aiofiles untuk menyimpan data kami yang dikikis secara tidak segerak:

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = ['https://example.com', 'https://example.org', 'https://example.net']
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        responses = await asyncio.gather(*tasks)
        for response in responses:
            print(len(response))

asyncio.run(main())

Skrip ini mengambil kandungan HTML, mengekstrak tajuk dan menyimpannya ke fail, semuanya secara tidak segerak. Pendekatan ini amat berguna apabila berurusan dengan set data besar yang perlu diteruskan ke cakera.

Untuk tugas mengikis web yang lebih kompleks, rangka kerja Scrapy menawarkan penyelesaian yang teguh dan berskala. Scrapy dibina dengan pengaturcaraan tak segerak pada terasnya, menjadikannya pilihan terbaik untuk projek merangkak dan mengikis web berskala besar. Berikut ialah contoh mudah labah-labah Scrapy:

import aiohttp
import asyncio
from bs4 import BeautifulSoup

async def fetch_and_parse(session, url):
    async with session.get(url) as response:
        html = await response.text()
        soup = BeautifulSoup(html, 'html.parser')
        return soup.title.string if soup.title else "No title found"

async def main():
    urls = ['https://example.com', 'https://example.org', 'https://example.net']
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_and_parse(session, url) for url in urls]
        titles = await asyncio.gather(*tasks)
        for url, title in zip(urls, titles):
            print(f"{url}: {title}")

asyncio.run(main())

Untuk menjalankan labah-labah ini, anda biasanya menggunakan alat baris arahan Scrapy. Scrapy mengendalikan sifat tak segerak permintaan web secara dalaman, membolehkan anda menumpukan pada mentakrifkan logik penghuraian.

Apabila melakukan pengikisan web secara berskala, adalah penting untuk melaksanakan pengehadan kadar untuk mengelakkan keterlaluan pelayan sasaran dan menghormati fail robots.txt mereka. Berikut ialah contoh cara kami boleh melaksanakan pengehadan kadar dalam pengikis tak segerak kami:

import aiohttp
import asyncio
import aiofiles
from bs4 import BeautifulSoup

async def fetch_and_save(session, url, filename):
    async with session.get(url) as response:
        html = await response.text()
        soup = BeautifulSoup(html, 'html.parser')
        title = soup.title.string if soup.title else "No title found"
        async with aiofiles.open(filename, 'w') as f:
            await f.write(f"{url}: {title}\n")
        return title

async def main():
    urls = ['https://example.com', 'https://example.org', 'https://example.net']
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_and_save(session, url, f"title_{i}.txt") for i, url in enumerate(urls)]
        titles = await asyncio.gather(*tasks)
        for url, title in zip(urls, titles):
            print(f"Saved: {url} - {title}")

asyncio.run(main())

Dalam contoh ini, kami menggunakan perpustakaan aiolimiter untuk mencipta pengehad kadar yang membenarkan satu permintaan sesaat. Ini memastikan pengikis kami tidak menghantar permintaan terlalu cepat, yang boleh menyebabkan disekat oleh tapak web sasaran.

Pengendalian ralat ialah satu lagi aspek kritikal pengikisan web yang mantap. Apabila berurusan dengan berbilang permintaan tak segerak, adalah penting untuk mengendalikan pengecualian dengan anggun untuk mengelakkan satu permintaan yang gagal daripada menghentikan keseluruhan proses mengikis. Berikut ialah contoh cara kami boleh melaksanakan pengendalian ralat dan cuba semula:

import scrapy

class TitleSpider(scrapy.Spider):
    name = 'title_spider'
    start_urls = ['https://example.com', 'https://example.org', 'https://example.net']

    def parse(self, response):
        yield {
            'url': response.url,
            'title': response.css('title::text').get()
        }

Skrip ini melaksanakan mekanisme cuba semula dengan penyingkiran eksponen, yang membantu menangani isu rangkaian sementara atau ralat pelayan. Ia juga menetapkan tamat masa untuk setiap permintaan untuk mengelakkan penangguhan pada respons perlahan.

Untuk operasi mengikis berskala besar, anda mungkin perlu mengagihkan beban kerja pada berbilang mesin. Walaupun butiran pengikisan yang diedarkan berada di luar skop artikel ini, anda boleh menggunakan alat seperti Saderi dengan Redis atau RabbitMQ untuk mengagihkan tugas mengikis merentas sekumpulan mesin pekerja.

Semasa kami mengakhiri penerokaan teknik mengikis web tak segerak dalam Python, adalah penting untuk menekankan kepentingan amalan pengikisan beretika. Sentiasa semak dan hormati fail robots.txt tapak web yang anda sedang mengikis dan pertimbangkan untuk menghubungi pemilik tapak web untuk mendapatkan kebenaran semasa menjalankan operasi mengikis secara besar-besaran.

Pengikisan web tak segerak menawarkan peningkatan prestasi yang ketara berbanding kaedah segerak tradisional, terutamanya apabila berurusan dengan sejumlah besar halaman web atau API. Dengan memanfaatkan teknik yang telah kami bincangkan – menggunakan aiohttp untuk permintaan serentak, menyepadukan BeautifulSoup untuk menghurai, menggunakan aiofiles untuk operasi fail tanpa menyekat, menggunakan Scrapy untuk tugas mengikis yang kompleks, melaksanakan pengehadan kadar dan mengendalikan ralat dengan mantap – anda boleh membina kuat dan penyelesaian mengikis web yang cekap.

Memandangkan web terus berkembang dan berkembang, begitu juga teknik dan alatan yang tersedia untuk mengikis web. Mengikuti perkembangan terkini dengan perpustakaan terkini dan amalan terbaik akan memastikan projek mengikis web anda kekal cekap, berskala dan menghormati tapak web yang berinteraksi dengan anda.

---

101 Buku

101 Buku ialah syarikat penerbitan dipacu AI yang diasaskan bersama oleh pengarang Aarav Joshi. Dengan memanfaatkan teknologi AI termaju, kami memastikan kos penerbitan kami sangat rendah—sesetengah buku berharga serendah $4—menjadikan pengetahuan berkualiti boleh diakses oleh semua orang.

Lihat buku kami Kod Bersih Golang tersedia di Amazon.

Nantikan kemas kini dan berita menarik. Apabila membeli-belah untuk buku, cari Aarav Joshi untuk mencari lebih banyak tajuk kami. Gunakan pautan yang disediakan untuk menikmati diskaun istimewa!

Ciptaan Kami

Pastikan anda melihat ciptaan kami:

Pusat Pelabur | Pelabur Central Spanish | Pelabur Jerman Tengah | Hidup Pintar | Epos & Gema | Misteri Membingungkan | Hindutva | Pembangunan Elit | Sekolah JS

---

Kami berada di Medium

Tech Koala Insights | Dunia Epok & Gema | Medium Pusat Pelabur | Medium Misteri Membingungkan | Sains & Zaman Sederhana | Hindutva Moden

Atas ialah kandungan terperinci Teknik Mengikis Web Asynchronous lanjutan dalam Python untuk Kepantasan dan Kecekapan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!