import requests
from bs4 import BeautifulSoup
import re
 
# 视频下载函数
def download_video(url, filename):
    response = requests.get(url, stream=True)
    with open(filename, 'wb') as f:
        for chunk in response.iter_content(chunk_size=1024):
            if chunk:
                f.write(chunk)
    print(f"视频 {filename} 已保存。")
 
# 主函数
def main(url):
    res = requests.get(url)
    soup = BeautifulSoup(res.text, 'html.parser')
    video_tags = soup.find_all('source')
    video_urls =  for video in video_tags]
    video_urls = [re.sub(r'\\', '', url) for url in video_urls]  # 处理Windows路径问题
    for url in video_urls:
        filename = url.split('/')[-1]
        download_video(url, filename)
 
# 使用方法: 网页url
main('http://www.example.com/videos')

这段代码使用了requests库来发送HTTP请求，BeautifulSoup来解析HTML，以及re库来处理正则表达式。代码中的download_video函数负责实际下载视频，而main函数负责提取视频链接并调用download_video函数进行下载。使用时只需要将'http://www.example.com/videos'替换为目标网页的URL。

为了使用Python和xxl-job构建爬虫系统，你需要遵循以下步骤：

1. 安装xxl-job-executor-python：

pip install xxl-job-executor-python

2. 配置XXL-JOB调度中心。
3. 创建Python脚本使用XXL-JOB执行器执行爬虫任务：

from xxl_job_executor import XxlJobExecutor
 
def my_spider_task(executor, job_params):
    # 这里编写你的爬虫代码
    print("正在运行爬虫任务...")
    # 爬虫代码...
    return "爬虫任务完成"
 
# 初始化XxlJobExecutor
executor = XxlJobExecutor()
# 注册任务处理器
executor.start_worker(job_handler="spiderJobHandler",
                      init_func=my_spider_task)

4. 在XXL-JOB管理界面创建任务，指定执行器，并设置调度策略。
5. 运行Python脚本启动爬虫任务执行器。

注意：这只是一个框架，你需要根据实际的爬虫需求来编写爬虫任务代码。此外，确保你的爬虫遵循网站的robots.txt规则，不进行对网站数据造成不良影响的爬取。

import requests
import re
 
def login_to_tianyancha(username, password):
    # 登录接口URL
    login_url = 'https://passport.tianyancha.com/login'
    session = requests.session()
 
    # 获取登录时需要的加密参数
    result = session.get(login_url)
    execution = re.search('"execution":"(.*?)"', result.text).group(1)
    _event_id = re.search('_event_id:"(.*?)"', result.text).group(1)
 
    # 登录数据
    login_data = {
        'username': username,
        'password': password,
        'execution': execution,
        '_event_id': _event_id,
        'lt': ''
    }
 
    # 发送登录请求
    login_response = session.post(login_url, data=login_data)
 
    # 登录成功后，获取token
    token = re.search('"token":"(.*?)"', login_response.text).group(1)
    print(f'登录成功，获取到的token: {token}')
    return token, session
 
# 使用示例
username = 'your_username'
password = 'your_password'
token, session = login_to_tianyancha(username, password)

在这段代码中，我们首先定义了一个函数login_to_tianyancha，它接受用户名和密码作为参数，使用requests库来管理会话，并通过正则表达式解析登录页面中的关键参数。然后，我们构建登录数据并发送POST请求进行登录。登录成功后，我们再次使用正则表达式提取token。最后，我们返回token和包含登录状态的会话对象。

import requests
from bs4 import BeautifulSoup
import pandas as pd
import matplotlib.pyplot as plt
 
# 请求URL获取页面内容
def get_page(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)
    return response.text
 
# 解析页面数据
def parse_data(html):
    soup = BeautifulSoup(html, 'lxml')
    movie_list = soup.find_all('div', class_='info')
    for movie in movie_list:
        yield {
            '排名': movie.find('em').text,
            '电影名': movie.find('span', class_='title').text,
            '评分': movie.find('rating_num').text,
            '评分人数': movie.find('span', class_='rating_people').text[3:-3]
        }
 
# 保存数据到CSV
def save_to_csv(data, filename):
    df = pd.DataFrame(data)
    df.to_csv(filename + '.csv', index=False, encoding='utf-8-sig')
 
# 绘制电影评分的直方图
def plot_histogram(data):
    ratings = data['评分'].str.extract(r'(\d+\.?\d*)').astype('float')
    plt.hist(ratings, bins=25, color='lightblue', edgecolor='black')
    plt.xlabel('评分')
    plt.ylabel('电影数')
    plt.title('豆瓣电影评分直方图')
    plt.show()
 
# 主函数
def main():
    url = 'https://movie.douban.com/chart'
    html = get_page(url)
    movie_data = list(parse_data(html))
    save_to_csv(movie_data, 'douban_movies')
    plot_histogram(pd.DataFrame(movie_data))
 
if __name__ == '__main__':
    main()

这段代码实现了从豆瓣电影排行榜网页爬取数据，并将数据保存到CSV文件，最后使用matplotlib绘制电影评分的直方图。代码使用了requests库来发送HTTP请求，BeautifulSoup库来解析页面，pandas库来处理数据，以及matplotlib库来绘图。

import requests
from bs4 import BeautifulSoup
 
def crawl_lagou_jobs(position, city, page_num):
    """
    爬取拉勾网的职位信息
    :param position: 职位名称
    :param city: 城市名称
    :param page_num: 页数
    :return: 职位信息列表
    """
    jobs_info = []
    for i in range(1, page_num+1):
        url = f'https://www.lagou.com/jobs/list_%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E6%8A%80%E5%91%98?city={city}&district=&positionName={position}&first=true&kd=e1f8c6b136364c89977c5539f8b84833'
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36',
        }
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            soup = BeautifulSoup(response.text, 'lxml')
            job_list = soup.find_all('div', class_='job-primary')
            for job in job_list:
                job_info = {
                    'company_name': job.find('div', class_='company-name').text,
                    'position_name': job.find('div', class_='name').text.strip(),
                    'salary': job.find('div', class_='money').text.strip(),
                    'work_year': job.find('div', class_='work-year').text.strip(),
                    'education': job.find('div', class_='eduBackground').text.strip(),
                    'city': job.find('div', class_='work-location').text.strip(),
                }
                jobs_info.append(job_info)
        else:
            print(f'请求失败，状态码：{response.status_code}')
    return jobs_info
 
# 使用示例
position = '机器学习工程师'
city = '北京'
page_num = 3
jobs_info = crawl_lagou_jobs(position, city, page_num)
for info in jobs_info:
    print(info)

这段代码定义了一个crawl_lagou_jobs函数，它接受职位名称、城市名称和页数作为参数，返回拉勾网上该职位的信息列表。这个简易的网络爬虫示例展示了如何使用Python进行网页爬取，并提取出有价值的数据。

由于原始链接已经提供了完整的代码，我们只需要提取关键部分，以下是一个简化的代码实例，用于演示如何使用Python爬取西安工业大学OJ上的题目文档：

import requests
from bs4 import BeautifulSoup
 
# 西安工业大学OJ的网址
oj_url = "http://noj.xidian.edu.cn/"
 
# 使用requests获取网页内容
response = requests.get(oj_url)
 
# 检查请求是否成功
if response.status_code == 200:
    # 使用BeautifulSoup解析网页
    soup = BeautifulSoup(response.text, 'html.parser')
    
    # 假设题目列表在一个特定的<div>中，这里需要根据实际情况调整CSS选择器
    problem_div = soup.find('div', class_='problem-list')
    
    # 遍历所有的<a>标签，提取题目名称和链接
    for a_tag in problem_div.find_all('a'):
        problem_name = a_tag.text
        problem_link = oj_url + a_tag['href']
        print(f"题目名称: {problem_name}, 链接: {problem_link}")
        # 这里可以添加代码来下载题目文档
else:
    print("网页请求失败")

这段代码演示了如何使用requests和BeautifulSoup库来获取网页内容，并解析出需要的信息。在实际应用中，你可能需要处理登录验证、处理分页、处理复杂的DOM结构等问题，但基本的爬虫框架就是这样的。

import requests
from lxml import etree
import pandas as pd
 
def crawl_zhi_net(query, start_year, end_year, save_path):
    # 知网文献信息的容器
    data = []
 
    for year in range(start_year, end_year + 1):
        print(f"正在爬取 {query} {year} 年的文献信息...")
        url = f"https://www.zhihu.com/question/29134642/answer/101174968?sort=created"
        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:
            html = etree.HTML(response.text)
            # 解析并提取文献信息
            for item in html.xpath('//div[@class="zm-editable"]/ul/li'):
                title = item.xpath('./a/text()')[0]
                link = item.xpath('./a/@href')[0]
                data.append({'year': year, 'title': title, 'link': link})
 
    # 保存为CSV文件
    df = pd.DataFrame(data)
    df.to_csv(save_path, index=False)
    print(f"文献信息已保存至 {save_path}")
 
# 使用示例
crawl_zhi_net("机器学习", 2010, 2020, "MachineLearning_papers_2010-2020.csv")

这段代码首先定义了一个函数crawl_zhi_net，输入参数包括查询词、开始和结束年份以及保存路径。函数通过循环遍历每一年，并构造知网URL来发送请求，解析响应内容，提取文献信息，并将其存储在一个列表中。最后，使用Pandas库将文献信息转换为DataFrame并保存为CSV文件。这个过程展示了如何使用Python爬取动态网页内容，并进行数据解析和存储的基本方法。

为了提高Python爬虫的效率和稳定性，可以采取以下几种策略：

1. 异步IO：使用asyncio库和aiohttp库实现异步网络请求，这样可以并发处理多个请求，而不是逐个顺序等待。
2. 分布式爬虫：使用Scrapy分布式框架，可以通过多台机器或服务器并行抓取同一网站，大大提高爬取速度。
3. 请求头部优化：为每个请求随机设置User-Agent、Referer等头部信息，避免被服务器识别为爬虫。
4. 代理和IP池：使用代理和IP池，可以避免单一IP被封禁的风险，提高爬取效率。
5. 设置合理的请求间隔：遵守网站的robots.txt协议，设置合理的请求间隔，避免对网站造成过大压力。
6. 异常处理：对网络异常和爬取异常进行捕获和处理，避免爬虫程序意外中断。

以下是一个简单的异步爬虫示例代码：

import asyncio
import aiohttp
 
async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()
 
async def main():
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, 'http://example.com')
        print(html)
 
loop = asyncio.get_event_loop()
loop.run_until_complete(main())

这段代码使用aiohttp库以异步方式获取了指定URL的内容。通过异步IO，可以显著提高爬取效率。

以下是一个使用Python、Selenium和Chrome驱动的微博搜索和内容抓取的示例代码。请确保你已经安装了selenium库和chromedriver，并且将其放置在系统PATH中。

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import time
 
# 初始化webdriver
driver = webdriver.Chrome()
 
# 打开微博首页
driver.get('https://weibo.com/')
 
# 等待搜索框加载完成
search_input = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, 'search_input'))
)
 
# 输入搜索关键词
search_input.send_keys('关键词')
 
# 提交搜索
search_input.send_keys(Keys.RETURN)
 
# 等待搜索结果加载完成
time.sleep(5)  # 假设加载时间为5秒，实际可能需要更长
 
# 滚动页面加载更多博文
for i in range(3):  # 假设只需要抓取3页的博文
    driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
    time.sleep(2)  # 等待加载
 
# 获取博文链接并打开
blog_links = driver.find_elements_by_css_selector('.td-02 a')
for blog_link in blog_links:
    blog_link.click()
    time.sleep(2)  # 等待博文加载
    
    # 获取博文内容
    blog_content = driver.find_element_by_css_selector('.article').text
    print(blog_content)
    
    # 返回博文列表页
    driver.execute_script("window.history.go(-1)")
    time.sleep(2)
 
# 关闭webdriver
driver.quit()

请注意，这个代码示例是为了展示如何使用Selenium和ChromeDriver来进行基本的网页操作和内容抓取。在实际应用中，你可能需要处理更多的细节，例如处理用户登录、处理无限滚动加载的博文、处理分页、处理反爬虫策略（如登录验证、验证码识别等）。

以下是一个简单的示例，使用Python的requests和lxml库来爬取B站视频的评论。

import requests
from lxml import etree
 
def get_comments(bvid):
    # B站评论API
    api_url = f'https://api.bilibili.com/x/v2/reply?type=1&oid={bvid}&pn=1&sort=0'
    headers = {
        'User-Agent': 'your_user_agent'
    }
 
    # 发送请求
    response = requests.get(api_url, headers=headers)
    comments_data = response.json()
 
    # 提取评论内容
    comments = [comment['content']['message'] for comment in comments_data['data']['replies']]
    return comments
 
# 使用示例
bvid = 'BV12J411p7KT'  # 示例BV号
comments = get_comments(bvid)
for comment in comments:
    print(comment)

请注意，你需要替换'your\_user\_agent'为你自己的User-Agent，以避免被B站API封禁。此外，B站有反爬机制，如果频繁请求可能会被封禁IP。

由于B站的评论可能需要登录或者验证等安全措施，你可能需要添加额外的请求头信息，如cookie、Referer、csrf等，以通过B站的验证。

此代码只是一个简单的示例，实际应用中可能需要处理分页、登录验证、异常处理等复杂情况。