首页手记爬虫突破反爬学习：新手入门教程

爬虫突破反爬学习：新手入门教程

标签：

Python 人工智能爬虫

概述

本文详细介绍了爬虫的基础概念和工作原理，涵盖了常用的爬虫工具及常见反爬机制，如IP封禁和验证码。文章还提供了多种破解反爬策略的方法和示例代码，帮助读者理解如何进行爬虫突破反爬学习。

爬虫基础概念及工作原理

什么是爬虫

爬虫，即网络爬虫或网页爬虫，是一种自动化程序，用于抓取互联网上的信息。它通过模拟浏览器的行为，自动访问网站并获取网页内容。爬虫在搜索引擎、数据挖掘、市场分析等领域有着广泛的应用。

爬虫的工作流程

爬虫的工作流程可以分为以下几个步骤：

URL管理：管理爬取的URL，包括待爬取的URL和已经爬取过的URL。
请求发送：向目标网站发送HTTP请求，获取网页内容。
内容解析：解析获取到的网页内容，提取所需的数据。
数据存储：将提取的数据存储到数据库或其他格式中。
异常处理：处理爬取过程中可能出现的异常，如网络请求失败、服务器错误等。

示例代码

以下是一个简单的Python爬虫示例，使用requests库获取网页内容，并使用BeautifulSoup解析HTML。

import requests
from bs4 import BeautifulSoup

def fetch_and_parse(url):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        return soup
    else:
        print(f"Failed to fetch {url}, status code: {response.status_code}")
        return None

if __name__ == "__main__":
    url = "https://www.example.com"
    soup = fetch_and_parse(url)
    if soup:
        print(soup.prettify())

常用爬虫工具介绍

Python的`requests`和`beautifulsoup`库

用途：用于发起HTTP请求和解析HTML。

示例代码


import requests
from bs4 import BeautifulSoup

def fetch_and_parse(url):
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
response = requests.get(url, headers=headers)
if response.status_code == 200:
soup = BeautifulSoup(response.text, 'html.parser')
return soup
else:
print(f"Failed to fetch {url}, status code: {response.status_code}")
return None

if name == "main":
url = "https://www.example.com"
soup = fetch_and_parse(url)
if soup:
print(soup.prettify())


### Scrapy
- **用途**：一个高级的Python爬虫框架，提供了一整套工具来帮助构建和维护爬虫，支持分布式爬取。
- **示例代码**
```python
import scrapy

class ExampleSpider(scrapy.Spider):
    name = 'example'
    start_urls = ['https://www.example.com']

    def parse(self, response):
        for title in response.css('title::text'):
            yield {'title': title.extract()}

Selenium

用途：一个浏览器自动化工具，支持JavaScript渲染及动态加载内容。

示例代码


from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def fetch_dynamic_content(url):
driver = webdriver.Chrome()
driver.get(url)
try:
WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.ID, "dynamic-content"))
)
content = driver.find_element(By.ID, "dynamic-content").text
return content
finally:
driver.quit()

if name == "main":
url = "https://www.example.com"
content = fetch_dynamic_content(url)
print(content)


### HttpClient
- **用途**：Java中的HTTP客户端库，用于发起HTTP请求。
- **示例代码**
```java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class SimpleHttpClient {
    public static void main(String[] args) throws Exception {
        URL url = new URL("https://www.example.com");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String inputLine;
        StringBuilder content = new StringBuilder();
        while ((inputLine = in.readLine()) != null) {
            content.append(inputLine);
        }
        in.close();
        System.out.println(content.toString());
    }
}

Jsoup

用途：一个Java库，用于解析和操作HTML文档。

示例代码


import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

public class SimpleJsoup {
public static void main(String[] args) {
String html = "<html><head><title>Title</title></head><body><p>Paragraph</p></body></html>";
Document doc = Jsoup.parse(html);
Elements elements = doc.select("title");
for (Element element : elements) {
System.out.println(element.text());
}
}
}


# 常见反爬机制
## IP封禁
IP封禁是指网站通过记录爬虫频繁访问的IP地址，并在一定时间内禁止该IP地址的访问。常见的封禁策略有：
- **黑名单**：将被封禁的IP地址加入黑名单。
- **验证码**：要求爬虫请求时提交验证码，增加爬取难度。

### 示例代码
示例代码展示如何使用代理IP池避免IP被封禁。

```python
import requests
from bs4 import BeautifulSoup
import random

def fetch_and_parse_with_proxy(url, proxy_list):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    proxy = random.choice(proxy_list)
    proxies = {
        'http': proxy,
        'https': proxy
    }
    response = requests.get(url, headers=headers, proxies=proxies)
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        return soup
    else:
        print(f"Failed to fetch {url}, status code: {response.status_code}")
        return None

if __name__ == "__main__":
    url = "https://www.example.com"
    proxy_list = ['http://123.123.123.123:8080', 'http://123.123.123.124:8080']
    soup = fetch_and_parse_with_proxy(url, proxy_list)
    if soup:
        print(soup.prettify())

频率限制

频率限制是指网站通过限制请求的发送频率来防止爬虫。常见的频率限制策略有：

延迟请求：增加请求之间的间隔时间。
随机请求：随机化每次请求的时间，以更加模拟真实用户的行为。
请求头：通过发送不同的请求头来模拟不同的用户。

示例代码

示例代码展示如何通过延迟请求避免频率限制。

import time
import requests
from bs4 import BeautifulSoup

def fetch_and_parse_with_delay(url, delay):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    response = requests.get(url, headers=headers)
    time.sleep(delay)  # 延迟请求
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        return soup
    else:
        print(f"Failed to fetch {url}, status code: {response.status_code}")
        return None

if __name__ == "__main__":
    url = "https://www.example.com"
    soup = fetch_and_parse_with_delay(url, 1)  # 延迟1秒
    if soup:
        print(soup.prettify())

验证码

验证码是一种常见的反爬手段。网站通过要求用户输入验证码来验证是否为真实用户。常见的验证码类型有：

图形验证码：需要用户识别图片中的文字或图案。
滑块验证码：用户需要将滑块拖动到指定位置。
音频验证码：用户需要听音频并输入听到的文字。

示例代码

示例代码展示如何使用滑块验证码的通用处理方法。

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def handle_slider_captcha(url):
    driver = webdriver.Chrome()
    driver.get(url)
    try:
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "captcha"))
        )
        captcha_element = driver.find_element(By.ID, "captcha")
        # 处理滑块验证码的具体逻辑
        # 通常需要定位到滑块元素并执行拖动操作
        # 这里假设我们使用某种方法处理了验证码
        captcha_element.drag_and_drop(By.ID, "target")
        time.sleep(2)  # 等待验证码处理完成
    finally:
        driver.quit()

if __name__ == "__main__":
    url = "https://www.example.com"
    handle_slider_captcha(url)

示例代码

示例代码展示如何处理图形验证码。

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import pytesseract

def handle_image_captcha(url):
    driver = webdriver.Chrome()
    driver.get(url)
    try:
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "captcha-image"))
        )
        captcha_image = driver.find_element(By.ID, "captcha-image").screenshot("captcha.png")
        captcha_text = pytesseract.image_to_string("captcha.png")
        # 输入验证码的具体逻辑
        driver.find_element(By.ID, "captcha-text").send_keys(captcha_text)
        time.sleep(2)  # 等待验证码处理完成
    finally:
        driver.quit()

if __name__ == "__main__":
    url = "https://www.example.com"
    handle_image_captcha(url)

JS动态加载

JS动态加载是指网站通过JavaScript动态加载部分内容，使得静态爬虫难以抓取。常见的处理方法有：

使用Selenium：通过浏览器自动化抓取动态内容。
使用无头浏览器：像PhantomJS、Puppeteer等无头浏览器，可以模拟浏览器环境，抓取动态内容。

示例代码

示例代码展示如何使用Selenium抓取动态加载的内容。

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def fetch_dynamic_content(url):
    driver = webdriver.Chrome()
    driver.get(url)
    try:
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "dynamic-content"))
        )
        content = driver.find_element(By.ID, "dynamic-content").text
        return content
    finally:
        driver.quit()

if __name__ == "__main__":
    url = "https://www.example.com"
    content = fetch_dynamic_content(url)
    print(content)

破解反爬策略

使用代理IP池

通过使用代理IP池，可以有效避免IP被封禁。代理IP池可以动态切换不同的IP地址，模拟真实用户的行为。

示例代码

示例代码展示如何使用代理IP池。

import requests
from bs4 import BeautifulSoup
import random

def fetch_and_parse_with_proxy(url, proxy_list):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    proxy = random.choice(proxy_list)
    proxies = {
        'http': proxy,
        'https': proxy
    }
    response = requests.get(url, headers=headers, proxies=proxies)
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        return soup
    else:
        print(f"Failed to fetch {url}, status code: {response.status_code}")
        return None

if __name__ == "__main__":
    url = "https://www.example.com"
    proxy_list = ['http://123.123.123.123:8080', 'http://123.123.123.124:8080']
    soup = fetch_and_parse_with_proxy(url, proxy_list)
    if soup:
        print(soup.prettify())

设置合理的请求频率

通过设置合理的请求频率，可以有效避免频率限制。可以通过增加请求间隔时间或引入随机性来模拟真实用户的行为。

示例代码

示例代码展示如何设置合理的请求频率。

import time
import requests
from bs4 import BeautifulSoup

def fetch_and_parse_with_delay(url, delay):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    response = requests.get(url, headers=headers)
    time.sleep(delay)  # 延迟请求
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        return soup
    else:
        print(f"Failed to fetch {url}, status code: {response.status_code}")
        return None

if __name__ == "__main__":
    url = "https://www.example.com"
    soup = fetch_and_parse_with_delay(url, 1)  # 延迟1秒
    if soup:
        print(soup.prettify())

解决验证码问题

通过模拟用户行为，可以有效解决验证码问题。常见的方法有使用Selenium抓取动态内容，通过识别滑块验证码等方式。

示例代码

示例代码展示如何使用Selenium抓取动态加载的内容并处理滑块验证码。

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def handle_slider_captcha(url):
    driver = webdriver.Chrome()
    driver.get(url)
    try:
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "captcha"))
        )
        captcha_element = driver.find_element(By.ID, "captcha")
        # 处理滑块验证码的具体逻辑
        # 通常需要定位到滑块元素并执行拖动操作
        # 这里假设我们使用某种方法处理了验证码
        captcha_element.drag_and_drop(By.ID, "target")
        time.sleep(2)  # 等待验证码处理完成
    finally:
        driver.quit()

def fetch_dynamic_content(url):
    driver = webdriver.Chrome()
    driver.get(url)
    try:
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "dynamic-content"))
        )
        content = driver.find_element(By.ID, "dynamic-content").text
        return content
    finally:
        driver.quit()

if __name__ == "__main__":
    url = "https://www.example.com"
    handle_slider_captcha(url)
    content = fetch_dynamic_content(url)
    print(content)

示例代码

示例代码展示如何处理图形验证码。

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import pytesseract

def handle_image_captcha(url):
    driver = webdriver.Chrome()
    driver.get(url)
    try:
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "captcha-image"))
        )
        captcha_image = driver.find_element(By.ID, "captcha-image").screenshot("captcha.png")
        captcha_text = pytesseract.image_to_string("captcha.png")
        # 输入验证码的具体逻辑
        driver.find_element(By.ID, "captcha-text").send_keys(captcha_text)
        time.sleep(2)  # 等待验证码处理完成
    finally:
        driver.quit()

if __name__ == "__main__":
    url = "https://www.example.com"
    handle_image_captcha(url)

处理JS动态加载数据

通过使用Selenium或者无头浏览器，可以有效处理JS动态加载数据。Selenium可以模拟浏览器环境，抓取动态加载的内容。

示例代码

示例代码展示如何使用Selenium抓取动态加载的内容。

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def fetch_dynamic_content(url):
    driver = webdriver.Chrome()
    driver.get(url)
    try:
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "dynamic-content"))
        )
        content = driver.find_element(By.ID, "dynamic-content").text
        return content
    finally:
        driver.quit()

if __name__ == "__main__":
    url = "https://www.example.com"
    content = fetch_dynamic_content(url)
    print(content)

爬虫的法律与道德规范

法律风险

爬虫可能会涉及以下法律风险：

隐私权：爬取个人信息可能会侵犯隐私权。
版权法：爬取受版权保护的内容可能会侵犯版权。
数据泄露：爬取敏感数据可能会导致数据泄露。
商业秘密：爬取商业秘密信息可能会侵犯商业秘密。
网站协议：爬取网站时需要遵守网站的使用协议和隐私政策。

道德规范

爬虫的使用需要遵循以下道德规范：

尊重隐私：不要爬取个人敏感信息，如姓名、住址、电话号码等。
尊重版权：不要爬取受版权保护的内容。
尊重数据：不要爬取和利用敏感数据，如银行账号、身份证号等。
尊重商业秘密：不要爬取和利用商业秘密信息。
遵守网站协议：遵守网站的使用协议和隐私政策。

合理使用爬虫

合理使用爬虫可以遵循以下原则：

合法合规：确保爬取的内容在法律范围内。
透明公开：明确告知网站所有者，获得必要的许可。
最小化影响：尽量减少对网站的影响，避免频繁请求。
合理存储：合理使用和存储爬取的数据，避免泄露。
遵守规范：遵守道德规范，尊重隐私、版权、商业秘密等。

示例代码

示例代码展示如何获取网页标题并存储到数据库。

import requests
from bs4 import BeautifulSoup
import sqlite3

def fetch_and_parse(url):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        title = soup.find('title').text
        return title
    else:
        print(f"Failed to fetch {url}, status code: {response.status_code}")
        return None

def store_data(title):
    conn = sqlite3.connect('example.db')
    c = conn.cursor()
    c.execute('''CREATE TABLE IF NOT EXISTS pages (title text)''')
    c.execute("INSERT INTO pages VALUES (?)", (title,))
    conn.commit()
    conn.close()

if __name__ == "__main__":
    url = "https://www.example.com"
    title = fetch_and_parse(url)
    if title:
        store_data(title)

实战案例分析

从简单的网页爬取开始

从简单的网页爬取开始，可以帮助我们理解爬虫的基础概念和工作流程。以下是一个简单的网页爬取案例。

示例代码

示例代码展示如何从一个简单的网页获取标题。

import requests
from bs4 import BeautifulSoup

def fetch_and_parse(url):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        title = soup.find('title').text
        return title
    else:
        print(f"Failed to fetch {url}, status code: {response.status_code}")
        return None

if __name__ == "__main__":
    url = "https://www.example.com"
    title = fetch_and_parse(url)
    if title:
        print(title)

到实现一个简单的反爬突破案例

通过实现一个简单的反爬突破案例，可以更好地理解反爬手段和破解策略。以下是一个简单的IP封禁突破案例。

示例代码

示例代码展示如何通过代理IP池突破IP封禁。

import requests
from bs4 import BeautifulSoup
import random

def fetch_and_parse_with_proxy(url, proxy_list):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    proxy = random.choice(proxy_list)
    proxies = {
        'http': proxy,
        'https': proxy
    }
    response = requests.get(url, headers=headers, proxies=proxies)
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        return soup
    else:
        print(f"Failed to fetch {url}, status code: {response.status_code}")
        return None

if __name__ == "__main__":
    url = "https://www.example.com"
    proxy_list = ['http://123.123.123.123:8080', 'http://123.123.123.124:8080']
    soup = fetch_and_parse_with_proxy(url, proxy_list)
    if soup:
        print(soup.prettify())

实现一个更复杂的反爬突破案例

通过实现一个更复杂的反爬突破案例，可以更好地理解更复杂的反爬手段。以下是一个结合了IP封禁突破和验证码处理的案例。

示例代码

示例代码展示如何处理滑块验证码并使用代理IP池。

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def handle_slider_captcha(url):
    driver = webdriver.Chrome()
    driver.get(url)
    try:
        WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "captcha"))
        )
        captcha_element = driver.find_element(By.ID, "captcha")
        # 处理滑块验证码的具体逻辑
        # 这里假设我们使用某种方法处理了验证码
        captcha_element.drag_and_drop(By.ID, "target")
        time.sleep(2)  # 等待验证码处理完成
    finally:
        driver.quit()

def fetch_and_parse_with_proxy(url, proxy_list):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
    proxy = random.choice(proxy_list)
    proxies = {
        'http': proxy,
        'https': proxy
    }
    response = requests.get(url, headers=headers, proxies=proxies)
    if response.status_code == 200:
        soup = BeautifulSoup(response.text, 'html.parser')
        return soup
    else:
        print(f"Failed to fetch {url}, status code: {response.status_code}")
        return None

if __name__ == "__main__":
    url = "https://www.example.com"
    handle_slider_captcha(url)
    proxy_list = ['http://123.123.123.123:8080', 'http://123.123.123.124:8080']
    soup = fetch_and_parse_with_proxy(url, proxy_list)
    if soup:
        print(soup.prettify())

进阶学习资源推荐

相关书籍推荐

《Python网络爬虫开发与项目实战》：深入讲解Python网络爬虫的开发，并提供实战案例。
《Scrapy实战》：详细介绍Scrapy框架的使用方法和实战技巧。
《Selenium自动化测试实战》：讲解使用Selenium进行网页自动化测试的方法。

在线课程及社区推荐

慕课网：提供丰富的Python爬虫课程和实战项目。
Stack Overflow：提供爬虫开发过程中的常见问题解答。
GitHub：可以找到开源的爬虫项目，学习借鉴。
Reddit：提供爬虫开发的讨论和交流平台。
知乎：提供爬虫开发的相关讨论和问答。

以上就是关于爬虫突破反爬的学习教程，希望对你有所帮助。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

12345678_0001

学生

手记
篇

粉丝

13

获赞与收藏

47

关注作者，订阅最新文章

阅读免费教程

Python 办公自动化教程

17个小节 25773 875

Python 算法入门教程

15个小节 27469 1075

Python 进阶应用教程

38个小节 65895 1036

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

爬虫突破反爬学习：新手入门教程

示例代码

Python的requests和beautifulsoup库

Selenium

Jsoup

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

阅读免费教程

Python的`requests`和`beautifulsoup`库