如何使用python爬虫selenium爬取知网信息以及对数据进行本地化储存和mysql数据库储存

最新推荐文章于 2024-09-03 08:22:00 发布

崔书菡

最新推荐文章于 2024-09-03 08:22:00 发布

阅读量2.3k

点赞数 5

分类专栏： python 文章标签：爬虫 python selenium mysql 数据库

本文链接：https://blog.csdn.net/weixin_48846320/article/details/134936076

版权

python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、selenium

1.selenium介绍

selenium的官网（selenium中文网 | selenium安装、selenium使用、selenium中文、selenium下载）给出了详细定义：

Selenium 是web自动化测试工具集，包括IDE、Grid、RC（selenium 1.0）、WebDriver（selenium 2.0）等。

Selenium IDE 是firefox浏览器的一个插件。提供简单的脚本录制、编辑与回放功能。

Selenium Grid 是用来对测试脚步做分布式处理。现在已经集成到selenium server 中了。

RC和WebDriver 更多应该把它看成一套规范，在这套规范里定义客户端脚步与浏览器交互的协议。以及元素定位与操作的接口。

而在python爬虫过程中，为了规避一些网站的反爬机制，我们会选择更智能更灵活的selenium和palywright等工具，这些原本应用于web自动化测试的工具能够很好模拟人工操作，让一些被javascript隐藏的网页信息也能被我们获取。

2.selenium安装

windows系统需要用win+R打开cmd窗口，输入

pip install selenium按下回车键等待安装完成即可

3.selenium在pycharm的环境配置

我们安装selenium之后还需要在pycharm里面进行添加

点击file里面的settings

点击+号

搜索selenium勾选版本然后点击install package等待提示安装完成即可

二、爬虫书写

1.爬虫运行前提及注意事项

此爬虫默认ip登陆可以访问知网，适合高校学子，个人账户需添加登录账号和密码，但鉴于知网的反爬机制，不建议个人爬取，容易被封号。

另外，运行selenium需要安装webdrive才能打开浏览器，不同的浏览器webdrive不同，我这里用的是IE浏览器，NuGet Gallery | Selenium.WebDriver.IEDriver 4.14.0，具体版本和安装方式可以自行搜索。

2.知网页面及爬虫逻辑

知网作为大学文献阅读的必备网站之一，可以给我们提供大量文献帮助，但人手检索文献一篇一篇地复制下载没办法宏观地查看一个领域的学科发展脉络等，所以我们可能需要一些爬虫工具来进行辅助。

我们先看知网的初始页面

我们需要在搜索栏里面输入想要检索的内容，然后点击搜索键，默认的是初级搜索+主题检索，当然你可以改到高级搜索或其他检索方式。

我这里输入的内容是“现代林业”，检索之后默认界面里面按中文、发表时间倒序、“题名作者来源发表时间数据库被引下载”、每页20条显示，这样的检索结果爬不全我想要的内容，我需要对其进行修改，我要点击详情，并让显示改到最大的每页50篇。

此时我想要的关键词和摘要都出现了但这时我发现这里单位和作者位于一个div里面，仅用span包裹，且有的没有作者或者单位或者多个作者或者单位，这个页面的信息储存十分混乱，不太利于我爬取数据后进行处理。

这时我又发现有一个全选-导出与分析-自定义的选项

这个页面里面数据的储存就十分有规律且对作者和单位进行了分割，我还可以自定义想导出的内容

于是就这么愉快的决定了！

3.爬虫函数

首先需要导入，这些是包含数据储存需要的内容，储存的方式不同可能用不到一些内容，如果你要本地建表储存，就不需要pymysql，如果你mysql储存就不需要csv

import time
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from selenium.webdriver.common.action_chains import ActionChains
import csv
import random
import pymysql

设置驱动环境，设置driver，定义爬取网站，我们可以适当设置不加载图片，减少加载时长。

# get直接返回，不再等待界面加载完成
desired_capabilities = DesiredCapabilities.EDGE
desired_capabilities["pageLoadStrategy"] = "none"

# 设置 Edge 驱动器的环境
options = webdriver.EdgeOptions()

#设置 Edge 不加载图片，提高速度
options.add_experimental_option("prefs", {"profile.managed_default_content_settings.images": 2})

# 创建一个 Edge 驱动器
driver = webdriver.Edge(options=options)
#选择网址
driver.get("https://www.cnki.net")

模拟在输入框输入搜索内容并点击

#定义并输入主题,主题词可以换成别的
theme='现代林业'
WebDriverWait(driver, 100).until(
        EC.presence_of_element_located((By.XPATH, '''//*[@id="txt_SearchText"]'''))).send_keys(theme)
# 点击搜索
WebDriverWait(driver, 100).until(
        EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div/div[1]/input[2]"))).click()
time.sleep(3)

默认是主题检索，也可以通过下面的代码换到其他方式检索，比如全文检索

# 点击主题按钮
WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div/div[1]/div"))).click()
time.sleep(1)
# 选择内容检索，这里面我以全文检索举例，li[5]代表的是点击“全文”
WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div/div[1]/div/div[2]/ul/li[5]"))).click()
time.sleep(3)
# 点击搜索
WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div/div[1]/input[2]"))).click()
time.sleep(5)

对应的 li[n]列表如下

调整一页里面50页，点击详情，看一眼一共多少论文多少页

#控制显示数量为50
WebDriverWait(driver, 100).until(
        EC.presence_of_element_located((By.XPATH, "//*[@id='perPageDiv']/div[@class='sort-default']"))).click()
WebDriverWait(driver, 100).until(
        EC.presence_of_element_located((By.XPATH, "//*[@id='perPageDiv']/ul/li[@data-val='50']"))).click()
time.sleep(5)
# 点击查看详情
WebDriverWait(driver, 100).until(
        EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div[2]/div[2]/div/div[1]/div/div[2]/ul[2]/li[1]"))).click()
time.sleep(3)
# 获取总文献数和页数
res_unm = WebDriverWait(driver, 200).until(
        EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div[2]/div[2]/div/div[1]/div/div[1]/span[1]/em"))).text
# 去除千分位里的逗号
res_unm = int(res_unm.replace(",", ''))
page_unm = int(res_unm / 20) + 1
papers_need=res_unm
print(papers_need)
print(page_unm)

爬取的主函数如下，具体看注释解释吧

def crawl(driver, papers_need, theme):
    # 赋值序号, 控制爬取的文章数量
    count = 1
    expect_count=0

    # 当爬取数量小于需求时，循环网页页码
    while count <= papers_need:
        # 等待加载完全，休眠3S
        time.sleep(3)
        #点击全选键
        WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "//*[@id='briefBox']/div[1]/div/div[2]/div[1]/label"))).click()
        time.sleep(5)
        #看一下这页一共多少篇论文
        title_list = WebDriverWait(driver, 200).until(EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div[2]/div[2]/div/div[1]/div/div[2]/div[1]/em"))).text
        print(title_list)
        title_count=int(title_list)
        #点击导出与分析——导出文献——自定义
        WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "//*[@id='batchOpsBox']/li[2]"))).click()
        WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "//*[@id='batchOpsBox']/li[2]/ul/li[@class='export']"))).click()
        WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "//*[@id='batchOpsBox']/li[2]/ul/li[1]/ul/li[13]"))).click()
        # 等待新窗口打开并切换到新窗口的上下文
        wait = WebDriverWait(driver, 100)
        new_window = wait.until(EC.number_of_windows_to_be(2))
        driver.switch_to.window(driver.window_handles[-1])
        #选择关键词、摘要、发表时间标签
        WebDriverWait(driver, 300).until(
            EC.presence_of_element_located((By.XPATH, "//*[@id='result']/ul/div/label[@title='Keyword-关键词']"))).click()
        WebDriverWait(driver, 300).until(
            EC.presence_of_element_located(
                (By.XPATH, "//*[@id='result']/ul/div/label[@title='Summary-摘要']"))).click()
        WebDriverWait(driver, 300).until(
            EC.presence_of_element_located(
                (By.XPATH, "//*[@id='result']/ul/div/label[@title='PubTime-发表时间']"))).click()
        # 刷新一下等页面更新
        WebDriverWait(driver, 300).until(
            EC.presence_of_element_located(
                (By.XPATH, "//*[@id='result']/ul/div/div/ul/li"))).click()
        time.sleep(10)
        # 由于知网的原因，需要滑动一下页面才能让信息加载完全，没搞懂知网加载机制，手动模拟了一下发现滑到第20再滑到40条才能50条显示完全
        element_xpath = "//*[@id='result']/ul/li[20]"
        # 等待元素出现
        wait = WebDriverWait(driver, 300)
        element = wait.until(EC.presence_of_element_located((By.XPATH, element_xpath)))

        # 滚动到元素位置
        actions = ActionChains(driver)
        actions.move_to_element(element).perform()
        time.sleep(5)
        element_xpath = "//*[@id='result']/ul/li[40]"

        # 等待元素出现
        wait = WebDriverWait(driver, 300)
        element = wait.until(EC.presence_of_element_located((By.XPATH, element_xpath)))
        # 滚动到元素位置
        actions = ActionChains(driver)
        actions.move_to_element(element).perform()
        time.sleep(3)
        #设置一个预期在这个页面获取的文献信息数量
        expect_count=expect_count+title_count
        for i in range(title_count):

            if count % title_count != 0:
                term = count % title_count  # 本页的第几个条目
            else:
                term = title_count
            #从第一条开始爬取，获取html元素并解析
            all_elements = WebDriverWait(driver, 300).until(EC.presence_of_element_located((By.XPATH,
                                            f"//*[@id='result']/ul / li[{term}]")))
            element_html = all_elements.get_attribute("outerHTML")

            #去掉前后的<li>和</li>，把内容根据<br>进行切割
            stripped_html = element_html.replace('<li>', '').replace('</li>', '')

            # 根据<br>标签对元素进行分割
            elements = stripped_html.split('<br>')

            # 创建一个空列表来存储内容
            content_list = []

            # 遍历每个元素，处理并添加到列表中
            for element in elements:
                element = element.strip()  # 去除首尾的空白字符
                content_list.append(element)  # 将元素添加到列表中


            def replace_in_list(my_list, search_string, replace_string):
                for element in my_list:
                    if search_string in element:
                        # 找到含有 search_string 的元素，去掉该部分并赋值给变量SrcDatabase
                        new_element1 = element.replace(search_string, replace_string)
                        new_element = new_element1.replace(" ", "")
                        # 在原列表中替换元素
                        my_list[my_list.index(element)] = new_element
                        break  # 找到后退出循环
                else:  # 如果没有找到含有 search_string 的元素
                    # 将SrcDatabase设为"无"
                    new_element = "无"
                return new_element
            #消去前缀分类赋值
            SrcDatabase=replace_in_list(content_list, "SrcDatabase-来源库:", "")
            Title=replace_in_list(content_list, "Title-题名:", "")
            Author = replace_in_list(content_list, "Author-作者:", "")
            Organ = replace_in_list(content_list, "Organ-单位:", "")
            Source = replace_in_list(content_list, "Source-文献来源:", "")
            Keyword = replace_in_list(content_list, "Keyword-关键词:", "")
            Summary = replace_in_list(content_list, "Summary-摘要:", "")
            PubTime = replace_in_list(content_list, "PubTime-发表时间:", "")
            #形成存储格式
            content = [count,SrcDatabase, Title, Author, Organ, Source, Keyword, Summary, PubTime]
            print(content)

            #插个眼，后面储存数据需要在这里加代码

            if count % 10!= 5:
                random_number = random.randint(1, 20)
                time.sleep(random_number)
            # 获取完这页所有的信息后关闭这个网页回到原页面
            if term==title_count:
                n2 = driver.window_handles
                if len(n2) > 1:
                    driver.close()
                    driver.switch_to.window(n2[0])
                #回到页面并清除全选
                #// *[ @ id = "briefBox"] / div[1] / div / div[2] / div[1] / a
                WebDriverWait(driver, 300).until(EC.presence_of_element_located(
                    (By.XPATH, "//*[@id='briefBox']/div[1]/div/div[2]/div[1]/a"))).click()
                WebDriverWait(driver, 300).until(EC.presence_of_element_located((By.XPATH,"/html/body/div[2]/div[2]/div[2]/div[2]/div/div[2]/div/div[2]/a[@class='pagesnums']"))).click()

            count += 1
        if count == papers_need:
            break

到了这一步基本就完成了，别忘了最关键的一步，运行函数

crawl(driver,papers_need,theme)

4.报错补救方法（待优化）

我运行的时候前2000条基本不会报错，不过因为网络问题和知网有时候会断连等一些问题，2000条左右会爬取失败断连，还没想到更好的补救方法，不过有个好处是我的爬虫方法让50条文章的信息都在一个页面，且一整页信息导出后爬取，爬不出来报错的断点都是50的倍数，页数也是整数。我目前的方法是写了另一个文件，根据报错前最后打印的那条信息记录一下断点是哪里，用第二个爬虫文件翻页到那一页然后从断点出继续爬取。

import time
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from selenium.webdriver.common.action_chains import ActionChains
import random


# get直接返回，不再等待界面加载完成
desired_capabilities = DesiredCapabilities.EDGE
desired_capabilities["pageLoadStrategy"] = "none"

# 设置 Edge 驱动器的环境
options = webdriver.EdgeOptions()

#设置 Edge 不加载图片，提高速度
options.add_experimental_option("prefs", {"profile.managed_default_content_settings.images": 2})

# 创建一个 Edge 驱动器
driver = webdriver.Edge(options=options)
#选择网址
driver.get("https://www.cnki.net")
#定义并输入主题
theme='现代林业'
WebDriverWait(driver, 100).until(
        EC.presence_of_element_located((By.XPATH, '''//*[@id="txt_SearchText"]'''))).send_keys(theme)
# 点击搜索
WebDriverWait(driver, 100).until(
        EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div/div[1]/input[2]"))).click()
time.sleep(5)

#/html/body/div[2]/div[2]/div[2]/div[2]/div/div[1]/div/div[2]/div[2]/div/div/div[@class='sort-default']
#//*[@id="perPageDiv"]/div
#//*[@id="perPageDiv"]/ul/li[3]


# 点击查看详情
WebDriverWait(driver, 100).until(
        EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div[2]/div[2]/div/div[1]/div/div[2]/ul[2]/li[1]"))).click()
time.sleep(5)

WebDriverWait(driver, 100).until(
        EC.presence_of_element_located((By.XPATH, "//*[@id='perPageDiv']/div[@class='sort-default']"))).click()
WebDriverWait(driver, 100).until(
        EC.presence_of_element_located((By.XPATH, "//*[@id='perPageDiv']/ul/li[@data-val='50']"))).click()
time.sleep(5)
# 获取总文献数和页数
res_unm = WebDriverWait(driver, 300).until(
        EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div[2]/div[2]/div/div[1]/div/div[1]/span[1]/em"))).text
# 去除千分位里的逗号
res_unm = int(res_unm.replace(",", ''))
page_unm = int(res_unm / 50) + 1
papers_need=res_unm
print(papers_need)
print(page_unm)


def crawl(driver, papers_need, theme):
    # 赋值序号, 控制爬取的文章数量
    #此处count是断点值+1
    count = 5951

    expect_count=0

    # 当爬取数量小于需求时，循环网页页码
    while count <= papers_need:
        # 等待加载完全，休眠3S
        time.sleep(3)
        #点击全选键
        WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "//*[@id='briefBox']/div[1]/div/div[2]/div[1]/label"))).click()
        time.sleep(5)
        #看一下这页一共多少篇论文
        title_list = WebDriverWait(driver, 200).until(EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div[2]/div[2]/div/div[1]/div/div[2]/div[1]/em"))).text
        print(title_list)
        title_count=int(title_list)
        #点击导出与分析——导出文献——自定义
        WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "//*[@id='batchOpsBox']/li[2]"))).click()
        WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "//*[@id='batchOpsBox']/li[2]/ul/li[@class='export']"))).click()
        WebDriverWait(driver, 100).until(EC.presence_of_element_located((By.XPATH, "//*[@id='batchOpsBox']/li[2]/ul/li[1]/ul/li[13]"))).click()
        # 等待新窗口打开并切换到新窗口的上下文
        wait = WebDriverWait(driver, 100)
        new_window = wait.until(EC.number_of_windows_to_be(2))
        driver.switch_to.window(driver.window_handles[-1])
        #选择关键词、摘要、发表时间标签
        time.sleep(5)
        WebDriverWait(driver, 300).until(
            EC.presence_of_element_located((By.XPATH, "//*[@id='result']/ul/div/label[@title='Keyword-关键词']"))).click()
        time.sleep(5)
        WebDriverWait(driver, 300).until(
            EC.presence_of_element_located(
                (By.XPATH, "//*[@id='result']/ul/div/label[@title='Summary-摘要']"))).click()
        time.sleep(5)
        WebDriverWait(driver, 300).until(
            EC.presence_of_element_located(
                (By.XPATH, "//*[@id='result']/ul/div/label[8]"))).click()
        #//*[@id="result"]/ul/div/label[8]
        # 刷新一下等页面更新
        WebDriverWait(driver, 300).until(
            EC.presence_of_element_located(
                (By.XPATH, "//*[@id='result']/ul/div/div/ul/li[@class='blue']"))).click()
        time.sleep(10)
        #设置一个预期在这个页面获取的文献信息数量
        expect_count=expect_count+title_count
        # 定位到目标元素
        # 定位元素
        element_xpath = "//*[@id='result']/ul/li[20]"

        # 等待元素出现
        wait = WebDriverWait(driver, 300)
        element = wait.until(EC.presence_of_element_located((By.XPATH, element_xpath)))

        # 滚动到元素位置
        actions = ActionChains(driver)
        actions.move_to_element(element).perform()
        time.sleep(5)
        element_xpath = "//*[@id='result']/ul/li[40]"

        # 等待元素出现
        wait = WebDriverWait(driver, 300)
        element = wait.until(EC.presence_of_element_located((By.XPATH, element_xpath)))
        # 滚动到元素位置
        actions = ActionChains(driver)
        actions.move_to_element(element).perform()
        time.sleep(3)



        for i in range(title_count):

            if count % title_count != 0:
                term = count % title_count  # 本页的第几个条目
            else:
                term = title_count
            #从第一条开始爬取，获取html元素并解析
            all_elements = WebDriverWait(driver, 300).until(EC.presence_of_element_located((By.XPATH,
                                            f"//*[@id='result']/ul / li[{term}]")))
            element_html = all_elements.get_attribute("outerHTML")

            #去掉前后的<li>和</li>，把内容根据<br>进行切割
            stripped_html = element_html.replace('<li>', '').replace('</li>', '')

            # 根据<br>标签对元素进行分割
            elements = stripped_html.split('<br>')

            # 创建一个空列表来存储内容
            content_list = []

            # 遍历每个元素，处理并添加到列表中
            for element in elements:
                element = element.strip()  # 去除首尾的空白字符
                content_list.append(element)  # 将元素添加到列表中


            def replace_in_list(my_list, search_string, replace_string):
                for element in my_list:
                    if search_string in element:
                        # 找到含有 search_string 的元素，去掉该部分并赋值给变量SrcDatabase
                        new_element1 = element.replace(search_string, replace_string)
                        new_element = new_element1.replace(" ", "")
                        # 在原列表中替换元素
                        my_list[my_list.index(element)] = new_element
                        break  # 找到后退出循环
                else:  # 如果没有找到含有 search_string 的元素
                    # 将SrcDatabase设为"无"
                    new_element = "无"
                return new_element
            #消去前缀分类赋值
            SrcDatabase=replace_in_list(content_list, "SrcDatabase-来源库:", "")
            Title=replace_in_list(content_list, "Title-题名:", "")
            Author = replace_in_list(content_list, "Author-作者:", "")
            Organ = replace_in_list(content_list, "Organ-单位:", "")
            Source = replace_in_list(content_list, "Source-文献来源:", "")
            Keyword = replace_in_list(content_list, "Keyword-关键词:", "")
            Summary = replace_in_list(content_list, "Summary-摘要:", "")
            PubTime = replace_in_list(content_list, "PubTime-发表时间:", "")
            #形成存储格式
            content = [count,SrcDatabase, Title, Author, Organ, Source, Keyword, Summary, PubTime]
            print(content)

            if count % 10!= 5:
                random_number = random.randint(1, 3)
                time.sleep(random_number)
            # 获取完这页所有的信息后关闭这个网页回到原页面
            if term==title_count:
                n2 = driver.window_handles
                if len(n2) > 1:
                    driver.close()
                    driver.switch_to.window(n2[0])
                #回到页面并清除全选
                #// *[ @ id = "briefBox"] / div[1] / div / div[2] / div[1] / a
                WebDriverWait(driver, 300).until(EC.presence_of_element_located(
                    (By.XPATH, "//*[@id='briefBox']/div[1]/div/div[2]/div[1]/a"))).click()
                WebDriverWait(driver, 300).until(EC.presence_of_element_located((By.XPATH,"/html/body/div[2]/div[2]/div[2]/div[2]/div/div[2]/div/div[2]/a[@class='pagesnums']"))).click()

            count += 1
        if count == papers_need:
            break
#这里的逻辑是知网文献第一页是1-9，断点一般在9页之后，所以我直接点第九页跳到第九页
#/html/body/div[2]/div[2]/div[2]/div[2]/div/div[2]/div/div[2]/div[9]
time.sleep(5)
wait = WebDriverWait(driver, 300)
click_element = wait.until(EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div[2]/div[2]/div/div[2]/div/div[2]/div[9]")))
click_element.click()
time.sleep(5)
n=1
#这里的逻辑是知网文献点到第九页之后，如果当前页面为t，显示可以点击跳转的最大页面数是t+4，这里面n是点击数，相当于点到9+4*n页
while n<28:
    time.sleep(5)
    wait = WebDriverWait(driver, 300)
    click_element = wait.until(EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div[2]/div[2]/div/div[2]/div/div[2]/div[10]")))
    click_element.click()
    n+=1
else:
    page_now=117
    # 这里的逻辑是如果断点页不是9+4*n，我们需要点下一页下一页下一页到想要的那个页面
    while page_now<120:
        time.sleep(5)
        wait = WebDriverWait(driver, 300)
        #/html/body/div[2]/div[2]/div[2]/div[2]/div/div[1]/div/div[1]/span[4]/a
        click_element = wait.until(EC.presence_of_element_located((By.XPATH, "/html/body/div[2]/div[2]/div[2]/div[2]/div/div[2]/div/div[2]/a[@class='pagesnums']")))
        click_element.click()
        page_now+=1
    else:
        crawl(driver, papers_need, theme)

三、数据储存

1.本地建表及储存

我们爬取数据后假如需要储存在本地，就需要在一开始建表（假如已经建过了这步可以省略）

import csv

# 建立一个表格，路径E:\test\test.csv和文件名自己修改
with open(r'E:\test\test.csv', 'w', encoding='UTF8', newline='') as f:
    writer = csv.writer(f)
    # 写入表头，按自己想爬的内容修改
    header = [ '标题', '作者及机构',  '发表时间',  '来源', '摘要', '关键词']
    writer.writerow(header)
    print('over')

储存时则需要在爬虫函数中插入一段代码（返回去找一下我插眼的地方）

with open(r'E:\test\test.csv', 'a', encoding='UTF8', newline='') as f:
     writer = csv.writer(f)
     writer.writerow(content)
     print("信息写入完成")

2.mysql建表及储存

如果爬取的数据需要储存在mysql里面：

mysql的安装我就省略了，注意我这里用的库是pymysql，像selenium一样配置pymysql到pycharm

配置好之后我们得确保有要储存的库和表，我这里的代码是检查是否有这个库和表，没有就建一个

# 连接 MySQL 数据库服务器
cnx = pymysql.connect(user='root', password='123456', port=3306, host='localhost')
cursor = cnx.cursor()

# 检查数据库是否存在，不存在则创建
db_name = 'courseDate'
cursor.execute(f"SHOW DATABASES LIKE '{db_name}'")
if cursor.fetchone() is None:
    cursor.execute(f"CREATE DATABASE {db_name}")
    print(f"Database {db_name} created successfully.")
else:
    print(f"Database {db_name} already exists.")

# 关闭连接
cursor.close()
cnx.close()

# 连接数据库
cnx = pymysql.connect(user='root', password='123456', port=3306, host='localhost', database=db_name)
cursor = cnx.cursor()

# 检查表是否存在，不存在则创建
table_name = 'cuishuhan'
cursor.execute(f"SHOW TABLES LIKE '{table_name}'")
if cursor.fetchone() is None:
    cursor.execute(f"""CREATE TABLE {table_name} (  
                        count INT,  # 整数类型的'count'列  
                        SrcDatabase VARCHAR(255),  
                        Title VARCHAR(255),  
                        Author VARCHAR(255),  
                        Organ VARCHAR(255),  
                        Source VARCHAR(255),  
                        Keyword VARCHAR(255),  
                        Summary TEXT,  
                        PubTime TIMESTAMP DEFAULT CURRENT_TIMESTAMP  
                    )""")
    print(f"Table {table_name} created successfully.")
else:
    print(f"Table {table_name} already exists.")

# 提交更改
cnx.commit()

# 关闭连接
cursor.close()
cnx.close()

储存就简单多了

# 连接到MySQL数据库
            def connect_to_mysql():
                try:
                    conn = pymysql.connect(user='root', password='123456', host='localhost',
                                           port=3306, database='courseDatet')
                    cursor = conn.cursor()
                    cursor.execute('SELECT 1')  # 进行一次查询操作来检查连接是否活着
                    if cursor.fetchone()[0] == 1:  # 如果查询结果为1，那么连接是活动的
                        print("成功连接到MySQL数据库")
                        return conn
                except pymysql.Error as e:
                    print(f"Failed to connect to database: {e}")
                    return None

                    # 将数据插入到MySQL数据库的表中

            def insert_into_mysql(conn, content):
                try:
                    cursor = conn.cursor()
                    query = "INSERT INTO cuishuhan (count,SrcDatabase,Title,Author,Organ,Source,Keyword,Summary,PubTime) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)"
                    cursor.execute(query, content)
                    conn.commit()
                    print("数据插入成功")
                except pymysql.Error as e:
                    print(e)

                    # 主函数

            def chucun(content):
                conn = connect_to_mysql()
                if conn is not None:
                    insert_into_mysql(conn, content)
                else:
                    print("无法连接到MySQL数据库")

            chucun(content)