python 基础知识-面向对象

面向对象的概念

拥有共同属性的一类进行归类的过程叫做面向对象。

面向对象案例

class Person(object):
    def __init__(self,name,age):  #name,age可以理解为类的属性；init为初始化；类里定义的函数称为构造方法/构造函数
        self.name=name   #实例属性
        self.age=age
        print("start")
    def __del__(self):   #清理操作
        print("end")
    def show(self):     #self为类本身，不可省略
        print("name:{0},age:{1}".format(self.name,self.age))
obj=Person(name="wuya",age=18)   #要调用类里边的变量、方法函数等，首先需要对类进行实例化；obj是类Person()实例化后的对象,类实例化的过程也是类初始化的过程。类的实例化过程也是针对构造方法初始化的过程（等于调用了__init__的方法）
obj.show()
#Person(name="wuya",age=18).show()   #用类名调用方法

以上代码运行的结果为：

类中方法的执行顺序：初始化方法->具体的方法->清理的方法(class定义类的时候，类名的首字母必须大写)

面向对象的方法

普通方法

属于对象，也属于类，只能读写，方法之间的相互调用，self.方法()；

特性方法

属于对象，只具备读属性，方法不能有形式参数；

静态方法

属于类，只能用类名来调用，一般把数据属性使用静态方法来处理

定义方式:
@staticmethod
def 方法名():
pass
特征:
1. 定义方式不同，使用@staticmethod装饰器
2. 他不是必须要有类似self，cls的参数
3. 类似类方法，只不过在方法体中需要通过:类名.属性名 或者 类名.方法()
4. 对象方法中可否调用静态方法？ 能够调用静态方法

面向对象的特性

1）封装

　　a.实例属性

　　b.数据属性（类中的变量）

2）继承

3）多态

封装

封装入门实例

class Animal(object):
    def __init__(self,age):
        self.age=age
    def getAge(self):
        return self.age
    def setAge(self,age):
        if age>10 and age<100:
            self.age=age    #允许修改年龄
        else:
            print("年龄错误")
objAnimal=Animal(age=25)    #类的实例化
print(objAnimal.getAge())   #输出获取年龄的方法的调用结果
objAnimal.setAge(age=11)    #调用修改年龄的方法
print(objAnimal.getAge())   #输出获取年龄的方法的调用结果

封装的进阶实例

class Animal(object):
    address="地球"   #数据属性
    def __init__(self,age):
        self.age=age   #实例属性
    #     @staticmethod
    def address(self):   #静态方法，数据属性使用静态方法来处理
        return "地球"
    def show(self,name="❀"):   #普通方法，可读写
        print("it come from {0},and it's age is {1},and it's name is {2}".format(self.address(),self.age,name))
    def func(self,**kwargs):
        print(kwargs)
    @property
    def info(self):   #特性方法，只读（只有输出）
        print("hello world")
    @property
    def getAge(self):    #特性方法，只读（只有返回）
        return self.age
objAnimal=Animal(age=30)   #类的实例化
objAnimal.show()           #调用普通方法
#objAnimal.show(name="monkey")
# Animal().show(name="monkey")
# Animal(age=10).address()
objAnimal.func(name="cch",age=18,city="西安")
objAnimal.info             #特性方法调用
print(Animal.address(""))
print(objAnimal.age)

 

继承

概念

父类（基类）：被继承的类

子类（派生类）：继承其他的类

Java和Python继承的区别

Java是单继承的，Python是多继承的

子类继承父类的什么：

a、变量（数据属性）

b、实例属性

c、方法

3）方法重写

当父类的方法没有办法满足子类的需求的时候，子类就会重写父类的方法，那么子类实例化后的对象调用该方法，优先考虑的是子类的方法。

class Father(object):
    address="西安"
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print("this is a father's method")
class Son(Father):
    def __init__(self,name,age,score):
        Father.__init__(self,name,age)   #子类继承了父类的实例属性
        self.score=score
    def show(self):
        print("name is {0},and age is {1},and score is {1}".format(self.name,self.age,self.score))
    def info(self):      #父类的方法重写
        print("this is a son's method")
son=Son(name="wuya",age=18,score=99)
son.show()
print(son.address)   #子类继承了父类的变量（数据属性）
son.info()    #不用print,info()中有print,函数与返回值时，输出函数为空。子类重写父类的方法，那么子类实例化后的对象调用该方法，优先考虑的是子类的方法。

以上代码运行的结果为：

继承顺序

1）从上到下（前提条件）：

a.单个继承

b.子类重写了父类的方法

2）从左到右（前提条件）：子类继承多个类（子类可以继承多个父类，但父类之间必须是同级关系。）

3）所以在Python中，基于MRO的解析顺序规则，就会从左到右开始查找基类，如果找到第⼀个匹配的属性类，就会停⽌查找，如果没有，那就继续查找，直到查找到符合要求的为止。MRO其实就是通过⼀个C3线性化算法来实现的，它的核心思想为：

子类会优于父类检查

多个父类会根据他们在列表中的顺序被依次检查

如果对下一个类存在两个合法的选择，只能选择第一个（线性查找）

继承顺序示例

class Father(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def funM(self):
        print("father")

class Mother(object):
    def funM(self):
        print("mother")

class Son(Father,Mother):     #子类Son继承了两个父类
    def __init__(self,name,age,score):
        Father.__init__(self,name,age)    #子类Son继承了父类Father和Mother的实例属性
        self.score=score

son=Son(name="ccj",age=18,score=100)
son.funM()
print(Son.mro())   #使用类名调用mro，查看类的执行顺序

以上代码的执行结果为：

子类继承多个非同级的父类错误示例

class Person(object):
    pass

class Father(Person):
    def __init__(self):
        pass
    def funM(self):
        print("father")
class Mother(object):
    def funM(self):
        print("mother")

class Son(Person,Father):  #子类继承的多个父类不是同一级，代码会报错,z子类可以继承多个父类，但父类之间必须是同级关系。
14 def __init__(self,score): 15 Father.__init__(self) 16 self.score=score 17 son=Son(score=90) 18 son.funM() 19 print(Son.mro())

以上代码的运行结果为;

继承方法调用错误示例

class Person(object):
    pass

class Father(Person):
    def __init__(self):
        pass

class Mother(Person):
    def funM(self):
        print("mother")

class Son(Father):   #子类继承的父类中没有funM方法，代码会报错
    def __init__(self,score):
        Father.__init__(self)
        self.score=score

son=Son(score=99)
son.funM()

以上代码的运行结果为：

继承方法调用错误示例纠正

class Person(object):
    def funM(self):
        print("person")

class Father(Person):
    def __init__(self):
        pass

class Mother(Person):
    def funM(self):
        print("mother")

class Son(Father):   #子类继承法的父类是Father
    def __init__(self,score):
        Father.__init__(self)
        self.score=score

son=Son(score=99)
son.funM()    #子类调用方法，先从子类中查找，再从继承的父类查找，若未找到，再从父类的父类中查找。
print(Son.mro())

以上方法的运行结果为：

继承历史问题

python2是深度优先，python3是广度优先

class A:
    def show(self):
        print('A')

class B(A):
    pass

class C(A):
    def show(self):
        print('C')

class D(B,C):
    pass

if __name__ == '__main__':
    obj=D()
    obj.show()  #python2执行的结果是A，pyhton3中的运行结果为C

多态

多太的优势具体可以总结为如下几点，具体为：

增加了持续的灵活性

增加了持续的额外扩展功能

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

class Dog(object):
    def talk(self):
        print("狗也会叫")

class Cat(object):
    def talk(self):
        print("猫也会叫")

def func(animal):
    animal.talk()
if __name__ == '__main__':
    dog=Dog()
    func(animal=dog)

以上代码的运行结果为：