1.面向對象概述

面向過程編程：根據操作數據的函數或語句塊來設計程序的。

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

面向對象編程：數據和功能結合起來，用稱為對象的東西包裹起來組織程序的方法；

在大多數時候你可以使用面向過程編程，但是有些時候當需要編寫大型程序或是尋求一個更加合適的解決方案的時候，就需要面向對象的編程，Python既可以提供面向過程的編程，也可以面向對象的編程，歸根到底，Python語言是面向對象的編程語言。

2.創建類和對象

__metaclass__=type #確定使用新式類，這句話可以不寫，內部自動調用
class Person: #創建類
 

    def setName(self,name):#self是特殊參數，必填
        self.name=name

    def getName(self):
        return self.name

    def greet(self):
        print("Hello,%s"%self.name)

>>> foo=Person()#根據類Person創建對象foo，實例化這個類
>>> foo.setName(‘greg‘)#執行setName方法，此時的foo就是類Person的實例化對象
>>> foo.greet() #執行greet方法
Hello,greg

類的執行邏輯

定義類時，所有位於class語句中的代碼都在特殊的命名空間中執行——類命名空間（class namespace）。

這個命名空間可由類內所有成員訪問，類的定義其實就是執行代碼塊，在類的定義區並不只限只能使用def語句。

>>>class C:
    print("Class C being defined")
#運行
>>>Class C being defined

class Person(object):
    def __init__
 
(self, name):
        self.name = name

    def hello(self):
        print("hello,%s" %self.name)

obj=Person("greg")
obj.hello()  #hello,greg
print(Person)#<class ‘__main__.Person‘>

3.對象的魔力

3.1 多態（Polymorphism）：意味著可以對不同類的對象使用相同的操作。

def add(x,y):
    return x+y

print(add(1,2))
print(add(‘Fish‘,‘license‘))

def length_message(x):
    print("長度：",repr(x),"是",len(x))

print(length_message(‘gregory‘))
print(length_message([1,2,3]))

python裏的很多函數和運算符都是多態的，只要使用多態函數和運算符，就會與多態發生關聯。

唯一能夠毀掉多態的就是使用函數顯式地檢查類型，比如type，isinstance，issubclass函數等。

多態的形式在Python裏也被稱為鴨子類型duck typing

class F1:
    pass

class S1(F1):
    def show(self):
        print(‘S1.show‘)

class S2(F1):
    def show(self):
        print(‘S2.show‘)

def Func(obj):
    print (obj.show())

s1_obj = S1()
Func(s1_obj)

s2_obj = S2()
Func(s2_obj)

3.2 封裝（Encapsulation）: 即對外部世界隱藏對象的工作細節。

封裝是指向程序中的其他部分隱藏對象的具體實現細節的原則。和多態類似，也是使用對象而不用知道其內部細節。

區別在於：多態可以讓用戶對於不知道是什麽類（對象類型）的對象進行方法調用，而封裝是可以不用關心對象是如何構建的而直接進行使用。

class Person:
    def __init__(self,name,age):
        #構造方法，類名（）自動執行構造方法
        self.n=name
        self.a=age
        self.b=‘o型‘
    def show(self):
        print(‘%s-%s-%s‘%(self.n,self.a,self.b))
obj1=Person(‘greg‘,18)

#直接調用對象的屬性

print(obj1.name)

#間接調用

Python默認會將obj1傳給self參數，即：obj1.show(obj1)

obj1.show()

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

1)將內容封裝到某處

2)從某處調用被封裝的內容

對於面向對象的封裝來說，其實就是使用構造方法將內容封裝到 對象 中，然後通過對象直接或者self間接獲取被封裝的內容。

3.3 繼承（Inheritance）： 以通用的類為基礎建立專門的類對象。

繼承
class G:
    def g1(self):
        print(‘G.g1‘)
class F(G): #父類，基類
    def f1(self):
        print(‘F.f1‘)
    def f2(self):
        print(‘F.f2‘)
class S(F): #子類，派生類
    def s1(self):
        print(‘S.s1‘)
    def f2(self):
        super(S,self).f2() #固定寫法，執行父類（基類）中的f2方法
        print(‘S.s2‘)
        # F.f2(self) #執行父類（基類）中的f2方法

obj=S()#self執行當前方法的對象
# obj.s2()#s1中的self是形參，此時代指obj
obj.f2()#self永遠指調用方法的調用者
# obj.g1()

多繼承

1、Python的類可以繼承多個類，Java和C#中則只能繼承一個類

2、Python的類如果繼承了多個類，從做到右一次查找，找不到會報錯

class Base:
    def a(self):
        print(‘Base.a‘)
class F0(Base):
    def a1(self):
        print(‘F0.a‘)
class F1(F0):
    def a1(self):
        print(‘F1.a‘)
class F2(Base):
    def a(self):
        print(‘F2,a‘)
class S(F1,F2):
    pass
obj=S()
obj.a()  #從左到右找,查找順序S-->F1-->F2

python抽象篇：面向對象