python

最新推荐文章于 2024-05-21 11:39:09 发布
最新推荐文章于 2024-05-21 11:39:09 发布
阅读量347 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pansuyong/article/details/101707222
版权

一.python环境安装

1.windows下一键环境安装包

type(1/1):结果是float

type(1//1):结果是int

36j:在数字后面加 "j"表示复数

原始字符串：[在字符串前面加‘r’]

print(r'ge\nrtrw')

字符串运算一

 

Python的基本数据类型

列表的定义

元组

序列的总结

set集合

dict字典

基本数据类型总结

变量

值类型：int str tuple【元组】(不可改变)

引用类型：list set dict(可变)

列表的可变与元组的不可变

 

运算符号

 

表达式

表达式是运算符和操作数所构成的序列

a=1

b=2

c=3

a or b and c的结果：1【会先执行 b and c】

（a or b）and (c+1):结果为4

and 的优先级大于 or

c = a or b  最终c为1，先执行逻辑运算，最后做赋值运算

while循环和for循环与使用场景

break 【强行终止当前的循环，并且以后的循环都不会再执行，只是跳出当前的内层循环，并不会影响到外层循环】

# 在递归中会经常用

counter = 1

while counter <= 10:

    counter += 1

    print(counter)

else:

    print('EOF')


# 主要是用来遍历/循环 序列或者集合、字典
a = [['apple', 'orange', 'banana', 'grape'], (1, 3, 4)]
for item in a:
    for item2 in item:
        if item2 == 'orange':
            # break 【强行终止当前的循环，并且以后的循环都不会再执行，只是跳出当前的内层循环，并不会影响到外层循环】
            print(item2)
            # print(item2, end='')

a = [1, 2, 3]

for x in a:

    if x == 2:

        # break 强行终止当前的循环，并且以后的循环都不会再执行

        # continue 只是终止当前的循环，不会影响以后（下次）的的循环

        print(x)

range和切片


for x in range(0, 10):
    print(x)
    # 0是起始值，10是数据的总长度；2是步长
for x in range(0, 10, 2):
    print(x)
    # 0是起始值，10是数据的总长度；2是步长
for x in range(10, 0, -2):
    print(x)


b = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in b:
    if i % 2 != 0:
        print(i)

 # 利用range
for k in range(0, len(b), 2):
    print(b[k])
# 利用切片
c = b[0:len(b):2]
print(c)

python的项目结构和import导入模块

import module_name

c7.py文件中定义变量a

a=2

c8.py

import c7

print(c7.a)

 

import t.c7 as m

print(m.a)

 

如何一次导入多个模块：

from c9 import (a, b,  c)


print(a)

 

# 导入包

import t

# 导入模块

from t.c7 import a

 

c7.py文件


# 模块的内置属性【__all__ 决定：当c7被以星号导入时，将自动导出哪些变量】

__all__ = ['a', 'c']

a = 4

c = 3

d = 4

 

__init__.py的用法

__init__.py文件是在包内自动运行的，只要引入该包或包中的模块就会运行

t包的目录结构：

t/__init__.py

t/c7.py

t/c8.py

__init__py文件：

当包以星号输出时，只会导出c7
__all__ = ['c7']

c11.py文件：【和t是同级的】

这时c11中并没有拿到模块c8


from t import *
print(c7.a)
# print(c8.e)

通过包的init文件导入python内置的库[init批量导入机制]：

t/__init__.py文件：

import sys
import datetime
import io

c12.py文件【不需要再单独把需要的系统库单个导入，只需要导入t】：

import t
print(t.sys.path)

包与模块的几个常见错误

包和模块是不会被重复导入的；

避免循环导入

入口文件和普通模块内置变量的区别

此时15.py为入口文件

入口文件的name为：__main__

package为空

 

__name__的经典应用

 

认识函数

函数返回多个值：

def demage(skill1, skill2):
    damage1 = skill1*3
    damage2 = skill2*2
    # 默认返回的是元组
    return damage1, damage2


# 序列解包
skill1_damages, skill2_damages = demage(2, 5)
print(skill1_damages, skill2_damages)

序列解包与链式赋值

a = 1
b = 2
c = 3

链式写法2：

a, b, c = 1, 2, 3
d = 3, 4, 5
print(d)  # (3,4,5)
e, f, g = d
print(e)

函数的默认参数：

def print_student(name, gender='男', age=18, college="人民路小学"):
    print("name:", name)
    print("gender:", gender)
    print("age:", age)
    print("college:", college)


print_student("susie")

可变参数【通过加*】

 

def demo(*param):
    print(param) #(1,2,3,4,5)
    print(type(param)) 


demo(1, 2, 3, 4, 4, 5) #参数会变为元组

如果参数本身就是一个元组，在传参数的时候需要加*，要不然参数会变为二维元组

a = (4, 5, 6, 7, 8)
demo(*a)

关键字可变参数的调用

#可变参数
def squsum(*param):
    sum = 0
#通过遍历来调用可变参数
    for i in param:
        sum += i*i
    print(sum)



# 关键字参数
# param参数可以不传
def city_temp0(param1,**param):
  pass

def city_temp(**param):
    print(param)  # {'bj': '32c', 'xm': '23c', 'sh': '31c}
    print(type(param))  # <class 'dict'>
    for key, value in param.items():
        print(key, ":", value)


a = {'bj': "23e", 'er': "45t"}
# 直接传入字典
city_temp(**a)
# 传入键值对
city_temp(bj='32c', xm='23c', sh='31c')

变量作用域

c = 50


def add(x, y):
    c = x+y  # 局部变量
    print(c)  # 3


add(1, 2)
print(c)  # 50


f = 23  # 全局变量


def demo2():
    p = 50

    # 在python里面没有块级作用域
    for i in range(0, 9):
        a = "a"
        p += 1
    print(c)  # 59
    # 在for循环的外部是可以引用其内部的变量的
    print(a)  # 'a'

    print(f)  # 23


demo2()

global 关键字

def demo():
    global c
    c = 8


demo()
print(c)  #8

类的定义

c1.py

class Student():
    name = ''
    age = 0
    # 一定要加self

    def print_file(self):
        print('name:', self.name)
        print('age:', self.age)


# 类的实例化
newStudent = Student()


newStudent.print_file()

c2.py

from c1 import Student

student2 = Student()
student2.print_file()

类与对象

构建类的主要两方面：抓住类的行为和特征

类是一个抽象的概念，并不具体，学生类：只是告诉我们每一个学生都有年龄，班级，姓名等特征；

然后还有学生会有上课做作业的行为等，并不是一个具体的学生。

类就好比一个模板，通过类可以产生很多个对象

 

当类被实例化了之后，它就变成了一个具体的对象，【所以通常实例化一个类时需要传入具体的学生的参数】

对象是用来表示一个具体的概念

 

构造函数

class Student():
  # 这是类变量，只和类相关，不是实例变量
    name = 'Susie'
    age = 0
    # 构造函数
    # 构造函数是自动执行的，当实例化的时候，就会自动执行
    #  构造函数不能返回其他的值，只能返回None
    # 构造函数的作用就是让类生成不同的对象

    def __init__(self, name1, age1):
      # 初始化对象的属性
      # 实例变量：只和对象相关，和类是没有关系的
        self.name = name1
        self.age = age1

    # 一定要加self【实例方法】

    def do_homework(self):
        print('name11:', self.name)
        print('age11:', self.age)


# 类的实例化
newStudent = Student("susu", 28)
print(newStudent.name)
print(Student.name)


newStudent.do_homework()

再实例方法中访问实例变量与类变量

  # 初始化对象的属性
      # 实例变量：只和对象相关，和类是没有关系的
      # 访问实例变量
        self.name = name1
        self.age = age1

        # 访问类变量
        print(Student.summ)
        print(self.__class__.summ)

 

class Student():
  # 这是类变量，只和类相关，不是实例变量
    summ = 40
    name = 'Susie'
    age = 0
    # 构造函数
    # 构造函数是自动执行的，当实例化的时候，就会自动执行
    #  构造函数不能返回其他的值，只能返回None
    # 构造函数的作用就是让类生成不同的对象
    # 构造函数是用来初始化类的各种特征的

    def __init__(self, name1, age1):
      # 初始化对象的属性
      # 实例变量：只和对象相关，和类是没有关系的
      # 访问实例变量
        self.name = name1
        self.age = age1

        # 访问类变量
        print(Student.summ)
        print(self.__class__.summ)

    # 实例方法【一定要加参数self】
    # 实例方法是来描述类的行为的

    def do_homework(self):
        print('name11:', self.name)
        print('age11:', self.age)


# 类的实例化
newStudent = Student("susu", 28)
# print(newStudent.name)
# print(Student.name)
print(newStudent.__dict__)


newStudent.do_homework()

类方法

# 类方法
@classmethod

class Student():
    sum=0
    # 类方法
    @classmethod
    def plus_sum(cls):
        cls.sum+=1

类方法的调用

student.plus_sum()

静态方法

  # 静态方法【很少用】

    @staticmethod

    def add(x,y):

        pass

 

公开和私有

在【方法名字|变量名】前面加双下划线，该方法就会变为私有的，不能在外面直接通过实例或者类访问该方法

         def __do_homework(self):

         self.__sore=0

 def __do_homework(self):

        self.do_english_homework()

  def __init__(self, name1, age1):

        # 初始化对象的属性

        # 实例变量：只和对象相关，和类是没有关系的

        # 访问实例变量

        self.name = name1

        self.age = age1

        self.__sore=0

python会自动在私有变量前面加上类名：

__score=0会变为：_Student__score

student2 = Student("susu", 28)

所以python可以通过 student2._Student__score来访问私有变量[python没有任何机制来阻止去读私有变量]

 

继承

父类c3：

class Human():
    sum = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def get_name(self):
        print(self.name)

    def do_homework(self):
        print("father")

子类c1：

#为了继承父类中的namehe age,参数中需要传入
    def __init__(self, school, name, age):
        self.school = school
        # 在子类中调用父类的构造函数【该方法不推荐使用】
        Human.__init__(self, name, age)

  #通常这样调用父类
        super(Student, self).__init__(name, age)

调用父类方法

  def do_homework(self):
        super(Student, self).do_homework()


from c3 import Human

# 继承


class Student(Human):
#为了继承父类中的namehe age,参数中需要传入
    def __init__(self, school, name, age):
        self.school = school
        # 在子类中调用父类的构造函数
        #Human.__init__(self, name, age)【该方法不推荐】

  #通常这样调用父类
        super(Student, self).__init__(name, age)

   def do_homework(self):
        super(Student, self).do_homework()

# 类的实例化
newStudent = Student("南开", "susu", 28)
# studeng2 = Student()
print(newStudent.name)
print(Student.sum)
newStudent.get_name()

正则表达式

初识表达式

import re
a = 'c|c++|Python|javascript|Python|Python|'
print(a.index('Python') > -1)
print('Python' in a)
r = re.findall('Python', a)
print(r)

if len(r) > 0:
    print("字符串中包含Python")
else:
    print('No')

字符集

# 字符集
import re
# 找出中间是c或者是f的单词
s = "adc,acc,adc,abdefc,afc,ahc"
r = re.findall('a[cf]c', s)
# 找出中间不是c或者是f的单词【^cf取反操作】
# []是或的关系
r2 = re.findall('a[^cf]c', s)
# 匹配从c到f
r3 = re.findall('a[b~f]c', s)
print(r)
print(r2)
print(r3)

概括字符集

# 概括字符集 只匹配单个字符
# \d  匹配数字
# \D  非数字
# \w (小w)等价于[a-zA-Z0-9_]
# \W(大w) 匹配非单词字符  :\n,\r,\t & 等
#  []
# \s 匹配空白字符 ：\n,\r,\t
# \S 匹配非空白字符
import re
a = 'python1111java678php'
r = re.findall('\d', a)
# 匹配单个数字
r2 = re.findall('[0-9]', a)
r3 = re.findall('[^0-9]', a)
r4 = re.findall('\w', a)
print(r)
print(r2)
print(r3)

 

贪婪和非贪婪

# 贪婪和非贪婪
import re
# 默认是贪婪的匹配
a = 'gfdgfh 768hdhdkhjk7 8jhjhd 89h'
r = re.findall('[a-z]{3,7}', a)
# 非贪婪模式：在数量词的后面加上'?'
r2 = re.findall('[a-z]{3,7}?', a)
print(r)
# ['gfdgfh', 'hdhdkhj', 'jhjhd']
print(r2)
# ['gfd', 'gfh', 'hdh', 'dkh', 'jhj']

 

数量词

# 数量词
# *匹配0次或者无限多次
# +匹配1次或者无限多次
# ?匹配0次或者无限1次[可以利用它去重]
import re
a = 'pytho0python1python3pythonn7'
r = re.findall('python*', a)
r2 = re.findall('python+', a)
r3 = re.findall('python?', a)
print(r)  # ['pytho', 'python', 'python', 'pythonn']
print(r2)  # ['python', 'python', 'pythonn']
print(r3)  # ['pytho', 'python', 'python', 'python']

边界匹配符

# 边界匹配【完整的匹配整个字符串】
import re
# ^001$  :表示字符串的必须是'000'
# ^000  :表示字符串的起始必须是'000'
# 000$ :表示字符串的末尾必须是'000'
# 要求4到8位
qq = '1007897987001'
r = re.findall('^\d{4,8}$', qq)
print(r)  # 这是超出了8位

q2 = '1000000001'
r2 = re.findall('000', q2)
print(r2)  # ['000', '000']
r3 = re.findall('^000', q2)
print(r3)  # []

组

import re
a = 'PythonPythonPythonPythonPythonPythonPythonPythonPython'
# 判断字符串中是否存在3个Python单词
# '(Python){3}'  用() 括号  表示一个组，是且的关系
# [abc]  中括号里的字符是或的关系
r = re.findall('(Python)', a)
print(r)

匹配模式参数

import re
lanuage = 'PythonC#\nJavaPHP'

# 模式匹配：re.I【忽略大小写】 re.S【包括换行符】
# .表示匹配除换行符(\n)之外其他所有字符
r = re.findall('c#', lanuage, re.I)  # 忽略大小写
# 既要忽略大小写又要支持对'.'号行为的改变【不排除换行符  \n】
r2 = re.findall('c#.{1}', lanuage, re.I | re.S)
r3 = re.findall('c#.{1}', lanuage, re.I)
print(r)
print(r2)  # []
print(r3)  # ['C#\n']

re.sub正则替换

import re
lanuage = 'PythonC#JavaPHP'
# 替换部份字符
r = re.sub('C#', 'GO', lanuage)
print(r)  # "PythonGOJavaPHP"


# 字符串是不可变的，所以要重新生成  r2
r2 = lanuage.replace('C#', 'ruby')
print(r2)  # PythonrubyJavaPHP

# sub的第二个参数也可以为函数
# value  ：正则表达式所匹配的结果
# 函数返回的结果将会被用于替换  'C#'
# 经常会用到


def convert(value):
  # 匹配日的结果
    mat = value.group()
    print(mat)
    return '!!'+mat+"!!"


r3 = re.sub('C#', convert, lanuage)
print(r3)  # PythonrubyJavaPHP

 

获取指定字符中间的字符

import re
s='life is short,i use python,i love python'

r1 =re.search('life(.*)python',s)
r2 =re.findall('life(.*)python',s)
r3=re.search('life(.*)python(.*)python',s)
# print(r1.group(1))  
# print(r2)
# print(r3.group(0))
# print(r3.group(1))
# print(r3.group(2))
print(r3.group(0,1,2))

结果：

 is short,i use python,i love
[' is short,i use python,i love ']
life is short,i use python,i love python
 is short,i use
,i love
('life is short,i use python,i love python', ' is short,i use ', ',i love ')

枚举

from enum import Enum

# 枚举 枚举的意义在于它的标签，而不是它的值
class VIP(Enum):
    YELLOW=1
    GREEN=2
    BLACK=3
    RED=4
print(VIP.RED)

 

枚举和普通类相比有什么优势

 

# 枚举

枚举的意义在于它的标签，而不是它的值
 Enum是VIP的父类

 

普通类：

# 在普通类下定义的并非是常量

#可变

# 没有防止相同标签的功能 

from enum import Enum

# 枚举 枚举的意义在于它的标签，而不是它的值
# Enum是VIP的父类
class VIP(Enum):
    # 在枚举类下定义的是常量，是不能够被更改的
    yellow=1
    green=2
    black=3
    red=4
print(VIP.red)


# 以普通类的方式定义枚举
class Common():
    # 在普通类下定义的并非是常量
     #可变
     # 没有防止相同标签的功能  
    YELLOW=1

操作枚举类

from enum import Enum

# 枚举 枚举的意义在于它的标签，而不是它的值
class VIP(Enum):
    # 在枚举类下定义的是常量，是不能够被更改的
    YELLOW=1
    GREEN=2
    BLACK=3
    RED=4

print(VIP.RED.value)#枚举的值
print(VIP.RED.name) #枚举名字
print(VIP.RED)  #枚举类型

for v in VIP:
    print(v)

枚举的比较运算和注意事项

from enum import Enum

# 枚举 枚举的意义在于它的标签，而不是它的值
class VIP(Enum):
    # 在枚举类下定义的是常量，是不能够被更改的
    # 枚举的标签名是不可以相同的,但是可以有相同的值【别名】
    YELLOW=1
    YELLOW_ALIAS=1   #是YELLOW的别名
    GREEN=2
    BLACK=3
    RED=4


# print(VIP.RED.value)#枚举的值
# print(VIP.RED.name) #枚举名字
# print(VIP.RED)  #枚举类型


# 枚举可以做等值的比较和身份的比较，但是不能做大小的比较
result=VIP.YELLOW==VIP.BLACK
result1=VIP.YELLOW is VIP.BLACK
print(result)
print(result1)

for v in VIP:
    # 别名不会被遍历
      print(v)


for v in VIP.__members__.items():
    # 别名会被遍历
    print(v)  #得到的是元组 ('YELLOW', <VIP.YELLOW: 1>)


for v in VIP.__members__:
    # 别名会被遍历
    print(v)    #  得到的是名称 YELLOW

枚举转换

 

 

pansuyong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python Class 详解
weixin_44983653的博客
04-02 2万+
Python Class 详解1、基本概念1.1 类 `class`1.2 对象 `instance / object`1.3 面向对象三要素1.4 哲学思想2、类2.1 类的定义2.2 类对象及类属性2.3 类的实例化2.4 `__init__` 方法2.5 实例对象 `instance`2.6 示例 12.7 示例 22.8 示例 33、对象属性3.1属性介绍3.2 实例属性的查找顺序3.3 示例 13.4 示例 23.5 示例 34、类方法 和 静态方法4.1 类方法4.2 静态方法4.3 总结4.4
超详细！Python 类 Class--详细整理
weixin_68789096的博客
10-25 1万+
并且，Python 中也没有真正的私有属性，只有一种约定俗成的方法来模拟私有属性的效果，这也是 Python 的一种“鸭子类型”的体现。类方法可以访问类的私有属性，也可以修改。当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。
python中for循环和while循环的区别_Python for和while循环的区别
weixin_39637661的博客
11-20 73
Python for和while循环的区别十分想念顺店杂可。。。for循环1.for循环第一种情况for x in range(0, 10):print(x)# 结果为0，1，2，3，4，5，6，7，8，9# 从0开始到9结束2.for循环第二种情况for x in range(0, 10, 2):print(x)# 结果为0，2，4，6，8# 从0开始到9结束，依次加23.for循环第三种情况a...
Python中class的用法
最新发布
人工智能视觉分析算法学习实践和经验分享。
05-21 1983
类是面向对象编程（Object-Oriented Programming, OOP）的核心概念之一，它允许我们定义具有属性和方法的对象类型。
Python 学习Task10!
weixin_45652666的博客
11-02 425
掌握 类与对象 类定义 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 class ClassName: <statement-1> . . . <statement-N> 类实例化后，可以使用其属性，创建一个类之后，可以通过类名访问其属性。 类对象 类对象...
Python Class（类）讲解
LaoYu.
09-12 807
Python Class（类）详解！有干货了！
python2.7.17安装包
02-27
Python 2.7.17 是 Python 语言的一个重要版本，尤其对于那些仍然依赖于旧代码库或系统的人来说，它是必不可少的。这个安装包是专为64位（AMD64）架构设计的，适用于Windows操作系统。在本文中，我们将深入探讨Python...
python3.12.2版本
02-20
python3.12.2版本
python3.12.3环境
04-19
python3.12.3环境
Python 八股文.pdf
06-17
Python是一种高级编程语言，以其简洁明了的语法和丰富的标准库而受到广泛欢迎。"Python八股文"可能指的是对Python基础知识的一种系统性总结。在Python中，有以下几个关键概念值得深入探讨： 1. **内置电池...
python入门奶牛问题
06-02
python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题python入门奶牛问题...
Python：class简单介绍
还是应该要努力的（12点前睡觉！！！！！
08-21 564
Python class 类的特点： 多态 Polymorphism 封装 Capusulation 继承 Inheritation 1. 定义 # derived_class - Class this class derived from class class_name(derived_class): # some variables # some override functions such as: __init__, __call__ # some user
Python基础之:Python中的类
程序那些事
04-02 6360
class是面向对象编程的一个非常重要的概念，python中也有class，并且支持面向对象编程的所有标准特性：继承，多态等。 本文将会详细讲解Python中class的信息。
Python Class详解 （附代码）
qq_42852699的博客
09-08 374
这里我们介绍了 Python 类的一些基本概念，包括创建类、实例化对象、访问属性、类方法和静态方法、继承、多继承和封装。对象和类的概念是面向对象编程的核心，是编写高质量 Python 代码的关键之一。
【Python】for i in range ()作用
热门推荐
Vincent Lai的博客
02-02 31万+
for i in range ()作用： range()是一个函数， for i in range () 就是给i赋值： 比如 for i in range （1，3）： 就是把1,2依次赋值给i range () 函数的使用是这样的: range（3）即：从1到3，不包含3，即1,2 range(1,3) 即：从1到3，不包含3，即1,2 range（1,3,2）即：1,2。第三个
『Python笔记』python中的for循环总结(enumerate)
AI新视界
11-19 6万+
目录 1、可以明确循环的次数 2、iteratle_object(可迭代对象) 3、enumerate()使用方法为 4、补充：统计文件行数可以这样写： 1、可以明确循环的次数 遍历一个数据集内的成员 在列表解析中使用 生成器表达式中使用 2、iteratle_object(可迭代对象) String（字符串） List（列表） Tuple（元组） Dictionary...
pytho使用for 元素变量 in range()循环结构、for i in x、意思是把x变量里的内容放到i变量里循环
水亦流人必上的博客
06-03 3557
for a1 in range(50): #range是区域值、就是括号里的值是多少次、然后从0开始、50次、就是0-49 print(a1) #a代表变量、只允许字母开头 for a in range(50): print('鬼啊') #也可以直接打印你需要打印什么东西 for a in range(50): print('第',a+1,'次打...
python😋 😋
09-15
Python是一种交互式语言，可以在Python提示符（>>>）后直接执行代码。Python解释器易于扩展，可以通过调用C语言或C来扩展新功能和数据类型。Python有多种解释器，包括CPython、IPython、PyPy、Jython和IronPython等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值