python学习第八节：爬虫的初级理解

最新推荐文章于 2024-09-13 19:41:31 发布

一只会敲代码的小灰灰

最新推荐文章于 2024-09-13 19:41:31 发布

阅读量2.2k

点赞数 16

分类专栏： python学习文章标签： python 学习爬虫

本文链接：https://blog.csdn.net/qq_34231823/article/details/142167136

版权

python学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

python学习第八节：爬虫的初级理解

在这里插入图片描述

爬虫说明：

对于爬虫，我的理解是通过方法从指定的url中获取数据或者网页，然后分析数据内容进而提取数据，最后保存下来。

专业一点的说法就是，按照一定规则，自动抓取互联网信息的程序或者脚本。比如从图片网站上抓取你喜欢的图片，从视频网站上抓取你想要的视频。

对于爬虫也是有一定的商业价值的，比如，你把你爬取到的图片或者视频整合放在你自己的网站上提供给网友下载进行引流，然后你承接一些广告放在你的网站上进行变现。

我们在做爬虫时的基本流程是：

准备工作
通过浏览器查看分析目标网页
获取数据
通过HTTP库向目标站点发起请求，请求可以包含额外的header等信息，如果服务器能正常响应，会得到一个Response，便是所要获取的页面内容。
解析内容
得到的内容可能是HTML、json等格式，可以用页面解析库、正则表达式等进行解析。
保存数据
保存形式多样，可以存为文本，也可以保存到数据库，或者保存特定格式的文件。

爬虫准备工作：

通过浏览器查看分析目标网页，下面我们以豆瓣网为例：https://movie.douban.com/

分析网站url

我们找到豆瓣top250：https://movie.douban.com/top250?start=0&filter=
第一页：
在这里插入图片描述
第二页：

通过对比url，发现，https://movie.douban.com/top250?start=0&filter= 中&filter=没用，可以去掉；因为每页是显示25条，第一页是start=0，第二页是start=25，很轻松得到规律：页面包含250条电影数据，每页25条，分10页；每页的url不同之处就是start后面的值等于（页数-1）*25

分析网页内容

通过开发者工具（F12）来快速帮助我们定位我们想要的数据的位置，特征，标签等一系列我们需要的东西
在这里插入图片描述

参数说明：
请求报文：

响应报文：

常见的请求头字段：

以下是常见的HTTP请求头字段：
Accept：表明客户端所能够接受的响应数据格式
Authorization：携带身份验证信息
Content-Length：请求体的长度
Content-Type：请求体的数据类型
User-Agent：浏览器或其他客户端的标识信息
Referer：从哪个页面发送的请求
Cookie：携带客户端的cookie信息

常见的响应头字段：

以下是常见的HTTP响应头字段：
Cache-Control：缓存控制策略，例如no-cache、max-age等
Content-Encoding：响应数据的压缩方式，例如gzip、deflate等
Content-Type：响应数据的数据类型
ETag：标识响应资源的唯一版本号
Last-Modified：响应资源的最后修改时间
Server：服务器类型和版本
Set-Cookie：服务端设置cookie信息

常见的HTTP状态码及其含义

HTTP协议定义了大量的状态码来表示服务器对客户端请求的响应结果。常见的状态码包括：
200 OK：表示请求成功
201 Created：表示请求已经被处理，并且新资源已经被创建
204 No Content：表示请求已经被成功处理，但是没有返回任何内容
400 Bad Request：表示请求无效或者不完整
401 Unauthorized：表示未经授权的请求
403 Forbidden：表示服务器拒绝执行请求
404 Not Found：表示请求的资源不存在
500 Internal Server Error：表示服务器出错

爬虫获取数据：

python中对于爬虫提供了4中方法库：

基于requests库的方法：
requests是Python的一个HTTP客户端库，用于发送HTTP请求和处理响应。它提供了简洁的API，使得发送HTTP请求和处理响应变得非常简单。你可以使用requests库获取网页内容，然后配合解析库（如BeautifulSoup、lxml等）进行HTML或XML文档的解析。
基于Scrapy框架的方法：
Scrapy是一个为了爬取网站数据，提取结构性数据而编写的应用框架。它可以应用在包括数据挖掘，信息处理或存储历史数据等一系列的程序中。Scrapy提供了丰富的API和工具，可以方便地实现网页请求、数据提取、数据存储等操作。
基于Selenium库的方法：
Selenium是一个用于Web应用程序测试的工具，但它同样可以用于爬取动态生成的网页内容。Selenium可以模拟真实用户操作浏览器，包括点击、输入、滚动等操作，从而获取JavaScript渲染后的网页内容。
基于urllib库的方法：
urllib是Python内置的HTTP请求库，它可以用来打开和读取URL。虽然urllib的功能比requests库要弱一些，但在一些简单的场景下，使用urllib就足够了。

本此使用urllib库的方法进行讲解：

1.使用urllib库发起一个get请求

import urllib.request    #导入urllib库
response = urllib.request.urlopen('https://www.baidu.com')  # urlopen 作用是下载网页内容
print(response.read().decode('utf-8')) # 使用response.read读取网页内容 对获取到的网页源码进utf-8解码

得到的结果：

<html>
<head>
	<script>
		location.replace(location.href.replace("https://","http://"));
	</script>
</head>
<body>
	<noscript><meta http-equiv="refresh" content="0;url=http://www.baidu.com/"></noscript>
</body>
</html>

这里会发现没有获取到正确的网页，在这里留一个悬念，下面我们会讲到

2.使用urllib库发起一个post请求

post请求需要传递参数，因此我们需要使用这个网站（http://httpbin.org）来测试我们传递的参数有没有实现

import urllib.request
#urllib.parse模块是一个用于解析URL的工具包，支持各种对URL的操作，包括拆分、拼接、编码、解码等。
import urllib.parse
# bytes 解析成二进制的数据用来传输
data = bytes(urllib.parse.urlencode({"hello":"world"}),encoding="utf-8")
#将二进制的data作为参数传递到方法里
response = urllib.request.urlopen("http://httpbin.org/post",data= data)
print(response.read().decode("utf-8"))

得到的结果：

{
  "args": {}, 
  "data": "", 
  "files": {}, 
  "form": {
    "hello": "world"
  }, 
  "headers": {
    "Accept-Encoding": "identity", 
    "Content-Length": "11", 
    "Content-Type": "application/x-www-form-urlencoded", 
    "Host": "httpbin.org", 
    "User-Agent": "Python-urllib/3.8", 
    "X-Amzn-Trace-Id": "Root=1-66e25873-6f5cc27f5219bb625bb5a9a1"
  }, 
  "json": null, 
  "origin": "61.186.130.22", 
  "url": "http://httpbin.org/post"
}

get方法获取网站响应内容

import urllib.request
response = urllib.request.urlopen('http://httpbin.org/get')
print(response.read().decode('utf-8')) #对获取到的网页源码进utf-8解码

得到结果：

{
  "args": {}, 
  "headers": {
    "Accept-Encoding": "identity", 
    "Host": "httpbin.org", 
    "User-Agent": "Python-urllib/3.12", 
    "X-Amzn-Trace-Id": "Root=1-65ae9140-44be121444ebb21c2fc87877"
  }, 
  "origin": "123.119.77.156", 
  "url": "http://httpbin.org/get"
}

3.网页超时处理

请求在规定时间内没有响应，就会报错，需要做异常处理

try:
    response = urllib.request.urlopen('http://httpbin.org/get', timeout=0.01)  # 这里我为了测试设置了超过0.01秒没有响应就报错
    print(response.read().decode('utf-8')) #对获取到的网页源码进utf-8解码
except Exception as e:
    print(e)

得到结果：

<urlopen error timed out>

完整代码：

import urllib.request
try:
    response = urllib.request.urlopen('http://httpbin.org/get', timeout=0.01)
    print(response.read().decode('utf-8')) #对获取到的网页源码进utf-8解码
    except urllib.error.URLError as e:
        if hasattr(e,"code"):   #  打印错误状态码
            print(e.code)
        if hasattr(e,"reason"):  # 打印错误问题原因
            print(e.reason)

4.简单反爬虫绕过

这里就要说到上面get请求时没有得到正确网页的问题，就是因为网站做了反爬。
我们在请求时模拟一个请求头向百度服务器发送信息

import urllib.request
#urllib.parse模块是一个用于解析URL的工具包，支持各种对URL的操作，包括拆分、拼接、编码、解码等。
import urllib.parse
url = 'https://www.baidu.com'
#模拟浏览器头部信息，向服务器发送消息
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" 					 # 用户代理，表示告诉服务器，我们是什么类型的机器、浏览器(本质上是告诉浏览器，我们可以接收什么水平的文件内容
}
req = urllib.request.Request(url=url,headers=headers)
response = urllib.request.urlopen(req)
print(response.read().decode('utf-8')) #对获取到的网页源码进utf-8解码
print(response.getheaders())  #h获取请求头

5.获取响应参数

#获取网页响应内容
response = urllib.request.urlopen("http://httpbin.org/get")
print(response.read().decode("utf-8")) #返回网页内容

#获取网页响应状态
response = urllib.request.urlopen("http://httpbin.org/get")
print(response.status) #返回：200

#获取网页响应头内容
response = urllib.request.urlopen("http://httpbin.org/get")
print(response.getheaders()) #返回：[('Date', 'Thu, 01 Feb 2024 04:19:30 GMT'), ('Content-Type', 'application/json'), ('Content-Length', '275'), ('Connection', 'close'), ('Server', 'gunicorn/19.9.0'), ('Access-Control-Allow-Origin', '*'), ('Access-Control-Allow-Credentials', 'true')]
#单独获取一个响应头参数的值
response = urllib.request.urlopen("http://httpbin.org/get")
print(response.getheader('Content-Type')) #返回：#text/html

#为请求传递更多参数
url  = "https://www.baidu.com/"
headers = {
    'User-Agent': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
}
# 封装一个request对象，传递初始化的参数的值
req = urllib.request.Request(url, headers=headers,data=data,method='POST')
response = urllib.request.urlopen(req)
print(response.read().decode('utf-8')) #对获取到的网页源码进utf-8解码

6.完整请求代码

获取数据已完成

import urllib.request, urllib.error
def main():
    baseurl = "https://movie.douban.com/top250?start="
    askURL(baseurl)

# 爬取所有250个网页内容
def getData(baseurl):
    datalist = []
    # 循环爬取所有页面
    for i in range(0, 250, 25):
        url = baseurl + str(i)
        html = askURL(url)

# 爬取单个网页内容
def askURL(url):
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
    }
    req = urllib.request.Request(url, headers=headers)
    try:
        response = urllib.request.urlopen(req)
        html = response.read().decode('utf-8')
        print(html)
    except urllib.error.URLError as e:
        if hasattr(e, "code"):
            print(e.code)
        if hasattr(e, "reason"):
            print(e.reason)
    return html


if __name__ == '__main__':
    # 定义程序的入口 ，当前这个程序调用的时候执行，主要是为了集中调用函数没不至于太分散找不到
    # 还可以在这里控制多个函数之间的流程和顺序，是代码更简洁，便利
    main()

解析数据

bs4库

BeautifulSoup4将复杂的HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可归纳为4种:Tag、Navigablestring、BeautifulSoup、Comment

1.获取整个标签

from bs4 import BeautifulSoup
# 逐一解析数据 把html使用html.parser进行解析
bs = BeautifulSoup(html,"html.parser")# 获取整个网页
print(bs.a)  # 返回找到的第一个a标签，返回时的整个标签 Tag
print(bs.title) #返回：<title>百度一下你就知道<title>

2.获取标签里的内容

from bs4 import BeautifulSoup
bs = BeautifulSoup(html,"html.parser")
print(bs.title.string)  # 返回找到的第一个title标签的内容 字符串

返回结果：百度一下你就知道

3.获取标签里的属性和属性值

#假如html= <a href="https://xxx.com" class="qk-a" id="qk-id"></a>
bs = BeautifulSoup(html,"html.parser")
print(bs.a.attrs)  # 返回找到的第一个title标签的属性和属性值，字典形式

返回结果：{'href': 'https://xxx.com', 'class': ['qk-a'], 'id': ['qk-id']}

4.获取标签里指定的属性值

#假如html= <a href="https://xxx.com" class="qk-a" id="qk-id"></a>
bs = BeautifulSoup(html,"html.parser")
print(bs.a.attrs["href"])  # 返回:https://xxx.com

5.文档搜索

find_all()函数

字符串过滤，会查找与字符串完全匹配的内容

bs = BeautifulSoup(html,"html.parser")
print(bs.find_all("a")) #查找所有a标签 以list列表形式显示

search()函数

正则表达式搜索:使用search()方法来匹配内容

bs = BeautifulSoup(html,"html.parser")
a_list =  bs.find_all(re.compile("a"))

通过标签属性搜索

t_list = bs.find_all(id="head")   # 查找所有的id=head的标签
t_list3 = bs.find_all(herf="http://news.baidu.com") # 查找所有的herf=指定值的标签
t_list2 = bs.find_all("a",{"class":{"lnk-book","lnk-book2"}}) #查找网页中所有a标签中class值等于lnk-book或者lnk-book2的标签
t_list4 = bs.find_all(string="豆瓣") #查找网页中有多少个指定的字符串，返回list列表 ['豆瓣', '豆瓣', '豆瓣']。注意：这里是完全匹配原则
t_list5 = bs.find_all(text=["hao123","新闻","贴吧"])

通过css选择器搜索

print(bs.select("a")) #查找所有的a标签
print(bs.select(".lnk-book")) #查找所有的类名为.lnk-book标签
print(bs.select("#lnk-book")) #查找所有的id名为#lnk-book标签
print(bs.select("a[class='lnk-book']")) #查找所有的a标签中class=lnk-book 的标签
print(bs.select("head > title")) #查找head标签下的title标签
print(bs.select(".mnav ~ .bri")) #查找.mnav的兄弟标签.bri的text

搜索限制条数

# 查找限制，比如，查找前3个a标签
print(bs.find_all("a", limit=3)) #查找前3个a标签 以list列表形式显示

re库

也就是正则表达式，可以查看我上一篇篇文章《python学习第七节：正则表达式》

保存数据

在这里插入图片描述

1.创建表格

xlwt对Excel文件进行写操作的时候，只能对通过xlwt新建的Excel文件进行写操作，无法直接对已经存在的Excel文件进行写操作。如果想要对已经存在的Excel文件进行写操作需要使用后面的xlutils模块。保存数据需要利用python库xlwt将抽取的数据datalist写入Excel表格。

新建工作簿和工作表
cell_overwrite_ok=True 重新写入会自动覆盖之前的内容不会报错

import xlwt
workbook = xlwt.Workbook(encoding='utf-8')     # 创建workbook对象 新建一个工作簿对象
worksheet = workbook.add_sheet('sheet1',cell_overwrite_ok=True)        # 创建工作表 
worksheet.write(0,0,'hello')   #写入数据，第一行参数，第二个参数"列”，第三个参数内容
workbook.save('student.xls')  #文件保存到指定位置

完整代码：

save_path = r"E:\豆瓣网电影TOP250.xls"
save_data(datalist, save_path)
def save_data(datalist,save_path):
    book = xlwt.Workbook(encoding="utf-8",style_compression=0)
    sheet = book.add_sheet("豆瓣网电影TOP250",cell_overwrite_ok=True)
    col = ("电影链接","图片链接","电影中文名称","电影外语名称","电影评分","评论人数","电影概述","电影的相关内容")
    for i in range(len(col)):
        sheet.write(0,i,col[i])
    for i in range(len(datalist)):
        data = datalist[i]
        for j in range(len(data)):
            sheet.write(i+1, j,data[j])
    book.save(save_path)

表格优化：

font = xlwt.Font()
font.name = '微软雅黑'
font.bold = True  # 字体加粗
font.underline = True  # 添加下划线
font.italic = True  # 设置字体为斜体
font.colour_index = 2 # 设置字体颜色

alignment = xlwt.Alignment()  # 设置对齐方式
# 设置水平对齐方式，可以是 HORZ_GENERAL, HORZ_LEFT, HORZ_CENTER, HORZ_RIGHT, HORZ_FILLED, HORZ_JUSTIFIED, HORZ_CENTER_ACROSS_SEL, HORZ_DISTRIBUTED
alignment.horz = xlwt.Alignment.HORZ_CENTER 
# 设置垂直对齐方式，可以是 VERT_TOP, VERT_CENTER, VERT_BOTTOM, VERT_JUSTIFIED, VERT_DISTRIBUTED
alignment.vert = xlwt.Alignment.VERT_CENTER

pattern = xlwt.Pattern()  # 设置背景色
# 可是0 = Black, 1 = White, 2 = Red, 3 = Green, 4 = Blue, 5 = Yellow, 6 = Magenta, 7 = Cyan, 16 = Maroon, 17 = Dark Green, 18 = Dark Blue, 19 = Dark Yellow , almost brown), 20 = Dark Magenta, 21 = Teal, 22 = Light Gray, 23 = Dark Gray
pattern.pattern_fore_colour = 5 

style = xlwt.XFStyle()
style.font = font
style.alignment = alignment
style.pattern = pattern
worksheet.write(0, 0, label = 'Hello world！', style)  # 使用格式

2.将九九乘法表输出到表格

import xlwt

i = 1
workbook = xlwt.Workbook(encoding='utf-8')     # 创建workbook对象
worksheet = workbook.add_sheet('sheet1')        # 创建工作表
while i < 10:
    j = 1
    while j <= i:
        worksheet.write(i-1,j-1,'%d * %d = %d' % (j,i,j*i))
        j += 1
    i += 1
# worksheet.write(0,0,'hello')   #写入数据，第一行参数，第二个参数"列”，第三个参数内容
workbook.save('E://jiu.xls')

读取表格

xlrd用来读取Excel文件内容非常方便，操作步骤和通过Excel软件操作Excel文件一样方便。

1.打开表格

import xlrd
#打开工作簿
wb = xlrd.open_workbook('E:\豆瓣网电影TOP250.xls')
#选择工作表;一个工作簿中可能包含多个工作表
book_names = wb.sheet_names()  # 获取工作簿中所有工作表的表名
print(book_names ) #['sheet1', 'sheet2']

2.选择工作表

一个工作簿中可能包含多个工作表

import xlrd
#打开工作簿
wb = xlrd.open_workbook('E:\豆瓣网电影TOP250.xls')
#选择工作表;一个工作簿中可能包含多个工作表
book_names = wb.sheet_names()  # 获取工作簿中所有工作表的表名
print(book_names ) #['sheet1', 'sheet2']

3.获取工作表对象

工作簿对象.sheets() - 获取工作簿中所有工作表对应的工作表对象
工作簿对象.sheet_by_index(下标) - 获取指定下标对应的工作表对象
工作簿对象.sheet_by_name(表名) - 获取指定表名对应的工作表对象

import xlrd
#打开工作簿
wb = xlrd.open_workbook('E:\豆瓣网电影TOP250.xls')
#  获取工作簿中所有工作表对应的工作表对象
book_sheets = wb.sheets()
print(book_sheets)
print(book_sheets[0])
# 获取指定下标对应的工作表对象
sheet1 = wb .sheet_by_index(1)
print(sheet1) 
# 获取指定表名对应的工作表对象
sheet2 = wb .sheet_by_name('sheet2')
print(sheet2)

4.获取工作表行、列信息

工作表对象.nrows - 获取工作表中的行数
工作表对象.ncols - 获取工作表中的列数

# 获取工作表中的行数
print(sheet1.nrows) 
# 获取工作表中的列数
print(sheet1.ncols)

工作表对象.row_values(行下标) - 获取指定下标对应的行中所有的数据，结果以列表的形式返回
工作表对象.col_values(列下标) - 获取指定下标对应的列中所有的数据，结果以列表的形式返回(下标从0开始)

# 获取指定下标对应的行中所有的数据，结果以列表的形式返回
print(sheet1.row_values(1)) 
# 获取指定下标对应的列中所有的数据，结果以列表的形式返回(下标从0开始)
print(sheet1.col_values(0))

根据之前获取行数结合获取整行的方法，可以通过循环一行一行的将整个excel:

for x in range(sheet1.nrows):
    print(sheet1.row_values(x))

5.操作单元格

工作表对象.row(行下标) - 获取指定下标对应的行中所有的单元格。结果是一个列表，列表中的元素是单元格对象（注意不是单元格内容）
工作表对象.col(列下标) - 获取指定下标对象的列中所有的单元格。
工作表对象.cell(行下标, 列下标) - 获取指定行下标和列下标对应的单元格对象。
单元格对象.value - 获取指定单元格中的值

print(sheet1.row(1))
print(sheet1.col(1))
print(sheet1.cell(3, 0))
print(sheet1.row(1)[0].value)
print(sheet1.col(1)[2].value)
print(sheet1.cell(3, 0).value)

数据入库

SQLite是python自带的数据库，不需要任何配置，使用sqlite3模块就可以驱动它。

1.创建数据库链接

import sqlite3
# 创建与数据库的连接
conn = sqlite3.connect('test.db')

建立与数据库的连接后，需要创建一个游标cursor对象，该对象的.execute()方法可以执行sql语句，我们可以够进行数据操作。

#创建一个游标 cursor
c = conn.cursor()

2.执行sql语句

# 查询语句
sql="select * from table_name "
c.execute(sql)
# 获取查询结果
c.fetchall()

# 插入语句
sql1 = "INSERT INTO product VALUES('001', '黑丝', 'x68', '45X36', '纯棉', 98)"
c.execute(sql1)
# 批量插入
data = [('001', '黑丝', 'x68', '45X36', '尼龙', 98),
        ('002', '黑丝', 'x48', '34X25', '尼龙', 55),
        ]
c.executemany('INSERT INTO scores VALUES (?,?,?,?,?,?)', data)

# 数据库做改动后（比如建表、插数等），都需要手动提交改动，否则无法将数据保存到数据库。
conn.commit()

# 使用完数据库之后，需要关闭游标：
c.close() # 关闭游标

# 使用完数据库之后，需要关闭数据库连接：
conn.close()

新建数据表的完整代码就是：

import sqlite3

conn = sqlite3.connect("test.db") # 打开或创建数据库文件
print("成功打开数据库")
c= conn.cursor()  #获取游标
sql1 ='''
    create table company
        (id int primary key not null,
        name text not null,
        age int not null,
        address char(50),
        salary real);
'''
sql2 ='''
    insert into company (id,name,age,address,salary),
        values(1,'张三',32,"成都",8000); 
'''
sql3 ='''
    insert into company (id,name,age,address,salary),
        values(2,'李四',30,"重庆",15000);
'''
sql4 ="select id,name,address,salary from company"
c.execute(sql1)  # 执行sql语句
c.execute(sql2)  # 执行sql语句
c.execute(sql3)  # 执行sql语句

cursor =c.execute(sql4)
#执行sql语句
for row in cursor:
    print("id =",row[0])
    print("name =",row[1])
    print("address =",row[2])
    print("salary =",row[3])

print("成功建表")
print("成功插入数据")
print("成功查询数据")
conn.commit()   # 提交数据库操作
conn.close()    # 关闭数据库连接

完整爬虫代码

from bs4 import BeautifulSoup
import re
import urllib.request, urllib.error
import xlwt
import sqlite3

# urllib.parse模块是一个用于解析URL的工具包，支持各种对URL的操作，包括拆分、拼接、编码、解码等。
import urllib.parse


def main():
    baseurl = "https://movie.douban.com/top250?start="
    print("爬虫开始....")
    datalist = get_data(baseurl)
    save_path = r"D:\水利部\豆瓣网电影TOP250.xls"
    save_data(datalist, save_path)
    dbpath = "test1.db"
    saveData2DB(datalist,dbpath)


# 影片详情链接的规则
findLink = re.compile(r'<a href="(.*?)">')   # 创建正则表达式对象，表示规则(字符串的模式)
# 影片图片
findImgSrc = re.compile(r'<img.*src="(.*?)"',re.S)  # re.s 让换行符包含在字符中
# 影片片名
findTitle =re.compile(r'<span class="title">(.*)</span>')
# 影片评分
findRating = re.compile(r'<span class="rating_num" property="v:average">(.*)</span>')
# 找到评价人数
findJudge =re.compile(r'<span>(\d*)人评价</span>')
# 找到概况
findInq =re.compile(r'<span class="inq">(.*)</span>')
# 找到影片的相关内容
findBd = re.compile(r'<p class="">(.*?)</p>',re.S)
#   爬取所有网页内容
def get_data(baseurl):
    datalist = []
    # 循环爬取所有页面
    for i in range(0,10):
        url = baseurl + str(i*25)
        html = askurl(url)
        #print(html)

        # 逐一解析数据 把html使用html.parser进行解析
        soup = BeautifulSoup(html, "html.parser")

        # 引入正则表达式，匹配满足的特征的字符串
        for item in soup.find_all("div", class_="item"):   #查找符合要求的字符串，形成列表
            #print(item) #测试:查看电影item全部信息
            #break
            data = []  #用于保存所有数据
            item = str(item)
            Link = re.findall(findLink, item)[0]  # re.findall查询所有符合条件的字符串，返回一个列表
            data.append(Link)
            ImgSrc = re.findall(findImgSrc, item)[0]
            data.append(ImgSrc)
            Titles = re.findall(findTitle, item)     #片名可能只有一个中文名，没有外国名
            if (len(Titles)) == 2:
                ctitle = Titles[0]
                data.append(ctitle)             #添加中文名
                otitle = Titles[1].replace("/","")
                data.append(otitle)            #添加外国名
            else:
                data.append(Titles[0])
                data.append(" ")           #外国名字留空
            Rating = re.findall(findRating, item)[0]
            data.append(Rating)
            Judge = re.findall(findJudge, item)[0]
            data.append(Judge)
            Inq = re.findall(findInq, item)
            if (len(Inq) != 0 ):
                Inq = Inq[0].replace("。","")                     # 去掉 。
                data.append(Inq)
            else:
                data.append(" ")
            Bd = re.findall(findBd, item)[0]
            Bd = re.sub(r'<br(\s+)?/>(\s+)?',"",Bd)   # 去掉换行符<br/>
            Bd = re.sub(r'/', "", Bd)                 # 去掉 /
            data.append(Bd.strip())
            datalist.append(data)
            # print(len(datalist))
    return datalist



def save_data(datalist,save_path):
    book = xlwt.Workbook(encoding="utf-8",style_compression=0)
    sheet = book.add_sheet("豆瓣网电影TOP250",cell_overwrite_ok=True)
    col = ("电影链接","图片链接","电影中文名称","电影外语名称","电影评分","评论人数","电影概述","电影的相关内容")
    for i in range(len(col)):
        sheet.write(0,i,col[i])
    for i in range(len(datalist)):
        data = datalist[i]
        #print('爬到到第%d行了' % i)
        for j in range(len(data)):

            sheet.write(i+1, j,data[j])

    book.save(save_path)

def saveData2DB(datalist,dbpath):
    init_db(dbpath)
    conn =sqlite3.connect(dbpath)
    cur =conn.cursor()
    for data in datalist:
        for index in range(len(data)):
            if index == 4 or index ==5:
                continue
            data[index]='"'+data[index]+'"'
        sql1 ='''
                insert into movie250(info_link,pic_link,cname,ename,score,rated,instroduction,info)
                values(%s)'''% ",".join(data)
        print(sql1)
        cur.execute(sql1)
        conn.commit()
    cur.close()
    conn.close()




def init_db(dbpath):
    sql = '''
        create table movie250
        (
        id integer primary key autoincrement,
        info_link text,
        pic_link text,
        cname varchar,
        ename varchar,
        score numeric,
        rated numeric,
        instroduction text,
        info text
        )
    '''
    print(sql)
    conn = sqlite3.connect(dbpath)
    c = conn.cursor()
    c.execute(sql)
    conn.commit()
    conn.close()

# 爬取单个网页内容
def askurl(url):
    headers = {
        'User-Agent': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) "
                      "Chrome/121.0.0.0 Safari/537.36"
    }
    req = urllib.request.Request(url, headers=headers)
    try:
        response = urllib.request.urlopen(req)
        html = response.read().decode('utf-8')
        # print(html)
    except urllib.error.URLError as e:
        if hasattr(e, "code"):
            print(e.code)
        if hasattr(e, "reason"):
            print(e.reason)
    except Exception as e:
        print(e)

    return html


if __name__ == '__main__':
    main()
    print("爬虫结束")