类中的成员

Posted 2022-09-04 weststar

类中的成员：字段、方法、属性

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方法反问私有方法__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对象时的返回值