python小记（6）

调用覆盖的方法

承接前面的问题和程序，可以对子类Gril做出这样的修改。

class Girl(Person):
    def __init__(self, name):
        Person.__init__(self, name)
        self.real_name = "Aoi sola"

    def get_name(self):
        return self.name

请读者注意观察Girl的初始化方法，与前面的有所不同。为了能够使用父类的初始化方法，以类方法的方式调用Person.__init__(self, name)。另外，在子类的__init__()的参数中，要增加相应的参数name。这样就回答了前面的问题。

实例化子类，以下面的方式运行程序：

if __name__ == "__main__":
    cang = Girl("canglaoshi")
    print cang.real_name
    print cang.get_name()
    print cang.height(160)
    print cang.breast(90)

执行结果为：

Aoi sola
canglaoshi
{'height': 160}
{'breast': 90}

就这样，使用类方法的方式，将父类中被覆盖的方法再次在子类中实现。

但上述方式有一个问题，如果父类的名称因为某种目前你无法预料的原因修改了，子类中该父类的的名称也要修改，有如果程序比较复杂或者忘记了，就会出现异常。于是乎，就有了更巧妙的方法——super。再重写子类。

class Girl(Person):
    def __init__(self, name):
        #Person.__init__(self, name)
        super(Girl, self).__init__(name)
        self.real_name = "Aoi sola"

    def get_name(self):
        return self.name

仅仅修改一处，将Person.__init__(self, name)修改为super(Girl, self).__init__(name)。执行程序后，显示的结果与以前一样。

关于super，有人做了非常深入的研究，推荐读者阅读《Python’s super() considered super! 》，文中已经探究了super的工作过程。读者如果要深入了解，可以阅读这篇文章。

 

封装和私有化

“封装”，是不是把代码写到某个东西里面，“人”在编辑器中打开，就看不到了呢？

除非是你的显示器坏了。

在程序设计中，封装(Encapsulation)是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，即无法调用（不是人用眼睛看不到那个代码，除非用某种加密或者混淆方法，造成现实上的困难，但这不是封装）。

要了解封装，离不开“私有化”，就是将类或者函数中的某些属性限制在某个区域之内，外部无法调用。

Python中私有化的方法也比较简单，就是在准备私有化的属性（包括方法、数据）名字前面加双下划线。例如：

#!/usr/bin/env python
# coding=utf-8

class ProtectMe(object):        #Python 3: class ProtectMe:
    def __init__(self):
        self.me = "qiwsir"
        self.__name = "kivi"

    def __python(self):
        print "I love Python."        #Python 3: print("I love Python.")，下同，从略

    def code(self):
        print "Which language do you like?"
        self.__python()

if __name__ == "__main__":
    p = ProtectMe()
    print p.me
    print p.__name

运行一下，看看效果：

$ python 21102.py
qiwsir
Traceback (most recent call last):
  File "21102.py", line 21, in <module>
    print p.__name
AttributeError: 'ProtectMe' object has no attribute '__name'

查看报错信息，告诉我们没有__name那个属性。果然隐藏了，在类的外面无法调用。再试试那个函数，可否？

if __name__ == "__main__":
    p = ProtectMe()
    p.code()
    p.__python()

修改这部分即可。其中p.code()的意图是要打印出两句话："Which language do you like?"和"I love Python."，code()方法和__python()方法在同一个类中，可以调用之。后面的那个p.__python()试图调用那个私有方法。看看效果：

$ python 21102.py 
Which language do you like?
I love Python.
Traceback (most recent call last):
  File "21102.py", line 23, in <module>
    p.__python()
AttributeError: 'ProtectMe' object has no attribute '__python'

如愿以偿。该调用的调用了，该隐藏的隐藏了。

用上面的方法，的确做到了封装。但是，我如果要调用那些私有属性，怎么办？

可以使用property函数。

#!/usr/bin/env python
# coding=utf-8

class ProtectMe(object):    #Python 3: class ProtectMe:
    def __init__(self):
        self.me = "qiwsir"
        self.__name = "kivi"

    @property
    def name(self):
        return self.__name

if __name__ == "__main__":
    p = ProtectMe()
    print p.name        #Python 3: print(p.name)

运行结果：

$ python 21102.py 
kivi

从上面可以看出，用了@property之后，在调用那个方法的时候，用的是p.name的形式，就好像在调用一个属性一样，跟前面p.me的格式相同。

看来，封装的确不是让“人看不见”。

使用@property

阅读: 79156

---

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

s = Student()
s.score = 9999

这显然不合逻辑。为了限制score的范围，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数：

class Student(object):

    def get_score(self): return self._score def set_score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value 

现在，对任意的Student实例进行操作，就不能随心所欲地设置score了：

>>> s = Student()
>>> s.set_score(60) # ok!
>>> s.get_score() 60 >>> s.set_score(9999) Traceback (most recent call last): ... ValueError: score must between 0 ~ 100! 

但是，上面的调用方法又略显复杂，没有直接用属性这么直接简单。

有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢？对于追求完美的Python程序员来说，这是必须要做到的！

还记得装饰器（decorator）可以给函数动态加上功能吗？对于类的方法，装饰器一样起作用。Python内置的@property装饰器就是负责把一个方法变成属性调用的：

class Student(object):

    @property def score(self): return self._score @score.setter def score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value 

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

>>> s = Student()
>>> s.score = 60 # OK，实际转化为s.set_score(60)
>>> s.score # OK，实际转化为s.get_score() 60 >>> s.score = 9999 Traceback (most recent call last): ... ValueError: score must between 0 ~ 100! 

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

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

class Student(object):

    @property def birth(self): return self._birth @birth.setter def birth(self, value): self._birth = value @property def age(self): return 2015 - self._birth 

上面的birth是可读写属性，而age就是一个只读属性，因为age可以根据birth和当前时间计算出来。

小结

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

 

 

转载于:https://www.cnblogs.com/liqiantu/p/5794563.html