语音识别技术之科大讯飞在线API

最新推荐文章于 2025-11-23 17:36:06 发布
原创 最新推荐文章于 2025-11-23 17:36:06 发布 · 695 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#语音识别 #人工智能

科大讯飞收费标准

控制台-讯飞开放平台

可基于控制台注册免费试用5小时（直接点击套餐有免费额度套餐）

总结一下个人认为的效果，标准版已经out，模型版太贵，不如本地部署。有钱无所谓

以下为针对“实时语音转写（标准版）”与“实时语音转写大模型”两者区别及应用场景：

  1. 问：实时语音转写（标准版）是什么？ 答：基于深度全序列卷积神经网络，通过 WebSocket 长连接实时将连续音频流转换为文字.

  2. 问：实时语音转写大模型是什么？ 答：建立在星火大模型预训练框架上，支持多语种与方言免切识别，能智能断句和补全标点.

  3. 问：标准版支持哪些音频格式？ 答：仅支持采样率16 kHz、位深16 bit、pcm_s16le单声道音频.

  4. 问：标准版支持哪些语种？ 答：默认中文普通话，中英混合和英文；其他小语种及方言需在控制台开通后使用.

  5. 问：大模型版支持哪些语种和方言？ 答：免切换支持37种语种和202种中文方言的混合识别.

  6. 问：标准版适合哪些应用场景？ 答：线上会议实时字幕、网络直播实时转写、客服中心对话监控等持续音频流场景.

  7. 问：大模型版适合哪些应用场景？ 答：跨区域多方言视频会议、国际化直播、电商带货等需覆盖多语种和方言的场景.

  8. 问：两者核心区别是什么？ 答：标准版聚焦低延迟与稳定性，仅支持常规语种；大模型版聚焦多语种与方言覆盖、断句标点及高识别精度.

标准版购买页显示各时长包均标注“并发路数：50路”，其余为价格、时长与有效期信息。单独方言购买优惠期5k/年，无优惠2w/年。

套餐价格(元)服务时长(小时)有效期并发路数
时长套餐一198401年50路
时长套餐二2,0006001年50路
时长套餐三6,0002,0001年50路
时长套餐四10,8006,0001年50路
时长套餐五24,00015,0001年50路
时长套餐六120,000100,0001年50路
时长套餐七400,000500,0001年50路

大模型为新版能力，产品文档提示其在方言与多语种上较标准版更强，以下价格来自网站。

套餐价格(元)时长(小时)有效期
免费包（个人）051年
免费包（企业）0501年
套餐一198401年
套餐二4,0001,0001年
套餐三17,5005,0001年
套餐四60,00020,0001年
套餐五240,000100,0001年
套餐六600,000300,0001年

每分钟单价：大模型各档约为0.0333–0.0825元/分钟，标准版各档约为0.0133–0.0825元/分钟

每小时单价：大模型各档约为4.95-2.00 元/小时，标准版各档约为4.95 –0.80 元/小时

使用教程

个人认为标准版本已被淘汰，主流使用大语言模型版本。

基于我的代码开发，你需要做的是替换API和外部接口加入。

self.app_id = kwargs.get('app_id', '')
self.access_key_id = kwargs.get('access_key_id', '')
self.access_key_secret = kwargs.get('access_key_secret', '')

外部接口方法

#单例模式初始化
 self.xfyunmodle_asr = create_asr(asr_type="xfyun_modle")
 if not self.xfyunmodle_asr.init():
     logger.error("error:XFYunModle ASR组件初始化失败")
 logger.info("✅ XFYunModle ASR组件初始化成功")


#转录工作
self.xfyunmodle_asr.generate(
                  audio=combined_audio,
                  is_final=False
                ) 
#类内对象 self.current_result 接收websocket 转录的文本。

对象代码

class XFYunModle(ASRAUTO):
    """
    基于官方demo扩展 讯飞云实时语音转写API的ASR实现
    使用WebSocket进行实时语音识别，严格控制发送节奏
    """
    
    # 全局配置：与服务端确认的固定参数
    FIXED_PARAMS = {
        "audio_encode": "pcm_s16le",
        "lang": "autodialect",
        "samplerate": "16000"  # 固定16k采样率，对应每40ms发送1280字节
    }
    AUDIO_FRAME_SIZE = 1280  # 每帧音频字节数（16k采样率、16bit位深、40ms）
    FRAME_INTERVAL_MS = 40    # 每帧发送间隔（毫秒）
    
    def __init__(self):
        """初始化XFYun Modle ASR实例"""
        self.app_id = None
        self.access_key_id = None
        self.access_key_secret = None
        self.base_ws_url = "wss://office-api-ast-dx.iflyaisol.com/ast/communicate/v1"
        self.ws = None
        self.is_connected = False
        self.recv_thread = None
        self.session_id = None
        self._is_loaded = False
        self.xfyun_logger = get_logger(__name__ + ".xfyun_modle")
        
        # 识别结果管理
        self.current_result = ""
        self.result_lock = threading.Lock()
        self.result_ready = threading.Event()
        
        # 音频缓冲区
        self.audio_buffer = b''
    
    def init(self, path: str = "", device: str = "cpu", **kwargs) -> bool:
        """
        初始化XFYun Modle ASR
        
        Args:
            path: 配置文件路径（可选）
            device: 设备类型（忽略，XFYun是云端服务）
            **kwargs: 其他参数，可包含app_id, access_key_id, access_key_secret
            
        Returns:
            bool: 初始化是否成功
        """
        try:
            # 从kwargs获取配置
            self.app_id = kwargs.get('app_id', '')
            self.access_key_id = kwargs.get('access_key_id', '')
            self.access_key_secret = kwargs.get('access_key_secret', '')
            
            self._is_loaded = True
            self.xfyun_logger.info("✅ XFYun Modle ASR初始化成功")
            return True
            
        except Exception as e:
            self.xfyun_logger.error(f"XFYun Modle ASR初始化失败: {e}")
            self._is_loaded = False
            return False
    
    def _get_utc_time(self):
        """生成服务端要求的UTC时间格式：yyyy-MM-dd'T'HH:mm:ss+0800"""
        beijing_tz = datetime.timezone(datetime.timedelta(hours=8))
        now = datetime.datetime.now(beijing_tz)
        return now.strftime("%Y-%m-%dT%H:%M:%S%z")
    
    def _generate_auth_params(self):
        """生成鉴权参数（严格按字典序排序，匹配Java TreeMap）"""
        auth_params = {
            "accessKeyId": self.access_key_id,
            "appId": self.app_id,
            "uuid": uuid.uuid4().hex,
            "utc": self._get_utc_time(),
            **self.FIXED_PARAMS
        }
        
        # 计算签名：过滤空值 → 字典序排序 → URL编码 → 拼接基础字符串
        sorted_params = dict(sorted([
            (k, v) for k, v in auth_params.items()
            if v is not None and str(v).strip() != ""
        ]))
        base_str = "&".join([
            f"{urllib.parse.quote(k, safe='')}={urllib.parse.quote(v, safe='')}"
            for k, v in sorted_params.items()
        ])
        
        # HMAC-SHA1 加密 + Base64编码
        signature = hmac.new(
            self.access_key_secret.encode("utf-8"),
            base_str.encode("utf-8"),
            hashlib.sha1
        ).digest()
        auth_params["signature"] = base64.b64encode(signature).decode("utf-8")
        return auth_params
    
    def _connect(self):
        """建立WebSocket连接"""
        try:
            auth_params = self._generate_auth_params()
            params_str = urllib.parse.urlencode(auth_params)
            full_ws_url = f"{self.base_ws_url}?{params_str}"
            self.xfyun_logger.debug(f"连接URL：{full_ws_url}")
            
            # 初始化WebSocket连接
            self.ws = create_connection(
                full_ws_url,
                timeout=15,
                enable_multithread=True
            )
            self.is_connected = True
            self.xfyun_logger.debug("WebSocket握手完成，等待服务端就绪...")
            #time.sleep(1.5)  # 确保服务端完全初始化
            
            # 启动接收线程
            self.recv_thread = threading.Thread(target=self._recv_msg, daemon=True)
            self.recv_thread.start()
            return True
            
        except WebSocketException as e:
            self.xfyun_logger.error(f"WebSocket连接失败：{str(e)}")
            return False
        except Exception as e:
            self.xfyun_logger.error(f"连接异常：{str(e)}")
            return False
    
    def _recv_msg(self):
        """接收服务端消息"""
        while True:
            if not self.is_connected or not self.ws:
                self.xfyun_logger.debug("接收线程：连接已关闭，退出接收循环")
                break
            
            try:
                msg = self.ws.recv()
                if not msg:
                    self.xfyun_logger.debug("服务端关闭连接")
                    self._close()
                    break
                
                # 仅处理文本消息
                if isinstance(msg, str):
                    try:
                        msg_json = json.loads(msg)
                        #https://www.xfyun.cn/doc/spark/asr_llm/rtasr_llm.html#_1-%E6%A6%82%E8%BF%B0                        
                        msg_type = msg_json.get('msg_type', '')
                        #self.xfyun_logger.debug(f"接收消息 - msg_type: {msg_type}, data类型: {type(msg_json.get('data'))}")
                        
                        # 更新会话ID
                        if (msg_type == 'action' 
                            and 'sessionId' in msg_json.get('data', {})):
                            self.session_id = msg_json['data']['sessionId']
#                            self.xfyun_logger.debug(f"更新session_id: {self.session_id}")
                        
                        # 处理识别结果
                        if msg_type == 'result':
                            self._process_recognition_result(msg_json)
                            
                    except json.JSONDecodeError:
                        self.xfyun_logger.warning(f"非JSON文本消息：{msg[:50]}...")
                else:
                    self.xfyun_logger.debug(f"收到二进制消息（长度：{len(msg)}字节），忽略")
            
            except WebSocketException as e:
                self.xfyun_logger.error(f"连接中断：{str(e)}")
                self._close()
                break
            except OSError as e:
                self.xfyun_logger.error(f"系统套接字错误：{str(e)}")
                self._close()
                break
            except Exception as e:
                self.xfyun_logger.error(f"接收异常：{str(e)}")
                self._close()
                break
    
    def _process_recognition_result(self, result_dict):
        """处理识别结果"""
        try:
            # 获取data字段，可能是字符串或已解析的字典
            data = result_dict.get("data", {})
            
            # 如果data是字符串，需要解析
            if isinstance(data, str):
                data = json.loads(data)
            
            # 如果data不是字典，无法处理
            if not isinstance(data, dict):
                self.xfyun_logger.warning(f"data字段类型错误: {type(data)}")
                return
            
            seg_id = data.get("seg_id", "")

            if "cn" in data and "st" in data["cn"]:
                st = data["cn"]["st"]
                type_ = st.get("type")

                if type_ == "0":  # 完整转写内容
                    text_parts = []
                    if "rt" in st:
                        for rt_item in st["rt"]:
                            if "ws" in rt_item:
                                for ws_item in rt_item["ws"]:
                                    if "cw" in ws_item:
                                        for cw_item in ws_item["cw"]:
                                            w = cw_item.get("w", "")
                                            text_parts.append(w)

                    if text_parts:
                        result_text = ''.join(text_parts)
                        with self.result_lock:
                            self.current_result = result_text
                            self.result_ready.set()
                        self.xfyun_logger.debug(f"XFYunModle识别结果: {result_text}")

        except Exception as e:
            self.xfyun_logger.error(f"XFYunModle ASR结果处理错误: {e}")


    def generate(self,
                audio: np.ndarray,
                cache: Optional[Dict] = None,
                is_final: bool = False,
                **kwargs) -> Optional[str]:
        """
        执行语音识别（流式缓冲发送模式，类似XFYunASR）
        
        Args:
            audio: 音频数据 (numpy array, 16kHz, 16bit)
            cache: 缓存（未使用）
            is_final: 是否为最终识别
            **kwargs: 其他参数
            
        Returns:
            Optional[str]: 识别结果文本
        """
        if not self._is_loaded:
            self.xfyun_logger.warning("XFYun Modle ASR未初始化")
            return None
        
        try:
            # 防止和para冲突，关闭最终帧
            is_final = False
            
            # 确保WebSocket连接存在
            if not self.ws or not self.is_connected:
                if not self._connect():
                    self.xfyun_logger.error("无法建立XFYun Modle WebSocket连接")
                    return None
            
            # 转换音频数据格式
            if audio.dtype != np.int16:
                audio = audio.astype(np.int16)
            audio_bytes = audio.tobytes()
            
            # 将音频数据添加到缓冲区
            self.audio_buffer += audio_bytes
            
            # 当缓冲区达到1280字节(40ms)时发送
            while len(self.audio_buffer) >= self.AUDIO_FRAME_SIZE:
                chunk_to_send = self.audio_buffer[:self.AUDIO_FRAME_SIZE]
                self.audio_buffer = self.audio_buffer[self.AUDIO_FRAME_SIZE:]
                
                # 发送音频数据
                self.ws.send_binary(chunk_to_send)
                #time.sleep(self.FRAME_INTERVAL_MS / 1000)  # 40ms间隔
            
            # 如果是最终帧，发送结束标记并等待最终结果
            if is_final:
                # 发送剩余的音频数据
                if len(self.audio_buffer) > 0:
                    self.ws.send_binary(self.audio_buffer)
                    self.audio_buffer = b''
                  #  time.sleep(self.FRAME_INTERVAL_MS / 1000)
                
                # 发送结束标记
                end_msg = {"end": True}
                if self.session_id:
                    end_msg["sessionId"] = self.session_id
                end_msg_str = json.dumps(end_msg, ensure_ascii=False)
                self.ws.send(end_msg_str)
                self.xfyun_logger.debug("已发送结束标记")
                
                # 等待最终识别结果
                max_wait_time = 5.0  # 最大等待5秒
                wait_time = 0
                while wait_time < max_wait_time:
                    with self.result_lock:
                        if self.current_result:
                            result = self.current_result
                            self.xfyun_logger.debug(f"XFYun Modle ASR结果: {result}")
                            self.current_result = ""  # 清空结果
                            self._close()
                            return result
                  #  time.sleep(0.1)
                    wait_time += 0.1
                
                # self._close()
                return None
            
            # 非最终帧，检查是否有中间结果
            with self.result_lock:
                if self.current_result:
                    result = self.current_result
                    #self.xfyun_logger.debug(f"XFYun Modle ASR中间结果: {result}")
                    self.current_result = ""  # 清空结果
                    return result
            
            return None
            
        except Exception as e:
            self.xfyun_logger.error(f"XFYun Modle语音识别失败：{e}")
            self._close()
            return None
    
    def _close(self):
        """安全关闭WebSocket连接"""
        if self.is_connected and self.ws:
            self.is_connected = False
            try:
                if self.ws.connected:
                    self.ws.close(status=1000, reason="客户端正常关闭")
                self.xfyun_logger.debug("WebSocket已安全关闭")
            except Exception as e:
                self.xfyun_logger.error(f"关闭时出错：{str(e)}")
        self.ws = None
    
    def is_loaded(self) -> bool:
        """检查模型是否已加载"""
        return self._is_loaded
    
    def close(self):
        """清理资源"""
        self._close()
        self.audio_buffer = b''
        self._is_loaded = False
        self.xfyun_logger.info("XFYun Modle ASR资源已清理")


def create_asr(asr_type: str = "paraformer") -> ASRAUTO:
    """
    创建ASR实例的工厂函数

    Args:
        asr_type: ASR类型 ("paraformer", "xfyun", "xfyun_modle" 或 "dummy")

    Returns:
        ASRAUTO: ASR实例
    """
    if asr_type.lower() == "paraformer":
        return ParaformerASR()
    elif asr_type.lower() == "xfyun":
        return XFYunASR()
    elif asr_type.lower() == "xfyun_modle":
        return XFYunModle()
    elif asr_type.lower() == "dummy":
        return DummyASR()
    else:
        logger.warning(f"未知的ASR类型: {asr_type}，使用虚拟ASR")
        return DummyASR()

学习社区
https://github.com/0voice

科大讯飞 语音测评 vue接入
m0_57874230的博客
12-15 1221
科大讯飞 语音测评 tts
python之调用科大讯飞的在线语音识别
热门推荐
weixin_45729594的博客
08-07 2万+
python之调用科大讯飞的在线语音识别 没注册的话可以在官网注册一下，新人注册的话语音识别这块有赠送的使用次数 科大讯飞 环境 cffi==1.12.3 gevent==1.4.0 greenlet==0.4.15 pycparser==2.19 six==1.12.0 websocket==0.2.1 websocket-client==0.56.0 wave pyaudio jieba windows 直接 pip install xxx 或 pip3 isntall xxx linux
AI语音识别：科大讯飞API实战
2501_92487436的博客
06-17 944
科大讯飞API提供了丰富的语音识别功能，包括实时语音识别、长语音识别、语音转写等。开发者可以通过简单的接口调用，实现高质量的语音识别服务。高识别准确率：在多种场景下，识别准确率可达95%以上。实时性：支持实时语音识别，满足实时交互需求。易用性：提供简洁的接口调用方式，降低开发难度。本文从技术原理、实战应用等方面详细介绍了AI语音识别在科大讯飞API中的应用。科大讯飞API具有高识别准确率、实时性、易用性等优点，为开发者提供了丰富的语音识别功能。
科大讯飞语音识别技术深入实现与应用
weixin_33759613的博客
07-14 604
科大讯飞成立于1999年，是基于中国科学技术大学语音实验室的科技成果孵化而成立的高科技企业。其成立背景与当时中国在语音技术领域寻求自主创新和突破的国家战略密切相关。讯飞的创建，不仅承载了科研成果转化的愿景，而且意图在国际上推广中文语音技术，解决中文信息处理中的难题。公司的初期发展侧重于语音识别、语音合成以及语音评测等核心技术的积累和创新，为后续的发展打下了坚实的技术基础。graph TDA[科大讯飞成立] -->|1999年| B[基于中国科学技术大学语音实验室]
C#与科大讯飞API的语音识别集成
weixin_28736145的博客
05-30 1327
科大讯飞提供了多种语音识别模式，以适应不同场景下的需求。主要包括但不限于以下几种：连续语音识别：适用于实时或者长时间连续识别的场景，它可以边听边识别，适用于电话会议记录、实时字幕生成等应用场景。标点预测：在此模式下，系统会在输出文本中预测并插入标点符号，通常适用于对识别文本的阅读体验有较高要求的场合。关键词触发：当用户说出预设的关键词时，系统才开始识别语音。此模式适合于需要语音触发特定指令的场景。开发者应根据应用的具体需求和预期的用户体验选择最合适的识别模式。
科大讯飞语音识别技术详解与应用实战
weixin_31185473的博客
08-25 1201
语音识别技术是人工智能的一个分支，它通过将人类的语音信号转换为可理解的文本或命令，使计算机能够理解和执行人类的语音指令。这项技术涉及到信号处理、模式识别以及人工智能等多个领域，是推动人机交互发展的重要技术之一。WFP（Weighted Finite-State Transducer）技术是一种先进的语音前端处理技术，它在语音识别领域中，提供了一种全新的优化方法。WFP技术的核心优势在于其能够有效地处理语音信号的变异性，同时降低计算复杂度，提高识别准确性。
C# 实现科大讯飞语音识别技术指南
weixin_36299472的博客
08-11 760
语音识别技术，也被称作自动语音识别（ASR），是一种将人类语音转换为机器可读文本或命令的技术。这项技术广泛应用于多种场景，如智能手机的语音助手、智能家居控制、汽车导航系统以及客服自动化等。随着人工智能和机器学习的发展，语音识别的准确性和效率显著提高，正在改变人机交互的方式。科大讯飞作为中国领先的智能语音和人工智能公众公司，在语音识别领域拥有先进的技术能力。科大讯飞API提供了基于云计算的语音识别服务，支持多种语言、方言的识别，并能够根据不同的应用场景提供定制化解决方案。
vue语音识别，科大讯飞语音识别webapi
wei9699pk的博客
12-25 1147
语音识别，科大讯飞语音识别webapi相关内容
基于科大讯飞在线语音识别实现语音识别开关风扇
Mi_Ni_BoX的博客
05-28 391
智能语音识别开关风扇系统
AI语音科大讯飞智能api【web端接口调用实现语音识别】webscoket调试试用
11-07
科大讯飞是全球领先的语音技术提供商，其智能API提供了丰富的语音处理功能，包括但不限于语音识别、语音合成、语音唤醒等。在本项目中，我们将主要关注语音识别，它是将人类的语音转化为文字的过程。这一技术在各种...
科大讯飞语音识别（离线+在线）完整工程源代码可运行
01-26
本文将详细讲解基于科大讯飞的语音识别技术，包括离线和在线两种模式，并结合提供的源代码工程，深入解析其工作原理和实现步骤。在Android平台上，利用Java语言进行开发，开发者可以有效地将语音转化为文字，提升...
基于科大讯飞语音识别demo
05-31
科大讯飞作为国内领先的语音技术提供商，其提供的语音识别API和服务在业界享有较高的声誉。本文将基于一个名为“基于科大讯飞语音识别demo”的C#项目，深入探讨如何利用科大讯飞的SDK进行语音识别，并解决实际开发中...
基于ARM与LINUX的机器伴侣，科大讯飞语音语音识别系统源码
05-31
基于ARM与LINUX的机器伴侣，科大讯飞语音语音识别系统源码。代码能在Linux开发板中运行，实现相册，音乐播放，语音控制，视频播放，相机五个功能。 UI设计并非本人，而是由同学CHY构建。 代码初始版本已实现基本功能...
Java Springboot科大讯飞webapi、sdk实现语音听写、语音转写、实时语音转写
06-27
基于Java Springboot微服务，整合科大讯飞webapi、sdk、实时语音转写，分别实现语音听写、语音转写、实时语音转写功能，填写appKey信息就能运行使用，集成了Knife4j接口文档，运行之后即可在线调试，并附有markdown...
Java语音识别开发
2509_93946545的博客
11-22 395
而直接用云服务的话，相当于把识别算法和运算压力甩给了服务商，咱们只需要关注怎么把音频数据传过去、再把返回的文本解析出来就行。整体来看，用Java做语音识别最大的优势是生态完善，各种网络库和音频处理工具都能找到现成轮子。另外网络延迟也可能导致请求超时，最好在代码里设置重试机制，比如用循环请求三次，每次间隔2秒。后来加了格式转换环节，用FFmpeg命令行工具先把音频转成标准的16位PCM WAV，再走识别流程。二是缓存识别结果，对相同音频文件做MD5校验，如果之前识别过就直接返回缓存内容，减少API调用次数。
基于开发者空间Notebook进行LoRA微调Whisper_base实现语音识别
优快云高校俱乐部官方博客
11-21 465
基于开发者空间Notebook进行LoRA微调Whisper_base实现语音识别
MySQL语音识别开发
2509_93946247的博客
11-22 313
语音识别这边，没选那些特别重的深度学习框架，而是用了Python里的SpeechRecognition库，搭配Pyaudio处理音频流。MySQL我用的是8.0版本，主要是看中它的窗口函数和JSON字段支持，后面处理识别结果的时候会很有用。我做了个简单的语音指令系统，比如你说“查询今天的订单”，系统就会先把语音转成文本，然后通过MySQL里预置的指令映射表找到对应的SQL模板，替换参数后执行查询，最后把结果用语音播报出来。我专门做了个定时任务，自动把超过30天的原始音频转移到冷存储，释放数据库空间。
React语音识别案例
最新发布
2509_93946129的博客
11-23 279
在Web开发里，现在主流用的是Web Speech API，这是浏览器原生支持的功能，不需要额外装什么库。这样，就能实时更新界面了。首先，我们需要在React组件里初始化语音识别对象，然后监听各种事件，比如当用户开始说话、识别出结果或者出错时，该做什么处理。然后，在事件里，我们可以遍历结果，提取出最终的文本，并更新到状态里。一个是浏览器权限问题：第一次调用时，浏览器会弹窗请求麦克风权限，如果用户不授权，就得处理这个错误。另外，语音识别对环境噪音比较敏感，在嘈杂的地方准确率会下降，这点在项目里得提醒用户。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值