面向对象编程

self

类方法与普通函数只有一种特定的区别----前者必须有一个额外的名字，这个名字必须添加到参数列表的开头，但是你不用再调用这个功能时为这个参数赋值
按照惯例，它被赋予self这一名称

Sample Code：

  class Person:
  def say_hi(self):
      print('say hi!!!');
  p = Person();
  p.say_hi();

init方法

会在类的对象被实例化时立即执行
Sample Code：

    class Person:
        def __init__(self,name):
            self.name = name;
        def say_hi(self):
            print('say hi!!! to',self.name);
    p = Person("endian11");
    p.say_hi();

类变量与对象变量

数据部分也就是字段，只不过是绑定到类与对象的命名空间。这就代表着这些名称仅在这些类与对象所存在的上下文中有效
字段有两种类型
- 类变量
  - 类变量是共享的，它可以被属于该类的所有实例访问
- 对象变量
  - 由类的每一个独立的对象或实例所拥有

Sample Code

class Robert:
    """表示有个带有名字的机器人."""
    population = 0;#一个类变量，用来计数机器人的数量
    def __init__(self,name):
        '''初始化数据'''
        self.name = name;
        print("(Initializing {})".format(self.name));
        Robert.population +=1;
    def die(self):
        '''我挂了。。'''
        print('{} is beging destroyed!'.format(self.name));
        Robert.population -=1;
        if Robert.population ==0:
            print('{} was the last one.'.format(self.name));
        else:
            print("There are still {:d} roberts working.".format(Robert.population));
    def say_hi(self):
        '''来自机器人的诚挚问候
        
        没问题，你做的到。'''
        print("Greetings, my masters call me {}.".format(self.name));
    @classmethod
    def how_many(cls):
        '''打印出当前的人口数量'''
        print("We have {:d} robots.".format(cls.population));
        
droid1 = Robert("R2-D2");
print(droid1.__init__.__doc__);
droid1.say_hi();
Robert.how_many();
droid2 = Robert("c-3P0");
droid2.say_hi();
Robert.how_many();
print("\nRobots can do some work here.\n");
print("Robots have finished their work,so let us  destroy them");
droid1.die();
droid2.die();
Robert.how_many();

运行结果：

  (Initializing R2-D2)
  初始化数据
  Greetings, my masters call me R2-D2.
  We have 1 robots.
  (Initializing c-3P0)
  Greetings, my masters call me c-3P0.
  We have 2 robots.
  
  Robots can do some work here.
  
  Robots have finished their work,so let us  destroy them
  R2-D2 is beging destroyed!
  There are still 1 roberts working.
  c-3P0 is beging destroyed!
  c-3P0 was the last one.
  We have 0 robots.

继承

面向对象编程的一大优点是对代码的重用

SampleCode：

  class SchoolMember:
  '''代表学校里的成员。'''
  def __init__(self,name,age):
      self.name = name;
      self.age = age;
      print('(Initialized SchoolMember:{})'.format(self.name));
  def tell(self):
      '''告诉我有关我的细节。'''
      print('Name:"{}" Age:"{}"'.format(self.name,self.age),end=" ");
  class Teacher(SchoolMember):
      '''代表一位老师。'''
      def __init__(self,name,age,salary):
          SchoolMember.__init__(self,name,age);
          self.salary = salary;
          print('Initialized Teacher:{}'.format(self.name));
      def tell(self):
          SchoolMember.tell(self);
          print('Salary {:d}:'.format(self.salary));
          
  class Student(SchoolMember):
      def __init__(self,name,age,marks):
          SchoolMember.__init__(self,name,age);
          self.marks = marks;
          print('Initialized Student:{}'.format(self.name));
      def tell(self):
          SchoolMember.tell(self);
          print('Marks:"{:d}"'.format(self.marks));
  
  t = Teacher("Li Zhanwei",28,25000);
  s = Student("Li Xiaolong",22,66);
  t.tell();
  s.tell();
  
  print();
  
  members = {t,s};
  for m in members:
      m.tell();