标签：dict cat stat tee 步骤 区别 成员 als 私有字段
类中的成员：字段、方法、属性
字段：普通字段、静态字段
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)
执行结果
普通字段
这是静态字段
普通字段：属于对象，由对象来访问，在内存中每个对象都要保存一份
静态字段：属于类，由类直接访问，在内存中只保存一份
方法：普通方法、静态方法、类方法
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参数
属性定义两种方法：装饰器定义、静态字段定义
（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的方法
在类中的每一个成员都有两种形式：公有、私有
公有：都可以访问 私有：只有在类的内部可以访问
举例——字段：
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方法反问私有方法__dog
20 a1._School__dog() # 强制访问
如果想要强制访问私有字段，可以通过(对象._类名__私有字段名)访问，不建议强制访问私有成员。
5、类的特殊成员
(1)__doc__
1 class Myclass(object): 2 ‘‘‘类的描述信息‘‘‘ 3 def __init__(self, argu): 4 self.argu = argu 5
6 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对象时的返回值
标签：dict cat stat tee 步骤 区别 成员 als 私有字段
原文地址：https://www.cnblogs.com/weststar/p/11420865.html
