以下是针对Python爬虫的五个实用案例及其代码示例：

1. 简单的网页爬取

import requests
 
url = 'http://example.com'
response = requests.get(url)
print(response.text)

2. 使用BeautifulSoup解析HTML

from bs4 import BeautifulSoup
import requests
 
url = 'http://example.com'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
print(soup.title.text)

3. 使用lxml解析XML或HTML

from lxml import etree
import requests
 
url = 'http://example.com'
response = requests.get(url)
tree = etree.HTML(response.text)
print(tree.xpath('//title/text()'))

4. 使用Scrapy框架创建一个爬虫

scrapy startproject myproject
cd myproject
scrapy genspider myspider example.com

编辑myproject/spiders/myspider.py文件以提取所需数据。

5. 使用Selenium处理JavaScript渲染的网页

from selenium import webdriver
 
driver = webdriver.Chrome()
driver.get('http://example.com')
print(driver.page_source)
driver.quit()

这些案例涵盖了爬虫开发的基本步骤，包括网页请求、数据解析和持久化存储。开发者可以根据实际需求选择合适的案例进行学习和应用。

要获取江苏省历年GDP数据，可以使用Python的requests库来发送HTTP请求，以及BeautifulSoup库来解析HTML页面。以下是一个简单的示例代码，用于从中国国家统计局网站抓取江苏省的GDP数据。

import requests
from bs4 import BeautifulSoup
import pandas as pd
 
def get_gdp_data_for_jiangsu():
    # 设置请求头，模拟浏览器访问
    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'}
    # 目标URL
    url = 'http://www.stats.gov.cn/tjsj/tjbz/tjyqhdmhcxhfdm/2021/'
    # 发送GET请求
    response = requests.get(url, headers=headers)
    # 检查请求是否成功
    if response.status_code == 200:
        # 解析HTML内容
        soup = BeautifulSoup(response.text, 'html.parser')
        # 找到包含GDP数据的表格
        table = soup.find('table', class_='table_gj')
        # 提取表格数据
        rows = table.find_all('tr')[2:]  # 跳过表头
        data = []
        for row in rows:
            cols = row.find_all('td')
            year = cols[0].text.strip()  # 年份
            gdp = cols[1].text.strip()   # GDP数据
            data.append([year, gdp])
        # 转换数据为DataFrame
        df = pd.DataFrame(data, columns=['Year', 'GDP(Yuan)'])
        return df
    else:
        print("Failed to retrieve data, status code:", response.status_code)
        return None
 
# 获取数据并输出
data_jiangsu = get_gdp_data_for_jiangsu()
print(data_jiangsu)

请注意，由于网站可能会更改其结构，因此这段代码可能不会永久有效。此外，遵循目标网站的使用条款，合法地使用数据非常重要。如果你发现这种爬取方法不再有效，请查找该网站提供的官方API或联系其支持团队获取数据。

# 安装Nginx日志分析工具
go get -u github.com/satyakom/ngxlong
 
# 使用ngxlong统计爬虫抓取404的频率
ngxlong -log /var/log/nginx/access.log -status 404 -agent "Googlebot|Bingbot|Slurp"

这段代码首先通过go get命令从GitHub上获取了ngxlong工具的最新版本，然后使用这个工具来分析Nginx的访问日志，统计了爬虫（如Googlebot、Bingbot和Slurp）尝试抓取404错误页面的频率。这个例子展示了如何利用Go语言和开源工具来解决实际的日志分析问题。

Scrapy是一个用Python编写的开源爬虫框架，用于抓取网站并提取结构化数据。以下是一个使用Scrapy框架的简单示例：

首先，安装Scrapy：

pip install scrapy

创建一个新的Scrapy项目：

scrapy startproject myspider

进入项目目录，创建一个爬虫：

cd myspider
scrapy genspider example example.com

这将创建一个名为example的爬虫，用于抓取example.com。

编辑爬虫文件example.py，提取所需数据：

import scrapy
 
class ExampleSpider(scrapy.Spider):
    name = 'example'
    allowed_domains = ['example.com']
    start_urls = ['http://example.com/']
 
    def parse(self, response):
        # 提取数据的示例XPath表达式
        for href in response.xpath('//a/@href'):
            yield {'href': href.get()}

运行爬虫：

scrapy crawl example

这个简单的Scrapy爬虫会抓取example.com上的所有超链接，并输出包含每个链接的字典。这只是Scrapy功能的一个简单展示，实际应用中可以提取更多数据，处理更复杂的逻辑。

import requests
from bs4 import BeautifulSoup
 
def get_soup(url, params=None):
    response = requests.get(url, params=params)
    if response.status_code == 200:
        return BeautifulSoup(response.text, 'html.parser')
    else:
        return None
 
def extract_data(soup):
    # 假设数据在<div class="item">中
    items = soup.find_all('div', class_='item')
    for item in items:
        # 提取数据并处理，例如打印
        print(item.get_text())
 
def crawl_pages(start_page, end_page, url, params_template):
    for page in range(start_page, end_page + 1):
        params = params_template.copy()
        params['page'] = page
        soup = get_soup(url, params)
        if soup:
            extract_data(soup)
 
# 示例使用
url = 'http://example.com/search'
params_template = {
    'query': 'python',
    'page': None
}
start_page = 1
end_page = 3
crawl_pages(start_page, end_page, url, params_template)

这个示例代码展示了如何使用Python的requests库和BeautifulSoup库来爬取多页数据。get_soup函数负责发送请求并获取页面的soup对象。extract_data函数用于从soup对象中提取数据。crawl_pages函数负责遍历页码，并将每一页的soup对象传递给extract_data函数进行数据提取。这个例子中的url和params_template需要根据实际的网站进行调整。

由于这个问题涉及的内容较多且涉及到实际的数据爬取和分析，我将提供一个简化的示例来说明如何使用Python进行基本的情感分析。

import jieba
import numpy as np
from wordcloud import WordCloud
import matplotlib.pyplot as plt
 
# 分词并去除停用词
def segment_sentence(sentence):
    stopwords = set()
    with open('stopwords.txt', 'r', encoding='utf-8') as f:
        for line in f:
            stopwords.add(line.strip())
    seg_list = jieba.cut(sentence, cut_all=True)
    return [w for w in seg_list if w not in stopwords and w != '']
 
# 情感分析函数
def sentiment_analysis(sentence):
    seg_list = segment_sentence(sentence)
    positive_words = set(['好', '优秀', '优秀', '高', '大', '好', '及格', '可以', '应该', '适当'])
    negative_words = set(['差', '不行', '差', '低', '不', '不适宜'])
    score = 0
    for word in seg_list:
        if word in positive_words:
            score += 1
        elif word in negative_words:
            score -= 1
    return score
 
# 生成词云
def generate_wordcloud(text):
    wordcloud = WordCloud(font_path='simhei.ttf', background_color='white', max_words=2000)
    wordcloud.generate_from_text(text)
    plt.imshow(wordcloud, interpolation='bilinear')
    plt.axis('off')
    plt.show()
 
# 示例文本
text = "这部手机非常好用，拍照效果优秀，性能也很高，但是价格略高。"
 
# 情感分析得分
sentiment_score = sentiment_analysis(text)
print(f"情感得分: {sentiment_score}")
 
# 生成词云
generate_wordcloud(text)

这个简化的示例展示了如何进行基本的情感分析，并生成词云。实际应用中，你需要根据你的数据集调整停用词和情感词典，并对爬取的数据进行清洗和预处理。

由于原始代码已经提供了一个很好的实例，以下是核心函数的简化版本，展示如何爬取城市评论并进行情感分析：

import requests
from bs4 import BeautifulSoup
from textblob import TextBlob
 
# 爬取评论并进行情感分析的函数
def crawl_and_analyze_comments(url):
    # 发送HTTP请求
    response = requests.get(url)
    # 解析网页
    soup = BeautifulSoup(response.text, 'html.parser')
    # 提取评论
    comments = soup.find_all('p', class_='comment-content')
    # 初始化情感分析计数器
    positive_count, negative_count, neutral_count = 0, 0, 0
    
    for comment in comments:
        text = comment.get_text()
        # 对评论进行情感分析
        analysis = TextBlob(text)
        sentiment = analysis.sentiment.polarity
        if sentiment > 0:
            positive_count += 1
        elif sentiment < 0:
            negative_count += 1
        else:
            neutral_count += 1
    
    # 计算情感比例
    positive_ratio = positive_count / (positive_count + negative_count + neutral_count)
    negative_ratio = negative_count / (positive_count + negative_count + neutral_count)
    
    return positive_ratio, negative_ratio
 
# 示例URL
example_url = 'https://www.tripadvisor.cn/Attraction_Review-g186338-d10351889-Reviews-Xian_Tian_An_Men_Tian_An_Men_Guan-Chengzhou_Sichuan_Province.html'
# 执行情感分析
positive_ratio, negative_ratio = crawl_and_analyze_comments(example_url)
print(f"Positive Ratio: {positive_ratio:.2f}, Negative Ratio: {negative_ratio:.2f}")

这段代码展示了如何使用requests库获取网页内容，使用BeautifulSoup进行网页解析，以及如何使用TextBlob进行情感分析。代码简洁，注重逻辑性，可以作为爬虫和情感分析相关开发的入门示例。

import requests
import pandas as pd
from bs4 import BeautifulSoup
 
# 定义一个函数来获取网页内容
def get_html(url):
    try:
        response = requests.get(url)
        if response.status_code == 200:
            return response.text
        else:
            return None
    except requests.RequestException:
        return None
 
# 定义一个函数来解析网页并提取需要的数据
def parse_html(html):
    soup = BeautifulSoup(html, 'html.parser')
    data = []
    for row in soup.find_all('tr')[1:]:  # 从第二行开始解析，跳过表头
        cols = row.find_all('td')
        data_row = [elem.text.strip() for elem in cols]
        data.append(data_row)
    return data
 
# 定义一个函数来将数据存储到CSV文件中
def save_to_csv(data, filename):
    df = pd.DataFrame(data, columns=['日期', '开盘', '收盘', '最高', '最低', '成交量', '成交额'])
    df.to_csv(filename, index=False, encoding='utf-8-sig')
 
# 定义一个主函数来运行整个流程
def main():
    url = 'http://example.com/stock-data'  # 示例URL，实际应用中需要替换为实际的股票信息网址
    html = get_html(url)
    parsed_data = parse_html(html)
    save_to_csv(parsed_data, 'stock_data.csv')
 
if __name__ == '__main__':
    main()

这个代码示例展示了如何使用Python爬取网页数据，并使用BeautifulSoup进行解析，然后将数据存储到CSV文件中。这个流程是数据分析的常规步骤，并且演示了如何将多个函数组合在一起来完成一个完整的任务。

package main
 
import (
    "fmt"
    "log"
    "net/http"
    "os"
    "time"
 
    "github.com/PuerkitoBio/goquery"
)
 
func main() {
    // 设置HTTP客户端超时
    client := &http.Client{Timeout: 10 * time.Second}
 
    // 从命令行参数获取URL
    if len(os.Args) != 2 {
        log.Fatal("请提供要抓取的网站URL作为第一个参数")
    }
    url := os.Args[1]
 
    // 发送HTTP GET请求
    res, err := client.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer res.Body.Close()
 
    if res.StatusCode != 200 {
        log.Fatalf("状态码错误: %d %s", res.StatusCode, res.Status)
    }
 
    // 使用goquery解析HTML文档
    doc, err := goquery.NewDocumentFromReader(res.Body)
    if err != nil {
        log.Fatal(err)
    }
 
    // 选择所有的<h1>元素并打印它们的内容
    doc.Find("h1").Each(func(i int, s *goquery.Selection) {
        fmt.Printf("第%d个H1标签的内容: %s\n", i, s.Text())
    })
}

这段代码使用了Go语言的标准库net/http来发送HTTP请求，使用了第三方库github.com/PuerkitoBio/goquery来解析HTML文档并提取数据。代码简洁，注重逻辑性，适合作为爬虫入门学习的示例。

package main
 
import (
    "fmt"
    "log"
    "net/http"
    "os"
    "time"
 
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "golang.org/x/net/html"
    "golang.org/x/net/html/atom"
)
 
// 初始化日志配置
func initLogger() (*zap.Logger, error) {
    encoderConfig := zapcore.EncoderConfig{
        TimeKey:        "ts",
        LevelKey:       "level",
        NameKey:        "logger",
        CallerKey:      "caller",
        MessageKey:     "msg",
        StacktraceKey:  "stacktrace",
        LineEnding:     zapcore.DefaultLineEnding,
        EncodeLevel:    zapcore.LowercaseLevelEncoder,
        EncodeTime:     zapcore.EpochMillisTimeEncoder,
        EncodeDuration: zapcore.SecondsDurationEncoder,
    }
    core := zapcore.NewCore(zapcore.NewJSONEncoder(encoderConfig), os.Stdout, zapcore.InfoLevel)
    return zap.New(core), nil
}
 
// 解析HTML并提取指定的元素
func extractElements(doc *html.Node, targetAtom atom.Atom) []*html.Node {
    var elements []*html.Node
    var f func(*html.Node)
    f = func(n *html.Node) {
        if n.Type == html.ElementNode && n.DataAtom == targetAtom {
            elements = append(elements, n)
        }
        for c := n.FirstChild; c != nil; c = c.NextSibling {
            f(c)
        }
    }
    f(doc)
    return elements
}
 
// 爬取指定URL的页面内容
func crawlPage(logger *zap.Logger, url string) (string, error) {
    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Get(url)
    if err != nil {
        logger.Error("Error fetching URL", zap.Error(err), zap.String("url", url))
        return "", err
    }
    defer resp.Body.Close()
 
    if resp.StatusCode != http.StatusOK {
        logger.Error("Received non-200 HTTP status code", zap.Int("status_code", resp.StatusCode), zap.String("url", url))
        return "", fmt.Errorf("non-200 status code: %d", resp.StatusCode)
    }
 
    doc, err := html.Parse(resp.Body)
    if err != nil {
        logger.Error("Error parsing HTML", zap.Error(err), zap.String("url", url))
        return "", err
    }
 
    // 假设我们要提取所有的h1元素
    h1Elements := extractElements(doc, atom.H1)
    var content string
    for _, elem := range h1Elements {
        for _, n := range elem.ChildNodes {
            content += n.Data
        }
    }
 
    return content, nil
}
 
func main() {
    logger, err := initLogger()
    if err != nil {
        log.Fatalf("Error initializing logger: %v", err)
    }
    defer logger.Sync()
 
    content, err := crawlPage(logger, "https://example.com")
    if err != nil {
        logger.Error("Crawling failed", zap.E