python ====面向對象=== 16


面向對象 

  什么時候使用面向對象?

    代碼量大,  功能多的時候

    處理比較復雜的角色之間的關系的時候

  代碼的清晰度更高:

    可讀性    :   無論是開發者還是調用者都能明確  的分辨出每個角色擁有的方法

    增加了代碼的可擴展性

    更加規范

類:  具有相同屬性和技能的一類事物     比如   :  人類

    類和類型  是一個東西   每個類型都是一個類   

    type( obj )   obj是一個對象,  那么它的type  就是它的類型

  創建一個類 :   

      class  類名    類也是被創建出來的,   被 type創建出來的類  

        type ( 對象 )   ===>   對象所在的類名

        type( 類名 )  ===>    type類型      除非制定class  類名(metaclass=***)     那么type就是這個類的元類

      class  A( metaclass=ABCMeta):

          那么  ABCMeta  創建了  A類  那么ABCMeta  就是A的元類   

      其他的  type  是所有類的元類

對象 :   python中 一切皆為對象   基礎的數據類型  都是對象

  具體的某一個事物 , 具體的類的表現 

   ,具體到類中的某一個東西,某個實例   ,   例如 :  張傑

  類創造對象的過程就是實例化的過程    先new開辟空間  再init初始化

  可以通過指針類找到類的空間中的內容   

  對象本身內部也儲存了一些只屬於對象的屬性

定義一個人類:     類名首字母必須大寫

class  Person:           #  定義一個類     人類(類名)

  mind = " 有思想的 "     ====>

  animal = " 高級動物 "        ===>     靜態變量  部分    靜態字段    變量

  faith = " 有信仰的 "     =====     

  def  _ _init_ _(self):            #      構造方法

    print(666)

  def  work(self) :

    print("會工作...")

  def  shop(self) :

    print("可以消費")

從類名的角度調用類中的靜態變量

  print(Person. _ _dict_ _)  #    查詢 類中所有的內容,  查出來形式是 字典的形式

  print( Person . _ _dict_ _[ faith ]  )  ===>  有信仰的     # 類名的角度調用靜態變量,但是  一般查詢單個內容不用_ _dict_ _查詢

  Person._ _dict_ _不能進行增刪改     只能查

 

從類名的角度對  類中的單個變量進行  增刪改查  

  用  萬能的  點   .      類名 . 屬性

  print( Person.mind )  ===>  有思想的     #   查詢靜態變量

  print( Person. animal )  ===>   高級動物    

 

  Person . money  = " 運用貨幣 "   #   增加一個 靜態變量   

  print(Person._ _dict_ _)   打印可以看到其中多了   money: 運用貨幣

 

  Person . mind = " 無腦的  "      #   修改    靜態變量

  print(Person._ _dict_ _)   打印可以看到  其中 有思想的    改為了   無腦的

 

  del Person.mind     #   刪除   靜態變量 

  print(Person._ _dict_ _)   打印可以看到   mind= " 無腦的 "   被刪除了

 

從類名的角度  操作類中的方法  (工作中基本不用)

  Person . work( 111 )  ==> 都會工作... 

 

從對象的角度   操作

 

類名 + ( )  : 過程  :  實例化過程  ,  相當於創建了一個  實例的 對象

Person( )   

1.  只要有 一個  類名+ ()    就會產生一個對象  自動執行  _ _init_ _  函數方法

  ret=Person()    #   看似沒有對象實際上是將  對象傳給 self   自動傳給第一個位置參數   self

  print(ret) ===> 666

def  _ _init_ _(self,name,age,hobby):            #      構造方法

    self.name=name

    self.age=age

    self.hobby=hobby

    print(name,age,hobby)

  ret=person("alex",28,"IT")

  print(ret)===>   alex,28,IT

 

實例化過程

:   1.     類名+()   產生一個實實例 ( 對象 )  (對象空間) 

  2.     自動執行類中的 _ _ init_ _方法  並將對象空間傳給 _ _init_ _中的 self  

  3.    執行具體的 _ _init _ _中的代碼   ., 給對象  封裝相應的  屬性   

    _ _iniit_ -中的self 后邊的參數  就是封裝的  屬性    例如:

                              self.name=name

                              self.age=age

                              self.hobby=hobby

        

對象的角度  操縱類中的靜態變量    

  print(ret.mind)   ===>   有思想    #   只能查 

  1.   對象名 . _ _dict_ _     #查詢 對象中  所有的內容  

    p1=Person("alex", 28, "IT")

       print(p1._ _dict_ _)====>   {'name': 'alex',  'age': 28, 'hobby': "IT"}

  2.  萬能的  .   對象名. 屬性

    print( p1.name )====>  alex   #   查詢  

    p1.hight = 175     #  增加

    print( p1._ _dict_ _)   可以看出   {'name': 'alex',  'age': 28, 'hobby': "IT"  , "hight" : 175 }

    del  p1. name     #   刪除

    print( p1._ _dict_ _)   可以看出    {  'age': 28, 'hobby': "IT"  , "hight" : 175 }

    p1.age=73

    print( p1._ _dict_ _)   可以看出   {  'age': 73, 'hobby': "IT"  , "hight" : 175 }

對象的角度   調用類中的方法   :   

    第一個參數不用傳  , 

    工作中常用  ,通過對象 執行類中的方法  ,而不是通過類名

    p1.shop()

操作類中的方法  除了類方法. 靜態方法   需要用類名調用之外,  剩下的方法,  都要用對象名調用

  在類中添加屬性

    def  func(self):

      self.hight=175

 

為什么要在   _ _init_ -中封裝屬性?

  因為 ,在他里邊封裝.   只要有 類名 +( )  它就可以自動執行    方便

 

計算實例化次數

  class  Count:

    count=0

    def   _ _init_ _(self):  

      Count.count=Count.count  +1   #  Count.count  指的是靜態變量的 count   

                      ,因此    最終結果只能用 Count.count  來表示

或者       Count.count= self.count  +1       #   self.count   這時傳進去的count  和外邊的是一樣的,但是結果必須用

                      Cont.count表示                                          

  odj=count()

  obj1=count()

  print(Count.ount)  ===>2 

 

查詢順序

  通過  類名  查詢   

    類名 . 屬性    先從本類  空間中找   ,如果找不到  再從父類中找  ,

  通過   對象查詢

    對象 . 屬性     先從對象所在空間 找,  若找不到  再從所在類的空間找,   再找不到,   再去父類中找...

 

通過類名  可以改變 類中的靜態變量的值  

  但是 通過對象  不能改變,  只能引用類中的靜態變量  ,   因為   通過對象一改  就相當於  新增了  一個屬性

 

 

 

 

 

 

 


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
  © 2014-2022 ITdaan.com 联系我们: