学习4: 面向对象

1. 类的定义和实例化

class dog():                
    def __init__(self,name,age,s,color):  
        self.name = name
        self.age = age
        self.single = s
        self.color = color
    def walk(self):
        self.a = 'aaa'
        self.b = 100
        print 'running dog'
    def eat(self,food):
        print 'eat..',food
    def talk(self):
        print 'w w w'
w = dog('heizi',1,True,'black')     
l = dog('nana',3,True,'yellow')
l.money = 'bumai!'
print l.money
print w.name

总结：
1) class后面紧接着是类名，类的类型分为经典类和新式类。经典类后面括号不继承任何东西。新式类括号里面面一般最好添加(object),表示该类是从哪个类继承下来的。通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
2) 由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，age等属性绑上去
3) 注意到__init__为初始化方法，第一个参数永远是self，表示创建的实例本身
4) 变量w就是指向dog的类的实例变量，而dog本身就是一个类。（）里面的都是给他捆绑的属性
5) 有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去。另外和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数和关键字参数。
6) 类的方法：在上面的dog类中，每个实例就拥有各自的name和age这些数据，因为dog的实例本身就有这些数据，要访问这些数据，就没有必要从外面的函数去访问，可以直接在dog类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和dog类本身是关联起来的，我们称之为类的方法。要定义一个方法，除了第一个参数是self外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入。

2. 属性

class student(object):
    grade = 'Four'       #类的公有属性，可以被类和实例访问
    __teacher = 'David'  #类的私有属性(以__为前缀)，不可以被类和实例访问，只可用于类的方法中调用
    def __init__(self,name,age):
        self.name = name #实例的公有属性，可以被实例访问
        self.__age = age #实例的私有属性(以__为前缀)，不可以被实例访问，只可用于类的方法中
    def getGrade(self):
        print self.grade
    def getTeacher(self):
        print self.__teacher
    def getName(self):
        print self.name
    def getAge(self):
        print self.__age
s = student('Lina',18)
print '---测试1：类的公有属性可以被类和实例访问'
print student.grade
print s.grade
print '---测试2：类的私有属性不可以被类和实例访问'
#print student.__teacher
#print s.__teacher
print '---测试3: 实例的公有属性，可以被实例访问，但是不能被类访问'
print s.name
#print student.name
print '---测试4, 实例的私有属性，不可以被实例访问'
#print s.__age
print '---测试5, 公有属性和私有属性都可以被类的方法中调用'
s.getGrade()
s.getTeacher()
s.getName()
s.getAge()

总结：
属性分为类的属性和实例属性。定义在类中方法之外的属性，称为类的属性，又分为类的公有属性和私有属性；
1) 类的公有属性，可以被类和实例访问；
2) 类的私有属性(以__为前缀)，不可以被类和实例访问，只可用于类的方法中通过self.__private_attrs调用
3) 实例的公有属性，可以被实例访问
4) 实例的私有属性(以__为前缀)，不可以被实例访问，只可用于类的方法中通过self.__private_attrs调用
5) 如果类的公有属性和实例公有属性同名，则两者互相不影响；

（类和实例的私有属性都是只能被类中定义的方法使用)

3. 方法

class student(object):
    grade = 'Four'       #类的公有属性，可以被类和实例访问
    __teacher = 'David'  #类的私有属性（以__为前缀)，不可以被类和实例访问，只可用于类的方法中调
    def __init__(self,name,age):
        self.name = name #实例的公有属性，可以被实例访问
        self.__age = age #实例的私有属性（以__为前缀)，不可以被实例访问，只可用于类的方法中
    def getGrade(self):
        print self.grade
    def getTeacher(self):
        print self.__teacher
    def getName(self):
        print self.name
    def __getAge(self):  #私有方法（以__为前缀)，不可以被实例访问
        print self.__age
    def getAge(self):    #公有方法，可以被实例访问
        self.__getAge()
s = student('Lina',18)
print '---测试1：类的公有属性可以被类和实例访问'
print student.grade
print s.grade
print '---测试2：类的私有属性不可以被类和实例访问'
#print student.__teacher
#print s.__teacher
print '---测试3: 实例的公有属性，可以被实例访问，但是不能被类访问'
print s.name
#print student.name
print '---测试4, 实例的私有属性，不可以被实例访问'
#print s.__age
print '---测试5, 公有属性和私有属性都可以被类的方法中调用'
s.getGrade()
s.getTeacher()
s.getName()
print '---测试6, 私有方法不可以被实例访问'
#s.__getAge()
s.getAge()

class Dav(student):
    grade = 'one'
    __teacher = 'Mrliu'
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    @staticmethod
    def getStu():
        #print self.grade
        #print self.__teacher
        #print self.name
        #print self.__age
        print '调用静态方法'
    @classmethod
    def getInfo(cls):
        print cls.grade
        print cls.__teacher
        #print self.name
        #print self.__age
        print '调用类方法'
print '---测试10: 静态方法不能访问类和实例的属性，定义时候也不需要加self参数，可以被实例或者类调用且两者效果一致'
d = Dav('david', 21)
d.getStu()
Dav.getStu()
print '---测试11: 类方法可以访问类的属性,包含类的公有属性和私有属性，可以被实例或者类调用且两者效果一致'
dd = Dav('tom', 23)
dd.getInfo()
Dav.getInfo()

总结：
方法包含实例方法，静态方法，类方法。
1) 私有方法以两个下划线开头，不可以被实例访问，只能在类的方法中通过self.__private_methods调用
2) 公有方法，可以被实例访问
3) 以上说的方法实际都是实例方法，其它还有静态方法，类方法。
4) 静态方法使用装饰器@staticmethod定义，并且方法参数中不能有self. 类对象和实例都可以调用静态方法,但是无法访问类属性、实例属性，相当于一个相对独立的方法，跟类其实没什么关系;
5) 类方法使用@classmethod装饰器定义，其第一个参数必须为cls，且不需要self参数。类对象和实例都可以调用类方法,可以访问类属性包含公有属性和私有属性，但是无法访问实例属性。

还有一种类中普通的方法（没有self参数)，这种方法既可以被类直接调用也可以被类的实例对象调用，但是被实例对象调用的时候，要求方法至少有一个参数，因为调用时会将实例对象本身传给第一个参数。staticmethod函数功能就是将这种方法定义成类的静态方法，正确的方法是使用 @staticmethod装饰器，这样在实例对象调用的时候，不会把实例对象本身传入静态方法的第一个参数了。

4. 构造方法

class student(object):
    grade = 'Four'       #类的公有属性，可以被类和实例访问
    __teacher = 'David'  #类的私有属性（以__为前缀)，不可以被类和实例访问，只可用于类的方法中调用
    def __init__(self,name,age):
        self.name = name #实例的公有属性，可以被实例访问
        self.__age = age #实例的私有属性（以__为前缀)，不可以被实例访问，只可用于类的方法中
        print '父类构造函数'
    def getGrade(self):
        print self.grade
    def getTeacher(self):
        print self.__teacher
    def getName(self):
        print self.name
    def __getAge(self):  #私有方法（以__为前缀)，不可以被实例访问
        print self.__age
    def getAge(self):    #公有方法，可以被实例访问
        self.__getAge()
s = student('Lina',18)
print '---测试1：类的公有属性可以被类和实例访问'
print student.grade
print s.grade
print '---测试2：类的私有属性不可以被类和实例访问'
#print student.__teacher
#print s.__teacher
print '---测试3: 实例的公有属性，可以被实例访问，但是不能被类访问'
print s.name
#print student.name
print '---测试4, 实例的私有属性，不可以被实例访问'
#print s.__age
print '---测试5, 公有属性和私有属性都可以被类的方法中调用'
s.getGrade()
s.getTeacher()
s.getName()
print '---测试6, 私有方法不可以被实例访问'
#s.__getAge()
s.getAge()

class Liming(student):
    def getName(self):
        print self.name
print '---测试7, 子类未定义构造函数，将默认使用父类构造函数'
l = Liming('liming', 20)
l.getName()
class Liutao(student):
    def __init__(self,name,age,height):
        self.name = name
        self.age =age
        self.height = height
        print '子类自己的构造函数'
    def getName(self):
        print self.name
print '--测试8,子类定义了构造函数，实例化将使用自己的构造函数'
lt = Liutao('liutao', 35, 168)
lt.getName()
class litao2(student):
    def __init__(self,name,age,height):
        student.__init__(self,name,age)
        self.height =height
        print '子类自己的构造函数'
    def getName(self):
        print self.name
print '---测试9，子类定义了构造函数，还可以继续调用父类构造函数'
lt2 = litao2('litao2',20,180)    
lt2.getName()

总结：
1) 如果子类没有定义构造函数，将默认使用父类构造函数；
2) 如果一个子类从多个父类派生，而子类又没有自己的构造函数,则按顺序继承，
哪个父类在最前面且它又有自己的构造函数，就继承它的构造函数；如果最前面第一个父类没有构造函数，
则继承第2个的构造函数，第2个没有的话，再往后找，以此类推。
3) 如果子类有自己的构造函数，不会自动调用父类的构造函数，只会调用自己的构造函数
4) 如果需要用到父类的构造函数，则需要在子类的构造函数中显式的调用
5) 显式调用父类构造函数有两种方法：super以及 通过父类直接调用__init__函数；

5. 多态

class A():
    def login(self):
        print 'A'
class B(A):
    def login(self):
        print 'B'
class C(A):
    def login(self):
        print 'C'
def test(a)
    a.login()
test(B()) 
test(A())
test(C())

总结：
1) 如果父类方法的功能不能满足需求，可以在子类重写父类的方法。实例对象调用方法时会调用其对应子类的重写后的方法

6. 继承

class A:
    pass
class B(A)
    pass

总结：
1) 定义：class 派生类名（基类名)
2) 特点：
I: 在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。使用super().__init__()或parentClassName.__init__()
II: 在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
III: 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

7. 封装