python面向对象的编程

    学过C＋＋的肯定对面向对象不陌生，面向对象就是一种把数据和功能结合起来,用称为对象的东西包裹起来组织程序的方法。python也是面向对象的语言，专业点的说法是OO，虽然，你完全可以不用这一性质，也能编写出程序。
    python中的类与C＋＋中的类非常的相似。

    类使用class关键字创建。类的域和方法被列在一个缩进块中。
    class name(parent1[,parent2...]):
         def method1(self,args):
                    ....

1.self
    类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称,但是在调用这个方法的时候你不为这个参数赋值,Python会提供这个值。这个特别的变量指对象本身,按照惯例它的名称是self。
    虽然你可以给这个参数任何名称,但是强烈建议你使用self这个名称——其他名称都是不赞成你使用的。使用一个标准的名称有很多优点——你的程序读者可以迅速识别它,如果使用self的话,还有些IDE(集成开发环境)也可以帮助你。其实Python中的self就等价于C++中的this指针。
    你一定很奇怪Python如何给self赋值以及为何你不需要给它赋值。举一个例子会使此变得清晰。假如你有一个类称为MyClass和这个类的一个实例MyObject。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候,这会由Python自动转为MyClass.method(MyObject, arg1,arg2)——这就是self的原理了。这也意味着如果你有一个不需要参数的方法,你还是得给这个方法定义一个self参数。
 
2.类
     一个尽可能简单的类如下面这个例子所示。

例 创建一个类
#!/usr/bin/python
# Filename: simplestclass.py
class Person:
   pass # An empty block
p = Person()
print p
输出
$ python simplestclass.py
<__main__.Person instance at 0xf6fcb18c>

 
3.对象的方法
   我们已经讨论了类/对象可以拥有像函数一样的方法,这些方法与函数的区别只是一个额外的self变量。现在我们来学习一个例子。

例 使用对象的方法
#!/usr/bin/python
# Filename: method.py
class Person:
  def sayHi(self):
     print 'Hello, world'
p = Person()
p.sayHi()

输出
$ python method.py
Hello, world

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

4.__init__方法
   在Python的类中有很多方法的名字有特殊的重要意义。现在我们将学习__init__方法的意义。__init__方法类似于C++中的构造函数。__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

5.__del__方法
    python的类中有一个方法类似于C＋＋中的析构函数，这便是__del__方法。__del__方法在类的一个对象被销毁时运行。
   
6.类与对象的方法
   我们已经讨论了类与对象的功能部分,现在我们来看一下它的数据部分。事实上,它们只是与类和对象的名称空间绑定的普通变量,即这些名称只在这些类与对象的前提下有效。
   有两种类型的域 ——类的变量和对象的变量,它们根据是类还是对象拥有这个变量而区分。
   类的变量由一个类的所有对象(实例)共享使用。只有一个类变量的拷贝,所以当某个对象对类的变量做了改动的时候,这个改动会反映到所有其他的实例上。
   对象的变量由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝,即它们不是共享的,在同一个类的不同实例中,虽然对象的变量有相同的名称,但是是互不相关的。通过一个例子会使这个易于理解。

例 使用类与对象的变量
#!/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.

   Python中所有的类成员(包括数据成员)都是公共的 ,所有的方法都是有效的 。只有一个例外:如果你使用的数据成员名称以 双下划线前缀 比如__privatevar,Python的名称管理体系会有效地把它作为私有变量。这样就有一个惯例,如果某个变量只想在类或对象中使用,就应该以单下划线前缀。而其他的名称都将作为公共的,可以被其他类/对象使用。记住这只是一个惯例,并不是Python所要求的(与双下划线前缀不同)。

 
7.继承
    面向对象的编程带来的主要好处之一是代码的重用,实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。假设你想要写一个程序来记录学校之中的教师和学生情况。他们有一些共同属性,比如姓名、年龄和地址。他们也有专有的属性,比如教师的薪水、课程和假期,学生的成绩和学费。你可以为教师和学生建立两个独立的类来处理它们,但是这样做的话,如果要增加一个新的共有属性,就意味着要在这两个独立的类中都增加这个属性。这很快就会显得不实用。
    一个比较好的方法是创建一个共同的类称为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"

    这里只是介绍了python面向对象的冰山一角，如若想了解更多的关于python OO方面的知识，可以多查阅写资料。