当前位置：首页 > news >正文

Python3 面向对象（1）

news 来源：原创 2024/5/10 16:15:41

面向.概述

面向过程：
    根据业务逻辑从上到下写垒代码面向过程的设计的核心是过程，过程即解决问题的步骤， 面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西
优点：
    极大降低了程序的复杂性
缺点：
    一套流水线或者流程就是用来解决一个问题，生产汽车的流水线无法生产汽水，即便是改造也要大改，牵一发而动全身。
函数式：
    将某功能代码封装到函数中，以后无需重复写代码，调用方便

面向对象：
    对函数进行分类和封装，"更快更好更强"。
　　 面向对象的程序核心是对象。如来安排唐僧，沙和尚，猪八戒，孙悟空去取经，但根本不会管师徒四人按照什么流程去取。

面向对象优点：
    解决了程序的可拓展性。对某一个对象单独修改会立刻反映到整个体系中，如对一个人物的参数的特征和技能修改都很容易。
面向对象缺点：
    可控性差，无法像面向过程的程序设计流水线式可以很精准的预测问题的处理流程和结果。面向对象的程序一旦开始就由对象之间的交互解决问题，即使是上帝也无法预测最终结果。
面向对象应用场景：
    需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。
　　 

面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性。

创建“类”和“对象”

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

对象——对象就是通过模板创建的实例，通过实例对象可以执行类中的函数。


面向对象是一种编程方式，此编程方式需要‘类’和‘对象’来实现，所有面向对象编程实际就是对‘类’和‘对象’的使用。

(纠正: 上图person = person() 应为 person = Person() )

class是关键字，表示类

创建对象类后面加括号即可

类中的函数第一个参数必须是self，类中定义的函数叫做‘方法’。

#创建类
class Person:
    def attack(self):
        print('attack')
    def hello(self,name):
        print('I am %s' %name)

#根据类Person创建对象Person()
person = Person()
person.attack()   #执行attack的方法
person.hello('zhugaochao')   #执行hello的方法

面向对象：创建对象，通过对象执行方法。

函数编程：直接执行函数。

场景的不同适合其编程方式也不同。

函数式编程的应用场景 >>> 各个函数之间是独立且无共用的数据。

面向对象的三大特性

1.封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性是
需要：
1.将内容封装到某处；
2.从某处调用被封装的内容。

1.1.将内容封装到某处

self是一个形式参数

当执行obj1 = Foo('zgc',18)时，self等于obj1
当执行obj2 = Foo('Joe',78)时，self等于obj2  (上图里不小心写错了)

So，内容其实被封装到了对象obj1和obj2中，每个对象都有name和age属性，在内存中类似下图保存。

1.2.从某处调用被封装的内容

（1）.通过对象直接调用被封装的内容

　　上图展示了对象obj1和obj2在内存中保存的方式，根据格式可以如此调用被封装的内容：对象.属性名。
class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age

obj1=foo('zgc',18)
print(obj1.name)      #直接调用obj1对象的name属性           
print(obj1.age)       #直接调用obj1对象的age属性

obj2=foo('Joe',23)
print(obj2.name)      #直接调用obj2对象的name属性
print(obj2.age)       #直接调用obj2对象的age属性
（2）.通过self间接调用被封装的内容

　　执行类中的方法时，需要通过self间接调用被封装的内容。
class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def detail(self):
        print(self.name)
        print(self.age)

obj1=Foo('zgc',18)
obj1.detail()    #python默认会将obj1传给self参数，即obj1.detail(obj1)，所以，此时方法内部的self=obj1，即self.name是zgc；self.age是18

obj2=Foo('Joe',23)
obj2.detail()    #python默认会将obj2传给self参数，即obj2.detail(obj2)，所以，此时方法内部的self=obj2，即self.name是Joe；self.age是23
综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。

在终端输出如下信息

小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健
老张...

练习

#函数式编程
def kanchai(name, age, gender):
    print("%s,%s岁,%s,上山去砍柴" %(name, age, gender))


def qudongbei(name, age, gender):
    print("%s,%s岁,%s,开车去东北" %(name, age, gender))


def dabaojian(name, age, gender):
    print("%s,%s岁,%s,最爱大保健" %(name, age, gender))


kanchai('小明', 10, '男')
qudongbei('小明', 10, '男')
dabaojian('小明', 10, '男')


kanchai('老李', 90, '男')
qudongbei('老李', 90, '男')
dabaojian('老李', 90, '男')
 

#面向对象编程
class Foo:
    
    def __init__(self, name, age ,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def kanchai(self):
        print("%s,%s岁,%s,上山去砍柴" %(self.name, self.age, self.gender))

    def qudongbei(self):
        print("%s,%s岁,%s,开车去东北" %(self.name, self.age, self.gender))

    def dabaojian(self):
        print("%s,%s岁,%s,最爱大保健" %(self.name, self.age, self.gender))


xiaoming = Foo('小明', 10, '男')
xiaoming.kanchai()
xiaoming.qudongbei()
xiaoming.dabaojian()

laoli = Foo('老李', 90, '男')
laoli.kanchai()
laoli.qudongbei()
laoli.dabaojian()

Answer

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

2.继承

2.1.常规继承

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

例如：
      猫可以：喵喵叫、吃、喝、拉、撒

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

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

#伪代码
class 猫：

    def 喵喵叫(self):
        print('喵喵叫')

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

class 狗：

    def 汪汪叫(self):
        print('喵喵叫')

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

点击查看示例代码

上述代码不难看出，吃喝拉撒是猫和狗都具有的功能，而我们却分别为猫和狗的类编写了二次。

如果使用继承的思想，如下：

动物：
       吃、喝、拉、撒

　　   猫：喵喵叫（猫继承动物的功能）

　　   狗：汪汪叫（狗继承动物的功能）

#伪代码
class 动物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 猫(动物)：

    def 喵喵叫(self):
        print('喵喵叫')
        
# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 狗(动物)：

    def 汪汪叫(self):
        print('喵喵叫')
#代码如下：
class Animal:

    def eat(self):
        print("%s 吃 " %self.name)

    def drink(self):
        print("%s 喝 " %self.name)

    def shit(self):
        print("%s 拉 " %self.name)

    def pee(self):
        print("%s 撒 " %self.name)


class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed＝'猫'

    def cry(self):
        print('喵喵叫')

class Dog(Animal):
    
    def __init__(self, name):
        self.name = name
        self.breed＝'狗'
        
    def cry(self):
        print('汪汪叫')
        

# ######### 执行 #########

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

c2 = Cat('小黑的小白猫')
c2.drink()

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

点击查看示例代码

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

注：

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

2.2.多继承

是否可以继承多个类？

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

1.python的类可以继承多个类，java和C　　#中则只能继承一个类

2.python的类如果继承了多个类，那么其寻找方法的方式有二种，分别是：深度优先和广度优先

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

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

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

#经典类多继承
class D:

    def bar(self):
        print('D.bar')


class C(D):

    def bar(self):
        print('C.bar')


class B(D):

    def bar(self):
        print('B.bar')


class A(B, C):

    def bar(self):
        print('A.bar')

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

经典类多继承

#新式类多继承
class D(object):

    def bar(self):
        print('D.bar')


class C(D):

    def bar(self):
        print('C.bar')


class B(D):

    def bar(self):
        print('B.bar')


class A(B, C):

    def bar(self):
        print('A.bar')

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

新式类多继承

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

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

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

　　　python3中统一都是新式类

　　　python2中才分新式类和经典类

3.多态

假设有一个毛坯房，户型是一个类
用钢精水泥组成这样一个户型，而你不需要去关心用了几根钢筋多少水泥，这是封装。
你住跟这个毛坯房同样户型的房子，不作修改或者多做一堵墙或者加个窗，这是继承。
你们上下层相同的卧室，都可以提供睡觉的功能，但是不同的人睡完之后感觉不同，这是多态。

python自带多态，是多态性语言

多态是面向对象语言的一个基本特性，多态意味着变量并不知道引用的对象是什么，根据引用对象的不同表现不同的行为方式。
在处理多态对象时，只需要关注它的接口即可，python中并不需要显示的编写（像Java一样）接口，在使用对象的使用先假定有该接口，如果实际并不包含，在运行中报错。

python不支持java和C　　#这一类强类型语言中多态的写法，但是原生多态python崇尚‘鸭子类型’。

#Python伪代码实现Java或C#的多态
class F1:
    pass


class S1(F1):

    def show(self):
        print('S1.show')


class S2(F1):

    def show(self):
        print('S2.show')


# 由于在Java或C#中定义函数参数时，必须指定参数的类型
# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类
# 而实际传入的参数是：S1对象和S2对象

def Func(F1 obj):
    """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伪代码实现Java或C#的多态

#Python “鸭子类型”
class F1:
    pass


class S1(F1):

    def show(self):
        print('S1.show')


class S2(F1):

    def show(self):
        print('S2.show')

def Func(obj):
    print(obj.show())

s1_obj = S1()
Func(s1_obj) 

s2_obj = S2()
Func(s2_obj)