【Python】详解面向对象（下篇）

已于 2022-07-20 12:42:35 修改
阅读量518 收藏 2
点赞数 4
分类专栏： Python入门 文章标签： python pycharm 开发语言
于 2022-07-13 08:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62511863/article/details/125742673
版权

在这里插入图片描述
🔥 越努力，越幸运，这里是博主程序喵 🎶
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾
🦄 本文由 程序喵正在路上 原创，CSDN首发！
💖 系列专栏：Python入门
🌠 首发时间：2022年7月13日
✅ 如果觉得博主的文章还不错的话，希望小伙伴们三连支持一下哦

阅读指南

🌟面向对象 —— 继承

生活中的继承，一般指的是子女继承父辈的财产

在这里插入图片描述

  • 经典类和旧式类
    不由任意内置类型派生出的类，称之为经典类
class 类名:
	代码
	......
  • 新式类
class 类名(object):
	代码

Python 面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法，具体如下

# 父类A
class A(object):
    def __init__(self):
        self.num = 1

    def info_print(self):
        print(self.num)

# 子类B
class B(A):
    pass

result = B()
result.info_print()  # 1

在 Python 中，所有类默认继承 object 类，object 类是顶级类或基类；其他子类叫做派生类

单继承

故事主线：一个煎饼果子老师傅，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼果子的技术。师傅要把这套技术传授给他唯一的最得意的徒弟。

分析：徒弟是不是要继承师父的所有技术？

# 1. 师父类
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

# 2. 徒弟类
class Prentice(Master):
    pass

# 3. 创建对象daqiu
daqiu = Prentice()

# 4. 对象访问实例属性和方法
print(daqiu.kongfu)
daqiu.make_cake()

在这里插入图片描述

多继承

故事推进：daqiu是个爱学习的好孩子，想学习更多的煎饼果子技术，于是，在百度搜索到培训班，想报班学习煎饼果子技术

所谓多继承的意思就是一个类同时继承了多个父类

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

# 创建学校类
class School(object):
    def __init__(self):
        self.kongfu = '[新式煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class Prentice(School, Master):
    pass


daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

在这里插入图片描述

注意：当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法

子类重写父类同名方法和属性

故事：daqiu掌握了师父和培训的技术后，自己潜心钻研出自己的独门配方的一套全新的煎饼果子技术

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

class School(object):
    def __init__(self):
        self.kongfu = '[新式煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

# 独创配方
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

结论：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法

_mro_ 魔法方法

看起来继承关系很复杂，但是通过__mro__魔法方法我们可以直接看到调用顺序

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(object):
    def __init__(self):
        self.kongfu = '[新式煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 独创配方
class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

print(Prentice.__mro__)

在这里插入图片描述

子类调用父类的同名属性和方法

故事：很多顾客都希望也能迟到古法和新式的技术制作的煎饼果子

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(object):
    def __init__(self):
        self.kongfu = '[新式煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'

    def make_cake(self):
        # 如果是先调用了父类的属性和方法，父类属性会覆盖子类属性，故在调用属性前，先调用自己子类的初始化
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    # 调用父类方法，但是为保证调用到的也是父类的属性，必须在调用方法前调用父类的初始化
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


daqiu = Prentice()

print(daqiu.kongfu)

daqiu.make_cake()

daqiu.make_master_cake()

daqiu.make_school_cake()

在这里插入图片描述

多层继承

故事：N年后，daqiu老了，想要把所有技术继承给自己的徒弟

步骤：

  1. 创建类Tusun，用这个类创建对象
  2. 用这个对象调用父类的属性或方法看能否成功
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(object):
    def __init__(self):
        self.kongfu = '[新式煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

# 徒孙类
class Tusun(Prentice):
    pass

xiaoqiu = Tusun()

xiaoqiu.make_cake()

xiaoqiu.make_school_cake()

xiaoqiu.make_master_cake()

在这里插入图片描述

super()调用父类方法

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 继承Master类
class School(Master):
    def __init__(self):
        self.kongfu = '[新式煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

        # 方法1
        # super(School, self)._init_()
        # super(School, self).make_cake()

        # 方法2
        super().__init__()
        super().make_cake()


# 继承School类
class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    # 子类调用父类的同名属性和方法：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

    # 一次性调用父类的同名属性和方法
    def make_old_cake(self):
        # 方法一：代码冗余；父类类名如果变化，这里代码需要频繁修改
        # Master._init_(self)
        # Master.make_cake(self)
        # School._init_(self)
        # School.make_cake(self)

        # 方法二：super()
        # 方法2.1 super(当前类名, self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()

        # 方法2.2 super().函数()
        super().__init__()
        super().make_cake()


daqiu = Prentice()
daqiu.make_old_cake()

在这里插入图片描述

注意：使用 super() 可以自动查找父类，调用顺序遵循 _mro_ 类属性的顺序，比较适合单继承使用

私有属性

1. 定义私有属性和方法

在 Python 中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类

故事：daqiu把技术传承给徒弟的同时，不想把自己的钱（2000000个亿）继承给徒弟，这个时候就要为钱这个实例属性设置私有权限

设置私有权限的方法：在属性名和方法名前面加上两个下划线_

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(object):
    def __init__(self):
        self.kongfu = '[新式煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
        # 定义私有属性
        self.__money = 2000000

    # 定义私有方法
    def __info_print(self):
        print(self.kongfu)
        print(self._money)

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

# 徒孙类
class Tusun(Prentice):
    pass

daqiu = Prentice()
# 对象不能访问私有属性和私有方法
print(daqiu.__money)
daqiu.__info_print()

xiaoqiu = Tusun()
# 子类无法继承父类的私有属性和私有方法
# print(xiaoqiu.__money)
# xiaoqiu.__info_print()

在这里插入图片描述

注意：私有属性和私有方法只能在类里面访问和修改

2. 修改私有属性值

在 Python 中，一般定义函数名 get_xx 用来获取属性，定义 set_xx 用来修改私有属性值

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(object):
    def __init__(self):
        self.kongfu = '[新式煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '[独创煎饼果子配方]'
        # 定义私有属性
        self.__money = 2000000

    # 获取私有属性
    def get_money(self):
        return self.__money

    # 修改私有属性
    def set_money(self):
        self.__money = 500

    def __info_print(self):
        print(self.kongfu)
        print(self._money)

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


# 徒孙类
class Tusun(Prentice):
    pass


xiaoqiu = Tusun()
# 调用get_money函数获取私有属性money的值
print(xiaoqiu.get_money())
# 调用set_money函数修改私有属性money的值
xiaoqiu.set_money()
print(xiaoqiu.get_money())

在这里插入图片描述

继承总结

  • 继承的特点
    ◦ 子类默认拥有父类的所有属性和方法
    ◦ 子类重写父类同名属性和方法
    ◦ 子类调用父类同名属性和方法
  • super() 方法快速调用父类方法
  • 私有权限
    ◦ 不能继承给子类的属性和方法需要添加私有权限
    ◦ 语法
class 类名():
	# 私有属性
	__属性名 = 值

	# 私有方法
	def __函数名(self):
		代码

⚡面向对象 —— 其他

面向对象三大特性

  • 封装
    ◦ 将属性和方法书写到类的里面的操作即为封装
    ◦ 封装可以为属性和方法添加私有权限
  • 继承
    ◦ 子类默认继承父类的所有属性和方法
    ◦ 子类可以重写父类属性和方法
  • 多态
    ◦ 传入不同的对象，产生不同的结果

多态

了解多态

多态指的是一类事物有多种形态（一个抽象类有多个子类，因而多态的概念依赖于继承）

  • 定义：多态是一种使用对象的方法，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果
  • 好处：使用灵活，有了多态，更容易写出通用的代码，做出通用的编程，以适应需求的不断变化
  • 实现步骤：
    ◦ 定义父类，并提供公共方法
    ◦ 定义子类，并重写父类方法
    ◦ 传递子类对象给调用者，可以看到不同子类执行效果不同

体验多态

class Dog(object):
    def work(self):     # 父类提供统一的方法，哪怕是空方法
        print('指哪打哪...')

class ArmyDog(Dog):     # 继承Dog类
    def work(self):             # 子类重写父类同名方法
        print('追击敌人...')

class DrugDog(Dog):
    def work(self):
        print('追查毒品...')
        
class Person(object):
    def work_with_dog(self, dog):   # 传入不同的对象，执行不同的代码，即不同的work函数
        dog.work()

ad = ArmyDog()
dd = DrugDog()

daqiu = Person()
daqiu.work_with_dog(ad)
daqiu.work_with_dog(dd)

在这里插入图片描述

类属性和实例属性

类属性

  • 设置和访问类属性
    ◦ 类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有
    ◦ 类属性可以使用类对象或实例对象访问
class Dog(object):
    tooth = 10


wangcai = Dog()
xiaohei = Dog()

print(Dog.tooth)
print(wangcai.tooth)
print(xiaohei.tooth)

在这里插入图片描述

  • 修改类属性
    ◦ 类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性
class Dog(object):
    tooth = 10


wangcai = Dog()
xiaohei = Dog()

# 修改类属性
Dog.tooth = 12
print(Dog.tooth)
print(wangcai.tooth)
print(xiaohei.tooth)

# 不能通过对象修改属性，如果这样操作，实则是创建了一个实例属性
wangcai.tooth = 20
print(Dog.tooth)
print(wangcai.tooth)
print(xiaohei.tooth)

在这里插入图片描述

类方法和静态方法

类方法

  • 类方法特点
    ◦ 需要用修饰器 @classmethod 来表示其为类方法，对于类方法，第一个参数必须是类对象，一般以 cls 作为第一个参数
  • 类方法使用场景
    ◦ 当方法中需要使用类对象（如访问私有类属性等）时，定义类方法
    ◦ 类方法一般和类属性配合使用
class Dog(object):
    __tooth = 10

    @classmethod
    def get_tooth(cls):
        return cls.__tooth


wangcai = Dog()
result = wangcai.get_tooth()
print(result)

在这里插入图片描述
静态方法

  • 静态方法特点
    ◦ 需要通过装饰器 @staticmethod 来进行修饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有 self/cls)
    ◦ 静态方法也能够通过实例对象和类对象去访问
  • 静态方法使用场景
    ◦ 当方法中既不需要使用实例对象（如实例对象、实例属性），也不需要使用类对象（如类属性、类方法、创建实例等）时，定义静态方法
    ◦ 取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗
class Dog(object):
    @staticmethod
    def info_print():
        print('这是一个狗类，用于创建狗实例......')


wangcai = Dog()
# 静态方法既可以使用对象访问又可以使用类访问
wangcai.info_print()
Dog.info_print()

在这里插入图片描述

总结

  • 面向对象三大特性
    ◦ 封装
    ◦ 继承
    ◦ 多态
  • 类属性
    ◦ 归属于类对象的属性，所有对象共有的属性
  • 实例属性
  • 类方法
@classmethod
def xx():
	代码
  • 静态方法
@staticmethod
def xx():
	代码

 

🧸这次的分享就到这里啦，继续加油哦^^
🍭有出错的地方欢迎在评论区指出来，共同进步，谢谢啦

程序喵正在路上
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
python 面向对象全面详解
日入上万
01-12 5万+
目录   一、对面向对象的理解 1、面向对象的编程---object oriented programming 2、python面向对象的重要术语： 3、函数和面向对象编程的区别 二、封装、继承、多态 1、封装（Encapsulation） 2、继承（Inheritance） 3、多态（Polymorphism） 三、面向对象的各种方法 1、静态方法  (用这个装饰器来表示 ...
python中的面向对象（教学式讲解）
十七光年的博客
08-02 2274
文章目录面向对象基础第一节 类和封装一.理解面向对象二.类和对象(封装)三.添加和获取对象属性四.类属性和实例属性五.类方法和静态方法 面向对象基础 第一节 类和封装 目标 理解面向对象 类和对象 添加和获取对象属性 一.理解面向对象 在讲面向对象之前，总结一下面向过程 1.1.面向过程和面向对象对比： 面向过程编程最易被初学者接受， 往往用一长段代码来实现指定功能 随着时间的推移，开始使用了函数式编程，增强代码的复用性和可读性，就变成了这样. 面向对象编程则是另一种解决问题的思路 python中“面向过程
Python面向对象详解（非常详细）
热门推荐
ZTLJQ的博客
04-21 2万+
面向对象编程（Object-Oriented Programming，OOP）是一种常用的编程思想，它强调万物皆对象，因此在编程时我们可以将现实世界中的事物抽象成程序中的对象，从而更好实现软件的设计与开发。与传统的基于函数的编程不同，面向对象编程注重于将数据与行为封装在一起，即对象既包含数据状态，还包含可调用的行为方法。面向对象编程的特点在于，它具有封装、继承和多态三大特性。封装意味着将对象的状态和行为进行封装，使其对外只暴露必要的接口，从而提高了安全性和可维护性；
python 面向对象（进阶篇）
Anakinami0的博客
12-08 439
python 面向对象（进阶篇） 上一篇《Python 面向对象（初级篇）》文章介绍了面向对象基本知识：面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用 类 是一个模板，模板中包装了多个“函数”供使用（可以讲多函数中公用的变量封装到对象中） 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类
python之面向对象编程
qq_43428929的博客
08-23 1491
面向对象程序设计面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是种具有对象概念的编程典范，同时也是一种程序开发的抽象方针。它可能包含数据、特性、代码与方法。对象则指的是类（class）的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性，对象里的程序可以访问及经常修改对象相关连的数据。在面向对象程序编程里，计算机程序会被设计成彼此相关的对象。从维基百科的定义可以看出，面向对象编程的对象。
面向对象编程（Python版详解）
辰兮要努力
04-03 2万+
本篇是面向对象编程Python版详解！案例教学超详细，欢迎打卡、阅读学习！
Python面向对象总结一
qq_42681787的博客
11-20 1280
本篇博客介绍了python面向对象知识
python面向对象和面向过程优缺点_面向对象和面向过程详解
weixin_34072003的博客
02-21 280
1.前言其实一直对面向过程和面向对象的概念和区别没有很深入的理解，在自己不断想完善自己的知识体系中，今天借这个时间，写一篇博客。来深入的了解面向过程与面向对象！好记性不如烂笔头！！2.面向对象与面向过程的区别面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为...
python面向对象基础_Python面向对象基础语法
weixin_39714383的博客
12-04 134
目标dir内置函数定义简单的类(只包含方法)方法中的self参数初始化方法内置方法和属性01.dir内置函数(知道)在Python中对象几乎是无所不在的，我们之前学习的变量、数据、函数都是对象在Python中可以使用以下两个方法验证：在标识符/数据后输入一个.，然后按下TAB键，iPython会提示该对象能够调用的方法列表使用内置函数dir传入标识符...
Python中的面向对象编程详解(下)
09-22
在Python中，面向对象编程（OOP）是一种非常重要的编程范式，它通过“类”和“对象”来组织代码。Python作为支持面向对象的语言，提供了丰富的面向对象编程特性。本篇详解的后半部分主要涵盖了以下几个重要概念： 1...
Python面向对象总结及类与正则表达式详解
10-17
Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的...这篇文章主要介绍了Python面向对象总结及类与正则表达式 ,需要的朋友可以参考下
Python面向对象进阶学习
09-19
本篇文章旨在为读者提供更深入的理解与实践指南，帮助大家更好地掌握Python面向对象编程的核心技巧。 #### 二、进阶知识点详解 ##### 1. @property 装饰器 - **背景**：在Python中，我们经常需要对对象的属性进行...
【python】—— Python爬虫实战：爬取珠海市2011-2023年天气数据并保存为CSV文件
weixin_63106307的博客
09-05 743
本文将介绍如何使用Python编写一个简单的爬虫程序，以爬取珠海市2011年至2023年的天气数据，并将这些数据保存为CSV文件。
JS都有哪些操作数组的方法
ggq53219的博客
09-04 445
JavaScript 中操作数组的方法非常丰富，这些方法大致可以分为几类：创建和初始化数组、添加元素、删除元素、遍历数组、搜索元素、数组排序、数组映射和过滤等。
Transiting from CUDA to HIP （二）
weixin_44500921的博客
09-03 1227
为了解决这个问题，HIP（Heterogeneous-compute Interface for Portability）提供了一套宏定义，使得开发者可以编写可移植的代码，这些代码可以在 NVIDIA 的 CUDA 平台和 AMD 的 ROCm 平台上运行。是一个预定义的宏，用于指示当前编译的代码所针对的 NVIDIA GPU 的计算能力（Compute Capability）。为了正确编译包含 HIP 代码的文件，您需要确保编译器能够找到 HIP 的头文件，并且定义了正确的宏。
asyncio note
weixin_48232453的博客
09-03 820
python异步库asyncio入门
【hot100篇-python刷题记录】【数据流的中位数】
m0_73629042的博客
09-04 282
精简的代码总是难以琢磨。
访问数组索引时超出边界引发 ArrayIndexOutOfBoundsException
最新发布
Itmastergo的博客
09-05 874
在 Java 中，数组是一种数据结构，用于存储固定数量的同类型元素。数组中的元素可以是基本数据类型（如intcharfloat等）或引用类型（如String、自定义类等）。数组是一种线性表数据结构，也就是说，数组中的元素可以通过一个整数索引来访问。数组的索引从0开始，这意味着对于长度为n的数组，合法的索引范围是从0到n-1。// 创建一个长度为 5 的整型数组在上面的例子中，numbers是一个包含 5 个整型元素的数组，索引从0到4。数组的大小在创建时就已经固定，因此无法动态扩展。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序喵正在路上

你的鼓励是我创作最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值