【python基础】类与类的实例化对象、类方法与类的属性、类实例化的方法与属性、初始化函数、类的继承与重写、@property、私有属性与方法

已于 2024-01-31 11:31:15 修改
阅读量1.1k 收藏 24
点赞数 17
分类专栏： python基础 文章标签： python 开发语言
于 2024-01-31 11:29:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sodaloveer/article/details/134056037
版权

文章目录

类与对象

在这里插入图片描述
“类"就像是工厂里模具，以它为模板，选出来成千上万的产品，才是被我们消费购买使用的东西。这些产品就像是"实例对象”。
从模具变成产品，也就是从"类"变成"实例对象"的过程，就叫做实例化。

类方法与类属性

类是一个函数包，可以放置函数和变量，然后类中的函数可以很方便的使用类中的变量。

语法：class语句来定义一个类。def自定义一个函数。

类方法

定义：在类中被定义的函数被称为类的方法， 描述的是这个类能做什么。
调用类的方法：类名.函数名()

#创建一个名为“ClassName”的类，类名一般首字母要大写，(): 不能丢 
class ClassName():
#假如定义一个名为“你好”的类，可以写成class Hello():
	def function1():
	# 定义类中的函数1

class ClassA():
	def func1():
		print("我是ClassA的第一个方法！")
	def func2():
		print("我是ClassA的第二个方法！")
	def func3():
		print("我是ClassA的第三个方法！")
		
ClassA.func1()
ClassA.func2()
ClassA.func3()

在这里插入图片描述

类的属性

定义：在类中被定义的变量被称为类的属性。
调用类的属性：类名.属性名

class ClassA():
	var1 = 100
	var2 = 200
	var3 = '你好'

print(ClassA.var1)
print(ClassA.var2)
print(ClassA.var3)

在这里插入图片描述

增加/修改类的属性：可以使用类名.变量名在类的外面进行操作。

class ClassA():
	var1 = 100
	var2 = 200
	var3 = '你好'

ClassA.var1 = 99
ClassA.var4 = 'add a var'

print(ClassA.var1)
print(ClassA.var4)

在这里插入图片描述

类方法与类的属性结合使用

方法一：调用类方法与类的属性的结合。

class Robot():
	macaron = 20
	cannele = 15
	cheese_bread = 23
	#以上为类的属性
	
	def welcome_supermarket():
		print("你好，欢迎来到超市的面包区！")
	def pick_one():
		print("我们热销有三款面包哦，欢迎选购~")
	def payment():
		print("收银台在这里，欢迎下次光临~")
	#以上为类的方法
	
#打印类的属性
print(Robot.macaron)
print(Robot.cannele)
print(Robot.cheese_bread)

#调用类的方法	
Robot.welcome_supermarket()
Robot.pick_one()
Robot.payment()

在这里插入图片描述

方法二：注意 如果类中的函数不需要类中的变量时，就不要用@classmethod、cls、cls. 三处格式，否则也会报错。

class ClassA():
	var1 = 100
	var2 = 200
	
	@classmethod  #类方法，@classmethod声明了func1是类方法，这样子才允许func1使用类属性中的数据。
	def func1(cls):  # class的缩写，如果func1想使用类的属性，就要写上cls作为func1的第一个参数，也就是把这个类作为参数传给自己，这样就能被允许使用类中的数据。
		print(cls.var1)
		print(cls.var2)

ClassA.func1()

在这里插入图片描述

类方法传参数

方法一：将参数放在类的内部，然后类的方法从内部获取参数。

class ClassA():
	num = 1

	@classmethod
	def add_100(cls):
		sum = cls.num + 100
		print("计算结果如下:")
		print(sum)
		
ClassA.add_100()

在这里插入图片描述

方法二：直接 参数=xx。

class ClassA():
	def add_100(num):
		sum = num + 100
		print("计算结果如下:")
		print(sum)

num = 1
ClassA.add_100(num)

在这里插入图片描述

方法三：同时使用内部和外部的参数。

举例1：

class ClassA():
	num = 1
	
	@classmethod
	def add_100(cls,para):
		sum = cls.num + 100 + para
		print("计算结果如下:")
		print(sum)

para= 10
ClassA.add_100(para)

在这里插入图片描述

举例2：当类方法要使用多个外部参数，我们要预设几个参数位置。

class ClassA():
	num = 1
	
	@classmethod
	def add_100(cls,para1,para2,para3):
		sum = cls.num + 100 + para1 + para2 + para3
		print("计算结果如下:")
		print(sum)

para1 = 10
para2 = 20
para3 = 30
ClassA.add_100(para1,para2,para3)

在这里插入图片描述

类属性：增加/修改类属性

在这里插入图片描述

方法一：用 类.变量=xx 直接增加、修改类属性。

class ClassA():

	@classmethod
	def add_class_var(cls):
		print("打印新增的类的属性：" + str(cls.var1))
	
ClassA.var1=100
ClassA.add_class_var()

在这里插入图片描述

方法二：用类方法去增加、修改。

class ClassA():

	@classmethod
	def add_class_var(cls):
		cls.var1 = "hello"
		
ClassA.add_class_var()
print("打印新增的类的属性：" + ClassA.var1)

在这里插入图片描述

类的实例化

实例化基本格式：实例名=类() 为类创建一个实例，然后再使用 实例名.函数() 调用对应的方法。
注意：与直接调用类格式不一样。

class ClassA():
	var1 = 'abc'

	def func(self): #self代表“实例”的意思，编码规范，不是强求。
		print('已经完成了实例化。')
		print('类属性的值是：'+ self.var1)

a=ClassA()
a.func()

在这里插入图片描述

class Robot():
	macaron = 20
	cannele = 15
	cheese_bread = 23
	
	#以上为类的属性
	def pick_one(self):
		print("我们热销有三款面包哦，欢迎选购~")
		print('马卡龙：' + str(self.macaron))
		print('可丽露：' + str(self.cannele))
		print('芝士面包：' + str(self.cheese_bread))

a=Robot()
a.pick_one()

在这里插入图片描述

注意：
1、实例化后，只要你类中使用了def语句那必须在其后的括号里把第一个位置留给self。
2、当支持实例化时，就不能再直接使用类方法。

实例方法与类方法

重写类方法：类.原始函数=新函数
第一步：在类的外部写一个函数
第二步：把这个新函数的函数赋值给类的原始函数。

class ClassA():
	def func1(self):
		print('我是原始函数')

def func2(self):
	print('我是重写后的新函数')

a = ClassA()
a.func1()

ClassA.func1=func2 
a.func1()

在这里插入图片描述

class Lucky():
	
	def lucky_double(self):
		print('好的，我把你的幸运数字记住了哦，并翻倍66倍还给你' + str(self.lucky_number*66))

def lucky_new_double(self):
	print('好的，我把你的幸运数字记住了哦，并翻倍88倍还给你' + str(self.lucky_number*88))

Lucky.lucky_number = int(input('请输入你的幸运数字'))
a = Lucky()
a.lucky_double()

Lucky.lucky_double=lucky_new_double
a.lucky_double()

在这里插入图片描述

a.lucky_double=lucky_new_double # 尝试重写实例方法，将会报错
a.lucky_double()

在这里插入图片描述

注意：重写类方法，让实例方法发生变化，但我们不能重写实例方法。

实例属性和类属性

实例属性和类属性：实例后获得类属性，所以实例属性和类属性完全相等。

class ClassA():
	var1 = 100

a = ClassA() #实例化，得到实例对象a
b = ClassA() #实例化，得到实例对象b

print(a.var1)
print(b.var1)

在这里插入图片描述

举例：修改实例属性

class ClassA():
	var1=100

a=ClassA()
b=ClassA()

print('原始属性值')
print(a.var1)
print(b.var1)

ClassA.var1='abc' # 修改类属性
print('修改后属性值')
print(a.var1) # 实例属性同步变化
print(b.var1)

在这里插入图片描述

初始化函数

初始化函数作用：当你创建一个实例的时候，这个函数就会被调用，初始化当前对象的相关属性，无返回值。上面的代码在执行的实例=类()时，就自动调用__init__(self)函数。

class ClassA():
	def __init__(self):
		print('实例化成功!')
		
a = ClassA() #创建对象,调用__init__()初始属性。		

class ClassA():
	def __init__(self,para1,para2):
		self.var1 = para1  #实例属性
		self.var2 = para2

	def print_var(self):
		print('变量1的值是：' + str(self.var1))
		print('变量2的值是：' + str(self.var2))

class ClassB(ClassA):
	def sum_var(self):
		var_sum = str(self.var1 + self.var2)
		print('所有变量的和是：' + var_sum)
		
b = ClassB(100,200)	
b.print_var()
b.sum_var()

在这里插入图片描述

在一个A类中调用B类，自动调用B类下面的 init(self) 函数。

class A():
    def func_A(self,name1='lily',name2='Jack'):
        names = B(name1,name2)
        return names
        
class B():
    def __init__(self,para1,para2):
        self.var1 = para1
        self.var2 = para2  
        print(self.var1)
        print(self.var2)
    def func_B(self,para3,para4):
        print("在类A中直接调用B类，只会运行__init__初始函数下面的代码，不影响A类中其他函数。")

a = A()
result=a.func_A()

在这里插入图片描述

另一种写法：

class A():
    def func_A(self,name1='lily',name2='Jack'):
        names = B(name1,name2)
        return names
        
class B():
    def __init__(self,para1,para2):
        self.var1 = para1
        self.var2 = para2

    def func_B(self):
        return self.var1
      
    def func_C(self):
        return self.var2
        
a=A()
result=a.func_A()
result.func_B()
result.func_C()

在这里插入图片描述

类的继承

如果新写的类，有许多的代码和旧类相同，又有一部分不同的话 ，可以用继承的方式避免重复写代码。

在python里，我们统一把旧的类称为父类，新写的类称为子类，子类可以在父类基础上改造类方法，所以我们可以说子类继承了父类。

class ClassA():
	def __init__(self,para1,para2):
		self.var1 = para1
		self.var2 = para2

	def print_var(self):
		print('变量1的值是：' + str(self.var1))
		print('变量2的值是：' + str(self.var2))

class ClassB(ClassA):
	def sum_var(self):
		var_sum = str(self.var1 + self.var2)
		print('所有变量的和是：' + var_sum)
		
b=ClassB(100,200)	
b.print_var()
b.sum_var()

在这里插入图片描述

类的重写: str()方法

作用：用于返回一个“对象的描述”，对于内置函数str()经常用于print()方法查看对象的信息。

class A():
	def __init__(self,name,age):
		self.name=name
		self.__age=age
	
p=A('lily',18)
p

# 输出：
# <__main__.A at 0x2b2f3c81640>

重写__str__()方法

class A():
	def __init__(self,name,age):
		self.name=name
		self.__age=age

	def __str__(self):
		'''将对象转化成一个字符串'''
		return  "名字是：{0},年龄是{1}".format(self.name,self.__age)
p=A('lily',18)
print(p)
# 输出：
# 名字是：lily,年龄是18

@property

@property作用：python的一种装饰器，用来修饰方法的。

  • 修饰方法，会将方法转换为相同名称的只读属性。
class A():
	@property
	def funcA_with_property(self):
		return 14
	def funcA_without_property(self):
		return 13
a=A()
a.funcA_with_property # 加了@property后，可以用调用属性的形式来调用方法,后面不需要加（）。
# 输出：
# 14
a.funcA_without_property()   #没有加@property , 必须使用正常的调用方法的形式，即在后面加()
# 输出：
# 13

注意： 使用@property进行修饰后，又在调用的时候，方法后面添加了()，那么就会显示错误的信息：TypeError: ‘int’ object is not callable，原因是使用@property后，方法变成了一个属性，如果后面加入()，就是当作函数来调用，而它不是callable（可调用）的。

class A():
	@property
	def funcA_with_property(self):
		return 14
		
a=A()
a.funcA_with_property()

在这里插入图片描述

  • 与所定义的属性配合使用，可以防止属性被修改。
class A():
	def __init__(self):
		self.name1='lily'
		self.name2='Jack'
		
	@property
	def print_name1(self):
		return self.name1

	@property
	def print_name2(self):
		return self.name2
		
a=A()
a.print_name1
# 输出：
# 'lily'
a.print_name2
# 输出：
# 'Jack'

下面的方法可以参考的使用场景：在A类中调用B类，但是与B类中需要输出的属性配合使用，直接输出某些属性值，如下例，直接输出属性var1，var2。

class A():
    def func_A(self,name1='lily',name2='Jack'):
        names = B(name1,name2)
        return names
        
class B():
    def __init__(self,para1,para2):
        self.var1 = para1
        self.var2 = para2

    @property
    def func_B(self):
        return self.var1
      
    @property
    def func_C(self):
        return self.var2
        
a=A()
result=a.func_A() #result其实是属于B类，打印result出来可以看到"<__main__.B at 0x2b2f3c49910>"
result.func_B
# 输出：
# 'lily'  一直没理解这种方法为什么可以调用出
result.func_C
# 输出：
# 'Jack'

示例：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

参考文章：
https://zhuanlan.zhihu.com/p/64487092
上面的例子参考《四、实际应用-实例二-收取邮件的代码封装》

私有属性、私有方法

私有属性与私有方法：通常约定两个下划线开头的属性(方法)是私有的，其他为公共的。

  • 类内部可以访问，类外部不可以访问。
  • 类外部可以通过“_类名__私有属性(方法)名”访问私有属性(方法)。
class A():
	def __init__(self,name,age):
		self.name=name #实例属性
		self.__age=age #私有实例属性
	
	def funcA(self):
		print("实例属性：",self.name)
		print("私有实例属性：",self.__age)
	
	def __funB(self):
		print("私有方法")

p1=A("lily","18")
print(p1.name) 
p1.funcA()
# 输出：
# lily
# 实例属性： lily
# 私有实例属性： 18


print(p1.__age) #直接访问私有属性，报错
p1.__funB() #直接访问私有方法，报错

print(dir(p1)) # ['_A__age', '_A__funB', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'funcA', 'name']

从上面内建函数dir()可以看到其中一些原由，“__age”属性在运行时，属性名被改为了“_A__age”，所以通过“_类名__私有属性(方法)名”访问私有属性，如下面：

print(p1._A__age) #通过这种方式可以直接访问到私有属性。通过dir 可以查到属性：_A__age

另一个通过“_类名__私有属性(方法)名”访问私有属性示例：

class A(object):
    def __init__(self):
        self.__private()
        self.public()
    
    def __private(self):
        print('A.__private()')
    
    def public(self):
        print('A.public()')

class B(A):
    def __private(self):
        print('B.__private()')
    
    def public(self):
        print('B.public()')
    
b = B()
# 输出：
# A.__private()
# B.public()

dir(A)
# 输出：
# _A__private
# __init__
# public

我们可以看到A类中的__private消失了，变成_A__private，因此实际A类变成如下：

class A(object):
    def __init__(self):
        self.__private() # 变成 self._A__private
        self.public()
    
    def __private(self): # 变成 _A__private
        print('A.__private()')
    
    def public(self):
        print('A.public()')


class B(A):
	```
	#继承A类中初始化函数，因此实际继承的如下，所以，输出A.__private()
    #def __init__(self):
    #    self._A__private
    #    self.public()
	```
    def __private(self):
        print('B.__private()')
    
    def public(self):
        print('B.public()')

参考文章：
https://blog.csdn.net/u013250861/article/details/109230731
https://www.cnblogs.com/fengff/p/9290910.html

sodaloveer
关注
  • 17
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python类的继承实例详解
01-20
python 类的继承 对于许多文章讲解python类的继承，大多数都是说一些什么oop,多态等概念，我认为这样可能对有一定基础的开发者帮助不是那么大，不如直接用在各种情况下所写的代码，来展示对于某一种代码情况，代码运行会有什么效果。这样可能对开发者的帮助更大。不说废话，直接上代码。 这里不区分经典类和新式类，下面分析的对新式类和经典类都适用 对于类中的__init__函数，只是一个初始化是调用的一个函数（ps:初始化和创建实例并不是一个过程，实例的创建是通过一个create函数来完成的），如果在子类中没有显示的声明__init__函数，则子类就会调用父类的__init__函数，但是不会再
python类继承与子类实例初始化用法分析
01-21
本文实例讲述了python类继承与子类实例初始化用法。分享给大家供大家参考。具体分析如下： [ 先贴参考书籍原文（中文英文对照）] __init__方法介绍: If a base class has an __init__() method the derived class’s __init__() method must explicitly call it to ensure proper initialization of the base class part of the instance; for example: “BaseClass.__init__(self, [args…
Python实例化方法、类方法、静态方法
qq_55621259的博客
08-13 1929
实例化方法便是我们最常见的第一个参数为self类方法是在方法前加一个@classmethod装饰器静态方法是在方法前加一个@staticmethod装饰器（PS：实例对象的权限最大。）
python入门学习之类属性、实例属性、类方法、实例方法
familyyan的博客
12-24 2593
一、类属性 1、定义 直接在类中定义的属性是类属性 2、访问 类属性可以通过类或类的实例访问到 3、修改 类属性只能通过类对象来修改，无法通过实例对象修改 eg： class A: # 定义类属性 count = 10 # 通过类来访问 print(A.count) # 10 a = A() # 通过类实例来访问 print(a.count) # 10 # 通过类对象来修改 A.count = 20 print('类对象修改之后的值：', A.count) # 20
Python类属性和方法的调用、实例对象、类继承等（实例讲解）
WANGJUNAIJIAO的博客
12-31 3247
Python使用class关键字来定义类，class关键字之后是一个空格，接下来是类的名字，如果派生自其它基类的话则需要把所有父类放到一对圆括号中并使用逗号分隔，然后是一个冒号，最后换行并定义类的内部实现。类名的首字母一般要大写；语句1...语句n需要注意的几点：① 类定义与函数定义(def语句)一样：只有在被执行才会起作用，在定义阶段只是语法检查。② 类是属性和方法的组合，所以语句1可能是内部变量(数据、属性)的定义和赋值语句，也可能是内部方法(函数)的定义语句。
python中类的创建和实例化
weixin_30735391的博客
07-27 1815
python中同样使用关键字class创建一个类，类名称第一个字母大写,可以带括号也可以不带括号； python中实例化类不需要使用关键字new（也没有这个关键字），类的实例化类似函数调用方式； # coding: utf-8 # 创建一个类，类名称第一个字母大写,可以带括号也可以不带括号 class Student(): student_cou...
python：类实例化
OceanStar的博客
11-16 4294
类对象就像是一个用来创建对象的工厂。举个例子。
python 类的实例化
JavaBigData的博客
09-24 241
给定一个经过编码的字符串，返回它解码后的字符串。 编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。 你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。 此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。 示例 1： 输入：s = "3[a]2[bc]" 输出："aaabcbc" 来源：力扣
Python 类的实 例化
lxgwm2008的专栏
07-05 8927
在 Python 中对类进行实例化很直接。要对类进行实例化，只要调用类 (就好像它是一个函数)，传入定义在 __init__ 方法中的参数。返回值将是新创建的对象。 1. 创建  Fi le Info  实例 >>> import fileinfo >>> f = fileinfo.FileInfo("/music/_singles/kairo.mp3") (1) >>> f.__
python类的实例化
weixin_42600128的博客
01-13 894
在 Python 中，类的实例化是通过在类名后面加上圆括号的方式来创建一个类的实例。例如，如果有一个名为 "MyClass" 的类，可以通过如下方式创建一个该类的实例： my_object = MyClass() ...
Python 类属性与实例属性，类对象与实例对象用法分析
01-20
本文实例讲述了Python 类属性与实例属性，类对象与实例对象用法。分享给大家供大家参考，具体如下： demo.py（类属性，所有实例对象共用类属性）： # 定义工具类 继承object是为了兼容python2.x class Tool...
基于python3 类的属性、方法、封装、继承实例讲解
12-25
Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。 对象可以包含任意数量和类型的数据。 python类与c++类相似，提供了...
Python实现动态添加类的属性或成员函数的解决方法
01-21
这里做的比较简单，只是声明一个类，类初始化的时候读取配置文件，根据配置列表加载特定目录下的模块下的函数，函数和模块同名，将此函数动态加载为类的成员函数。 代码如下所示： class WinBAS(Bas): def __init_...
python面向对象之类属性和类方法案例分析
12-23
本文实例讲述了python面向对象之类属性和类方法。分享给大家供大家参考，具体如下： 目标 类的结构 类属性和实例属性 类方法和静态方法 01. 类的结构 1.1 术语 —— 实例 使用面相对象开发，第 1 步 是设计 类 使用 ...
[python3] 读取一个正在更新的日志文件
最新发布
言之。
04-24 1169
等同于–follow=name --retry，根据文件名进行追踪，并保持重试，即该文件被删除或改名后，如果再次创建相同的文件名，会继续追踪。这两种方法都会持续监听日志文件的变化，并实时读取新增的日志内容。你可以根据实际需求选择其中一种方法。要读取一个正在更新的日志文件（即实时写入的日志文件），你可以使用 Python 的。的技巧来实现实时读取。函数打开文件，并使用。
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 1182
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
Pandas 2.2 中文官方教程和指南（二十二）
龙哥盟
04-24 1165
原文：pandas.pydata.org/docs/ 时间增量 原文：pandas.pydata.org/docs/user_guide/timedeltas.html 时间增量是时间之间的差异，以不同的单位表示，例如天、小时、分钟、秒。它们可以是正数也可以是负数。 Timedelta是datetime.timedelta的子类，并且行为类似，但也允许与np.timedelta64类型兼容，以及一系列自定义表示、解析和属性。 解析 您可以通过各种参数构造一个Timedelta标量，包括ISO 860
Pandas 2.2 中文官方教程和指南（十五）
龙哥盟
04-24 768
原文：pandas.pydata.org/docs/ 处理文本数据 原文：pandas.pydata.org/docs/user_guide/text.html 文本数据类型 在 pandas 中有两种存储文本数据的方式： object -dtype NumPy 数组。 StringDtype 扩展类型。 我们建议使用StringDtype来存储文本数据。 在 pandas 1.0 之前，object dtype 是唯一的选项。这在很多方面都是不幸的： 你可能会在object dty
python使用类函数的返回值初始化类属性
04-26
可以在类定义中使用类函数的返回值来初始化类属性，这可以通过在类定义中直接调用类函数并将其返回值分配给相应的类属性来实现。例如： ``` class MyClass: @classmethod def class_func(cls): return "class_attribute_value" class_attribute = class_func() ``` 在这个例子中，`class_func()` 是一个类函数，它返回一个字符串 "class_attribute_value"。`class_attribute` 是一个类属性，它在类定义中使用 `class_func()` 的返回值进行了初始化。请注意，`class_func()` 用 `@classmethod` 装饰器进行了修饰，这使得它可以在没有实例的情况下直接从类中调用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值