类中的成员：字段、方法、属性
1、字段
字段：普通字段、静态字段
1 class Mycalss: 2 str = ‘这是静态字段‘ 3 def __init__(self,str1): 4 self.str1 = str1 # 普通字段 5 # 实例化对象 6 a = Mycalss(‘普通字段‘) 7 print(a.str1) #访问静态字段 8 print(Mycalss.str)
执行结果
普通字段 这是静态字段
普通字段：属于对象，由对象来访问，在内存中每个对象都要保存一份
静态字段：属于类，由类直接访问，在内存中只保存一份
2、方法
方法：普通方法、静态方法、类方法
1 class Myclass(object): 2 doc = ‘静态字段‘ 3 def __init__(self, argu1, argu2 ,): 4 self.argu1 = argu1 5 self.argu2 = argu2 6 def func1(self): #普通方法 至少一个self 7 print(‘普通方法‘) 8 @staticmethod # 静态方法，任意参数 9 def func2(): 10 print(‘静态方法‘) 11 @classmethod #类方法，只能一个cls 12 def func3(cls): 13 print(‘类方法‘，cls)#执行时它会把当前的类当成参数传进去14 # 创建对象 15 c = Myclass(123, ‘hello world‘)16 c.func1() #访问普通方法
执行结果：
普通方法 静态方法 类方法 <class ‘__main__.Myclass‘> #执行时它会把当前的类当成参数传进去
普通方法：先创建一个对象，在用对象去调用这个方法
静态方法：直接用类调用，可以有任意参数(静态方法可以让类直接调用，省去了普通方法创建对象的步骤)
类方法：直接用类调用，只能一个cls参数
3、属性
属性定义两种方法：装饰器定义、静态字段定义
（1）装饰器定义属性
1 class Myclass(object): 2 doc = ‘This is a test‘ 3 def __init__(self,argu): 4 self.argu = argu 5 def func1(self):#方法 6 print(‘方法‘) 7 @property 8 def func2(self): #属性，加上@property装饰器，仅有一个self参数 9 print(‘属性‘) 10 #创建对象 11 a = Myclass(2222) 12 a.func1() #调用方法 13 a.func2 # 调用属性 执行结果>>> 15 方法 16 属性
在方法上加上@property装饰器就叫属性，属性和方法的区别就是调用时不用加括号
在新式类中，除了@property，还有另外两种装饰器
1 class School(object):
2 def __init__(self, name, age):
3 self.name = name
4 self.age = age
5 @property
6 def classroom(self): # 属性，加上@property装饰器，仅有一个self参数
7 print(self.name, self.age)
8 @classroom.setter
9 def classroom(self, age):
10 self.age = age # 把age修改为传入的参数
11 print("修改", self.name, self.age)
12 @classroom.deleter
13 def classroom(self):
14 del self.age # 删除age
15 print("删除", self.name, self.age)
16
17 # 创建对象a1
18 a1 = School("张三", 18)
19 a1.classroom #1.执行后会自动调用@property方法
20 a1.classroom = 20 #2.执行后会自动调用@classroom.setter的方法，并将20传给age参数
21 del a1.classroom #3.执行后会自动调用@classroom.deleter的方法
执行结果
张三 18
Traceback (most recent call last):
修改 张三 20
File "E:/Python-Advanced/面向对象/类中的成员/属性/装饰器1.py", line 21, in <module>
del a1.classroom #3.执行后会自动调用@classroom.deleter的方法
File "E:/Python-Advanced/面向对象/类中的成员/属性/装饰器1.py", line 15, in classroom
print("删除", self.name, self.age)
AttributeError: ‘School‘ object has no attribute ‘age‘
（2）静态字段定义的属性
1 class School(object):
2 def __init__(self,name,age):
3 self.name=name
4 self.age=age
5
6 def classroom(self):
7 print(self.name,self.age)
8
9 def classroom_update(self,age):
10 self.age=age #把age修改为传入的参数
11 print("修改",self.name,self.age)
12
13 def classroom_del(self):
14 del self.age #删除age
15 print("删除",self.name,self.age)
16
17 obj=property(classroom,classroom_update,classroom_del) #静态字段方式定义属性
18
19 #创建对象a1
20 a1=School("张三",18)
21 a1.obj #1.执行后会自动调用classroom方法
22 a1.obj=20 #2.执行后会自动调用classroom_update的方法，并将20传给age参数
23 del a1.obj #3.执行后会自动调用classroom_delr的方法
4、公有成员和私有成员
在类中的每一个成员都有两种形式：公有、私有
公有：都可以访问 私有：只有在类的内部可以访问
举例——字段：
1 class School(object):
2 deg="狗" #公有静态字段
3 __cat="猫" #私有静态字段
4 def __init__(self,name,age):
5 self.name=name #公有普通字段
6 self.__age=age #私有普通字段
7
8 def dormitory(self):
9 print(self.__age)
10
11 def cat(self):
12 print(School.__cat)
13
14 #创建对象a1
15 a1=School("张三",18)
16 #访问普通字段
17 print(a1.name) #输出：张三
18 print(a1.age) #报错，提示没有age，因为age是私有字段，只能间接内部访问
19 a1.dormitory() #只能通过类内部访问私有字段
20 #访问静态字段
21 print(School.deg) #输出：狗
22 print(School.__cat) #报错
23 a1.cat() #输出：猫 可以间接通过内部的cat方法反问私有静态字段
方法
1 class School(object):
2
3 def __init__(self, name, age):
4 self.name = name
5 self.__age = age
6
7 def cat(self): # 公有方法
8 print("cat")
9
10 def __dog(self): # 私有方法
11 print("dog")
12
13 def doo(self): #内部访问私有方法
14 a1.__dog()
15 #创建对象a1
16 a1 = School("张三",18)
17 a1.cat() #输出：cat
18 # a1.__dog() #报错
19 a1.doo() # 输出：dog 间接通过doo方法反问私有方法__dog20 a1._School__dog() # 强制访问
如果想要强制访问私有字段，可以通过(对象._类名__私有字段名)访问，不建议强制访问私有成员。
5、类的特殊成员
(1)__doc__
1 class Myclass(object): 2 ‘‘‘类的描述信息‘‘‘ 3 def __init__(self, argu): 4 self.argu = argu 56 print(Myclass.__doc__) #输出：类的描述信息
(2)__init__
在上面已经说过，在创建对象是自动执行
(3)__del__
当对象在内存中被释放时，自动触发执行
1 class Myclass(object): 2 ‘‘‘类的描述信息‘‘‘ 3 def __init__(self, argu): 4 self.argu = argu 5 def __del__(self): 6 print(‘对象内存已被释放‘) 7 8 a = Myclass(‘hello world‘) 9 print(a.argu)
执行结果：
hello world 对象内存已被释放
(4)__call__
在创建的对象后面加括号执行时，会自动执行类里的__call__方法
1 class Myclass(object):
2
3 def __call__(self, *args, **kwargs):
4 print("触发__call__方法")
5
6 a1=Myclass()
7 a1() #输出：触发__call__方法
8 Myclass()() #输出：触发__call__方法
(5)__dict__
获取类或对象的所有成员
class School(object):
"""类的描述信息"""
cat="猫"
def __init__(self,name,age):
self.name=name
self.__age=age
def dog(self):
print("dog")
print(School.__dict__) #获取类中的成员
a1=School("张三",18)
print(a1.__dict__) #获取对象中的成员
‘‘‘
输出：
{‘cat‘: ‘猫‘, ‘__init__‘: <function School.__init__ at 0x000000000226C950>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘School‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘School‘ objects>, ‘__module__‘: ‘__main__‘, ‘dog‘: <function School.dog at 0x000000000226CAE8>, ‘__doc__‘: ‘类的描述信息‘}
{‘name‘: ‘张三‘, ‘_School__age‘: 18}
‘‘‘
(6)__str__
1 class School(object):
2 def __init__(self,name,age):
3 self.name=name
4 self.__age=age
5
6 def __str__(self):
7 return("print对象时的返回值")
8 a1=School("张三",18)
9 print(a1) #输出：print对象时的返回值
原文地址：https://www.cnblogs.com/weststar/p/11420865.html
时间： 2024-10-09 11:11:08