python 面向对象的程序设计

1.类与实例

1.1创建类和子类

类使用class关键字创建，类的属性和方法被列在一个缩进块中。

class animals:
    pass
#“哺乳动物”是“动物”的子类
class mammals(animals):
    pass
class dog(mammals):
    pass

　　

子类mammals可以继承父类animals的所有属性，同样，子类dog也可以继承父类mammals的所有属性。

1.2增加属于类的对象实例

我们定义了两个子类mammals和dog。图中有一条具体存在的名叫Bob的狗，属于类dog，是一个实例对象，定义如下：

Bob=dog()

这里，用dog()定义了一个dog类的实例对象，并把它赋值给了标识变量Bob

class dog:
    """狗类的创建例子"""

    def __init__(self, name, kind, month_age):  # self代表对象Bob自身
        self.name = name
        self.month_age = month_age
        self.kind = kind

    def __str__(self):  # 对象都会有一个字符串函数，用来返回一个字符串(自定义)
        return '<狗名: %s(%s，%d个月)>' % (self.name, self.kind, self.month_age)

    # 前两个函数都有下划线，表示是缺省的函数，定义的类中都必须有这两个函数。
    # 其他的函数可以自加

    def bark(self):  # 类方法必须包含参数self
        print('汪汪')


if __name__ == '__main__':
    Bob = dog('Bob', '金毛', 9)
    print(Bob)
    Bob.bark()  # 执行实例的方法不加参数self

1.3用函数表示类的行为特征

class animals:
    def breath(self):
        print('呼吸')
class mammals (animals):
    def move(self):
        print('奔跑')
class dog (mammals):
    def eat(self):
        print('吃')

　　

#创建一个dog的实例Bob并调用父类中的函数
 
Bob=dog()
Bob.move()
Bob.eat()
 

　　

运行结果：
 
奔跑
吃

　　

2.面向对象的特征

2.1封装

封装，是指将抽象得到的数据和行为相结合，将基本类结构的细节隐藏起来，通过方法接口实现对实例变量的所有访问。 Python中允许对类中的数据和方法进行封装，下面的例子封装了类中的数据，将公司名和领导人分别封装到对象obj1、obj2中self的companyname和leader属性中。

例：封装及封装数据调用。

class Company:
    def __init__(self, dept, leader):
        self.dept = dept
        self.leader = leader

    def show(self):   #函数名show可以随意命名
        print(self.dept)
        print(self.leader)

if __name__ == "__main__":
    obj1 = Company("A", "Kevin")
    obj2 = Company("B", "Jone")

    #  通过对象直接调用封装的数据
    print(obj1.dept)
    print(obj1.leader)
    # print(obj1)
    #  通过self来间接调用，self即对象本身
    obj1.show()
    obj2.show()

　　

2.2继承

当已经存在一个类，需要另外再创建一个和已有类非常相似的类时，通常不必将同一段代码重复多次，而是用继承。在类上添加关联，使得位于下层的类可以“继承”位于关系上层的类的属性。继承有利于代码的复用和规模化。和其他语言不同的是，Python中的类还具有多继承的特性，即一个类可以有多个父类。

例： 继承一个父类。

class Scale:
    def check(self):
        if self.count_person > 500:            
            print ("%s是个大公司." %self.name)        
        else:            
            print ("%s是个小公司." %self.name)
            
class Company(Scale):
    def __init__(self, name, count):
        self.name = name
        self.count_person = count
        
if __name__ == "__main__":
    my_company = Company("ABC", 800)    
    my_company.check()

例：继承多个父类。

class Scale:
    def check(self):
        if self.count_person > 500:            
            return "%s是个大公司." %self.name        
        else:            
            return "%s是个小公司." %self.name
            
class Detail:
    def show(self, scale):
        print ("%s,公司有%s名员工." %(scale, self.count_person))
        
class Company(Scale, Detail):
    def __init__(self, name, count):
        self.name = name
        self.count_person = count
        
if __name__ == "__main__":
    my_company = Company("ABC", 800)
    company_scale = my_company.check()
    my_company.show(company_scale)

　　

2.3多态

多态，即多种状态，是指在事先不知道对象类型的情况下，可以自动根据对象的不同类型，执行相应的操作。很多内建运算符以及函数、方法都能体现多态的性质。例如“+”运算符，在连接数值类型变量时表示加法操作，在连接字符串时则表示拼接。

def length(x):
    print(repr(x),"的长度为",len(x))
length('aaa')
length([1,2,3,4,5])

运行结果：
'aaa'的长度为3
[1, 2, 3, 4, 5]的长度为5