python-封装&特性&绑定方法

封装

封装就是把属性封装在类里面，从类外部无法访问到被封装的属性

Py中定义类时，特征属性中的变量名采用双下划线开头的方式命名，方法属性里的函数名也采用双下划线开头的方式命名定义

class Student:
    __school = "UCAS"  # 特征属性__school被封装

    def __init__(self, name, age, sex):
        self.__name = name   # 特征属性__name\__age\__sex被封装
        self.__age = age
        self.__sex = sex

    def __learn(self):       # 方法属性__learn()被封装
        print("%s is learning" %self.__name)
     def tell_info(self):
        self.__learn() # 只有在类内部才可以通过__learn的形式访问到

stu1 = Student("Jack", 18,"M")

• 类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果
• 这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的
• 子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

**其实这仅仅这是一种变形操作，类中所有双下划线开头的名称如school都会自动变形成：_类名__school的形式**

这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：类名__属性，然后就可以访问了，如 _Student__school，但这样做是没有意义的

在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形

stu1 = Student("Jack", 18,"M")
print(stu1.__dict__)
stu1.birthday = "2010-09-10"   #对象实例化以后，再对对象属性的赋值操作，不会变形
print(stu1.__dict__)  # 打印结果显示：属性birthday没有发生变形

输出结果：

{'_Student__name': 'Jack', '_Student__age': 18, '_Student__sex': 'M'}
{'_Student__name': 'Jack', '_Student__age': 18, '_Student__sex': 'M', 'birthday': '2010-09-10'}

---

封装

特征属性，即数据：

• 将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。

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

    def tell_info(self):
        print("Name: %s, Age: %s" %(self.__name, self.__age))

    def set_info(self, name, age):
        if not isinstance(name, str):
            print("姓名必须是字符串类型的")

        elif not isinstance(age, int):
            print("年龄必须是数字类型")
        else:
            self.__name = name
            self.__age = age

p1 = Person("Jack", 18)
p1.tell_info()
p1.set_info(123, 18)   # 名字不是字符串，修改不成功
p1.tell_info()
p1.set_info("小明", 18)  # 修改成功
p1.tell_info()

打印结果：

Name: Jack, Age: 18
姓名必须是字符串类型的
Name: Jack, Age: 18
Name: 小明, Age: 18

方法属性，即函数：

• 目的是隔离复杂度

如取款系统，用户无需只要取款的具体流程，只要一个接口就行

class ATM:
    def __card(self):
        print('插卡')
    def __auth(self):
        print('用户认证')
    def __input(self):
        print('输入取款金额')
    def __print_bill(self):
        print('打印账单')
    def __take_money(self):
        print('取款')

    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()

a=ATM()
a.withdraw()

特性 property

用法1：

property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

用途：当需要知道对象的某一个属性，偏偏这个属性不是一成不变的，是根据其他数据计算出来的。这时，应该定义一个函数func()来计算它，然后返回。但是对用户来说，这个东西，是对象的一个属性，按理说不应该通过调用函数，即方法属性来实现，而是应该像普通对象的属性一样，通过直接访问特特属性名直接调用。这就引发的特性的需求来源

对于此需求，在需求函数上加装饰器 @property即可使用特性

# BMI指数,bmi = 体重（kg）÷身高^2（m）
class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property
    def bmi(self):  # bmi的确是一个函数
        return self.weight / (self.height**2)

p1=People('egon',75,1.85)
print(p1.bmi)     # 用户自然而然愿意使用p1.bmi 而不是p1.bmi()

此时，用户通过像普通特征属性一样的访问方式，访问到了方法属性，这就是特性的基本应用。

但是，此时不能通过p1.bmi做赋值删除等其他操作，因为bmi是本身是函数，而不是特征属性，即不是变量

将一个类的函数定义成特性以后，对象再去使用的时候obj.name，根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则

用法二：

public

protected

private

python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现

@property --->特性：行数当特征属性访问

@函数名.setter ---> 修改赋值操作 (f.name = "Jack")

@函数名.deleter ---> 删除操作 （使用del f.name）

class Foo:
    def __init__(self,val):
        self.__NAME=val #将所有的数据属性都隐藏起来

    @property
    def name(self):
        return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)

    @name.setter
    def name(self,value):
        if not isinstance(value,str):  #在设定值之前进行类型检查
            raise TypeError('%s must be str' %value)
        self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME

    @name.deleter
    def name(self):
        raise TypeError('Can not delete')

f=Foo('egon')
print(f.name)
# f.name=10 #抛出异常'TypeError: 10 must be str'
del f.name #抛出异常'TypeError: Can not delete'

用法三： 基本同用法二

class C:
    def __init__(self,size=10):
        self.size = size
    def getsize(self):
        return self.size
    def setsize(self, value):
        self.size = value
    def delsize(self):
        del self.size
    x = property(getsize, setsize, delsize)

c1 = C() # 实例化对象
print(c1.size)  # 输出10
print(c1.x)  # 输出10
c1.x = 20  # 修改size=20
print(c1.x) # 输出20
del c1.x # 删除x属性
print(c1.x) # 报错AttributeError: 'C' object has no attribute 'size'

封装与扩展性

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；

而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。

这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

isinstance & issubclass

• isinstance (obj, cls)
• 检查对象obj是否是cls的对象，或变量obj是否是cls类型的变量，以True或False的形式返回

# test1
class Foo:
    pass
f = Foo()
print(isinstance(f,Foo)) # 打印True

# test2
print(isinstance("hello", str))  # 判断"hello"是否为字符串类型，返回True

• issubclass(sub, supper)
• 检查sub类是否是supper类的派生类，以True或False的形式返回

绑定方法与非绑定方法

在类内部定义函数，分为两大类：绑定方法、非绑定方法

绑定方法：

• 绑定给谁，就应该由谁调用，谁来调用就会把谁当第一个参数自动传入

绑定到对象的方法：在类定义的没有被任何装饰器修饰的

绑定到类的方法：在类内定义的被装饰器@classmethod修饰的方法

非绑定方法：

• 在类内定义的被装饰器@staticmethod修饰的方法，只是一个普通的函数工具，没有自动传参的功能，对象和类都可以调用

非绑定方法：不与类或者对象绑定