哔哩哔哩番剧分析¶

# 内置
import re
import time
from datetime import datetime

# 第三方
import pandas as pd
import requests
import parsel

def gethtml(mdid):
    '''
    获取哔哩哔哩番剧详情页面的html文本
    input  mdid【int】
    output 对应番剧的详情页面【str】
    '''

    url = f'https://www.bilibili.com/bangumi/media/md{mdid}'
    response = requests.get(url)
    response.encoding = 'utf8'
    html = response.text
    # B站域名下非法的网址会跳转到错误页面，包含以下字符串
    if 'Σ(oﾟдﾟoﾉ) 无法找到该页面~' in html:
        html = 'invalid'
    return html

# 写入md7的html以便分析
with open('./data/md7.html','w',encoding='utf-8') as f:
    f.write(gethtml(7))

def eval_playdata(s):
    '''
    把playdata中的xxx万、亿转换为数字
    input  s【str】
    output 对应数字表达的整数值【int】
    '''

    d = {'万': 1e4, '亿': 1e8}
    try:
        #没有汉字，纯数字
        ans = eval(s)
    except SyntaxError:
        # 判断末尾是不是万或者亿，否则报错
        if s[-1] in d:
            ans = int(eval(s[:-1]) * d[s[-1]])
        else:
            ans = 'NA'
    return ans

def eval_broadcast_date(s):
    '''
    把播放日期格式化为datetime格式
    input  s【str】
    output 日期表达的datetime【datetime】
    '''

    if '日' in s:
        ans = datetime.strptime(s[:-2], '%Y年%m月%d日')
    elif '月' in s:
        ans = datetime.strptime(s[:-2], '%Y年%m月')
    elif '年' in s:
        ans = datetime.strptime(s[:-2], '%Y年')
    else:
        ans = datetime.strptime(s[:-2], '%Y')

    return ans

def eval_length(over):
    '''
    估算番剧的长度
    input  over【str】,例如'已完结，全3集'或者'123分钟'
    output 番剧总长度，单位为分钟【int】
    '''
    # 去除掉空格
    over = over.replace(' ','')
    ### 连载中
    if '更新' in over:
        return 'NA'
    ### 已完结
    # 电影
    elif over[-2:]=='分钟':
        length = int(over[:-2])
    # 动画
    elif over[-1]=='话':
        # 按照每一话25分钟估算
        length = int(over[5:-1])*25
    # 剧集
    elif over[-1]=='集':
        # 按照每一集45分钟估算
        length = int(over[5:-1])*45
    else:
        length = 'NA'
    return length

def getinfo(html):
    '''
    获取番剧的详细信息
    input html【str】
    output 提取到的番剧信息【dict】
    '''

    assert html != 'invalid'
    selector = parsel.Selector(html)
    # 标题
    title = selector.css('.media-info-title-t::text').get()
    # 评分
    score = selector.css('.media-info-score-content::text').get()
    # 评分人数
    review_times = selector.css('.media-info-review-times::text').get()
    # tags
    tags = selector.css('.media-tag::text').getall()
    # 播放数据
    media_info_label = selector.css('.media-info-label::text').getall()
    media_info_play_data = selector.css('em::text').getall()
    play_data = dict(zip(media_info_label, media_info_play_data))
    # 是否为系列
    series = True if '系列' in media_info_label[1] else False
    # 播放量、追番数、弹幕数
    play_times, followers, bullet_screen = selector.css('em::text').getall()
    # 开播时间(是否完结)
    ## 这两个时间，用CSS选择器无法正常获取，只能用正则表达式
    pattern1 = '<div class="media-info-time"><span>.*</span> <span>.*</span></div>'
    prefix_len = len('<div class="media-info-time"><span>')
    suffix_len = len('</span></div>')
    play_season_str = re.search(pattern1, html)[0]
    broadcast_date, _, over = play_season_str.partition('</span> <span>')
    broadcast_date, over = broadcast_date[prefix_len:], over[:-suffix_len]
    # 是否为电影or剧场版，标注分钟的一般是电影或者剧场版动画
    film = True if '分钟' in over else False
    # 番剧长度
    length = eval_length(over)
    # 是否为大会员专享
    pattern2 = '<div class="btn-pay-wrapper vip-only">'
    vip_only = True if re.search(pattern2, html) else False
    # 整理到一个字典里,这个时候尽量把更多的信息保留下来，所以会有很多后缀为str的变量
    # 后续可以再把这些变量删掉
    info = dict(
        title=title,
        # 可能没有评分
        score=eval(score) if score else 'NA',
        review_times=int(review_times[:-2]) if review_times else 'NA',
        # tags用逗号连接
        tags=','.join(tags),
        # play_data=str(play_data),
        series=series,
        film=film,
        # xxx万、亿转换为数字
        play_times=eval_playdata(play_times),
        followers=eval_playdata(followers),
        bullet_screen=eval_playdata(bullet_screen),
        # 字符串时间
        broadcast_date_str=broadcast_date,
        # 转换为时间类型
        broadcast_date=eval_broadcast_date(broadcast_date),
        over_str=over,
        over=True if over[:3] == '已完结' else False,
        length=length,
        vip_only=vip_only)
    return info

def moremdid(n):
    '''
    读取本地的mdidlist.txt文件中的mdid，接着探索更多可能的mdid
    input  n【int】
    output 所有已知合法的mdid【list】
    '''

    # 读取文件中的mdidlist
    with open('./data/mdidlist.txt', mode='r') as f:
        mdid = list(map(lambda x: eval(x[:-1]), f.readlines()))
        f.close()
    start = mdid[-1] + 1
    for i in range(start, start + n):
        # 如果页面不存在，返回404是逻辑上的FLase
        if requests.get(f'https://www.bilibili.com/bangumi/media/md{i}'):
            mdid.append(i)
    # 覆盖写，更新源文件中的mdidlist
    with open('./data/mdidlist.txt', mode='w') as f:
        f.writelines(map(lambda x: str(x) + '\n', mdid))
        f.close()
    print(f'completed, length of mdid now is {len(mdid)}')
    return mdid

def generate_df(mdid):
    '''
    获取mdid中所有番剧的信息，放到一个df中
    input mdid【list】
    output 汇总的所有番剧信息【pandas.DataFrame】
    '''
    l = []
    for i in mdid:
        # 不要过快访问
        time.sleep(0.1)
        # 用try语句捕获错误，尽量让程序一运行发现更多的错误
        try:
            html = gethtml(i)
            info = getinfo(html)
            info['mdid'] = i
            l.append(info)
        except Exception as e:
            # 不过exception不是很多就放弃那些报错的数据
            print(repr(e))
            print(f'{i} failed!')
    return pd.DataFrame(l)

# 获取mdid中包含的所有番剧信息，汇总到一个df中，这里就获取两个作为例子
df = generate_df(mdid[:2])

# 保存文件，以备后续处理
df.to_excel('./data/BLBLdata.xlsx', index=False, encoding='utf-8')

import pandas as pd
import numpy as np
import statsmodels.api as sm
from patsy import dmatrices
import matplotlib.pyplot as plt
import seaborn as sns

# 观察相关系数，选取和响应变量相关系数最大的追番人数建立回归模型
y, X = dmatrices(
    formula_like = 'play_times ~  followers',
    data=df_ols,
    return_type='dataframe')

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

def count_tag(dataframe):
    tags_l = []
    tag_count = {}
    # 初始化字典，这里没有使用collection的Counter是因为需要保留全部的key
    for tag in tags_set:
        tag_count[tag] = 0
    for i in dataframe.index:
        # 获取tag的字符串
        tag = dataframe.loc[i, 'tags']
        if pd.isna(tag):
            continue
        # 分割为列表，添加到tags_l后面
        tags_l += tag.split(',')
    # 计数
    for tag in tags_l:
        tag_count[tag] += 1
    return tag_count

tag_count = count_tag(df)

# Top 10 hot tags
sorted_key = sorted(tag_count, reverse=True,key=lambda x:tag_count.get(x))
sorted_values = [tag_count.get(key) for key in sorted_key]

# df中加入年份这一列
df['year'] = [date.year for date in df.broadcast_date]

# 按照年份分组
df_group_by_year = df.groupby(by='year')

# 分组后每个组对tag计数
count_tag_by_year = {}
for year in df_group_by_year.groups:
    count_tag_by_year[year] = count_tag(df_group_by_year.get_group(year))