python簡單學------------python面向對象(2)
保護對象的屬性
如果有一個對象,當需要對其進行修改屬性時,有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()
![技術分享圖片](http://image.bubuko.com/info/201901/20190122234508640836.png)
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)
![技術分享圖片](http://image.bubuko.com/info/201901/20190122234509000225.png)
靜態方法和類方法
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)