詞語練習

• class：告訴python創造一個新的東西
• object：兩個意思：最基本的東西和任何實例化的東西。
• instance：創建一個類得到的東西。
• def：在類中創建一個函數。
• self：在類里面的函數中使用，是實例和object能訪問的變量。
• inheritance：繼承，一個類可以繼承另一個類，像你和你的父母。
• composition：一個類可以包含另外一個類，就像汽車包含輪胎。
• attribute：一個屬性類，通常包括變量。
• is-a：表示繼承關系
• has-a：包含關系

通過卡片記憶這些詞語，單獨的詞語通常沒什么意義，不過我還是要先知道它們的存在。

短語練習

• class x(y)：創建一個類x，它繼承了y類。
• class x(object):def __init__(self,j)：x類包含__init__函數，函數中有self和j參數。
• class x(object):def m(self,j)：類x包含m函數，m函數有self和j兩個參數。
• foo = x()：設置foo為類x的實例化。
• foo.m(j)：通過foo調用m函數，參數是self和j。
• foo.k = q：通過foo給k屬性賦值為q。

上面那些x，y，m，q等等都是可以變的。

一個閱讀測試
這是一個簡單的腳本可以讓你用來做練習，它只做一件事，就是使用一個urllib的庫去下載一個單詞列表。我們把下面的代碼寫到opp_test.py文件中。

            
import random 
from urllib import urlopen 
import sys 
 
 
WORD_URL = "http://learncodethehardway.org/words.txt" 
WORDS = [] 
 
 
PHRASES = { 
  "class ###(###):": "Make a class named ### that is-a ###.", 
  "class ###(object):\n\tdef __init__(self, ***)" : "class ### has-a __init__ that takes self and *** parameters.", 
  "class ###(object):\n\tdef ***(self, @@@)": "class ### has-a function named *** that takes self and @@@ parameters.", 
  "*** = ###()" : "Set *** to an instance of class ###.", 
  "***.***(@@@)" : "From *** get the *** function, and call it with parameters self, @@@.", 
  "***.*** = '***'": "From *** get the *** attribute and set it to '***'." 
} 
 
 
PHRASE_FIRST = False 
if len(sys.argv) == 2 and sys.argv[1] == "english": 
  PHRASE_FIRST = True 
 
 
for word in urlopen(WORD_URL).readlines(): 
  WORDS.append(word.strip()) 
 
 
def convert(snippet, phrase): 
  class_names = [w.capitalize() for w in random.sample(WORDS, snippet.count("###"))] 
  other_names = random.sample(WORDS, snippet.count("***")) 
  results = [] 
  param_names = [] 
 
 
  for i in range(0, snippet.count("@@@")): 
    param_count = random.randint(1, 3) 
    param_names.append(', '.join(random.sample(WORDS, param_count))) 
 
 
  for sentence in snippet, phrase: 
    result = sentence[:] 
 
 
    # fake class names 
    for word in class_names: 
      result = result.replace("###", word, 1) 
 
 
    # fake other names 
    for word in other_names: 
      result = result.replace("***", word, 1) 
 
 
    # fake parameter lists 
    for word in param_names: 
      result = result.replace("@@@", word, 1) 
 
 
    results.append(result) 
 
 
  return results 
 
 
try: 
  while True: 
    snippets = PHRASES.keys() 
    random.shuffle(snippets) 
 
 
    for snippet in snippets: 
      phrase = PHRASES[snippet] 
      question, answer = convert(snippet, phrase) 
      if PHRASE_FIRST: 
        question, answer = answer, question 
 
 
      print question 
 
 
      raw_input("> ") 
      print "ANSWER: %s\n\n" % answer 
except EOFError: 
  print "\nBye" 


          

運行這個例子，它會盡可能準確的回答問題。

            
root@he-desktop:~/mystuff# python oop_test.py 

          

            
class Deer(object):
def __init__(self, connection)
> 
ANSWER: class Deer has-a __init__ that takes self and connection parameters.


class Cause(Agreement):
> 
ANSWER: Make a class named Cause that is-a Agreement.


animal.driving(arch)
> 
ANSWER: From animal get the driving function, and call it with parameters self, arch.


cat = Aftermath()
> 
ANSWER: Set cat to an instance of class Aftermath.


cork.card = 'attempt'
> 


          

類和對象
類就像模塊
你可以認為模塊就是一個特殊的字典，它可以保存python代碼，通過 . 號調用。python還有一個類似實現這種目的的結構，叫做類。一個類包含了很多函數和數據，可以通過 . 去訪問它們。

如果我要寫一個類似mystuff的類，就像這樣：

            
class mystuff(object):
  def __int__(self):
    self.tangerine = "Hello"

  def apple(self):
    print "apple"


          

和模塊比有點復雜，不過你可以認為它就是一個迷你模塊。讓人疑惑的是__init__()函數和self.tangerine設置tangerine變量的值。

這里是用類替代模塊的原因：你可以在一個程序中使用同一個類很多次，它們不相互影響，但是一個程序中只能導入一個模塊。

理解這些之前，你必須理解什么是對象。

對象就像迷你的導入
如果類像模塊，那么類也會有類型模塊的導入功能。就是實例化，如果你實例化一個類，得到的就是一個對象。

使用類的方法類似調用函數，像這樣：

            
thing = mystuff()
thing.apple()
print thing.tangerine

          

第一步是實例化，然后調用它的函數，我們通過上面的代碼分析一下python是怎么按照順序執行的：

• python尋找Myclass，看看你是不是定義了這個類。
• python為你在類里面定義的函數創建一個空對象。
• 如果類中有魔術方法__init__，那么就會使用這個函數初始化你的空對象。
• 在__init__方法中有一個額外的變量self，這就是python為我們創建的空對象，你可以給這個變量賦值。
• 這樣的話，我給 thing.tangerine賦了句歌詞，并且初始化了這個對象。
• 那么現在python就可以把這個剛完成的對象賦給一個變量thing了。

這就是我們為什么像調用函數一樣導入一個類。

記住，我給出的不是一個非常準確類的工作方法，僅僅是為了你能通過模塊而更好的理解類。事實是，類和對象和模塊不是一個東西，老實說的話，就像下面這樣：

• 類就像一個藍圖，定義用來創建一個迷你模塊。
• 實例化就是導入的同時使用這個迷你模塊。
• 創建出來的迷你模塊就是對象，賦給一個變量，然后通過這個變量工作。
• 雖然從模塊過渡到類和對象比較難，不過也只有這個方法比較好理解。

從東西中取出東西
現在有三種方法：

            
# 字典
mystuff['apple']

# 模塊
mystuff.apple()
print mystuff.tangerine

# 類
thing = mystuff()
thing.apple()
print thing.tangerine


          

第一個類
你可能還有很多疑問，不要著急，暫時先放放這些疑問，下一個練習我們學校面向對象的知識，下面我們先了解一下類的寫法，為下一練習做準備。

            
class Song(object): 
 
 
  def __init__(self, lyrics): 
    self.lyrics = lyrics 
 
 
  def sing_me_a_song(self): 
    for line in self.lyrics: 
      print line 
 
 
happy_bday = Song(["Happy birthday to you", 
  "I don't want to get sued", 
  "So I'll stop right there"]) 
 
 
bulls_on_parade = Song(["they relly around the family", 
  "With pockets full of shells"]) 
 
 
happy_bday.sing_me_a_song() 
bulls_on_parade.sing_me_a_song() 


          

運行結果

            
Happy birthday to you
I don't want to get sued
So I'll stop right there
they relly around the family
With pockets full of shells

          

繼承

你必須明白一個重要的概念，就是類和對象的不同。問題是，類和對象沒有真正的區別，他們在不同的時間是相同的東西，我將用禪語解釋他們：

魚和鮭魚的區別是什么呢？

這個問題是不是很暈？坐下來想想，我的意思是，魚和鮭魚是不同的，但是又是相同的，對嗎？鮭魚是魚的一種，所以沒有什么不同。但是，鮭魚是魚的一個分類，并且和其他魚的分類不同。所以鮭魚和魚既相同又不同。

我們不需要真的知道鮭魚和魚的區別，只要知道鮭魚是魚的一種，而魚還有其他很多種類就可以了。

現在讓我們更近一步，假設你有三條鮭魚，并且給他們取名為Frank，Joe，Mary，那么思考這個問題：

Mary和鮭魚有什么區別？

這也是一個奇怪的問題，但是比上個問題簡單一點。你知道Mary是一條鮭魚，她是鮭魚的一個實例。Joe和Frank也是一個鮭魚的實例。但是我們說的實例是什么意思呢？意思就是他們創建于鮭魚，然后現在是一個真實東西，鮭魚就像他們的屬性。

現在記住了：魚是一個類，鮭魚也是一個類，Mary是一個對象。好好想想，你能明白過來的。

魚是一個類，就是說魚不是一個真正存在的東西，但是我們通過它的相似的特點去實例化一些東西，比如，有鱗片，有鰓，生活在水里等，那么這個東西就是一條魚。

然后一個專家過來說：”這些魚是鮭魚。“ 這個專家給這些魚定義一個新類”鮭魚“，這個類有一些特別的屬性，長鼻子，紅色的肉，生活在海里，味道美味，好吧，它就是鮭魚。

最后，一個廚師過來對專家說：不，你看到的鮭魚在這里，我叫它Mary，我要把她做成一道美味。”現在，你就有了一個鮭魚的實例（也是魚的實例）叫做Mary，我們叫這個實例是一個對象。

現在我們得出：Mary是一種鮭魚，鮭魚是一種魚。對象是一個類，而類又是另外一個類。

寫成代碼是這樣的
這個概念有些奇怪，不過你只要在創建和使用類的時候注意一下就可以了，我來告訴你兩個區別類和對象的方法。

第一，你要學習兩個短語“is-a”和“has-a”。is-a就是對象和類之間通過類的關系想關聯，has-a是對象和類相關聯是因為他們彼此參考。

下面用這兩個關系標注下面的程序，記住，魚和鮭魚是is-a的關系，鮭魚和鰓是has-a的關系。

            
## Animal is-a object (yes, sort of confusing) look at the extra credit 
class Animal(object): 
  pass 
 
## ?? is-a 
class Dog(Animal): 
 
  def __init__(self, name): 
    ## ?? has-a 
    self.name = name 
 
## ?? is-a  
class Cat(Animal): 
 
  def __init__(self, name): 
    ## ?? has-a 
    self.name = name 
 
## ?? is-a 
class Person(object): 
 
  def __init__(self, name): 
    ## ?? has-a 
    self.name = name 
 
    ## Person has-a pet of some kind 
    self.pet = None 
 
## ?? has-a 
class Employee(Person): 
 
  def __init__(self, name, salary): 
    ## ?? hmm what is this strange magic? 
    super(Employee, self).__init__(name) 
    ## ?? has-a 
    self.salary = salary 
 
## ?? is-a 
class Fish(object): 
  pass 
 
## ?? is-a 
class Salmon(Fish): 
  pass 
 
## ?? is-a 
class Halibut(Fish): 
  pass 
 
 
## rover is-a Dog 
rover = Dog("Rover") 
 
## ?? is-a 
satan = Cat("Satan") 
 
## ?? is-a 
mary = Person("Mary") 
 
## ?? is-a 
mary.pet = satan 
 
## ?? is-a 
frank = Employee("Frank", 120000) 
 
## ?? is-a 
frank.pet = rover 
 
## ?? is-a 
flipper = Fish() 
 
## ?? is-a 
crouse = Salmon() 
 
## ?? is-a 
harry = Halibut() 


          

關于 class Name(object)
我讓你使用class Name(object)但是沒有告訴你為什么。因為怕你混淆，并且不知道怎么學習。

最初python設計類的時候有很多問題，等發現的時候已經太晚了，它們必須要支持這種錯誤的類。為了修正這個問題，他們必須設計一個新類方便舊的類能繼續使用，而且新的類也能正確使用。

這就是為什么類要繼承object類，是不是有點混亂，這里的object指的是類，而不是字面上的解釋為對象。

你就記住，一個新的頂級類必須繼承object就好了。不要太多糾結于字面上的理解，我們要留著思考更加重要的事情。