python学习笔记：第15天初识面向对象

1. 面向对象和面向过程
2. 面向对象如何编写：
3. 面向对象的三大特征
- 封装
- 继承
- 多态

1. 面向对象和面向过程

面向对象和面向过程的理解：

⾯向过程: ⼀切以事物的流程为核⼼。核⼼是"过程"⼆字, 过程是指解决问题的步骤，即：先⼲什么，后⼲什么。基于该思想编写程序就好比在编写⼀套流⽔线，是⼀种机械式的编程思维。
- 优点: 负责的问题流程化, 编写相对简单
- 缺点: 可扩展性差
⾯向对象: ⼀切以对象为中⼼.

什么是对象？事实上，我们身边的事物都是对象，一个对象它有自己的属性，它有自己的方法;就好像什么是⼈，有名字，年龄，爱好，会唱歌跳舞思考的是⼈。我们给这它下了⼀个简单的定义，总结: 具有相同属性和动作的结合体叫对象，⾯向对象思维，要⾃⼰建立对象，⾃⼰建立场景，你是就是⾯向对象世界中的上帝。
- 优点: 可扩展性强
- 缺点: 编程的复杂度⾼于⾯向过程

2. 面向对象如何编写：

首先，我们要创建一个类，创建类的语法很简单：

class 变量名：

    ...

创建一个人的类：

class Person:

    def __init__(self, name):           # 构造方法，在类创建时就会执行

        self.name = name

    def speek(self):                    # Person类的一个方法

        print(f'我是{self.name}')        # 在这里可以使用self来访问类中的属性和方法

p = Person('ZZC')                       # 创建一个具体Person类的对象

p.speek()                               #  通过对象名.function()可以使用类的方法

# 结果：

# 我是ZZC

通常在编写一个类的时候，会写一个__init__方法，它会在对象被创建的时候执行，这里也可以像使用函数一样给函数传递变量（如例子中的Person('ZZC')）在实例化的时候会执行并接受这个参数。

注意：关于self：

这里我们可以看到，__init__和speek方法都会接收一个self的参数，但是我们在传参的时候并没有手动传参给函数，这是因为解释器会自动把self参数帮我们传递给对象的方法

self其实就是实例本身：那个对象调用了这个方法，那个对象就是self

3. 面向对象的三大特征

了解过面向对象编程的都知道，面向对象的三大特征：封装、继承、多态。

封装

把很多数据封装到⼀个对象中，把固定功能的代码封装到⼀个代码块，函数，对象, 打包成模块，这都属于封装的思想，具体的情况具体分析。在⾯向对象思想中，是把⼀些看似⽆关紧要的内容组合到⼀起统⼀进⾏存储和使⽤. 这就是封装.

class Person:

    def __init__(self, name, age, gender):  # 把属性都封装在self里面

        self.name = name

        self.age = age

        self.gender = gender

    def eat(self):

        print(f'{self.name}正在吃饭')

obj1 = Person('孙福来', 18, '女')           # 实例化一个类，得到一个对象

print(obj1.age)                             # 要访问类的属性都需要通过对象来访问

obj.eat()                                   # 要执行类中的方法也要通过类来访问

继承

一个类在定义的时候可以继承自其他的类，继承的类默认拥有其父类的属性和方法。在python中实现继承非常简单. 在声明类的时候, 在类名后⾯添加⼀个⼩括号,就可以完成继承关系。

class A:

    def func1(self):

        print('这是fun1函数')

class B(A):

    pass

b = B()

b.func1()               # 打印： 这是fun1函数

那么什么情况可以使⽤继承呢? 单纯的从代码层⾯上来看. 两个类具有相同的功能或者特征的时候. 可以采⽤继承的形式. 提取⼀个⽗类, 这个⽗类中编写着两个类相同的部分. 然后两个类分别取继承这个类就可以了. 这样写的好处是我们可以避免写很多重复的功能和代码.

class DBUtil:

    def __init__(self, host, port, username, passwd):

        self.host = host

        self.port = port

        self.usernam = username

        self.passwd = passwd

    def connetc(self):

        pass

    def close(self):

        pass

class MysqlUtil(DBUtil):

    def inser(self):

        pass

    def delete(self):

        pass

    def update(self):

        pass

    def select(self):

        pass

class RedisUtil(DBUtil):

    def inser(self):

        pass

    def delete(self):

        pas

    def update(self):

        pass

    def select(self):

        pass

如上，假设我们要编写一个操作数据库的工具，那么就可以把一些公共的功能都写在父类中，对于具体的数据库操作实现都放在子类中，那样就可以避免编写多余的重复代码。

在python中还可以继承自多个类，在继承多各类时查找父类中的属性有一定的顺序，具体的顺序是基于MRO c3算法来计算的，关于这一块后面再补上。

多态

同⼀个对象，多种形态。多态在python中体现的并不是很明显，我们通过例子来看：

class Animal:

    def eat(self):

        print('这只动物正在吃，疯狂的吃')

class Cat(Animal):

    def eat(self):

        print(f'猫正在吃')

class Dog(Animal):

    def eat(self):

        print(f'狗正在吃')

class Tiger(Animal):

    pass

class Watch:

    def func(self, obj):

        obj.eat()

c = Cat()

d = Dog()

t = Tiger()

w = Watch()

w.func(c)                   # 猫正在吃

w.func(d)                   # 狗正在吃

w.func(t)                   # 这只动物正在吃，疯狂的吃

在上面的例子中，我们通过Watch类创建出的对象w来执行各种动物的eat方法，这个方法要接收一个参数，即把各个动物的对象传进去，然后执行对象中的eat方法，而这个方法只要接收的对象拥有eat方法，那么就可执行这个eat方法，因此只要保证传入进来的对象中有这个方法，就能够正常运行。这就是同⼀个对象，多种形态的表现；在python中，多态是鸭子模式的一种体现。

多态的好处: 程序具有超⾼的可扩展性. ⾯向对象思想的核⼼与灵魂. python⾃带多态