类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象这个类的 实例 。这类似于你有一个int类型的变量，这存储整数的变量是int类的实例（对象）。

继承    ：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。

给C/C++/Java/C#程序员的注释

注意，即便是整数也被作为对象（属于int类）。这和C++、Java（1.5版之前）把整数纯粹作为类型是不同的。通过help(int)了解更多这个类的详情。 C#和Java 1.5程序员会熟悉这个概念，因为它类似与封装与解封装 的概念。

对象可以使用普通的 属于 对象的变量存储数据。属于一个对象或类的变量被称为域。对象也可以使用 属于 类的函数来具有功能。这样的函数被称为类的方法。这些术语帮助我们把它们与孤立的函数和变量区分开来。域和方法可以合称为类的属性。

域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。

类使用class关键字创建。类的域和方法被列在一个缩进块中。

在Python类中定义的方法通常有三种：实例方法、类方法、静态方法。
这三者之间的区别是:

实例方法：一般都以self作为第一个参数，必须和具体的对象实例进行绑定才能访问，
类方法    ：以cls作为第一个参数，cls表示类本身，定义时使用@classmethod，那么通过cls引用的必定是类对象的属性和方法；
静态方法：不需要默认的任何参数，跟一般的普通函数类似.定义的时候使用@staticmethod，静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用。

而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析）

不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。

可以直接在类外通过对象名访问，如果想定义成私有的，则需在前面加2个下划线 ' __'
构造方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法.
构造方法支持重载，如果用户自己没有重新定义构造方法，系统就自动执行默认的构造方法。
析构方法__del__(self)在释放对象时调用，支持重载，可以在里面进行一些释放资源的操作，不需要显示调用。

创建实例对象

要创建一个类的实例，你可以使用类的名称，并通过__init__方法接受参数。
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)

访问属性

使用点(.)来访问对象的属性。使用如下类的名称访问类变量:
emp1.displayEmployee()
你可以添加，删除，修改类的属性，如下所示：
emp1.age = 7 # 添加一个 'age' 属性
emp1.age = 8 # 修改 'age' 属性
del emp1.age # 删除 'age' 属性
getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
delattr(obj, name) : 删除属性。

Python内置类属性

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，
如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）

python对象销毁(垃圾回收)

在Python内部记录着所有使用中的对象各有多少引用。
一个内部跟踪变量，称为一个引用计数器。当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 
也就是说， 这个对象的引用计数变为0 时，它被垃圾回收。但是回收不是"立即"的， 
由解释器在适当的时机，将垃圾对象占用的内存空间回收。

self

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self。

虽然你可以给这个参数任何名称，但是 强烈建议 你使用self这个名称——其他名称都是不赞成你使用的。使用一个标准的名称有很多优点——你的程序读者可以迅速识别它，如果使用self的话，还有些IDE（集成开发环境）也可以帮助你。

给C++/Java/C#程序员的注释
Python中的self等价于C++中的self指针和Java、C#中的this参考。

你一定很奇怪Python如何给self赋值以及为何你不需要给它赋值。举一个例子会使此变得清晰。假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1, arg2)——这就是self的原理了。

这也意味着如果你有一个不需要参数的方法，你还是得给这个方法定义一个self参数。

创建一个类

#!/usr/bin/python
# Filename: simplestclass.py

class Person:
    pass # An empty block

p = Person()
print p
输出
$ python simplestclass.py
<__main__.Person instance at 0xf6fcb18c>

它如何工作

我们使用class语句后跟类名，创建了一个新的类。这后面跟着一个缩进的语句块形成类体。在这个例子中，我们使用了一个空白块，它由pass语句表示。

接下来，我们使用类名后跟一对圆括号来创建一个对象/实例。（我们将在下面的章节中学习更多的如何创建实例的方法）。为了验证，我们简单地打印了这个变量的类型。它告诉我们我们已经在__main__模块中有了一个Person类的实例。

可以注意到存储对象的计算机内存地址也打印了出来。这个地址在你的计算机上会是另外一个值，因为Python可以在任何空位存储对象。

使用对象的方法

#!/usr/bin/python
# Filename: method.py

class Person:
    def sayHi(self):
        print 'Hello, how are you?'

p = Person()
p.sayHi()
# This short example can also be written as Person().sayHi()

输出
$ python method.py
Hello, how are you?

它如何工作

这里我们看到了self的用法。注意sayHi方法没有任何参数，但仍然在函数定义时有self。

__init__方法

在Python的类中有很多方法的名字有特殊的重要意义。现在我们将学习__init__方法的意义。

__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的 初始化 。注意，这个名称的开始和结尾都是双下划线__init__方法

#!/usr/bin/python
# Filename: class_init.py

class Person:
    def __init__(self, name):
        self.name = name
    def sayHi(self):
        print 'Hello, my name is', self.name

p = Person('Swaroop')
p.sayHi()

# This short example can also be written as Person('Swaroop').sayHi()

输出
$ python class_init.py
Hello, my name is Swaroop

它如何工作

这里，我们把__init__方法定义为取一个参数name（以及普通的参数self）。在这个__init__里，我们只是创建一个新的域，也称为name。注意它们是两个不同的变量，尽管它们有相同的名字。点号使我们能够区分它们。

最重要的是，我们没有专门调用__init__方法，只是在创建一个类的新实例的时候，把参数包括在圆括号内跟在类名后面，从而传递给__init__方法。

现在，我们能够在我们的方法中使用self.name域。这在sayHi方法中得到了验证。

给C++/Java/C#程序员的注释
__init__方法类似于C++、C#和Java中的 constructor 。 

类与对象的方法

已经讨论了类与对象的功能部分，现在来看一下它的数据部分。事实上，它们只是与类和对象的名称空间 绑定 的普通变量，即这些名称只在这些类与对象的前提下有效。

有两种类型的 域 ——类的变量和对象的变量，它们根据是类还是对象 拥有 这个变量而区分。

类的变量 由一个类的所有对象（实例）共享使用。只有一个类变量的拷贝，所以当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。

对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。通过一个例子会使这个易于理解。

使用类与对象的变量

#!/usr/bin/python
# Filename: objvar.py

class Person:
    '''Represents a person.'''
    population = 0

    def __init__(self, name):
        '''Initializes the person's data.'''
        self.name = name
        print '(Initializing %s)' % self.name

        # When this person is created, he/she
        # adds to the population
        Person.population += 1

    def __del__(self):
        '''I am dying.'''
        print '%s says bye.' % self.name

        Person.population -= 1

        if Person.population == 0:
            print 'I am the last one.'
        else:
            print 'There are still %d people left.'% Person.population

    def sayHi(self):
        '''Greeting by the person.

        Really, that's all it does.'''
        print 'Hi, my name is %s.' % self.name

    def howMany(self):
        '''Prints the current population.'''
        if Person.population == 1:
            print 'I am the only person here.'
        else:
            print 'We have %d persons here.'% Person.population

swaroop = Person('Swaroop')
swaroop.sayHi()
swaroop.howMany()

kalam = Person('Abdul Kalam')
kalam.sayHi()
kalam.howMany()

swaroop.sayHi()
swaroop.howMany()
输出

$ python objvar.py
(Initializing Swaroop)
Hi, my name is Swaroop.
I am the only person here.
(Initializing Abdul Kalam)
Hi, my name is Abdul Kalam.
We have 2 persons here.
Hi, my name is Swaroop.
We have 2 persons here.
Abdul Kalam says bye.
There are still 1 people left.
Swaroop says bye.
I am the last one.

它如何工作

这里，population属于Person类，因此是一个类的变量。name变量属于对象（它使用self赋值）因此是对象的变量。

观察可以发现__init__方法用一个名字来初始化Person实例。在这个方法中，我们让population增加1，这是因为我们增加了一个人。同样可以发现，self.name的值根据每个对象指定，这表明了它作为对象的变量的本质。

记住，你只能使用self变量来参考同一个对象的变量和方法。这被称为 属性参考 。

在这个程序中，我们还看到docstring对于类和方法同样有用。我们可以在运行时使用Person.__doc__和Person.sayHi.__doc__来分别访问类与方法的文档字符串。

就如同__init__方法一样，还有一个特殊的方法__del__，它在对象消逝的时候被调用。对象消逝即对象不再被使用，它所占用的内存将返回给系统作它用。在这个方法里面，我们只是简单地把Person.population减1。

当对象不再被使用时，__del__方法运行，但很难保证这个方法究竟在 什么时候 运行。如果你想要指明它的运行，你就得使用del语句，就如同以前的例子中使用的那样。

给C++/Java/C#程序员的注释
Python中所有的类成员（包括数据成员）都是 公共的 ，所有的方法都是 有效的 。
只有一个例外：如果你使用的数据成员名称以 双下划线前缀 比如__privatevar，Python的名称管理体系会有效地把它作为私有变量。
这样就有一个惯例，如果某个变量只想在类或对象中使用，就应该以单下划线前缀。而其他的名称都将作为公共的，可以被其他类/对象使用。记住这只是一个惯例，并不是Python所要求的（与双下划线前缀不同）。
同样，注意__del__方法与 destructor 的概念类似。 

继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过 继承 机制。继承完全可以理解成类之间的类型和子类型 关系。

假设你想要写一个程序来记录学校之中的教师和学生情况。他们有一些共同属性，比如姓名、年龄和地址。他们也有专有的属性，比如教师的薪水、课程和假期，学生的成绩和学费。

你可以为教师和学生建立两个独立的类来处理它们，但是这样做的话，如果要增加一个新的共有属性，就意味着要在这两个独立的类中都增加这个属性。这很快就会显得不实用。

一个比较好的方法是创建一个共同的类称为SchoolMember然后让教师和学生的类 继承 这个共同的类。即它们都是这个类型（类）的子类型，然后我们再为这些子类型添加专有的属性。

使用这种方法有很多优点。如果我们增加/改变了SchoolMember中的任何功能，它会自动地反映到子类型之中。例如，你要为教师和学生都增加一个新的身份证域，那么你只需简单地把它加到SchoolMember类中。然而，在一个子类型之中做的改动不会影响到别的子类型。另外一个优点是你可以把教师和学生对象都作为SchoolMember对象来使用，这在某些场合特别有用，比如统计学校成员的人数。一个子类型在任何需要父类型的场合可以被替换成父类型，即对象可以被视作是父类的实例，这种现象被称为多态现象。

另外，我们会发现在 重用 父类的代码的时候，我们无需在不同的类中重复它。而如果我们使用独立的类的话，我们就不得不这么做了。

在上述的场合中，SchoolMember类被称为 基本类 或 超类 。而Teacher和Student类被称为导出类 或子类 。

现在，我们将学习一个例子程序。

使用继承

#!/usr/bin/python
# Filename: inherit.py

class SchoolMember:
  '''Represents any school member.'''
  def __init__(self, name, age):
    self.name = name
    self.age = age
    print '(Initialized SchoolMember: %s)'% self.name

  def tell(self):
    '''Tell my details.'''
    print 'Name:"%s" Age:"%s"' % (self.name, self.age),

class Teacher(SchoolMember):
  '''Represents a teacher.'''
  def __init__(self, name, age, salary):
    SchoolMember.__init__(self, name, age)
    self.salary = salary
    print '(Initialized Teacher: %s)'% self.name

  def tell(self):
    SchoolMember.tell(self)
    print 'Salary: "%d"' % self.salary

class Student(SchoolMember):
  '''Represents a student.'''
  def __init__(self, name, age, marks):
    SchoolMember.__init__(self, name, age)
    self.marks = marks
    print '(Initialized Student: %s)'% self.name

  def tell(self):
    SchoolMember.tell(self)
    print 'Marks: "%d"' % self.marks

t = Teacher('Mrs. Shrividya', 40,30000)
s = Student('Swaroop', 22,75)

print # prints a blank line

members = [t, s]
for member in members:
  member.tell() # works for both Teachers and Students

输出
$ python inherit.py
(Initialized SchoolMember: Mrs. Shrividya)
(Initialized Teacher: Mrs. Shrividya)
(Initialized SchoolMember: Swaroop)
(Initialized Student: Swaroop)

Name:"Mrs. Shrividya" Age:"40" Salary: "30000"
Name:"Swaroop" Age:"22" Marks: "75"

它如何工作

为了使用继承，我们把基本类的名称作为一个元组跟在定义类时的类名称之后。然后，我们注意到基本类的__init__方法专门使用self变量调用，这样我们就可以初始化对象的基本类部分。这一点十分重要——Python不会自动调用基本类的constructor，你得亲自专门调用它。

我们还观察到我们在方法调用之前加上类名称前缀，然后把self变量及其他参数传递给它。

注意，在我们使用SchoolMember类的tell方法的时候，我们把Teacher和Student的实例仅仅作为SchoolMember的实例。

另外，在这个例子中，我们调用了子类型的tell方法，而不是SchoolMember类的tell方法。可以这样来理解，Python总是首先查找对应类型的方法，在这个例子中就是如此。如果它不能在导出类中找到对应的方法，它才开始到基本类中逐个查找。基本类是在类定义的时候，在元组之中指明的。

一个术语的注释——如果在继承元组中列了一个以上的类，那么它就被称作 多重继承 。

1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。
   （先在本类中查找调用的方法，找不到才去基类中找）。 如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

#coding=utf-8
#!/usr/bin/python
class Parent: # 定义父类
    parentAttr = 100
    def __init__(self):
        print "调用父类构造函数"
    def parentMethod(self):
        print '调用父类方法'
    def setAttr(self, attr):
        Parent.parentAttr = attr
    def getAttr(self):
        print "父类属性 :", Parent.parentAttr
        
class Child(Parent): # 定义子类
    def __init__(self):
        print "调用子类构造方法"
    def childMethod(self):
        print '调用子类方法 child method'
        
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法
c.getAttr() # 再次调用父类的方法

调用子类构造方法
调用子类方法 child method
调用父类方法
父类属性 : 200

#coding=utf-8
#!/usr/bin/python
class Parent: # 定义父类
    def myMethod(self):
        print '调用父类方法'
        
class Child(Parent): # 定义子类
def myMethod(self):
    print '调用子类方法'
    
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法

调用子类方法
基础重载方法

#!/usr/bin/python
class Vector:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __str__(self):
        return 'Vector (%d, %d)' % (self.a, self.b)
    def __add__(self,other):
        return Vector(self.a + other.a, self.b + other.b)


v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2
以上代码执行结果如下所示:
Vector(7,8)

#coding=utf-8
#!/usr/bin/python
class JustCounter:
    __secretCount = 0 # 私有变量
    publicCount = 0 # 公开变量
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print self.__secretCount
        
counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount # 报错，实例不能访问私有变量

　抽象是隐藏多余细节的艺术。在面向对象的概念中，抽象的直接表现形式通常为类。虽然Python是解释性语言，但是它是面向对象的，从设计之初就已经是一门面向对象的语言。Python基本上提供了面向对象编程语言的所有元素，如果你已经至少掌握了一门面向对象语言，那么利用Python进行面向对象程序设计将会相当容易。下面就来了解一下如何在Python中进行对象编程。

一. 如何定义一个类

　　在进行python面向对象编程之前，先来了解几个术语：类，类对象，实例对象，属性，函数和方法。

　　类是对现实世界中一些事物的封装，定义一个类可以采用下面的方式来定义：

[python] view plain copy  

1. class className:  
2.     block  

[python] view plain copy  

1. class people:  
2.     name = 'jack'       #定义了一个属性  
3.     #定义了一个方法  
4.     def printName(self):  
5.         print self.name  

　　people类定义完成之后就产生了一个全局的类对象，可以通过类对象来访问类中的属性和方法了。当通过people.name（至于为什么可以直接这样访问属性后面再解释，这里只要理解类对象这个概念就行了）来访问时，people.name中的people称为类对象，这点和C++中的有所不同。当然还可以进行实例化操作，p=people( )，这样就产生了一个people的实例对象，此时也可以通过实例对象p来访问属性或者方法了(p.name).

　　理解了类、类对象和实例对象的区别之后，我们来了解一下Python中属性、方法和函数的区别。

　　在上面代码中注释的很清楚了，name是一个属性，printName( )是一个方法，与某个对象进行绑定的函数称作为方法。一般在类里面定义的函数与类对象或者实例对象绑定了，所以称作为方法；而在类外定义的函数一般没有同对象进行绑定，就称为函数。

二. 属性

　　在类中我们可以定义一些属性，比如：

[python] view plain copy  

1. class people:  
2.     name = 'jack'  
3.     age = 12  
4.   
5. p = people()  
6. print p.name,p.age  

[python] view plain copy  

1. class people:  
2.     __name = 'jack'  
3.     __age = 12  
4.   
5. p = people()  
6. print p.__name,p.__age  

[plain] view plain copy  

1. Traceback (most recent call last):  
2.   File "C:/PycharmProjects/FirstProject/oop.py", line 6, in <module>  
3.     print p.__name,p.__age  
4. AttributeError: people instance has no attribute '__name  

　　提示找不到该属性，因为私有属性是不能够在类外通过对象名来进行访问的。在Python中没有像C++中public和private这些关键字来区别公有属性和私有属性，它是以属性命名方式来区分，如果在属性名前面加了2个下划线'__'，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。

三. 方法

　　在类中可以根据需要定义一些方法，定义方法采用def关键字，在类中定义的方法至少会有一个参数，，一般以名为'self'的变量作为该参数（用其他名称也可以），而且需要作为第一个参数。下面看个例子：

[python] view plain copy  

1. class people:  
2.     __name = 'jack'  
3.     __age = 12  
4.   
5.     def getName(self):  
6.         return self.__name  
7.     def getAge(self):  
8.         return self.__age  
9.   
10. p = people()  
11. print p.getName(),p.getAge()  

　　如果对self不好理解的话，可以把它当做C++中类里面的this指针一样理解，就是对象自身的意思，在用某个对象调用该方法时，就将该对象作为第一个参数传递给self。

四. 类中内置的方法

　　在Python中有一些内置的方法，这些方法命名都有比较特殊的地方（其方法名以2个下划线开始然后以2个下划线结束）。类中最常用的就是构造方法和析构方法。

　　构造方法__init__(self,....)：在生成对象时调用，可以用来进行一些初始化操作，不需要显示去调用，系统会默认去执行。构造方法支持重载，如果用户自己没有重新定义构造方法，系统就自动执行默认的构造方法。

　　析构方法__del__(self)：在释放对象时调用，支持重载，可以在里面进行一些释放资源的操作，不需要显示调用。

　　还有其他的一些内置方法，比如 __cmp__( ), __len( )__等。下面是常用的内置方法：

[python] view plain copy  

1. # Filename: class_init.py  
2. class Person:  
3.     def __init__(self, name):  
4.         self.name = name  
5.     def sayHi(self):  
6.         print 'Hello, my name is', self.name  
7.   
8. p = Person('Swaroop')  
9. p.sayHi()  
10.   
11. 输出：  
12. Hello, my name is Swaroop  

[python] view plain copy  

1. # -*- coding: UTF-8 -*-  
2.   
3. class Singleton(object):  
4.     __instance = None                       # 定义实例  
5.   
6.     def __init__(self):  
7.         pass  
8.   
9.     def __new__(cls, *args, **kwd):         # 在__init__之前调用  
10.         if Singleton.__instance is None:    # 生成唯一实例  
11.             Singleton.__instance = object.__new__(cls, *args, **kwd)  
12.         return Singleton.__instance  

[python] view plain copy  

1. # -*- coding: UTF-8 -*-  
2.   
3. class Fruit(object):  
4.     def __init__(self, color="red", price=0):  
5.         self.__color = color  
6.         self.__price = price  
7.   
8.     def __getattribute__(self, item):              # <span style="font-family:宋体;font-size:12px;">获取属性的方法</span>  
9.         return object.__getattribute__(self, item)  
10.   
11.     def __setattr__(self, key, value):  
12.         self.__dict__[key] = value  
13.   
14. if __name__ == "__main__":  
15.     fruit = Fruit("blue", 10)  
16.     print fruit.__dict__.get("_Fruit__color")    # <span style="font-family:宋体;font-size:12px;">获取color属性</span>  
17.     fruit.__dict__["_Fruit__price"] = 5  
18.     print fruit.__dict__.get("_Fruit__price")    # <span style="font-family:宋体;font-size:12px;">获取price属性</span>  

　　Python不允许实例化的类访问私有数据，但你可以使用object._className__attrName访问这些私有属性。

　　__getitem__():如果类把某个属性定义为序列，可以使用__getitem__()输出序列属性中的某个元素.假设水果店中销售多钟水果，可以通过__getitem__()方法获取水果店中的没种水果。代码例子：

[python] view plain copy  

1. # -*- coding: UTF-8 -*-  
2.   
3. class FruitShop:  
4.      def __getitem__(self, i):      # 获取水果店的水果  
5.          return self.fruits[i]        
6.   
7. if __name__ == "__main__":  
8.     shop = FruitShop()  
9.     shop.fruits = ["apple", "banana"]  
10.     print shop[1]  
11.     for item in shop:               # 输出水果店的水果  
12.         print item,  

[plain] view plain copy  

1. banana  
2. apple banana  

[python] view plain copy  

1. # -*- coding: UTF-8 -*-  
2.   
3. class Fruit:       
4.     '''''Fruit类'''               #为Fruit类定义了文档字符串  
5.     def __str__(self):          # 定义对象的字符串表示  
6.         return self.__doc__  
7.   
8. if __name__ == "__main__":  
9.     fruit = Fruit()  
10.     print str(fruit)            # 调用内置函数str()触发__str__()方法，输出结果为:Fruit类  
11.     print fruit                 #直接输出对象fruit,返回__str__()方法的值，输出结果为:Fruit类  

[python] view plain copy  

1. # -*- coding: UTF-8 -*-  
2.   
3. class Fruit:  
4.     class Growth:        # 内部类  
5.         def __call__(self):  
6.             print "grow ..."  
7.   
8.     grow = Growth()      # 调用Growth()，此时将类Growth作为函数返回,即为外部类Fruit定义方法grow(),grow()将执行__call__()内的代码  
9. if __name__ == '__main__':  
10.     fruit = Fruit()  
11.     fruit.grow()         # 输出结果：grow ...  
12.     Fruit.grow()         # 输出结果：grow ...  

五. 类属性、实例属性、类方法、实例方法以及静态方法

　　在了解了类基本的东西之后，下面看一下python中这几个概念的区别。

　　先来谈一下类属性和实例属性

　　在前面的例子中我们接触到的就是类属性，顾名思义，类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本，这个和C++中类的静态成员变量有点类似。对于公有的类属性，在类外可以通过类对象和实例对象访问。

[python] view plain copy  

1. class people:  
2.     name = 'jack'  #公有的类属性  
3.     __age = 12     #私有的类属性  
4.   
5. p = people()  
6.   
7. print p.name             #正确  
8. print people.name        #正确  
9. print p.__age            #错误，不能在类外通过实例对象访问私有的类属性  
10. print people.__age       #错误，不能在类外通过类对象访问私有的类属性  

[python] view plain copy  

1. class people:  
2.     name = 'jack'  
3.   
4. p = people()  
5. p.age =12  
6. print p.name    #正确  
7. print p.age     #正确  
8.   
9. print people.name    #正确  
10. print people.age     #错误  

[python] view plain copy  

1. class people:  
2.     name = 'jack'  
3.       
4.     #__init__()是内置的构造方法，在实例化对象时自动调用  
5.     def __init__(self,age):  
6.         self.age = age  
7.   
8. p = people(12)  
9. print p.name    #正确  
10. print p.age     #正确  
11.   
12. print people.name    #正确  
13. print people.age     #错误  

[python] view plain copy  

1. class people:  
2.     country = 'china'  
3.       
4.   
5. print people.country  
6. p = people()  
7. print p.country  
8. p.country = 'japan'   
9. print p.country      #实例属性会屏蔽掉同名的类属性  
10. print people.country  
11. del p.country    #删除实例属性  
12. print p.country  

　　下面来看一下类方法、实例方法和静态方法的区别。

　　类方法：是类对象所拥有的方法，需要用修饰器"@classmethod"来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以"cls"作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以'cls'作为第一个参数的名字，就最好用'cls'了），能够通过实例对象和类对象去访问。

[python] view plain copy  

1. class people:  
2.     country = 'china'  
3.       
4.     #类方法，用classmethod来进行修饰  
5.     @classmethod  
6.     def getCountry(cls):  
7.         return cls.country  
8.   
9. p = people()  
10. print p.getCountry()    #可以用过实例对象引用  
11. print people.getCountry()    #可以通过类对象引用  

　　类方法还有一个用途就是可以对类属性进行修改：

[python] view plain copy  

1. class people:  
2.     country = 'china'  
3.       
4.     #类方法，用classmethod来进行修饰  
5.     @classmethod  
6.     def getCountry(cls):  
7.         return cls.country  
8.          
9.     @classmethod  
10.     def setCountry(cls,country):  
11.         cls.country = country  
12.           
13.   
14. p = people()  
15. print p.getCountry()    #可以用过实例对象引用  
16. print people.getCountry()    #可以通过类对象引用  
17.   
18. p.setCountry('japan')     
19.   
20. print p.getCountry()     
21. print people.getCountry()  

[plain] view plain copy  

1. china  
2. china  
3. japan  
4. japan  

　　结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变。

　　实例方法：在类中最常定义的成员方法，它至少有一个参数并且必须以实例对象作为其第一个参数，一般以名为'self'的变量作为第一个参数（当然可以以其他名称的变量作为第一个参数）。在类外实例方法只能通过实例对象去调用，不能通过其他方式去调用。

[python] view plain copy  

1. class people:  
2.     country = 'china'  
3.       
4.     #实例方法  
5.     def getCountry(self):  
6.         return self.country  
7.           
8.   
9. p = people()  
10. print p.getCountry()         #正确，可以用过实例对象引用  
11. print people.getCountry()    #错误，不能通过类对象引用实例方法  

[python] view plain copy  

1. class people:  
2.     country = 'china'  
3.      
4.     @staticmethod  
5.     #静态方法  
6.     def getCountry():  
7.         return people.country  
8.           
9.   
10. print people.getCountry()  

　　对于类属性和实例属性，如果在类方法中引用某个属性，该属性必定是类属性，而如果在实例方法中引用某个属性（不作更改），并且存在同名的类属性，此时若实例对象有该名称的实例属性，则实例属性会屏蔽类属性，即引用的是实例属性，若实例对象没有该名称的实例属性，则引用的是类属性；如果在实例方法更改某个属性，并且存在同名的类属性，此时若实例对象有该名称的实例属性，则修改的是实例属性，若实例对象没有该名称的实例属性，则会创建一个同名称的实例属性。想要修改类属性，如果在类外，可以通过类对象修改，如果在类里面，只有在类方法中进行修改。

　　从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用。

六. 继承和多重继承

　　上面谈到了类的基本定义和使用方法，这只体现了面向对象编程的三大特点之一：封装。下面就来了解一下另外两大特征：继承和多态。

　　在Python中，如果需要的话，可以让一个类去继承一个类，被继承的类称为父类或者超类、也可以称作基类，继承的类称为子类。并且Python支持多继承，能够让一个子类有多个父类。

　　Python中类的继承定义基本形式如下：

[python] view plain copy  

1. #父类  
2. class superClassName:  
3.     block  
4.   
5. #子类  
6. class subClassName(superClassName):  
7.     block  

[python] view plain copy  

1. # -*- coding: UTF-8 -*-  
2.   
3. class UniversityMember:  
4.   
5.     def __init__(self,name,age):  
6.         self.name = name  
7.         self.age = age  
8.   
9.     def getName(self):  
10.         return self.name  
11.   
12.     def getAge(self):  
13.         return self.age  
14.   
15. class Student(UniversityMember):  
16.   
17.     def __init__(self,name,age,sno,mark):  
18.         UniversityMember.__init__(self,name,age)     #注意要显示调用父类构造方法，并传递参数self  
19.         self.sno = sno  
20.         self.mark = mark  
21.   
22.     def getSno(self):  
23.         return self.sno  
24.   
25.     def getMark(self):  
26.         return self.mark  
27.   
28.   
29.   
30. class Teacher(UniversityMember):  
31.   
32.     def __init__(self,name,age,tno,salary):  
33.         UniversityMember.__init__(self,name,age)  
34.         self.tno = tno  
35.         self.salary = salary  
36.   
37.     def getTno(self):  
38.         return self.tno  
39.   
40.     def getSalary(self):  
41.         return self.salary  

　　在大学中的每个成员都有姓名和年龄，而学生有学号和分数这2个属性，老师有教工号和工资这2个属性，从上面的代码中可以看到：

　　1）在Python中，如果父类和子类都重新定义了构造方法__init( )__，在进行子类实例化的时候，子类的构造方法不会自动调用父类的构造方法，必须在子类中显示调用。

　　2）如果需要在子类中调用父类的方法，需要以”父类名.方法“这种方式调用，以这种方式调用的时候，注意要传递self参数过去。

　　对于继承关系，子类继承了父类所有的公有属性和方法，可以在子类中通过父类名来调用，而对于私有的属性和方法，子类是不进行继承的，因此在子类中是无法通过父类名来访问的。

　　Python支持多重继承。对于多重继承，比如

　　class SubClass(SuperClass1,SuperClass2)

　　此时有一个问题就是如果SubClass没有重新定义构造方法，它会自动调用哪个父类的构造方法？这里记住一点：以第一个父类为中心。如果SubClass重新定义了构造方法，需要显示去调用父类的构造方法，此时调用哪个父类的构造方法由你自己决定；若SubClass没有重新定义构造方法，则只会执行第一个父类的构造方法。并且若SuperClass1和SuperClass2中有同名的方法，通过子类的实例化对象去调用该方法时调用的是第一个父类中的方法。

七. 多态

　　多态即多种形态，在运行时确定其状态，在编译阶段无法确定其类型，这就是多态。Python中的多态和Java以及C++中的多态有点不同，Python中的变量是弱类型的，在定义时不用指明其类型，它会根据需要在运行时确定变量的类型（个人觉得这也是多态的一种体现），并且Python本身是一种解释性语言，不进行预编译，因此它就只在运行时确定其状态，故也有人说Python是一种多态语言。在Python中很多地方都可以体现多态的特性，比如内置函数len(object)，len函数不仅可以计算字符串的长度，还可以计算列表、元组等对象中的数据个数，这里在运行时通过参数类型确定其具体的计算过程，正是多态的一种体现。这有点类似于函数重载（一个编译单元中有多个同名函数，但参数不同），相当于为每种类型都定义了一个len函数。这是典型的多态表现。有些朋友提出Python不支持多态，我是完全不赞同的。

　　本质上，多态意味着可以对不同的对象使用同样的操作，但它们可能会以多种形态呈现出结果。len(object)函数就体现了这一点。在C++、Java、C#这种编译型语言中，由于有编译过程，因此就鲜明地分成了运行时多态和编译时多态。运行时多态是指允许父类指针或名称来引用子类对象，或对象方法，而实际调用的方法为对象的类类型方法，这就是所谓的动态绑定。编译时多态有模板或范型、方法重载（overload）、方法重写（override）等。而Python是动态语言，动态地确定类型信息恰恰体现了多态的特征。在Python中，任何不知道对象到底是什么类型，但又需要对象做点什么的时候，都会用到多态。

[python] view plain copy  

1. # -*- coding: UTF-8 -*-  
2.   
3. _metaclass_=type # 确定使用新式类  
4. class calculator:  
5.     
6.     def count(self,args):  
7.         return 1  
8.   
9. calc=calculator() #自定义类型  
10.   
11. from random import choice  
12. obj=choice(['hello,world',[1,2,3],calc]) #obj是随机返回的 类型不确定  
13. print type(obj)  
14. print obj.count('a') #方法多态  

　　对于一个临时对象obj，它通过Python的随机函数取出来，不知道具体类型（是字符串、元组还是自定义类型），都可以调用count方法进行计算，至于count由谁（哪种类型）去做怎么去实现我们并不关心。

　　有一种称为”鸭子类型（duck typing）“的东西，讲的也是多态：

[python] view plain copy  

1. _metaclass_=type # 确定使用新式类  
2. class Duck:  
3.     def quack(self):   
4.         print "Quaaaaaack!"  
5.     def feathers(self):   
6.         print "The duck has white and gray feathers."  
7.    
8. class Person:  
9.     def quack(self):  
10.         print "The person imitates a duck."  
11.     def feathers(self):   
12.         print "The person takes a feather from the ground and shows it."  
13.    
14. def in_the_forest(duck):  
15.     duck.quack()  
16.     duck.feathers()  
17.    
18. def game():  
19.     donald = Duck()  
20.     john = Person()  
21.     in_the_forest(donald)  
22.     in_the_forest(john)  
23.    
24. game()  

[python] view plain copy  

1. def add(x,y):  
2.     return x+y  
3.   
4. print add(1,2) #输出3  
5.   
6. print add("hello,","world") #输出hello,world  
7.   
8. print add(1,"abc") #抛出异常 TypeError: unsupported operand type(s) for +: 'int' and 'str'  

[python] view plain copy  

1. class Vector:  
2.    def __init__(self, a, b):  
3.       self.a = a  
4.       self.b = b  
5.   
6.    def __str__(self):  
7.       return 'Vector (%d, %d)' % (self.a, self.b)  
8.      
9.    def __add__(self,other):  
10.       return Vector(self.a + other.a, self.b + other.b)  
11.   
12. v1 = Vector(2,10)  
13. v2 = Vector(5,-2)  
14. print v1 + v2  

参考文献：

http://www.cnblogs.com/dolphin0520/archive/2013/03/29/2986924.html

http://www.cnblogs.com/jeffwongishandsome/archive/2012/10/06/2713258.html