日韩久久久精品,亚洲精品久久久久久久久久久,亚洲欧美一区二区三区国产精品 ,一区二区福利

python基礎(chǔ)學(xué)習(xí)筆記(八)

系統(tǒng) 1692 0

python基礎(chǔ)學(xué)習(xí)筆記(八)

2013-04-26 00:11 ?蟲師 閱讀( ... ) 評論( ... ) 編輯 收藏

創(chuàng)建自已對象就 python 非常核心的概念,事實上, python 被稱為面向?qū)ο笳Z言,本章會介紹如何創(chuàng)建對象。以及面向?qū)ο蟮母拍睿豪^承、封裝、多態(tài)。

?

  • 多態(tài):?可對不同類的對象使用同樣的操作。
  • 封裝:對外部世界隱藏對象的工作細(xì)節(jié)。?
  • 繼承:以普通的類為基礎(chǔ)建立專門的類對象。

?

?

多態(tài)

面向?qū)ο蟪绦蛟O(shè)計最有趣的特性是多太,它是是讓大多數(shù)人犯暈的特性。所以,先來介紹這個。

多態(tài)意思是“有多種形式”。多態(tài)意味著就算不知道變量所引用的對象類是什么,還是能對它進(jìn)行操作,而它也會根據(jù)對象(或類)類型的不同而表現(xiàn)出不同的行為。

?

從最簡單的開始

  任何不知道對象到底是什么類型,但是又要對對象“做點什么”的時候,都會用到多態(tài)。這不僅限于方法 ---- 很多內(nèi)建運算符和函數(shù)都有多態(tài)的性質(zhì),考慮下面這個例子:

                >>> 1 + 2
3
>>> 
                
                  '
                
                
                  fish
                
                
                  '
                
                 + 
                
                  '
                
                
                  license
                
                
                  '
                
                
                  '
                
                
                  fishlicense
                
                
                  '
                
              

?

這里的加運算符對于數(shù)字(本例中為整數(shù))和字符串(以及其他類型的序列)都能起作用。假設(shè)有個叫做 add 的函數(shù),它可以將兩個對象相加。那么可以直接將其定義成上面的形式,對于很多類型的參數(shù)都可以用,如下:

                >>> 
                
                  def
                
                
                   add(x,y):
    
                
                
                  return
                
                 x+
                
                  y


                
                >>> add(1,2
                
                  )

                
                3
>>> add(
                
                  '
                
                
                  hello.
                
                
                  '
                
                ,
                
                  '
                
                
                  world
                
                
                  '
                
                
                  )

                
                
                  '
                
                
                  hello.world
                
                
                  '
                
              

看起來有點傻,但是關(guān)鍵在于參數(shù)可以是任何支持加法的對象。

?

如果需要編寫打印對象長度消息的函數(shù),則只需對象具有長度( len 函數(shù)可用)即可。

                >>> 
                
                  def
                
                
                   length_message(x):
    
                
                
                  print
                
                
                  "
                
                
                  The length of 
                
                
                  "
                
                 , repr(x),
                
                  "
                
                
                  is
                
                
                  "
                
                
                  ,len(x)

    

                
                >>> length_message(
                
                  '
                
                
                  chongshi
                
                
                  '
                
                
                  )
The length of  
                
                
                  '
                
                
                  chongshi
                
                
                  '
                
                
                  is
                
                 8
>>> length_message([1,2,3
                
                  ])
The length of  [
                
                1, 2, 3] 
                
                  is
                
                 3
              

len 函數(shù)用于計算長度, repr 用于放置函數(shù)的內(nèi)容; repr 函數(shù)是多態(tài)特性的代表之一 --- 可以對任何東西使用。 ?

很多函數(shù)和運算符都是多態(tài)的,你寫的絕大多數(shù)程序可能都是,即便你并非有意這樣。

?

?

封裝

?

封裝是對全局作用域中其它區(qū)域隱藏多余信息的原則。

封裝聽起來有些像多態(tài),因為他們都是?抽象的原則 --- 他們都會幫助處理程序組件而不用過多關(guān)心多余細(xì)節(jié),就像函數(shù)做的一樣。

但是封裝并不等同于多態(tài)。多態(tài)的可以讓用戶對于不知道是什么類(或?qū)ο箢愋停┑膶ο筮M(jìn)行方法調(diào)用,而封裝是可以不用關(guān)心對象是如何構(gòu)建的而直接進(jìn)行使用。

創(chuàng)建一個有對象(通過像調(diào)用函數(shù)一樣調(diào)用類)后,將變量 c 綁定到該對象上。可以使用 setName? 和? getName? 方法(假設(shè)已經(jīng)有)

                >>> c =
                
                   closedObject()

                
                >>> c.setName(
                
                  '
                
                
                  sir lancelot
                
                
                  '
                
                
                  )

                
                >>>
                
                   c.getName()
‘sir lancelot’
                
              

?

?

繼承

我們不想把同一段代碼寫好幾,之前使用的函數(shù)避免了這種情況。但現(xiàn)在又有個更微妙的問題。如果已經(jīng)有了一個類,又想建立一個非常類似的類,只是添加幾個方法。

比如有動物類,我們又想在動物類的基礎(chǔ)上建立鳥類、魚類,哺乳動物類。

?

上面這些特性會根據(jù)后面的學(xué)習(xí)來深入的理解。

?================================

?

?

創(chuàng)建自己的類

?

終于可以創(chuàng)建自己的類了,先來看一個簡單的類:

                _metaclass_ = type 
                
                  #
                
                
                  確定新式類
                
                
                  class
                
                
                   Person:
    
                
                
                  def
                
                
                   setName(self,name):
        self.name 
                
                =
                
                   name

    
                
                
                  def
                
                
                   getName(self):
        
                
                
                  return
                
                
                   self,name

    
                
                
                  def
                
                
                   greet(self):
        
                
                
                  print
                
                
                  "
                
                
                  Hello, world! I'm %s
                
                
                  "
                
                 %self.name
              

注意:新式類的語法中,需要在模塊或者腳本開始的地方放置賦值語句 _metaclass_?=?type ?。

?

創(chuàng)建了一個 Person 的類,這個類包含了三個方法定義,只是那個 self 看起有點奇怪,它是對于對象自身的引用。

讓我們創(chuàng)建實例看看:

                >>> huhu =
                
                   Person()

                
                >>> huhu.setName(
                
                  '
                
                
                  hu zhiheng
                
                
                  '
                
                
                  )

                
                >>>
                
                   huhu.greet()
Hello, world! I
                
                
                  '
                
                
                  m hu zhiheng
                
              

應(yīng)該能說明 self 的用處了,在調(diào)用 huhu setName? 和? greet? 函數(shù)時, huhu 自動將自己作為第一個參數(shù)傳入函數(shù)中 ---- 因此形象地命名為 self 。每個人可能都會有自己的叫法,但是因為它總是對象自身,所以習(xí)慣上總是叫做 self?

?

和之前一樣,特性也可以在外部訪問:

                >>>
                
                   huhu.name

                
                
                  '
                
                
                  hu zhiheng
                
                
                  '
                
                
>>> huhu.name = 
                
                  '
                
                
                  yoda
                
                
                  '
                
                
>>>
                
                   huhu.greet()
Hello, world! I
                
                
                  '
                
                
                  m yoda
                
              

?

?

?

特性、函數(shù)和方法

?

self? 參數(shù)事實上正是方法和函數(shù)的區(qū)別。方法將它們的第一個參數(shù)綁定到所屬的實例上,因此這個參數(shù)可以不必提供。所以可以將特性綁定到一個普通函數(shù)上,這樣就不會有特殊的 self 參數(shù)了:

                >>> 
                
                  class
                
                
                   Class:
    
                
                
                  def
                
                
                   method(self):
        
                
                
                  print
                
                
                  '
                
                
                  I have a self!
                
                
                  '
                
                

        
>>> 
                
                  def
                
                
                   function():
    
                
                
                  print
                
                
                  "
                
                
                  I don't
                
                
                  "
                
                

    
>>> instance =
                
                   Class()

                
                >>>
                
                   instance.method()
I have a self!

                
                >>> instance.method =
                
                   function

                
                >>>
                
                   instance.method()
I don
                
                
                  '
                
                
                  t
                
              

?

self 參數(shù)并不取決于調(diào)用方法的方式,目前使用的是實例調(diào)用方法,可以隨意使用引用同一個方法的其他變量:

                >>> 
                
                  class
                
                
                   Bird:
    song 
                
                =  
                
                  '
                
                
                  Squaawk!
                
                
                  '
                
                
                  def
                
                
                   sing(self):
        
                
                
                  print
                
                
                   self.song

        

                
                >>> bird =
                
                   Bird()

                
                >>>
                
                   bird.sing()
Squaawk!

                
                >>> birdsong =
                
                   bird.sing

                
                >>>
                
                   birdsong()
Squaawk!
                
              

?

?

?

指定超類

?

子類可以擴(kuò)展超類的定義。將其他類名寫在 class 語句后的圓括號內(nèi)可以指定超類:

                
                  class
                
                
                   Filter:
    
                
                
                  def
                
                
                   init(self):
        self.blocked 
                
                =
                
                   []
    
                
                
                  def
                
                
                   filter(self , sequence):
        
                
                
                  return
                
                 [x 
                
                  for
                
                 x 
                
                  in
                
                 sequence 
                
                  if
                
                 x 
                
                  not
                
                
                  in
                
                
                   self.blocked]


                
                
                  class
                
                 SPAMFilter(Filter):  
                
                  #
                
                
                  SPAMFilter是Filter的子類
                
                
                  def
                
                 init(self):        
                
                  #
                
                
                  重寫Filter類中的init方法
                
                
        self.blocked = [
                
                  '
                
                
                  SPAM
                
                
                  '
                
                ]
              

Filter? 是個用于過濾序列的通用類,事實上它不能過濾任何東西:

                >>> f =
                
                   Filter()

                
                >>>
                
                   f.init()

                
                >>> f.filter([1,2,3
                
                  ])
[
                
                1, 2, 3]
              

Filter? 類的用戶在于它可以用作其他類的基類(超類,“ java 中叫父類”),比如 SPAMFilter 類,可以將序列中的“ SPAM ”過濾出來。

                >>> s =
                
                   SPAMFilter()

                
                >>>
                
                   s.init()

                
                >>> s.filter([
                
                  '
                
                
                  SPAM
                
                
                  '
                
                ,
                
                  '
                
                
                  SPAMD
                
                
                  '
                
                ,
                
                  '
                
                
                  SPAM
                
                
                  '
                
                ,
                
                  '
                
                
                  HELLO
                
                
                  '
                
                ,
                
                  '
                
                
                  WORLD
                
                
                  '
                
                ,
                
                  '
                
                
                  SPAM
                
                
                  '
                
                
                  ])
[
                
                
                  '
                
                
                  SPAMD
                
                
                  '
                
                , 
                
                  '
                
                
                  HELLO
                
                
                  '
                
                , 
                
                  '
                
                
                  WORLD
                
                
                  '
                
                ]
              

?

?

?

調(diào)查繼承

?

如果想要查看一個類是否是另一個的子類。可以使用內(nèi)建的 issubclass 函數(shù):

                >>>
                
                   issubclass(SPAMFilter, Filter)
True

                
                >>>
                
                   issubclass(Filter,SPAMFilter)
False
                
              

?

?


更多文章、技術(shù)交流、商務(wù)合作、聯(lián)系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號聯(lián)系: 360901061

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機(jī)微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對您有幫助就好】

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長會非常 感謝您的哦!!!

發(fā)表我的評論
最新評論 總共0條評論
主站蜘蛛池模板: 鄂托克旗| 门源| 安徽省| 高清| 汪清县| 北川| 安宁市| 甘谷县| 乌鲁木齐市| 波密县| 汾西县| 大港区| 密云县| 奉化市| 阿克陶县| 莎车县| 余江县| 马公市| 汝城县| 裕民县| 长汀县| 永靖县| 浦城县| 贵港市| 敦化市| 小金县| 镇坪县| 苏尼特左旗| 镇安县| 于田县| 崇文区| 精河县| 清水河县| 柘荣县| 克东县| 互助| 习水县| 衡东县| 湖北省| 阿尔山市| 新乐市|