python面向对象

一,类

类的关键词是class

class Person(object):#类的创建'''类的名称首字母必须大写"""
    def __init__(self,name,age):#构造方法也可以理解为init是Person的形式参数
        self.name=name
        self.age=age
    def show(self):#具体方法
        print("name{0},age{1}.format(self.name,self.age)
    def __del__(self):#清理方法
        print("end")
Person(name='柏舟',age=18).show()#调用类中的具体方法
#调用类的具体方法的时候通常会进行实例化,类实例化的过程也是类初始化的过程
obj=Person(name='柏舟',age=18)
obj.show()==Person(name='柏舟',age=18).show()
print(obj.name)
print(obj.age)
"""在类中,方法的执行顺序是,构造方法---->具体方法---->清理方法.

二,类的三种操作

1,封装:封装”就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体（即类）；封装的目的是增强安全性和简化编程

　　1,实例属性

　　2,数据属性

class Animal(object):
    def __inif__(self,age):#age相当于类Animal的形式参数
        self.age=age
    def getage(self):
        return self.age
    def setage(self,age)#输入age的数据
        if age>0 and age<100:
            self.age=age
        else:
            print("输入有误")

　　类的三种方法

　　　　1,普通方法:可以读写

　　　　2,特性方法:不可写,只可读,不存在形式参数

　　　　3,静态方法:属于类,只能使用类名来进行调用,一般把数据属性用静态方法来处理

class Date:
    def __inif__(self,age):#构造方法
        self.age=age
    def show(self,name='dog'):#普通方法+默认参数
        print(itis{0},itis{1},itis{2}.format.(name,self.age,self.address)
    def fun(self,**kwargs):#动态参数
        print(kwargs)
    @property
    def into(self)#特性方法
        print("hello")
    @property
    def getage(self)#特性方法
        return self.age
    @staticmethod#静态方法
    def address()
        return '地球'

objAnimal=Animal(age=30)#对类进行实例化
objAnimal.show()#调用具体方法
objAnimal.info特性方法不用带括号
objAnimal.fun(name="baizhou",age=18,job='student')#调用动态参数,输出默认为字典类型
print(objAnimal.address())#调用静态参数并输出
print(objAnimal.age)#输出类的构造方法

 

2,继承

父类(基类):被继承的类

子类(派生类):继承其他的类

子类继承父类继承了1,变量(数据属性)2,实例属性,3,方法

方法重写:当子类和父类拥有同样的方法时,子类实例化后优先考虑子类方法

class Animal(object):
    name='动物'#变量
    def__inif__(self,age,sex)#实例属性
        self.age=age
        self.sex=sex
    def info(self):#方法
        print("动物")

class Cat(Animal):#Cat就是Animal的子类
    def __inif__(self,age,sex,address):
        self.address=address
    Animal.__inif__(self,age,sex)#继承父类的实例参数
    def show(self):
        print(it is {0},it is {1},it is {2}.format(self.age,self.sex,self.address)
    def info(self):
        print("这是猫")
cat=Cat(age=5,sex=t,address=中国)
cat.show()
cat.name
cat.info()

继承的顺序

　　1,从下到上:

　　　　条件1,单个继承2,子类重写

　　2,从左到右

　　　　条件:多个继承

　　3,子类可以继承多个父类,但是父类要属于同一级别

　　4,假设a继承b,b继承c,c继承d,那么逻辑顺序假设abcd

class A:
    def info(self):
        print("a")
class B(A):
    def info(self):
        print("b")
b=B()
b.info()

在python2中,深度优先,在python3中广度优先

3,多态

"""多态的优势具体可以总结为如下⼏点，具体为:
增加了持续的灵活性
增加了持续的额外扩展的功能"""

class Animal(object):
    def talk(self):
        print('动物会叫')

class Cat(Animal):
    def talk(self):
        print('猫也叫')
class Dog(Animal):
    def talk(self):
        print('狗也叫')
def func(animal):
    animal.talk()

if __name__=='__main__':
    cat=Cat()
func(animal=cat)