Python - 面向对象编程 - 初级篇

1、概述

一、 面向过程编程

面向过程编程每每用一长段代码来实现指定功能，在开发过程当中最多见的操做就是复制粘贴，即：将以前实现的代码块复制到现需功能处。

while True：
    if cpu利用率 > 90%:
        #发送邮件提醒
        链接邮箱服务器
        发送邮件
        关闭链接
  
    if 硬盘使用空间 > 90%:
        #发送邮件提醒
        链接邮箱服务器
        发送邮件
        关闭链接
  
    if 内存占用 > 80%:
        #发送邮件提醒
        链接邮箱服务器
        发送邮件
        关闭链接

二、 函数式编程

将具备相同功能的代码写到一个函数中，当须要时，调用、执行这个函数

def 发送邮件(内容)
    #发送邮件提醒
    链接邮箱服务器
    发送邮件
    关闭链接
  
while True：
  
    if cpu利用率 > 90%:
        发送邮件('CPU报警')
  
    if 硬盘使用空间 > 90%:
        发送邮件('硬盘报警')
  
    if 内存占用 > 80%:
        发送邮件('内存报警')

三、 面向对象编程

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）

面向对象编程是一种编程方式，此编程方式须要使用 “类” 和 “对象” 来实现，因此，面向对象编程其实就是对 “类” 和 “对象” 的使用。

• 类就是一个模板，模板里能够包含多个函数，函数里实现一些功能
• 对象则是根据模板建立的实例，经过实例对象能够执行类中的函数

# 建立类
class Foo:
    # 建立类中的函数
    def bar(self):
        # do something
        print("bar")
    
    def hello(self, name):
        self.name = name
        print("My name is :%self.name")
# 根据类Foo建立对象obj
obj = Foo()
obj.bar()                # 执行bar方法
obj.hello("Python")  # 执行hello方法

执行方式：

• 面向对象：【建立对象】【经过对象执行方法】
• 函数编程：【执行函数】
  总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据

2、面向对象三大特性

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

一、 封装

封装，顾名思义就是将内容封装到某个地方，之后再去调用被封装在某处的内容。因此，在使用面向对象的封装特性时，须要：

• 将内容封装到某处
• 从某处调用被封装的内容
  **第一步： 将内容封装到某处 **

# 建立类
class Foo:
    # __init__ 称为构造方法，在根据类建立对象时自动执行
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 建立类中的函数
    def hello(self):
        # do something
        print("hello %s" % self.name)
# 根据类Foo建立对象
obj1 = Foo("Python", 8)  # 将Python 和 8 分别封装到obj1(self)的name和age属性中
obj2 = Foo("Linux", 18)  # Linux 和 18 分别封装到obj1(self)的name和age属性中

第二步：从某处调用被封装的内容 调用被封装的内容时，有两种状况：

• 经过对象直接调用方法的属性

print(obj1.name)
print(obj1.age)

• 经过对象调用类的方法，再经过self调用属性

print(obj1.hello())
print(obj2.hello())

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

二、继承

面向对象中的继承和现实生活中的继承相同，即：子能够继承父的内容。 例如：

• 猫能够：喵喵叫、吃、喝、拉、撒
• 狗能够：汪汪叫、吃、喝、拉、撒
• 猫、狗都具备（继承了）动物的基本属性吃、喝、拉、撒

# 代码实例
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()

因此，对于面向对象的继承来讲，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而没必要一一实现每一个方法。

多继承相关

• 新式类和经典类

当前类或者父类继承了object类，则该类为新式类，不然为经典类。

class C1:  # C1是经典类
    pass


class C2(C1):  # C2是经典类
    pass


class N1(object):  # N1是新式类
    pass
    
    
class N2(N1):  # N2是新式类
    pass

• 深度优先和广度优先

查找方法： 新式类-->广度优先，经典类-->深度优先

3、多态

多态即多种形态 Pyhon不支持多态而且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

总结

以上就是本节对于面向对象初级知识的介绍，总结以下：

• 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
• 类 是一个模板，模板中包装了多个“函数”供使用
• 对象，根据模板建立的实例（即：对象），实例用于调用被包装在类中的函数
• 面向对象三大特性：封装、继承和多态