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崇尚「鴨子類型」。

總結

以上就是本節對於面向對象初級知識的介紹，總結以下：

• 面向對象是一種編程方式，此編程方式的實現是基於對 類 和 對象 的使用
• 類 是一個模板，模板中包裝了多個「函數」供使用
• 對象，根據模板建立的實例（即：對象），實例用於調用被包裝在類中的函數
• 面向對象三大特性：封裝、繼承和多態