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

已于 2024-01-31 11:31:15 修改
阅读量4.4k 收藏 66
点赞数 28
分类专栏： 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
关注
专栏目录
Python中的对象实例化过程 用python解密__new__
02-26 1407
在本文中，您将学习： 什么是python中的对象 Python中的对象实例化过程 该__new__方法 该__call__方法 可在python中调用 Python是一种面向对象的编程语言。python中的所有内容都是对象或实例，例如类，函数，整数，浮点数等。因此，每个对象都有一个实例化它的类。我们可以type(obj) function or __class__ property用来检查对象的类型。 >>> type(a) <class 'int'> &g.
Python 面向对象编程：类的创建与初始化、实例属性与方法、类属性与方法
12-21
在Python中，面向对象主要涉及类（Class）的创建、实例化（Instantiation）、属性（Attributes）和方法（Methods）。 1. 类的创建与实例化： 在Python中，类通过`class`关键字定义。类名通常遵循“驼峰式命名”，...
Python中的“实例化对象”：从零开始的探索之旅
最新发布
m0_71948321的博客
09-27 581
在面向对象编程（OOP）中，“实例化对象”是创建具体实例的过程，它是将抽象的概念（如类定义）转化为可以操作的具体实体的关键步骤。通过实例化，我们不仅能够创建出具有特定属性和方法的对象，还能通过这些对象之间的交互来实现复杂的功能。比如，在开发一款游戏时，每个游戏角色都可以看作是一个对象实例，它们有自己的状态（如生命值、攻击力等）和行为（如攻击、移动等）。理解和掌握实例化对象，对于构建可维护性高、扩展性强的软件系统至关重要。
实例化类的五种方法
热门推荐
u012524415的博客
05-15 2万+
1、用new语句创建对象，这是最常见的创建对象的方法。2、使用Class类的newInstance方法3、使用Constructor类的newInstance方法    运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。如：Object obj = Class.forName("java.lang....
python：类实例化
OceanStar的博客
11-16 4721
类对象就像是一个用来创建对象的工厂。举个例子。
Python的类定义，实例化
weixin_42276816的博客
04-21 7377
定义： 必须使用class关键字 类名必须是用大驼峰命名 类定义完成后，就会产生一个类对象，绑定到了标识符ClassName上 class ClassName: 语句块 举例： class MyClass: """A example class""" x = 'abc'#类属性 def foo(self):#类属性foo，也是方法 return 'My Class' print(MyClass.x) print(MyClass.foo) print(MyClass.__doc
python 类的实例化
JavaBigData的博客
09-24 271
给定一个经过编码的字符串，返回它解码后的字符串。 编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。 你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。 此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。 示例 1： 输入：s = "3[a]2[bc]" 输出："aaabcbc" 来源：力扣
python实例化对象点击_python的面向对象-实例（对象）的相关知识、实例化
weixin_39795479的博客
11-29 224
1、对象就是实例，什么是实例类运行的过程就是实例化的过程，实例化产生的结果就是产生了一个实例class的牛逼之处就是不用手动的return，他会加载完函数之后，自动return __init__这个函数里面的字典，字典当中封装了数据属性函数属性就是属于类的2、实例化只要用类名加()的方式运行，（在类中这个运行叫实例化）首先会运行__init__这个函数class Chinese:#定义了Chin...
python类的实例化
weixin_42600128的博客
01-13 977
在 Python 中，类的实例化是通过在类名后面加上圆括号的方式来创建一个类的实例。例如，如果有一个名为 "MyClass" 的类，可以通过如下方式创建一个该类的实例： my_object = MyClass() ...
Python 类属性与实例属性，类对象与实例对象用法分析
01-20
本文实例讲述了Python 类属性与实例属性，类对象与实例对象用法。分享给大家供大家参考，具体如下： demo.py（类属性，所有实例对象共用类属性）： # 定义工具类 继承object是为了兼容python2.x class Tool...
python类继承与子类实例初始化用法分析
01-21
本文实例讲述了python类继承与子类实例初始化用法。分享给大家供大家参考。具体分析如下： [ 先贴参考书籍原文（中文英文对照）] __init__方法介绍: If a base class has an __init__() method the derived class’s...
基于python3 类的属性、方法、封装、继承实例讲解
12-25
Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。 对象可以包含任意数量和类型的数据。 python类与c++类相似，提供了...
python中类的创建和实例化
weixin_30735391的博客
07-27 1846
python中同样使用关键字class创建一个类，类名称第一个字母大写,可以带括号也可以不带括号； python中实例化类不需要使用关键字new（也没有这个关键字），类的实例化类似函数调用方式； # coding: utf-8 # 创建一个类，类名称第一个字母大写,可以带括号也可以不带括号 class Student(): student_cou...
python类实例化_python类和实例化
weixin_39542608的博客
11-21 115
简答介绍类和实例python是面向对象的语言，最主要的就是类和实例，类是抽象的模版创建一个类class Studen(object),class 后接类名，定义的类名大些字母开头，object为类的继承，没有合适的继承类用object类，这是所有类最终会继承的类类的实例化：bart = student()类可以起到模版的作用，所以在创建实例的时候，可以将我们认为必要的属性填写进去，方法__init...
Python - 对象=属性+方法，实例化是从类变成实例对象的过程
current的博客
11-29 940
Python面向对象三大特征：封装、继承、多态。 比较：类，对象，属性，方法，实例化。
python的类的实例化_Python第十六天 类的实例化
weixin_39992665的博客
12-03 163
首先 , 先定义一个 简单的 Person 类1 classPerson:2 head = 13 ear = 245 defeat(self):6 print('吃饭')关于什么是类, 定义类, 类对象,类的实例化,类的初始化 都是初学时非常容易混乱的概念.有时候, 拿我们生活中比较熟悉的概念, 去 和 新的知识点比较, 相对就会容易理解.先设想一下, ...
python基础——对象、类（创建实例化）
kdq18486588014的博客
04-06 2582
文章目录一、编程思想1.面向过程编程2.面向对象编程二、类、对象总结 一、编程思想 1.面向过程编程 面向过程编程实际上就是将解决问题的全部过程分解为很多步，然后一一调用下一步就能解决问题。 。 2.面向对象编程 面向对象编程是将解决问题的每一个环节都变成了一个个个对象，而不是用对象来实现每一个步骤，而是用来描述解决问题的每个环节的。 二、类、对象 类：一些类别、种类的集合，拥有公共特性的对象。 对象：是具有属性和方法的一种事物。对象可以在原基础上属性基础上添加新的属性。 class Play:
Python——类的实例化
wxsy024680的博客
12-02 507
在C1中实例化RefreshLabels，并将对象传递给C2和C3，当在C2中改变对象某一变量时，在C3中也可以得到该变量的最新值。 class RefreshLabels: def __init__(self): self.rect_labels = [] class C1: def __init__(self): self.c2 = C2() self.c3 = C3() self.refreshLabels = RefreshLabels() self.c2.refreshL
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` 装饰器进行了修饰，这使得它可以在没有实例的情况下直接从类中调用。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值