Python3.7之封装

Posted 彩虹然

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python3.7之封装相关的知识,希望对你有一定的参考价值。

Python3.7之封装

一、封装的意义

封装不是单纯意义的隐藏

1.封装数据

主要原因是:保护私隐,明确区分内外。将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口,然后我们可以在接口附加上对该数据操作的限制,以此完成对数据属性操作的严格控制。

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

    def tell_info(self):
        print('Name:%s  Age:%d' % (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


teacher = Teacher('A', 30)
teacher.tell_info()

teacher.set_info('A', 29)
teacher.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.私有变量

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

__名字,这种语法,只在定义的时候才会有变形的效果,如果类或者对象已经产生了,就不会有变形效果

class A:

    __x = 1  # 在属性前面加两个下划线,表示对该属性进行隐藏,设置成私有,在内部都会变成成:_类名.__x

    def __test(self):  # 这里在内部会变形:_A__test,调用的时候a._A__test()
        print('from A')

    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()
print(a._A__x)
a._A__test()  # 不建议在外部直接通过这种方式调用隐藏方法

2.私有方法

# 正常情况
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()  # b.test ---> B ---> A ---> b.fa() ---> b 是 B 的对象,在 B 里找 fa
from B
# 知识点:在继承中,父类如果不想让子类覆盖自己的方法,可以将方法定义为私有的
# __名字,在定义节点就已经变形了,变成  _类名__属性
class A:
    def __fa(self):  # 在定义时就变形为_A__fa
        print('from A')

    def test(self):
        self.__fa()  # 只会与自己所在的类为准,即调用_A__fa


class B(A):
    def __fa(self):  # 变形:_B__fa
        print('from B')


b = B()
b.test()  # b.test ---> B没有 ---> 找A的test ---> b.fa() ---> b._A__fa  找的A的 __fa
from A

这种自动变形的特点:

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

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

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

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

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

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

三、封装特性

1.什么是特性property

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

2.为什么要用property

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

# 圆周率的例子
import math


class Circle:  # 圆周率
    def __init__(self, radius):  # 圆的半径
        self.radius = radius

    @property   # area=property(area)
    def area(self):
        return math.pi * self.radius**2  # 计算圆的面积

    @property
    def perimeter(self):
        return 2*math.pi*self.radius  # 计算周长


c = Circle(7)
print(c.area)  # 伪装成数据属性,如果不加 property 的话,调用的时候变成  c.area(),一个函数属性
'''
property 简单来说就把类里的函数属性伪装成一个数据属性,使用者用起来感觉不到自己用的其实一个函数

#注意:此时的特性arear和perimeter不能被赋值,因为实质上是一个函数属性
c.area=3 #为特性area赋值

抛出异常:
AttributeError: can't set attribute

'''
class People:
    def __init__(self, name, SEX):
        self.name = name
        # self.__sex = SEX  # 性别隐藏起来不让人知道
        self.sex = SEX  # # p2.sex=male 一初始化或赋值操作就找 sex.setter

    @property   # 负责查询
    def sex(self):   # 通过接口可以查看隐藏的性别
        return self.__sex  # p2.__sex = male

    @sex.setter  # 定义修改性别的接口
    def sex(self, value):
        sexes = ['male', 'female']
        if not isinstance(value, str):  # 在设定值之前进行类型检查,增加限制的扩展性
            raise TypeError('性别必须是字符串类型')
        if value not in sexes:
            raise TypeError('性别只能是 male 或者 female')
        self.__sex = value  # p2.__sex = male

    @sex.deleter
    def sex(self):   # 删除属性接口
        del self.__sex  # del p2.__sex


p2 = People('alex', 'male')  # 触发 init 执行,这里有个赋值操作 p2.sex='male'
print(p2.sex)
# p2.sex ='female3'
# print(p2.sex)
del p2.sex  # 删掉 __sex 数据属性
# print(p2.sex)  # 再去 property 找的话找不到了

被 property 装饰的属性会优先于对象的属性被使用,被找到;而被 property装饰的属性,如 sex ,分成三种

property 查询

sex.setter 赋值,修改

sex.deleter 删除

如果对象要修改数据属性的时候,在没有 property 的情况下,可以随便改,但是加了之后,就可以有一个扩展性,限制对象只能改什么。

以上是关于Python3.7之封装的主要内容,如果未能解决你的问题,请参考以下文章

Python3.7之继承

Python3.7之抽象类与归一化

VSCode自定义代码片段14——Vue的axios网络请求封装

VSCode自定义代码片段14——Vue的axios网络请求封装

VSCode自定义代码片段14——Vue的axios网络请求封装

回归 | js实用代码片段的封装与总结(持续更新中...)