效果图

• 上图为1月22号晚上战旗平台热门直播的弹幕消息截图
  一行中为 直播房间标题-[发弹幕者昵称]--弹幕内容

效果图2

开源包

• 我最早发现直播视频弹幕爬虫是从无与童比同学的斗鱼弹幕助手ruby版本看到的，他还有详细的原理解析文记一次斗鱼TV弹幕爬虫经历(Ruby版本)，他也做了一个python版本的，不过只适用于Mac和Linux系统。
• 后来又在github上看到了littlecodersh同学开源的Python 弹幕包，无操作系统依赖，而且拓展了适用直播平台，斗鱼、熊猫、战旗、全民、Bilibili的弹幕认证连接与消息解析代码全都有，适用多个平台，代码解耦适度，结构清晰。

原理

• 原理上，都是先从直播房间页面或者相应api接口获取主播信息、弹幕服务器信息、弹幕认证服务器信息等，然后通过socket连接，维持心跳包并持续获取弹幕数据。不过都是使用了多线程的方式。以littlecodersh的代码为例，他的结构大概是由使用者提供的直播页url启动一个弹幕消息处理线程（处理的是已经解析完毕结构化好的弹幕消息，实际是一个接口）和一个相应平台的客户端线程，客户端线程初始化一个socket并维护两个子线程，这两个子线程共用同一个socket分别发送心跳包和接收弹幕消息原始数据，在接收消息的线程里同时完成弹幕消息的解析和结构化，并放入队列，提供给一开始的弹幕消息处理线程，让其进一步对弹幕进行处理。但是多个房间的弹幕要开多个进程，也可以对源码相应修改，采取多开客户端线程的方式，在同一个进程里进行处理。

应用场景与异步修改尝试

• 考虑到应用场景，目标是要收集某直播平台的热门节目的优质片段，首先考虑优质片段如何判断，直播弹幕量的突然上升（当然也可能是主播在抽奖。。）在很大程度上是直播中特殊情况发生的信号，于是通过实时监测弹幕信息发现弹幕变化节点就解决了优质片段的初步筛选工作，同时还可以根据弹幕消息处理出当前观众热词，方便进一步加工。于是需要同时获取某平台上百台直播节目，多平台的话就要更多，使用python的话或许异步协程在这里更为适合。这里我将littlecodersh的线程代码改写为异步（感谢littlecodersh同学），使用一个eventloop控制器，管理所有的socket异步事件，每个socket对应一个直播弹幕的获取，代码的结构看上去感觉也更易理解一点。测试同时接收200台时占用内存约为30M（python解释器占大概10M多点），流量约为400Kb/s。这里只是改写了战旗平台的代码做了一下尝试，很多地方处理的也比较粗糙，可以改进的地方比较多，欢迎指点交流。
• 首先从战旗平台直播列表页面获取当前热门直播，直接使用以下代码爬取热门列表到txt文件保存，这里只是爬了第一页的。

import requests
from bs4 import BeautifulSoup
#
r = requests.get('https://www.zhanqi.tv/lives')
soup = BeautifulSoup(r.content, "lxml") # 可以不要lxml
urlist = [i.get('href') for i in soup.select("#hotList li a")]
with open('urlist3.txt', 'a') as f:
    for i in urlist:
        f.write(
            ''.join(['https://www.zhanqi.tv', i, '\n'])
        )

• 然后使用以下代码连接txt文件中的所有房间，python zhanqidanmu.py即可执行。
  其中socket接收到了弹幕消息的原始数据后，需要对其进行较为耗时的数据解析工作，即msgHandleBlock方法，这里采取维护一个线程池（进程池也可，只需将Thread改为Process）的方法，将该耗时工作委托给另一个线程处理。对初步处理完成的数据这里只是简单的打印到控制台，可以稍作修改直接存入数据库，也可留出接口。

# zhanqidanmu.py
import abc
import asyncio
import socket
import concurrent.futures

import sys
import json
import time
import re
import base64
from struct import pack
import requests

USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 \
(KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36'


async def testMemory():
    # 测试内存占用
    import os
    import psutil
    while True:
        process = psutil.Process(os.getpid())
        print(os.getpid(), '占用',
              str(process.memory_info().rss / 1024 / 1024))
        await asyncio.sleep(10)


class DanMuClientManager():

    def __init__(self, loop=None, executor=None):
        self.loop = loop or asyncio.get_event_loop()
        # 私有一个事件循环控制器
        self.executor = executor or concurrent.futures.ThreadPoolExecutor(
            max_workers=2,
        )
        # 私有一个处理cpu占用型任务的线程池
        self._urltextProcess()
        # 得到需要连接的直播房间列表

    def _urltextProcess(self):
        with open('urlist3.txt', 'r') as f:
            self.url = f.readlines()

    def start(self):

        clientList = [ZhanQiDanMuClient(url.strip(), self.loop, self.executor)
                      for url in self.url if url != '\n']
        # 由url列表实例化客户端生成列表
        initTasks = []
        clients = []
        for c in clientList:
            try:
                danmuSocketInfo, roomInfo = c.prepare_env()
                # 完成准备工作，生成弹幕服务器信息和房间信息
            except:
                print("某主播不在线-", c.url)
            else:
                clients.append(c)
                initTasks.append(c.init_socket(danmuSocketInfo, roomInfo))
                # 将所有的socket初始连接协程放入队列
        self.loop.run_until_complete(asyncio.gather(*initTasks))
        # 等待连接完成
        print('连接弹幕服务器完成 *', len(initTasks))
        danmuTasks = [testMemory()]
        for c in clients:
            danmuTasks.extend([
                asyncio.ensure_future(c.heartCoro()),
                asyncio.ensure_future(c.danmuCoro()),
            ])
        # 生成所有的心跳协程和弹幕消息接收协程构成的任务列表
        try:
            self.loop.run_until_complete(asyncio.gather(*danmuTasks))
            # 持续接收弹幕消息
        except KeyboardInterrupt:
            print('关闭')
        finally:
            # print(">> Cancelling tasks now")
            # for task in asyncio.Task.all_tasks():
            #     task.cancel()
            # self.loop.run_until_complete(asyncio.sleep(1))
            # print(">> Done cancelling tasks")
            self.loop.close()


class AbstractDanMuClient(metaclass=abc.ABCMeta):
    '''主要流程：
       先获取直播状态，
       然后获取弹幕服务器地址与房间信息，
       之后开启socket连接并认证，
       最后持续发送心跳包和接收弹幕消息'''

    def __init__(self, url, loop, executor):
        self.url = url
        self.loop = loop
        self.executor = executor
        self.sock = None

    @abc.abstractmethod
    def _get_live_status(self):
        '''由直播网页获取主播直播状态'''
        return False

    @abc.abstractmethod
    def _prepare_env(self):
        '''获取弹幕服务器ip和端口号以及房间信息用以认证'''
        return ('0.0.0.0', 80), {}
        # danmuSocketInfo, roomInfo

    def prepare_env(self):
        '''调用self._get_live_status和self._prepare_env完成准备工作'''
        if not self._get_live_status():
            raise Exception(u"直播未开始")
        return self._prepare_env()

    @abc.abstractmethod
    async def _init_socket(self, roomInfo):
        '''具体的socket连接到房间的方式，由子类重写，
           应使用await self.loop.sock_sendall方式发送数据'''
        pass

    async def init_socket(self, danmuSocketInfo, roomInfo):
        '''初始化socket并调用self.init_socket方法'''
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.setblocking(False)
        try:
            await self.loop.sock_connect(self.sock, danmuSocketInfo)
            # ConnectionRefusedError
        except Exception as e:
            print(e)
        else:
            await self._init_socket(roomInfo)

    @abc.abstractmethod
    async def heartCoro(self):
        '''每隔x秒发送心跳包维持websocket连接'''
        pass

    async def danmuCoro(self):
        '''弹幕处理协程，异步接收弹幕数据
           并使用self.msgHandleBlock在另一线程/进程处理数据
           因为数据流是单向的所以即使是进程也不麻烦'''
        while True:
            content = await self.loop.sock_recv(self.sock, 1024)
            # sock_recv(sock[, 1024]) 接收字节不可以省略
            self.loop.run_in_executor(self.executor,
                                      self.msgHandleBlock, content)

    @abc.abstractmethod
    def msgHandleBlock(self, content):
        '''阻塞耗时的弹幕数据处理'''
        pass


def pp(msg):
    print(msg.encode(sys.stdin.encoding, 'ignore').
          decode(sys.stdin.encoding))


class ZhanQiDanMuClient(AbstractDanMuClient):
# 其它平台类似修改即可
    def _get_live_status(self):
        url = 'https://www.zhanqi.tv/' + \
              self.url.split('/')[-1] or self.url.split('/')[-2]
        r = requests.get(url, headers={'User-Agent': USER_AGENT})
        if r.url == 'https://www.zhanqi.tv/':
            return False
        rawJson = re.findall('oRoom = (.*);[\s\S]*?window.', r.text)
        if not rawJson:
            rawJson = re.findall('aVideos = (.*);[\s\S]*?oPageConfig.', r.text)
        self.roomInfo = json.loads(rawJson[0])
        # if isinstance(self.roomInfo, list):
        #     self.roomInfo = self.roomInfo[0]
        # print(self.roomInfo['title'])
        return self.roomInfo['status'] == '4'

    def _prepare_env(self):
        serverAddress = json.loads(base64.b64decode(
            self.roomInfo['flashvars']['Servers']).decode('ascii'))['list'][0]
        serverAddress = (serverAddress['ip'], serverAddress['port'])
        url = '%s/api/public/room.viewer' % 'https://www.zhanqi.tv'
        params = {
            'uid': self.roomInfo['uid'],
            '_t': int(time.time() / 60), }
        roomInfo = requests.get(url, params).json()
        roomInfo['id'] = int(self.roomInfo['id'])
        # print(serverAddress, roomInfo)
        return serverAddress, roomInfo

    async def _init_socket(self, roomInfo):
        data = {
            'nickname': '',
            'roomid': int(roomInfo['id']),
            'gid': roomInfo['data']['gid'],
            'sid': roomInfo['data']['sid'],
            'ssid': roomInfo['data']['sid'],
            'timestamp': roomInfo['data']['timestamp'],
            'cmdid': 'loginreq',
            'develop_date': '2015-06-07',
            'fhost': 'zhanqi.tool',
            'fx': 0,
            't': 0,
            'thirdacount': '',
            'uid': 0,
            'ver': 2,
            'vod': 0,
        }
        data = json.dumps(data, separators=(',', ':'))
        await self.loop.sock_sendall(self.sock,
                                     b'\xbb\xcc' + b'\x00' * 4 +
                                     pack('i', len(data)) + b'\x10\x27' +
                                     data.encode('ascii'))

    async def heartCoro(self):
        while True:
            await self.loop.sock_sendall(self.sock,
                                         b'\xbb\xcc' +
                                         b'\x00' * 8 + b'\x59\x27')
            await asyncio.sleep(3)

    def msgHandleBlock(self, content):
        for msg in re.findall(b'\x10\x27({[^\x00]*})\x0a', content):
            try:
                msg = json.loads(msg.decode('utf8', 'ignore'))
                msg['NickName'] = (msg.get('fromname', '') or
                                   msg.get('data', {}).get('nickname', ''))
                msg['Content'] = msg.get('content', '')
                if 'chatm' in msg.get('cmdid', ''):
                    msg['MsgType'] = 'danmu'
                    pp("{0:<30} - [{1}] {2:->10}".format(
                        self.roomInfo['title'],
                        msg['NickName'], msg['Content']))
                    # 格式化输出-参考http://www.crifan.com/python_string_format_fill_with_chars_and_set_alignment/
                elif 'Gift' in msg.get('cmdid', ''):
                    msg['MsgType'] = 'gift'
                else:
                    msg['MsgType'] = 'other'
            except Exception as e:
                print('消息解析出现错误')
            else:
                # self.msgPipe.append(msg)
                pass


if __name__ == '__main__':
    cm = DanMuClientManager()
    cm.start()

其它

• Combining Coroutines with Threads and Processes
  python多进程multiprocessing.Process和异步asyncio.get_event_loop()直接放在一起使用会有问题，使用loop.run_in_executor()来解决该问题。

executor = concurrent.futures.ProcessPoolExecutor(max_workers=3,) 
loop.run_in_executor(executor, task, args)