保護對象的屬性

如果有一個對象，當需要對其進行修改屬性時，有2種方法

• 對象名.屬性名 = 數據 ---->直接修改
• 對象名.方法名() ---->間接修改

為了更好的保存屬性安全，即不能隨意修改，一般的處理方式為

• 將屬性定義為私有屬性
• 添加一個可以調用的方法，供調用

class People(object):

    def __init__(self, name):
        self.__name = name

    def getName(self):
        return self.__name

    def setName(self, newName):
        if len(newName) >= 5:
            self.__name = newName
        else:
            print("error:名字長度需要大於或者等於5")

xiaoming = People("dongGe")
print(xiaoming.__name)
 

class People(object):

    def __init__(self, name):
        self.__name = name

    def getName(self):
        return self.__name

    def setName(self, newName):
        if len(newName) >= 5:
            self.__name = newName
        else:
            print("error:名字長度需要大於或者等於5")

xiaoming = People("dongGe")

xiaoming.setName("wanger")
print(xiaoming.getName())

xiaoming.setName("lisi")
print(xiaoming.getName())
 

class People(object):

    def __init__(self, name):
        self.__name = name

    def getName(self):
        return self.__name

    def setName(self, newName):
        if len(newName) >= 5:
            self.__name = newName
        else:
            print("error:名字長度需要大於或者等於5")

xiaoming = People("dongGe")

xiaoming.setName("wanger")
print(xiaoming.getName())

xiaoming.setName("lisi")
print(xiaoming.getName())
 

總結

• Python中沒有像C++中public和private這些關鍵字來區別公有屬性和私有屬性
• 它是以屬性命名方式來區分，如果在屬性名前面加了2個下劃線‘__‘，則表明該屬性是私有屬性，否則為公有屬性（方法也是一樣，方法名前面加了2個下劃線的話表示該方法是私有的，否則為公有的）。

__del__()方法

創建對象後，python解釋器默認調用__init__()方法；

當刪除一個對象時，python解釋器也會默認調用一個方法，這個方法為__del__()方法

import time
class Animal(object):

    # 初始化方法
    # 創建完對象後會自動被調用
    def __init__(self, name):
        print(‘__init__方法被調用‘)
        self.__name = name


    # 析構方法
    # 當對象被刪除時，會自動被調用
    def __del__(self):
        print("__del__方法被調用")
        print("%s對象馬上被幹掉了..."%self.__name)

# 創建對象
dog = Animal("哈皮狗")

# 刪除對象
del dog


cat = Animal("波斯貓")
cat2 = cat
cat3 = cat

print("---馬上 刪除cat對象")
del cat
print("---馬上 刪除cat2對象")
del cat2
print("---馬上 刪除cat3對象")
del cat3

print("程序2秒鐘後結束")
time.sleep(2)

結果:

總結

• 當有1個變量保存了對象的引用時，此對象的引用計數就會加1
• 當使用del刪除變量指向的對象時，如果對象的引用計數不會1，比如3，那麽此時只會讓這個引用計數減1，即變為2，當再次調用del時，變為1，如果再調用1次del，此時會真的把對象進行刪除

繼承介紹以及單繼承

1. 繼承的概念

在現實生活中，繼承一般指的是子女繼承父輩的財產，如下圖

在程序中，繼承描述的是事物之間的所屬關系，例如貓和狗都屬於動物，程序中便可以描述為貓和狗繼承自動物；同理，波斯貓和巴厘貓都繼承自貓，而沙皮狗和斑點狗都繼承足夠，如下如所示：

2. 繼承示例

# 定義一個父類，如下:
class Cat(object):

    def __init__(self, name, color="白色"):
        self.name = name
        self.color = color

    def run(self):
        print("%s--在跑"%self.name)


# 定義一個子類，繼承Cat類如下:
class Bosi(Cat):

    def setNewName(self, newName):
        self.name = newName

    def eat(self):
        print("%s--在吃"%self.name)


bs = Bosi("印度貓")
print(‘bs的名字為:%s‘%bs.name)
print(‘bs的顏色為:%s‘%bs.color)
bs.eat()
bs.setNewName(‘波斯‘)
bs.run()

運行結果:

說明：

• 雖然子類沒有定義__init__方法，但是父類有，所以在子類繼承父類的時候這個方法就被繼承了，所以只要創建Bosi的對象，就默認執行了那個繼承過來的__init__方法

總結

• 子類在繼承的時候，在定義類時，小括號()中為父類的名字
• 父類的屬性、方法，會被繼承給子類

3. 註意點

class Animal(object):

    def __init__(self, name=‘動物‘, color=‘白色‘):
        self.__name = name
        self.color = color

    def __test(self):
        print(self.__name)
        print(self.color)

    def test(self):
        print(self.__name)
        print(self.color)



class Dog(Animal):
    def dogTest1(self):
        #print(self.__name) #不能訪問到父類的私有屬性
        print(self.color)


    def dogTest2(self):
        #self.__test() #不能訪問父類中的私有方法
        self.test()


A = Animal()
#print(A.__name) #程序出現異常，不能訪問私有屬性
print(A.color)
#A.__test() #程序出現異常，不能訪問私有方法
A.test()

print("------分割線-----")

D = Dog(name = "小花狗", color = "黃色")
D.dogTest1()
D.dogTest2()

• 私有的屬性，不能通過對象直接訪問，但是可以通過方法訪問
• 私有的方法，不能通過對象直接訪問
• 私有的屬性、方法，不會被子類繼承，也不能被訪問
• 一般情況下，私有的屬性、方法都是不對外公布的，往往用來做內部的事情，起到安全的作用

多繼承

1. 多繼承

從圖中能夠看出，所謂多繼承，即子類有多個父類，並且具有它們的特征

Python中多繼承的格式如下:

# 定義一個父類
class A:
    def printA(self):
        print(‘----A----‘)

# 定義一個父類
class B:
    def printB(self):
        print(‘----B----‘)

# 定義一個子類，繼承自A、B
class C(A,B):
    def printC(self):
        print(‘----C----‘)

obj_C = C()
obj_C.printA()
obj_C.printB()

運行結果:

----A----
----B----

說明

• python中是可以多繼承的
• 父類中的方法、屬性，子類會繼承

註意點

• 想一想:

  如果在上面的多繼承例子中，如果父類A和父類B中，有一個同名的方法，那麽通過子類去調用的時候，調用哪個？

#coding=utf-8
class base(object):
    def test(self):
        print(‘----base test----‘)
class A(base):
    def test(self):
        print(‘----A test----‘)

# 定義一個父類
class B(base):
    def test(self):
        print(‘----B test----‘)

# 定義一個子類，繼承自A、B
class C(A,B):
    pass


obj_C = C()
obj_C.test()

print(C.__mro__) #可以查看C類的對象搜索方法時的先後順序

重寫父類方法與調用父類方法

1. 重寫父類方法

所謂重寫，就是子類中，有一個和父類相同名字的方法，在子類中的方法會覆蓋掉父類中同名的方法

#coding=utf-8
class Cat(object):
    def sayHello(self):
        print("halou-----1")


class Bosi(Cat):

    def sayHello(self):
        print("halou-----2")

bosi = Bosi()

bosi.sayHello()

2. 調用父類的方法

#coding=utf-8
class Cat(object):
    def __init__(self,name):
        self.name = name
        self.color = ‘yellow‘


class Bosi(Cat):

    def __init__(self,name):
        # 調用父類的__init__方法1(python2)
        #Cat.__init__(self,name)
        # 調用父類的__init__方法2
        #super(Bosi,self).__init__(name)
        # 調用父類的__init__方法3
        super().__init__(name)

    def getName(self):
        return self.name

bosi = Bosi(‘xiaohua‘)

print(bosi.name)
print(bosi.color)

多態

多態的概念是應用於Java和C#這一類強類型語言中，而Python崇尚“鴨子類型”。

所謂多態：定義時的類型和運行時的類型不一樣，此時就成為多態

• Python偽代碼實現Java或C#的多態

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

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

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

# 由於在Java或C#中定義函數參數時，必須指定參數的類型
# 為了讓Func函數既可以執行S1對象的show方法，又可以執行S2對象的show方法，所以，定義了一個S1和S2類的父類
# 而實際傳入的參數是：S1對象和S2對象

def Func(F1 obj):
    """Func函數需要接收一個F1類型或者F1子類的類型"""

    print obj.show()

s1_obj = S1()
Func(s1_obj) # 在Func函數中傳入S1類的對象 s1_obj，執行 S1 的show方法，結果：S1.show

s2_obj = S2()
Func(s2_obj) # 在Func函數中傳入Ss類的對象 ss_obj，執行 Ss 的show方法，結果：S2.show

• Python “鴨子類型”

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

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)

類屬性、實例屬性

在了解了類基本的東西之後，下面看一下python中這幾個概念的區別

先來談一下類屬性和實例屬性

在前面的例子中我們接觸到的就是實例屬性（對象屬性），顧名思義，類屬性就是類對象所擁有的屬性，它被所有類對象的實例對象所共有，在內存中只存在一個副本，這個和C++中類的靜態成員變量有點類似。對於公有的類屬性，在類外可以通過類對象和實例對象訪問

類屬性

class People(object):
    name = ‘Tom‘  #公有的類屬性
    __age = 12     #私有的類屬性

p = People()

print(p.name)           #正確
print(People.name)      #正確
print(p.__age)            #錯誤，不能在類外通過實例對象訪問私有的類屬性
print(People.__age)        #錯誤，不能在類外通過類對象訪問私有的類屬性

實例屬性(對象屬性)

class People(object):
    address = ‘山東‘ #類屬性
    def __init__(self):
        self.name = ‘xiaowang‘ #實例屬性
        self.age = 20 #實例屬性

p = People()
p.age =12 #實例屬性
print(p.address) #正確
print(p.name)    #正確
print(p.age)     #正確

print(People.address) #正確
print(People.name)    #錯誤
print(People.age)     #錯誤

通過實例(對象)去修改類屬性

class People(object):
    country = ‘china‘ #類屬性


print(People.country)
p = People()
print(p.country)
p.country = ‘japan‘ 
print(p.country)      #實例屬性會屏蔽掉同名的類屬性
print(People.country)
del p.country    #刪除實例屬性
print(p.country)

靜態方法和類方法

1. 類方法

是類對象所擁有的方法，需要用修飾器@classmethod來標識其為類方法，對於類方法，第一個參數必須是類對象，一般以cls作為第一個參數（當然可以用其他名稱的變量作為其第一個參數，但是大部分人都習慣以‘cls‘作為第一個參數的名字，就最好用‘cls‘了），能夠通過實例對象和類對象去訪問。

class People(object):
    country = ‘china‘

    #類方法，用classmethod來進行修飾
    @classmethod
    def getCountry(cls):
        return cls.country

p = People()
print p.getCountry()    #可以用過實例對象引用
print People.getCountry()    #可以通過類對象引用

類方法還有一個用途就是可以對類屬性進行修改：

class People(object):
    country = ‘china‘

    #類方法，用classmethod來進行修飾
    @classmethod
    def getCountry(cls):
        return cls.country

    @classmethod
    def setCountry(cls,country):
        cls.country = country


p = People()
print p.getCountry()    #可以用過實例對象引用
print People.getCountry()    #可以通過類對象引用

p.setCountry(‘japan‘)   

print p.getCountry()   
print People.getCountry()

結果顯示在用類方法對類屬性修改之後，通過類對象和實例對象訪問都發生了改變

2. 靜態方法

需要通過修飾器@staticmethod來進行修飾，靜態方法不需要多定義參數

class People(object):
    country = ‘china‘

    @staticmethod
    #靜態方法
    def getCountry():
        return People.country


print People.getCountry()

總結

從類方法和實例方法以及靜態方法的定義形式就可以看出來，類方法的第一個參數是類對象cls，那麽通過cls引用的必定是類對象的屬性和方法；而實例方法的第一個參數是實例對象self，那麽通過self引用的可能是類屬性、也有可能是實例屬性（這個需要具體分析），不過在存在相同名稱的類屬性和實例屬性的情況下，實例屬性優先級更高。靜態方法中不需要額外定義參數，因此在靜態方法中引用類屬性的話，必須通過類對象來引用

總結

• 如果需要在類外修改類屬性，必須通過類對象去引用然後進行修改。如果通過實例對象去引用，會產生一個同名的實例屬性，這種方式修改的是實例屬性，不會影響到類屬性，並且之後如果通過實例對象去引用該名稱的屬性，實例屬性會強制屏蔽掉類屬性，即引用的是實例屬性，除非刪除了該實例屬性。

python簡單學------------python面向對象(2)