您现在的位置是：首页 > Python

当前栏目

python面向对象: 封装

Python 接口对象数据

2023-03-02 11:47:59 时间

**引子**

从封装本身的意思去理解，封装就好像是拿来一个麻袋，把小猫，小狗，小王八一起装进麻袋，然后把麻袋封上口子，按照这种逻辑看，封装=‘隐藏’，这种理解是相当片面的

**先看如何隐藏**

class A:
        __N = 0     # 类的数据属性就应该是共享的，但是语法上是可以把类的数据属性设置成私有的如__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，即双下划线开头的属性在继承给子类时，子类无法覆盖的

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

1.  这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：\_类名\_\_属性，然后就可以访问了，如:a.\_A\_\_N
2.  变形的过程只在类的定义时发生一次，在定义后的赋值操作，不会变形

![1372019-20180630144545677-405948742.png][]

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()
    print(b.test())
    
    # 把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()
    print(b.test())

封装不是单纯意义的隐藏

1：封装数据

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

class Teacher:
        def __init__(self, name, age):
            self.__name = name
            self.__age = age
    
        def tell_info(self):
            print('姓名:%s, 年龄:%s' % (self.__name, self.__age))
    
        def set_info(self, name, age):
            if not isinstance(name, str):
                raise TypeError('姓名必须是字符串类型')
            if not isinstance(age, int):
                raise TypeError('年龄必须是整型')
            self.__name = name
            self.__age = age
    
    
    t = Teacher('egon', 18)
    t.tell_info()
    
    t.set_info('egon', 20)
    t.tell_info()

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

封装方法的其它举例：

1.  电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏
2.  快门就是傻瓜相机为傻瓜们提供的方法，该方法内部复杂的照相概念都隐藏起来了

提示：在编程语言里，对外提供的接口（接口可理解为一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体

**特性（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

class People:
        def __init__(self, name, weight, height):
            self.name = name
            self.weight = weight
            self.height = height
    
        @property
        def bmi(self):
            return self.weight / (self.height**2)
    
    p1 = People('egon', 75, 1.85)
    print(p1.bmi)

例二：圆的周长和面积

# # 圆的周长和面积
    import math
    class Circle:
        def __init__(self, radius): # 圆的半径radius
            self.radius = radius
    
        @property
        def area(self):
            return math.pi * self.radius**2 # 计算面积
    
        @property
        def perimeter(self):
            return 2*math.pi*self.radius    # 计算周长
    
    c = Circle(10)
    print(c.radius)
    print(c.area)       # 可以向访问数据属性一样去访问area，会触发一个函数的执行，动态计算出一个值
    print(c.perimeter)

注意：此时的特性area和perimeter不能被赋值

c.area=3 #为特性area赋值
    '''
    抛出异常:
    AttributeError: can't set attribute
    '''

为什么要用property

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

除此之外，看下

ps：面向对象的封装有三种方法：
    【public】
    这种其实就是不封装，是对外公开的
    【protected】
    这种封装方式对外不公开，单对朋友（friend）或者子类（形象的说法是“儿子”）
    【private】
    这种封装对谁都不公开

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

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)

封装与扩展性

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

lass Room:
        def __init__(self, name, owner, width, length, hight):
            self.name = name
            self.owner = owner
            self.__width = width
            self.__length = length
            self.__hight = hight
    
        def tell_area(self):         # 对外提供的接口，隐藏内部的实现细节，此时我们想求的是面积
            return self.__width * self.__length * self.__hight
    
    r1 = Room('卧室', 'egon', 20, 20, 20)
    print(r1.tell_area())  # 使用者调用接口tell_area

转载于:https://www.cnblogs.com/mike-liu/p/9241944.html

[1372019-20180630144545677-405948742.png]: /images/20210725/c90cbafd10504b2c8e1f31d5ecde8c4d.png

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

python面向对象: 封装

相关文章