博客园的博文对每篇博文的长度似乎做了限制
面向对象编程，
在程序何种，根据操作数据的函数或语句块来设计程序。这被成为面向过程的编程。还有一种把数据和功能结合起来，用称为对象的东西包裹起来组织组织程序的额方法。这种方法称为面向对象的编程理念。
类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象是这个类的实例。这类似于你有一个int的变量，这纯属整数的变量是int类的实例(对象)
对象可以使用普通的属于对象的变量存储数据。属于一个对象或累i的变量称为域。对象可以使用属于类的函数来具有功能。这样的函数被称为类的方法。这些属于帮助我们把它们与鼓励的函数和变量区分开来。域和方法可以合成为类的属性。
域有两种类型---属于每个实例/类的对象或属于类本身。它们分别被成为实例变量和类变量。
类使用class关键字创建。类的域和方法被列在一个缩进块中。
self
类的方法于普通的函数只有一个特别的区别---他们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，python会提供这个值。这个特别的便利指对象本身，按照惯例它的名称是self.
虽然你可以给这个参数任何名称，但是强烈建议你使用self这个名称---其它名称都是不赞成使用的。使用一个标准的名称有很多优点-IDE和读者会容易识别
你一定很奇怪 python如何给self赋值以及为何你不需要给他赋值。举一个例子会使此变得清晰。假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method（arg1,arg2）的时候，这会由python自动转化为MyClass.method(MyObject,arg1,arg2)--这就是self的原理了。
这也意味着如果你有一个不需要参数的方法，你还是得给这个方法定义一个self参数。
class Person:
pass
p=Person()
print p
输出：
$ python simplestclass.py
<__main__.Person instance at 0xf6fcb18c>
我们使用class语句后跟类名，创建了一个新的类。这后面跟着一个缩进的语句块形成类体。在这个例子中，我们使用了一个空白块，它由pass语句表示。
接下来，我们使用类名后跟一对圆括号来创建一个对象/实例。
为了验证，我们简单地打印了这个变量的类型，它告诉我们在__main__模块中有了一个Person类的实例。
可以注意到存储对象的计算机内存地址也打印了出来。这个地址在你的计算机上会是另外一个只，因为python可以在任何空位存储对象。
对象的方法
我们已经讨论了类/对象可以拥有像函数一样的方法，这些方法与函数的区别只是一个额外的sel变量。
class Person:
def sayHi(self):
print 'hello '
p=Person()
p.sayHi()
输出：
$ python method.py
Hello, how are you?
这里我们看到了self的用法，注意sayHi方法没有任何参数，但仍然在函数定义时有self
__init__方法
在python的类中有很多方法的名字有特殊的重要意义。
__init__方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化。注意，这个名称的开始和结尾都是双下划线。
class Person:
def sayHi(self):
print 'hello,my name is ',self.name
def __init__(self,name):
self.name=name
p=Person('swaroop')
p.sayHi()
输出：
$ python class_init.py
Hello, my name is Swaroop
这里，我们把__init__方法定义为取一个参数name（以及普通的参数self）。在这个__init__里，我们只是创建一个新的域，也称为name.注意它们是两个不同的变量，尽管它们有相同的名字。点号能够使我们区分它们。
最重要的是，我们没有专门调用__inti__方法，只是在创建一个类的新实例的时候，把参数包括在圆括号内跟在类名后面，从而传递给__init__方法。
其实__init__就是构造函数
类与对象的方法
事实上，数据部分只是类和对象的名称空间绑定的普通变量，即这些名称只在这些类与对象的前提下有效。
有两种类型的域--类的变量和对象的变量，它们是根据是类还是对象拥有这个变量而区分。
类的变量由一个类的所有对象(实例）共享使用。只有一个类变量的拷贝，所以当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。
对象的变量由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。
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语句，
当在python中，你使用的数据成员名称以双下划线前缀如__privatevar,python的名称管理体系才会有效地把它作为私有变量。
这样就有一个管理，如果某个变量只想在类或对象中使用，就应该以单下划线前缀。而其他的名称都是公共的，可以被其他类/对象使用。
继承
面向对象编程带来的好处之一就是代码的重用，实现这种重用的方法之一就是通过继承机制。继承可以理解成类之间的类型和子类型关心。
假设你想要写一个程序来记录学校之中的教师和学生情况。他们有一些共同属性，比如姓名、年龄和地址。他们也有专有的属性，比如教师的薪水、课程和假期，学生的成绩和学费。
你可以为教师和学生建立两个独立的类来处理它们，但是这样做的话，如果要增加一个新的共有属性，就意味着要在这两个独立的类中都增加这个属性。这很快就会显得不实用。
一个比较好的方法是创建一个共同的类称为SchoolMember然后让教师和学生的类 继承 这个共同的类。即它们都是这个类型（类）的子类型，然后我们再为这些子类型添加专有的属性。
使用这种方法有很多优点。如果我们增加/改变了SchoolMember中的任何功能，它会自动地反映到子类型之中。例如，你要为教师和学生都增加一个新的身份证域，那么你只需简单地把它加到SchoolMember类中。然而，在一个子类型之中做的改动不会影响到别的子类型。另外一个优点是你可以把教师和学生对象都作为SchoolMember对象来使用，这在某些场合特别有用，比如统计学校成员的人数。一个子类型在任何需要父类型的场合可以被替换成父类型，即对象可以被视作是父类的实例，这种现象被称为多态现象。
另外，我们会发现在 重用 父类的代码的时候，我们无需在不同的类中重复它。而如果我们使用独立的类的话，我们就不得不这么做了。
在上述的场合中，SchoolMember类被称为 基本类 或 超类 。而Teacher和Student类被称为 导出类 或 子类 。
现在，我们将学习一个例子程序。
class SchoolMember:
'''represents any school member.'''
def __init__(self,name,age):
self.name=name
self.age=age
print '(Initalized 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 '(Initalized Student:%s)' %self.name
def tell(self):
SchoolMember.tell(self)
print 'Marks:"%d:' %self.marks
t=Teacher('Mrs.Shrividya',40,30000)
s=Student('Swarrop',22,75)
members=[t,s]
for member in members:
member.tell()
输出：
$ 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总是首先查找对应类型的方法，在这个例子中就是如此。如果它不能在到导出类中找到对应的方法，它才开始到基本类中逐个查找。基本类是在类定义的时候，在元组之中指明的。
一个属于的解释，如果在继承元组中列了一个以上的类，那么它就叫做多重继承。