面向对象进阶

绑定方法和非绑定方法

绑定方法

在Python中，绑定方法是指一个对象的方法与该对象本身相关联的特殊类型的函数。当你调用一个对象的方法时，该方法会自动将该对象作为其第一个参数传递给函数，这样它可以访问该对象的属性和其他方法。

绑定方法分为绑定给类的方法和绑定给对象的方法

class Foo(object):

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

    def f1(self):
        print("绑定方法", self.name)

    @classmethod
    def f2(cls):
        print("类方法", cls)


        
# 绑定方法（对象）
obj = Foo("antony",20)
obj.f1() # Foo.f1(obj)


# 类方法
Foo.f2()  # cls就是当前调用这个方法的类。（类）
obj.f2()  # cls就是当前调用这个方法的对象的类。

• 绑定给对象的方法，默认有一个self参数，由对象进行调用（此时self就等于调用方法的这个对象）【对象&类均可调用】

• 绑定给类的方法，默认有一个cls参数，用类或对象都可以调用（此时cls就等于调用方法的这个类）【对象&类均可调用】

非绑定方法（静态方法static）

当你在函数中不需要对象，也不需要类的时候，就把函数设置为静态方法。
静态方法，无默认参数，用类和对象都可以调用。【对象&类均可调用】

lass Student():
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        self.id = self.create_id()

    @staticmethod
    def create_id():
        """当你在函数中不需要对象，也不需要类的时候，就把函数设置为静态方法，类能来调用，对象也能来调用，而且不用传递任何的参数"""
        import uuid
        return uuid.uuid4()
	
    def func(self):
        """如果你在方法中即需要对象，也需要类，就把方法绑定给对象"""
        # self.__class__ # 返回该对象的类
        # self.__class__.__name__ # Student # 类名字的字符串形式的
        # return self.__class__() # Student()

        
stu = Student('ly', 20, 'female')
print(stu.id)
print(stu.create_id())

隐藏属性（成员修饰符）

Python中隐藏属性通过成员修饰符完成，换言之公有和私有属性。

• 公有，在任何地方都可以调用这个成员。
• 私有，只有在类的内部才可以调用（双下划线开头，表示该成员私有，即该成员隐藏）

示例：

class Foo(object):

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

    def get_data(self):
        return self.__name

    def get_age(self):
        return self.age


obj = Foo("antony", 123)


# 公有成员
print(obj.age)
v1 = self.get_age()
print(v1)

# 私有成员
# print(obj.__name) # 错误，由于是私有成员，只能在类中进行使用。
v2 = obj.get_data()
print(v2)

示例二：

class Foo(object):

    def get_age(self):
        print("公有的get_age")

    def __get_data(self):
        print("私有的__get_data方法")

    def proxy(self):
        print("公有的proxy")
        self.__get_data()


obj = Foo()
obj.get_age()

obj.proxy()

理论上私有成员，即被隐藏的成员无法被外部调用后，但是在python中其本质是在定义阶段发生形变：_类名__属性名

如下：

可以对修改类内部的属性的时候，可以在类的内部做更好的限制，然后在类的内部开放一个公共的接口，对外返回内部隐藏的值

通过上述案例大家能不能想到，其实python中的私有并不是真正意义上的私有，只能说是一个大家约定俗成的规定，但是如果不遵守也是可以强行修改。
示例如下：

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


foo1 = Foo("antony", 23)
foo1._Foo__name = "alex"
print(foo1._Foo__name)
print(foo1.__dict__)

# alex
# {'_Foo__name': 'alex', 'age': 23}

property装饰器

一个内置的装饰器，将方法伪装成属性来使用
示例如下：

class Student(object):
    __school = "SH"
    __country = "CHINA"
    
    def __init__(self, name, age, gender):
        self.__name = name
        self.age = age
        self.gender = gender
    
    @property
    def school(self):
        return self.__school
    
    @school.setter
    def school(self, value):
        if type(value) is str:
            Student.__school = value
        else:
            print("修改的数据必须是字符串")
            
    @school.deleter
    def school(self):
        del Student.__school
        

还有一种方法基于定义变量达到伪装属性的效果
示例如下：

class C(object):
    
    def getx(self): 
		pass
    
    def setx(self, value): 
		pass
        
    def delx(self): 
		pass
        
    x = property(getx, setx, delx, "I'm the 'x' property.")
    
obj = C()

obj.x
obj.x = 123
del obj.x

PS:顺序一次是读取，改写，删除和说明