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

目录

• 1. 面向对象和面向过程
• 2. 面向对象如何编写：
• 3. 面向对象的三大特征

1. 面向对象和面向过程

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

1. ⾯向过程: ⼀切以事物的流程为核⼼。 核⼼是"过程"⼆字, 过程是指解决问题的步骤，即：先⼲什么，后⼲什么。基于该思想编写程序就好比在编写⼀套流⽔线，是⼀种机械式的编程思维。

   • 优点: 负责的问题流程化, 编写相对简单
   • 缺点: 可扩展性差

2. ⾯向对象: ⼀切以对象为中⼼.
   什么是对象？事实上，我们身边的事物都是对象，一个对象它有自己的属性，它有自己的方法;就好像什么是⼈，有名字，年龄，爱好，会唱歌跳舞思考的是⼈。我们给这它下了⼀个简单的定义，总结: 具有相同属性和动作的结合体叫对象，⾯向对象思维，要⾃⼰建立对象，⾃⼰建立场景，你是就是⾯向对象世界中的上帝。

   • 优点: 可扩展性强
   • 缺点: 编程的复杂度⾼于⾯向过程

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⾃带多态