python菜鸟面向对象(Python语法基础10面向对象)

python菜鸟面向对象(Python语法基础10面向对象)(1)

面向对象(初级篇)

面向对象的三大特性是指:封装、继承和多态。

封装

封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。 所以,在使用面向对象的封装特性时,需要:

  • 将内容封装到某处
  • 从某处调用被封装的内容

第一步:将内容封装到某处

python菜鸟面向对象(Python语法基础10面向对象)(2)

self 是一个形式参数, 当执行 obj1 = Foo('wupeiqi', 18 ) 时,self 等于 obj1 当执行 obj2 = Foo('alex', 78 ) 时,self 等于 obj2

所以,内容其实被封装到了对象obj1和obj2中,每个对象中都有name和age属性,在内存里类似于下图来保存。

python菜鸟面向对象(Python语法基础10面向对象)(3)

第二步:从某处调用被封装的内容

调用被封装的内容时,有两种情况:

  • 通过对象直接调用
  • 通过self间接调用

1、通过对象直接调用被封装的内容 上图展示了对象obj1和obj2在内存中保存的方式,根据保存格式可以如此调用被封装的内容:对象.属性名

classFoo: def__init__(self,name,age): self.name=name self.age=age obj1=Foo('wupeiqi',18) print(obj1.name)#直接调用obj1对象的name属性 print(obj1.age)#直接调用obj1对象的age属性 obj2=Foo('alex',73) print(obj2.name)#直接调用obj2对象的name属性 print(obj2.age)#直接调用obj2对象的age属性


wupeiqi 18 alex 73

2、通过self间接调用被封装的内容

执行类中的方法时,需要通过self间接调用被封装的内容

classFoo: def__init__(self,name,age): self.name=name self.age=age defdetail(self): print(self.name) print(self.age) obj1=Foo('wupeiqi',18) obj1.detail()#Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的self=obj1,即:self.name是wupeiqi;self.age是18 obj2=Foo('alex',73) obj2.detail()#Python默认会将obj2传给self参数,即:obj1.detail(obj2),所以,此时方法内部的self=obj2,即:self.name是alex;self.age是78


wupeiqi 18 alex 73

综上所述,对于面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过对象直接或者self间接获取被封装的内容。

继承

继承,面向对象中的继承和现实生活中的继承相同,即:子可以继承父的内容。

例如:

猫可以:喵喵叫、吃、喝、拉、撒

狗可以:汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,如下所示:

class猫: def喵喵叫(self): print('喵喵叫') def吃(self): #dosomething def喝(self): #dosomething def拉(self): #dosomething def撒(self): #dosomething class狗: def汪汪叫(self): print('喵喵叫') def吃(self): #dosomething def喝(self): #dosomething def拉(self): #dosomething def撒(self): #dosomething

上述代码不难看出,吃、喝、拉、撒是猫和狗都具有的功能,而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想,如下实现:

动物:吃、喝、拉、撒

猫:喵喵叫(猫继承动物的功能)

狗:汪汪叫(狗继承动物的功能)

class动物: def吃(self): #dosomething def喝(self): #dosomething def拉(self): #dosomething def撒(self): #dosomething #在类后面括号中写入另外一个类名,表示当前类继承另外一个类 class猫(动物): def喵喵叫(self): print('喵喵叫') #在类后面括号中写入另外一个类名,表示当前类继承另外一个类 class狗(动物): def汪汪叫(self): print('喵喵叫')

#!/usr/bin/python #-*-coding:UTF-8-*- classAnimal: defeat(self): print("%s吃"%self.name) defdrink(self): print("%s喝"%self.name) defshit(self): print("%s拉"%self.name) defpee(self): print("%s撒"%self.name) classCat(Animal): def__init__(self,name): self.name=name self.breed='猫' defcry(self): print('喵喵叫') classDog(Animal): def__init__(self,name): self.name=name self.breed='狗' defcry(self): print('汪汪叫') ##########执行######### c1=Cat('小白家的小黑猫') c1.eat() c2=Cat('小黑的小白猫') c2.drink() d1=Dog('胖子家的小瘦狗') d1.eat()

所以,对于面向对象的继承来说,其实就是将多个类共有的方法提取到父类中,子类仅需继承父类而不必一一实现每个方法。

注:除了子类和父类的称谓,你可能看到过 派生类 和 基类 ,他们与子类和父类只是叫法不同而已。

python菜鸟面向对象(Python语法基础10面向对象)(4)

classAnimal: defeat(self): print("%s吃"%self.name) defdrink(self): print("%s喝"%self.name) defshit(self): print("%s拉"%self.name) defpee(self): print("%s撒"%self.name) classCat(Animal): def__init__(self,name): self.name=name self.breed='猫' defcry(self): print('喵喵叫') classDog(Animal): def__init__(self,name): self.name=name self.breed='狗' defcry(self): print('汪汪叫') ##########执行######### c1=Cat('小白家的小黑猫') c1.eat() c2=Cat('小黑的小白猫') c2.drink() d1=Dog('胖子家的小瘦狗') d1.eat()

那么问题又来了,多继承呢?

  • 是否可以继承多个类
  • 如果继承的多个类每个类中都定了相同的函数,那么哪一个会被使用呢?

1、Python的类可以继承多个类,Java和C#中则只能继承一个类

2、Python的类如果继承了多个类,那么其寻找方法的方式有两种,分别是:深度优先广度优先

python菜鸟面向对象(Python语法基础10面向对象)(5)

当类是经典类时,多继承情况下,会按照深度优先方式查找 当类是新式类时,多继承情况下,会按照广度优先方式查找 经典类和新式类,从字面上可以看出一个老一个新,新的必然包含了更多的功能,也是之后推荐的写法,从写法上区分的话,如果当前类或者父类继承了object类,那么该类便是新式类,否则便是经典类。

python菜鸟面向对象(Python语法基础10面向对象)(6)

#经典类多继承 classD: defbar(self): print('D.bar') classC(D): defbar(self): print('C.bar') classB(D): defbar(self): print('B.bar') classA(B,C): defbar(self): print('A.bar') a=A() #执行bar方法时 #首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去D类中找,如果D类中么有,则继续去C类中找,如果还是未找到,则报错 #所以,查找顺序:A-->B-->D-->C #在上述查找bar方法的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了 a.bar()


A.bar

#新式类多继承 classD(object): defbar(self): print('D.bar') classC(D): defbar(self): print('C.bar') classB(D): defbar(self): print('B.bar') classA(B,C): defbar(self): print('A.bar') a=A() #执行bar方法时 #首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错 #所以,查找顺序:A-->B-->C-->D #在上述查找bar方法的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了 a.bar()


A.bar

经典类:首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去D类中找,如果D类中么有,则继续去C类中找,如果还是未找到,则报错

新式类:首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错

注意:在上述查找过程中,一旦找到,则寻找过程立即中断,便不会再继续找了

多态

Pyhon不支持Java和C#这一类强类型语言中多态的写法,但是原生多态,其Python崇尚**“鸭子类型”**。

#Python伪代码实现Java或C#的多态 classF1: pass classS1(F1): defshow(self): print('S1.show') classS2(F1): defshow(self): print('S2.show') #由于在Java或C#中定义函数参数时,必须指定参数的类型 #为了让Func函数既可以执行S1对象的show方法,又可以执行S2对象的show方法,所以,定义了一个S1和S2类的父类 #而实际传入的参数是:S1对象和S2对象 defFunc(F1obj): """Func函数需要接收一个F1类型或者F1子类的类型""" print(obj.show()) s1_obj=S1() Func(s1_obj)#在Func函数中传入S1类的对象s1_obj,执行S1的show方法,结果:S1.show s2_obj=S2() Func(s2_obj)#在Func函数中传入Ss类的对象ss_obj,执行Ss的show方法,结果:S2.show

#Python“鸭子类型” classF1: pass classS1(F1): defshow(self): print('S1.show') classS2(F1): defshow(self): print('S2.show') defFunc(obj): print(obj.show()) s1_obj=S1() Func(s1_obj) s2_obj=S2() Func(s2_obj)

总结

以上就是本节对于面向对象初级知识的介绍,总结如下:

  • 面向对象是一种编程方式,此编程方式的实现是基于对类和对象的使用。
  • 类是一个模板,模板中包装了多个“函数”供使用。
  • 对象,根据模板创建的实例(即:对象),实例用于调用被包装在类中的函数。
  • 面向对象三大特性:封装、继承和多态。
,

免责声明:本文仅代表文章作者的个人观点,与本站无关。其原创性、真实性以及文中陈述文字和内容未经本站证实,对本文以及其中全部或者部分内容文字的真实性、完整性和原创性本站不作任何保证或承诺,请读者仅作参考,并自行核实相关内容。文章投诉邮箱:anhduc.ph@yahoo.com

    分享
    投诉
    首页