Python類——面向對象

1、有關面向對象的一些知識

面向過程：根據業務邏輯從上到下寫壘代碼

函數式：將某功能代碼封裝到函數中，往後便無需重複編寫，僅調用函數便可

面向對象：對函數進行分類和封裝，讓開發「更快更好更強...」

面向過程編程最易被初學者接受，其每每用一長段代碼來實現指定功能，開發過程當中最多見的操做就是粘貼複製，即：將以前實現的代碼塊複製到現需功能處。

面向對象編程是一種編程方式，此編程方式的落地須要使用 「類」 和 「對象」 來實現，因此，面向對象編程其實就是對 「類」 和 「對象」 的使用。

　　類就是一個模板，模板裏能夠包含多個函數，函數裏實現一些功能

　　對象則是根據模板建立的實例，經過實例對象能夠執行類中的函數

class是關鍵字，表示類

建立對象，類名稱後加括號便可

類中的函數第一個參數必須是self（詳細見：類的三大特性之封裝）
類中定義的函數叫作 「方法」

1 2 3 4 5 6 7 8 9 10 11 12 13

# 建立類 class Foo:            def Bar( self ):          print 'Bar'        def Hello( self , name):          print 'i am %s' % name   # 根據類Foo建立對象obj obj = Foo() obj.Bar()            #執行Bar方法 obj.Hello( 'wupeiqi' ) #執行Hello方法

 

面向對象：【建立對象】【經過對象執行方法】、

函數編程：【執行函數】

觀察上述對比答案則是確定的，而後並不是絕對，場景的不一樣適合其的編程方式也不一樣。

總結：函數式的應用場景 --> 各個函數之間是獨立且無共用的數據

面向對象三大特性

面向對象的三大特性是指：封裝、繼承和多態。

（一）封裝

封裝，顧名思義就是將內容封裝到某個地方，之後再去調用被封裝在某處的內容。

因此，在使用面向對象的封裝特性時，須要：

• 將內容封裝到某處
• 從某處調用被封裝的內容

第一步：將內容封裝到某處

 self 是一個形式參數，當執行 obj1 = Foo('wupeiqi', 18 ) 時，self 等於 obj1

                              當執行 obj2 = Foo('alex', 78 ) 時，self 等於 obj2

因此，內容其實被封裝到了對象 obj1 和 obj2 中，每一個對象中都有 name 和 age 屬性，在內存裏相似於下圖來保存。

第二步：從某處調用被封裝的內容

調用被封裝的內容時，有兩種狀況：

• 經過對象直接調用
• 經過self間接調用

一、經過對象直接調用被封裝的內容

（二）繼承

繼承，面向對象中的繼承和現實生活中的繼承相同，即：子能夠繼承父的內容。

若是咱們要分別爲貓和狗建立一個類，那麼就須要爲 貓 和 狗 實現他們全部的功能，以下所示

 

上述代碼不難看出，吃、喝、拉、撒是貓和狗都具備的功能，而咱們卻分別的貓和狗的類中編寫了兩次。若是使用 繼承 的思想，以下實現：

　　動物：吃、喝、拉、撒

　　   貓：喵喵叫（貓繼承動物的功能）

　　   狗：汪汪叫（狗繼承動物的功能）

 

 

因此，對於面向對象的繼承來講，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而沒必要一一實現每一個方法。

注：除了子類和父類的稱謂，你可能看到過 派生類 和 基類 ，他們與子類和父類只是叫法不一樣而已。

（三）多態 

 Pyhon不支持Java和C#這一類強類型語言中多態的寫法，可是原生多態，其Python崇尚「鴨子類型」（其實我也不太清楚什麼是鴨子類型，去百度百度吧）。

上圖展現了對象 obj1 和 obj2 在內存中保存的方式，根據保存格式能夠如此調用被封裝的內容：對象.屬性名

（四）對象與類之間的關係

       類： 現實生活中對事物的描述。

　　 對象： 這一類事物的實實在在的個體。

　　　　生活中有有一類個體：他們都會拿槍、射擊、穿迷彩服、越野、殺敵等功能。------這就是一個軍人的類。 類有屬性（成員變量）和方法（動態屬性）。
　　　　而具體到個體： 士兵1號、士兵2號、士兵3號等 就是這個類中的具體實體-----這就是一些士兵的對象。

　　而映射到java中 ，這些描述就是class定義的一個類
　　具體的對象， 就是new關鍵字在堆（heap）中建立的實體。

（五）成員變量 與 局部變量
　　做用範圍： 成員變量 做用於整個類的內部
　　　　　　　局部變量 做用於方法或者語句塊之中

　　內存中的位置 ：   成員變量 存在於堆內存中，由於對象的存在而存在。 會先有系統的默認初始化（0 null）， 以後纔是咱們定義個顯示初始化。
　　　　　　　　　　在沒有引用指向其對象的時候（及變成垃圾對象），被垃圾回收機回收後消失。
　　　　　　　　　　局部變量 存在於棧內存中，由於語句的執行而存在。 必須人工給予初始化，不然次變量不能使用。相關語句執行完畢後自動消失。

 

（六）匿名對象

　　如： new Car（）; new Car().color = "blue"; new Car().runCar();

　　　　特色：只能使用一次， 使用以後便會變成垃圾， 等垃圾回收機回收清空內存。
　　　　　　　匿名對象調用其屬性沒有意義， 調用其方法具備必定的意義。

　　　　使用狀況：1）、只對對象的 方法 進行 一次調用 的時候。 這樣寫比較簡便。 若是要對對象的多個成員進行調用，就必須給對象命名。
　　　　　　　　   2）、能夠將匿名對象當成參數緊傳遞。

 

2、面向對象相關應用

下面展現一下有關三維向量計算的程序

import math

class Vectors:

    def __init__(self):         #計算向量座標，根據所給點座標

        self.x1=0

        self.x2=0

        self.y1=0

        self.y2=0

        self.z1=0

        self.z2=0

        self.x=self.x2-self.x1

        self.y=self.y2-self.y1
        
        self.z=self.z2-self.z1
 
    def add(self):              #輸入三維點座標，並計算向量座標，根據所輸入的點座標

        self.x1=int(input("input x1 :"))

        self.y1=int(input("input y1 :"))

        self.z1=int(input("input z1 :"))

        self.x2=int(input("input x2 :"))

        self.y2=int(input("input y2 :"))

        self.z2=int(input("input z2 :"))

        self.x=self.x2-self.x1

        self.y=self.y2-self.y1

        self.z=self.z2-self.z1

    def out(self):              #輸出向量座標

        print(self.x,self.y,self.z)

    def plus(self,a,b):         #向量相加

        self.x=a.x+b.x

        self.y=a.y+b.y

        self.z=a.z+b.z

    def sub(self,a,b):          #向量相減

        self.x=a.x-b.x

        self.y=a.y-b.y

        self.z=a.z-b.z

    def pointmuti(self,a,b):    #向量的數量積

        return (a.x*b.x+a.y*b.y+a.z*b.z )

    def angle(self,a,b):        #向量的餘弦值

        a1=(a.x*a.x+a.y*a.y+a.z*a.z)**0.5   #向量a的模長

        b1=(b.x*b.x+b.y*b.y+b.z*b.z)**0.5   #向量b的模長

        ab=a.x*b.x+a.y*b.y+a.z*b.z  

        return ab/(a1*b1)

 

v=Vectors()

a=Vectors()

b=Vectors()

a.add()

b.add()

print("向量a座標爲：" ,end='')

a.out()

print("向量b座標爲：",end='')

b.out()

print("向量a、向量b相加得：",end='')

v.plus(a,b)

v.out()

print("向量a、向量b相減得：",end='')

v.sub(a,b)

v.out()

print("向量a、向量b的向量積爲：",end='')

print(v.pointmuti(a,b))

print("向量a、向量b的夾角餘弦值爲：",end='')

print(math.acos(v.angle(a,b)))

這些就是個人關於面向對象的一些總結了。