欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-05-28 11:46:27
[TOC] 1. 面向对象和面向过程 面向对象和面向过程的理解: 1. ⾯向过程: ⼀切以事物的流程为核⼼。 核⼼是"过程"⼆字, 过程是指解决问题的步骤,即:先⼲什么,后⼲什么。基于该思想编写程序就好比在编写⼀套流⽔线,是⼀种机械式的编程思维。 优点: 负责的问题流程化, 编写相对简单 缺点: 可 ......

目录

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