• Day 5-4封装.__隐藏属性或者方法


    封装

    property

    封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

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

     1 class A:
     2     __x = 1  # 以__开头的变量属性或者函数方法,在类定义以后都会自动变形成_A__.x
     3 
     4     def __test(self):   # _A__test
     5         print("from A")
     6 
     7     def foo(self):
     8         self.__test()   # 在类内部可以通过self.__test()来调用私有的属性或者方法.因为在方法定义阶段,就已经变形成_A__test()
     9         print("from foo")
    10 
    11 print(A.__dict__)
    12 a = A()
    13 a.foo()
    14 print(a.__test)
    15 
    16 a._A__test()
    17 
    18 
    19 # 子类无法覆盖父类__开头的属性或方法.
    20 class Foo:
    21     def __test(self):     # 定义阶段就变成了_Foo__test()
    22         print("from Foo")
    23 
    24 class Bar(Foo):
    25     def __test(self):    # 定义阶段编程了_Bar__test().所以这2个__test()完全是2个不同的方法.
    26         print("from Bar")

    变形的特点:

    1. 类中定义的__x只能在内部使用,如self.__x,引用的就是变形的结果。(代码1-9)

    2. 这种变形其实正是针对外部的变形,在外部是无法通过__x这个名字访问到的。(代码14行)

    3. 在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开头的属性在继承给子类时,子类是无法覆盖的。(代码:20-26行)

    变形需要注意的问题是:

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

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

    1 class A:
    2     __y = 5
    3     def __test(self):
    4         print("from A")
    5 
    6 A.__X = 3
    7 print(A.__dict__)
    8 # '__X': 3 定义的并未发生变形.

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

     1 class A:
     2     def test(self):
     3         print("from A")
     4         self.__foo()
     5 
     6     def __foo(self): # 定义阶段变成self._B__foo() 当从A中test()方法调用的时候,就是调自己类中的__foo()
     7         print("from A.foo")
     8 
     9 
    10 class B(A):
    11     def __foo(self):
    12         print("from B.foo")
    13 
    14 
    15 a = B()
    16 a.test()

     封装的作用:

    1. 隐藏起来然后对外提供操作该数据的接口,然后我们可以在接口附加上对该数据操作的限制,以此完成对数据属性操作的严格控制。

     

    class Teacher:
        def __init__(self, name, age):
            self.__name = name
            self.__age = age
    
        def tell_infco(self):
            print("name is %s and age is %s" % (self.__name, self.__age))
    
        def set_info(self, name, age):
            if not isinstance(name, str):
                print("33[1;31mError,name must str.33[0m")
            else:
                self.__name = name
            if not isinstance(age, int):
                print("33[1;31mError,age is must int.33[0m")
            else:
                self.__age = age
    
    
    t1 = Teacher("Jack", 18)
    
    t1.tell_infco()
    t1.set_info(123,"123")   # 姓名和年龄,有一个不符合我们设定的条件,就打印我们设置的提示.
    t1.set_info("mayun", 55)    # 符合要求,打印我们修改后的内容.
    t1.tell_infco()

    2.封装方法:隔离复杂度

    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()

    取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱

    对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做

    隔离了复杂度,同时也提升了安全性

    封装与扩展性:

    封装在于明确区分内外,使得类实现者可以修改封装内的东西而不影响外部调用者的代码;而外部使用用者只知道一个接口(函数),只要接口(函数)名、参数不变,使用者的代码永远无需改变。

     

    #类的设计者
    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()

     property

     property是一种特殊的属性,访问它时会执行一段功能(函数)然后返回值.

     

    class Peoplo:
        def __init__(self, name, height, weight):
            self.name = name
            self.height = height
            self.weight = weight
        @property      # 加上property这个装饰器,就把这个方法变成了像一个属性.在调用的时候,直接b.bmi就可以了
        def bmi(self):
            return  self.weight / (self.height ** 2)
    
    
    
    p = Peoplo("Nick", 1.7, 69)
    
    # print(p.bmi())  # 正常情况下,我们要调用这个方法来获取我们想要的数据.
    p.bmi = 35555  # 会报错.本质上行还是调用bmi()方法.没有修改属性.
    print(p.bmi)   

     

    为什么要用property

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

     

     

     

     

  • 相关阅读:
    3513: [MUTC2013]idiots
    ELK+Filebeat+Kafka+ZooKeeper 构建海量日志分析平台(elk5.2+filebeat2.11)
    【python全栈开发】初识python
    SQL疑难问题
    费用分摊问题
    透过现象看本质
    关于python3round与float的四省五入精度的问题
    Win10下VSCode安装PlantUML
    安装pymssql
    ensorFlow的安装
  • 原文地址:https://www.cnblogs.com/lovepy3/p/8974767.html
Copyright © 2020-2023  润新知