面向对象编程(封装、封装的意义、封装与扩展性、@property)

1.封装之如何实现属性的隐藏

封装： __x=1 # 把数据属性隐藏 (如何实现隐藏) 类定义阶段 __开头发生了变形 __x --> _A__x
特点：
　　1.在类外部无法直接：obj.__AttrName
　　2.在类内部是可以直接使用：obj.__AttrName # 为什么会这样？python 如何实现的！类定义阶段已经变形 #__x --> _A__x #self._A_foo()
　　3.子类无法覆盖父类__开头的属性它两根本不是一个名字 #_Foo__func #_Bar__func
总结:
这种变形需要注意的问题：
　　1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N eg:print(A._A__x)
　　2.变形的过程只在类的定义时发生一次,在定义后的赋值操作，不会变形 eg: b.__age=18 {'_B__name': 'alice', '__age': 18}
　　3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的 eg: def __foo(self): #_A__foo

# class A:

#     __x=1  # 把数据属性隐藏    _A__x

#

#     def __init__(self,name):

#         self.__name=name    # _A__name

#

#     def __foo(self):  # 把函数属性隐藏   def _A__foo(self)

#         print('run foo')

#

#     def bar(self):

#         self.__foo()  #self._A_foo()  定义阶段已经变了

#         print('from bar')

# print(A.__dict__)

# {'__module__': '__main__', '_A__x': 1, '__init__': <function A.__init__ at 0x0000017AC92B0B70>, '_A__foo': <function A.__foo at 0x0000017AC92B0BF8>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}

# 类定义阶段  __开头发生了变形  __x --> _A__x

# print(A.__x)

# print(A._A__x)

# print(A.__foo)

# print(A._A__foo)

# a=A('alice')

# print(a.__dict__)

# {'_A__name': 'alice'}

# print(a.__name)

# print(a._A__name)

# a.bar()

# ---------------------------------------------

# class Foo:

#     def __func(self):  #_Foo__func

#         print('from foo')

#

# class Bar(Foo):

#     def __func(self):  #_Bar__func

#         print('from bar')

# b=Bar()

# b.func()  # 子类把父类 重名的给覆盖掉了

# ---------------------------------------------

# class B:

#     __x=1

#

#     def __init__(self,name):

#         self.__name=name

# # print(B._B__x)   # 一般不要这么做！py不让你这么干了

# B.__y=2   # 类定义完之后不会发生变形

# # print(B.__dict__)

# # {'__module__': '__main__', '_B__x': 1, '__init__': <function B.__init__ at 0x00000180405A0B70>, '__dict__': <attribute '__dict__' of 'B' objects>, '__weakref__': <attribute '__weakref__' of 'B' objects>, '__doc__': None, '__y': 2}

#

# b=B('alice')

# print(b.__dict__)  # {'_B__name': 'alice'}

#

# b.__age=18

# print(b.__dict__) #{'_B__name': 'alice', '__age': 18}

# ---------------------------------------------

# class A:

#     def foo(self):

#         print('A.foo')

#

#     def bar(self):

#         print('A.bar')

#         self.foo() #b.foo

#

# class B(A):

#     def foo(self):

#         print('B.foo')

#

# b=B()

# b.bar()

# ---------------------------------------------

class A:

    def __foo(self):  #_A__foo

        print('A.foo')

    def bar(self):

        print('A.bar')

        self.__foo() #self._A__foo()  # 只调自己类的方法 定义时就已经确定好的！

class B(A):

    def __foo(self): #_B__foo

        print('B.foo')

b=B()

b.bar()

2.封装的意义

封装数据属性目的： (封装不是单纯意义上的隐藏)
明确的区分内外,控制外部对隐藏的属性的操作行为

封装方法属性目的：
隔离复杂度 # a=ATM() a.withdraw(

在绑定属性时，如果我们直接把属性暴露出去，虽然写起来很简单，但是，没办法检查参数，导致可以把成绩随便改：

# class People:

#     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('名字必须是字符串类型')

#             return

#         if not isinstance(age,int):

#             print('年龄必须是数字类型')

#             return

#         self.__name=name

#         self.__age=age

#

# p=People('alice','18')

# p.tell_info()

# p.set_info('alex',38)

# p.tell_info()

# p.set_info('alex','38')

# p.tell_info()

# -------------------------------------------------------

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

3.封装与扩展性

面向对象：可扩展性高面向对象三大特性：继承多态封装封装的扩展性： def tell_area(self): # 对使用者来说不用改变方式开发者在类里面修改

class Room:

    def __init__(self,name,owner,weight,length,height):

        self.name=name

        self.owner=owner

        self.__weight=weight

        self.__length=length

        self.__height=height

    def tell_area(self):  # 对使用者来说 不用改变 方式

        return self.__weight * self.__length * self.__height

r=Room('卫生间','alex',10,10,10)

print(r.tell_area())

4.property的使用

Python内置的@property装饰器就是负责把一个方法变成属性调用的：

@property的实现比较复杂，我们先考察如何使用。把一个getter方法变成属性，只需要加上@property就可以了，此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：

注意到这个神奇的@property，我们在对实例属性操作的时候，就知道该属性很可能不是直接暴露的，而是通过getter和setter方法来实现的。

还可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：

小结

@property广泛应用在类的定义中，可以让调用者写出简短的代码，同时保证对参数进行必要的检查，这样，程序运行时就减少了出错的可能性。

property :
   @property
   def bmi(self): 必须有个返回值
   print(p.bmi)   可以使 函数属性 伪装成 数据属性  bmi 是名词

   p.bmi=23  # 不能赋值 can't set attribute  bmi 实质是个方法

总结：通过计算得来的方法 可以通过@property 伪装成数据属性
      @property      查看  必须有返回值
      @name.setter   修改
      @name.deleter  删除

练习

请利用@property给一个Screen对象加上width和height属性，以及一个只读属性resolution：

class Screen(object):

    @property

    def resolution(self):

        return self.width * self.height

# 测试:

s = Screen()

s.width = 1024

s.height = 768

print('resolution =', s.resolution)

if s.resolution == 786432:

    print('测试通过!')

else:

    print('测试失败!')

#输出

resolution = 786432

测试通过!

巴特西

面向对象编程(封装、封装的意义、封装与扩展性、@property)

1.封装之如何实现属性的隐藏

2.封装的意义

3.封装与扩展性

4.property的使用

小结

练习

最新文章

热门文章