python笔记--面向对象

louyaoluan

　　面向对象编程
　　面向对象编程是一种编程方式，需要使用 “类” 和 “对象” 来实现：
　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能，实现对具有共同特征的事物的描述；
　　对象是类的实体，是一种数据类型。它不存在内存中，不能被直接操作，只有被实例化对象时，才会变的可操作。举例说明：
#!/usr/bin/env python　　
# -*- coding:utf-8 -*-
　　
class Student():    #calss是关键字，表示类Student是类的名称，通常首字母大写。
　　
s=100               #类属性，属于全局变量。
　　
‘’’
　　
这是一个测试类#给类添加注释
　　
‘’’
　　
    def name(self,name):    #类中的函数，第一个参数必须是self。
　　
        print 'I am %s'%name
　　
def score(self):
　　
print self.s                #方法中调用类属性
　　
obj=Student()               #obj就是对象的实例化，可使用tyte(obj)查看其类型。
　　
obj.name('zhangsan')        #调用类的方法，输出结果为”I am zhangsan”
　　一、__init__初始化实例属性
　　python中定义了一个__init__方法，可以初始化类变量、传递类的参数，例如：
　　#初始化类变量
#!/usr/bin/env python　　
# -*- coding:utf-8 -*-
　　
class Student():
　　
    def __init__(self):        #__init__函数定义到类的开头
　　
        self.name='zhangsan'   #初始化变量，在以后的函数中可以调用。
　　
        self.score=100
　　
    def print_score(self):
　　
        print '%s:%s'%(self.name,self.score)    #调用self.name
　　
f=Student()
　　
f.print_score()
　　注意：self.name 变量是一个实例属性，只能在类方法中使用。
　　#传参
#!/usr/bin/env python　　
# -*- coding:utf-8 -*-
　　
class Student():
　　
    def __init__(self,a,b):
　　
        self.name=a    #初始化变量，只不过赋予的不是固定值，是一个可变参数。
　　
        self.score=b
　　
    def print_score(self):
　　
        print '%s:%s'%(self.name,self.score)
　　
f=Student('zhangsan','100')    #定义参数，传递给__init__函数
　　
f.print_score()
　　注意：我们没有专门调用__init__方法，只是在创建一个类的新实例的时候，把参数包括在圆括号内跟在类名后面，从而传递给__init__方法。
　　二、私有属性
　　以双下划线开头的变量，表示私有变量，受保护的，只能类本身能访问，连子类也不能访问，例如：
#!/usr/bin/env python　　
class Info():
　　
    def __init__(self):
　　
        self.__name='zhangsan'
　　
    def say(self):
　　
        print self__name
　　
a=Info()
　　
print a.__name
　　执行以上代码会报错：AttributeError: Info instance has no attribute '__name'
　　事实上这是一种伪私有，例如：
#!/usr/bin/env python　　
class Info():
　　
    def __init__(self):
　　
        self.__name='zhangsan'
　　
    def say(self):
　　
        print self__name
　　
a=Info()
　　
print a._Info__name    #在属性前面加上_classname依然可以打印出来
　　注意：Python 中的以双下滑开头的类方法名，在类实例化以后会自动被概念，在其名字前加 _classname ，因为名字被改了，所以自然无法用双下滑开头的名字被访问，从而达到不可进入的目的。
　　详细的私有属性描述，可以参考：
　　http://blog.itpub.net/26250550/viewspace-1411768/
　　三、面向对象的三大特性
　　1.封装
　　通过上面的例子，可以看到面向对象编程需要两个步骤：
　　（1）将内容封装到某处
　　通过创建类、实例化对象，其实就是将内容封装到对象中了。
　　（2）从某处调用被封装的内容
　　调用被封装的内容，一般有两种情况：
　　#通过对象直接调用（第一个例子）
　　#通过self间接调用（第二个例子）
　　2.继承
　　子类继承父类的属性和方法，能够提高代码的重用。
　　#简单继承
#!/usr/bin/env python　　
class Student():
　　
    def __init__(self,a,b):
　　
        self.name=a
　　
        self.score=b
　　
    def print_score(self):
　　
        print '%s:%s'%(self.name,self.score)
　　
class One(Student):#子类：One，父类：Student
　　
    pass
　　
f=One('zhangsan',100)
　　
print f.name#调用父类的属性
　　
f.print_score()#调用父类的方法
　　
#输出结果如下：
　　
zhangsan
　　
zhangsan:100
　　#子类实例初始化
　　如果子类实例属性初始化了，那父类的属性和方法是不会被继承的：
#!/usr/bin/env python　　
class Boy():
　　
    def __init__(self):
　　
        self.sex='boy'
　　
        self.height='170'
　　
    def print_mes(self):
　　
        print 'sex:%s,hei:%s'%(self.sex,self.height)
　　
class Name(Boy):
　　
    def __init__(self):    #子类初始化实例属性
　　
        self.name='zhangsan'
　　
    def print_name(self):
　　
        print 'name:%s'%self.name
　　
f=Name()
　　
print f.name
　　
f.print_name()
　　
f.print_mes()
　　
#异常信息如下：
　　
AttributeError: Name instance has no attribute 'sex'
　　没有找到父类中的属性，说明父类中的方法并没有被子类继承。
　　解决方法一：
#!/usr/bin/env python　　
class Boy():
　　
    def __init__(self):
　　
        self.sex='boy'
　　
        self.height='170'
　　
    def print_mes(self):
　　
        print 'sex:%s,hei:%s'%(self.sex,self.height)
　　
class Name(Boy):
　　
    def __init__(self):
　　
        Boy.__init__(self)    #将父类的__init__方法添加到子类中
　　
        self.name='zhangsan'
　　
    def print_name(self):
　　
        print 'name:%s'%self.name
　　
f=Name()
　　
print f.name
　　
f.print_name()
　　
f.print_mes()
　　解决方法二：
#!/usr/bin/env python　　
class Boy(object):    #需要指定基类object（新式类）
　　
    def __init__(self):
　　
        self.sex='boy'
　　
        self.height='170'
　　
    def print_mes(self):
　　
        print 'sex:%s,hei:%s'%(self.sex,self.height)
　　
class Name(Boy):
　　
    def __init__(self):
　　
        super(Name, self).__init__()    #使用super函数（super只能用于新式类）
　　
        self.name='zhangsan'
　　
    def print_name(self):
　　
        print 'name:%s'%self.name
　　
f=Name()
　　
print f.name
　　
f.print_name()
　　
f.print_mes()
　　#多重继承
　　子类有多个父类，如果调用的属性或方法在子类中没有，就会从父类中查找。在经典类和新式类中，查找的方式不同。python3.0之后不再经典类，统一为新式类。
　　经典类：
　　默认没有父类，多继承情况下，会按照深度优先方式查找。
　　新式类：
　　有继承的类，如果没有，可以继承 object。多继承情况下，会按照广度优先方式查找。
　　举例说明：
class D:    #经典类　　
    def bar(self):
　　
        print 'D.bar'
　　
class C(D):
　　
    def bar(self):
　　
        print 'C.bar'
　　
class B(D):
　　
    def bar(self):
　　
        print 'B.bar'
　　
class A(B, C):
　　
    def bar(self):
　　
        print 'A.bar'
　　
a = A()
　　
a.bar()
　　执行bar方法时：
　　首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中没有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错。
　　所以，查找顺序：A --> B --> D --> C
　　在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了。
class D(object):    #新式类　　
    def bar(self):
　　
        print 'D.bar'
　　
class C(D):
　　
    def bar(self):
　　
        print 'C.bar'
　　
class B(D)：
　　
    def bar(self):
　　
        print 'B.bar'
　　
class A(B, C):
　　
    def bar(self):
　　
        print 'A.bar'
　　
a = A()
　　
a.bar()
　　执行bar方法时：
　　首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中没有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错。
　　所以，查找顺序：A --> B --> C --> D
　　在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了。
　　#多态
class F1:　　
    pass
　　
class S1(F1):
　　
    def show(self):
　　
        print 'S1.show'
　　
class S2(F1):
　　
    def show(self):
　　
        print 'S2.show'
　　
def Func(obj):
　　
    print obj.show()
　　
s1_obj = S1()
　　
Func(s1_obj)
　　

　　
s2_obj = S2()
　　
Func(s2_obj)
　　
#为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类，而实际传入的参数是：S1对象和S2对象。
　　从上面这个例子可以看出，相同的消息可能会送给多个不同的对象，而系统可依据对象所属类，引发对应类的方法，而有不同的行为，这就是多态的特点。