import requests
from bs4 import BeautifulSoup
 
# 发送HTTP请求
url = 'https://www.example.com'
response = requests.get(url)
 
# 检查请求是否成功
if response.status_code == 200:
    # 解析响应内容
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # 提取页面内容
    # 例如，提取所有的段落
    paragraphs = soup.find_all('p')
    for p in paragraphs:
        print(p.text)
else:
    print("请求网页失败，状态码：", response.status_code)

这段代码使用了requests库来发送HTTP GET请求，使用了bs4（BeautifulSoup4）库来解析HTML页面，并提取了页面中所有段落标签的文本内容。这是爬虫开发中最基础的步骤，为进一步开发更复杂的爬虫设置了基础。

import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class RegexExample {
    public static void main(String[] args) {
        String content = "这里是需要被检索的文本内容...";
        String regex = "正则表达式规则";
 
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(content);
 
        while (matcher.find()) {
            System.out.println("找到匹配项：" + matcher.group());
        }
    }
}

在这个例子中，我们首先导入了必要的java.util.regex包中的Pattern和Matcher类。然后定义了一个名为RegexExample的类，在其主方法中，我们定义了待搜索的文本content和用于匹配的正则表达式regex。接着，我们通过Pattern.compile()方法将正则表达式编译成一个Pattern对象，然后通过该模式对象的matcher()方法生成一个Matcher对象，用于在文本中查找匹配项。最后，我们使用matcher.find()方法来查找所有匹配项，并通过matcher.group()打印出每一个匹配到的内容。

import requests
from bs4 import BeautifulSoup
 
# 设置代理服务器
proxies = {
    'http': 'http://user:password@proxy.server.com:port',
    'https': 'https://user:password@proxy.server.com:port'
}
 
# 设置请求头
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'}
 
def get_html(url, proxies=None, headers=None):
    """
    获取网页HTML内容
    :param url: 网页链接
    :param proxies: 代理服务器（可选）
    :param headers: 请求头（可选）
    :return: 网页内容
    """
    response = requests.get(url, proxies=proxies, headers=headers)
    return response.text
 
def parse_html(html):
    """
    解析HTML内容
    :param html: 网页内容
    :return: 解析后的数据
    """
    soup = BeautifulSoup(html, 'html.parser')
    # 解析数据的代码放这里
    # 例如获取所有的段落
    paragraphs = soup.find_all('p')
    for p in paragraphs:
        print(p.text)
 
def main():
    url = 'http://example.com'  # 替换为目标网址
    html = get_html(url, proxies=proxies, headers=headers)
    parse_html(html)
 
if __name__ == '__main__':
    main()

这段代码提供了一个简单的网络爬虫框架，包括使用代理和请求头来发送HTTP请求，并使用BeautifulSoup进行网页内容的解析。开发者可以在parse_html函数中添加具体的解析逻辑来提取所需数据。

在Node.js中编写一个简单的爬虫，可以使用axios来发送HTTP请求，以及cheerio来解析返回的HTML内容。以下是一个简单的例子，用于抓取一个网页上的所有链接。

首先，确保安装了所需的包：

npm install axios cheerio

然后，编写爬虫代码：

const axios = require('axios');
const cheerio = require('cheerio');
 
async function fetchLinks(url) {
  try {
    const { data } = await axios.get(url);
    const $ = cheerio.load(data);
    const links = [];
 
    $('a').each((i, link) => {
      const href = $(link).attr('href');
      if (href) {
        links.push(href);
      }
    });
 
    console.log(links);
  } catch (error) {
    console.error('An error occurred:', error);
  }
}
 
// 使用示例
const url = 'https://example.com'; // 替换为你想抓取的网址
fetchLinks(url);

这段代码会输出指定网页上所有<a>标签的href属性。你可以根据需要修改选择器来抓取不同的内容。记得遵守网站的robots.txt规则和政策，尊重版权和法律，不要进行破坏性爬取。

import requests
from bs4 import BeautifulSoup
import time
 
def get_html(url):
    try:
        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, timeout=30)
        response.raise_for_status()
        response.encoding = response.apparent_encoding
        return response.text
    except Exception as e:
        print(f"An error occurred: {e}")
 
def parse_html(html):
    soup = BeautifulSoup(html, 'html.parser')
    return soup.find_all('div', class_='post-text')[0].text
 
def main():
    start_time = time.time()
    url = 'https://www.example.com/some-article'
    html = get_html(url)
    text = parse_html(html)
    print(f"The article text is: {text}")
    end_time = time.time()
    execution_time = end_time - start_time
    print(f"Execution time: {execution_time} seconds")
 
if __name__ == "__main__":
    main()

这段代码展示了如何使用Python的requests库和BeautifulSoup库高效地抓取网页数据。同时，代码中加入了异常处理和请求头信息，模拟了一个正规的网络请求，提高了爬虫的合法性和成功率。通过time模块，代码还可以统计爬取数据的耗时，为爬虫效率的评估提供数据支持。

以下是一个简单的Java单线程网页爬虫示例，使用java.net.HttpURLConnection进行网络请求。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
 
public class SimpleCrawler {
 
    public static void main(String[] args) {
        try {
            URL url = new URL("http://example.com"); // 替换为你想爬取的网页
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
 
            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String inputLine;
                StringBuilder content = new StringBuilder();
 
                while ((inputLine = in.readLine()) != null) {
                    content.append(inputLine);
                }
 
                in.close();
                connection.disconnect();
 
                // 打印网页内容
                System.out.println(content.toString());
            } else {
                System.out.println("GET request not worked");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这段代码创建了一个简单的单线程网页爬虫，它连接到指定的URL，发送GET请求，并打印出服务器响应的内容。这个例子没有处理更复杂的情况，比如多线程下载、处理重定向、处理cookies、处理Ajax加载的内容、爬取的深度控制等。

import os
import urllib3
 
# 初始化urllib3的PoolManager对象，用于处理HTTP请求
http = urllib3.PoolManager()
 
def download_image(url, file_path):
    """
    下载图片到本地
    :param url: 图片的URL
    :param file_path: 本地文件路径
    """
    response = http.request('GET', url)
    with open(file_path, 'wb') as file:
        file.write(response.data)
 
def get_image_urls(html_content):
    """
    提取HTML中的图片URL
    :param html_content: 下载的HTML内容
    :return: 图片URL列表
    """
    # 此处的正则表达式需要根据实际HTML结构进行调整
    import re
    image_urls = re.findall(r'https?://.*?\.(?:jpg|jpeg|gif|png)', html_content)
    return image_urls
 
def crawl_baidu_images(keyword, max_num):
    """
    爬取百度图片
    :param keyword: 搜索关键词
    :param max_num: 最大下载数量
    """
    # 构建搜索URL
    base_url = 'https://image.baidu.com/search/index?tn=baiduimage&word={}'
    url = base_url.format(urllib3.quote(keyword))
 
    # 下载HTML内容
    response = http.request('GET', url)
    html_content = response.data.decode()
 
    # 提取图片URLs
    image_urls = get_image_urls(html_content)
 
    # 创建文件夹
    os.makedirs('images', exist_ok=True)
 
    # 下载图片
    for i, image_url in enumerate(image_urls, 1):
        file_path = os.path.join('images', f'{i}.jpg')
        download_image(image_url, file_path)
        if i >= max_num:
            break
 
if __name__ == '__main__':
    crawl_baidu_images('美女', 50)  # 搜索关键词为“美女”，最多下载50张图片

这段代码首先导入了必要的模块，并初始化了一个urllib3的PoolManager对象。然后定义了两个辅助函数：download_image用于下载图片到本地，get_image_urls用于从HTML内容中提取图片URL。最后，crawl_baidu_images函数实现了主要的爬虫逻辑：构建URL、下载HTML内容、提取图片URLs，并循环下载图片。

注意：由于爬取行为可能违反目标服务器的robots.txt协议及条款，请在使用爬虫时确保你有权限和责任地进行网络爬取，并遵守相关法律法规。

import asyncio
import aiohttp
import trio
 
# 使用aiohttp的异步HTTP客户端
async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()
 
# 使用Trio的异步IO运行
def run_with_trio(coroutine):
    try:
        trio.run(coroutine)
    except KeyboardInterrupt:
        print("Execution cancelled by user")
 
async def main():
    async with aiohttp.ClientSession() as session:
        urls = ['http://example.com/{}'.format(i) for i in range(10)]
        tasks = [fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        for result in results:
            print(result)
 
if __name__ == '__main__':
    trio_coroutine = trio.run_in_thread(asyncio.run, main())
    run_with_trio(trio_coroutine)

这段代码展示了如何使用aiohttp和Trio来编写异步的网络请求代码。首先，我们定义了一个异步的fetch函数，它使用aiohttp库来发送HTTP请求并获取响应。然后，我们定义了一个主异步函数main，它使用aiohttp的ClientSession来发送多个请求并收集结果。最后，我们通过Trio来运行这个异步函数，确保在整个过程中有良好的异步处理和异常管理。

import requests
 
def login_to_website(username, password):
    """使用 Session 对象模拟用户登录"""
    # 创建一个 Session 对象
    session = requests.Session()
 
    # 登录的 URL
    login_url = 'http://example.com/login'
 
    # 用户输入的登录信息
    login_data = {
        'username': username,
        'password': password,
        # 如果需要，还可以包含其他登录所需的数据
    }
 
    # 发送登录请求
    response = session.post(login_url, data=login_data)
 
    # 检查是否登录成功
    if response.ok:
        print('登录成功')
        # 登录成功后，session 对象会保存会话信息，之后可以用它来发送需要登录才能访问的请求
        return session
    else:
        print('登录失败')
        return None
 
# 用户的登录信息
username = 'your_username'
password = 'your_password'
 
# 获取登录后的 Session 对象
session = login_to_website(username, password)
 
# 如果登录成功，可以用 session 对象来发送后续的请求
if session:
    # 示例：获取登录后的用户信息
    user_info_url = 'http://example.com/userinfo'
    response = session.get(user_info_url)
    if response.ok:
        print('用户信息:', response.text)
    else:
        print('获取用户信息失败')

这段代码首先定义了一个函数login_to_website，它接受用户名和密码作为参数，使用requests.Session()创建一个Session对象，然后发送一个POST请求来尝试登录。登录成功后，会返回这个Session对象，之后可以用这个对象来发送需要登录的请求。在实际使用中，需要替换登录URL和登录所需的数据以适应特定的网站。

from mitmproxy import ctx
 
def response(flow):
    # 只处理图片请求
    if flow.response.headers.get('Content-Type', '').startswith('image'):
        # 保存图片到本地
        with open(f'image_{flow.id}.png', 'wb') as f:
            f.write(flow.response.content)
        # 打印图片保存路径
        ctx.log.info(f"保存图片到: image_{flow.id}.png")

这段代码定义了一个mitmproxy的response处理函数，用于只保存服务器响应的图片资源。它检查每个响应的Content-Type头是否以'image'开头，如果是，则将图片内容写入本地文件，并打印保存路径。这是一个简单的示例，展示了如何使用mitmproxy来处理特定类型的响应数据。