Python--模块、类、对象、继承、合成

1.模块

模块和字典差不多，它的一些属性：

1.模组是包含函数和变量的Python 文件。

2.你可以import 这个文件。

3.然后你可以使用'.'操作符访问到模组中的函数和变量。

假如说有一个模块名字叫mystuff.py 并且在里边放了个叫做 apple 的函数，就像这样：

# this goes in mystuff.py
def apple():
    print "I AM APPLES!"
# this is just a variable
tangerine = "Living reflection of a dream"

接下来我就可以用import 来调用这个模块，并且访问到 apple 函数和变量：

import mystuff
mystuff.apple()
print mystuff.tangerine

2.类

类和模块差不多，通过类，可以把一组函数和数据放到一个容器中，从而用'.'操作符访问到它们使用创建 mystuff 模块的方法来创建一个类：

class MyStuff(object):
    def __init__(self):
        self.tangerine = "And now a thousand years between"
    def apple(self):
        print "I AM CLASSY APPLES!"

创建类时，括号里的object表示的是继承自object

3.对象

当你将一个类“实例化”以后，你就得到了一个对象(object)

实现实例化的方法，就是像调用函数一样地调用一个类:

thing = MyStuff()
thing.apple()
print thing.tangerine

第一行代码就是“实例化”操作，这和调用函数很相似。然而，当你进行实例化操作时，Python 在背后
做了一系列的工作：
1. Python 看到了 MyStuff() 并且知道了它是你定义过的一个类。
2. Python 创建了一个空的对象，里边包含了你在类中用 def 创建的所有函数。
3. 然后 Python 回去检查你是不是在里边创建了一个 __init__ 的函数，如果你有创建，它就会调用这个函数，从而对你的空对象实现了初始化。
4. 在 MyStuff 中的 __init__ 函数里，我们有一个多余的函数叫做 self ，这就是 Python 为我们创建的空对象，而我可以对它进行类似模块、字典等的操作，为它设置一些变量进去。
5. 在这里，把 self.tangerine 设成了一段歌词，这样我就初始化了该对象。
6. 最后 Python 将这个新建的对象赋给一个叫 thing 的变量，以供后面使用。

4.例子

class Song(object):
    def __init__(self, lyrics):
        self.lyrics = lyrics
    def sing_me_a_song(self):
        for line in self.lyrics:
            print line
happy_bday = Song(["Happy birthday to you",
                 "I don't want to get sued",
                 "So I'll stop right there"])
bulls_on_parade = Song(["They rally around the family",
                     "With pockets full of shells"])
happy_bday.sing_me_a_song()
bulls_on_parade.sing_me_a_song()

输出结果

</pre><pre name="code" class="html">Happy birthday to you
I don't want to get sued
So I'll stop right there
They rally around the family
With pockets full of shells

4.类、对象、继承

对象是类的一个实例，类之间可以有继承的关系：

## Animal is-a object (yes, sort of confusing) look at the extra credit
class Animal(object):
    pass
class Dog(Animal):
    def __init__(self, name):
    self.name = name

class Person(object):
    def __init__(self, name):
        self.name = name
        self.pet = None  #确保类的 self.pet 属性被设置为 None
class Employee(Person):
    def __init__(self, name, salary):
        super(Employee, self).__init__(name)
        self.salary = salary

5.继承

继承的用处，就是用来指明一个类的大部分或全部功能，都是从一个父类中获得的。当你写class Foo(Bar) 时，代码就发生了继承效果，这句代码的意思是“创建一个叫Foo的类，并让他继承Bar”。当你这样写时,Python 语言会让 Bar 的实例所具有的功能都工作在 Foo 的实例上。这样可以让你把通用的功能放到Bar 里边，然后再给Foo特别设定一些功能。

父类和子类有三种交互方式：
1. 子类上的动作完全等同于父类上的动作
2. 子类上的动作完全改写了父类上的动作
3. 子类上的动作部分变更了父类上的动作

(1)隐式继承（Implicit Inheritance）

在父类里定义了一个函数，但没有在子类中定义的例子，这时候会发生隐式继承。

class Parent(object):
    def implicit(self):
        print "PARENT implicit()"
class Child(Parent):
    pass

dad = Parent()
son = Child()
dad.implicit()
son.implicit()

class Child: 中的pass是在Python中创建空的代码区块的方法。这样就创建了一个叫Child的类，但没有在里边定义任何细节。在这里它将会从它的父类中继承所有的行为。运行起来就是这样：
PARENT implicit()
PARENT implicit()
就算我在第 16 行调用了son.implicit() 而且就算Child 中没有定义过implicit 这个函数，这个函数依然可以工作，而且和在父类 Parent 中定义的行为一样。这就说明，如果你将函数放到基类中（也就是这里的Parent ），那么所有的子类（也就是Child 这样的类）将会自动获得这些函数功能。
如果你需要很多类的时候，这样可以让你避免重复写很多代码。
(2)显式覆写（Explicit Override）

有时候你需要让子类里的函数有一个不同的行为，这种情况下隐式继承是做不到的，而你需要覆写子类中的函数，从而实现它的新功能。你只要在子类Child 中定义一个相同名称的函数就可以了，如下所示：

class Parent(object):
    def override(self):
        print "PARENT override()"
class Child(Parent):
    def override(self):
        print "CHILD override()"
dad = Parent()
son = Child()
dad.override()
son.override()

这里我在两个类中都定义了一个叫override的函数，我们看看运行时会出现什么情况。
PARENT override()
CHILD override()
如你所见，运行到第 14 行时，这里执行的是Parent.override，因为dad这个变量是定义在Parent里的。不过到了第 15 行打印出来的却是Child.override里的信息，因为son是Child的一个实例，而子类中新定义的函数在这里取代了父类里的函数。

(3)在运行前或运行后覆写

class Parent(object):
    def altered(self):
        print "PARENT altered()"
class Child(Parent):
    def altered(self):
        print "CHILD, BEFORE PARENT altered()"
        super(Child, self).altered()
        print "CHILD, AFTER PARENT altered()"
dad = Parent()
son = Child()
dad.altered()
son.altered()

重要的是 9 到 11 行，当调用 son.altered() 时：
1. 由于我覆写了Parent.altered，实际运行的是Child.altered，所以第9行执行结果是预料之中
的。
2. 这里我想在前面和后面加一个动作，所以，第9行之后，我要用super来获取Parent.altered这个版本。
3. 第10行我调用了super(Child, self).altered()，这和你过去用过的getattr很相似，不过它还知道你的继承关系，并且会访问到Parent类。这句你可以读作“调用super并且加上Child和self这两个参数，在此返回的基础上然后调用altered ”。
4. 到这里Parent.altered就会被运行，而且打印出了父类里的信息。
5. 最后从Parent.altered返回到Child.altered，函数接着打印出来后面的信息。运行的结果是这样的：
PARENT altered()
CHILD, BEFORE PARENT altered()
PARENT altered()
CHILD, AFTER PARENT altered()

6.合成

继承是一种有用的技术，不过还有一种实现相同功能的方法，就是直接使用别的类和模块，而非依赖于继承

class Other(object):
    def override(self):
        print "OTHER override()"
    def implicit(self):
        print "OTHER implicit()"
    def altered(self):
        print "OTHER altered()"
class Child(object):
    def __init__(self):
        self.other = Other()
    def implicit(self):
        self.other.implicit()
    def override(self):
        print "CHILD override()"
    def altered(self):
        print "CHILD, BEFORE OTHER altered()"
        self.other.altered()
        print "CHILD, AFTER OTHER altered()"
son = Child()
son.implicit()
son.override()
son.altered()