【Python基础入门系列】12、Python中的面向对象（三）

最新推荐文章于 2022-04-07 20:54:30 发布
最新推荐文章于 2022-04-07 20:54:30 发布
阅读量110 收藏
点赞数
原文链接：https://blog.csdn.net/CUFEECR/article/details/103103803
版权

一、继承的简介

1.引入

class Doctor():
    name = ''
    age = ''
    def treat(self):
        print('treat a patient')

class soldier():
    name = ''
    age = ''

    def protect(self):
        print('Protect the people')

以上定义了两个类，但是又重复的属性name、age，如果每定义一个类都要分别定义这两个属性，很重复冗余，所以可以抽象出一个类来封装它们的公共属性和方法，即它们的父类这些类都继承自它们的父类。
如

class Person():
    name = ''
    age = ''

2.继承的特点：

1.提高了代码的复用性；
2.让类与类之间产生联系，有了这个联系，才有了多态。
继承是面向对象的三大特性之一，其他两个特性是封装、多态。

定义一个动物类

class Animal:
    def run(self):
        print('Running...')

    def sleep(self):
        print('Sleeping...')

a = Animal()
a.run()

再定义一个狗类，

class Dog:
    def run(self):
        print('Running...')

    def sleep(self):
        print('Sleeping...')

这样定义狗类，有大量重复性代码，表现较差，我们应该使狗类继承自动物类，继承动物类的属性和方法。

class Dog(Animal):

    pass

d = Dog()
d.run()
d.sleep()

打印

Running...
Sleeping...

在定义类时可以在类名＋括号，括号内的指定的是当前类的父类（超类、基类，super）。

class Dog(Animal):
    def Housekeep(self):
        print('Housekeeping...')

d = Dog()
d.run()
d.sleep()
d.Housekeep()
r1 = isinstance(d,Dog)
r2 = isinstance(d,Animal)
print(r1,r2)

打印

Running...
Sleeping...
Housekeeping...
True True

显然，d既是Dog的实例，也是Animal的实例，所以Dog也继承自了Animal。
如果在创建类的时候省略了父类，则默认父类是object；
object是所有类的父类，所有类都继承自object。
issubclass()检查一个类是否是另一个类的子类。

class Animal:
    def run(self):
        print('Running...')

    def sleep(self):
        print('Sleeping...')

class Dog(Animal):
    def Housekeep(self):
        print('Housekeeping')

r1 = issubclass(Dog,Animal)
r2 = issubclass(Animal,object)
print(r1,r2)

证明了所有类都是object的子类，所有对象都是object的实例。

二、方法的重写

如果在子类中有和父类重名的方法，通过子类的实例去调用方法时，会调用子类的方法而不是父类的方法，这个特点称为方法的重写（覆盖，override）。
如，

class Animal:
    def run(self):
        print('Running...')

    def sleep(self):
        print('Sleeping...')

class Dog(Animal):
    def run(self):
        print('Dog is running...')

    def sleep(self):
        print('Dog is sleeping...')

    def Housekeep(self):
        print('Dog is housekeeping')

d = Dog()
d.run()

打印Dog is running...
下边再详细说明，

class A(object):
    def test(self):
        print('A...')

class B(A):
    pass

class C(B):
    pass

c = C()
c.test()

打印A...。
类B中加入方法test()后，

class A(object):
    def test(self):
        print('A...')

class B(A):
    def test(self):
        print('B...')

class C(B):
    pass

c = C()
c.test()

打印B...
类C中加入方法test()后，

class A(object):
    def test(self):
        print('A...')

class B(A):
    def test(self):
        print('B...')

class C(B):
    def test(self):
        print('C...')

c = C()
c.test()

打印C...。
当我们调用一个对象时，会有先去当前对象寻找是否有该方法，如果有直接调用；如果没有，则取当前对象的父类中寻找，如果有，直接调用父类中的方法，如果没有，则去父类的父类寻找，如果有直接调用，以此类推，直到找到object，如果依然没有则报错。

三、super()

父类中所有的方法都会被子类继承，包括特殊方法，如__init__()等，也可以重写特殊方法。

class Animal:
    def __init__(self,name):
        self._name = name

    def run(self):
        print('Running...')

    def sleep(self):
        print('Sleeping...')

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name

class Dog(Animal):
    def run(self):
        print('Dog is running...')

    def sleep(self):
        print('Dog is sleeping...')

    def Housekeep(self):
        print('Dog is housekeeping')

d = Dog()
d.run()

会抛出异常，TypeError: __init__() missing 1 required positional argument: 'name'
因为初始化没有传入参数，因为父类初始化要传入name这个参数，子类也必须传入。
传入参数后,

class Animal:
    def __init__(self,name):
        self._name = name

    def run(self):
        print('Running...')

    def sleep(self):
        print('Sleeping...')

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name

class Dog(Animal):
    def run(self):
        print('Dog is running...')

    def sleep(self):
        print('Dog is sleeping...')

    def Housekeep(self):
        print('Dog is housekeeping')

d = Dog('erha')
print(d.name)

打印erha
调用setter方法修改属性，

class Animal:
    def __init__(self,name):
        self._name = name

    def run(self):
        print('Running...')

    def sleep(self):
        print('Sleeping...')

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name

class Dog(Animal):
    def run(self):
        print('Dog is running...')

    def sleep(self):
        print('Dog is sleeping...')

    def Housekeep(self):
        print('Dog is housekeeping')

d = Dog('erha')
d.name = 'demu'
print(d.name)

打印demu。
如果需要在子类中定义新的属性时，即要扩展属性时，

class Animal:
    def __init__(self,name):
        self._name = name

    def run(self):
        print('Running...')

    def sleep(self):
        print('Sleeping...')

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name

class Dog(Animal):
    def __init__(self,name,age):
        self._name = name
        self._age = age

    def run(self):
        print('Dog is running...')

    def sleep(self):
        print('Dog is sleeping...')

    def Housekeep(self):
        print('Dog is housekeeping')

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

d = Dog('erha',10)
print(d.name)
print(d.age)

打印

erha
10

可以直接调用父类中的__init__()来初始化父类中的属性，

class Animal:
    def __init__(self,name):
        self._name = name

    def run(self):
        print('Running...')

    def sleep(self):
        print('Sleeping...')

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name

class Dog(Animal):
    def __init__(self,name,age):
        Animal.__init__(self,name)
        self._age = age

    def run(self):
        print('Dog is running...')

    def sleep(self):
        print('Dog is sleeping...')

    def Housekeep(self):
        print('Dog is housekeeping')

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

d = Dog('erha',10)
print(d.name)
print(d.age)

即Dog类中的初始化方法中，name属性通过Animal的初始化调用获取，可以将父类的多个属性传给子类，但是继承的父类是固定的，这是需要用suoer()动态地继承父类属性。
super()可以用来获取当前类的父类，并且通过suoer()返回的对象，调用父类方法时不需要传入self。

class Animal:
    def __init__(self,name):
        self._name = name

    def run(self):
        print('Running...')

    def sleep(self):
        print('Sleeping...')

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name

class Dog(Animal):
    def __init__(self,name,age):
        super().__init__(name)
        self._age = age

    def run(self):
        print('Dog is running...')

    def sleep(self):
        print('Dog is sleeping...')

    def Housekeep(self):
        print('Dog is housekeeping')

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

d = Dog('erha',10)
print(d.name)
print(d.age)

执行结果与之前相同。

四、多重继承

语法：类名.__bases__
可以用来获取当前类的所有直接父类。

class A(object):
    def test(self):
        print('A...')

class B(A):
    def test2(self):
        print('B...')

class C(B):
    pass

print(C.__bases__)
print(B.__bases__)
print(A.__bases__)

打印

(<class '__main__.B'>,)
(<class '__main__.A'>,)
(<class 'object'>,)

在Python中支持多重继承，即可以为一个类同时指定多个父类。

class A(object):
    def test(self):
        print('A...')

class B(object):
    def test2(self):
        print('B...')

class C(A,B):
    pass

print(C.__bases__)

打印(<class '__main__.A'>, <class '__main__.B'>)。

class A(object):
    def test(self):
        print('A...')

class B(object):
    def test2(self):
        print('B...')

class C(A,B):
    pass

c = C()
c.test()
c.test2()

打印

A...
B...

显然，子类可以同时继承多个父类的方法。
但是一般在实际中没有特殊情况，尽量避免使用多重继承，因为多重继承会让代码过于复杂；
如果多个父类中有同名的方法，则会在第一个父类中寻找，找不到再继续往下寻找…
如，

class A(object):
    def test(self):
        print('A...test')

class B(object):
    def test(self):
        print('B...test')

    def test2(self):
        print('B...')

class C(A,B):
    pass

c = C()
c.test()

会打印A...test
如果A中没有test()方法，

class A(object):
    pass

class B(object):
    def test(self):
        print('B...test')

    def test2(self):
        print('B...')

class C(A,B):
    pass

c = C()
c.test()

会打印B...test

五、多态

多态是面向对象的三大特征之一。
多态字面理解即多种形态，在面向对象中指一个对象可以以不同的形态呈现。

class A(object):
    def __init__(self,name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name


class B(object):
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

def speak(obj):
    print('Hello,%s' % obj.name)

a = A('Tom')
b = B('Jerry')
speak(a)
speak(b)

打印

Hello,Tom
Hello,Jerry

定义一个新类C，但是没有name属性时，

class A(object):
    def __init__(self,name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name


class B(object):
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

class C(object):
    pass
def speak(obj):
    print('Hello,%s' % obj.name)

a = A('Tom')
b = B('Jerry')
c= C()
speak(a)
speak(b)
speak(c)

会抛出异常，AttributeError: 'C' object has no attribute 'name'，
增加类型检查，

class A(object):
    def __init__(self,name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self,name):
        self._name = name


class B(object):
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

class C(object):
    pass

def speak(obj):
    print('Hello,%s' % obj.name)

def test_speak(obj):
    '''类型检查'''
    if isinstance(obj,A):
        print('Hello,%s' % obj.name)

a = A('Tom')
b = B('Jerry')
c= C()
test_speak(a)
test_speak(b)
test_speak(c)

打印Hello,Tom。
在test_speak()这个函数中做了类型检查，也就是obj是A类型的对象的时候，才可以正常执行，其他类型的对象无法使用该函数。
这个函数其实就是违反了多态。
违反了多态的函数，只适合于一种类型的对象，无法适用于其他类型的对象，导致函数的适用性非常差。
多态使面向对象的编程更加具有灵活性。

l = [1,2,3]
s = 'python'
print(len(l),len(s))

如上，len()函数既可以得到list的长度，又可以获取str的长度，
len()就可以检查不同对象类型的长度就是面向对象的特征之一——多态。
len()的底层实现：
之所以len()函数能获取长度，是因为这些对象中有一个特殊方法len__()方法；换句话说，只要对象中有__len()方法，就可以通过len()方法来获取对象的长度。

class B(object):
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

b = B('Jerry')
print(len(b))

会报错TypeError: object of type 'B' has no len()。
在B中加入__len__()方法后，

class B(object):
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

    def __len__(self):
        return 1

b = B('Jerry')
print(len(b))

会打印1

面向对象的三大特征：
   1.封装：确保对象中的数据更安全；
   2.继承：保证对象的可扩展性；
   3.多态：保证了程序的灵活性。

六、类中的属性和方法

类属性是直接在类中定义的属性，类属性可以通过类或类的实例访问；
通过实例对象添加的属性属于实例属性。

class A(object):
    #类属性
    count = 0

a = A()
print(A.count)
print(a.count)

打印

0
0

修改实例的属性，

class A(object):
    #类属性
    count = 0

a = A()
a.count = 5
print('In class,',A.count)
print('In instance,',a.count)

打印

In class, 0
In instance, 5

修改类中的属性，

class A(object):
    #类属性
    count = 0

a = A()
A.count = 5
print('In class,',A.count)
print('In instance,',a.count)

打印

In class, 5
In instance, 5

可总结出：类属性只能通过类对象来修改，无法通过实例对象来修改；

class A(object):
    def __init__(self):
        #实例属性
        self.name = 'Tom'

a = A()
print(a.name)

打印Tom
在初始化中定义的属性为实例属性，只能通过实例属性来访问和修改，类对象无法访问和修改。
如，

class A(object):
    def __init__(self):
        #实例属性
        self.name = 'Tom'

a = A()
print(A.name)

报错AttributeError: type object 'A' has no attribute 'name'
在类中定义的以self为第一个参数的方法都是实例方法；
实力方法在调用时，Python会将调用对象作为self传入；

class A(object):
    def __init__(self):
        #实例属性
        self.name = 'Tom'
    def test(self):
        #实例方法
        print('in test')
a = A()
a.test()

打印in test
类对象调用时，

class A(object):
    def __init__(self):
        #实例属性
        self.name = 'Tom'
    def test(self):
        #实例方法
        print('in test')
a = A()
A.test()

报错TypeError: test() missing 1 required positional argument: 'self'
但是通过类对象调用时，传入实例对象多为方法的参数不会报错。
即通过类对象调用方法时，不会自动穿self，必须手动传self。

class A(object):
    def __init__(self):
        #实例属性
        self.name = 'Tom'
    def test(self):
        #实例方法
        print('in test')
a = A()
A.test(a)

输出结果相同。
即a.test()等价于A.test(a)。
可以通过classmethod装饰器来调用类方法；
类方法的第一个参数是cls，也会被自动传递，cls就是当前的类对象。

class A(object):
    count = 0
    def __init__(self):
        #实例属性
        self.name = 'Tom'
    def test(self):
        #实例方法
        print('in test')
    @classmethod
    def test2(cls):
        #实例方法
        print('in test2',cls)

a = A()
A.test2()

打印in test2 <class '__main__.A'>
调用类属性，

class A(object):
    count = 0
    def __init__(self):
        #实例属性
        self.name = 'Tom'
    def test(self):
        #实例方法
        print('in test')
    @classmethod
    def test2(cls):
        #实例方法
        print('in test2',cls)
        print(cls.count)

a = A()
A.test2()

打印

in test2 <class '__main__.A'>
0

通过实例调用类方法，

class A(object):
    count = 0
    def __init__(self):
        #实例属性
        self.name = 'Tom'
    def test(self):
        #实例方法
        print('in test')
    @classmethod
    def test2(cls):
        #实例方法
        print('in test2',cls)
        print(cls.count)

a = A()
a.test2()

结果相同。
可总结：类方法可以通过类对象调用，也可通过实例方法调用。
A.test2()等价于a.test2()。
静态方法：
用staticmethod装饰器来调用类方法

class A(object):
    count = 0
    def __init__(self):
        #实例属性
        self.name = 'Tom'
    def test(self):
        #实例方法
        print('in test')
    @classmethod
    def test2(cls):
        #实例方法
        print('in test2',cls)
        print(cls.count)
    @staticmethod
    def test3():
        print('in test3')

a = A()
A.test3()
a.test3()

打印

in test3
in test3
Python3X
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python全栈（一）基础之14.面向对象（3）
CUFEECR的博客
11-16 1688
面向对象是Python的重要思想之一，本篇博客从多态说起，到方法的重写，super()的使用，再到多重继承的分析，再谈到面向对象的另一个重要特性——多态，最后分析了实例方法、实例属性、类方法、类属性，用了大量的实例和对比分析，加深对语法和概念的理解，适合初学者。
【Python入门自学笔记专辑】——面向对象编程
01-20
【Python入门自学笔记专辑】——面向对象编程 前言 ​ 面相对象是Python的重要特性，继承了C++的类风格，在Python中的一切数据类型都是面向对象的。本章主要介绍Python的面向对象编程。 面向对象： ​ 什么是OOP...
Python——匿名函数
时光·漫步的博客
08-17 1530
python 使用 lambda 来创建匿名函数。 所谓匿名，即不再使用 def 语句这样标准的形式定义一个函数。 lambda  只是一个表达式，函数体比 def 简单很多。 lambda  的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。 lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。 虽然 lamb...
Python的基本数据类型——String
沐码人
08-14 333
String是一个Unicode字符序列，是Python中最重要的数据类型之一，可以使用单引号、双引号、三引号创建 创建一个字符串 a='1234' b="hello world" c='''hello world 1234''' 既然单引号、双引号、三引号都可以创建字符串,那么他们的区别在哪呢？ # 单引号、双引号没有太大的区别 # 但是如果我们想输出 what's up ...
Python字符串的基本操作
8X_I的博客
04-07 786
在Python中，字符串使用成对的单引号、双引号、三个单引号、三个双引号，包含数字或字符。在C、C++等语言中，使用单引号来表示字符，而在Python中没有字符类型，单引号和双引号效果是相同的。
上海交通大学python期末考试样题加解析_上海交通大学python期末考试样题加解析...
weixin_39669761的博客
12-13 441
一、选择题: 将唯一正确的选项写在题前括号中.每题2分. 【 】(1) 本课程的目标定位是什么? [A] 学习Python语言 [B] 学习计算机的工作原理 [C] 学习各种算法[D] 学习用计算机解决问题【 】(2) 下列哪个标识符是合法的? [A] var-name [B] !@#$% [C] _100 [D] elif【 】(3) 执行下列语句后的显示结果是什...
Python面向对象基础入门之设置对象属性
12-24
前面我们已经介绍了 python面向对象入门教程之从代码复用开始（一） ，这篇文章主要介绍的是关于Python面向对象之设置对象属性的相关内容，下面话不多说了，来一起看看详细的介绍吧 用类存储数据 类实际上就是一个...
Python入门——类，面向对象的编程
12-21
文章目录引子第一部分 类的定义1.1 类的命名1.2 类的属性——类内部声明的变量1.3 类的方法——类内部定义的函数第二部分 创建实例2.1 实例的创建——实例名 = ...Why：面向对象更符合人类对客观世界的抽象和理解 一切
Python面向对象基础入门之编码细节与注意事项
12-23
在前面，我用了3篇文章解释python的面向对象： 面向对象：从代码复用开始 面向对象：设置对象属性 类和对象的名称空间 本篇是第4篇，用一个完整的示例来解释面向对象的一些细节。 例子的模型是父类Employe和子类...
Python零基础入门-面向对象编程
04-01
本视频为撩课学院Python课程的核心阶段——面向对象编程。毫不夸张的说，这是我所看过的对于面向对象讲解最通俗易懂的教程了，在此安利给大家。 Python教程配套的全套资料更新如下：链接:...
python基础数据类型
浅水鲤鱼的博客
01-20 1209
一、变量、常量、注释 1.1变量   由字母、数字、下划线组成，不能以是数字开头，不能占用python关键字   双下划线开头，双下划线结尾是python内置变量，尽量不适用双下划线开头结尾的   变量与变量之间不互相指，变量指向数据   变量在内存中是唯一命名的 推荐命名方式：   驼峰体：第一个单词的首字母大写    大驼峰：MyName    小驼峰：myname    大小驼峰的不同在于开头的单词字母大小写不同   下划线方式：    my_name ...
python列表练习
m0_64116684的博客
12-21 383
1.循环在列表中添加1-10之间所有的整数 2.在列表中添加一个字符串“XuanGe” 3.删除下标索引为0的元素 4.将下标索引为1的元素修改为66 5.输出列表中的第三个元素 第二 list = [23,34,35,31,22,33,55,43,78,34] 1.新建一个列表为list1并判断list中的偶数添加到list1中并排序 2.将排序的list1通过extend添加list2=[[[3,21],2],[4]...
Python-列表(List)
Michaelyq1229的博客
09-11 1731
列表,类似于JAVA中的数组,但是它比数组更加强大,可以存放任意数据类型 list1=[10,20,30,40,50,60] #可以存放数字 list2=['aa','bb','cc'] #也可以存放字符串 list3=[10,'ABC',(10,20,30),{'A':'B'},[36,72]] #也可以存放其他类型 print(list1,list2,list3) 访问列表中的值 与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。 通过索引列表可以进行截取、组合等操作
python del函数_Python之列表常用函数
weixin_42411799的博客
02-09 618
1. append()和insert()append()函数在列表末尾添加新元素，如：animal = ["dog", "cat", "cow", "lion"]animal.append("rabbit")animal----> ['dog', 'cat', 'cow', 'lion', 'rabbit']insert()函数则可以在列表的任意位置插入元素，如：animal = ["dog...
第1：print("Hello World!")
Shawne's blog
04-19 4765
print()函数概述 print() 方法用于打印输出，是python中最常见的一个函数。 语法 print(*objects, sep=' ', end='\n', file=sys.stdout) 参数 objects --表示输出的对象。输出多个对象时，需要用 , （逗号）分隔。带引号时，计算机无需理解，直接输出；无引号时，计算机需先读懂内容，再打印。 sep – 用来间隔多个对象。 e...
python获取字符串首字母_重拾Python（一）之字符串
weixin_39880621的博客
11-24 1814
逼逼赖赖（俗称前言）：本文乃读 Python3.8 官方文档有感，公交车起步，请乡亲们站稳扶好。目录：字符串基本操作字符串切片字符串方法一、字符串基本操作打印# python 单双引号都可用于字符串（字符）print('hello world')print("hello world")# 下面两种原模原样输出，多行打印print('''helloworld''')print("""hellowor...
Python 探究对象和类
小鹏AI
04-08 169
类的构成： 类的名称：类型 属性：对象的属性 方法：对象的方法 创建和使用类 类的定义： class 类名: 属性列表 方法列表 示例 class people: # 定义基本属性 name = "" age = 0 # 定义私有属性，私有属性在类外部无法直接访问 __weight = 0 #定义构造方法 def __init__(...
Python学习之路（3）
闵豪miao的博客
01-08 127
类的继承 class People: def __init__(self, name, age): self.name = name self.age = age def sleep(self): print("%s is sleeping" % self.name) class Man(People): def __
Pandas出现KeyError及其分析解决
linchun210的专栏
03-09 6062
Pandas出现KeyError及其分析解决（机器翻译）
python零基础入门
最新发布
08-18
如果你是零基础入门Python，我建议你按照以下学习路线进行学习。首先，你可以通过参考中提供的详细教程来系统学习Python的基础知识。该教程从Python基础、文件操作、函数等方面进行了讲解。你可以下载并安装Pycharm...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值