python类及对象

#pass---程序块为空使用
l=[1,2,3]
for i in range(len(l)):
  pass
  
#一.类和对象---------------
#类：描述具有相同特征的一类事物，是抽象的概念，不能执行具体的动作。  比如： 人类
#类组成：属性和方法（动作）组成
#对象：是符合该类特性的实，也就是说是类的实例化，可以执行具体的动作。比如：学生
#1. 如何定义一个类
#class 类名:
      #类代码块（类体）
      #属性-----类的成员变量
      #方法-----类的成员函数
class Person:
  pass
#2. 类的实例化    实例名=类名()
Tom=Person()
Marry=Person()
#3. 属性------类的成员变量
class Person:
  classname='Person'
  def output(self):
    print self.classname
p=Person()
p.output()
#4.方法-------类的成员函数
#类的成员函数特点：
#（1）参数第一个必须是self
#（2）类的成员函调用时不需要传递self，python解释器在执行的之后会帮我们将实例名传递给参数self
#（3）调用成员函数用实例（对象）调用  (1)   实例名.函数名（参数）(2)类名.函数名（实例对象，参数1····）
#（4）全局唯一--不会因为不同的实例调用而出现不同的方法
class Person:
  def init_person(self):
    print('hello  python!')
Tom=Person()
Tom.init_person()
Person.init_person(Tom)
#多个参数的成员函数
#调用方法时要携带参数值
class Person:
  def init_person(self,name,age):
    self.name=name
    self.age=age
    print'name:',self.name
    print'age:',self.age
Tom=Person()
Tom.init_person('Tom',20)
Person.init_person(Tom,'Tom',20)
#构造函数__init__:构造对象实例的时候主动调用的函数，执行类的初始化操作。
#如果构造函数中有参数，那么在实例化对象的时候就要进行传递参数值
class Person:
  def __init__(self,name,age):
    self.name=name
    self.age=age
    print'name:',self.name
    print'age:',self.age
Tom=Person('Tom',20)
#析构函数__del__：释放对象占用资源（删除对象）
class Person:
  def init_person(self,name,age):
    self.name=name
    self.age=age
    print'name:',self.name
    print'age:',self.age
  def __del__(self):
    print('delete obj Tom!!')
Tom=Person()
Tom.init_person('Tom',20)
del Tom
#5.实例的成员变量
#类的实例有一个字典对象 存放 key（属性名） ：value（属性值）
class Person:
  classname='Person'     #类的成员变量
  def init_person(self,name,age):
#实例的成员变量self.name中的name是字典中的key，=后面的name是实例调用方法是传递进来的值value
    self.name=name   #实例的成员变量，将name 值用self.name的值来存储------存储
    self.age=age     #实例的成员变量
    print self.name      #利用实例对象来访问成员变量--------访问
p=Person()
p.init_person('Marry',19)

#二. 继承----------------------------
#子类可以直接调用基类的方法------隐式调用（不显示调用基类的名字）子类名.方法名（参数）
#子类显示调用基类的方法-------显示调用 基类名.方法（self,参数1，参数2....）
class Person(object):
  def init_person (self,name,age):
    self.name=name
    self.age=age
    print 'name:'+self.name
    print'age:',self.age
class Man(Person):
  pass
m=Man()
m.init_person('Tom',23)
print '以下是显示调用结果：'
Person.init_person(m,'Marry',20)
#如果子类调用的方法找不到可以到基类中调用；
#如果子类调用的方法可以在子类中找到，则使用子类的方法
#这种子类重新实现了基类原有的方法我们称为-------------方法重载（重写）
class Person(object):
  def init_person (self,name,age):
    self.name=name
    self.age=age
    print 'name:'+self.name
    print'age:',self.age
class Man(Person):
  def init_person(self,name,age):
    print 'man init_person'
m=Man()
m.init_person('Tom',23)
#如果子类中可以找到调用的方法，子类还想用基类的同名方法，可以基类显式调用
class Person(object):
  def init_person (self,name,age):
    self.name=name
    self.age=age
    print 'name:'+self.name
    print'age:',self.age
class Man(Person):
  def init_person(self,n,a,sex):
    Person.init_person(self,n,a)
    self.sex=sex
    print 'sex:',self.sex
    print 'man init_person'
class Woman(Person):
  def init_person(self,n):
    Person.init_person(self,n,'')
    print 'man init_person'
m=Man()
m.init_person('Tom',23,'girl')
w=Woman()
w.init_person('Marry')
#多态---------------------
#对象呈现多中状态成为多态
#在继承关系中，子类继承了父类的属性和方法
#子类也可以有自己的方法，那么我们可以称子类具有多态性
#三.  抽象类----包含抽象方法的类。抽象方法中部包含任何实现的代码
#实现的代码都在子类中下实现。
#在python中定义抽象类
#（1）从类库abc中导入ABCMeta类和abstractmethod类
#from abc import ABCMeta,abstractmethod
#（2）在类的代码块中指定该类的元类是ABCMeta      _metaclass_=ABCMeta
#（3）在抽象类里定义抽象方法加上装饰符 @abstractmethod
from abc import ABCMeta,abstractmethod
class Person:
  __metaclass__=ABCMeta
  @abstractmethod
  def abc(self):
    pass
  def output(self):
    print'this is abstractmethod!'
class Man(Person):
  def abc(self):
    print 'this is Man!'   
m=Man()
m.abc()
m.output()