ドラゴンボールのBlog
python实现b站自动下载收藏视频，防止视频和谐
岁月如梦 Lv4
  2022-10-01 18:17:21   2024-11-14 13:04:13    4.9k 字  23 分钟  

点击收藏b站视频后，自动下载收藏视频


前言

详细代码已上传至GitHub,
访问链接：https://github.com/longhz/Collection_download_bilibili_video
当然，你也可以直接下载测试运行，我已经打包好了
下载链接：https://github.com/longhz/Collection_download_bilibili_video/releases

目的

1
2
3
写这个同步下载的小脚本是为了什么？
今年，我在b站寻找资料时候，发现我关注的up主一些视频下架了，收藏的视频失效了很多，
然后萌生了本地收藏视频的想法，想到了就开始动手去做

实现的结果

我最终要实现一个什么样的结果？

  • 我在b站点赞收藏的视频，分类规划文件夹
  • 根据不同的文件夹来生成不同的本地json
  • 脚本在执行后，每隔10分钟检测一次收藏夹是否有变动
  • 如果监测到有新收藏，会触发下载脚本
  • 下载的视频不能是音频和视频分开，得合二为一，所以会用的ffmpeg
  • 最终,在我本地电脑指定的保存视频路径中，能看到我的收藏视频

我已经实现了我的最终目标，我将脚本放在了我的nas后台，于是视频再也不会失效

下面是主体的运行逻辑和框架

生成本地json

获取收藏夹中的一页内容

当收藏夹的内容超过20，那么将会产生新的一页，这里pag来进行分页获取每一页的信息

1
2
3
4
5
6
7
8
9
10
11
12
# 获取收藏夹一页内容
def generate_fav_content_url(fid: int, page_number: int) -> str:
    """
        获取收藏夹一页内容
        https://api.bilibili.com/x/v3/fav/resource/list?
            keyword=&order=mtime&type=0&tid=0&platform=web&jsonp=jsonp&ps=20&
            media_id={fid}&pn={page_number}
        :param fid: 收藏夹id
        :param page_number: 收藏夹中页码
        :return: 获取收藏夹一页内容url

return f'https://api.bilibili.com/x/v3/fav/resource/list?ps=20&media_id={fid}&pn={page_number}'

获取收藏夹信息

这里获取的信息用于解析出查询页面的前置条件

1
2
3
4
5
6
7
8
9
10
11
# 获取收藏夹信息
def generate_fav_url(fid: int) -> str:
    """
    获取收藏夹信息
    https://api.bilibili.com/x/v3/fav/resource/list?
        pn=1&ps=20&keyword=&order=mtime&type=0&tid=0&platform=web&jsonp=jsonp&
        media_id={fid}
    :param fid: 收藏夹id
    :return: 获取收藏夹信息url
    """
    return f'https://api.bilibili.com/x/v3/fav/resource/list?ps=1&media_id={fid}'

查询页码

1
2
3
4
5
6
7
8
9
10
11
# 查询页码
def page_numbe(fid):
    """
    fid: 视频收藏夹id
    Returns: 分页统计
    """
    resp = request_retry_json(generate_fav_url(fid))
    media_count = resp['data']['info']['media_count']
    page_count = math.ceil(media_count / 20)

    return page_count

获取Response信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def request_retry(url: str, headers: dict = None, retry: int = 3) -> requests.Response:
    if headers is None:
        headers = {'Connection': 'close'}
    headers['Connection'] = 'close'
    while retry > 0:
        try:
            resp = requests.get(url, headers=headers)
            return resp
        except:
            logging.error('request %s error: %s' % (url, sys.exc_info()[0]))
            time.sleep(5 - retry)
        retry -= 1
    raise requests.RequestException

def request_retry_json(url: str, headers=None, retry: int = 3) -> dict:
    return json.loads(request_retry(url, headers, retry).text)

读取网页信息，并转化为son格式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
def request_info(resp):

    bili_json1 = []
    for a in resp['data']['medias']:
        # 视频搜索id
        av_id = a['id']
        # 视频搜索av_id链接
        av_id_link = a['link']
        # 播放时长
        n = int(a['duration'])
        m = int(n / 60)
        s = n - m * 60
        # print(f"可以换算成 {m}分钟 {s}秒。")
        duration = f"时长：{m}分钟{s}秒"

        # 类型
        type = a['type']
        # 标题
        title = a['title']

        # 去除格式和特殊符号
        re_exp = u"([^\u4e00-\u9fa5\u0030-\u0039\u0041-\u005a\u0061-\u007a\’!\"#$%&\'()*+,-./:;<=>?@，。?、…【】《》？“”‘’！["u"\\]^_`{|}~\s])"
        video_title = str(title).strip(re_exp)
        
        # 对一些格式的保留和替换
        video_name = "".join(video_title.split())
        video_name = (((video_name.replace("/", "-")).replace("】", "-")).replace("[", "-")).replace("【", "-")
        video_name = (((video_name.replace("；", "-")).replace("\n", "")).replace("]", "-")).replace("r&b", "")
        video_name = (((video_name.replace("（", "-")).replace("）", "")).replace(" ", "")).replace("＆", "与")
        video_name = (((video_name.replace("--", "-")).replace("(", "")).replace(")", "")).replace("&","")
        video_name = (((video_name.replace("amp;", "")).replace("|", "-")).replace("《", "")).replace("》", "")
        
        # 图片链接
        cover = a['cover']
        # 摘要
        intro = a['intro']
        # 页数
        page = a['page']
        # up主个人id
        up_mid = a['upper']['mid']
        # up主昵称
        up_name = a['upper']['name']
        # up主头像
        up_face = a['upper']['face']
        # 视频id
        bv_id = a['bv_id']
        # 视频链接
        bv_link = "https://www.bilibili.com/video/" + a['bv_id']
        # 该视频收藏人数
        bv_collect = a['cnt_info']['collect']
        # 该视频播放次数
        bv_play = a['cnt_info']['play']
        # 当前观看人数
        bv_danmaku = a['cnt_info']['danmaku']

        bili_json = {
            'title': video_name,
            'intro': intro,
            'cover': cover,
            'bv_id': bv_id,
            'bv_link': bv_link,
            'page': page,
            'av_id': av_id,
            'av_id_link': av_id_link,
            'type': type,
            'duration': duration,
            'bv_collect': bv_collect,
            'bv_play': bv_play,
            'bv_danmaku': bv_danmaku,
            'up_mid': up_mid,
            'up_name': up_name,
            'up_face': up_face,
            'is_Download': 0
        }
        bili_json1.append(bili_json)

    return bili_json1

json调用格式清理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def write_json(resp, json_file_path_name):

    bili_create_json(json_file_path_name)
    try:
        bili_json_format_eliminate(json_file_path_name)
    except Exception as err:
        pass
    with open(json_file_path_name, 'a', encoding='utf-8') as fw:
        fw.write(',')
        json.dump(resp, fw, indent=4, ensure_ascii=False)
        fw.write('\n')
    # print("写入完毕")
    fw.close()
    bili_create_json(json_file_path_name)
    bili_tihuan(json_file_path_name)

写入json文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
def read_write_json(resp, json_file_path_name):
    """
        文件操作中的 r, r+, a, a+, w, w+ 几种方式的区别:
        r只读，r+ 可读可写，若文件不存在，报错；
        w只写，w+ 可读可写，二者都会将文件内容清零,若文件不存在，创建；
        a附加写方式打开，不可读，a+ 附加读写方式打开，二者都是若文件不存在，创建；
    """
    my_file = Path(json_file_path_name)
    resp1 = request_info(resp)
    a = 0
    b = 0

    if my_file.is_file():
        for rss in resp1:
            tt1 = rss['bv_id']
            title_ysx = str(rss['title'].strip())
            flag = select_json(tt1, json_file_path_name)
            
            if flag == 1:
                # print("检测到已存在json文件中")
                a = a + 1
                # pass
            else:
                if title_ysx in "已失效视频":
                    print("该视频已被up主删除，已失效，为您跳过该条新增记录！")
                    # b = b + 1
                else:
                    write_json(rss, json_file_path_name)
                    b = b + 1
                    print(f'新增了第{b}条收藏记录，标题：' + rss['title'])
        print(f'已检测到已存在收藏记录{a}条,新增了{b}条收藏记录')
    else:
        print("检测到文件不存在，已为您新建json文件")
        for rss in resp1:
            title_ysx = str(rss['title'].strip())
            if title_ysx in "已失效视频":
                print("该视频已被up主删除，已失效，为您跳过该条新增记录！")
            else:
                write_json(rss, json_file_path_name)
                b = b + 1
                print(f'新增了第{b}条收藏记录，标题：' + rss['title'])
        print(f'已检测到已存在收藏记录{a}条,新增了{b}条收藏记录')

创建并添加json文件内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def ins_json(fid: int, json_name: str, file_dir):
    # fid: 收藏夹id
    fid = fid
    # page_number: 收藏夹中页码
    page_number = page_numbe(fid)
    # 文件名称
    json_name = json_name + '.json'

    Subscribe = os.path.join(file_dir, 'Subscribe_json')
    mkdir_folder(Subscribe)
    # json文件路径名称
    json_file_path_name = File_dir(Subscribe, json_name)
    # total 负责做累加和
    total = 1

    while total <= page_number:
        url = generate_fav_content_url(fid, total)
        resp = request_retry_json(url)
        read_write_json(resp, json_file_path_name)
        print(f'第{total}页收藏夹已记录~~\n')
        total += 1

    print("执行完毕")

下载收藏夹中的视频

请求的url地址

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 请求的url地址
def get_response(html_url):
    """
    Args: 发送请求，以及获取数据函数
        html_url: 请求的url地址
    Returns: 返回请求服务器返回的响应数据
    """
    # 请求代码，在发送请求前，需要进行伪装 headers 请求头
    # user-agent 浏览器基本标识 用户代理 基本伪装 反爬手段
    # <Response [200]> 对象response响应对象 200 状态码 表示请求成功
    # 404 网址可能出错
    # 403 网址没有权限，出现 403 加防盗链 referer ,是为了告诉服务器，我们发送请求的url地址，是从哪里跳转过来的

    headers = {
        "referer": "https://search.www.bilibili.com",
        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36"
    }

    response = requests.get(url=html_url, headers=headers, stream=True)  # 请求代码
    # stream 字节流 (可选，开启后可用于判断大小以及做进度条使用)
    # 一般选取小而快的内容时，将stream设置为false或者不加也许，可以快速的读取response.content内容
    # 当stream开启后，后面需要自己执行response.close()操作进行关闭接收，否则只有所有的响应体数据被读取完毕连接才会被释放，如果用with可以不用close()

    return response

视频的详情页

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
def get_video_info(html_url):
    """
    获取视频标题 /音频 url地址 / 视频画面url地址
    Args:
        html_url: 视频的详情页

    Returns: 视频标题 /音频 url地址 / 视频画面url地址

    """

    response = get_response(html_url=html_url)
    # response.text 获取响应体的文本数据
    # print(response.text)
    # 解析数据 提取视频标题 re正则表达式 css选择器 xpath bs4 parsel lxml (解析模块) jsonpath 主要提取json数据

    # 正则表达式提取的数据内容 返回都是列表数据类型[0] 列表 所返回的索引取值（ 0或者-1都行，0是从左往右，-1是从右往左）
    title = re.findall('<h1 title="(.*?)" class="video-title tit">', response.text)[0] # 标题

    # 去除格式和特殊符号
    re_exp = u"([^\u4e00-\u9fa5\u0030-\u0039\u0041-\u005a\u0061-\u007a\’!\"#$%&\'()*+,-./:;<=>?@，。?、…【】《》？“”‘’！["u"\\]^_`{|}~\s])"
    video_title = str(title).strip(re_exp)
    # 替换和保留一些格式
    video_name = "".join(video_title.split())
    video_name = (((video_name.replace("/", "-")).replace("】", "-")).replace("[", "-")).replace("【", "-")
    video_name = (((video_name.replace("；", "-")).replace("\n", "")).replace("]", "-")).replace("r&b", "")
    video_name = (((video_name.replace("（", "-")).replace("）", "")).replace(" ", "")).replace("＆", "与")
    video_name = (((video_name.replace("--", "-")).replace("(", "")).replace(")", "")).replace("&", "")
    video_name = (((video_name.replace("amp;", "")).replace("|", "-")).replace("《", "")).replace("》", "")


    html_data = re.findall('<script>window.__playinfo__=(.*?)</script>',response.text)[0]
    # html_data 是<class 'str'>数据类型
    # 为了更加方便提取数据，可以字符串数据 转换成 字典数据类型
    json_data = json.loads(html_data)
    # 根据键值对取值
    audio_url = json_data['data']['dash']['audio'][0]['base_url']
    video_url = json_data['data']['dash']['video'][0]['base_url']
    video_info = [video_name, audio_url, video_url]

    return video_info

下载保存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
def save(title, audio_url, video_url, tmp_dir):
    """

    Args: 保存数据函数
        title: 视频标题
        audio_url: 音频url
        video_url: 视频画面url
    Returns:

    """

    au_response = get_response(html_url=audio_url)
    audio_content = au_response.iter_content(chunk_size=1024)
    au_total = int(au_response.headers.get('content-length', 0))

    vi_response = get_response(html_url=video_url)
    video_content = vi_response.iter_content(chunk_size=1024)
    vi_total = int(vi_response.headers.get('content-length', 0))

    with open(tmp_dir + '/' + title + '.mp3', mode='wb') as f, tqdm(
            desc="音频下载进度",
            total=au_total,
            unit='iB',
            unit_scale=True,
            unit_divisor=1024
    ) as bar:
        for data in audio_content:
            size = f.write(data)
            bar.update(size)
        f.close()

    with open(tmp_dir + '/' + title + '.mp4', mode='wb') as f, tqdm(
            desc="视频下载进度",
            total=vi_total,
            unit='iB',
            unit_scale=True,
            unit_divisor=1024
    ) as bar:
        for data in video_content:
            size = f.write(data)
            bar.update(size)
        f.close()

    print(title, "已下载保存至临时目录：" + tmp_dir + '/' + title)

下载主函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def Download_main(bv_id, tmp_dir, Download_videos):
    """

    Args: 下载主函数
        bv_id: bv号
        tmp_dir：临时目录
        Download_videos：实际保存目录
    Returns:

    """
    url = f'https://www.bilibili.com/video/{bv_id}'
    video_info = get_video_info(url)  # [title, audio_url, video_url]

    save(video_info[0], video_info[1], video_info[2], tmp_dir)
    merge_data(video_info[0], tmp_dir, Download_videos)

数据合并 - 视频合并（使用了ffmpeg）

1
2
3
4
5
6
7
def merge_data(video_name, tmp_dir, Download_videos):
    """ 数据合并 - 视频合并 """

    print('视频合并开始：', video_name)
    cmd = f"ffmpeg -i {tmp_dir}/{video_name}.mp4 -i {tmp_dir}/{video_name}.mp3 -c:v copy -c:a aac -strict experimental {Download_videos}/{video_name}.mp4"
    subprocess.run(cmd, shell=True)
    print(f'视频合成结束,已将视频保存至路径： {Download_videos}/{video_name}.mp4')

读取json文件，执行脚本，修改下载状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
def bili_json(folder_dir, Download_videos, json_file_path_name):
    """

    Args: 读取json文件，执行脚本，修改下载状态
        folder_dir:
        Download_videos:

    Returns:

    """
    # 休眠10s
    sleepTime = 10

    json_flag = json_file_path_name.strip()
    # 判断路径是否存在 存在 True 不存在   False
    isExists = os.path.exists(json_flag)

    # 判断结果
    if not isExists:
        print(json_file_path_name + "不存在,已为您跳过!")
    else:
        with open(json_file_path_name, 'r', encoding='utf-8') as jsonFile:

            data = json.load(jsonFile)
            for aa in data:
                bv_id = aa['bv_id']
                is_Download = aa['is_Download']
                title = aa['title']

                # print(type(is_Download))
                if is_Download == 0:

                    bb = str(aa['is_Download']).replace('0', '1')
                    print(f"\n检测到新收藏,标题为：{title},正在下载,请稍后")
                    bili_download_main(folder_dir, Download_videos, bv_id)
                    aa['is_Download'] = int(bb)
                    # print("下载脚本执行完毕！,休眠30s后，继续执行！ \n ------------------------------------------------")
                    with open(json_file_path_name, 'w', encoding='utf-8') as f:
                        json.dump(data, f, indent=4, ensure_ascii=False)
                        f.close()
                    # jsonFile.close()
                    print(f"休眠10s后，将执行下载命令！ \n ------------------------------------------------")
                    time.sleep(sleepTime)

                else:
                    jsonFile.close()
                    print(title + "\n检测到已存在下载历史，已为你跳过下载~ \n ------------------------------------------------")

下载前校验文件夹是否存在

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
def bili_download_main(folder_dir, Download_videos, bv_id):
    # url = 'https://www.bilibili.com/video/BV1xL411M7yg/'
    # video_info = get_video_info(url)
    # print(video_info)

    # 键盘输入
    # keyword = input("输入要下载的bv号：")
    # main(keyword)
    start_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    start_time = datetime.strptime(start_time, r"%Y-%m-%d %H:%M:%S")

    try:
        mkdir_folder(folder_dir)
        print("临时文件夹——创建成功")

        mkdir_folder(Download_videos)
        print("视频实际存储文件夹——创建成功")

        Download_main(bv_id, folder_dir, Download_videos)
        print("视频下载成功")

        end_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        end_time = datetime.strptime(end_time, r"%Y-%m-%d %H:%M:%S")
        diff = end_time - start_time

        rm_folder(folder_dir)
        print("临时文件夹——已删除")
        print(f"总计运行{diff.total_seconds()}秒")
    except Exception as err:
        end_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        end_time = datetime.strptime(end_time, r"%Y-%m-%d %H:%M:%S")
        diff = end_time - start_time
        print("临时文件夹——已删除")
        print(f"总计运行{diff.total_seconds()}秒")

config.ini设置与导入包

1
2
3
4
5
def config_collection():
    # 导入configparser模块，
    conf = ConfigParser()

    return conf

config.ini设置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[bili_collection]
fid_1: 1781782216
fid_1_name: 测试收藏
;如果有多个收藏夹，复制fid_序列数字，如下面所示
;fid_2: #
;fid_2_name: #
[video_dir]
;临时文件夹名称
Temporary_folder: tmp
;视频文件夹名称
Download_videos_folder: Download_videos
;具体保存路径
windows_dir: D:/Downloads/video/
;如果linux使用
;linux_dir: /tmp/

创建文件夹和替换文本

创建文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def mkdir_folder(path):
    """
    Args:
        path: 创建临时文件
    Returns:
    """
    # 去除首位空格
    path = path.strip()
    # 去除尾部 \ 符号
    path = path.rstrip("\\")
    # 判断路径是否存在 存在 True 不存在   False
    isExists = os.path.exists(path)

    # 判断结果
    if not isExists:
        # 如果不存在则创建目录
        # 创建目录操作函数
        os.makedirs(path)
        # print(path+' 创建成功')
        return True
    else:
        # 如果目录存在则不创建，并提示目录已存在
        # print(path+' 目录已存在')
        return False

删除文件和文件夹

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def rm_folder(dir):
    """

    Args:
        dir: 遍历删除文件夹和文件

    Returns:

    """
    # 引入模块
    import os
    # 判断是否是文件夹，如果是，递归调用rmdir()函数
    if (os.path.isdir(dir)):
        # 遍历地址下的所有文件
        for file in os.listdir(dir):
            # 删除文件
            oo = dir + r'/' + file
            os.remove(oo)
            # print("文件已删除")
            # 继续删除文件夹
            rm_folder(dir)
        # 如果是空文件夹，直接删除
        if (os.path.exists(dir)):
            os.rmdir(dir)
            # print(dir, "文件夹删除成功")
    # 如果是文件，直接删除
    else:
        if (os.path.exists(dir)):
            os.remove(dir)
            print(dir, "文件删除成功")

json文件格式初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def bili_create_json(json_file_path_name):
    ffe = os.path.exists(json_file_path_name)

    if ffe == True:

        with open(json_file_path_name, 'a', encoding='utf-8') as fw:
            fw.write(']\n')
        # print("写入完毕")
        fw.close()
    else:
        with open(json_file_path_name, 'w+', encoding='utf-8') as fw:
            fw.write('[')
        # print("创建写入完毕")
        fw.close()

文本格式清理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def bili_json_format_eliminate(json_file_path_name):
    matchPattern = re.compile(r']')

    file = open(json_file_path_name, 'r', encoding='UTF-8')
    lineList = []
    while 1:
        line = file.readline()
        if not line:
            # print("指定格式已清理")
            break
        elif matchPattern.search(line):
            pass
        else:
            lineList.append(line)
    file.close()
    file = open(json_file_path_name, 'w', encoding='UTF-8')
    for i in lineList:
        file.write(i)
    file.close()

文本查询和替换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def bili_tihuan(json_file_path_name):
    # 创建一个变量并存储我们要搜索的文本
    search_text = "[,"

    # 创建一个变量并存储我们要添加的文本
    replace_text = "["

    # 使用 open() 函数以只读模式打开我们的文本文件
    with open(json_file_path_name, 'r', encoding='UTF-8') as file:
        # 使用 read() 函数读取文件内容并将它们存储在一个新变量中
        data = file.read()

        # 使用 replace() 函数搜索和替换文本
        data = data.replace(search_text, replace_text)

    # 以只写模式打开我们的文本文件以写入替换的内容
    with open(json_file_path_name, 'w', encoding='UTF-8') as file:
        # 在我们的文本文件中写入替换的数据
        file.write(data)

    # 打印文本已替换
    # print("文本已替换")

查询验证文本是否存在

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def select_json(bv_id, json_file_path_name):
    with open(json_file_path_name, 'r', encoding='utf-8') as jsonFile:
        data = json.load(jsonFile)
        aa = 0
        for data_a in data:
            if bv_id == data_a['bv_id']:
                # print("存在")
                aa = aa+1
                jsonFile.close()
                return aa
            else:
                pass
        # print(aa)
        jsonFile.close()
        return aa

判断系统平台和文件保存路径

判断当前运行平台是windows还是linux

1
2
3
4
5
6
7
8
9
10
def isWondowsorLinux():
    ''' 判断当前运行平台 :return: '''
    sysstr = platform.system()
    if (sysstr == "Windows"):
        return True
    elif (sysstr == "Linux"):
        return False
    else:
        print("Other System ")
    return False

根据系统环境分配文件保存路径

1
2
3
4
5
6
7
8
9
10
def File_dir(file_dir: str, json_name: str):
    mkdir_folder(file_dir)

    # 判断当前系统环境
    if isWondowsorLinux() == True:
        windows_dir = os.path.join(file_dir, json_name)
        return windows_dir
    else:
        linux_dir = os.path.join(file_dir, json_name)
        return linux_dir

调用收藏同步和执行下载

日期获取

1
2
3
def getDate():
    date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    return "当前时间："+date

config 初始化

1
2
3
4
5
6
7
conf = config_collection()
# 获取当前目录路径
file_dir = os.path.dirname(os.path.abspath(__file__))
# 实际文件路径
CONF_FILE = os.path.join(file_dir, 'config.ini')
# 实例化语言格式
conf.read(CONF_FILE, encoding="utf-8")

同步收藏夹

1
2
3
4
5
6
7
8
9
10
def tb_sc():
    # 获取配置文件的参数信息
    fid_1 = conf.get("bili_collection", "fid_1")
    fid_1_name = conf.get("bili_collection", "fid_1_name")
    ins_json(fid_1, fid_1_name, file_dir)

    # ---如果有多个收藏夹，可以仿照下面复制，要记得修改数字---
    # fid_2 = conf.get("bili_collection", "fid_2")
    # fid_2_name = conf.get("bili_collection", "fid_2_name")
    # ins_json(fid_2, fid_2_name, file_dir)

下载收藏夹视频

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def download_video():
    # 获取配置文件的参数信息
    tmp_file_name = conf.get("video_dir", "Temporary_folder")
    download_file_name = conf.get("video_dir", "Download_videos_folder")
    # 根据系统来使用linux还是windows
    # linux_dir = conf.get("video_dir", "linux_dir")
    windows_dir = conf.get("video_dir", "windows_dir")

    # 临时文件夹路径
    folder_dir_path = File_dir(windows_dir, tmp_file_name)
    # 视频下载实际保存路径
    Download_videos_path = File_dir(windows_dir, download_file_name)
    # 收藏夹视频json文件路径
    json_file_path_name1 = File_dir((os.path.join(file_dir, 'Subscribe_json')), (conf.get("bili_collection", "fid_1_name")) + ".json")
    # 调用下载
    bili_json(folder_dir_path, Download_videos_path, json_file_path_name1)

    # ---如果有多个收藏夹，可以仿照下面复制，要记得修改数字---
    # json_file_path_name2 = File_dir((os.path.join(file_dir, 'Subscribe_json')), (conf.get("bili_collection", "fid_2_name")) + ".json")
    # bili_json(folder_dir_path, Download_videos_path, json_file_path_name2)

运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 1分=60s,休眠10分钟
    sleepTime = 600
    # 添加err_log日志文件
    logging.basicConfig(filename='err.log')

    while True:
        try:
            # 执行收藏同步
            tb_sc()
            print(getDate() + " 收藏记录执行完毕！")

            try:
                # 执行视频下载
                download_video()
                print(getDate() + " 视频下载执行完毕！")
            except Exception as e:
                s = traceback.format_exc()
                print(getDate() + " 视频下载执行失败！")
                logging.error(s)

        except Exception as e:
            s = traceback.format_exc()
            print(getDate() + " 收藏记录执行失败！")
            logging.error(s)

        print("脚本执行完毕！" + getDate() + " ,休眠10分钟后，继续执行！")
        # 休眠10分钟
        time.sleep(sleepTime)
        continue
python实现b站自动下载收藏视频，防止视频和谐
2022/10/01/python-bilibili-Collection-Download/
作者
ドラゴンボールのLong
发布于
2022-10-01 18:17
许可
Long License
 请作者喝咖啡
 评论
评论插件加载失败
正在加载评论插件
  1. 1. 点击收藏b站视频后，自动下载收藏视频
    1. 1.1. 前言
      1. 1.1.1. 目的
      2. 1.1.2. 实现的结果
  2. 2. 下面是主体的运行逻辑和框架
    1. 2.1. 生成本地json
      1. 2.1.0.1. 获取收藏夹中的一页内容
      2. 2.1.0.2. 获取收藏夹信息
      3. 2.1.0.3. 查询页码
      4. 2.1.0.4. 获取Response信息
      5. 2.1.0.5. 读取网页信息，并转化为son格式
      6. 2.1.0.6. json调用格式清理
      7. 2.1.0.7. 写入json文件
      8. 2.1.0.8. 创建并添加json文件内容
  3. 2.2. 下载收藏夹中的视频
    1. 2.2.0.1. 请求的url地址
    2. 2.2.0.2. 视频的详情页
    3. 2.2.0.3. 下载保存
    4. 2.2.0.4. 下载主函数
    5. 2.2.0.5. 数据合并 - 视频合并（使用了ffmpeg）
    6. 2.2.0.6. 读取json文件，执行脚本，修改下载状态
    7. 2.2.0.7. 下载前校验文件夹是否存在
  • 2.3. config.ini设置与导入包
  • 2.4. 创建文件夹和替换文本
    1. 2.4.0.1. 创建文件
    2. 2.4.0.2. 删除文件和文件夹
    3. 2.4.0.3. json文件格式初始化
    4. 2.4.0.4. 文本格式清理
    5. 2.4.0.5. 文本查询和替换
    6. 2.4.0.6. 查询验证文本是否存在
  • 2.5. 判断系统平台和文件保存路径
    1. 2.5.0.1. 判断当前运行平台是windows还是linux
    2. 2.5.0.2. 根据系统环境分配文件保存路径
  • 2.6. 调用收藏同步和执行下载
    1. 2.6.0.1. 日期获取
    2. 2.6.0.2. config 初始化
    3. 2.6.0.3. 同步收藏夹
    4. 2.6.0.4. 下载收藏夹视频
  • 2.7. 运行
    1. 1. 点击收藏b站视频后，自动下载收藏视频
      1. 1.1. 前言
        1. 1.1.1. 目的
        2. 1.1.2. 实现的结果
    2. 2. 下面是主体的运行逻辑和框架
      1. 2.1. 生成本地json
        1. 2.1.0.1. 获取收藏夹中的一页内容
        2. 2.1.0.2. 获取收藏夹信息
        3. 2.1.0.3. 查询页码
        4. 2.1.0.4. 获取Response信息
        5. 2.1.0.5. 读取网页信息，并转化为son格式
        6. 2.1.0.6. json调用格式清理
        7. 2.1.0.7. 写入json文件
        8. 2.1.0.8. 创建并添加json文件内容
    3. 2.2. 下载收藏夹中的视频
      1. 2.2.0.1. 请求的url地址
      2. 2.2.0.2. 视频的详情页
      3. 2.2.0.3. 下载保存
      4. 2.2.0.4. 下载主函数
      5. 2.2.0.5. 数据合并 - 视频合并（使用了ffmpeg）
      6. 2.2.0.6. 读取json文件，执行脚本，修改下载状态
      7. 2.2.0.7. 下载前校验文件夹是否存在
  • 2.3. config.ini设置与导入包
  • 2.4. 创建文件夹和替换文本
    1. 2.4.0.1. 创建文件
    2. 2.4.0.2. 删除文件和文件夹
    3. 2.4.0.3. json文件格式初始化
    4. 2.4.0.4. 文本格式清理
    5. 2.4.0.5. 文本查询和替换
    6. 2.4.0.6. 查询验证文本是否存在
  • 2.5. 判断系统平台和文件保存路径
    1. 2.5.0.1. 判断当前运行平台是windows还是linux
    2. 2.5.0.2. 根据系统环境分配文件保存路径
  • 2.6. 调用收藏同步和执行下载
    1. 2.6.0.1. 日期获取
    2. 2.6.0.2. config 初始化
    3. 2.6.0.3. 同步收藏夹
    4. 2.6.0.4. 下载收藏夹视频
  • 2.7. 运行