封装

封装

封装
广义上的封装 : 属于一个类的静态和动态属性 总是出现在一个类中
                使用的使用永远用类名或者对象名调用
狭义上的封装 : 就是把变量方法私有化,在类的外部以及子类中不能直接使用了

                         隐藏对象的属性和实现细节，仅对外提供公共访问方式。

 

 

class A:
    STATIC = 'aaa'  # 静态变量
    __S = 'bbb'     # 私有的静态变量
    def wahaha(self):
        print(A.__S) #内部转化 _A__S
print(A.STATIC)#类名调用静态属性
print(A.__dict__)#显示A类中的存储的字典
print(A._A__S)  # 在类的外面调用私有的变量
a = A()#创建对象
a.wahaha()#实例化
A.__B = 'ccc'   #在类的外部添加了一个静态变量，并不是添加一个类的私有静态属性
print(A.__dict__)  #我们不能在一个类的外部创建一个"私有的"变量
print(A.__B)#打印c出来只是A的一个静态属性

 

class B:
    def __init__(self,name,pwd):
        self.name = name
        self.__pwd = pwd   # 也可以创建对象的私有属性，因为__pwd会自动转化成_B__pwd

    def qqxing(self):
        self.__a = 'A'     # 自动转化_B__a

    def get_pwd(self):
        print(self.__pwd)
b = B('alex','Alex3714')
b.qqxing()

print(b.name)#打印类的.name方法
print(b._B__pwd)  # 当在类外部的时候,我们也不能直接使用对象的私有属性
b.get_pwd()#获取pwd

 

class C:
    def __ppt(self):    # 私有的方法
        print('ppt')
        self.age = 83
    def open(self):#open方法
        self.__ppt
        print('打开文件')
c = C()
c._C__ppt()   # 不能直接调用
c.open()#使用对象中的函数方法
c.name = 'Alex'#添加一个对象的静态变量
print(c.name)#打印实例的静态变量

私有de 静态变量 对象属性 方法
    私有的 只能在类的内部定义和使用
    __名字
    在类外部使用私有静态变量 _类名__私有的名字
    私有的名字 不能被子类继承java

    # private 私有的  - __变量名
    # protect 保护的  - N/A
    # public 公共的   - 正常的变量

【好处】 

1. 将变化隔离； 

2. 便于使用；

3. 提高复用性； 

4. 提高安全性；

【封装原则】

      1. 将不需要对外提供的内容都隐藏起来；

      2. 把属性都隐藏，提供公共方法对其访问。

私有变量和私有方法

在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

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

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

#A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

这种自动变形的特点：

1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。

2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

class D:
    __DDD = 'ddd'     # 私有静态属性_D__DDD
    AAA = 'aaa'        #静态属性

class E(D):#继承父类属性
    def qqxing(self):#对象函数
        print(E.AAA)   #调用父类静态属性
        print(E.__DDD)   #无法被调用因为会变形成E._E__DDD
e = E()#对象实例化
e.qqxing()#调用对象函数    
 

这种变形需要注意的问题是：

1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N

2.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形

私有方法

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

#正常情况
>>> class A:
...     def fa(self):
...         print('from A')
...     def test(self):
...         self.fa()
... 
>>> class B(A):
...     def fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from B
 

#把fa定义成私有的，即__fa
>>> class A:
...     def __fa(self): #在定义时就变形为_A__fa
...         print('from A')
...     def test(self):
...         self.__fa() #只会与自己所在的类为准,即调用_A__fa
... 
>>> class B(A):
...     def __fa(self):
...         print('from B')
... 
>>> b=B()
>>> b.test()
from A

封装与扩展性

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

#类的设计者
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
        return self.__width * self.__length


#使用者
>>> r1=Room('卧室','egon',20,20,20)
>>> r1.tell_area() #使用者调用接口tell_area


#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
class Room:
    def __init__(self,name,owner,width,length,high):
        self.name=name
        self.owner=owner
        self.__width=width
        self.__length=length
        self.__high=high
    def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
        return self.__width * self.__length * self.__high


#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
>>> r1.tell_area()

#房间类 : 所有人 价格 面积
class Room:#定义房间类
    def __init__(self,owner,price,length,width,height):#动态属性
        self.owner = owner#类的属性
        self.__price_single = price  #单价私有属性
        self.__length = length#长度私有属性
        self.__width = width#长度私有属性
        self.height = height#高度属性

    def get_area(self):#面积方法
        return self.__length * self.__width

    def get_price(self):#价格方法
        return self.__price_single * self.get_area()

alex = Room('alex',1000000,2,1,0.8)#实例化
print(alex.get_area())#打印面积
print(alex.get_price())#打印价格

property属性

什么是特性property

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

例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）

成人的BMI数值：
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖, 高于32
　　体质指数（BMI）=体重（kg）÷身高^2（m）
　　EX：70kg÷（1.75×1.75）=22.86

类 能够计算人体的BMI指数
class Person:
    def __init__(self,name,height,weight):
        self.name = name
        self.__height = height#私有身高
        self.__weight = weight#私有质量

    @property   #将一个方法伪装成属性property财产
    def bmi(self):
        return self.__weight / (self.__height**2)

wang = Person('王子',1.77,69)
print(wang.bmi)

圆形类  : r   面积area 周长perimeter
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    @property#转换成属性的装饰器
    def area(self):
        return self.r*self.r*pi
    @property#方法转换成属性的装饰器
    def perimeter(self):
        return 2*pi*self.r

c = Circle(10)
print(c.area)
print(c.perimeter)

#注意：此时的特性area和perimeter不能被赋值
c.area=3 #为特性area赋值
'''
抛出异常:
AttributeError: can't set attribute
'''

为什么要用property

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

除此之外，看下

ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开

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

class Foo:
    def __init__(self,name):
        self.__name = name#私有属性
    @property
    def name(self):#函数转化成一个私有属性
        return self.__name
    @name.setter
    def name(self,new_name):
        if type(new_name) == str:
            self.__name = new_name

alex = Foo('alex')
print(alex.name)
alex.name = 123  # 为了迎合属性的设置方式
print(alex.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'

 

 

一个静态属性property本质就是实现了get，set，delete三种方法

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,value):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

class Foo:
    def get_AAA(self):
        print('get的时候运行我啊')

    def set_AAA(self,value):
        print('set的时候运行我啊')

    def delete_AAA(self):
        print('delete的时候运行我啊')
    AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应

f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

怎么用？

class Goods:

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price


obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

 

 

classmethod：

将一个普通方法装饰为一个类方法

class Goods:
    __discount = 0.8
    def  __init__(self,name,price):
        self.name = name
        self.__price = price

    @property
    def price(self):
        return self.__price*Goods.__discount

    @classmethod  #将一个普通方法装饰为一个类方法
    def change_discount(cls,new_dis):  # 类方法
        cls.__discount = new_dis
Goods.change_discount(2)#定义了Good的一个静态属性
cig = Goods('cigrette',20)
print(cig.price)#40   20*2
cig.change_discount(0.2)
print(cig.price)#4.0   20*0.2
cig.change_discount(1)
print(cig.price)#20 *1

#类方法是被@classmethod装饰的特殊方法
    #被装饰之后,方法默认接收一个 类 作为参数
    # 之后所有的操作都只能和 类中的静态变量相关 而不应该和对象相关
# 类名 和 对象名 都可以直接调用类方法

staticmethod：

外部函数可以直接类名+函数名使用内部函数

class Student:
    def __init__(self,name):
        self.name = name

    @staticmethod    #装饰一个不需要self参数 也不需要cls参数的函数
    def login(a,b,c):    # 普通的函数
        usr = input('username>>>')
        pwd = input('password>>>')
        if usr == 'alex' and pwd == '123':
            obj = Student(usr)
            return obj
# 学生 login
# 用户名  密码  属性
ret = Student.login(1,2,3)#外部函数可以直接类名+函数名使用内部函数
print(ret)