python 基础知识-day10(面向对象)

1、面向对象的概念

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

2、注意事项

class定义类的时候,类名的首字母必须大写

3、面向对象案例

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

以上代码运行的结果为:

4、类中方法的执行顺序:初始化方法->具体的方法->清理的方法

5、面向对象的特性

1)封装

  a.实例属性

  b.数据属性(类中的变量)

2)继承

3)多态

6、方法:

  a.普通方法:属于对象,也属于类,只能读写;

  b.特性方法:属于对象,只具备读属性,方法不能有形式参数;

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

7、封装入门实例

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

8、封装的进阶实例

 1 class Animal(object):
 2     address="地球"   #数据属性
 3     def __init__(self,age):
 4         self.age=age   #实例属性
 5     #     @staticmethod
 6     def address(self):   #静态方法,数据属性使用静态方法来处理
 7         return "地球"
 8     def show(self,name=""):   #普通方法,可读写
 9         print("it come from {0},and it's age is {1},and it's name is {2}".format(self.address(),self.age,name))
10     def func(self,**kwargs):
11         print(kwargs)
12     @property
13     def info(self):   #特性方法,只读(只有输出)
14         print("hello world")
15     @property
16     def getAge(self):    #特性方法,只读(只有返回)
17         return self.age
18 objAnimal=Animal(age=30)   #类的实例化
19 objAnimal.show()           #调用普通方法
20 #objAnimal.show(name="monkey")
21 # Animal().show(name="monkey")
22 # Animal(age=10).address()
23 objAnimal.func(name="cch",age=18,city="西安")
24 objAnimal.info             #特性方法调用
25 print(Animal.address(""))
26 print(objAnimal.age)

 

 

 

 9、继承

1)概念

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

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

2)Java和Python继承的区别

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

3)子类继承父类的什么:

a、变量(数据属性)

b、实例属性

c、方法

3)方法重写

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

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

以上代码运行的结果为:

 

 

 10、继承顺序

1)从上到下(前提条件):

a.单个继承

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

2)从左到右(前提条件):子类继承多个类(子类可以继承多个父类,但父类之间必须是同级关系。)

3)所以在Python中,基于MRO的解析顺序规则,就会从左到右开始查找基类,如果找到第⼀个匹配的属性类,就会停⽌查找,如果没有,那就继续查找,直到查找到符合要

求的为止。MRO其实就是通过⼀个C3线性化算法来实现的,它的核心思想为:

子类会优于父类检查

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

如果对下一个类存在两个合法的选择,只能选择第一个(线性查找)

11、继承顺序示例

 1 class Father(object):
 2     def __init__(self,name,age):
 3         self.name=name
 4         self.age=age
 5     def funM(self):
 6         print("father")
 7 
 8 class Mother(object):
 9     def funM(self):
10         print("mother")
11 
12 class Son(Father,Mother):     #子类Son继承了两个父类
13     def __init__(self,name,age,score):
14         Father.__init__(self,name,age)    #子类Son继承了父类Father和Mother的实例属性
15         self.score=score
16 
17 son=Son(name="ccj",age=18,score=100)
18 son.funM()
19 print(Son.mro())   #使用类名调用mro,查看类的执行顺序

以上代码的执行结果为:

 

 

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

 1 class Person(object):
 2     pass
 3 
 4 class Father(Person):
 5     def __init__(self):
 6         pass
 7     def funM(self):
 8         print("father")
 9 class Mother(object):
10     def funM(self):
11         print("mother")
12 
13 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())

以上代码的运行结果为;

 

 

 13、继承方法调用错误示例

 1 class Person(object):
 2     pass
 3 
 4 class Father(Person):
 5     def __init__(self):
 6         pass
 7 
 8 class Mother(Person):
 9     def funM(self):
10         print("mother")
11 
12 class Son(Father):   #子类继承的父类中没有funM方法,代码会报错
13     def __init__(self,score):
14         Father.__init__(self)
15         self.score=score
16 
17 son=Son(score=99)
18 son.funM()

以上代码的运行结果为:

 

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

 1 class Person(object):
 2     def funM(self):
 3         print("person")
 4 
 5 class Father(Person):
 6     def __init__(self):
 7         pass
 8 
 9 class Mother(Person):
10     def funM(self):
11         print("mother")
12 
13 class Son(Father):   #子类继承法的父类是Father
14     def __init__(self,score):
15         Father.__init__(self)
16         self.score=score
17 
18 son=Son(score=99)
19 son.funM()    #子类调用方法,先从子类中查找,再从继承的父类查找,若未找到,再从父类的父类中查找。
20 print(Son.mro())

以上方法的运行结果为:

 

 15、继承历史问题

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

 1 class A:
 2     def show(self):
 3         print('A')
 4 
 5 class B(A):
 6     pass
 7 
 8 class C(A):
 9     def show(self):
10         print('C')
11 
12 class D(B,C):
13     pass
14 
15 if __name__ == '__main__':
16     obj=D()
17     obj.show()  #python2执行的结果是A,pyhton3中的运行结果为C

16、多态

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

增加了持续的灵活性

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

 1 class Animal(object):
 2     def talk(self):
 3         print("动物会叫")
 4 
 5 class Dog(object):
 6     def talk(self):
 7         print("狗也会叫")
 8 
 9 class Cat(object):
10     def talk(self):
11         print("猫也会叫")
12 
13 def func(animal):
14     animal.talk()
15 if __name__ == '__main__':
16     dog=Dog()
17     func(animal=dog)

以上代码的运行结果为:

posted @ 2022-06-23 19:27  $Cch$  阅读(14)  评论(0编辑  收藏  举报