2024-08-13



import scrapy
 
class DoubanMovieItem(scrapy.Item):
    # 定义爬取的字段
    movie_name = scrapy.Field()
    movie_rating = scrapy.Field()
    movie_comment = scrapy.Field()
 
class DoubanMovieSpider(scrapy.Spider):
    name = 'douban_movie'
    allowed_domains = ['douban.com']
    start_urls = ['https://movie.douban.com/top250']
 
    def parse(self, response):
        # 提取电影信息的xpath路径
        movie_selectors = response.xpath('//div[@class="info"]')
        for movie_selector in movie_selectors:
            item = DoubanMovieItem()
            # 提取电影名称
            movie_name = movie_selector.xpath('.//a/span[1]/text()').extract_first()
            item['movie_name'] = movie_name.strip() if movie_name else None
            # 提取电影评分
            movie_rating = movie_selector.xpath('.//div[@class="star"]/span[2]/text()').extract_first()
            item['movie_rating'] = movie_rating.strip() if movie_rating else None
            # 提取电影评论
            movie_comment = movie_selector.xpath('.//p[@class="quote"]/span/text()').extract_first()
            item['movie_comment'] = movie_comment.strip() if movie_comment else None
            yield item
 
        # 提取下一页链接并进行爬取
        next_page_url = response.xpath('//span[@class="next"]/a/@href').extract_first
        if next_page_url:
            next_page_full_url = response.urljoin(next_page_url)
            yield scrapy.Request(next_page_full_url, callback=self.parse)

这段代码实现了一个简单的Scrapy爬虫,用于抓取豆瓣电影TOP250的电影名称、评分和评论。它使用XPath选择器来定位页面元素,并使用Item对象来存储爬取的数据。此外,它还实现了简单的分页逻辑来爬取所有页的数据。

2024-08-13



import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
from statsmodels.tsa.arima_model import ARIMA
from fbprophet import Prophet
 
# 假设我们有以下函数来获取智慧交通数据
def get_data(city, date):
    # 这里应该是获取数据的代码,但由于数据不公开,我们模拟一些数据返回
    return pd.DataFrame({
        'time': pd.date_range(start=date, periods=24*7, freq='H'),
        'car_count': np.random.randint(1000, 10000, size=24*7)
    })
 
# 获取数据
city = '北京'
date = '2021-01-01'
data = get_data(city, date)
 
# 数据预处理
data['hour'] = data['time'].dt.hour
data = data.set_index('time')
 
# 使用fbprophet进行时间序列预测
model = Prophet(daily_seasonality=True, weekly_seasonality=True)
model.fit(data)
future = model.make_future_dataframe(periods=24*7)
forecast = model.predict(future)
 
# 画出预测图
fig1 = model.plot(forecast)
 
# 保存图表
fig1.savefig(f'prophet_prediction_{city}.png')
 
# 输出预测结果
print(forecast[['ds', 'yhat']])

这个示例展示了如何使用Prophet模型进行时间序列预测,并将预测结果保存为图片文件。注意,这里的数据是模拟的,实际应用中需要替换为实际的交通数据。

2024-08-13



import requests
from bs4 import BeautifulSoup
import pandas as pd
 
# 设置请求头,模拟浏览器访问
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_data(url):
    response = requests.get(url, headers=headers)
    soup = BeautifulSoup(response.text, 'lxml')
    data = soup.find_all('div', class_='title')
    rank = [i.span.get_text() for i in soup.find_all('div', class_='num')]
    names = [i.a.get_text() for i in data]
    hrefs = ['https://www.toutiao.com' + i.a.get('href') for i in data]
    return rank, names, hrefs
 
def main(url):
    rank, names, hrefs = get_data(url)
    data = pd.DataFrame(list(zip(rank, names, hrefs)), columns=['排名', '名称', '链接'])
    print(data)
    data.to_csv('今日头条热榜.csv', index=False, encoding='utf-8')
 
if __name__ == '__main__':
    url = 'https://www.toutiao.com/hotwords/'
    main(url)

这段代码首先定义了请求头,用于模拟浏览器访问网页。get_data 函数用于获取网页数据,并通过BeautifulSoup进行解析。main 函数则是程序的主要逻辑,它调用get_data函数获取数据,并将数据存储在一个DataFrame中,最后将数据保存到CSV文件中。最后,在__name____main__时,执行主函数,开始爬取数据。

2024-08-13

要使用Python构建一个企业级的高可用海量爬虫调度系统,可以选择使用Kubernetes和Python的第三方库如Celery来实现分布式任务调度,以及Scrapy来实现爬虫。

以下是一个基本的架构示例:

  1. Kubernetes:负责整个系统的部署、扩缩容和服务发现。
  2. Celery:负责分布式任务调度。
  3. Scrapy:用于实现爬虫。

以下是一个简单的Celery配置示例:




# celery_tasks.py
from celery import Celery
 
app = Celery('my_crawler', broker='redis://localhost:6379/0', backend='redis://localhost:6379/0')
 
@app.task
def add(x, y):
    return x + y

在Kubernetes中部署Celery:




# celery-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: celery-worker
spec:
  replicas: 3
  selector:
    matchLabels:
      component: celery-worker
  template:
    metadata:
      labels:
        component: celery-worker
    spec:
      containers:
      - name: celery-worker
        image: my_celery_worker_image
        command: celery worker -A my_crawler -l info

在Scrapy中创建爬虫项目,并配置为在Celery中运行:




# myspider.py
import scrapy
from celery_tasks.tasks import add
 
class MySpider(scrapy.Spider):
    name = 'myspider'
 
    def parse(self, response):
        # 假设爬取到的数据为item
        item = ...
        # 将爬取的数据提交给Celery进行异步处理
        add.delay(item)

这个例子展示了如何使用Celery和Scrapy来构建一个简单的分布式爬虫系统。在实际部署中,你需要考虑更多的细节,如错误处理、日志记录、监控、安全性等。此外,你还需要搭配Kubernetes的服务发现和自动扩缩容功能来保证系统的高可用性和扩展性。

2024-08-13

EasySpider是一个网络爬虫工具,它提供了一个直观的用户界面,让用户可以轻松地创建、编辑和运行网络爬虫。以下是一个使用EasySpider的基本示例:

  1. 安装EasySpider:



pip install easyspider
  1. 启动EasySpider:



easyspider
  1. 在EasySpider界面中:
  • 创建一个新的项目。
  • 定义爬虫的起始URL和需要抓取的数据字段。
  • 设置爬虫的行为,如是否跟随链接、并发请求等。
  • 运行爬虫。
  1. 爬虫完成后,可以导出数据。

EasySpider提供了一个易于使用的界面,让即使是没有技术背景的用户也能够轻松地进行网络爬取。

请注意,EasySpider不是一个代码库,而是一个用于创建和管理爬虫的工具,它依赖于其他库(如Scrapy)来实现实际的爬取功能。因此,具体的爬虫实现细节(如解析算法、异常处理等)需要通过编辑生成的Scrapy代码来完成。

2024-08-13

要使用Python爬取豆瓣电影评论,你可以使用requests库获取网页内容,然后用BeautifulSoup解析网页。以下是一个简单的示例代码:




import requests
from bs4 import BeautifulSoup
import time
 
# 设置HTTP请求头部,模拟浏览器访问
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_comments(url):
    # 获取网页内容
    response = requests.get(url, headers=headers)
    response.raise_for_status()  # 检查请求是否成功
    soup = BeautifulSoup(response.text, 'lxml')  # 解析网页
 
    # 提取评论内容
    comments = soup.find_all('div', class_='comment')
    for comment in comments:
        content = comment.find('div', class_='comment-content').text.strip()
        author = comment.find('span', class_='comment-info').text.strip()
        print(f'评论内容:{content}\n作者:{author}\n')
 
# 主函数
def main(url):
    # 循环抓取多页评论
    for page in range(1, 11):  # 假设只抓取前10页
        print(f'正在抓取第{page}页评论...')
        page_url = f'{url}&page={page}'
        get_comments(page_url)
        time.sleep(2)  # 暂停2秒,减少对服务器的请求频率
 
if __name__ == '__main__':
    movie_url = 'https://movie.douban.com/subject/1292720/comments?sort=new_score'
    main(movie_url)

请注意,由于豆瓣网站可能有反爬机制,实际运行时可能需要处理登录验证、反爬机制等问题。此外,频繁的爬取数据可能会对豆瓣服务器造成压力,应遵守豆瓣的爬虫政策。

2024-08-13



# 使用Python 3.8的官方镜像作为基础镜像
FROM python:3.8
 
# 安装必要的系统库和依赖
RUN apt-get update && apt-get install -y \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*
 
# 安装项目依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
# 复制项目代码
COPY . /app
 
# 设置容器内的工作目录
WORKDIR /app
 
# 运行爬虫
CMD ["python", "run.py"]

以上Dockerfile为一个简化版的爬虫系统Docker部署的例子。它演示了如何为Python爬虫系统创建一个Docker镜像,包括安装依赖、复制代码和设置启动命令。这样的实践可以帮助开发者理解如何将他们的应用程序打包到一个容器中,并在生产环境中进行部署。

2024-08-13

以下是一个简化的版本,用于演示如何使用Python爬取彼岸图网上的4K高清图片。




import requests
from bs4 import BeautifulSoup
import os
 
def download_image(url, filename):
    response = requests.get(url)
    with open(filename, 'wb') as file:
        file.write(response.content)
 
def crawl_behance_images(username, max_pages=2):
    base_url = f'https://www.behance.net/{username}'
    os.makedirs(username, exist_ok=True)
    page_number = 1
    while page_number <= max_pages:
        print(f'Crawling page {page_number}')
        url = f'{base_url}/gallery/{{project_id}}/revisions?page={page_number}&display_type=grid&sort=recent'
        response = requests.get(url)
        soup = BeautifulSoup(response.text, 'html.parser')
        image_urls = [image['src'] for image in soup.find_all('img', class_='image') if image['src'].endswith('.jpg')]
        for image_url in image_urls:
            filename = os.path.basename(image_url)
            download_image(image_url, os.path.join(username, filename))
        page_number += 1
 
crawl_behance_images('username_example', max_pages=1)  # 替换为具体的用户名

请注意,由于版权和平台政策,未经允许,不应在未经允许的情况下爬取大量图片。此代码仅用于学习目的,并假定用户已获得合法权限。

2024-08-13



import requests
from bs4 import BeautifulSoup
import pandas as pd
 
# 获取网页内容
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)
        return response.text
    except requests.RequestException as e:
        print(e)
        return None
 
# 解析网页数据
def parse_data(html):
    soup = BeautifulSoup(html, 'lxml')
    data = []
    for tr in soup.find('tbody').children:
        if isinstance(tr, bs4.element.Tag):
            tds = tr('td')
            data.append({
                '排名': tds[0].text,
                '电影名': tds[1].text,
                '票房': tds[2].text,
                '上映天数': tds[3].text,
                '上映场次': tds[4].text,
                '人均票房': tds[5].text
            })
    return data
 
# 保存数据到CSV
def save_to_csv(data, filename):
    df = pd.DataFrame(data)
    df.to_csv(filename, index=False, encoding='utf-8-sig')
 
# 主函数
def main():
    url = 'http://www.bj-m.com/boxoffice/bom/202101/ranking.html'
    html = get_html(url)
    data = parse_data(html)
    save_to_csv(data, '2021年1月票房排行.csv')
 
if __name__ == '__main__':
    main()

这段代码实现了从网页爬取数据、解析数据、保存数据到CSV文件的完整流程。使用了requests库获取网页内容,BeautifulSoup进行网页解析,pandas处理和保存数据。代码简洁,注重逻辑性和实用性,是学习爬虫技术的一个很好的示例。

2024-08-13

以下是一个简单的Python爬虫示例,用于爬取豆瓣电影TOP250的电影名称和评分,并将结果保存到CSV文件中。




import requests
from lxml import etree
import csv
 
# 请求URL
url = 'https://movie.douban.com/top250'
 
# 发送请求,获取响应
response = requests.get(url)
 
# 解析HTML内容
html = etree.HTML(response.text)
 
# XPath表达式,用于定位电影信息
xpath_movie = '//div[@class="info"]/div[@class="hd"]/a/span[1]/text()'
xpath_rating = '//div[@class="info"]/div[@class="bd"]/div[@class="star"]/span[@class="rating_num"]/text()'
 
# 存储电影数据的列表
movies = []
 
# 解析页面,提取电影信息
for i in range(25):  # 每页有25部电影
    movie_name = html.xpath(xpath_movie)[i].strip()
    movie_rating = html.xpath(xpath_rating)[i].strip()
    movies.append({'电影名称': movie_name, '评分': movie_rating})
 
# 保存到CSV文件
with open('douban_top250.csv', 'w', newline='', encoding='utf-8') as file:
    writer = csv.DictWriter(file, fieldnames=['电影名称', '评分'])
    writer.writeheader()
    for movie in movies:
        writer.writerow(movie)
 
print("爬取完成,结果保存到douban_top250.csv文件。")

这段代码使用了requests库来发送HTTP请求,获取页面内容;使用lxml库来解析HTML内容并通过XPath表达式定位和提取需要的数据;最后将数据保存到CSV文件中。这个Demo简单易懂,适合作为爬虫入门学习的示例。