类中的成员

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

1、字段

字段：普通字段、静态字段

class Mycalss:
    str = '这是静态字段'
    def __init__(self,str1):
        self.str1 = str1 # 普通字段
# 实例化对象
a = Mycalss('普通字段')
print(a.str1) #访问静态字段
print(Mycalss.str)

 执行结果

普通字段
这是静态字段

　　普通字段：属于对象，由对象来访问，在内存中每个对象都要保存一份

　　静态字段：属于类，由类直接访问，在内存中只保存一份

2、方法

方法：普通方法、静态方法、类方法

class Myclass(object):
    doc = '静态字段'
    def __init__(self, argu1, argu2 ,):
        self.argu1 = argu1
        self.argu2 = argu2
    def func1(self):  #普通方法 至少一个self
        print('普通方法')
    @staticmethod # 静态方法，任意参数
    def func2():
        print('静态方法')
    @classmethod  #类方法，只能一个cls
    def func3(cls):
        print('类方法'，cls)#执行时它会把当前的类当成参数传进去
14 # 创建对象 
c = Myclass(123, 'hello world')16 c.func1() #访问普通方法

执行结果：

普通方法
静态方法
类方法 <class '__main__.Myclass'> #执行时它会把当前的类当成参数传进去

普通方法：先创建一个对象，在用对象去调用这个方法

静态方法：直接用类调用，可以有任意参数(静态方法可以让类直接调用，省去了普通方法创建对象的步骤)

类方法：直接用类调用，只能一个cls参数

3、属性

属性定义两种方法：装饰器定义、静态字段定义

（1）装饰器定义属性

class Myclass(object):
    doc = 'This is a test'
    def __init__(self,argu):
        self.argu = argu
    def func1(self):#方法
        print('方法')
    @property
    def func2(self):  #属性，加上@property装饰器，仅有一个self参数
        print('属性')
#创建对象
a = Myclass(2222)
a.func1()  #调用方法
a.func2 # 调用属性
 执行结果>>>
方法
属性

在方法上加上@property装饰器就叫属性，属性和方法的区别就是调用时不用加括号

在新式类中，除了@property，还有另外两种装饰器

class School(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    @property
    def classroom(self):    # 属性，加上@property装饰器，仅有一个self参数
        print(self.name, self.age)
    @classroom.setter
    def classroom(self, age):
        self.age = age    # 把age修改为传入的参数
        print("修改", self.name, self.age)
    @classroom.deleter
    def classroom(self):
        del self.age        # 删除age
        print("删除", self.name, self.age)

# 创建对象a1
a1 = School("张三", 18)
a1.classroom    #1.执行后会自动调用@property方法
a1.classroom = 20     #2.执行后会自动调用@classroom.setter的方法，并将20传给age参数
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）静态字段定义的属性

class School(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def classroom(self):
        print(self.name,self.age)

    def classroom_update(self,age):
        self.age=age    #把age修改为传入的参数
        print("修改",self.name,self.age)

    def classroom_del(self):
        del self.age        #删除age
        print("删除",self.name,self.age)

    obj=property(classroom,classroom_update,classroom_del)  #静态字段方式定义属性

#创建对象a1
a1=School("张三",18)
a1.obj  #1.执行后会自动调用classroom方法
a1.obj=20     #2.执行后会自动调用classroom_update的方法，并将20传给age参数
del a1.obj    #3.执行后会自动调用classroom_delr的方法

4、公有成员和私有成员

在类中的每一个成员都有两种形式：公有、私有

公有：都可以访问　　　　　　私有：只有在类的内部可以访问

举例——字段：

class School(object):
    deg="狗" #公有静态字段
    __cat="猫"   #私有静态字段
    def __init__(self,name,age):
        self.name=name  #公有普通字段
        self.__age=age  #私有普通字段

    def dormitory(self):
        print(self.__age)

    def cat(self):
        print(School.__cat)

#创建对象a1
a1=School("张三",18)
#访问普通字段
print(a1.name)  #输出：张三
print(a1.age)   #报错，提示没有age，因为age是私有字段，只能间接内部访问
a1.dormitory()  #只能通过类内部访问私有字段
#访问静态字段
print(School.deg)   #输出：狗
print(School.__cat) #报错
a1.cat()        #输出：猫   可以间接通过内部的cat方法反问私有静态字段

方法

class School(object):

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

    def cat(self):  # 公有方法
        print("cat")

    def __dog(self):   # 私有方法
        print("dog")

    def doo(self):  #内部访问私有方法
        a1.__dog()
#创建对象a1
a1 = School("张三",18)
a1.cat()    #输出：cat
# a1.__dog()    #报错
a1.doo()    # 输出：dog  间接通过doo方法反问私有方法__dog
20 a1._School__dog() # 强制访问

如果想要强制访问私有字段，可以通过(对象._类名__私有字段名)访问，不建议强制访问私有成员。

5、类的特殊成员

(1)__doc__

class Myclass(object):
    '''类的描述信息'''
    def __init__(self, argu):
        self.argu = argu
5
print(Myclass.__doc__) #输出：类的描述信息

(2)__init__

　　在上面已经说过，在创建对象是自动执行

(3)__del__

当对象在内存中被释放时，自动触发执行

class Myclass(object):
    '''类的描述信息'''
    def __init__(self, argu):
        self.argu = argu
    def __del__(self):
        print('对象内存已被释放')

a = Myclass('hello world')
print(a.argu)

执行结果：

hello world
对象内存已被释放

(4)__call__

在创建的对象后面加括号执行时，会自动执行类里的__call__方法

class Myclass(object):

    def __call__(self, *args, **kwargs):
        print("触发__call__方法")

a1=Myclass()
a1()    #输出：触发__call__方法
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__

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

    def __str__(self):
        return("print对象时的返回值")
a1=School("张三",18)
print(a1)   #输出：print对象时的返回值