怎么在Python中實現(xiàn)類的封裝與繼承

這期內(nèi)容當(dāng)中小編將會給大家?guī)碛嘘P(guān)怎么在Python中實現(xiàn)類的封裝與繼承，文章內(nèi)容豐富且以專業(yè)的角度為大家分析和敘述，閱讀完這篇文章希望大家可以有所收獲。

訪問限制（封裝）

1、概念

面向?qū)ο笳Z言的三大特征:封裝, 繼承, 多態(tài)。

廣義的封裝: 類和函數(shù)的定義本身就是封裝的體現(xiàn)。

狹義的封裝:一個類的某些屬性,不希望外界直接訪問,而是把這個屬性私有化[只有當(dāng)前類持有],然后暴露給外界一個訪問的方法。

封裝的本質(zhì):就是屬性私有化的過程。

封裝的好處:提供了數(shù)據(jù)的復(fù)用性,保證了數(shù)據(jù)的安全性。

舉例:插排

2、使用

class Person(object):
 def __init__(self, name, age, height, weight, money):
  self.name = name
  self.__age__ = age
  self.weight = weight
  self.__money = money
  self.__height = height
 def run(self):
  print(self.__money)
 def eat(self):
  print("eat")
 # 通過內(nèi)部方法,去修改、獲取私有屬性
 # 通過自定義的方法實現(xiàn)對私有屬性的賦值與取值
 # set方法:setxxx
 def setMoney(self, money):
  # 數(shù)據(jù)的過濾
  if money < 0:
   money = 0
  self.__money = money
 # get方法:getXXX
 def getMoney(self):
  return self.__money
per = Person("hanmeimei", 20, 170, 55, 10000)
# 1.屬性被私有化之后的訪問
# 如果要讓內(nèi)部屬性不被外部直接訪問,在屬性前加兩個下劃線(__),
# 在python中如果在屬性前面加兩個下劃線,name這個屬性就變成了私有屬性[private]
# 私有屬性的含義:在外界不能像以前那么直接訪問
# print(per.__money) #無法在外界直接訪問
per.run() # 內(nèi)部可以訪問
# 2.解決辦法: 如何對私有屬性取值和賦值
# 屬性被私有化之后,可以通過get/set的方法進(jìn)行訪問
per.setMoney(10)
print(per.getMoney())
# 3.工作原理
# 不能直接訪問per.__money是因為python解釋器把__money變成了_Person__money
# 仍然可以使用_Person__money去訪問,但是強(qiáng)烈不建議這么干,不同的解釋器可能存在解釋的變量名不一致的問題
per._Person__money = 1
print(per.getMoney())
# 4.特殊情況
# 在Python中 __xxx__ 屬于特殊變量,將不再屬于私有變量,可以直接訪問
print(per.__age__)
# 在python中 __xxx變量,這樣的實例變量外部是可以訪問的,但是,按照約定的規(guī)則
# 當(dāng)我們看到這樣的變量時,意思雖然是"雖然我可以被訪問,但是請把我視為私有變量,不要直接訪問我"
print(per._Person__height)

輸出：

10000
10
1
20
170

繼承

1、概念

如果兩個或者兩個以上的類具有相同的屬性和方法,我們可以抽取一個類出來,

在抽取的類中聲明公共的部分

被抽取出來的類 ——父類 超類 基類
其他類 —— 子類 派生類
他們之間的關(guān)系 ——子類繼承自父類

2、單繼承

簡單來說,一個子類只有一個父類,被稱為單繼承

演示:test.py 文件

注意:在使用繼承時,盡量一個類存在于一個模塊中

from person import Person
from student import Student
from worker import Worker
per = Person("aa", 1, 2)
stu = Student("tom", 18, 12345, 110)
print(stu.name, stu.age)
stu.run()
print(stu.stuId)
#私有屬性
#print(stu.__money)
print(stu.getMoney())#通過繼承過來的共有方法訪問私有屬性
#stu.stuFunc()
wor = Worker("lilei", 20, 111)
print(wor.name, wor.age)
wor.eat("apple")
#子類對象調(diào)用父類同名的函數(shù),則優(yōu)先調(diào)用子類中的函數(shù)
#本質(zhì)是子類中的方法覆蓋了父類中同名的函數(shù)
wor.run()
print(per.getMoney())
#父類對象不能訪問子類特有的屬性或方法
#print(per.stuId)

輸出：

tom 18
run
110
12345
lilei 20
eat apple
子類中的run方法被調(diào)用了
2

person.py文件：

#以前的寫法 class Person(object):
#但是實質(zhì)上,如果沒有顯示的寫出父類,則這個類的父類默認(rèn)為object
#object是所有類的父類或者超類
class Person(object):
 #構(gòu)造方法
 def __init__(self, name, age, money):
  self.name = name
  self.age = age
  self.__money = money
  #get/set方法
 def setMoney(self, money):
  self.__money = money
 def getMoney(self):
  return self.__money
 def run(self):
  print("run")
 def eat(self, food):
  print("eat", food)

#student.py文件
from person import Person
class Student(Person):
 def __init__(self, name, age, money, stuId):
  #調(diào)用父類中的構(gòu)造方法
  #方法1 super(當(dāng)前類,self).__init__(參數(shù)列表)
  #super(Student,self).__init__(name, age, money, stuId)
  #方法2 父類名.__init__(屬性列表)
  Person.__init__(self, name, age, money)
  #子類可以有一些自己獨有的屬性
  self.stuId = stuId
 def setFunc(self):
  print(self.__money)

#worker.py文件
from person import Person
class Worker(Person):
 def __init__(self, name, age, money):
  super(Worker,self).__init__(name, age, money)
 # 在子類中定義和一個父類中重名的函數(shù)
 def run(self):
  print("子類中的run方法被調(diào)用了")

總結(jié):

繼承的特點:

a. 子類對象可以直接訪問父類中未私有的對象
b. 子類對象可以調(diào)用父類中的方法
c. 父類對象不能訪問子類中特有的屬性或者方法

優(yōu)缺點:

優(yōu)點:

1.可以簡化代碼,減少冗余
2.提高代碼的維護(hù)性
3.提高了代碼的安全性

缺點:

耦合和內(nèi)聚被用來描述類與類之間的關(guān)系,耦合性越低,內(nèi)聚性越高,說明代碼越好。
但是,在繼承關(guān)系中,耦合性相對比較高,如果修改父類,子類也會隨著變化。

3、多繼承

顧名思義:就是一個子類中可以有多個父類,比如一個孩子有一個爸爸一個媽媽

from child import Child
def main():
 c = Child(300, 100,"xiaoming")
 print(c.money, c.faceValue)
 c.play()
 c.eat()
 #注意:如果多個父類中的方法名相同,默認(rèn)調(diào)用的是子類括號中排前面的父類中的方法
 #此時調(diào)用的是Father中func方法
if __name__ == "__main__":
 main()

輸出：

300 100
play
eat

#father.py文件
class Father(object):
 def __init__(self, money):
  self.money = money
 def play(self):
  print("play")
 def func(self):
  print("Father")

#mother.py文件
class Mother(object):
 def __init__(self, faceValue):
  self.faceValue = faceValue
 def eat(self):
  print("eat")
 def func(self):
  print("Mother")

#child.py文件
from father import Father
from mother import Mother
class Child(Father, Mother):
 def __init__(self, money, faceValue,name):
  #注意:分別調(diào)用各個父類中的構(gòu)造方法
  Father.__init__(self, money)
  Mother.__init__(self, faceValue)
  #子類中同樣可以有自己獨有的特性
  self.name = name

總結(jié):

子類可以從多個父類中繼承屬性和方法
一個父類可以有多個子類
一個子類可以有多個父類

4、函數(shù)重寫

4.1、系統(tǒng)函數(shù)

'''
重寫:將函數(shù)重寫一遍
__str__():在調(diào)用print打印對象時自動調(diào)用,是給用戶用的,是一個描述對象的方法.
__repr__():是給機(jī)器用的,在python解釋器里面直接敲對象名在回車后調(diào)用方法
注意:在沒有str,且有repr時,str=repr
'''
class Animal(object):
 def __init__(self, name, age, height, weight):
  self.name = name
  self.age = age
  self.height = height
  self.weight = weight
 def __str__(self):
  return "%s-%d-%d-%d"%(self.name, self.age, self.height, self.weight)
ani = Animal("大黃", 5, 60, 25)
#print(per.name, per.age, per.height, per.weight)
#在打印ani時自動調(diào)用str函數(shù)
print(ani)
#優(yōu)點或者使用時機(jī):當(dāng)一個對象的屬性值很多,并且都需要打印,重寫__str__方法后,簡化了代碼,方便查看.

輸出：

大黃-5-60-25

5、自定義函數(shù)

重寫函數(shù)的時機(jī):當(dāng)父類中函數(shù)的功能滿足不了子類的需求時,就可以進(jìn)行重寫。
演示:

from smallAnimal import SmallAnimal
from cat import Cat
c = Cat()
c.func()

#smallAnimal.py文件
class SmallAnimal(object):
 def func(self):
  print("wwww")

#cat.py文件
from smallAniml import SmallAnimal
class Cat(SmallAnimal):
 def func(self):
  print("呵呵呵")

Python的優(yōu)點有哪些

1、簡單易用，與C/C++、Java、C# 等傳統(tǒng)語言相比，Python對代碼格式的要求沒有那么嚴(yán)格；2、Python屬于開源的，所有人都可以看到源代碼，并且可以被移植在許多平臺上使用；3、Python面向?qū)ο?，能夠支持面向過程編程,也支持面向?qū)ο缶幊蹋?、Python是一種解釋性語言，Python寫的程序不需要編譯成二進(jìn)制代碼，可以直接從源代碼運行程序；5、Python功能強(qiáng)大，擁有的模塊眾多，基本能夠?qū)崿F(xiàn)所有的常見功能。

上述就是小編為大家分享的怎么在Python中實現(xiàn)類的封裝與繼承了，如果剛好有類似的疑惑，不妨參照上述分析進(jìn)行理解。如果想知道更多相關(guān)知識，歡迎關(guān)注億速云行業(yè)資訊頻道。