爬虫：模拟浏览器打开网页，获取网页中我们想要的那部分数据
url :https://movie.douban.com/top250
任务：爬取豆瓣电影top250的基本信息，包括：电影名称、豆瓣评分、评价数、电影概况、电影链接
Screen Shot 2021-11-24 at 3.32.36 PM.png
根据一个网页的链接，找到下一个网页：爬行——获取——爬行
Screen Shot 2021-11-24 at 3.34.49 PM.png
搜索引擎：爬取+索引
基本流程

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

  1. 网页解析
    1. userAgent: 表明你是一个什么版本的浏览器
    2. cookie：存储 读取，用于爬取登陆后才能获取的内容
    3. headers：我们向网页发送请求时，向服务器发送的消息，服务器通过headers验证我们的身份

学习urllib库

  1. import urllib.request
  3. ## 获取一个get请求
  4. response = urllib.request.urlopen("http://www.baidu.com")
  5. ## 返回一个对象，可以用read（）函数获取它的内容，并且用decode来解码，
  6. ## 中文通常用utf-8
  7. print(response.read().decode('utf-8'))
  9. ## 获取一个post请求，模拟用户登陆
  10. ## 测试网站：http://httpbin.org/
  11. import urllib.parse
  12. data = bytes(urllib.parse.urlencode({'hello':'world'}),encoding='utf-8') ## 传入用户名、密码
  13. ## 模拟浏览器发送请求，需要用post的方法来封装数据
  14. response = urllib.request.urlopen('http://httpbin.org/post',data=data)
  15. print(response.read().decode('utf-8'))
  17. ## time out 如果不响应，就pass
  18. ## 超时处理 try catch
  19. try:
  20.     response = urllib.request.urlopen('http://httpbin.org/',timeout=0.01)
  21.     print(response.read().decode('utf-8'))
  22. except urllib.error.URLError as e:
  23.     print('time out!')
  25.  # 测试豆瓣 418 被发现是爬虫，需要把url、headers等封装起来，伪装成一个浏览器
  26. headers = {
  27. "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36"
  28. }
  29. url = 'https://www.douban.com'
  30. ## 封装一个请求，模拟浏览器发出这个请求。
  31. req = urllib.request.Request(url=url,headers=headers,method='POST')
  32. response = urllib.request.urlopen(req)
  33. print(response.read().decode('utf-8'))

beautiful Soup 学习

  1. beautiful Soup中解析的数据类型 ```python “”” BeautifulSoup4将复杂的html文档转换成一个复杂的树形结构，每个节点都是python对象，所有对象可以 归纳成4种 -Tag -NavigableString ## 常用 -BeautifulSoup ## 常用 -Comment “”” from bs4 import BeautifulSoup file = open(‘../豆瓣/baidu.html’,’rb’) html = file.read() bs = BeautifulSoup(html,’html.parser’)

1. Tag 标签及其内容 默认拿到它所找到的第一个内容

如

print(bs.title) print(bs.a) print(bs.head)

print(bs.title.string) print(type(bs.title.string))

2. NavigableString 标签里的内容（字符串）

百度一下，你就知道

print(bs.a.attrs) ## 打印标签的属性，用字典存储

{‘class’: [‘mnav’], ‘href’: ‘http://news.baidu.com‘, ‘name’: ‘tj_trnews’}

3. BeautifulSoup 表示整个文档

print(type(ba)) # 一个类

4. Comment 是一个特殊的NavigableString，输出的内容不包括注释符号

print(bs.a.string) print(type(bs.a.string)

  2. 2. 文档的遍历
  3. ```python
  4. #1.contents： 获取Tag 的所有子节点，返回一个list
  5. print(bs.head.contents) ## 返回是head的内容，存储在一个list中，可以用下表取出
  6. print(bs.head.contents[1]) ## 用列表索引来获取它的某一个元素
  7. # 2. childern： 获取Tag 的所有子节点，返回一个生成器
  8. for child in bs.body.children:
  9.     print(child)
  10. # 3. decendants: 获取tag的所有子孙节点
  11. # 4. strings ：如果tag中包含多个字符串，即在子孙节点中所有内容，可以用此获取，然后进行遍历
  12. # 5. stripped_strings ： 与strings用法一致，只不过可以去除那些多余的空白内容
  13. # 5. parent：获取tag的父节点
  14. ## 等各种乱七八糟的亲戚节点

  1. 文档的搜索

    1. # 1. find_all() # 字符串过滤： 会查找与字符串完全匹配的的内容 返回一个list
    2. t_list = bs.find_all('a')
    3. print(t_list)
    4. #2.正则表达式搜索： 使用search（）方法搜索
    5. import  re
    6. t_list= bs.find_all(re.compile("a"))
    7. print(t_list) # 带a的都找出来了，需要精确匹配
    8. # 3.方法 传入一个函数（方法），根据函数的要求来搜索
    9. def name_is_exists(tag):
    10.  return tag.has_attr("name")
    11. t_list = bs.find_all(name_is_exists) ## 函数作为一个参数传入
    12. print(t_list)
    13. for item in t_list:
    14.  print(item)
    15. #4. kwargs 指定参数
    16. t_list = bs.find_all(id='head')
    17. t_list = bs.find_all(class_='True')
    18. for item in t_list:
    19.   print(item)
    20. #5. text 参数
    21. t_list = bs.find_all(text=['hao123','地图','贴吧'])
    22. t_list = bs.find_all(re.compile("\d")) #应用正则表达式来查找包含特定文本的内容（标签里的字符串）
    23. for item in t_list:
    24.  print(item)
    25. # 6.limit
    26. t_list = bs.find_all('a'，limit= 3) # 限制搜索返回个数
    27. # 7. css选择器
    28. t_list = bs.select('title')
    29. t_list = bs.select('.mnav') # 按类名查找
    30. t_list = bs.select('#u1') # 按id查找
    31. t_list = bs.select('a[class="bri"]') # 按属性查找
    32. t_list = bs.select("head > title") # 按子标签查找
    33. t_list = bs.select('.mnav~.bri') # 按兄弟节点查找 manv 的bri的 兄弟
    34. pring(t_list[0].get_text())
    35. for item in t_list:
    36.  print(item)

  2. 正则表达式

Screen Shot 2021-11-25 at 2.59.24 PM.pngScreen Shot 2021-11-25 at 3.21.03 PM.png
ps：很多用户名要求大小写+_,因为，可以用\w很快匹配

Screen Shot 2021-11-25 at 3.24.44 PM.pngScreen Shot 2021-11-25 at 3.25.39 PM.png

  1. import re
  2. #创建模式对象
  4. pat = re.compile("AA") # 此处的AA,是正则表达式，用来去验证其他的字符串
  5. m = pat.search('CBAABDAACEG') # search字符串被校验的内容. search只返回第一个匹配的
  6. print(m)
  8. m = re.search('asd','Aasd') ## 前：模版 后：被校验的对象
  9. print(m)
  11. print(re.findall("a","ASEAaDNOa"))## 前：模版 后：被校验的对象, 返回list
  12. print(re.findall("[A-Z]","ASEAaDNOa")) # 挑出所有大些字母
  13. print(re.findall("[A-Z]+","ASEAaDNOa"))# 挑出所有大些字母组合
  15. ## sub
  16. print(re.sub("a",'A','abcdliebowb')) # 找到a用A替换，在第三个字符串中替换
  17. ## 建议在正则表达式中，被比较的字符串前面加上r，不用担心转转义字符的问题

爬虫的全过程：

  1. #-*- codeing  = utf-8 -*_
  2. #@Time: 2021/11/22
  3. #@Author: yl-5940
  4. #@File : douban.py
  5. #@Software: PyCharm
  8. from bs4 import  BeautifulSoup ## 网页解析
  9. import re ## 正则表达式，进行文字匹配
  10. import xlwt ## 进行excel操作
  11. import urllib.request,urllib.error  ## 定制URL，获取网页数据
  12. import sqlite3   ## 进行SQLite数据库操作
  14. def main():
  15.     baseurl = 'https://movie.douban.com/top250?start='
  16.     ##1，2.爬取网页、解析数据
  17.     datalist = getData(baseurl)
  18.     ##3.保存数据
  19.     savepath = '豆瓣电影Top250.xls'
  20.     saveData(datalist,savepath)
  21.     ## 4.保存到数据库
  22.     dbpath = 'movie.db'
  23.     saveData2DB(datalist,dbpath)
  25. ## 用正则匹配所需要获取的信息
  26. # 影片详情链接的规则
  27. findLink = re.compile(r'<a href="(.*?)">') # 创建正则表达式对象，表示规则（字符串模式）
  28. # 影片图片
  29. findImgSrc = re.compile(r'<img.*src="(.*?)"',re.S) ## . 不匹配换行符，加上re.S表示忽略换行符，让换行符也包括在内
  30. # 影片片名
  31. findTitle = re.compile(r'<span class="title">(.*)</span>')
  32. # 影片评分
  33. findRating = re.compile(r'<span class="rating_num" property="v:average">(.*)</span>')
  34. # 评价人数
  35. findJudge= re.compile(r'<span>(\d*)人评价</span>')
  36. # 找到概况
  37. findInq = re.compile(r'<span class="inq">(.*)</span>')
  38. # 找到影片相关内容
  39. findBd = re.compile(r'<p class="">(.*?)</p>',re.S)
  41. ## 爬取网页
  42. def getData(baseurl):
  43.     datalist = []
  44.     for i in range(0,10): ## 调用获取页面信息的函数，10次
  45.         url = baseurl + str(i*25)
  46.         html =askURL(url) ## 保存获取到的网页源码
  47.         ## 2. 逐一解析， 采用BeautifulSoup
  48.         soup = BeautifulSoup(html,'html.parser')
  49.         for item in soup.find_all('div', class_="item"):## 查找符合要求的字符串，形成列表
  50.             #print(item) # 测试，查看电影item的全部信息
  51.             data =[]
  52.             item = str(item) ## 转换为str来采用正则
  53.             # 获取影片的超链接
  54.             link = re.findall(findLink,item)[0]
  55.             data.append(link)
  56.             # 获取影片的图片
  57.             imgSrc = re.findall(findImgSrc,item)[0]
  58.             data.append(imgSrc)
  59.             # 获取影片的名字
  60.             titles = re.findall(findTitle, item) ## 片名可能有中英文
  61.             if len(titles)==2:
  62.                 ctitle = titles[0]  # 添加中文名
  63.                 data.append(ctitle)
  64.                 otitle = titles[1].replace('/','') # 添加外文名
  65.                 data.append(otitle)
  66.             else:
  67.                 data.append(titles[0])
  68.                 data.append(' ')  ## 外国名留空、占位 很重要！
  69.             # 获取影片的评分
  70.             rating = re.findall(findRating,item)
  71.             data.append(rating)
  72.             # 获取影片的评价人数
  73.             judgeNum = re.findall(findJudge,item)
  74.             data.append(judgeNum)
  75.             # 获取影片的一句话评价
  76.             inq = re.findall(findInq,item) ## 有的inq可能是空的
  77.             if len(inq) !=0 :
  78.                 inq = inq[0].replace('。','') # 去掉句号
  79.                 data.append(inq)
  80.             else:
  81.                 data.append(' ') ## 留空
  83.             bd = re.findall(findBd,item)[0]
  84.             bd = re.sub('<br(\s+)?/>(\s+)?'," ",bd) # 去掉.<br/>
  85.             bd = re.sub('/'," ",bd) # 替换 /
  86.             data.append(bd.strip()) # 去掉前后空格
  88.             datalist.append(data) ## 把处理好的一步电影的新型放入datalist
  89.     print(datalist)
  90.     return datalist
  93. ## 保存数据
  94. def saveData(datalist,savepath):
  95.     book = xlwt.Workbook(encoding='utf-8',style_compression=0)  ## 创建workbook对象
  96.     sheet = book.add_sheet('豆瓣电影Top250',cell_overwrite_ok=True)  ## 创建工作表
  97.     col = ("电影详情链接",'图片链接','影片中文名','影片外文名','评分','评价人数','概况','相关信息')
  98.     for i in range(0,8):
  99.         sheet.write(0,i,col[i]) ## 写入列名
  100.     for i in range(0,250):
  101.         print("第%d条"%(i+1))
  102.         data = datalist[i]
  103.         for j in range(0,8):
  104.             sheet.write(i+1,j,data[j]) ##
  105.     book.save(savepath)
  109. ## 得到指定一个url网页内容
  110. def askURL(url):
  111.     head = {  ## 模拟浏览器头部信息，向豆瓣服务器发消息
  112.         "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36"
  113.     }  ## 用户代理，表示告诉豆瓣服务器，我们是什么类型的机器，浏览器（本质上是告诉浏览器我们可以接受什么格式的文件）
  115.     request = urllib.request.Request(url, headers=head)
  116.     html = ""
  117.     try:
  118.         response = urllib.request.urlopen(request)
  119.         html = response.read().decode('utf-8')
  120.         #print(html)
  121.     except urllib.error.URLError as e:
  122.         if hasattr(e,'code'):
  123.             print(e.code)
  124.         if hasattr(e,'reason'):
  125.             print(e.reason)
  126.     return html
  129. ## 储存到数据库
  130. def saveData2DB(datalist,dbpath):
  131.     init_db(dbpath)
  132.     conn = sqlite3.connect(dbpath)
  133.     cur =conn.cursor()
  135.     for data in datalist:
  136.         for index in range(len(data)):
  137.             #print(type(data[index]))
  138.             if type(data[index]) == list:## 评分和评价人数type是list, 不要换成str，否则无法写入
  139.                 data[index] = data[index][0]
  140.             else:
  141.                 data[index] = '"'+str(data[index]) +'"'
  142.         sql = '''
  143.             insert into movie250(
  144.             info_link,pic_link,cname,ename, score,rated,introduction,info)
  145.             values(%s)'''%",".join(data)
  146.         cur.execute(sql)
  147.         conn.commit()
  148.     cur.close()
  149.     conn.close()
  150. def init_db(dbpath):
  151.     # 创建数据表
  152.     sql = '''   
  153.         create table movie250
  154.         (
  155.         id integer primary key autoincrement,
  156.         info_link text,
  157.         pic_link text,
  158.         cname varchar,
  159.         ename varchar,
  160.         score numeric,
  161.         rated numeric,
  162.         introduction text,
  163.         info text
  164.         )
  165.     '''
  166.     conn = sqlite3.connect(dbpath)
  167.     cursor = conn.cursor()
  168.     cursor.execute(sql)
  169.     conn.commit()
  170.     conn.close()
  175. if __name__ == "__main__" :   ## 当程序执行时
  176.     ## 调用函数 ，可以空值函数和代码的主流程
  177.     ## 可以用于测试代码，让程序控制在此语句下
  178.     main()