Python入门基础(6)--面向对象/类和对象/魔术方法

最新推荐文章于 2024-05-02 18:45:29 发布
最新推荐文章于 2024-05-02 18:45:29 发布
阅读量259 收藏
点赞数
分类专栏： Python 文章标签： python 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ona_Soton/article/details/120265650
版权

 

面向对象基本概述

  • 面向对象（Object Oriented Programming,OOP）编程：扩展性更强、可读性更好。面向对象的编程将数据和操作数据封装到对象中，组织代码和数据的方式更接近人的思维，提高编程效率。
  • python支持面向对象、面向过程、函数式编程等多种编程范式

面向对象与面向过程编程的区别与联系


面向过程procedure oriented思维

  1. 按照解决问题的逻辑去编写代码，根据业务逻辑从上到下写代码,
  2. 面向过程编程：“程序的逻辑流程”，适合编写小范围的程序。
  3. 在思考问题时，首先分析‘怎么按照步骤去实现’，然后将问题解决拆解成若干个步骤，并将这些步骤对应成方法，一步一步的最终完成这个功能
  4. 没有精力考虑别的事情，只专注于如何完成，因此不适合做大项目


面向对象object oriented思维

  1. 是一种python的编程思想，将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程
  2. 面向对象编程：“软件中对象之间的关系”，有更多的精力去做别的事情，因此适合编写大规模的程序
  3. 思考方式：名词—类—根据需求确定属性和方法—确定之间关系
  4. 关注设计的思维（让别人去做），像是洗车找谁去洗车

例如：

第一种洗车方式（面向过程）--关注过程

  1. 自己上某宝买洗车工具。
  2. 根据自己的不多的预算买，抹布，水泵，清洁剂。
  3. 跟店小二狂砍一个小时，便宜了2块钱。
  4. 等了一周，买的东西到了，开始洗车
  5. 洗到一半，水泵坏了，泡泡还没洗干净

第二种洗车方式（面向对象）--关注结果

  1. 找一家靠谱的洗车店
  2. 给钱洗车

函数式

      将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

面向对象&面向对象过程：

面向对象：按人们认识客观世界的系统思维方式,采用基于对象(实体) 的概念建立模型,模拟客观世界分析、设 计、实现软件的办法。（万事万物皆对象）

面向对象编程(Object Oriented Programming-OOP)：是一种解决软件复用的设计和编程方法。这种方法把软件系统中相近相似的操作逻辑和操作，应用数据、状态,以类的形式描述出来, 以对象实例的形式在软件系统中复用,以达到提高软件开发效率的作用。

面向对象的基本功能

继承、多态、封装（python无法实现像其他高级语言一样的隐藏，此处的封装就是逻辑意义上的封装）等。

面向对象编程的好处

扩展性更强、可读性更好、简化编程过程。面向对象编程就是将数据和操作对应数据相关的方法封装到类对象中。

类和对象

类和对象是面向对象编程中重要的概念

类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

类相当于制造汽车的图纸，用这个图纸制造的汽车相当于对象


类

  • 类：也称为类对象，类的实例称为实例对象，类是具有一组相同或者相似特征/属性，行为/功能的一系列/多个对象的组合
  • 类(Class)由3个部分构成
    类的名称: 类名
    类的属性: 一组数据 （车的颜色，大小等）
    类的方法: 允许对进行操作的方法 (行为) （车的跑，倒车等）
  • 类在创建时，不占用内存空间，只有实例化的时候才会分配内存空间

对象

  • 对象：对象是实实在在的一个东西，是类的实例化，具象化，
  • 类是对象的抽象化，而对象是类的一个实例

类的抽象

具有相同(或者类似)属性和行为的一系列对象的集合都可以抽像出一个类

例1：小明开着他家的宝马去逛街
         小明 ->可以抽象中人类
         宝马 ->可以抽象出车类

例2：抽象坦克大战中的类
         坦克
         --类名：Tank
         --属性：血量 类型
         --方法：发射子弹
         墙
         --类名: Wall
         --属性：血量 类型
         --方法：阻挡
         子弹
         --类名：Bullet
         --属性：杀伤力

语法（类和对象）

-类名符合标识符规则：首字母大写，采用大驼峰规则
-类体中可以定义属性和方法

-属性用来描述数据，方法（即函数）来描述数据相关的操作

 

 

实例方法与属性

在类的内部（class内部定义），使用 def 关键字可以定义一个实例方法，第一个参数默认是self【名字标识可以是其他的】，实例方法是归于类的实例所有，与一般函数定义不同，类方法必须包含参数 self（可以不叫self，但是必须有这个关键字）,且为第一个参数

实例方法是指所属权利归实例所有，每一个实例都可以调用

属性：

类里面定义的变量。定义在类里面，方法外面的属性称之为类属性

定义在方法里面使用self引用的属性称之为实例属性【通过类似于 self.变量名 定义】，实例属性的归属于实例

（定义属性最好不要重名，不管是哪种属性）

（两者的区别在系统分配内存空间是会有明显的不同）

 

# 定义类和对象
# 类结构  类名  属性  方法
# class 类名:
#     属性
#     方法

class Person:
    '''
    对应人的特征
    '''
    # name='小明'  #类属性
    age=20       #类属性
    '''
    对应人的行为  实例方法
    '''
    def __init__(self):
        self.name='小明'   #实例属性
        pass
    def eat(parms):
        print("大口的吃饭")
        pass
    def run(self):   #实例方法
        print('飞快的跑')
        pass
    pass
def printInfo():
    '''
    普通方法
    :return:
    '''
    pass
# 创建一个对象【类的实例化】
# 规则格式  对象名=类名()
xm=Person()
xm.eat() #调用函数
xm.run()
print("{}的年龄是：{}".format(xm.name,xm.age))

# 创建另外一个实例对象
xw=Person()
xw.eat()  #实例方法


class GoodStudent:
    def __init__(self,name,score): #self必须位于第一个参数
        self.name=name
        self.score=score
    def say_score(self):
        print("{0}的分数是:{1}".format(self.name,self.score))
s1=GoodStudent("hzh",18). #调用构造方法
s1.say_score()

__init__(self) 方法

__init__(self) 方法，初始化方法，实例化对象的时候自动调用，主要用于实例属性的声明，和完成一些初始化设置，系统在创建对象是自动调用，不需要手动调用。

*方法名左右都有下划线的方法我们称为魔术方法，是系统内部已经定义好的方法

__init__传参

如果init方法里面的属性固定了，每个类创建出来的对象属性都一样，这个时候我们是不是考虑将属性当参数在实例化对象的时候传进去，让类更通用？

  

# class Pepole:
#     def __init__(self):##init方法的创建
#         '''
#         实例属性的声明
#         '''
#         self.name='小倩'
#         self.sex='女生'
#         self.age=20
#         pass
#     def eat(self):
#         '''
#         吃的行为
#         :return:
#         '''
#         print('喜欢吃榴莲')
#     pass
#传统添加实例属性的两种方式
# xq=Pepole() 
# xq.name='小倩'  #添加实例属性
# xq.sex='女生'   #添加实例属性
# xq.age=20    #添加实例属性，直接赋值了
# xq.eat()      #传统的添加实力属性方式
# # print(xq.name,xq.sex,xq.age)
#
# xl=Pepole()  #创建出来的（完全独立的对象仍然需要重新实例化属性）
# xl.name='小倩'  #添加实例属性
# xl.sex='女生'   #添加实例属性
# xl.age=20    #添加实例属性
####添加init方法后可以直接使用
# xm=Pepole()  #在创建新对象的时候 是自动执行的，不需要专门调用init的方法
# print(xm.name) #直接输出的是默认值（在class内部就已经定义好的，如果此处再次赋值则是修改了）
# xm.name='小明'##修改class内部已经定义好的属性
# print(xm.name)

# 如果有n个这个对象  被实例化  那么就需要添加很多次这样的属性了 显然是比较麻烦
#####引入init方法
# init传递参数 改进
class Pepole:
    def __init__(self,name,sex,age):
        '''
        实例属性的声明
        '''
        self.name=name
        self.sex=sex
        self.age=age
        pass
    def eat(self,food):
        '''
        吃的行为
        :return:
        '''
        print(self.name+'喜欢吃'+food) #最好用format格式化一下
    pass

zp=Pepole('张鹏','男生',18)
print(zp.name,zp.age)
zp.eat('香蕉')
lh=Pepole('李辉','男生',28)
lh.eat('苹果')
print(lh.name,lh.age)

xh=Pepole('小花','女生',20)
xh.eat('橘子')
print(xh.name,xh.age)

总结 __init__

  1. python 自带的内置函数 具有特殊的函数   使用双下划线 包起来的【魔术方法】
  2. 是一个初始化的方法 用来定义实例属性 和初始化数据的，在创建对象的时候自动调用  不用手动去调用
  3. 利用传参的机制可以让我们定义功能更加强大并且方便的 类

Self

是什么？

self和对象指向同一个内存地址，可以认为self就是对象的引用。

self传参问题

所谓的self，可以理解为对象自己，某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可。

*self本身就一个对象，实例化时，自动把创建的对象和self对应上了，因此在传参的时候不需要为self传递参数

##证明self和实例对象是同一个对象
class Person:
    def __init__(self,pro,name,food):
        
    '''
   定义类
    '''
    def eat(self):
        '''
        实例方法
        :return:
        '''
        # print('self-%s',id(self)) 
        pass
    pass
##xm是一个新的实例化对象
xm=Person()
print('xw=%s',id.(xw))
xw.eat()
###实例化对象和self的内存地址都是相同的，self和xw是同一个对象
###self就是指的实例对象本身（当类方法里只有一个self参数时）

##self传参

class Person:
    def __init__(self,pro,name,food):
        '''

        :param pro: 专业
        :param name: 姓名
        :param food: 食物
        '''
        self.pro=pro  #实例属性的定义
        self.name=name
        self.food=food
        print('----init-----函数执行')
        pass
    '''
   定义类
    '''
    def eat(self,name,food):
        '''
        实例方法
        :return:
        '''
        # print('self=%s',id(self))
        print('%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro))
        pass
    def __str__(self):
        '''
        打印对象 自定义对象 是内容格式的
        :return:
        '''
        return '%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro)
        pass
    def __new__(cls, *args, **kwargs):
        '''
        创建对象实例的方法  每调用一次 就会生成一个新的对象 cls 就是class的缩写

        场景：可以控制创建对象的一些属性限定 经常用来做单例模式的时候来使用
        :param args:
        :param kwargs:
        '''
        print('----new-----函数的执行')
        return object.__new__(cls) #在这里是真正创建对象实例的
        pass
    pass


# xw是一个新的实例化对象
xw=Person('心理学','小王','榴莲')
# print('xw=%s',id(xw))
# xw.eat('小王','榴莲')##self本身就一个对象，实例化时，自动把创建的对象和self对应上了，因此在传参的时候不需要为self传递参数
print(xw)  #直接输出对象 输出的是地址

小结  self特点

  1. self只有在类中定义 实例方法的时候才有意义,在调用时候不必传入相应的参数 而是由解释器 自动去指向
  2. self的名字是可以更改的  可以定义成其他的名字，只是约定俗成的定义成了 self
  3. self 指的是 类实例对象本身, 相当于java中 this

魔术方法

概述

在python中，有一些内置好的特定的方法，方法名是“__xxx__”,在进行特定的操作时会自动被调用，这些方法称之为魔法方法。
下面介绍几种常见的魔法方法。
__init__方法：初始化一个类，在创建实例对象为其赋值时使用。
__str__方法：在将对象转换成字符串  str(对象)  测试的时候，打印对象的信息。
__new__方法：创建并返回一个实例对象，调用了一次，就会得到一个对象。
__class__方法：获得已知对象的类 ( 对象.__class__)。
__del__方法：对象在程序运行结束后进行对象销毁的时候调用这个方法，来释放资源。
……

__str__方法

直接打印对象，输出结果只一串类似id地址的信息。

输出结果

 在类中定义给__str__方法

输出结果

print(xw)  #直接输出对象 输出的是地址
#__str__可以输出对象的一些信息

class Person:
    def __init__(self,pro,name,food):
        '''

        :param pro: 专业
        :param name: 姓名
        :param food: 食物
        '''
        self.pro=pro  #实例属性的定义
        self.name=name
        self.food=food
        print('----init-----函数执行')
        pass
    '''
   定义类
    '''
    def eat(self,name,food):
        '''
        实例方法
        :return:
        '''
        # print('self=%s',id(self))
        print('%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro))
        pass
#####str方法定义
    def __str__(self):
        '''
        打印对象 自定义对象 是内容格式的
        :return:
        '''
        return '%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro)
        pass
    pass


# xw是一个新的实例化对象
xw=Person('心理学','小王','榴莲')
# print('xw=%s',id(xw))
# xw.eat('小王','榴莲')
print(xw)  #直接输出对象，这回就输出了信息，魔术方法默认在调用对象时就会执行

__new__方法

 创建对象实例的方法  每调用一次 就会生成一个新的对象 cls 就是class的缩写

  场景：可以控制创建对象的一些属性限定 经常用来做单例模式的时候来使用

class Person:
    def __init__(self,pro,name,food):
        '''

        :param pro: 专业
        :param name: 姓名
        :param food: 食物
        '''
        self.pro=pro  #实例属性的定义
        self.name=name
        self.food=food
        print('----init-----函数执行')
        pass
    '''
   定义类
    '''
    def eat(self,name,food):
        '''
        实例方法
        :return:
        '''
        # print('self=%s',id(self))
        print('%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro))
        pass
    def __str__(self):
        '''
        打印对象 自定义对象 是内容格式的
        :return:
        '''
        return '%s 喜欢吃 %s 修的专业是:%s'%(self.name,self.food,self.pro)
        pass
    def __new__(cls, *args, **kwargs):
        '''
        创建对象实例的方法  每调用一次 就会生成一个新的对象 cls 就是class的缩写

        场景：可以控制创建对象的一些属性限定 经常用来做单例模式的时候来使用
        :param args:
        :param kwargs:
        '''
        print('----new-----函数的执行')
        pass
    pass


# xw是一个新的实例化对象
xw=Person('心理学','小王','榴莲')
# print('xw=%s',id(xw))
# xw.eat('小王','榴莲')
print(xw)  #直接输出对象

##加了new魔术方法打印结果
----new-----函数的执行
None
##加了new，str没有创建成功，有new时先执行new，新创建了个对象，那么就肯定没有内容
#改为：
 def __new__(cls, *args, **kwargs):
        '''
        创建对象实例的方法  每调用一次 就会生成一个新的对象 cls 就是class的缩写

        场景：可以控制创建对象的一些属性限定 经常用来做单例模式/对象的时候来使用
        :param args:
        :param kwargs:
        '''
        print('----new-----函数的执行')
        return object.__new__(cls) #在这里是真正创建对象实例的，return必须有，object是超类对象，至少有一个cls这个参数，代表要实例化的类，此参数由python解释器自动提供，不需传递
        pass
    pass
# xw是一个新的实例化对象
xw=Person('心理学','小王','榴莲')
# print('xw=%s',id(xw))
# xw.eat('小王','榴莲')
print(xw)  #直接输出对象

#打印结果
----new-----函数的执行
----init-----函数执行
小王 喜欢吃 榴莲 修的专业是：心理学

__new__和__init___函数的区别

  1.  __new__ 类的实例化方法 必须要返回该实例（return） 否则对象就创建不成功
  2.  __init___ 用来做数据属性的初始化工作  也可以认为是实例的构造方法  接受类的实例 self 并对其进行构造
  3. __new__   至少有一个参数是 cls 代表要实例化的类 ，此参数在实例化时由python解释器自动提供
  4. __new__  函数 执行要早于 __init___ 函数

案例---决战紫禁之巅（双人对战）

问题分析：

决战紫禁之巅有两个人物，西门吹雪以及叶孤城
        属性：
            name 玩家的名字
            blood 玩家血量

         方法：
            tong() 捅对方一刀,对方掉血10滴
            kanren() 砍对方一刀，对方掉血15滴
            chiyao() 吃一颗药，补血10滴
            __str__ 打印玩家状态

实现步骤：

1、定义类，创建__init__方法

2、创建玩家技能方法

 3、创建__str__方法，输出玩家状态

4、创建西门吹雪以及叶孤城两个人物

5、两个开始互砍

输出结果

 

 

 

Ona_Soton
关注
专栏目录
【PHP 面向对象】面向对象(OOP)编程之魔术方法实现重载知识点归纳总结（三）
Zeus
05-13 290
魔术方法实现重载PHP 通过魔术方法实现重载属性重载（属性拦截器）方法重载（方法拦截器）事件委托（方法重定向）实战案例（查询构造器）trait: 类功能横向扩展 PHP 通过魔术方法实现重载 魔术方法 作用 __construct() 实例化类时自动调用（构造函数） __destruct() 类对象使用结束时自动调用（析构函数） __set() 在给未定义的属性赋值时自动调用 __get() 调用未定义的属性时自动调用 __isset() 使用 isset() 或 empty
6.python入门-面向对象
数据分析之路
05-23 179
面向对象编程：类好对象，类的成员,属性、方法、修饰器等。还有类的特性，封装，继承，多态，组合。以及魔术方法的汇总。
Python 面向对象1_类和对象-属性方法-下划线-魔术方法-自省
hj的博客
01-12 437
1、概念 常见的三种编程范式： 函数式编程 高阶函数、返回函数、装饰器等 面向过程编程（函数） 着重于作什么 面向对象编程（类） 着重于谁去做 **类：**用来描述具有相同的属性和方法的对象的集合—>车类 **对象：**通过类定义的数据结构实例—>我的车 **属性：**对象的描述信息---->车的零部件 **方法：**对象的行为—>车的功能（将零部件组装，实现某种功能） ...
OOP-常用魔术方法
qq_36685978的博客
10-31 249
类的常用魔术方法 魔术方法就是不需要认为调用的方法，基本是在特定的时刻自动触发 魔术方法的统一特征，方法名前后各两个下划线包裹 操作类 ‘__init__’: 构造函数 ‘__new__’: 对象实例化方法，此函数教特殊，一般不需要使用 ‘__call__’: 对象当函数使用的时候触发 ‘_str_’: 当对象被当作字符串使用的时候调用 ‘__repr__’: 返回字符串，跟’_str_'具体...
PHP对象的魔术方法,PHP面向对象(OOP)的魔术方法和常用函数
weixin_28717611的博客
03-09 218
一. OOP的魔术方法__autoload()内置方法来自动包含类文件。__autoload()应该被写成单个参数的方法。当PHP引擎遇到试图实例化未知类的操作时，会调用__autoload()方法，并将类名当作字符串参数传递给它。__autoload()解决了要引入多个类文件不需要一一引入，不会过多引入文件而造成浪费，不会由于遗漏引用某个类文件而报错。__autoload()应该写在所有实例化类...
面向对象(OOP：Object Oriented Programming)5 -- 魔术方法
谁家的喵
04-29 334
魔术方法是其他语言没有的方法，能够大大提高编程效率，使代码更加pythonic
《量化交易入门（七）Python开发－面向对象和类》配套源码
03-21
以上就是Python面向对象编程的基础知识，结合《量化交易入门（七）Python开发－面向对象和类》的配套源码，你可以进一步了解如何将这些概念应用于量化交易的实际场景中。通过不断实践和学习，你将能够熟练地运用...
11-Python入门基础必备-面向对象编程进阶
Python基础回顾 ## 1.1 Python基础语法复习 在这一部分，我们将回顾Python的基础语法，包括变量的定义、数据类型、运算符等内容。 ### 变量的定义 在Python中，可以通过赋值语句来定义变量，例如： ```python ...
Python面向对象class的魔术函数.py
07-09
Python面向对象class的魔术函数.py
Python基础篇：面向对象【案例实操】_python面向对象的实例练习 csdn
最新发布
2401_84585372的博客
05-02 100
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。工具都帮大家整理好了，安装就可直接上手！“”“部门经理”“”
python中常见的魔法方法 magic method
onlinexkxk的博客
12-13 529
魔法方法都是父类object有的，在python3中所有的类默认都会继承object。当我们对这个对象使用这些函数或者运算符时就会调用类中的对应魔法方法，可以理解为重写这些python的内置函数。到达条件自动触发
Python——类和对象、魔术方法（day07）
清园暖歌的博客
06-30 763
一、面向对象二、类和对象三、实例方法和属性四、__init__方法五、self六、魔法方法七、双人对决八、作业九、补充面向对象编程：oop [object oriented programming] 是一种python的编程思路 面向过程：就是我们一开始学习的，按照解决问题的步骤去写代码 【根据业务逻辑去写代码】 在思考问题的时候, 首先分析'怎么按照步骤去实现' 然后将问题解决拆解成若干个步骤，并将这些步骤对应成方法一步一步的 最终完成功能 面向对象：关注的是设计思维【找洗车店 给钱洗车】出差--北京
object.__new__
Claroja
07-01 2380
https://python-packaging-zh.readthedocs.io/zh_CN/latest/minimal.html python模块或者包名应该遵循: 1.全小写 2.不要和pypi上已有的包重复,即使不想发布,因为在本地可能重名 生成 创建目录结构 test/ project/ __init__.py setup.py setup.py设置 from setuptools import setup setup(name='project', # 包
python 面向对象-类的魔法方法__new__()和单例模式（九）
分享我的点点滴滴，在成长路上与你同行！
01-29 337
object类中__new__方法： 说明： __new__（）创建和返回一个新的对象。通俗说：该魔法属性是用来创建实例对象的。接下来我们看一下它的是如何创建对象的。 1、__new__()是在新式类中新出现的方法，它作用在构造方法建造实例之前。 2、__new__() 方法始终都是类的静态方法，即使没有被加上静态方法装饰器。 __new__()方法用于定义创建对象时执行的操作 > 对象的创建由new方法控制 init > 只是对象创建的时候会自动执行的方法 new &gt.
python object.__new__（）单例模式
记录软件测试过程中遇到的问题
05-25 312
单例模式是一种常用的模式，目的是确保类只有一个实例存在。使用场景多出现于访问文件。基于__new__（）魔法方法实现单例模式
python __new__()分析
weixin_30654583的博客
07-13 235
我们来看下下面类中对__new__()方法的实现： class Demo(object): def __init__(self): print '__init__() called...' def __new__(cls, *args, **kwargs): print '__new__() - {cls}'.format(cls=cls） ...
Python 里的 super() 函数和 object.__new__ ()、.__del__() 方法
weixin_34405354的博客
01-17 497
2019独角兽企业重金招聘Python工程师标准>>> ...
Python中super()或object.__new__报TypeError: object.__new__() takes no arguments错误的解决方案
老猿Python
06-25 4969
出现这种情况是调用object类__new__方法参数传递多了导致： 一般是使用了类似super().new(cls,*args,**kwargs) 或object.new(self,*args,**kwargs) 这种方式调用的，此时只要改成： super().new(cls) 或object.new(self) 调用就可以了。 注意：如果直接父类不是object，通过super调用服了的__n...
Object类，以及__new__，__init__，__setattr__，__dict__
xx_xjm的博客
06-25 558
笔记
Python面向对象编程入门教程详解
7. 魔术方法：Python中有一类特殊的双下划线开头和结尾的方法，称为魔术方法（Magic Methods），例如`__init__`、`__str__`、`__repr__`等。它们有特殊的用途，例如初始化对象、定义对象的字符串表示等。 8. 静态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值