Python Spider学习笔记（一）：爬取B站视频基本信息

 一、创作来源

         最近搞数据分析需要爬取B站上相关视频的内容，但打开两年前的代码却发现已经跑不通了，或者说根本就是漏洞百出。经过一段时间的缝缝补补，我发现是B站的网页代码更换的原因。（应该是吧，不确定哈！）由于当时写代码的时候也是东抄西抄，最后搞得自己也看不懂是什么意思（鬼知道当时的程序怎么跑起来的）。索性从头来过，自己学自己写。

二、第一部分：利用Selenium获取BV_ID

        对于B站视频来说，只要知道了他的BV号就相当于一个人你知道了他的身份证号，想要知晓他的更多的信息也就不是什么难事儿了，因此在本文中，我们要进行的第一步就是获取到我们想要爬取信息的B站视频的身份证——BV_ID。

        这是第一步，也是最关键的一步。这个时候就需要用到selenium这个库，关于这个库的详细介绍和科普可以去别的博客下了解，这里我们不过多赘述。

Selenium库的安装：

pip install selenium

具体使用方法如下：

        引入必要的库

1. from selenium import webdriver
2. from selenium.webdriver.common.by import By
3. from selenium.webdriver.chrome.options import Options

定义一个selenium的爬虫

        这里只用关键词作为形参，其余的部分都可以以这些关键词为核心进行生成

1. def spider_bvid(keyword):
2. """
3. 利用seleniume获取搜索结果的bvid，供给后续程序使用
4. :param keyword: 搜索关键词
5. :return: 生成去重的output_filename = f'{keyword}BV号.csv'
6. """

         首先，定义一个用于写入爬取结果的文件，这里因为数据量大，我选择了csv文件，大家在自己运行的时候，可以选择自己喜欢的文件形式。

        接着设置无界面爬虫，窗口大小并禁用gpu加速，以减少浏览器的内存占用，防止出现浏览器崩溃的情况。

1. # 保存的文件名
2. input_filename = f'{keyword}BV号.csv'
4. # 启动爬虫
5. options = Options()
6. options.add_argument('--headless')
7. options.add_argument('--disable-gpu')
8. browser = webdriver.Chrome(options=options) # 设置无界面爬虫
9. browser.set_window_size(1400, 900) # 设置全屏，注意把窗口设置太小的话可能导致有些button无法点击
10. browser.get('https://bilibili.com')
11. # 刷新一下，防止搜索button被登录弹框遮住
12. browser.refresh()
13. print("============成功进入B站首页！！！===========")

        利用网页元素定位找到B站首页的搜索框和搜索按钮，输入我们要搜索的关键词，确定点击搜索按钮。

1. input = browser.find_element(By.CLASS_NAME, 'nav-search-input')
2. button = browser.find_element(By.CLASS_NAME, 'nav-search-btn')
4. # 输入关键词并点击搜索
5. input.send_keys(keyword)
6. button.click()
7. print(f'==========成功搜索{keyword}相关内容==========')

        成功进入搜索结果页面后，我们本来的技术思路是：1、根据网页元素定位，css、xpath或其他方法定位到页面最下方的页数box和下一页box；2、通过获取最后一页的box中的text值和下一页的text值，利用循环不断模拟点击下一页，从而达到爬取所有结果页面的内容的目的。

        但B站网页代码更改后，显示为34页，网页内容检查后显示为42页（至多），因而会导致页面定位的不同，在我个人运行程序的过程中，出现过第一个关键词搜索可以定位到最大页数box，但是利用循环输入的下一个keyword就无法定位到相同的box。

        因而我们更换思路：B站搜索结果显示的并非全部内容，而是至多一千多个，也就是说页面数最大是42页。因而当我们手动搜索后发现结果页面页数较多时，可以直接设置最大页数为42。

        同样，由于本小白并不会定位这个新的下一页按钮，因而我通过循环输入页码数，拼成搜索的网页URL进而达到与模拟点击下一页相同的效果。但这种操作方法的结果就是会出现重复爬取第情况，因而需要在最后进行去重操作。

        另外值得一说的是，如果各位像研究元素定位到话，我之前看到本站里有一位大佬“潘帕斯的雄鹰”，他写了一个只用selenium进行滚动爬取搜索结果下所有视频的一级、二级评论的博客。代码是开源的，那个里面的定位和断点续爬都做得很好，有时间的话可以研究一下。

1. # 设置窗口
2. all_h = browser.window_handles
3. browser.switch_to.window(all_h[1])
5. # B站最多显示42页
6. total_page = 42
7. # 同样由于B站网页代码的更改，通过找到并点击下一页的方式个人暂不能实现
8. #（对，不会分析那个破网页！！！）
10. for i in range(0, total_page):
11. # url 需要根据不同关键词进行调整内容！！！
12. # 这里的url需要自己先搜索一下然后复制网址进来
13. url = (f"https://search.bilibili.com/all?keyword={keyword}"
14. f"&from_source=webtop_search&spm_id_from='你自己的'&search_source='你自己的'&page={i}")
16. print(f"===========正在尝试获取第{i + 1}页网页内容===========")
17. print(f"===========本次的url为：{url}===========")
18. browser.get(url)
19. # 这里请求访问网页的时间也比较久(可能因为我是macos)，所以是否需要等待因设备而异
20. # 取消刷新并长时间休眠爬虫以避免爬取太快导致爬虫抓取到js动态加载源码
21. # browser.refresh()
22. print('正在等待页面加载：3')
23. time.sleep(1)
24. print('正在等待页面加载：2')
25. time.sleep(1)
26. print('正在等待页面加载：1')
27. time.sleep(1)

        能够顺利获取到所有页面结果之后，我们就可以直接分析页面，因为我们只需要获取到BV号就可以，因此并不需要重复爬取一些后面可以轻易获得的数据。

        这里直接使用bs4对页面进行分析，直接定位到card中的herf，获取每个视频的详情页URL，在这个URL中可以拆分出我们需要的BV号。

1. # 直接分析网页
2. html = browser.page_source
3. # print("网页源码" + html) 用于判断是否获取成功
4. soup = BeautifulSoup(html, 'lxml')
5. infos = soup.find_all(class_='bili-video-card')
6. bv_id_list = []
7. for info in infos:
8. # 只定位视频链接
9. href = info.find('a').get('href')
10. # 拆分
11. split_url_data = href.split('/')
12. # 利用循环删除拆分出现的空白
13. for element in split_url_data:
14. if element == '':
15. split_url_data.remove(element)
16. # 打印检验内容
17. # print(split_url_data)
18. # 获取bvid
19. bvid = split_url_data[2]
21. # 利用if语句直接去重
22. if bvid not in bv_id_list:
23. bv_id_list.append(bvid)
24. for bvid_index in range(0, len(bv_id_list)):
25. # 写入 input_filename
26. write_to_csv_bvid(input_filename, bv_id_list[bvid_index])
27. # 输出提示进度
28. print('写入文件成功')
29. print("===========成功获取第" + str(i + 1) + "次===========")
30. time.sleep(1)
31. i += 1
33. # 退出爬虫
34. browser.quit()
36. # 打印信息显示是否成功
37. print(f'==========爬取完成。退出爬虫==========')

        写入文件后，我们就能得到去重之后的BV号了，下面就可以通过BV号来爬取我们需要的视频的基本信息了。

三、第二部分 Request函数请求访问

        Request函数不用多说，涉及到爬虫的程序大多都会用到，这里也不再赘述。另一方面，使用request函数的原因是bilibili的api开放接口可以轻松地获取到我们想要的信息。

        这里也可以使用bilibili-api库，但本文不使用的原因是：bilibili-api库在获取视频详细信息时需要进行异步请求，但直接在循环中调用异步请求的函数会导致各种报错，小白肯定是无法解决的，哪怕翻阅资料也很难看懂。（对，就是我没看懂。）例如：     aiohttp.client_exceptions.ServerDisconnectedError: Server disconnected、pipe broken等。

        因此这里用比较笨的方法，通过BV号拼接成视频数据api接口的URL在进行访问，返回的页面转成json格式，然后直接读取json字典中的值，进行调用。

        这里想要了解更多B站API接口的，可以去Github上查看。

https://github.com/SocialSisterYi/bilibili-API-collect

        此处的关于视频信息的API接口URL为：

1. #A EXAMPLE : https://api.bilibili.com/x/web-interface/view?bvid=BV1n24y1D75V
2. api_url = f'https://api.bilibili.com/x/web-interface/view?bvid={bv_id}'

写在最前面：使用Request函数时，一定要注意时间间隔。如果你的设备接入URL很快，那么可以适当增加间隔，如果接入较慢，可以适当减少间隔。Time.sleep()的数值至少要大于1.5s，不然轻则报错，重则被叔叔封网络IP。（当然，如果真的被封IP了，换个网络环境就行了。比如你在家里用的无线网，那么切换到自己的手机流量热点就可以解决。）

requests.exceptions.SSLError: HTTPSConnectionPool(host='api.bilibili.com', port=443)

        具体的调用代码为：

        首先，我们需要编写我们自己的请求头。User-Agenta是我们自己的网络代理，可以有chrome、firefox等，Cookies就是网站获取到一些记录文件，主要用于识别。这两个值都可以通过网页抓包来获取。以Chrome为例，登录B站后，点开任意一个视频播放后，按下F12（win）或option+command+I（mac）后，进入network部分，尽量找到total?list开头的js文件，里面就可以比较轻松地找到我们需要的这两个值。

        接着，传入BV号后，拼接成可用的URL后，可以自己拼好后先用浏览器打开进行检验和分析一下，以确保URL的有效性。之后，利用json库返回json形式的网页源码。返回的值基本是字典，很好操作。

1. def get_video_info(bv_id):
2. headers = {
3. 'User-Agent': "你的",
4. 'Cookie': "你的"}
6. api_url = f'https://api.bilibili.com/x/web-interface/view?bvid={bv_id}'
7. # 打印本次要获取的bvid，用于错误时确认
8. print(f"正在进行爬取uid为：{bv_id}的UP主的粉丝数量与作品总数")
9. print(f"==========本次获取数据的视频BV号为：{bv_id}==========")
10. print(f"url为：{api_url}")
11. # https://api.bilibili.com/x/web-interface/view?BV1n24y1D75V
12. video_info = requests.get(url=api_url, headers=headers)
13. video_info_json = json.loads(video_info.text)

        得到网页源码后，我们需要的值都存放在"data"标签中，直接根据我们对需要进行调用就可以。我这里是新建了一个字典，进行存储值，大家也可以不用这么麻烦。 对于相关值，英文名对应的中文意义，可以参考这篇知乎专栏的介绍，也可在上面的github文档中进行查看。

1. # 创建存放的字典
2. info_dict = {}
3. # 信息解读
4. # https://zhuanlan.zhihu.com/p/618885790
5. # 视频bvid，即bv号
6. bvid = video_info_json['data']['bvid']
7. info_dict['bvid'] = bvid
8. # 视频aid，即av号
9. aid = video_info_json['data']['aid']
10. info_dict['aid'] = aid
11. # 视频cid，用于获取弹幕信息
12. cid = video_info_json['data']['cid']
13. info_dict['cid'] = cid
14. # 作者id
15. mid = video_info_json['data']['owner']['mid']
16. info_dict['mid'] = mid
17. # up主昵称
18. name = video_info_json['data']['owner']['name']
19. info_dict['name'] = name
20. # 视频标题
21. title = video_info_json['data']['title']
22. info_dict['title'] = title
23. # 视频标签
24. tname = video_info_json['data']['tname']
25. info_dict['tname'] = tname
26. # 视频发布时间戳
27. pubdate = video_info_json['data']['pubdate']
28. # 转化时间戳
29. pub_datatime = datetime.fromtimestamp(pubdate)
30. # 整体格式
31. pub_datatime_strf = pub_datatime.strftime('%Y-%m-%d %H:%M:%S')
32. # 日期
33. date = re.search(r"(\d{4}-\d{1,2}-\d{1,2})", pub_datatime_strf)
34. info_dict['pub_date'] = date.group()
35. # 时间
36. pub_time = re.search(r"(\d{1,2}:\d{1,2}:\d{1,2})", pub_datatime_strf)
37. info_dict['pub_time'] = pub_time.group()
38. # 视频创建时间戳
39. # ctime = info['ctime']
40. # 视频简介
41. desc = video_info_json['data']['desc']
42. info_dict['desc'] = desc
43. # 视频播放量
44. view = video_info_json['data']['stat']['view']
45. info_dict['view'] = view
46. # 点赞数
47. like = video_info_json['data']['stat']['like']
48. info_dict['like'] = like
49. # 投币数
50. coin = video_info_json['data']['stat']['coin']
51. info_dict['coin'] = coin
52. # 收藏数
53. favorite = video_info_json['data']['stat']['favorite']
54. info_dict['favorite'] = favorite
55. # 分享数
56. share = video_info_json['data']['stat']['share']
57. info_dict['share'] = share
58. # 评论数
59. repiy = video_info_json['data']['stat']['reply']
60. info_dict['reply'] = repiy
61. # 视频弹幕数量
62. danmaku = video_info_json['data']['stat']['danmaku']
63. info_dict['danmaku'] = danmaku
65. print(f'=========={bv_id} 的视频基本信息已成功获取==========')
67. # 发布作品时的动态
68. # dynamic = info['dynamic']
69. print('正在等待，以防访问过于频繁\n')
70. time.sleep(3)
72. return info_dict

        如此就返回了带有我们数据的字典，后续可以直接调用。

        获取UP主信息的整体思路相同，这里就不再赘述，直接贴上代码：

        

1. def get_user_info(uid):
2. """
3. 通过uid(即mid)获取UP主的粉丝总数和作品总数
4. :param uid: mid
5. :return:user_info_dict
6. """
7. # 定义空字典用于存放数据
8. # 粉丝数 follower
9. # 作品总数 archive
10. user_info_dict = {}
11. # 首先写入请求头
12. # 设置用户代理 User_Agent及Cookies
13. headers = {
14. 'User-Agent': "",
15. 'Cookie': ""}
17. # 将传入的的uid组成up主主页的api_url
18. # A Example: https://api.bilibili.com/x/web-interface/card?mid=1177893348
19. api_url = f'https://api.bilibili.com/x/web-interface/card?mid={uid}'
20. # https://api.bilibili.com/x/web-interface/view?BV1n24y1D75V
21. # 打印次数，数据量大，便于查看进程
22. print(f"正在进行爬取uid为：{uid}的UP主的粉丝数量与作品总数")
24. # 打印本次要获取的uid，用于错误时确认
25. print(f"==========本次获取数据的up主的uid为：{uid}==========")
26. print(f"url为{api_url}")
28. # 利用requests进行访问，并返回需要的封装信息
29. up_info = requests.get(url=api_url, headers=headers)
31. # 不知道会不会被封ip，保险起见
32. # time.sleep(2)
34. # 将数据转化为json格式
35. up_info_json = json.loads(up_info.text)
37. # 利用json定位相关数据
38. fans_number = up_info_json['data']['card']['fans']
39. user_info_dict['follower'] = fans_number
40. archive_count = up_info_json['data']['archive_count']
41. user_info_dict['archive'] = archive_count
43. print(f'=========={bv_id} 的作者基本信息已成功获取==========\n')
45. # 等待
46. print('正在等待，以防访问过于频繁\n')
47. time.sleep(1.5)
48. return user_info_dict

四、第三部分 最后的调用

        上面的函数都写好之后，我们只需要创建一个主入口，之后直接调用函数就可以。

1. if __name__ == '__main__':
3. # 针对不同内容修改搜索关键词！！！！
4. keywords = ["1", "2"]
5. for keyword in keywords:
6. # 自动爬取多个主题时须注意上面的最大页数定位问题
7. # 爬取后生成去重了的len(keywords)个f'{keyword}BV号.csv'文件
8. spider_bvid(keyword)
9. for keyword in keywords:
10. # 拼接成文件名
11. csv_to_merge = f'{keyword}BV号.csv'
12. # 合并后生成未去重的文件
13. merge_csv(input_filename=csv_to_merge, output_filename='BV号合并.csv')
16. # 遍历读取bv_id
17. filename = 'BV号合并.csv'
18. # 打开文件并去重
19. open_csv = pd.read_csv(filename)
20. open_csv.drop_duplicates(subset='BV号')
21. bv_id_list = np.array(open_csv['BV号'])
22. """
23. # 第一次调用，若读取csv进行爬取时，意外中断
24. # 则更改为读取txt文本，将已爬取第bvid删除，以达到断点续爬的目的
25. for bvid in bv_id_list:
26. with open("bv_id_list.txt", 'a') as f:
27. f.write(bvid+'\n')
28. """
29. with open("bv_id_list.txt", 'r') as f:
30. bv_id_list = f.readlines()
31. # 循环写入内容
32. for i in range(0, len(bv_id_list)):
33. bv_id = bv_id_list[i]
34. print(f'正在进行第{i+1}次爬取\n')
35. # 获取视频所有的基本信息
36. video_info = get_video_info(bv_id)
37. bvid = video_info['bvid']
38. aid = video_info['aid']
39. cid = video_info['cid']
40. mid = video_info['mid']
41. name = video_info['name']
42. title = video_info['title']
43. tname = video_info['tname']
44. pub_date = video_info['pub_date']
45. pub_time = video_info['pub_time']
46. desc = video_info['desc']
47. view = video_info['view']
48. like = video_info['like']
49. coin = video_info['coin']
50. favorite = video_info['favorite']
51. share = video_info['share']
52. reply = video_info['reply']
53. danmaku = video_info['danmaku']
55. # 传播效果计算公式
56. Communication_Index = math.log(
57. 0.5 * int(view) + 0.3 * (int(like) + int(coin) + int(favorite)) + 0.2 * (int(reply) + int(danmaku)))
58. # 获取作者的相关信息
59. user_info = get_user_info(uid=mid)
60. follower = user_info['follower']
61. archive = user_info['archive']
62. write_to_csv(filename='视频基本信息.csv', bvid=bvid, aid=aid, cid=cid, mid=mid, name=name, follower=follower,
63. archive=archive, title=title, tname=tname, pub_date=pub_date, pub_time=pub_time, desc=desc,
64. view=view, like=like, coin=coin, favorite=favorite, share=share, reply=reply, danmaku=danmaku,
65. communication_index=Communication_Index)
66. print(f'==========第{i+1}个BV号：{bv_id}的相关数据已写入csv文件中==========')
67. print('==================================================\n')

五、完整代码

        需要注明的一些事情：

        1、writr_to_csv()函数是抄的大佬的代码，虽然后面else基本用不到，但是前面的真的很好用，大家可以自己理解一下再改一改。

        2、关于传播效果计算公式，这个是引用自己大佬的论文，如果有需要请注明引用，学术不端是很严重的事情。

        引用：陈强，张杨一，马晓悦，等. 政务 B 站号信息传播效果影响因素与实证研究[J]. 图书情报工作，2020，64( 22) : 126 - 134.

        3、代码中的一些部分，我是以非常笨的方法解决到，有同学优化了之后请贴在评论区交流学习。

1. # -*- coding: utf-8 -*-
2. """
3. @ Project : pythonProject
4. @ File : spider bilibi.py
5. @ IDE : PyCharm
6. @ Auther : Avi-OvO-CreapDiem
7. @ Date : 2023/9/2 08:49
8. @ Purpose :
9. """
11. import re
12. import os
13. import csv
14. import time
15. import math
16. import json
17. import requests
18. import numpy as np
19. import pandas as pd
20. from datetime import datetime
21. from bs4 import BeautifulSoup
22. from selenium import webdriver
23. from selenium.webdriver.common.by import By
24. from selenium.webdriver.chrome.options import Options
27. def merge_csv(input_filename, output_filename):
28. """
29. 读取csv文件内容，并写入新的文件
30. :param input_filename: 传入的文件名称
31. :param output_filename: 写入的新文件的名称
32. :return: 向新文件中写入input_filename中的内容
33. """
35. # 读取文件
36. csv_data_read = pd.read_csv(input_filename)
37. # 获取文件总行数
38. number_of_row = (len(csv_data_read))
39. # 循环该csv文件中的所有行，并写入信息
40. for i in range(0, number_of_row):
41. row_info = csv_data_read.values[i]
42. # 输出查看内容
43. # print(row_info)
44. # 具体内容
45. row_content = row_info[0]
46. # 写入
47. write_to_csv_bvid(output_filename, row_content)
48. # 退出循环
49. # 打印进度
50. print(f'成功向{output_filename}中写入了{input_filename}的全部信息')
53. def write_to_csv_bvid(input_filename, bvid):
54. """
55. 写入新的csv文件，若没有则创建，须根据不同程序进行修改
56. :param input_filename: 写入的文件名称
57. :param bvid: BV号
58. :return: 生成写入的input_filename文件
59. """
60. # OS 判断路径是否存在
61. file_exists = os.path.isfile(input_filename)
62. # 设置最大尝试次数
63. max_retries = 50
64. retries = 0
66. while retries < max_retries:
67. try:
68. with open(input_filename, mode='a', encoding='utf-8', newline='') as csvfile:
69. fieldnames = ['BV号']
70. writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
72. if not file_exists:
73. writer.writeheader()
75. writer.writerow({
76. 'BV号': bvid
77. })
78. # print('写入文件成功')
79. break # 如果成功写入，跳出循环
80. except PermissionError as e:
81. retries += 1
82. print(f"将爬取到的数据写入csv时，遇到权限错误Permission denied，文件可能被占用或无写入权限: {e}")
83. print(f"等待3s后重试，将会重试50次... (尝试 {retries}/{max_retries})")
84. time.sleep(3) # 等待10秒后重试
85. else:
86. print("将爬取到的数据写入csv时遇到权限错误，且已达到最大重试次数50次，退出程序")
89. def spider_bvid(keyword):
90. """
91. 利用seleniume获取搜索结果的bvid，供给后续程序使用
92. :param keyword: 搜索关键词
93. :return: 生成去重的output_filename = f'{keyword}BV号.csv'
94. """
95. # 保存的文件名
96. input_filename = f'{keyword}BV号.csv'
98. # 启动爬虫
99. options = Options()
100. options.add_argument('--headless')
101. options.add_argument('--disable-gpu')
102. browser = webdriver.Chrome(options=options) # 设置无界面爬虫
103. browser.set_window_size(1400, 900) # 设置全屏，注意把窗口设置太小的话可能导致有些button无法点击
104. browser.get('https://bilibili.com')
105. # 刷新一下，防止搜索button被登录弹框遮住
106. browser.refresh()
107. print("============成功进入B站首页！！！===========")
108. input = browser.find_element(By.CLASS_NAME, 'nav-search-input')
109. button = browser.find_element(By.CLASS_NAME, 'nav-search-btn')
111. # 输入关键词并点击搜索
112. input.send_keys(keyword)
113. button.click()
114. print(f'==========成功搜索{keyword}相关内容==========')
116. # 设置窗口
117. all_h = browser.window_handles
118. browser.switch_to.window(all_h[1])
119. """
120. # 这里可以通过xpath或者其他方法找到B站搜索结果页最下方的页码数值
121. # 但B站网页代码更改后，显示为34页，网页内容检查后显示为42页（至多）
122. # 由于我们的搜索结果很多，肯定超出B站最大显示的42页，故而直接设置最大页数为42
123. # 找到最后一个页码所在位置，并获取值
124. # total_btn = browser.find_element(By.XPATH,"//*[@id="i_cecream"]/div/div[2]/div[2]/div/div/div/div[4]/div/div/button[9]"")
125. # //*[@id="i_cecream"]/div/div[2]/div[2]/div/div/div/div[4]/div/div/button[9]
126. # total = int(total_btn)
127. # print(f'==========成功搜索！ 总页数: {total}==========')
128. """
130. # B站最多显示42页
131. total_page = 42
132. # 同样由于B站网页代码的更改，通过找到并点击下一页的方式个人暂不能实现（对，不会分析那个破网页！！！）
133. # 因此这里利用总页数进行循环访问来实现自动翻页的效果
135. for i in range(0, total_page):
136. # url 需要根据不同关键词进行调整内容！！！
137. url = (f"https://search.bilibili.com/all?keyword={keyword}"
138. f"&from_source=webtop_search&spm_id_from=333.1007&search_source=5&page={i}")
140. print(f"===========正在尝试获取第{i + 1}页网页内容===========")
141. print(f"===========本次的url为：{url}===========")
142. browser.get(url)
143. # 这里请求访问网页的时间也比较久(可能因为我是macos)，所以是否需要等待因设备而异
144. # 取消刷新并长时间休眠爬虫以避免爬取太快导致爬虫抓取到js动态加载源码
145. # browser.refresh()
146. print('正在等待页面加载：3')
147. time.sleep(1)
148. print('正在等待页面加载：2')
149. time.sleep(1)
150. print('正在等待页面加载：1')
151. time.sleep(1)
153. # 直接分析网页
154. html = browser.page_source
155. # print("网页源码" + html) 用于判断是否获取成功
156. soup = BeautifulSoup(html, 'lxml')
157. infos = soup.find_all(class_='bili-video-card')
158. bv_id_list = []
159. for info in infos:
160. # 只定位视频链接
161. href = info.find('a').get('href')
162. # 拆分
163. split_url_data = href.split('/')
164. # 利用循环删除拆分出现的空白
165. for element in split_url_data:
166. if element == '':
167. split_url_data.remove(element)
168. # 打印检验内容
169. # print(split_url_data)
170. # 获取bvid
171. bvid = split_url_data[2]
173. # 利用if语句直接去重
174. if bvid not in bv_id_list:
175. bv_id_list.append(bvid)
176. for bvid_index in range(0, len(bv_id_list)):
177. # 写入 input_filename
178. write_to_csv_bvid(input_filename, bv_id_list[bvid_index])
179. # 输出提示进度
180. print('写入文件成功')
181. print("===========成功获取第" + str(i + 1) + "次===========")
182. time.sleep(1)
183. i += 1
185. # 退出爬虫
186. browser.quit()
188. # 打印信息显示是否成功
189. print(f'==========爬取完成。退出爬虫==========')
192. def write_to_csv(filename, bvid, aid, cid, mid, name, follower, archive, title, tname, pub_date, pub_time, desc,
193. view, like, coin, favorite, share, reply, danmaku, communication_index):
194. """
195. 向csv文件中写入B站视频相关的基本信息，未按路径找到文件，则新建文件
196. :param filename: 写入数据的文件名
197. :param bvid: BV号
198. :param aid: AV号
199. :param cid: 用于获取弹幕文本的
200. :param mid: UP主的ID
201. :param name: UP主名称
202. :param follower: UP主粉丝数
203. :param archive: UP主作品总数
204. :param title: 标题
205. :param tname: tag名称
206. :param pub_date: 发布日期
207. :param pub_time: 发布时间
208. :param desc: 视频简介
209. :param view: 播放量
210. :param like: 点赞数
211. :param coin: 投币数
212. :param favorite: 收藏数
213. :param share: 分享数
214. :param reply: 评论数
215. :param danmaku: 弹幕数
216. :param communication_index: 传播效果公式的值
217. :return:
218. """
219. file_exists = os.path.isfile(filename)
220. max_retries = 50
221. retries = 0
223. while retries < max_retries:
224. try:
225. with open(filename, mode='a', encoding='utf-8', newline='') as csvfile:
226. fieldnames = ['BV号', 'AV号', 'CID', 'UP主ID', 'UP主名称', 'UP主粉丝数', '作品总数', '视频标题',
227. '视频分类标签',
228. '发布日期', '发布时间', '视频简介', '播放量', '点赞数', '投币数', '收藏数', '分享数',
229. '评论数',
230. '弹幕数', '传播效果指数']
231. writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
233. if not file_exists:
234. writer.writeheader()
236. writer.writerow({
237. 'BV号': bvid, 'AV号': aid, 'CID': cid, 'UP主ID': mid, 'UP主名称': name, 'UP主粉丝数': follower,
238. '作品总数': archive, '视频标题': title, '视频分类标签': tname, '发布日期': pub_date,
239. '发布时间': pub_time,
240. '视频简介': desc, '播放量': view, '点赞数': like, '投币数': coin, '收藏数': favorite,
241. '分享数': share,
242. '评论数': reply, '弹幕数': danmaku, '传播效果指数': communication_index
243. })
244. break # 如果成功写入，跳出循环
245. except PermissionError as e:
246. retries += 1
247. print(f"将爬取到的数据写入csv时，遇到权限错误Permission denied，文件可能被占用或无写入权限: {e}")
248. print(f"等待3s后重试，将会重试50次... (尝试 {retries}/{max_retries})")
249. else:
250. print("将爬取到的数据写入csv时遇到权限错误，且已达到最大重试次数50次，退出程序")
253. def get_user_info(uid):
254. """
255. 通过uid(即mid)获取UP主的粉丝总数和作品总数
256. :param uid: mid
257. :return:user_info_dict
258. """
259. # 定义空字典用于存放数据
260. # 粉丝数 follower
261. # 作品总数 archive
262. user_info_dict = {}
263. # 首先写入请求头
264. # 设置用户代理 User_Agent及Cookies
265. headers = {
266. 'User-Agent': "",
267. 'Cookie': ""}
269. # 将传入的的uid组成up主主页的api_url
270. # A Example: https://api.bilibili.com/x/web-interface/card?mid=1177893348
271. api_url = f'https://api.bilibili.com/x/web-interface/card?mid={uid}'
272. # https://api.bilibili.com/x/web-interface/view?BV1n24y1D75V
273. # 打印次数，数据量大，便于查看进程
274. print(f"正在进行爬取uid为：{uid}的UP主的粉丝数量与作品总数")
276. # 打印本次要获取的uid，用于错误时确认
277. print(f"==========本次获取数据的up主的uid为：{uid}==========")
278. print(f"url为{api_url}")
280. # 利用requests进行访问，并返回需要的封装信息
281. up_info = requests.get(url=api_url, headers=headers)
283. # 不知道会不会被封ip，保险起见
284. # time.sleep(2)
286. # 将数据转化为json格式
287. up_info_json = json.loads(up_info.text)
289. # 利用json定位相关数据
290. fans_number = up_info_json['data']['card']['fans']
291. user_info_dict['follower'] = fans_number
292. archive_count = up_info_json['data']['archive_count']
293. user_info_dict['archive'] = archive_count
295. print(f'=========={bv_id} 的作者基本信息已成功获取==========\n')
297. # 等待
298. print('正在等待，以防访问过于频繁\n')
299. time.sleep(1.5)
300. return user_info_dict
303. def get_video_info(bv_id):
304. headers = {
305. 'User-Agent': "",
306. 'Cookie': ""}
308. api_url = f'https://api.bilibili.com/x/web-interface/view?bvid={bv_id}'
309. # 打印本次要获取的bvid，用于错误时确认
310. print(f"正在进行爬取uid为：{bv_id}的UP主的粉丝数量与作品总数")
311. print(f"==========本次获取数据的视频BV号为：{bv_id}==========")
312. print(f"url为：{api_url}")
313. # https://api.bilibili.com/x/web-interface/view?BV1n24y1D75V
314. video_info = requests.get(url=api_url, headers=headers)
315. video_info_json = json.loads(video_info.text)
316. # 创建存放的字典
317. info_dict = {}
318. # 信息解读
319. # https://zhuanlan.zhihu.com/p/618885790
320. # 视频bvid，即bv号
321. bvid = video_info_json['data']['bvid']
322. info_dict['bvid'] = bvid
323. # 视频aid，即av号
324. aid = video_info_json['data']['aid']
325. info_dict['aid'] = aid
326. # 视频cid，用于获取弹幕信息
327. cid = video_info_json['data']['cid']
328. info_dict['cid'] = cid
329. # 作者id
330. mid = video_info_json['data']['owner']['mid']
331. info_dict['mid'] = mid
332. # up主昵称
333. name = video_info_json['data']['owner']['name']
334. info_dict['name'] = name
335. # 视频标题
336. title = video_info_json['data']['title']
337. info_dict['title'] = title
338. # 视频标签
339. tname = video_info_json['data']['tname']
340. info_dict['tname'] = tname
341. # 视频发布时间戳
342. pubdate = video_info_json['data']['pubdate']
343. # 转化时间戳
344. pub_datatime = datetime.fromtimestamp(pubdate)
345. # 整体格式
346. pub_datatime_strf = pub_datatime.strftime('%Y-%m-%d %H:%M:%S')
347. # 日期
348. date = re.search(r"(\d{4}-\d{1,2}-\d{1,2})", pub_datatime_strf)
349. info_dict['pub_date'] = date.group()
350. # 时间
351. pub_time = re.search(r"(\d{1,2}:\d{1,2}:\d{1,2})", pub_datatime_strf)
352. info_dict['pub_time'] = pub_time.group()
353. # 视频创建时间戳
354. # ctime = info['ctime']
355. # 视频简介
356. desc = video_info_json['data']['desc']
357. info_dict['desc'] = desc
358. # 视频播放量
359. view = video_info_json['data']['stat']['view']
360. info_dict['view'] = view
361. # 点赞数
362. like = video_info_json['data']['stat']['like']
363. info_dict['like'] = like
364. # 投币数
365. coin = video_info_json['data']['stat']['coin']
366. info_dict['coin'] = coin
367. # 收藏数
368. favorite = video_info_json['data']['stat']['favorite']
369. info_dict['favorite'] = favorite
370. # 分享数
371. share = video_info_json['data']['stat']['share']
372. info_dict['share'] = share
373. # 评论数
374. repiy = video_info_json['data']['stat']['reply']
375. info_dict['reply'] = repiy
376. # 视频弹幕数量
377. danmaku = video_info_json['data']['stat']['danmaku']
378. info_dict['danmaku'] = danmaku
380. print(f'=========={bv_id} 的视频基本信息已成功获取==========')
382. # 发布作品时的动态
383. # dynamic = info['dynamic']
384. print('正在等待，以防访问过于频繁\n')
385. time.sleep(1.5)
387. return info_dict
390. if __name__ == '__main__':
392. # 针对不同内容修改搜索关键词！！！！
393. keywords = ["1", "2"]
394. for keyword in keywords:
395. # 自动爬取多个主题时须注意上面的最大页数定位问题
396. # 爬取后生成去重了的len(keywords)个f'{keyword}BV号.csv'文件
397. spider_bvid(keyword)
398. for keyword in keywords:
399. # 拼接成文件名
400. csv_to_merge = f'{keyword}BV号.csv'
401. # 合并后生成未去重的文件
402. merge_csv(input_filename=csv_to_merge, output_filename='BV号合并.csv')
405. # 遍历读取bv_id
406. filename = 'BV号合并.csv'
407. # 打开文件并去重
408. open_csv = pd.read_csv(filename)
409. open_csv.drop_duplicates(subset='BV号')
410. bv_id_list = np.array(open_csv['BV号'])
412. """
413. # 第一次调用，若读取csv进行爬取时，意外中断
414. # 则更改为读取txt文本，将已爬取第bvid删除，以达到断点续爬的目的
415. for bvid in bv_id_list:
416. with open("bv_id_list.txt", 'a') as f:
417. f.write(bvid+'\n')
418. with open("bv_id_list.txt", 'r') as f:
419. bv_id_list = f.readlines()
420. """
423. # 循环写入内容
424. for i in range(0, len(bv_id_list)):
425. bv_id = bv_id_list[i]
426. print(f'正在进行第{i+1}次爬取\n')
427. # 获取视频所有的基本信息
428. video_info = get_video_info(bv_id)
429. bvid = video_info['bvid']
430. aid = video_info['aid']
431. cid = video_info['cid']
432. mid = video_info['mid']
433. name = video_info['name']
434. title = video_info['title']
435. tname = video_info['tname']
436. pub_date = video_info['pub_date']
437. pub_time = video_info['pub_time']
438. desc = video_info['desc']
439. view = video_info['view']
440. like = video_info['like']
441. coin = video_info['coin']
442. favorite = video_info['favorite']
443. share = video_info['share']
444. reply = video_info['reply']
445. danmaku = video_info['danmaku']
447. # 传播效果计算公式
448. Communication_Index = math.log(
449. 0.5 * int(view) + 0.3 * (int(like) + int(coin) + int(favorite)) + 0.2 * (int(reply) + int(danmaku)))
450. # 获取作者的相关信息
451. user_info = get_user_info(uid=mid)
452. follower = user_info['follower']
453. archive = user_info['archive']
454. write_to_csv(filename='视频基本信息.csv', bvid=bvid, aid=aid, cid=cid, mid=mid, name=name, follower=follower,
455. archive=archive, title=title, tname=tname, pub_date=pub_date, pub_time=pub_time, desc=desc,
456. view=view, like=like, coin=coin, favorite=favorite, share=share, reply=reply, danmaku=danmaku,
457. communication_index=Communication_Index)
458. print(f'==========第{i+1}个BV号：{bv_id}的相关数据已写入csv文件中==========')
459. print('==================================================\n')