十天学会Python——第10天：Web服务器、闭包与装饰器

于 2024-07-21 14:49:39 发布
阅读量392 收藏 1
点赞数 12
分类专栏： 十天学会Python 文章标签： python 服务器 人工智能 机器学习 自然语言处理 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RunningJie/article/details/140588078
版权

1 静态Web服务器

搭建Python自带的Web服务器：使用 python3 -m http.server 端口号（默认8000）

返回固定页面数据开发步骤：

1 编写一个TCP服务端程序

2 获取浏览器发送的HTTP请求报文数据

3 读取固定页面数据，把页面数据组装成HTTP响应报文数据发送给浏览器

4 HTTP响应报文数据发送完成以后，关闭服务于客户端的套接字

import socket

if __name__ == "__main__":
    # 1 编写一个TCP服务端程序
    tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)	# 创建socket
    tcp_server_socket.setsockopt(socket.SOLSOCKET,socket.SO_RESUEADDR,True)		# socket复用
    tcp_server_socket.bind(("",8080))		# 绑定地址
    tcp_server_socket.listen(128)		# 设置监听
    
    while True:
        # 2 获取浏览器发送的HTTP请求报文数据
        client_socket,client_addr = tcp_server.accept()	# 建立链接
        client_request_data = client_socket.recv(1024)decode()	# 获取浏览器请求信息
        print(client_request_data)
        # 3 读取固定页面数据，把页面数据组装成HTTP响应报文数据发送给浏览器
        with open("./static/index.html","rb") as f:
            file_data = f.read
        
        response_line = "HTTP/1.1 200 OK\r\n"
        response_header = "Sercer:pwb\r\n"
        response_body = file_data
        
        response_data = (response_line + response_header + "\r\n")
        client_socket.send(response_data)	# 发生数据
        
        # 4 HTTP响应报文数据发送完成以后，关闭服务于客户端的套接字
        cline_socket.close()

注意：

with expression as variable：expression是一个返回上下文管理器的表达式，variable用于保存上下文管理器返回的对象

返回指定页面数据开发步骤：

1 获取用户请求资源的路径

2 根据请求资源的路径，读取指定文件的数据

3 组装指定文件数据的响应报文，发送给浏览器

4 判断请求的文件在服务端不存在，组装404状态的响应报文，发送给浏览器

import socket

if __name__ == "__main__":
    # 1 编写一个TCP服务端程序
    tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)	# 创建socket
    tcp_server_socket.setsockopt(socket.SOLSOCKET,socket.SO_RESUEADDR,True)		# socket复用
    tcp_server_socket.bind(("",8080))		# 绑定地址
    tcp_server_socket.listen(128)		# 设置监听
    
    while True:
            # 2 获取浏览器发送的HTTP请求报文数据
            client_socket,client_addr = tcp_server.accept()	# 建立链接
            client_request_data = client_socket.recv(1024)decode()	# 获取浏览器请求信息
            print(client_request_data)

            # 获取用户请求资源的路径
            request_data = client_request_data.split(" ")	# 返回的是一个列表
            request_path = request_data[1]

            if request_path == "/":
                request_path = "/index.html"

            # 3 读取固定页面数据，把页面数据组装成HTTP响应报文数据发送给浏览器
            # 根据请求资源路径，获取指定文件的数据
            try:
                with open("./static" + request_path,"rb") as f: 	# 这里是用户输入路径
                    file_data = f.read
            except Exception as e:
                # 返回404错误数据
                response_line = "HTTP/1.1 404 Not Found\r\n"
                response_header = "Sercer:pwb\r\n"
                response_body = "404 Not Found sorry"

                # 组装指定文件数据的响应报文，发送给浏览器
                response_data = (response_line + response_header + "\r\n" + response.body).encode
                client_socket.send(response_data)	# 发生数据

            else:
                response_line = "HTTP/1.1 200 OK\r\n"
                response_header = "Sercer:pwb\r\n"
                response_body = file_data

                # 组装指定文件数据的响应报文，发送给浏览器
                response_data = (response_line + response_header + "\r\n").emcode() + response.body
                client_socket.send(response_data)	# 发数据
            finally:
                # 4 HTTP响应报文数据发送完成以后，关闭服务于客户端的套接字
                cline_socket.close()

静态Web服务器—多任务版

当客户端和服务端建立连接成功，创建子线程，使用子线程专门处理客户端的请求，防止主线程阻塞

import socket
import threading

def handle_client_request(client_socket):
    client_request_data = client_socket.recv(1024)decode()	# 获取浏览器请求信息
        print(client_request_data)
        
        # 获取用户请求资源的路径
        request_data = client_request_data.split(" ")	# 返回的是一个列表
        request_path = request_data[1]
        
        # 判断客户端是否关闭
        if len(request_data) == 1:
            client_socket.close()
            return
        
        if request_path == "/":
            request_path = "/index.html"
        
        # 3 读取固定页面数据，把页面数据组装成HTTP响应报文数据发送给浏览器
        # 根据请求资源路径，获取指定文件的数据
        try:
            with open("./static" + request_path,"rb") as f: 	# 这里是用户输入路径
                file_data = f.read
        except Exception as e:
            # 返回404错误数据
            response_line = "HTTP/1.1 404 Not Found\r\n"
            response_header = "Sercer:pwb\r\n"
            response_body = "404 Not Found sorry"

            # 组装指定文件数据的响应报文，发送给浏览器
            response_data = (response_line + response_header + "\r\n" + response.body).encode
            client_socket.send(response_data)	# 发生数据
                
        else:
            response_line = "HTTP/1.1 200 OK\r\n"
            response_header = "Sercer:pwb\r\n"
            response_body = file_data

            # 组装指定文件数据的响应报文，发送给浏览器
            response_data = (response_line + response_header + "\r\n").emcode() + response.body
            client_socket.send(response_data)	# 发数据
        finally:
            # 4 HTTP响应报文数据发送完成以后，关闭服务于客户端的套接字
            cline_socket.close()
            
if __name__ == "__main__":
    # 1 编写一个TCP服务端程序
    tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)	# 创建socket
    tcp_server_socket.setsockopt(socket.SOLSOCKET,socket.SO_RESUEADDR,True)		# socket复用
    tcp_server_socket.bind(("",8080))		# 绑定地址
    tcp_server_socket.listen(128)		# 设置监听
    
    while True:
            # 2 获取浏览器发送的HTTP请求报文数据
            client_socket,client_addr = tcp_server.accept()	# 建立链接

            # 创建子线程
            sub_thread = threading.Thread(target=handler_client_request,args=(client_socket,))
            sub_thread.start()

静态Web服务器—面向对象开发

1 把提供服务的Web服务器抽象成一个类(HTTPWebServer)：class HttpWebServer

2 提供Web服务器的初始化方法，在初始化方法里面创建Socket对象：def __init__(self)

3 提供一个开启Web服务器的方法，让Web服务器处理客户端请求操作：def star(self)

import socket
import threading
         
class HttpWebServer:
    def __init__(self):
        # 1 编写一个TCP服务端程序
        self. tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)	# 创建socket
        self. tcp_server_socket.setsockopt(socket.SOLSOCKET,socket.SO_RESUEADDR,True)		# socket复用
        self. tcp_server_socket.bind(("",8080))		# 绑定地址
        self. tcp_server_socket.listen(128)		# 设置监听
    
    def handle_client_request(self,client_socket):
    client_request_data = client_socket.recv(1024)decode()	# 获取浏览器请求信息
        print(client_request_data)
        
        # 获取用户请求资源的路径
        request_data = client_request_data.split(" ")	# 返回的是一个列表
        request_path = request_data[1]
        
        # 判断客户端是否关闭
        if len(request_data) == 1:
            client_socket.close()
            return
        
        if request_path == "/":
            request_path = "/index.html"
        
        # 3 读取固定页面数据，把页面数据组装成HTTP响应报文数据发送给浏览器
        # 根据请求资源路径，获取指定文件的数据
        try:
            with open("./static" + request_path,"rb") as f: 	# 这里是用户输入路径
                file_data = f.read
        except Exception as e:
            # 返回404错误数据
            response_line = "HTTP/1.1 404 Not Found\r\n"
            response_header = "Sercer:pwb\r\n"
            response_body = "404 Not Found sorry"

            # 组装指定文件数据的响应报文，发送给浏览器
            response_data = (response_line + response_header + "\r\n" + response.body).encode
            client_socket.send(response_data)	# 发生数据
                
        else:
            response_line = "HTTP/1.1 200 OK\r\n"
            response_header = "Sercer:pwb\r\n"
            response_body = file_data

            # 组装指定文件数据的响应报文，发送给浏览器
            response_data = (response_line + response_header + "\r\n").emcode() + response.body
            client_socket.send(response_data)	# 发数据
        finally:
            # 4 HTTP响应报文数据发送完成以后，关闭服务于客户端的套接字
            cline_socket.close()
    
    def star(self):
        while True:
            # 2 获取浏览器发送的HTTP请求报文数据
            client_socket,client_addr = self. tcp_server.accept()	# 建立链接
            # 创建子线程
            sub_thread = threading.Thread(target=self.handler_client_request,args=(client_socket,))
            sub_thread.start()
            
if __name__ == '__main__':
    # 创建服务器对象
    my_web_server = HttpWebServer()
    my_web_server.start()

静态Web服务器—命令行启动动态绑定端口号

1 获取执行python程序的终端命令行参数

2 判断参数的类型，设置端口号必须是整型

3 给Web服务器类的初始化方法添加一个端口号参数，用于绑定端口号

import socket
import threading
import sys
         
class HttpWebServer:
    def __init__(self,port):
        # 1 编写一个TCP服务端程序
        self. tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)	# 创建socket
        self. tcp_server_socket.setsockopt(socket.SOLSOCKET,socket.SO_RESUEADDR,True)		# socket复用
        self. tcp_server_socket.bind(("",port))		# 绑定地址
        self. tcp_server_socket.listen(128)		# 设置监听
    
    def handle_client_request(self,client_socket):
    client_request_data = client_socket.recv(1024)decode()	# 获取浏览器请求信息
        print(client_request_data)
        
        # 获取用户请求资源的路径
        request_data = client_request_data.split(" ")	# 返回的是一个列表
        request_path = request_data[1]
        
        # 判断客户端是否关闭
        if len(request_data) == 1:
            client_socket.close()
            return
        
        if request_path == "/":
            request_path = "/index.html"
        
        # 3 读取固定页面数据，把页面数据组装成HTTP响应报文数据发送给浏览器
        # 根据请求资源路径，获取指定文件的数据
        try:
            with open("./static" + request_path,"rb") as f: 	# 这里是用户输入路径
                file_data = f.read
        except Exception as e:
            # 返回404错误数据
            response_line = "HTTP/1.1 404 Not Found\r\n"
            response_header = "Sercer:pwb\r\n"
            response_body = "404 Not Found sorry"

            # 组装指定文件数据的响应报文，发送给浏览器
            response_data = (response_line + response_header + "\r\n" + response.body).encode
            client_socket.send(response_data)	# 发生数据
                
        else:
            response_line = "HTTP/1.1 200 OK\r\n"
            response_header = "Sercer:pwb\r\n"
            response_body = file_data

            # 组装指定文件数据的响应报文，发送给浏览器
            response_data = (response_line + response_header + "\r\n").emcode() + response.body
            client_socket.send(response_data)	# 发数据
        finally:
            # 4 HTTP响应报文数据发送完成以后，关闭服务于客户端的套接字
            cline_socket.close()
    
    def star(self):
        while True:
            # 2 获取浏览器发送的HTTP请求报文数据
            client_socket,client_addr = self. tcp_server.accept()	# 建立链接
            # 创建子线程
            sub_thread = threading.Thread(target=self.handler_client_request,args=(client_socket,))
            sub_thread.start()
            
def main():
    # 获取执行python程序的终端命令行参数
    print(sys.argv)
    if len(sys.argv) != 2:
        print('格式错误 pyhton3 xxx.py 9090')
        return
    # 判断参数的类型，设置端口号必须是整型
    if not sys.argv[1].isdigit():		# isdigit()：判断参数是否为整型
        print('格式错误 pyhton3 xxx.py 9090')
        return
    # 创建服务器对象
    # 给Web服务器类的初始化方法添加一个端口号参数，用于绑定端口号
    my_web_server = HttpWebServer(port)
    my_web_server.start()
    
if __name__ == '__main__':
    main()

2 闭包

2.1 函数参数

函数名存放的是函数所在空间地址，函数名()执行函数名所存放空间地址中的代码
在这里插入图片描述

def func01():
    print('nihao')
def foo(func):
    func()
# 调用函数 参数就是函数func01
foo(func01)

闭包：在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包

def func_out(num1):		# 这就是一个闭包
    def func_inner(num2):
        num = num1 + num2
    return func_inner
f = func_out(10)	# 创建闭包实例
f(1)		# 返回结果是：11

注意：

1 通过f=func_out(10)创建闭包，实际上f() 等价于 内部函数func_inner()，即调用闭包相当于调用内部函数

2 利用 nonlocal 变量，可以修改外部函数的变量

def func_out(num1):		# 这就是一个闭包
    def func_inner(num2):
        nunlaocal num1	# 声明外部函数变量
        num1 = num2 + 10
    print(num1)
    dun_inner(10)
    print(num1)
        
    return func_inner
func_out(10)	# 返回结果是：10,20

3 装饰器

装饰器：在不改变原有函数的源代码的情况下,给函数增加新的功能，本质是闭包

装饰器语法糖用法：

def check(fn):
    def inner():
        print('登录验证...')
        fn()
    return inner
# 解释器遇到 @check 会立即执行comment = check(comment)
@check
def comment():		# 需要被装饰的函数
    print('发表评论')
# 使用装饰器装饰函数，增加一个登录功能
# comment = check(comment)
comment()	# 返回结果是：登录验证...发表评论

在这里插入图片描述

装饰器实现函数执行时间统计

import time
def get_time(fn):
    def inner():
        start = time.time()
        fn()
        end = time.time()
        print('时间：',end - start)
    return inner

@get_time
def func():		# 需要被装饰的函数
    for i in range(100000):
        print(i)

func()	# 返回结果是：时间：0.2xxs

带有参数的装饰器

def logging(fn):	# fn = sum_num
    def inner(a,b):
        fn(a,b)
    return inner	# sum_num = inner

@logging
def sun_num(a,b):		# 需要被装饰的函数
    result = a + b
    print(result)

sum_num(1,2)	# 返回结果是：3

装饰带有返回值的函数

def logging(fn):	# fn = sum_num
    def inner(a,b):
        result = fn(a,b)
        print(result)
    return inner	# sum_num = inner

@logging
def sun_num(a,b):		# 需要被装饰的函数
    result = a + b
    print(result)

result = sum_num(1,2)
print(result)		# 返回结果是：3

通用装饰器—装饰带有不定长参数的函数

def logging(fn):	# fn = sum_num
    def inner(*args,**kwargs):
        result = fn(*args,**kwargs)
        print(result)
    return inner	# sum_num = inner

@logging
def sun_num(*args,**kwargs):		# 需要被装饰的函数
    print(*args,**kwargs)

sum_num(1,2,3,age="18")

多个装饰器装饰一个函数

def check1(fn1):
    def inner1():
        print('登录验证1')
        fn1()
    return inner1

def check1(fn2):
    def inner2():
        print('登录验证1')
        fn2()
    return inner2

@check1
@check2

def comment():		# 需要被装饰的函数
    print('发表评论')

comment()	# 返回结果是：登录验证1 登录验证2 发表评论

带有参数的装饰器

def logging(flag):
    def decorator(fn):		# 外部函数只允许有fn一个参数
        def inner(num1,num2):
            if flag == "+":
                print('正在进行加法运算')
            elif flag == "-":
                print('正在进行减法运算')
            result = fn(num1,num2)
            return result
        return inner
    return decorator

@logging('+')		# 此处 + 是装饰器的参数
def add(a,b):
    print a + b
    
result = add(1,3)
print(result)

类装饰器

__call__方法：一个类里面一旦实现了__call__方法，那么这个类创建的对象就是一个可调用对象，可以像调用函数一样进行调用

class Check(object):
    def __call__(self,*args,**kwargs):
        print('我是call')
c = Check()
c()			# 返回结果是：我是call

class Check(object):
    def __init__(self,fn):	# fn = comment
        self.__fn = fn		# 私有属性
    def __call__(self,*args,**kwargs):
        print('登录')
        self.__fn()		# comment()
@Check	# comment= Ckeck(comment)
def comment:
    print('发表评论')
    
comment()

esult = add(1,3)
print(result)

类装饰器

__call__方法：一个类里面一旦实现了__call__方法，那么这个类创建的对象就是一个可调用对象，可以像调用函数一样进行调用

class Check(object):
    def __call__(self,*args,**kwargs):
        print('我是call')
c = Check()
c()			# 返回结果是：我是call

class Check(object):
    def __init__(self,fn):	# fn = comment
        self.__fn = fn		# 私有属性
    def __call__(self,*args,**kwargs):
        print('登录')
        self.__fn()		# comment()
@Check	# comment= Ckeck(comment)
def comment:
    print('发表评论')
    
comment()
夏风肆意
关注
  • 12
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
21天学通python-21天学通Python（第2版）_PDF电子书
q6q6q的专栏
10-28 2458
因资源下载地址容易失效，请加微信号359049049直接领取，直接发最新下载地址。前言=============================================================="21 天学编程系列”自2009 年1 月上市以来一直受到广大读者的青睐。该系列中的大部分图书从一上市就登上了编程类图书销售排行榜的前列，很多大、中专院校也将该系列中的一些图书作为...
python基础学习笔记——完结
程序烂人的博客
08-17 2955
文章目录1. python概述1.1 概述1.2 优缺点1.3 应用场景2. python解释器和集成环境的安装2.1. 编程语言分类2.2 基本环境搭建2.3 集成开发环境pycharm基本配置3. 基本语法3.1 python标准开发规范3.2 标准的输入输出3.3 变量与常量4. 数据类型4.1. 数值4.2 字符串4.3 列表4.4 元祖4.5 字典4.6 元组4.7 自定义类型4.8 查看数据类型type()函数5. 数据类型转换5.1类型转换表如下5.2 int函数5.3 float函数
万字浓缩版，Python 潮流周刊第 1 季的 800 个链接！
Python猫
07-17 534
△△请给“Python猫”加星标，以免错过文章推送你好，我是豌豆花下猫。前几天，我重新整理了 Python 潮流周刊的往期分享，推出了第 1 季的图文版电子书，受到了很多读者的一致好评。但是，合集和电子书的篇幅很长，阅读起来要花不少时间。所以，为了方便大家阅读，我打算将合集进一步整理，分门别类将原始内容的标题罗列出来。本文总计约 800 个链接，有 5 大分类，你可以快速浏览文章、项目、播客、视...
python学习—01:python基础
bxmxuxin的博客
02-14 1768
python编程基础 python介绍 深入理解python编程 一. 高效的开发环境与基础 python开发环境 Windows下Sublime Text3和python语言环境 Linux下Sublime Text3和python语言环境 Ubuntu 下 ipython ...
Python基础语法详解
qq_52421831的博客
07-19 3864
Python基础语法
PYTHON笔记
qq_46658082的博客
03-10 1802
整理的一部分python知识点和学习链接
Python深度使用指南
喝饱水没烦恼的博客
11-22 697
python的基础与进阶知识
精心整理|Python爱好者社区历史文章合集（作者篇）--20190925从豆瓣获取
小仙女说：但行好事，不问前程
09-25 6349
精心整理|Python爱好者社区历史文章合集（作者篇） 参考文件地址：http://www.360doc.com/content/18/0801/00/2990557_774796873.shtml（供共同学习python的同学食用） 若侵权，联系删除 7月16日更新： Python爬取起点中文网小说排行榜信息（上海线下培训作业） 唯一小编王大...
Python学习零基础
weixin_60994019的博客
03-21 1246
Python基本用法易上手
Python学习之路——函数的闭包与装饰器
12-22
很多初次接触到python的小伙伴可能并不理解闭包是什么,为什么有闭包,闭包有什么用,那么今天博主就从这三点来为大家讲解一下python的闭包 一、闭包是什么 官方定义: 在计算机科学中，闭包（英语：Closure），又称词法...
Python高级特性之闭包与装饰器实例详解
01-02
本文实例讲述了Python高级特性之闭包与装饰器。分享给大家供大家参考，具体如下： 闭包 1.函数参数： (1)函数名存放的是函数的地址 (2)函数名()存放的是函数内的代码 (3)函数名只是函数代码空间的引用，当函数名...
实例详解Python装饰器与闭包
12-31
闭包是Python装饰器的基础。要理解闭包，先要了解Python中的变量作用域规则。 变量作用域规则 首先，在函数中是能访问全局变量的： >>> a = 'global var' >>> def foo(): print(a) >>> foo() global var 然后，在...
Python闭包与装饰器原理及实例解析
09-16
Python中的闭包和装饰器是两种非常重要的编程概念，它们都是基于函数的特性来实现的。闭包是一种特殊的函数，它能够记住自己被定义时的环境，即使在外部作用域中，闭包仍然能访问到那些非全局的局部变量。而装饰器则...
使用Python的Turtle库绘制动态风车
最新发布
爱写代码的小朋友
07-20 174
python绘制风车
华为od机试真题 — 代表团坐车(Python)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
07-17 583
【华为od机试真题 】代表团坐车(Python) 某组织举行会议，来了多个代表团同时到达，接待处只有一辆汽车可以同时接待多个代表团，为了提高车辆利用率，请帮接待员计算可以坐满车的接待方案输出方案数量。
【Python如何将字符串连接在一起并使用`join()`方法】
qq_36253366的博客
07-19 248
方法是字符串对象的方法，而不是列表或元组等序列类型的方法。因此，你需要先指定一个用作分隔符的字符串，然后调用这个字符串的。方法将字符串连接在一起，你需要首先确保这些字符串被存储在一个序列类型中（如列表或元组），然后调用这个序列的。方法是一个字符串方法，它用于将序列（如列表、元组等）中的元素以指定的字符连接生成一个新的字符串。列表中的所有字符串元素使用空格作为分隔符连接成一个新的字符串。方法，并将你想要作为分隔符的字符串作为参数传递给。方法，并将包含要连接字符串的序列作为参数传递。
IPython 日志秘籍：%logstate 命令全解析
2401_85812026的博客
07-17 569
logstate命令是 IPython 日志系统的重要组成部分，它帮助我们掌控日志记录的状态。通过本文的介绍，你应该对如何在 IPython 中使用%logstate查看日志状态有了更深入的理解。记住，合理利用日志系统，可以让你的数据探索过程更加透明和可追溯。本文详细介绍了 IPython 的%logstate命令，包括其基本概念、基本用法、输出解析以及实战示例。希望本文能够帮助读者更好地利用 IPython 的日志系统，优化数据探索和科学计算的工作流。记住，掌握%logstate。
Python每日一题：回文数
xiongxiaoxuan的博客
07-16 281
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。给你一个整数 x ，如果 x 是一个回文整数，返回 true；否则，返回 false。解释：从左向右读, 为 -121。从右向左读, 为 121-。因此它不是一个回文数。先将整数x转化为字符串形式，判断x和它的反转形态是否完全相等。解释：从右向左读, 为 01。需注意：True和False首字母大写！提示：-231

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值