python 學習筆記7 面向對象編程

1、概述

• 面向過程：根據業務邏輯從上到下寫壘代碼
• 函數式：將某功能代碼封裝到函數中，往後便無需重複編寫，僅調用函數便可
• 面向對象：對函數進行分類和封裝，讓開發「更快更好更強...」

2、建立類和對象

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

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

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

#建立類
class Foo:   #class 關鍵字，表示要建立類，Foo 類名稱
    #建立類中的函數    
    def Bar(self):  #self 特殊參數，必填
        #do something

# 根據類Foo建立對象obj
obj = Foo()

• class是關鍵字，表示類
• 建立對象，類名稱後加括號便可

#建立類
class Dog(object):

    def __init__(self,name): #構造函數，構造方法 ==初始化方法
        self.NAME = name

    def sayhi(self): #類的方法
        print("hello , I am a dog. my name is", self.NAME )

    def eat(self,food):
        print("%s is eating %s" %(self.NAME,food))

print(Dog)

d = Dog("LiChang") # Dog(d,"LiChang")  #實例化後產生的對象 叫 實例 ，
d2 = Dog("Chuang2")
#根據Dog 建立對象
d.sayhi()
d2.sayhi()

d.eat("baozi")

• 面向對象：【建立對象】【經過對象執行方法】
• 函數編程：【執行函數】

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

 

面向對象三大特性

　　

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

1、封裝

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

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

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

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

 

#建立類
class Foo:
    def __init__(self,name,age):  #稱爲構造方法，根據類建立對象時自動執行
        self.name = name
        self.age = age
    #根據類Foo建立對象
    #自動執行Foo類的__init__方法
obj1 = Foo("admin",18)  #將admin和18分別封裝到obj1 self的name和age屬性中

#根據類Foo建立對象
#自動執行Foo類的__init__方法
obj2 = Foo("zewei",19) #將zewei和19分別封裝到obj2 self的name和age屬性中

 

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

                              當執行 obj2 = Foo('zewei',19 ) 時，self 等於 obj2

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

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

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

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

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

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

class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age


obj1 = Foo('wupeiqi', 18)
print(obj1.name)  # 直接調用obj1對象的name屬性
print(obj1.age)  # 直接調用obj1對象的age屬性

obj2 = Foo('alex', 73)
print(obj2.name)  # 直接調用obj2對象的name屬性
print(obj2.age)  # 直接調用obj2對象的age屬性

二、經過self間接調用被封裝的內容

執行類中的方法時，須要經過self間接調用被封裝的內容

class Foo:
  
    def __init__(self, name, age):
        self.name = name
        self.age = age
  
    def detail(self):
        print self.name
        print self.age
  
obj1 = Foo('wupeiqi', 18)
obj1.detail()  # Python默認會將obj1傳給self參數，即：obj1.detail(obj1)，因此，此時方法內部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
  
obj2 = Foo('alex', 73)
obj2.detail()  # Python默認會將obj2傳給self參數，即：obj1.detail(obj2)，因此，此時方法內部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

 

 

類的語法

class Dog(object):
 
    def __init__(self,name,dog_type):
        self.name = name
        self.type = dog_type
 
    def sayhi(self):
 
        print("hello,I am a dog, my name is ",self.name)
 
 
d = Dog('LiChuang',"京巴")
d.sayhi()

self,就是實例自己！你實例化時python會自動把這個實例自己經過self參數傳進去。

class Role(object): #定義一個類， class是定義類的語法，Role是類名，(object)是新式類的寫法，必須這樣寫，之後再講爲何
    def __init__(self,name,role,weapon,life_value=100,money=15000): #初始化函數，在生成一個角色時要初始化的一些屬性就填寫在這裏
        self.name = name #__init__中的第一個參數self,和這裏的self都 是什麼意思？ 看下面解釋
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

繼承

面向對象編程 (OOP) 語言的一個主要功能就是「繼承」。繼承是指這樣一種能力：它可使用現有類的全部功能，並在無需從新編寫原來的類的狀況下對這些功能進行擴展。

經過繼承建立的新類稱爲「子類」或「派生類」。

被繼承的類稱爲「基類」、「父類」或「超類」。

繼承的過程，就是從通常到特殊的過程。

要實現繼承，能夠經過「繼承」（Inheritance）和「組合」（Composition）來實現。

在某些 OOP 語言中，一個子類能夠繼承多個基類。可是通常狀況下，一個子類只能有一個基類，要實現多重繼承，能夠經過多級繼承來實現。

繼承概念的實現方式主要有2類：實現繼承、接口繼承。

Ø         實現繼承是指使用基類的屬性和方法而無需額外編碼的能力；

Ø         接口繼承是指僅使用屬性和方法的名稱、可是子類必須提供實現的能力(子類重構爹類方法)；

在考慮使用繼承時，有一點須要注意，那就是兩個類之間的關係應該是「屬於」關係。例如，Employee 是一我的，Manager 也是一我的，所以這兩個類均可以繼承 Person 類。可是 Leg 類卻不能繼承 Person 類，由於腿並非一我的。

 

抽象類僅定義將由子類建立的通常屬性和方法。

OO開發範式大體爲：劃分對象→抽象類→將類組織成爲層次化結構(繼承和合成) →用類與實例進行設計和實現幾個階段。

繼承示例

 

class SchoolMember(object):
    members = 0 #初始學校人數爲0
    def __init__(self,name,age):
        self.name = name
        self.age = age
 
    def  tell(self):
        pass
 
    def enroll(self):
        '''註冊'''
        SchoolMember.members +=1
        print("\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m " %(self.name,SchoolMember.members))
     
    def __del__(self):
        '''析構方法'''
        print("\033[31;1mmember [%s] is dead!\033[0m" %self.name)
class Teacher(SchoolMember):
    def __init__(self,name,age,course,salary):
        super(Teacher,self).__init__(name,age)
        self.course = course
        self.salary = salary
        self.enroll()
 
 
    def teaching(self):
        '''講課方法'''
        print("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course,'s12'))
 
    def tell(self):
        '''自我介紹方法'''
        msg = '''Hi, my name is [%s], works for [%s] as a [%s] teacher !''' %(self.name,'Oldboy', self.course)
        print(msg)
 
class Student(SchoolMember):
    def __init__(self, name,age,grade,sid):
        super(Student,self).__init__(name,age)
        self.grade = grade
        self.sid = sid
        self.enroll()
 
 
    def tell(self):
        '''自我介紹方法'''
        msg = '''Hi, my name is [%s], I'm studying [%s] in [%s]!''' %(self.name, self.grade,'Oldboy')
        print(msg)
 
if __name__ == '__main__':
    t1 = Teacher("Alex",22,'Python',20000)
    t2 = Teacher("TengLan",29,'Linux',3000)
 
    s1 = Student("Qinghua", 24,"Python S12",1483)
    s2 = Student("SanJiang", 26,"Python S12",1484)
 
    t1.teaching()
    t2.teaching()
    t1.tell()

 

 

多態

多態性（polymorphisn）是容許你將父對象設置成爲和一個或更多的他的子對象相等的技術，賦值以後，父對象就能夠根據當前賦值給它的子對象的特性以不一樣的方式運做。簡單的說，就是一句話：容許將子類類型的指針賦值給父類類型的指針。

那麼，多態的做用是什麼呢？咱們知道，封裝能夠隱藏實現細節，使得代碼模塊化；繼承能夠擴展已存在的代碼模塊（類）；它們的目的都是爲了——代碼重用。而多態則是爲了實現另外一個目的——接口重用！多態的做用，就是爲了類在繼承和派生的時候，保證使用「家譜」中任一類的實例的某一屬性時的正確調用。

 

Pyhon不直接支持多態，但能夠間接實現

經過Python模擬的多態

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")
 
class Cat(Animal):
    def talk(self):
        return 'Meow!'
 
class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'
 
animals = [Cat('Missy'),
           Dog('Lassie')]
 
for animal in animals:
    print animal.name + ': ' + animal.talk()