面向对象静态方法

proprety 函数，

对方法进行伪装，将方法伪装为一个属性，对象调用方法的时候，就相当于对象调用一个属性，就是可以少写一个括号，但是调用的还是方法

from  math import pi


class Circle:
    def __init__(self, r):
        self.r = r

    @property  # 将方法伪装为一个属性，就是调用的时候少写一个括号.如果使用了这个property那么方法里面不能穿参数
    def perimeter(self):
        return 2 * pi * self.r

    @property
    def area(self):
        return self.r ** 2 * pi


a = Circle(5)
print(a.area)  # 调用area方法
print(a.perimeter)  # 调用perimeter方法

proprety 函数，外部调用私有属性

class Person:
    def __init__(self, name, sex):
        self.__name = name
        self.sex = sex

    @property  # 将方法伪装类的一个属性。可以在外部调用
    def name(self):
        return self.__name

    @name.deleter  # 调用这个del的时候，就找到@name.deleter这个函数里面的操作，删除这个属性，为了就是对象可以删除属性。
    # 如果没有加这个，对象是不能删除属性的，因为属性在内部，对象在外部
    def name(self):
        del self.__name


a = Person('小明', '男')
print(a.name)  外部对象调用私有属性
del a.name  # 找到@name.deleter 下的方法，执行操作，删除了属性，使用对象删除属性
print(a.name)

classmethod 类方法函数

class Goods:
    __duncon = 0.8

    def __init__(self, name, pirc):
        self.__name = name
        self.pirc = pirc

    @property
    def nane(self, new_name):
        self.__name = new_name

    def fun(self):
        return self.pirc * Goods.__duncon

    @classmethod  # 变方法变为类的方法，当方法操作只涉及静态属性的时候，就应该使用classmethod来装饰这个方法
    def get_duncon(self, new_duncon):
        Goods.__duncon = new_duncon


Goods.get_duncon(0.5)
a = Goods('苹果', 8)
print(a.fun())

staticmenthod  静态方法，使用一般是，一个函数如果 和类没有关系，和对象也没有关系的时候，就是要静态方法

class Logoin:
    def __init__(self, aname, password):
        self.name = aname
        self.password = password

    def fun(self): pass

    @staticmethod
    def fun1():  我这个类里面的和类没有关系，和对象也没有关系，所有使用静态方法
        aname = input('>>')
        password = input('>>>>')
        Logoin(aname,password)

Logoin.fun1()