Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

时间:2023-02-24 17:52:11

概念:                                                                                                                                                    

·        面向过程:根据业务逻辑从上到下写垒代码

·        函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可

·        面向对象:对函数进行分类和封装,让开发更快更好更强...”    

面向过程编程最易被初学者接受,其往往用一长段代码来实现指定功能,开发过程中最常见的操作就是粘贴复制,即:将之前实现的代码块复制到现需功能处。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

while True

    if cpu利用率 > 90%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

 

    if 硬盘使用空间 > 90%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

 

    if 内存占用 > 80%:

        #发送邮件提醒

        连接邮箱服务器

        发送邮件

        关闭连接

随着时间的推移,开始使用了函数式编程,增强代码的重用性和可读性,就变成了这样:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

def 发送邮件(内容)

    #发送邮件提醒

    连接邮箱服务器

    发送邮件

    关闭连接

 

while True

 

    if cpu利用率 > 90%:

        发送邮件('CPU报警')

 

    if 硬盘使用空间 > 90%:

        发送邮件('硬盘报警')

 

    if 内存占用 > 80%:

        发送邮件('内存报警') 

今天我们来学习一种新的编程方式:面向对象编程(Object Oriented ProgrammingOOP,面向对象程序设计)
注:JavaC#来说只支持面向对象编程,而python比较灵活即支持面向对象编程也支持函数式编程

创建类和对象                                                                                                                                                                                                       

面向对象编程是一种编程方式,此编程方式的落地需要使用对象来实现,所以,面向对象编程其实就是对对象的使用。

类就是一个模板,模板里可以包含多个函数,函数里实现一些功能

  对象则是根据模板创建的实例,通过实例对象可以执行类中的函数

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

·        class是关键字,表示类

·        创建对象,类名称后加括号即可

ps:类中的函数第一个参数必须是self(详细见:类的三大特性之封装)
   类中定义的函数叫做方法

# 创建类

class Foo:

     

    def Bar(self):

        print 'Bar'

 

    def Hello(self, name):

        print 'i am %s' %name

 

# 根据类Foo创建对象obj

obj = Foo()

obj.Bar()            #执行Bar方法

obj.Hello('wupeiqi') #执行Hello方法 

你在这里是不是有疑问了?使用函数式编程和面向对象编程方式来执行一个方法时函数要比面向对象简便

·        面向对象:【创建对象】【通过对象执行方法】

·        函数编程:【执行函数】

观察上述对比答案则是肯定的,然后并非绝对,场景的不同适合其的编程方式也不同。

总结:函数式的应用场景 --> 各个函数之间是独立且无共用的数据

面向对象三大特性                                                                                                                                                                               

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

一、封装

封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。

所以,在使用面向对象的封装特性时,需要:

·        将内容封装到某处

·        从某处调用被封装的内容

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

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

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

                              当执行 obj2 = Foo('alex', 78 ) 时,self 等于 obj2

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

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

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

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

·        通过对象直接调用

·        通过self间接调用

1、通过对象直接调用被封装的内容

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

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

 1 class Foo:

 2 

 3     def __init__(self, name, age):

 4         self.name = name

 5         self.age = age

 6 

 7 obj1 = Foo('wupeiqi', 18)

 8 print obj1.name    # 直接调用obj1对象的name属性

 9 print obj1.age     # 直接调用obj1对象的age属性

10 

11 obj2 = Foo('alex', 73)

12 print obj2.name    # 直接调用obj2对象的name属性

13 print obj2.age     # 直接调用obj2对象的age属性

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

对象.属性名调用

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

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

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

 1 class Foo:

 2

 3     def __init__(self, name, age):

 4         self.name = name

 5         self.age = age

 6

 7     def detail(self):

 8         print (self.name)

 9         print (self.age)

10

11 obj1 = Foo('wupeiqi', 18)

12 obj1.detail() # Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的 self obj1,即:self.name wupeiqi self.age 18

13

14 obj2 = Foo('alex', 73)

15 obj2.detail() # Python默认会将obj2传给self参数,即:obj1.detail(obj2),所以,此时方法内部的 self obj2,即:self.name alex self.age 78

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

self间接调用被封装的内容

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

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

 1 def kanchai(name, age, gender):

 2     print "%s,%s,%s,上山去砍柴" %(name, age, gender)

 3

 4

 5 def qudongbei(name, age, gender):

 6     print "%s,%s,%s,开车去东北" %(name, age, gender)

 7

 8

 9 def dabaojian(name, age, gender):

10     print "%s,%s,%s,最爱大保健" %(name, age, gender)

11

12

13 kanchai('小明', 10, '')

14 qudongbei('小明', 10, '')

15 dabaojian('小明', 10, '')

16

17

18 kanchai('老李', 90, '')

19 qudongbei('老李', 90, '')

20 dabaojian('老李', 90, '')

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

函数

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

 1 class Foo:

 2    

 3     def __init__(self, name, age ,gender):

 4         self.name = name

 5         self.age = age

 6         self.gender = gender

 7

 8     def kanchai(self):

 9         print "%s,%s,%s,上山去砍柴" %(self.name, self.age, self.gender)

10

11     def qudongbei(self):

12         print "%s,%s,%s,开车去东北" %(self.name, self.age, self.gender)

13

14     def dabaojian(self):

15         print "%s,%s,%s,最爱大保健" %(self.name, self.age, self.gender)

16

17

18 xiaoming = Foo('小明', 10, '')

19 xiaoming.kanchai()

20 xiaoming.qudongbei()

21 xiaoming.dabaojian()

22

23 laoli = Foo('老李', 90, '')

24 laoli.kanchai()

25 laoli.qudongbei()

26 laoli.dabaojian()

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

面向对象

上述对比可以看出,如果使用函数式编程,需要在每次执行函数时传入相同的参数,如果参数多的话,又需要粘贴复制了...  ;而对于面向对象只需要在创建对象时,将所有需要的参数封装到当前对象中,之后再次使用时,通过self间接去当前对象中取值即可。

二、继承

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

例如:

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

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

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

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

 1 class 猫:

 2

 3     def 喵喵叫(self):

 4         print '喵喵叫'

 5

 6     def (self):

 7         # do something

 8

 9     def (self):

10         # do something

11

12     def (self):

13         # do something

14

15     def (self):

16         # do something

17

18 class 狗:

19

20     def 汪汪叫(self):

21         print '喵喵叫'

22

23     def (self):

24         # do something

25

26     def (self):

27         # do something

28

29     def (self):

30         # do something

31

32     def (self):

33         # do something

34

35 伪代码

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

费事来

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

  动物:吃、喝、拉、撒

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

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

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

 1 class Animal:

 2

 3     def eat(self):

 4         print "%s " %self.name

 5

 6     def drink(self):

 7         print "%s " %self.name

 8

 9     def shit(self):

10         print "%s " %self.name

11

12     def pee(self):

13         print "%s " %self.name

14

15

16 class Cat(Animal):

17

18     def __init__(self, name):

19         self.name = name

20         self.breed ''

21

22     def cry(self):

23         print '喵喵叫'

24

25 class Dog(Animal):

26    

27     def __init__(self, name):

28         self.name = name

29         self.breed ''

30        

31     def cry(self):

32         print '汪汪叫'

33        

34

35 # ######### 执行 #########

36

37 c1 = Cat('小白家的小黑猫')

38 c1.eat()

39

40 c2 = Cat('小黑的小白猫')

41 c2.drink()

42

43 d1 = Dog('胖子家的小瘦狗')

44 d1.eat()

45

46 代码实例

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

继承动物

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

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

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

多继承

·        是否可以继承多个类

·        如果继承的多个类每个类中都定了相同的函数,那么那一个会被使用呢?

1Python的类可以继承多个类,JavaC#中则只能继承一个类

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

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

·        当类是经典类时,多继承情况下,会按照深度优先方式查找

·        当类是新式类时,多继承情况下,会按照广度优先方式查找

经典类和新式类,从字面上可以看出一个老一个新,新的必然包含了跟多的功能,也是之后推荐的写法,从写法上区分的话,如果 当前类或者父类继承了object,那么该类便是新式类,否则便是经典类。

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性) Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

三、多态 和多态性

多态指的是一类事物有多种形态,(一个抽象类有多个子类,因而多态的概念依赖于继承)

什么是多态性(请务必注意注意注意:多态与多态性是两种概念。)

多态性是指具有不同功能的函数可以使用相同的函数名,这样就可以用一个函数名调用不同功能的函数。

在面向对象方法中一般是这样表述多态性:向不同的对象发送同一条消息(!!!obj.func():是调用了obj的方法func,又称为向obj发送了一条消息func,不同的对象在接收时会产生不同的行为(即方法)。也就是说,每个对象可以用自己的方式去响应共同的消息。所谓消息,就是调用函数,不同的行为就是指不同的实现,即执行不同的函数。

比如:老师.下课铃响了(),学生.下课铃响了(),老师执行的是下班操作,学生执行的是放学操作,虽然二者消息一样,但是执行的效果不同

多态性分为静态多态性和动态多态性

静态多态性:如任何类型都可以用运算符+进行运算

动态多态性:如下

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

#多态是同一种事物的多种形态

class Animal:

    def talk(self):

            print('正在叫')

 

 

class People(Animal):

    def talk(self):

        print('say hello')

 

class Pig(Animal):

    def talk(self):

        print('哼哼哼')

 

class Dog(Animal):

    def talk(self):

        print('汪汪汪')

 

 

class Cat(Animal):

    def talk(self):

        print('喵喵喵')

peo1=People()

pig1=Pig()

dog1=Dog()

cat1=Cat()

 

 

#多态性

 

peo1.talk()

dog1.talk()

pig1.talk()

 

 

def func(x):

    x.talk()

 

 

func(peo1)

func(pig1)

func(dog1)

func(cat1)

 

 

#输出结果:

# say hello

# 汪汪汪

# 哼哼哼

 

# say hello

# 哼哼哼

# 汪汪汪

# 喵喵喵

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)