Python 3

模組名稱空間

2011-09-10T14:03:00.001-07:00

在Python中，模組實際的作用之一是作為名稱空間，你所建立的變數，最大有效範圍就是模組範圍，而你所定義的函式名稱、類別名稱，實際上也是以模組作為名稱空間。例如：

mod.py

x = 10

def some():
    print(x)
    
class Other:
    def __init__(self, arg):
        self.arg = arg
    def show(self):
        print(self.arg)

在這個模組中定義了x變數、some函式與Other類別，你可以在另一個模組中這麼使用它：

import mod

print(mod.x)  # 10

mod.some()    # 10

other = mod.Other(20)
other.show()  # 20

實際上，Python中一個可作為名稱空間的物件，都具有__dict__特性（參考特性名稱空間），模組也不例外。例如，若要存取上例中mod模組的x變數、some函式或Other類別，亦可如下操作：

import mod

print(mod.__dict__['x'])            # 10

mod.__dict__['some']()              # 10

other = mod.__dict__['Other'](20)   
other.show()                        # 20

你可以使用from import語句，於目前模組中建立與被匯入模組相同的變數名稱。例如：

from mod import *

print(x)              # 10

some()                # 10

other = Other(20) 
other.show()          # 20

使用from import語句時，若最後是*結尾，則會將被匯入模組中所有變數，在當前模組中都建立相同的名稱。如果你有些變數，並不想被from import *建立同名變數，則可以用底線作為開頭。例如：

mod.py

x = 10

def some():
    print(x)
    
class Other:
    def __init__(self, arg):
        self.arg = arg
    def show(self):
        print(self.arg)
        
_y = 10

上例中，mod模組有個_y變數，它不會被from import *用來建立同名變數。例如：

from mod import *

print(x)            # 10
some()              # 10
other = Other(20)
other.show()        # 20

print(_y)           # NameError: name '_y' is not defined

不過這個避免被建立同名變數的方式，僅適用於from import *，其它的import形式就不起作用了。例如：

from mod import _y
print(_y)           # 10

相對的，你可以在模組中建立一個__all__變數，參考至串列實例，內含想要被其它模組from import *的變數名單，如果有這麼一個__all__變數，則只有名單中的變數，才可以被其它模組from import *。例如：

__all__ = ['x', 'some']

x = 10

def some():
    print(x)
    
class Other:
    def __init__(self, arg):
        self.arg = arg
    def show(self):
        print(self.arg)

上例中，僅開放x變數與some函式被其它模組from import *。所以：

from mod import *

print(x)           # 10

some()             # 10

other = Other(20)  # NameError: name 'Other' is not defined

匯入套件

2011-09-10T14:02:00.001-07:00

如果你在dir1目錄中有有個名為mod的模組檔案，而dir2中也有個名為mod的模組檔案。若sys.path中包括dir1與dir2。如果現在你的應用程式中，撰寫了以下的程式：

import mod
...

那麼，會匯入的僅有dir1/mod模組檔案。模組檔案的尋找，是以sys.path中的路徑，先找到符合的名稱就使用。

如果要同時使用到dir1/mod.py與dir2/mod.py，那麼單純僅使用sys.path來尋找模組無法達到這個目的。同名模組的名稱衝突問題，可以藉由套件（Package）的使用來解決。在Python中，套件的實體結構就是目錄，而每個套件目錄中必須放置一個__init__.py檔案。例如：

每個套件資料夾都要有一個__init__.py。在上面的例子中，若要在程式中使用dir1/mod.py模組檔案，則可以：

import dir1.mod
print(dir1.mod.name)

在上例中，假設mod中有個name變數，則要取用該變數，則是透過「套件.模組.變數」的方式來取得，透過套件階層的安排，可以為模組分門別類，在程式中則使用「套件.模組」的方式來減少名稱衝突的問題，而若要檢閱模組，套件階層也有助於尋找出模組檔案的正確位置。

若遇到套件階層名稱較長，例如cc.openhome.web.mvc.xxxmodel這樣名稱，在程式中撰寫冗長，則可以透過import as來讓程式便於撰寫。例如：

import cc.openhome.web.mvc.xxxmodel as xxxmodel
xxxmodel.dosome()

或者是透過from import在目前模組中建立想要存取的變數名稱即可。例如：

from cc.openhome.web.mvc.xxxmodel import dosome
dosome()

在Python中，如果為同一套件中的模組檔案，無需時完整import語法來匯入模組，而可以透過相對匯入語法來彼此匯入。例如：

from .helper import func1
func1()

注意，在上面的from語句後面的模組名稱前有個 . ，這表示相對匯入同一套件中的helper.py模組檔案，從而避免了必須從sys.path中尋找，以及在同一套件中模組彼此引用的語法冗長。

每個套件目錄中都必須有個__init__.py，當你匯入套件時，該套件目錄中的__init__.py也會被執行，你可以在其中作一些匯入套件時所必須進行的初始化動作。

import、import as、from import

2011-09-10T14:01:00.003-07:00

接續匯入模組，使用import匯入模組，會以被匯入的模組名稱在當前模組命名一個同名的名稱，被匯入模組中的變數，其實是以被匯入模組為名稱空間。例如，若有個some.py：

name = 'Justin'

若你匯入some模組，要存取some模組中的name變數，則必須使用some.name。事實上，你可以使用del刪除與被匯入模組同名的變數：

import some
print(some.name)  # Justin
del some
print(some.name)  # NameError: name 'some' is not defined

上例中，於del some後，由於目前模組中已沒有some變數，因而發生錯誤。你可以在del與被匯入模組同名的變數，之後再度使用import設回該變數。例如：

import some
print(some.name)  # Justin
del some
import some
print(some.name)  # Justin

再次匯入模組，可以設回與被匯入模組的同名變數，但不會再度執行被匯入模組，import模組時只會執行模組一次，再次import是不會再度執行模組的。

如果想要知道現在到底匯入了多少模組，則可以使用sys.modules得知，這是個字典物件。例如：

>>> import sys
>>> sys.modules.keys()
dict_keys(['heapq', 'sre_compile', '_collections', 'locale', '_multibytecodec',
'functools', 'encodings', 'site', 'operator', 'io', '__main__', 'copyreg', '_hea
pq', '_weakref', 'abc', 'builtins', 'errno', 'itertools', 'sre_constants', 're',
'encodings.latin_1', 'collections', 'ntpath', '_sre', 'nt', 'genericpath', 'sta
t', 'zipimport', '_codecs', '_bisect', 'encodings.utf_8', 'sys', 'codecs', 'os.p
ath', '_functools', '_locale', 'keyword', 'bisect', '_codecs_tw', 'signal', 'wea
kref', '_io', '_weakrefset', 'encodings.cp950', 'encodings.aliases', 'sre_parse'
, 'os', '_abcoll'])
>>>

如果你使用del刪除某個與被匯入模組同名的變數，並不會影響sys.modules。例如：

import sys
import some
print(some.name)     # Justin
del some
print(sys.modules['some'].name)  # Justin
print(some.name)    # NameError: name 'some' is not defined

如果你想要改變被匯入模組在當前模組中的變數名稱，則可以使用import as。例如：

import some as other
print(other.name)   # Justin

import as改變的是被匯入模組在當前模組的名稱，而不是sys.modules中的名稱，以上例來說，sys.modules中的名稱仍然是some。上例比較像是：

import some
other = some
del some
print(other.name)

可以使用from import語句「複製」出模組中的名稱。例如：

import some
from some import name

print(name)            # Justin
print(some.name)       # Justin

name = 'caterpillar'  
print(name)            # caterpillar
print(some.name)       # Justin

上例比較像是：

import some
name = some.name

print(name)
print(some.name)

name = 'caterpillar'
print(name)
print(some.name)

你可以一次匯入兩個以上的名稱，例如：

from some import x, y

或者是將模組中的名稱全部匯入，例如：

from some import *

Python是個不斷演進的語言，有些新語法或功能會不相容於舊版本Python，甚至破壞舊版本Python原本的功能，如果你想要體驗一下將來版本可能有的新語法或功能，則可以透過__future__模組。例如在Python 2.6中，print是個陳述句，而在Python 3中，print是個函式，若要在Python 2.6中使用Python 3中的print函式，則可以：
from __future__ import print_function

匯入模組

2011-09-10T14:01:00.001-07:00

接續簡介模組的內容。sys.path陣列中的字串元素其實是由幾個來源所組成：所執行檔案（模組）的所在目錄、PYTHONPATH環境變數的內容、標準程式庫搜尋目錄、.pth檔案中所列出的目錄。

例如，若在Windows上，有個模組檔案位於C:\workspace，而Python安裝於C:\winware\python31：

import sys
print(sys.path)

若你如下執行程式：

C:\workspace>c:\winware\python31\python demo.py
['C:\\workspace', 'C:\\Windows\\system32\\python31.zip', 'c:\\winware\\python31\
\DLLs', 'c:\\winware\\python31\\lib', 'c:\\winware\\python31\\lib\\plat-win', 'c
:\\winware\\python31', 'c:\\winware\\python31\\lib\\site-packages']

C:\workspace>set PYTHONPATH=C:\lib

C:\workspace>c:\winware\python31\python demo.py
['C:\\workspace', 'C:\\lib', 'C:\\Windows\\system32\\python31.zip', 'c:\\winware
\\python31\\DLLs', 'c:\\winware\\python31\\lib', 'c:\\winware\\python31\\lib\\pl
at-win', 'c:\\winware\\python31', 'c:\\winware\\python31\\lib\\site-packages']

C:\workspace>

C:\\workspace是所執行檔案所在目錄、C:\\lib是PYTHONPATH的設定內容，其它是標準程式庫搜尋目錄，至於.pth檔案所列出的目錄，是指你可以在Python安裝目錄，或者是安裝目錄的lib\site-packages目錄中建立.pth檔案，當中一行一行列出搜尋模組檔案的目錄，如果該目錄確實存在，則會列為sys.path的內容。例如，若在C:\winware\python31中放置mydir.pth，內容如下：

C:\lib2
C:\lib3

而在c:\winware\python31\lib\site-packages中放置一個mydir.pth，內容如下：

C:\lib4
C:\lib5

如果所列的目錄確實存在，則再度執行demo.py，會顯示如下：

import會在sys.path中尋找.py或已編譯的.pyc，如果.py尚未編譯則編譯為.pyc，而後載入執行一次，再次import同一個模組並不會再執行一次模組，如果找到.py與.pyc，而.pyc的版本並沒有比.py舊，則略過編譯直接執行，如果僅找到.pyc而沒有找到.py，也會直接執行。

在執行時期，你可以動態地改變sys.path的內容，來改變搜尋模組的路徑。例如，若有個superman.py放在C:\library中，而superman.py的內容如下：

print('superman modulle')
name = 'Justin'

而你執行的檔案為：

import sys
print(sys.path, end='\n\n')

sys.path.append('c:\library')
print(sys.path, end='\n\n')

import superman
print(superman.name)

則執行的結果會是：

C:\workspace>c:\winware\python31\python demo.py
['C:\\workspace', 'C:\\lib', 'C:\\Windows\\system32\\python31.zip', 'C:\\Winware
\\Python31\\DLLs', 'C:\\Winware\\Python31\\lib', 'C:\\Winware\\Python31\\lib\\pl
at-win', 'C:\\Winware\\Python31', 'C:\\Winware\\Python31\\lib\\site-packages']

['C:\\workspace', 'C:\\lib', 'C:\\Windows\\system32\\python31.zip', 'C:\\Winware
\\Python31\\DLLs', 'C:\\Winware\\Python31\\lib', 'C:\\Winware\\Python31\\lib\\pl
at-win', 'C:\\Winware\\Python31', 'C:\\Winware\\Python31\\lib\\site-packages', '
c:\\library']

superman modulle
Justin

C:\workspace>

Python的import是執行時期的運算，import某個模組，就會執行該模組中定義的內容，被import的模組名稱會成為目前模組的變數，而被import的模組中的變數，就是以被import模組名稱為名稱空間。

物件相等性

2011-09-10T13:45:00.000-07:00

如果你定義了類別時沒有定義__eq__()方法，則預設使用==比較兩個實例時，會得到與使用is比較相同的結果。例如：

>>> class Some:
... pass
...
>>> s1 = Some()
>>> s2 = Some()
>>> s1 == s2
False
>>> s3 = s1
>>> s1 == s3
True
>>>

你可以定義__eq__()方法，來定義使用==運算時的實質比較結果。例如：

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        
    def __eq__(self, that):
        if not isinstance(that, Point):
            return False
        return self.x == that.x and self.y == that.y

p1 = Point(1, 1)
p2 = Point(1, 1)
print(p1 == p2)    # True
print(p1 is p2)    # False

如果你試圖將以上定義的Point實例置入集合物件，則會發生錯誤：

pset = {p1} # TypeError: unhashable type: 'Point'

要將實例置入Python的集合物件，該實例必須定義__hash__()方法。在許多場合，例如將物件加入一些群集（Collection）時，會同時利用__eq__()與__hash__()來判斷是否加入的是（實質上）相同的物件。來看看定義__hash__()時必須遵守的約定（取自java.lang.Object的hashCode() 說明）：

在同一個應用程式執行期間，對同一物件呼叫 __hash__()方法，必須回傳相同的整數結果。
如果兩個物件使用__eq__()測試結果為相等, 則這兩個物件呼叫__hash__()時，必須獲得相同的整數結果。
如果兩個物件使用 __eq__()測試結果為不相等, 則這兩個物件呼叫__hash__()時，可以獲得不同的整數結果。

以集合物件為例，會先使用__hash__()得出該將物件放至哪個雜湊桶（Hash buckets）中，如果雜湊桶有物件，再進一步使用__eq__()確定實質相等性，從而確定集合中不會有重複的物件。以下是定義了__hash__()的Point版本：

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        
    def __eq__(self, that):
        if not isinstance(that, Point):
            return False
        return self.x == that.x and self.y == that.y
        
    def __hash__(self):
        return 41 * (41 + self.x) + self.y

p1 = Point(1, 1)
p2 = Point(1, 1)
pset = {p1}
print(p2 in pset)    # True

一個重要的觀念是，定義__eq__()與__hash__()時，最好別使用狀態會改變的資料成員。你可能會想，以這個例子來說，點會移動，如果移動了就不是相同的點了，不是嗎？若x、y是個允許會變動的成員，那麼就會發生這個情況：

p1 = Point(1, 1)
pset = {p1}
print(p1 in pset) # True
p1.x = 2
print(p1 in pset) # False

明明是記憶體中同一個物件，但置入集合後，最後跟我說不包括p1？這是因為，你改變了x，算出來的__hash__()也就改變了，使用in嘗試比對時，會看看新算出來的雜湊桶中是不是有物件，而根本不是置入p1的雜湊桶中尋找，結果就是False了。
一個限制修改不可變動成員的方式，是定義__setattr__()方法。例如：

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __setattr__(self, name, value):
        if not name in self.__dict__:
            self.__dict__[name] = value
        elif name == 'x' or name == 'y':
            raise TypeError('Point(x, y) is immutable')
    
    def __eq__(self, that):
        if not isinstance(that, Point):
            return False
        return self.x == that.x and self.y == that.y
        
    def __hash__(self):
        return 41 * (41 + self.x) + self.y

p1 = Point(1, 1)
p2 = Point(1, 1)
pset = {p1}
print(p1 in pset)
p1.x = 2   # TypeError: Point(x, y) is immutable

再來看看在實作__eq__()時要遵守的約定（取自java.lang.Object的 equals() 說明）：

反身性（Reflexive）：x == x的結果要是True。
對稱性（Symmetric）：x == y與y == x的結果必須相同。
傳遞性（Transitive）：x == y、y == z的結果都是True，則x == z的結果也必須是True。
一致性（Consistent）：同一個執行期間，對x == y的多次呼叫，結果必須相同。
對任何非None的x，x == None必須傳回False。

目前定義的Point，其__eq__()方法滿足以上幾個約定（你可以自行寫程式測試）。現在考慮繼承的情況，你要定義3D的點：

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __eq__(self, that):
        if not isinstance(that, Point):
            return False
        return self.x == that.x and self.y == that.y
        

class Point3D(Point):
    def __init__(self, x, y, z):
        super(Point3D, self).__init__(x, y)
        self.z = z
        
    def __eq__(self, that):        
        if not isinstance(that, Point3D):
            return False
        return super(Point3D, self).__eq__(that) and self.z == that.z
        
        
p1 = Point(1, 1)
p2 = Point3D(1, 1, 1)

print(p1 == p2)

在繼承的情況下，若==兩旁運算元有一個是子類別實例，則會使用子類別的__eq__()版本進行比對。在上面的定義之下，直接將2D與3D的點視作不同的類型，這避免了2D點與3D點（父、子類別）進行比較時，無法符合對稱性、傳遞性合約的問題。

抽象類別

2011-09-10T13:43:00.003-07:00

定義類別，本身就是在進行抽象化，如果一個類別定義時不完整，有些狀態或行為必須留待子類別來具體實現，則它是個抽象類別（Abstract Class）。例如，在定義銀行帳戶時，你也許想將一些帳戶的共同狀態與行為定義在父類別中：

class Account:
    def withdraw(self, amount):
        if amount >= self.balance:
            self.balance -= amount
        else:
            raise ValueError('餘額不足')

    def __str__(self):
        return ('Id:\t\t' + self.id +
               '\nName:\t\t' + self.name +
               '\nBalance:\t' + str(self.balance))

顯然地，這個類別的定義不完整，self.id、self.name、self.balance沒有定義，嘗試使用這個類別進行操作時，就會發生直譯錯誤：

acct = Account()
print(acct)

你可以繼承這個類別來實作未完整的定義：

class CheckingAccount(Account):
    def __init__(self, id, name):
        self.id = id
        self.name = name
        self.balance = 0
        self.overdraftlimit = 30000

    def withdraw(self, amount):
        if amount <= self.balance + self.overdraftlimit:
            self.balance -= amount
        else:
            raise ValueError('超出信用')

    def __str__(self):
        return (super(CheckingAccount, self).__str__() + 
                '\nOverdraft limit\t' + str(self.overdraftlimit));
                
acct = CheckingAccount('E1223', 'Justin Lin')
print(acct)

現在的問題是，實際上開發人員還是可以用Account()實例化，也許您可以修改一下Account的定義：

class Account:
    def __init__():
        raise NotImplementedError("Account is abstract")

    ...略

如此，嘗試使用Account()實例化後，在初始化方法中就會引發錯誤（不過，實際上Account實例確實有產生了，但就這邊的需求來說，目的算已達到）。

像Python這類的動態語言，沒有Java的abstract或interface這種機制來規範一個類別所需實作的介面，遵循物件之間的協定基本上是開發人員的自我約束（當然，還得有適當的說明文件）。如果你非得有個方式，強制實現某個公開協定，那該怎麼作？像上面一樣，藉由直譯錯誤是一種方式，實際上視你的需求而定（是否可實例化、子類別是否定義初始化方法等），還有許多模擬的方式，不過在Python中，可以使用Meta class與@abstractmethod來達到規範的需求。

舉個例子來說，您想要設計一個猜數字遊戲，猜數字遊戲的流程大致就是：

顯示訊息（歡迎）
隨機產生數字
遊戲迴圈
顯示訊息（提示使用者輸入）
取得使用者輸入
比較是否猜中顯示訊息（輸入正確與否）

在描述流程輸廓時，並沒有提及如何顯示訊息、沒有提及如何取得使用者輸入等具體的作法，只是歸納出一些共同的流程步驟：

import random
from abc import ABCMeta, abstractmethod

class GuessGame(metaclass=ABCMeta):
    @abstractmethod
    def message(self, msg):
        pass

    @abstractmethod
    def guess(self):
        pass     

    def go(self):
        self.message(self.welcome)
        number = int(random.random() * 10)
        while True:
            guess = self.guess();
            if guess > number:
                self.message(self.bigger)
            elif guess < number:
                self.message(self.smaller)
            else:
                break
        self.message(self.correct)

現在GuessGame是個抽象類別，如果你嘗試實例化GuessGame：

game = GuessGame()

則會引發錯誤：

TypeError: Can't instantiate abstract class GuessGame with abstract methods guess, message

如果是個文字模式下的猜數字遊戲，可以將顯示訊息、取得使用者輸入等以文字模式下的具體作法實現出來。例如：

class ConsoleGame(GuessGame):
    def __init__(self):
        self.welcome = "歡迎"
        self.prompt = "輸入數字："
        self.correct = "猜中了"
        self.bigger = "你猜的比較大"
        self.smaller = "你猜的比較小"
    
    def message(self, msg):
        print(msg)
    
    def guess(self):
        return int(input(self.prompt))

game = ConsoleGame()
game.go()

如果子類別忘了實作某個方法，則該子類別仍被視為一個抽象類別，如果嘗試實例化抽象類別就會引發錯誤。例如若忘了實作message()，就會發生以下錯誤：

TypeError: Can't instantiate abstract class ConsoleGame with abstract methods message

所以，如果你真的想要模擬Java中interface的作用，則可以定義一個抽象類別，完全沒有實作的方法即可。例如：

import random
from abc import ABCMeta, abstractmethod

class Flyer(metaclass=ABCMeta): # 就像是Java中的interface
    @abstractmethod
    def fly(self):
        pass

class Bird:
    pass
    
class Sparrow(Bird, Flyer):  # 就像Java中繼承Bird類別並實作Flyer介面
    def fly(self):
        print('麻雀飛')

s = Sparrow()
s.fly()

繼承

2011-09-10T13:43:00.001-07:00

你建立了一個銀行帳戶類別：

class Account:
    def __init__(self, id, name):
        self.id = id
        self.name = name
        self.balance = 0
        
    def deposit(self, amount):
        self.balance += amount
    
    def withdraw(self, amount):
        if amount >= self.balance:
            self.balance -= amount
        else:
            raise ValueError('餘額不足')

    def __str__(self):
        return ('Id:\t\t' + self.id +
               '\nName:\t\t' + self.name +
               '\nBalance:\t' + str(self.balance))

在這個類別中，雖然沒有聲明，但你已經使用了繼承，在Python中，所有類別都繼承自object類別。上例其實相當於：

class Account(object):
...略

在Python中繼承的語法，是在類別名稱旁使用括號表明要繼承的父類別。例如，你為以上的類別建立了一個支票帳戶：

class CheckingAccount(Account):
    def __init__(self, id, name):
        super(CheckingAccount, self).__init__(id, name) # 呼叫父類別__init__()
        self.overdraftlimit = 30000

    def withdraw(self, amount):
        if amount <= self.balance + self.overdraftlimit:
            self.balance -= amount
        else:
            raise ValueError('超出信用')

    def __str__(self):
        return (super(CheckingAccount, self).__str__() + 
                '\nOverdraft limit\t' + str(self.overdraftlimit));

在上例中，你繼承了Account來定義一個CheckingAccount子類別。如果在子類別中，需要呼叫父類別的某個方法，則可以使用super()指定類別名稱與物件，這會將目前實例綁定至所指定父類別方法的第一個引數。

在上例中，你重新定義了withdraw()與__str__()方法，在操作實例方法時，是從子類別開始尋找是否有定義，否則就搜尋父類別中是否有定義方法。所以：

acct = CheckingAccount('E1234', 'Justin Lin')
print(acct, end='\n\n')
acct.deposit(1000) # 使用 Account 的 deposit() 定義
print(acct, end='\n\n')
acct.withdraw(2000) # 使用 CheckingAccount 的 withdraw() 定義
print(acct, end='\n\n')

在呼叫acct的deposit()方法時，由於CheckingAccount並沒有定義，所以呼叫的是Account的deposit()，而呼叫withdraw()時，則是使用CheckingAccount上有定義的withdraw()。

在Python中，可以進行多重繼承，這個時候要注意搜尋的順序，是從子類別開始，接著是同一階層父類別由左至右搜尋，再至更上層同一階層父類別由左至右搜尋，直到達到頂層為止。例如：

class A(object):
    def method1(self):
        print('A.method1')
        
    def method2(self):
        print('A.method2')
        
class B(A):
    def method3(self):
        print('B.method3')
        
class C(A):
    def method2(self):
        print('C.method2')
        
    def method3(self):
        print('C.method3')
        
class D(B, C):
    def method4(self):
        print('C.method4')

d = D()
d.method4() # 在 D 找到，C.method4
d.method3() # 以 D->B 順序找到，B.method3
d.method2() # 以 D->B->C 順序找到，C.method2
d.method1() # 以 D->B->C->A 順序找到，A.method1

在Python中，類別有個__bases__特性，記錄著所繼承的父類別，__bases__是個 Tuple，有趣的是，你可以改變__bases__來動態改變繼承的父類別。例如：

>>> class A:
...     def method(self):
...         print('A method')
...
>>> class B:
...     def method(self):
...         print('B method')
...
>>> class C(A):
...     pass
...
>>> c = C()
>>> c.method()
A method
>>> C.__bases__
(<class '__main__.A'>,)
>>> C.__bases__ = (B,)
>>> c.method()
B method
>>>

在上例中，C原本來繼承自A類別，透過修改__bases__實際參考的Tuple，C改變繼承B，而尋找特性或方法時，也就改尋找B父類別，因此最後執行的是從B繼承下來的method()。

建構、初始與消滅

2011-09-10T13:42:00.001-07:00

在之前的文件中所提到的，__init__()方法是定義物件建立後初始化的流程，也就是執行到__init__()方法時，物件實際上已建構完成，傳入__init__()的引數，並不是作為建構物件之用，而是作為初始物件之用。

實際上要決定如何建構物件，必須定義__new__()方法，這個方法的第一個參數總是傳入類別本身，之後可接任意參數作為建構物件之用。

__new__() 方法可以傳回物件，如果傳回的物件是第一個參數的類別實例，則會執行__init__()方法（如果有定義的話），而__init__()方法的第一個參數綁定所傳回的物件。如果沒有傳回第一個參數的類別實例（傳回別的實例或None），則不會執行__init__()方法（即使有定義）。

一個簡單測試建構與初始流程的例子如下所示：

>>> class Some:
...     def __new__(clz, isClzInstance):
...         print('__new__')
...         if isClzInstance:
...             return object.__new__(clz)
...         else:
...             return None
...     def __init__(self, isClzInstance):
...         print('__init__')
...         print(isClzInstance)
...
>>> Some(True)
__new__
__init__
True
>>> Some(False)
__new__
>>>

由於若傳回__new__()第一個參數的類別實例，就會執行__init__()方法，所以__new__()與__init__()通常會具有相同個數的參數。藉由定義__new__()方法，可以決定如何建構物件與初始物件，一個應用的例子，就是實作 Singleton 模式。例如：

class Singleton:
    __single = None
    def __new__(clz):
        if not Singleton.__single:
            Singleton.__single = object.__new__(clz)
        return Singleton.__single
        
    def doSomething(self):
        print("do something...XD")

singleton1 = Singleton()
singleton1.doSomething()  # do something...XD

singleton2 = Singleton()
singleton2.doSomething()  # do something...XD

print(singleton1 is singleton2)  # True

在上面的程式中，一旦Singleton.__single有參考至物件，則直接傳回，從客戶端的角度則如常執行Singleton()來建構物件，但實際上傳回的都會是同一個物件（由於傳回的是Singleton實例，所以若有定義__init__()則會被執行，就單例物件來說，可於__init__()中進行狀態的回復）。

如果要定義物件被垃圾收集（Garbage collection）時，所要進行的資源清除動作，則可以定義__del__()方法，物件會被資源回收的資格，基本上就是參考至物件的變數計數為0的時候。例如：

>>> class Some:
... def __del__(self):
... print('__del__')
...
>>> s = Some()
>>> s = None
__del__
>>> s1 = Some()
>>> s2 = s1
>>> del s1
>>> del s2
__del__
>>>

在上例中，將s參考至None時，原先所參考的物件其變數計數就為0，所以在回收物件前執行了__del__()，而使用del刪除s1時，s2仍參考至物件，直到s2也被del刪除，物件符合回收資格，回收物件前執行了__del__()。

特殊方法名稱

2011-09-10T13:41:00.001-07:00

在Python中定義類別時，有些__name__的特殊函式名稱，是用定義運算子或特定操作的行為。舉個例子來說，可以定義一個有理數類別，並定義其+、-、*、/等行為：

class Rational:
    def __init__(self, n, d):  # 物件建立之後所要建立的初始化動作
        self.numer = n
        self.denom = d
    
    def __str__(self):   # 定義物件的字串描述
        return str(self.numer) + '/' + str(self.denom)
    
    def __add__(self, that):  # 定義 + 運算
        return Rational(self.numer * that.denom + that.numer * self.denom, 
                        self.denom * that.denom)
    
    def __sub__(self, that):  # 定義 - 運算
        return Rational(self.numer * that.denom - that.numer * self.denom,
                        self.denom * that.denom)
                           
    def __mul__(self, that):  # 定義 * 運算
        return Rational(self.numer * that.numer, 
                        self.denom * that.denom)
        
    def __truediv__(self, that):   # 定義 / 運算
        return Rational(self.numer * that.denom,
                        self.denom * that.denom)

    def __eq__(self, that):   # 定義 == 運算
        return self.numer * that.denom == that.numer * self.denom

x = Rational(1, 2)
y = Rational(2, 3)
z = Rational(2, 3)
print(x)       # 1/2
print(y)       # 2/3
print(x + y)   # 7/6
print(x - y)   # -1/6
print(x * y)   # 2/6
print(x / y)   # 3/6
print(x == y)  # False
print(y == z)  # True

__init__()定義物件建立後要執行的初始化過程，相對它的是__del__()方法，在物件被回收前會被執行（因為回收物件的時間不一定，所以不建議用在要求立即性的情況）。常見的+、-、*、/、==等操作，則分別是由__add__()、__sub__()、__mul__()、__truediv__()（//則是由__floordiv__()定義）與__eq__()定義。

__str__()用來定義傳回物件描述字串，通常用來描述的字串是對使用者友善的說明文字，如果對物件使用str()，所呼叫的就是__str__()。如果要定義對開發人員較有意義的描述，例如傳回產生實例的類別名稱之類的，則可以定義__repr__()，如果對物件使用repr()，則所呼叫的就是__repr__()。

在特性名稱空間中看過的例子則是__getattr__()方法，相對它的方法是__setattr__()，而用來定義實例的特性被設定時該作什麼動作。例如：

>>> class Some:
...     def __setattr__(self, name, value):
...         print(name, value)
...     def __init__(self):
...         self.x = 10
...
>>> s = Some()
x 10
>>> s.w = 100
w 100
>>> s.__dict__['z'] = 200
>>> print(s.__dict__)
{'z': 200}
>>>

一旦有定義__setattr__()，則所有以 . 運算子來設定特性的操作，都會呼叫__setattr__()，但直接對實例的__dict__操作則不會。

__getitem__()與__setitem__()則用來設定[]運算子的行為。例如：

>>> class Some:
...     def __init__(self):
...         self.inner = {}
...     def __setitem__(self, name, value):
...         self.inner[name] = value
...     def __getitem__(self, name):
...         return self.inner[name]
...
>>> s = Some()
>>> s[0] = 100
>>> s['Justin'] = 'Message'
>>> s[0]
100
>>> s['Justin']
'Message'
>>>

在設計程式的過程中，經常有的需求之一，就是希望逐一取得某物件內部的所有資料（或物件），像是取得串列中所有的資料，或取得集合中所有的資料。

因為串列是有序結構並有索引特性，而集合則為無序不重複的特性，兩者所提供的公開存取方法也不相同，如何以一致方式取得不同資料結構的群集物件是個問題。

在Python中，你可以讓物件實作__iter__()方法，這個方法可以傳回一個迭代器（Iterator），一個具有__next__()方法的物件。迭代器走訪物件內容收集物件後傳回，每次呼叫迭代器物件的__next__()方法，必須傳回群集的下一個元素，如果沒有下一個元素了，則丟出StopIteration物件。例如：

class Some:
    class Iterator:
        def __init__(self, length):
            self.length = length
            self.number = -1
        def __next__(self):
            self.number = self.number + 1
            if self.number == self.length:
                raise StopIteration
            return self.number
    
    def __init__(self, length):
        self.length = length

    def __iter__(self):
        return Some.Iterator(self.length)

s = Some(3)
it = iter(s)
print(next(it))   # 0
print(next(it))   # 1
print(next(it))   # 2
print(next(it))   # StopIteration

實際上，你可以使用iter()來代為呼叫物件的__iter__()方法，使用next()方法代為呼叫物件的__next__()方法。事實上，你可以結合for in迴圈來提取物件，for in迴圈會透過__iter__()取得迭代器，然後在每次迴圈中呼叫__next__()方法，而後遇到StopIteration丟出後離開迴圈。例如：

for n in Some(10):
print(n) # 顯示 0 到 9

以上先簡介一些簡單的特殊方法名稱，詳細的特殊方法說明，可以參考 Special method names。

特性名稱空間

2011-09-10T13:40:00.001-07:00

一個事實是：類別（Class）或實例（Instance）本身的作用是作為特性（Property）的名稱空間（Namespace）。類別或實例本身會擁有一個__dict__特性參考至一個字典物件，其中記錄著類別或實例所擁有的特性。例如：

>>> class Math:
... PI = 3.14159
...
>>> Math.PI
3.14159
>>> print(Math.__dict__)
{'__dict__': <attribute '__dict__' of 'Math' objects>, '__module__': '__main__',
'PI': 3.14159, '__weakref__': <attribute '__weakref__' of 'Math' objects>, '__d
oc__': None}
>>> Math.__dict__['PI']
3.14159
>>>

在上例中，Math類別上定義了PI特性，這記錄在Math.__dict__中，你嘗試使用Math.PI，則使用Math.__dict__['PI']來尋找出對應的值。如果你試著透過實例來取得PI：

>>> m = Math()
>>> m.PI
3.14159
>>> print(m.__dict__)
{}
>>>

實際上m所參考的實例，其__dict__中並沒有PI，此時會到Math.__dict__中找看看有無PI。這是Python中尋找特性的順序：如果實例的__dict__中沒有，則到產生實例的類別__dict__中尋找。如果你試著在m實例上設定PI特性：

>>> m.PI
3.14
>>> Math.PI
3.14159
>>> print(m.__dict__)
{'PI': 3.14}
>>> print(Math.__dict__)
{'__dict__': <attribute '__dict__' of 'Math' objects>, '__module__': '__main__',
'PI': 3.14159, '__weakref__': <attribute '__weakref__' of 'Math' objects>, '__d
oc__': None}
>>>

實際上你並沒有改變Math.__dict__中的PI，而是在實例m.__dict__中新增一個PI，而你嘗試使用實例存取PI時，由於m.__dict__中已經有了，就直接取得該值。

這也說明了，為什麼實例方法的第一個參數會綁定至實例：

>>> class Some:
... def setx(self, x):
... self.x = x
...
>>> s = Some()
>>> print(Some.__dict__)
{'__dict__': <attribute '__dict__' of 'Some' objects>, '__weakref__': <attribute
'__weakref__' of 'Some' objects>, '__module__': '__main__', 'setx': <function s
etx at 0x018FA078>, '__doc__': None}
>>> print(s.__dict__)
{}
>>> s.setx(10)
>>> print(s.__dict__)
{'x': 10}
>>>

類別中所定義的函式，其實就是類別的特性，也就是在類別的__dict__中可以找到該名稱。實例方法的第一個參數self綁定實例，透過self.x來設定特性值，也就是在self.__dict__中添增特性。

由於Python可以動態地為類別添加屬性，即使是未添加屬性前就已建立的物件，在類別動態添加屬性之後，也可依Python的名稱空間搜尋順序套用上新的屬性，用這種方式，您可以為類別動態地添加方法。例如：

class Some:
    def __init__(self, x):
        self.x = x
        
s = Some(1)
Some.service = lambda self, y: print('do service...', self.x + y)
s.service(2)    # do service... 3

如果你要刪除物件上的某個特性，則可以使用del。例如：

>>> class Some:
... pass
...
>>> s = Some()
>>> s.x = 10
>>> print(s.__dict__)
{'x': 10}
>>> del s.x
>>> print(s.__dict__)
{}
>>>

如果你試著在實例上呼叫某個方法，而該實例上沒有該綁定方法時（被@staticmethod或@classmethod修飾的函式），則會試著去類別__dict__中尋找，並以類別呼叫方式來執行函式。例如：

>>> class Some:
...     @staticmethod
...     def service():
...         print('XD')
...
>>> s = Some()
>>> s.service()
XD
>>>

在上例中，嘗試執行s.service()，由於s並沒有service()的綁定方法（因為被@staticmethod修飾），所以嘗試尋找Some.service()執行。

實際上，如果嘗試透過實例取得某個特性，如果實例的__dict__中沒有，則到產生實例的類別__dict__中尋找，如果類別__dict__仍沒有，則會試著呼叫__getattr__()來傳回，如果沒有定義 __getattr__()方法，則會引發AttributeError，如果有__getattr__()，則看__getattr__()如何處理。例如：

>>> class Some:
...     w = 10
...     def __getattr__(self, name):
...         if name == 'w':
...             return 20
...
>>> s = Some()
>>> s.w
10
>>> s.x
>>> class Some:
...     def __getattr__(self, name):
...         if name == 'w':
...             return 20
...         else:
...             raise AttributeError(name)
...
>>> s = Some()
>>> s.w
20
>>> s.x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 6, in __getattr__
AttributeError: x
>>>

在類別中的函式執行過程中若有定義實例特性時，具特性名稱是以__開頭，則該名稱會被加工處理。例如：

>>> class Some:
... def __init__(self):
... self.__x = 10
...
>>> s = Some()
>>> s.__x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Some' object has no attribute '__x'
>>> print(s.__dict__)
{'_Some__x': 10}
>>> s._Some__x
10
>>>

實例變數若以__name這樣的名稱，則會自動轉換為「_類別名__name」這樣的名稱儲存在實例的__dict__中，以__開頭的變數名稱，Python沒有真正阻止你存取它，但這提示不希望你直接存取。

如果不想要直接使用實例的__dict__來取得特性字典物件，則可以使用vars()，vars()會代為呼叫實例的__dict__。例如：

>>> class Some:
...     def __init__(self):
...         self.x = 10
...         self.y = 20
...
>>> s = Some()
>>> vars(s)
{'y': 20, 'x': 10}
>>>

靜態方法、類別方法

2011-09-10T13:39:00.002-07:00

如果你定義了一個類別：

class Some:
    def __init__(self, x):
        self.x = x
    
    def service(self, y):
        print('do service...', self.x + y)

你可以透過Some實例來操作service()方法。例如：

s = Some(10)
s.service(2) # do service... 12

表面上，上例像是：

s = Some(10)
Some.service(s, 2)

s所參考的實例，會綁定至service()的第一個參數，而所給定的引數，會指定service()方法的第二個參數，實際上在這類的情況下，service()方法是一個綁定方法（Bound method），而每個實例會有自己的綁定方法。例如：

s1 = Some(10)
service = s1.service
service(5) # do service... 15

s2 = Some(20)
service = s2.service
service(5) # do service... 25

而Some類別本身亦擁有一個service()函式，例如：

s1 = Some(10)
Some.service(s1, 5) # do service... 15

s2 = Some(20)
Some.service(s2, 5) # do service... 25

service = Some.service
service(s1, 5) # do service... 15
service(s2, 5) # do service... 25

如果在定義類別時，類別中的函式沒有任何參數，則該函式無法成為綁定方法，因為試圖將實例作為第一個參數時會發生錯誤。例如：

class Other:
    def service():
        print('do service...')
        
o = Other()
o.service()  # TypeError: service() takes no arguments (1 given)

像上例中service()只能作為Other上的一個函式來使用：

Other.service() # do service...

如果你在定義類別時希望某個函式，完全不要作為實例的綁定方法，也就是不要將第一個參數綁定為所建立的實例，則可以使用@staticmethod加以修飾。例如：

class Some:
    @staticmethod
    def service(x, y):
        print('do service...', x + y)

Some.service(10, 20) # do service... 25

s = Some()
s.service(10, 20)    # do service... 25
s.service(10)        # TypeError: service() takes exactly 2 positional arguments (1 given)

雖然你可以透過實例來呼叫@staticmethod所修飾的靜態方法，但建議透過類別名稱來呼叫。類似的，建議透過實例來呼叫實例的綁定方法。一個沒有使用@staticmethod宣告而又帶有參數的函式，就如先前所看到的，可以用實例方法來使用，也可以用靜態方法的方式呼叫，這是Python3給的方便性，讓你不一定得使用@staticmethod來區別，只要你知道自己在作什麼。事實上，你還可以這麼作：

class Some:
    def __init__(self, x):
        self.x = x
    
    def service(self, y):
        print('do service...', self.x + y)

class Other:
    pass

o = Other()
o.x = 100
Some.service(o, 200)    # do service... 25

Some.service()的第一個參數可以任何物件，只要它有個x屬性。

你還可以使用@classmethod來修飾一個函式成為類別方法，這樣的方法第一個參數永遠綁定為類別物件本身，無論是以實例方法來呼叫，或是以靜態方法來呼叫。例如：

class Some:
    def __init__(self, x):
        self.x = x
        
    @classmethod
    def service(clz, y):
        print('do service...', clz, y)

s = Some(10)
s.service(20)      # do service... <class '__main__.Some'> 20
Some.service(30)   # do service... <class '__main__.Some'> 30

定義類別

2011-09-10T13:39:00.000-07:00

在Python中要定義類別非常的簡單，例如你可以定義一個帳戶（Account）類別：

class Account:
    pass

def deposit(acct, amount):
    if amount <= 0:
        raise ValueError('must be positive')
    acct.balance += amount
       
def withdraw(acct, amount):
    if amount <= acct.balance:
        acct.balance -= amount
    else:
        raise RuntimeError('balance not enough')
        
acct = Account()
acct.number = '123-456-789'
acct.name = 'Justin'
acct.balance = 0

print(acct.number)    # 123-456-789
print(acct.name)      # Justin

deposit(acct, 100)
print(acct.balance)   # 100
withdraw(acct, 50)
print(acct.balance)   # 50

上例中，class用來定義一個類別，現在還沒有要定義類別特性（Property）等，所以使用pass先略過。要建立類別的實例（Instance），直接呼叫Account()來建立。建立物件之後，你可以直接在物件上添增特性，透過 . 來存取特性。

上面這個例子的帳號、名稱、餘額是在程式碼中自行建立，並透過函式來作存提款的動作。事實上，你可以將物件建立後的初始化動作，以及會用到的相關操作定義在類別之中。來看看下面這個例子：

class Account:
    def __init__(self, number, name):
        self.number = number
        self.name = name
        self.balance = 0
        
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError('must be positive')
        self.balance += amount
        
    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
        else:
            raise RuntimeError('balance not enough')

這個類別已包含幾個Python中定義類別的觀念。首先是：

def __init__(self, number, name):
    self.number = number
    self.name = name
    self.balance = 0

__init__這個特定的名稱，用來定義類別的實例建立之後，要進行的初始化動作。第一個self參數代表建立的類別實例，在Python中，實例可操作的方法，第一個參數必須明確作為接受實例之用，慣例上取名為self名稱。__init__之後則可指定初始化時所必須給定的資料。在上面的例子中，會在建立的實例上增加number、name與balance特性。你可以用以下方式來建構物件：

acct = Account('123-456-789', 'Justin')

每個建構出來的Account實例，都會擁有自己的資料狀態，可以直接透過物件及 . 來存取特性：

print(acct.number) # 123-456-789
print(acct.name) # Justin

再來看到方法（Method）定義：

def deposit(self, amount):
    if amount <= 0:
        raise ValueError('must be positive')
    self.balance += amount

def withdraw(self, amount):
    if amount <= self.balance:
        self.balance -= amount
    else:
        raise RuntimeError('balance not enough')

同樣的道理，在Python中，實例可操作的方法，第一個參數必須明確作為接受實例之用，之後若要在方法中存取物件特性或呼叫物件方法，則必須明確以傳入的物件搭配.運算，例如self.balance這樣的方式。以下則是呼叫方法的幾個例子：

acct.deposit(100)
print(acct.balance) # 100
acct.withdraw(50)
print(acct.balance) # 50

在Python中，函式是物件，對於定義在類別中的方法也是一種函式，自然你也可以將之指定給別的變數。例如：

acct1 = Account('123-456-789', 'Justin')
deposit1 = acct1.deposit
withdraw1 = acct1.withdraw
deposit1(100)
withdraw1(50)
print(acct1.balance)

acct2 = Account('987-654-321', 'Momor')
deposit2 = acct2.deposit
withdraw2 = acct2.withdraw
deposit2(200)
withdraw2(100)
print(acct2.balance)

acct1.deposit = acct2.deposit
acct1.deposit(1000)      # 你其實是將錢存到 acct2 去
print(acct1.balance)     # 50
print(acct2.balance)     # 1100

上面這個例子其實也指出了，在Python中，方法總是跟隨著物件而建立，而self是綁定為所建立的物件，別以為將方法指定給另一個物件可以欺騙Python，就如上面的例子中，倒數第三行的結果，其實是將錢存到acct2所參考的物件。

yield 產生器

2011-09-10T13:22:00.002-07:00

你可以在函式中包括yield來「產生」值，表面上看來，yield就像是return會傳回值，但又不中斷函式的執行：

>>> def myrange(n):
...     x = 0
...     while True:
...         yield x
...         x += 1
...         if x == n:
...             break
...
>>> for i in myrange(10):
...     print(i, end='')
... print()
...
0123456789
>>>

上面的程式模擬了內建函式range()的作用。表面上看來，你在myrange()函式中使用yield傳回值，然後執行for in迴圈，接著再使用myrange()傳回下一個值，再執行for in迴圈，就好似myrange()執行過後沒有結束似的。

實際上，在def所定義的本體中，若包括yield運算式，則Python會將之編譯為一個產生器（Generator）。例如：

>>> myrange(10)
<generator object myrange at 0x01C98440>
>>> dir(myrange(10))
['__class__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__get
attribute__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__lt__',
'__name__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__r
epr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'close', 'gi
_code', 'gi_frame', 'gi_running', 'send', 'throw']
>>>

產生器物件是個具有迭代器（Iterator）介面的物件，也就是說，它具有__next__()方法，可以使用next()函式來取出下一個值，若無法產生下一個值，則會丟出StopIteration物件。例如：

>>> g = myrange(3)
>>> next(g)
0
>>> next(g)
1
>>> next(g)
2
>>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>

這也就是為何在第一個例子中，在for in迴圈呼叫myrange()會有那樣的結果。一個函式若包括yield，則會傳回產生器物件，而該函式基本上可以包括return，不過不可以指明傳回值（也就是只能傳回None）。return只是用來結束函式的執行流程。例如：

>>> def myrange(n):
...     x = 0
...     while True:
...         yield x
...         return
...
>>> g = myrange(3)
>>> next(g)
0
>>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>

在上例中，第一個next(g)後，函式的執行流程就因return而結束了，嘗試再執行next(g)，就函式定義來看，無法再執行到yield運算式，所以就函式定義來看，StopIteration是因為無法執行到yield運算式而丟出的。

先前談過 for 包含式（Comprehension），實際上，for包含式與迭代器都是一個叫產生器運算式的語言特性。在 for 包含式（Comprehension）中最後一個例子也有提到，使用()與for包含式時，實際上是建立一個產生器。例如：

>>> (i ** 2 for i in range(3))
<generator object <genexpr> at 0x01C98440>
>>> g = (i ** 2 for i in range(3))
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>> for p in (i ** 2 for i in range(3)):
... print(p)
...
0
1
4
>>>

從Python 2.5開始，yield從陳述改為運算式，也就是yield除了「產生」指定的值之外，會有一個運算結果，yield運算結果預設是None，你可以透過產生器的send()方法傳入一個值，這個值就成為yield的運算結果。這給了你一個與產生器溝通的機會。例如：

>>> def myrange(n):
...     x = 0
...     while True:
...         val = (yield x)
...         if val is not None:
...             x = val
...         else:
...             x += 1
...         if x >= n:
...             break
...
>>> g = myrange(10)
>>> next(g)
0
>>> next(g)
1
>>> next(g)
2
>>> g.send(0)
0
>>> next(g)
1
>>> next(g)
2
>>> g.send(5)
5
>>> next(g)
6
>>> next(g)
7
>>>

變數範圍

2011-09-10T13:22:00.000-07:00

在Python中，變數無需宣告就可以直接使用並指定值，除非特別使用global或nonlocal指明，否則變數範圍（Scope）總是在指定值時建立。例如：

>>> x = 10
>>> y = 10
>>> def some():
...     x = 20
...     print(x)
...     print(y)
...
>>> some()
20
10
>>> print(x)
10
>>> print(y)
10
>>>

在上例中，some()函式中的x，其實是在函式範圍中所建立的新x，其覆蓋了外部的x範圍，所以你所設定的是區域變數x，指定值給變數時，就是在該範圍中建立該變數，就是指這樣的情況。如果取用變數時，也是從當時的範圍開始尋找，若沒有，才找尋外部範圍，例如上例中，取用x時，在區域範圍找到區域變數x，所以顯示的是區域變數x的值，而不是外部變數x，取用y時，由於區域範圍找不到，所以取得外部y的值。

記得變數範圍的建立是在指定時發生，而不是在取用時發生，所以像下面這個例子：

>>> x = 20
>>> def some(x = x):
... print(x)
...
>>> some()
20
>>> some(30)
30
>>> print(x)
20
>>>

是定義了一個some()函式，將當時外部變數x的值20設定給參數x作為預設值。

實際上，在Python中變數可以在四個範圍中建立或尋找。內建（Builtin）、全域（Global）、外包函式（Endosing function）、函式（Local functon）。一個例子如下：

demo.py

x = 10       　　# 全域

def outer():
   y = 20        # 在 outer() 函式範圍
   
   def inner():
       z = 30    # 在 inner() 函式範圍
       print(x)  # 內建範圍 print，全域的 x
   　　print(y)  # 內建範圍 print，外包 outer() 函式的 y
   
   prnt(x)       # 內建範圍 print，全域的 x

取用名稱時（而不是指定），一定是從最內層往外尋找。Python中所謂全域，實際上是以模組檔案為界，以上例來說，x實際上是demo模組範圍中的變數，不會橫跨所有模組範圍。

注意，到print名稱，實際上它是內建範圍，在Python 3中有個builtins模組，該模組中的變數，會自動被所有的模組所擁有。例如：

>>> import builtins
>>> dir(builtins)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'Buffer
Error', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'Environme
ntError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'Generato
rExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexErr
or', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError',
'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'P
endingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', '
StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'Ta
bError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'Unicod
eEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserW
arning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_
class__', '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs'
, 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'chr', 'classmetho
d', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'div
mod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozens
et', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int
', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map'
, 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'pr
int', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr'
, 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'va
rs', 'zip']
>>>

所以許多Python中可以直接使用的函式，其名稱實際上是在builtins模組之中。基本上，你也可以將變數建立至builtins中。例如：

import builtins
import sys
builtins.argv = sys.argv
print(argv[1])

變數指定值的同時就確立其所在的範圍。如果你希望指定值的變數是全域範圍的話，則可以使用global指明（雖然並不鼓勵全域變數）。例如：

>>> x = 10
>>> def some():
... global x
... x = 20
...
>>> some()
>>> print(x)
20
>>>

來看看以下這個會發生什麼事情？

>>> x = 10
>>> def some():
... print(x)
... x = 20
...
>>> some()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in some
UnboundLocalError: local variable 'x' referenced before assignment
>>>

在some()函式中，print(x)中的x其實是some()函式中的區域變數x，因為範圍建立總是在指定時發生，在some()函式的第二行中，有個x指定，所以Python直譯器看到的是這個x，而你在指定x值之前，就要顯示其值，就會發生錯誤。上面這個錯誤可以這麼修改：

>>> x = 10
>>> def some():
...     global x
...     print(x)
...     x = 20
...
>>> some()
10
>>>

在Python 3中新增了nonlocal，可以讓你指明變數並非區域變數，請依照函式（Local functon）、外包函式（Endosing function）、全域（Global）、內建（Builtin）的順序來尋找，即使是指定運算。例如：

x = 10
def outer():
   x = 100         # 這是在 outer() 函式範圍的 x
   def inner():
       nonlocal x
       x = 1000    # 改變的是 outer() 函式的 x
   inner()
   print(x)        # 顯示 1000

outer()
print(x)           # 顯示 10

因此，在 lambda 運算式看過的一個例子：

>>> def func():
...     x = 10
...     def getX():
...         return x
...     def setX(n):
...         x = n
...     return (getX, setX)
...
>>> getX, setX = func()
>>> getX()
10
>>> setX(20)
>>> getX()
10
>>>

在上例中，func()中的setX()宣告的x，其實是setX()中的區域變數x，其覆蓋了外部func()的x，所以你的n是指定給區域變數x。如果你要改變func()中的x值，則可以在setX()函式中宣告nonlocal。例如：

>>> def func():
...     x = 10
...     def getX():
...         return x
...     def setX(n):
...         nonlocal x
...         x = n
...     return (getX, setX)
...
>>> getX, setX = func()
>>> getX()
10
>>> setX(20)
>>> getX()
20
>>>

lambda 運算式

2011-09-10T13:21:00.003-07:00

在Python中，函式是一級（First-class）公民，也就是說，在Python中，函式是物件，為function的實例。如果你要定義一個函式，基本上是使用def來定義，如同 def 陳述句中所說明過的，例如你要定義一個最大值的函式：

def max(m, n):
    return m if m > n else n

print(max(10, 3))  # 顯示 10

你可以用lambda運算式來定義函式，執行運算式時將會產生函式物件。例如，上面的max函式，可以用以下的方式定義：

max = lambda m, n: m if m > n else nprint(max(10, 3))  # 顯示 10

lambda的語法是：

lambda arg1, arg2, ....: expression

lambda中arg1、arg2等就相當於定義函式時的參數，之後你可以在expression中使用這些參數。注意！lambda是運算式，不是陳述句，你在:之後的也必須是運算式，lambda中也不能有區塊，這表示一些小的運算任務你可以使用lambda，而較複雜的邏輯你可以使用def來定義。

基本上，lambda會產生function的實例，所以在def 陳述句中所提到的參數定義與引數指定方式，對於lambda所產生的function實例都是適用的。

在Python中缺少其它語言中的switch陳述句，以下結合字典物件與lambda模擬switch的示範：

score = int(input('請輸入分數：'))
level = score // 10
{
    10 : lambda: print('Perfect'),
    9  : lambda: print('A'),
    8  : lambda: print('B'),
    7  : lambda: print('C'),
    6  : lambda: print('D')
}.get(level, lambda: print('E'))()

在上例中，字典物件中的值的部份是lambda所建立的函式物件，你使用get()方法指定鍵，如果有符合的鍵，就傳回對應的函式物件並執行，否則就傳回get()第二個引數所指定的函式並執行，這模擬了switch中default的陳述。

在Python中，函式是function的實例，所以你可以自由傳遞，將一個函式中所定義的函式傳回也是常見的應用。例如：

def add(n1):
    def func(n2):
        return n1 + n2
    return func

print(add(1)(2))  # 顯示 3

從一個函式中呼叫另一個函式，這是函式程設中鞣制（Curry）的概念。所謂鞣製，是指將接受多個參數的函式，改為接受單一參數的函式，在函式執行過後傳回一個函式物件再套用剩下的參數，就像是將兩個函式鞣製在一起。

另一個值得注意的是，n1參數的存活期間，本應跟隨著add()函式呼叫完成就結束，不過因為n1被綁定在func()函式之中，形成了一個閉包（Closure）。

所謂的閉包（Closure），是指一個函式物件（或函式值）在建立時，綁定了當時作用範圍（Scope）下有效的自由變數（Free variable）。所以支援閉包的語言，必須有支援一級函式（First-class function），建立函式物件並不等於建立閉包，建立函式物件時同時綁定了某個（些）自由變數，該函式物件才稱之為閉包。

在Python中，確實支援閉包的概念。例如：

>>> def outer():
...     x = 10
...     def inner():
...         print(x)
...     inner()
...     x = 20
...     return inner
...
>>> f = outer()
10
>>> f()
20
>>>

在上例中，inner()確實綁定了區域變數x，在outer()內部呼叫inner()時顯示的是10，而後改變了x為20，由於inner()綁定了x，所以傳回的函式執行時，顯示x的值為20。

不過實際上在應用時，還是得小心一點。例如：

在上例中，func()中的setX()宣告的x，其實是setX()中的區域變數x，其覆蓋了外部func()的x，所以你的n是指定給區域變數x。

回到鞣製的討論，實際上其應用，在於先針對既有的資料先行作運算並傳回未運算的函式，待後續資料備妥後再完成整個所需的運算結果。一個例子像是因式分解，可以先準備好一定長度的質數表，之後利用該質數表來進行因式分解。例如：

import math

def prepare_factor(max):
    prime = [1] * max
    for i in range(2, int(math.sqrt(max))):
        if prime[i] == 1:
            for j in range(2 * i, max):
                if j % i == 0:
                    prime[j] = 0
    primes = [i for i in range(2, max) if prime[i] == 1] # 質數表
           
    def factor(num):
        list = []
        i = 0
        while primes[i] ** 2 <= num:
            if num % primes[i] == 0:
                list.append(primes[i])
                num //= primes[i]
            else:
                i += 1
        list.append(num)
        f = [0] * len(list)
        for i in range(len(f)):
            f[i] = list[i]
        return f
        
    return factor

factor = prepare_factor(1000)
print(factor(100))  # 顯示 [2, 2, 5, 5]
print(factor(500))  # 顯示 [2, 2, 5, 5, 5]
print(factor(800))  # 顯示 [2, 2, 2, 2, 2, 5, 5]

def 陳述句

2011-09-10T13:21:00.001-07:00

在Python中要定義函式，是使用def來定義，例如，以下是個求最大公因數的函式定義：

def gcd(m, n):
    if n == 0:
        return m
    else:
        return gcd(n, m % n)

print(gcd(20, 30)) # 顯示 10

在上例中，gcd是函式名稱，m與n為參數（Parameter）名稱，如果要傳回值則使用return，如果函式執行完畢但沒有使用return傳回值，則傳回None。

實際上，def是個陳述句，Python執行到def時，會產生一個函式物件，為function的實例，即然函式是個物件，它可以指定給其它的變數，例如：

def gcd(m, n):
    if n == 0:
        return m
    else:
        return gcd(n, m % n)

print(gcd(20, 30))         # 顯示 10
print(type(gcd))           # 顯示 <class 'function'>

gcd2 = gcd
print(gcd2(20, 30))        # 顯示 10
print(id(gcd), id(gcd2))   # 兩個顯示的數字相同

在Python中不支援其它語言函式重載的概念（例如Java），也就是在Python中同一個名稱空間中，不能有相同的函式名稱。如果你定義了兩個函式具有相同的名稱但擁有不同的參數個數，則後者定義會覆蓋前者定義。例如：

>>> def sum(a, b):
... return a + b
...
>>> def sum(a, b, c):
... return a + b + c
...
>>> sum(1, 2, 3)
6
>>> sum(1, 2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: sum() takes exactly 3 positional arguments (2 given)
>>>

由於Python是動態語言，只需在設計時確認傳入函式的物件所擁有的特性或方法，無需採函式重載中，依型態不同來區別所呼叫函式的部份，至於依函式個數不同來區別的函式重載概念，在Python中可以使用預設引數（Argument）來解決。例如：

def sum(a, b, c = 0):
    return a + b + c

print(sum(10, 20, 30))   # 顯示 60
print(sum(10, 20))       # 顯示 30

在上例中，如果沒有指定第三個參數c的值，則預設值是0。事實上，在呼叫函式時，並不一定要依參數宣告順序來傳入引數，而可以指定參數名稱來設定其引數值，稱之為關鍵字引數。例如：

def sum(a, b, c = 0):
    return a + b + c

print(sum(c = 30, a = 10, b = 20))  # 顯示 60

使用預設值指定時，必須小心指定可變動物件時的一個陷阱，在Python中，def是個陳述，所以執行到def陳述時，就建立了該陳述相關的資源。來看看下面會有什麼問題？

>>> def appendTo(element, arr = []):
... arr.append(element)
... return arr
...
>>> appendTo(10, [1, 2, 3])
[1, 2, 3, 10]
>>> appendTo(10)
[10]
>>> appendTo(20, [4, 5, 6])
[4, 5, 6, 20]
>>> appendTo(20)
[10, 20]
>>> appendTo(30)
[10, 20, 30]
>>> appendTo(40)
[10, 20, 30, 40]
>>>

在上例中，你的 arr預設值設定為空串列，由於def是個陳述，執行到def的函式定義時，就建立了空串列物件，而這個物件會一直存在，如果你沒有指定arr的串列物件時，所使用的就一直會是一開始指定的預設空串列物件，也因此，隨著每次呼叫都不指定arr的值，你附加的對象，都是同一個物件。

像sum這種加總數字的需求，事先可能不知道要傳入的引數數量，可以在定義函式的參數時使用*，表示該參數接受不定長度參數。例如：

def sum(*numbers):
    total = 0
    for number in numbers:
        total += number
    return total

print(sum(1, 2))        # 顯示 3
print(sum(1, 2, 3))     # 顯示 6
print(sum(1, 2, 3, 4))  # 顯示 10

你傳入函式的引數，會被收集在一個Tuple中，再設定給number參數。有趣的是，如果你有個函式擁有固定的參數，你可以將一個Tuple傳入，只要在傳入時加上*，則Tuple中每個元素會自動指定給各個參數。例如：

def sum3(a, b, c):
    return a + b + c

numbers = (1, 2, 3)
print(sum3(*numbers))

**則可以將關鍵字引數收集在一個字典物件中，當一個函式所需要的參數個數很多時，可以使用這個方式。例如：

>>> def dosome(**args):
... print(args)
...
>>> dosome(name = 'Justin', passwd = 123456, job = '?')
{'passwd': 123456, 'job': '?', 'name': 'Justin'}
>>>

反過來的話，如果函式參數個數固定，你也可以傳給函式一個字典物件，只要在物件前加上**，則Python會依字典物件的鍵名稱，將值指定給對應名稱的參數。例如：

def sum3(a, b, c):
    return a + b + c

args = {'a' : 1, 'b' : 2, 'c' : 3}
print(sum3(**args))

你可以在一個函式中，同時使用*與**。例如：

>>> def some(*arg1, **arg2):
... print(arg1)
... print(arg2)
...
>>> some(1, 2, 3)
(1, 2, 3)
{}
>>> some(a = 1, b = 22, c = 3)
()
{'a': 1, 'c': 3, 'b': 22}
>>> some(2, a = 1, b = 22, c = 3)
(2,)
{'a': 1, 'c': 3, 'b': 22}
>>>

在Python中，函式中還可以定義函式，稱之為區域函式（Local function），你可以使用區域函式將某個函式中的演算組織為更小的單元，例如，在選擇排序的實作時，每次會從未排序部份選擇一個最小值放置到已排序部份之後，在底下的範例中，尋找最小值的演算就實作為區域函式的方式：

def selection(number):
    # 找出未排序中最小值
    def min(m, j):
        if j == len(number):
            return m
        elif number[j] < number[m]:
            return min(j, j + 1)
        else:
            return min(m, j + 1)
    
    for i in range(0, len(number)):
        m = min(i, i + 1)
        if i != m:
            number[i], number[m] = number[m], number[i]

number = [1, 5, 2, 3, 9, 7]
selection(number)
print(number)     # 顯示 [1, 2, 3, 5, 7, 9]

可以看到，區域函式的好處之一，就是可以直接存取包裹它的外部函式之參數（或宣告在區域函式之前的區域變數），如此可減少呼叫函式時引數的傳遞。

try、raise 陳述句

2011-09-09T15:43:00.001-07:00

以下這個程式，預期使用者要輸入整數：

input = int(input('輸入整數：'))
print('{0} 為 {1}'.format(input, '奇數' if input % 2 else '偶數'))

如果使用者輸入的不是整數，就會出現錯誤：

輸入整數：one
Traceback (most recent call last):
File "demo.py", line 1, in <module>
input = int(input('輸入整數：'))
ValueError: invalid literal for int() with base 10: 'one'

在Python中程式若發生錯誤，會丟出例外事件，以上例而言就是引發（Raise）ValueError物件，如果程式沒有處理例外而丟出至執行環境，則會顯示例外追蹤（Traceback）並中斷程式。如果你想要處理例外，則可以使用try...except語句。例如：

try:
    input = int(input('輸入整數：'))
    print('{0} 為 {1}'.format(input, '奇數' if input % 2 else '偶數'))
except ValueError:
    print('請輸入阿拉伯數字')

如果使用者輸入錯誤，引發的ValueError物件會被except比對型態是否相同，如果相同則執行對應的區塊。以上例而言，如果使用者輸入錯誤，就會顯示較友善的提示訊息（而不是丟個使用者看不懂的追蹤訊息）：

輸入整數：one
請輸入阿拉伯數字

try..except的except可以指定多個物件，也可以有多個except，如果沒有指定except後的物件型態，則表示捕捉所有引發的物件。舉例來說，上例中若使用者於輸入時輸入Ctrl+Z，在Windows環境下會引發EOFError，若輸入Ctrl+C，則會引發KeyboardInterrupt。下例中處理這些可能的狀況：

import traceback
try:
    input = int(input('輸入整數：'))
    print('{0} 為 {1}'.format(input, '奇數' if input % 2 else '偶數'))
except ValueError:
    print('請輸入阿拉伯數字')
except (EOFError, KeyboardInterrupt):
    print('使用者中斷程式')
except:
    print('不明的程式中斷')
    traceback.print_exc()

由於except會捕捉所有引發的物件，所以必須置於最後。traceback.print_exc()則可以顯示例外的追蹤訊息。try還可以搭配finally，一但設置，無論有無引發物件，finally區塊一定會執行，這通常用來作為關閉若干資源的區塊，例如關閉檔案：

file = open('demo.py', 'r', encoding='UTF-8')
try:
    for line in file:
        print(line, end='')
except:
    print('讀取檔案發生錯誤')
finally:
    file.close()

try也可以搭配else區塊，如果try區塊中沒有任何的錯誤發生，則會執行else區塊：

try:
    statement
except some:
    statement
except:
    statement
else:
    statement
finally:
    statement

你可以使用raise自行引發例外。例如：

>>> try:
... raise EOFError
... except EOFError:
... print('EOFError')
...
EOFError
>>>

for 包含式（Comprehension）

2011-09-09T15:42:00.000-07:00

你可以在for運算式中使用包含式語法來進行值的收集，for運算結束傳回收集的結果，例如：

import sys
files = [arg for arg in sys.argv if arg.endswith('.txt')]
print(files)

這個範例可以收集命令列引數中輸入為.txt結尾的檔名，只有符合if測試的arg才會被收集，由於使用[]包含，所以最後的結果是以串列傳回。例如：

>python demo.py 1.txt 2.doc. 3.txt 4.html 5.txt
['1.txt', '3.txt', '5.txt']

if的部份可以省略，這時會收集所有的迭代的值，你可以在for左邊進行值的處理。例如計算串列中所有數的平方數：

>>> [number ** 2 for number in [10, 20, 30]]
[100, 400, 900]

如果要作更巢狀的元素包括也是可行的，例如以下可將二維矩陣轉換為一維陣列：

>>> matrix = [
...     [1, 2, 3],
...     [4, 5, 6],
...     [7, 8, 9]
... ]
>>> array = [element for row in matrix for element in row]
>>> array
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

上例若不以for包含式來實作，則如下：

>>> matrix = [
...     [1, 2, 3],
...     [4, 5, 6],
...     [7, 8, 9]
... ]
>>> array = []
>>> for row in matrix:
...     for element in row:
...         array.append(element)
...
>>> array
[1, 2, 3, 4, 5, 6, 7, 8, 9]

另一個例子是，使用for包含式來取得兩個串列的排列組合：

>>> [letter1 + letter2 for letter1 in 'Justin' for letter2 in 'momor']
['Jm', 'Jo', 'Jm', 'Jo', 'Jr', 'um', 'uo', 'um', 'uo', 'ur', 'sm', 'so', 'sm', 'so', 'sr', 'tm', 'to', 'tm', 'to', 'tr', 'im', 'io', 'im', 'io', 'ir', 'nm', 'no
', 'nm', 'no', 'nr']
>>>

在Python3中，for包含式所收集的元素並不一定得包括在串列中，而可以包括在集合、字典中。例如：

>>> {i for i in 'Justin'}
{'i', 'J', 'n', 's', 'u', 't'}
>>> scores = [('Justin', 95), ('momor', 93), ('Hamimi', 99)]
>>> {name : score for (name, score) in scores}
{'Hamimi': 99, 'Justin': 95, 'momor': 93}
>>>

如果以()包括for包含式，則會建立一個產生器物件（本身是個具有__next__()的迭代器），可以直接對其迭代來逐一取得元素。例如建立一個質數產生器（參考 Eratosthenes 篩選求質數）：

import math
def primes(max):
    prime = [1] * max
    for i in range(2, int(math.sqrt(max))):
        if prime[i] == 1:
            for j in range(2 * i, max):
                if j % i == 0:
                    prime[j] = 0
    return (i for i in range(2, max) if prime[i] == 1)
                
for prime in primes(1000):
    print(prime, end=" ")

for 與 while 陳述句

2011-09-09T15:41:00.000-07:00

如果你想要循序取出某個序列，例如串列，則可以使用for陳述句，例如，將使用者提供的命令列引數逐一取出：

import sys
for arg in sys.argv:
    print(arg)

一個執行的範例如下：

> python demo.py justin momor
demo.py
justin
momor

實際上，只要是具有__iter__()方法的物件，都可以使用for陳述句來迭代，__iter__()方法應該傳回一個迭代器（Iterator），該迭代器具有__next__()方法，每次迭代時就會傳回下一個物件，而沒有下一個元素時，則會引發StopIteration例外。可以使用iter()方法嘗試從物件上取得迭代物件。例如：

>>> iterator = [1, 2, 3].__iter__()
>>> iterator.__next__()
1
>>> iterator.__next__()
2
>>> iterator.__next__()
3
>>> iterator.__next__()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>> iterator = iter([1, 2, 3])
>>> iterator.__next__()
1
>>> iterator.__next__()
2
>>> iterator.__next__()
3
>>> iterator.__next__()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>

對於具有__iter__()所傳回的迭代器，你也可以直接使用next()取得下一個元素，而不用直接呼叫__next__()方法。

所以你可以使用for迭代字串、串列、集合、字典或Tuple等，只要物件上具有__iter__()方法。除了逐元素來進行迭代外，還可以結合指定運算的特性。例如：

>>> for (a, b) in [(1, 2), (10, 20), (100, 200)]:
... print(a, b)
...
1 2
10 20
100 200
>>> for (key, value) in {'admin' : 'Justin', 'user' : 'momor'}.items():
... print(key, value)
...
admin Justin
user momor
>>>

如果你有指定範圍或索引的需求，則可以使用range()類別產生一個range物件，由它來迭代出所指定的數字範圍，而你再利用這些數字作為索引：

>>> for index in range(2, 5):
...     print(index)
...
2
3
4
>>> for index in range(5):
...     print(index)
...
0
1
2
3
4
>>> for index in range(0, len('Justin'), 2):
...     print('Justin'[index])
...
J
s
i
>>>

如上所看到的，range類別可以指定起始、結結與步進值：

range([start,] stop[, step]) -> range object

for陳述可以搭配一個可選的else陳述，當for迴圈中沒有遇到任何break陳述而離開迴圈時，就會執行else區塊。例如以下判斷輸入數字是否為質數：

number = int(input('輸入數字：'))
half = number // 2
for num in range(2, half + 1):
    if (number % num) == 0:
        print(number, '不是質數')
        break
else:
    print(number, '是質數')

一個執行的範例如下：

輸入數字：13
13 是質數

break陳述可以讓你離開迴圈，而continue則可以讓你跳過該次迭代continue後的程式碼，直接作下一次迭代。例如以下僅顯示小寫英文字母：

text = input('輸入英文字母：')
for letter in text:
    if letter.isupper():
        continue
    print(letter, end='')

一個執行範例如下：

輸入英文字母：This is Justin's speaking!
his is ustin's speaking!

while迴圈根據所指定的條件式來判斷是否執行迴圈本體，例如以下是個求最大公因數的程式：

print('輸入兩個數字...')
m = int(input('number 1: '))
n = int(input('number 2: '))
while n != 0:
   r = m % n
   m = n
   n = r
print("GCD:", m)

Python中沒有其它語言的do while語句，所以必須使用判斷式及break來達成。例如判斷輸入為奇數或偶數，直到使用者回答No為止：

while True:
    number = int(input("輸入數字："))
    print("輸入數為", '奇數' if number % 2 else "偶數")
    if(input('繼續？（Yes/No）') == 'No'):
        break

while陳述同樣可以搭配else陳述，同樣地，在迴圈中沒有遇到break的話，則else區塊會被執行，由於while一開始就會測試是否執行迴圈，所以若迴圈本體完全沒有執行（當然也就不會遇到break），一樣也會執行else區塊。

if 陳述句

2011-09-09T15:40:00.000-07:00

要在某條件成立時才進行某些動作，Python提供了if運算式，一個例子如下：

import sys
filename = 'default.properties'
if len(sys.argv) != 1:
    filename = sys.argv[1]
print(filename)

這個範例中，預設的檔案名稱是default.properties，如果使用者有提供命令列引數，則sys.argv的長度就會大於1（記得索引0是模組檔案名稱），所以len(sys.argv) != 1的結果是True，所以if條件成立，將filename設定為使用者所提供的命令列引數。

if可以搭配else，在if條件不成立時，執行else中定義的程式碼，所以上例也可以這麼寫：

import sys
filename = ''
if len(sys.argv) == 1:
    filename = 'default.properties'
else:
    filename = sys.argv[1]
print(filename)

在Python中，區塊是從:開始，同屬一個區塊的程式碼，必須有相同的縮排（例如四個空白或一個Tab鍵）。這可以避免C/C++、Java中的某些不明確的狀況。例如：

if(....)
    if(...)
         doSometing();
else
    doOther();

乍看之下，else似乎是與第一個if配對，但實際上，else是與最近的if配對，也就是第二個if。但在Python中沒有這個問題：

if ...:
    if ...:
         dosomething()
else:
    doother()

Python以縮排作為區塊依據，以上例而言，else是與第一個if配對，如果是下例，則else是與第二個if配對：

if ...:
    if ...:
         dosomething()
        else:
        doother()

如果有多重判斷，則可以使用if..elif..else結構。例如：

score = int(input('輸入分數：'))
if score >= 90:
    print('得 A')
elif score >= 80 and score < 90:
    print('得 B')   
elif score >= 70 and score < 80:
    print('得 C')   
elif score >= 60 and score < 70:
    print('得 D')       
else:
    print('不及格')

在Python中有個if..else運算式語法，可以讓你擁有像C/C++、Java的?:三元運算子功能。例如：

import sys
filename = 'default.properties' if len(sys.argv) == 1 else sys.argv[1]
print(filename)

上例中，如果if的判斷為真，則傳回'default.properties'，否則傳回sys.argv[1]的值。以下是個簡單的判斷輸入數是奇數或偶數的程式：

input = int(input('輸入整數：'))
print('{0} 為 {1}'.format(input, '奇數' if input % 2 else '偶數'))

物件與記憶體管理

2011-09-09T15:39:00.000-07:00

在Python中所有東西都是物件，即使是數值型態也不例外，變數在Python中，是個用來參考至物件的名稱。例如：

>>> x = 1.0
>>> y = 1.0
>>> id(x)
25925072
>>> id(y)
25925056
>>> x == y
True
>>> x is y
False
>>> x = y
>>> id(x)
25925056
>>> id(y)
25925056
>>> x is y
True
>>>

在上例中，x與y一開始分別參考至兩個浮點數物件，可以使用id()函式來傳回物件所在的記憶體位址值。==在Python中比較實質的相等性，如果要知道兩個變數是否參考至同一物件，則可以使用is運算子。指定運算會將右邊物件指定給左邊變數參考，在上例中，y參考的物件後來指定了給x參考，而x原先參考的物件，目前沒有任何變數參考至它，最後就會被垃圾回收（Garbage collection），從記憶體中清除。

+在Python中通常會產生新物件，例如在串接字串時：

>>> str1 = 'Just'
>>> str2 = 'in'
>>> str3 = str1 + str2
>>> str3
'Justin'
>>> id(str3)
26577760
>>> str3 = str1 + str2
>>> id(str3)
26578432
>>> str3 = str1 + str2
>>> id(str3)
26577760
>>>

在上例中可以看到，每次串接都會產生新字串，因此str3所參考的物件記憶體位址都不相同，在Python中不建議在經常性的操作中使用+串接字串（例如迴圈中）。如果要串接字串，可以一些替代方式，例如先使用串列收集：

>>> str1 = 'Just'
>>> str = ''
>>> id(str)
25608320
>>> str += 'Just'
>>> id(str)
26606976
>>> str += 'in'
>>> id(str)
26578432
>>> str
'Justin'
>>> buf = []
>>> id(buf)
27053752
>>> buf.append('Just')
>>> id(buf)
27053752
>>> buf.append('in')
>>> id(buf)
27053752
>>> str = ''.join(buf)
>>> str
'Justin'
>>>

上例中，示範了直接使用+與使用串列先收集個別字串的方式，如果執行次數頻繁的話，後者會較有效率。

在Python中，對於小整數或字串會有快取的動作。例如：

>>> x = 1
>>> y = 1
>>> id(1)
505389048
>>> x = 1
>>> y = 1
>>> id(x)
505389048
>>> id(y)
505389048
>>> x = 10000
>>> y = 10000
>>> id(x)
26713152
>>> id(y)
26711664
>>> str1 = 'Justin'
>>> str2 = 'Justin'
>>> str1 == str2
True
>>>

什麼範圍的小整數會快取，因Python的版本而有所不同。

如果想要知道一個物件有幾個名稱參考至它，可以使用sys.getrefcount()函式。例如：

>>> import sys
>>> sys.getrefcount(1)
117
>>> x = [1, 2, 3]
>>> y = x
>>> z = x
>>> sys.getrefcount(x)
4

運算子

2011-09-09T15:38:00.000-07:00

到現在已經看過幾個運算子了，最基本的就是+、-、*、/運算子，當他們用在數值運算時是較為直覺的加、減、乘、除運算。不過，+在Python的物件上，往往可以作串接物件的作用，例如串接字串、串接Tuple、串接串列等，結果都是產生新的物件傳回：

>>> 'Just' + 'in'
'Justin'
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> (1, 2) + (3, 4)
(1, 2, 3, 4)
>>>

*在Python上，則通常可以作加倍的動作，例如：

>>> 'Justin' * 4
'JustinJustinJustinJustin'
>>> [1, 2] * 4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> (1, 2) * 4
(1, 2, 1, 2, 1, 2, 1, 2)
>>>

如果要作數值次方運算，則使用**。例如：

>>> 9 ** 2
81
>>> 9 ** 3
729
>>> 9 ** 0.5
3.0
>>>

在數值運算上，還有個//運算子，這是用來取除法的商值，而%則用來取除法的餘數。例如：

>>> 10 // 3
3
>>> 10 % 3
1
>>>

Python還提供了關係運算（Rational operation）、邏輯運算（Logical operation）、位元運算（Bitwise operation）等對物件的運算子：

關係運算：如>、>=、<、<=、==、!=
邏輯運算：如and、or、not
位元運算：如&、|、~、^、>>、<<
指定運算：如+=、-=、*=、/=、%=、&=、|=、~=、>>=、<<=...

不僅僅是數值可以使用其它的運算子，在適當的場合，特定的物件也可以使用這些運算子，例如集合（Set）可以使用&、|、^來作交集、聯集等設定，可以參考集合的說明。

在現階段，你可以先知道的是，運算子作用於物件的動作，其實是可以透過定義特殊方法（Method）來決定該如何進行處理。例如+可以定義__add__()方法，而%可以定義__mod__()方法：

>>> dir(1)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delatt
r__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__
', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__ha
sh__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__',
'__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__po
s__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_
ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ro
r__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtrue
div__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subcla
sshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'de
nominator', 'imag', 'numerator', 'real']
>>> 1 + 2
3
>>> (1).__add__(2)
3
>>> 10 % 3
1
>>> (10).__mod__(3)
1
>>>

就算是[]索引運算，也是可以透過對應的__getitem__()、__setitem()__來定義：

>>> dir([])
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__doc__'
, '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__',
'__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__'
, '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__re
pr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '
__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'p
op', 'remove', 'reverse', 'sort']
>>> x = [1, 2, 3]
>>> x[1]
2
>>> x.__getitem__(1)
2
>>> x.__getitem__(2)
3
>>> x[2]
3
>>> x[0] = 10
>>> x.__setitem__(1, 20)
>>> x
[10, 20, 3]
>>>

初學目前僅需了解到這邊，在了解如何自定義類別之後，將會再介紹如何定義這些特定的方法。

在使用邏輯運算and、or、not時，要注意到，在Python中，數字不是0就是True，而所有物件不是「空」就是True，例如字串'Justin'在判斷式中會是 True，而空字串''在判斷式中會是False，所以空串列是False、空字典是False、空Tuple是False，而None也是False。例如：

>>> passwd = ''
>>> if not passwd:
... print('Password Required')
...
Password Required
>>>

and、or有捷徑運算，and左運算元若判定為假，則就不會繼續運算右運算元，or則是左運算元判斷為真，則不的運算右運算元。當判斷確認時停在哪個運算元，就會傳回該運算元，例如：

>>> [] and 'Justin'
[]
>>> [1, 2] and 'Justin'
'Justin'
>>> [] or 'Justin'
'Justin'
>>> [1, 2] or 'Justin'
[1, 2]
>>>

如果是在判斷式中，同樣的，and、or傳回的運算元再進行True、False的結果判斷，即數字不是0就是True，而所有物件不是「空」就是True。例如：

>>> if [] and 'Justin':
...     print('True')
... else:
...     print('False')
...
False
>>> if [1, 2] and 'Justin':
...     print('True')
... else:
...     print('False')
...
True
>>>

變數

2011-09-05T22:45:00.000-07:00

依型態資訊是記錄在宣告在變數之上，或者是執行時期的物件之上，程式語言可以區分為靜態（Static）語言（例如C/C++、Java）與動態（Dynamic）語言（例如Python、JavaScript）。

Python是動態語言，也就是變數本身並沒有型態資訊，型態的資訊是在執行時期的物件之上，在Python中要建立變數，無需宣告型態，只要命名變數並指定值給它，就建立了一個變數，在建立變數之前，嘗試存取某個變數會發生變數未定義的錯誤。例如：

>>> x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
>>> x = 10
>>> x
10
>>> x = 'Justin'
>>> x
'Justin'
>>>

在上例中，一開始建立了一個x變數，參考至整數10，由於變數本身沒有型態，之後你可以將字串'Justin'指定給x。在Python中，變數始終是個參考至真實物件的名稱，指定運算只是改變變數的參考對象。例如：

>>> x = 1.0
>>> y = x
>>> id(x)
19437008
>>> id(y)
19437008
>>> y = 2.0
>>> id(x)
19437008
>>> id(y)
19436976
>>>

在上例中，x一開始參考至1.0整數物件，而後將x參考的物件指定給y來參考，你可以使用id()函式來取得所參考物件的記憶體位址代表數字，可以看到x與y都參考同一物件。之後y參考至2.0，所以x與y就參考至不同的物件。

下面這個例子亦顯示了，變數在Python中只是一個參考（而所有的資料都是物件）：

>>> x = 1
>>> id(x)
505389048
>>> x = x + 1
>>> id(x)
505389064
>>>

一開始x參考至1整數物件，之後+運算後，建立了新的2整數物件，而後指定給x，所以x參考至新的物件。由於變數在Python中只是個參考至物件的名稱，所以對於可變動物件，才會有以下的操作結果：

>>> x = [1, 2]
>>> x
[1, 2]
>>> x[0] = 10
>>> x
[10, 2]
>>>

在Python中，==用來比較兩個物件的實質內容是否相同。例如：

>>> list1 = [1, 2, 3]
>>> list2 = [1, 2, 3]
>>> list1 == list2
True
>>>

但實際上list1與list2是參考至不同的物件。如果你想要比較兩個變數是否參考至同一物件，可以使用is運算：

>>> id(list1)
26224600
>>> id(list2)
26225200
>>> list1 is list2
False
>>>

變數本身沒有型態，若你透過變數操作物件的某個方法，只要確認該物件上確實有該方法即可。例如：

>>> x = [1, 2, 3]
>>> x.index(2)
1
>>> x = (10, 20, 30)
>>> x.index(20)
1
>>>

這是動態語言所流行的鴨子定型（Duck typing）：「如果它走路像個鴨子，游泳像個鴨子，叫聲像個鴨子，那它就是鴨子。」

如果你不再需要一個變數，則可以使用del將之刪除。例如：

>>> x = 10
>>> x
10
>>> del x
>>> x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
>>>

Tuple

2011-09-05T22:43:00.000-07:00

在Python中，Tuple就像是串列（List），不過串列是可變動（Mutable）物件，而Tuple是不可變動（Immutable）物件。你可以使用()來建立Tuple物件，也可以直接逗號區隔元素來建立Tuple物件。例如：

>>> (1, 'Justin', 93)
(1, 'Justin', 93)
>>> 1, 'Justin', 93
(1, 'Justin', 93)
>>> data = (1, 'Justin', 93)
>>> data[0]
1
>>> data[0:2]
(1, 'Justin')
>>> data[0:]
(1, 'Justin', 93)
>>> for elem in data:
... print(elem)
...
1
Justin
93
>>> (1, 'Justin', 93) + (2, 'momor', 99)
(1, 'Justin', 93, 2, 'momor', 99)
>>> (1, 'Justin', 93) * 2
(1, 'Justin', 93, 1, 'Justin', 93)
>>>

串列中的索引特性、切片運算、for迴圈迭代等操作，只要不變動Tuple的內容，都可以直接在Tuple在上運作。

如果你要建立單一元素的Tuple，記得不要僅使用括號，而必須在單一元素後加上一個逗號，以免被認定為數值等其它型態。例如：

>>> (1)
1
>>> (1,)
(1,)
>>> tuple([1])
(1,)
>>> tuple([1, 2])
(1, 2)
>>>

你也可以使用tuple來建立Tuple，tuple接受可迭代（iterable）物件（例如串列）作為建構Tuple之用。

由於Tuple的內容是不能變動的，所以你不能對它作變更操作，例如排序，若你想要排序Tuple，則必須先取得當中元素、排序後重新建構Tuple。例如：

>>> t1 = (3, 6, 1, 2, 7)
>>> l1 = list(t1)
>>> l1.sort()
>>> t1 = tuple(l1)
>>> t1
(1, 2, 3, 6, 7)
>>>

Tuple的內容不可變動，指的是不能變動每個索引所參考的物件，而不是指物件本身不能變動。例如：

>>> t = ([1, 2], [3, 4])
>>> t
([1, 2], [3, 4])
>>> t[0] = [10, 20]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> t[0][0] = 10
>>> t[0][1] = 20
>>> t
([10, 20], [3, 4])
>>>

上例中，打算指定Tuple索引0為新的串列物件是不可行的，但t[0][0]指的是改變索引0處的串列索引0的元素，同樣的t[0][1]指的是改變索引0處的串列索引1的元素，也就是相當於：

>>> t = ([1, 2], [3, 4])
>>> l = t[0]
>>> l[0] = 10
>>> l[1] = 20
>>> t
([10, 20], [3, 4])
>>>

Tuple的內容，可以同時指定給多個變數。例如：

>>> x, y = 1, 2
>>> x
1
>>> y
2
>>> t = (10, 20)
>>> x, y = t
>>> x
10
>>> y
20
>>> x, y = y, x
>>> x
20
>>> y
10
>>>

注意x, y = y, x該行，實際上就等於在作交換（Swap）的動作，由於Tuple指定的特性，使得交換的動作在Python中並不需要暫存變數。

事實上，串列、集合，都可以用類似的方式來指定：

>>> [x, y] = [1, 2]
>>> x
1
>>> y
2
>>> x, y = [1, 2]
>>> x
1
>>> y
2
>>> (x, y) = [1, 2]
>>> x
1
>>> y
2
>>> x, y = {1, 2}
>>> x
1
>>> y
2
>>> x, y, z = 'Joe'
>>> x
'J'
>>> y
'o'
>>> z
'e'
>>>

在Python 3中，還有個擴充的指定方式：

>>> s = [1, 2, 3, 4, 5]
>>> a, *b = s
>>> a
1
>>> b
[2, 3, 4, 5]
>>> *a, b = s
>>> a
[1, 2, 3, 4]
>>> b
5
>>> *a, b, c = s
>>> a
[1, 2, 3]
>>> b
4
>>> c
5
>>> a, *b, c = s
>>> a
1
>>> b
[2, 3, 4]
>>> c
5
>>>

你可以在左邊的變數指定一個*，未指定的變數會被指定一個值，而剩餘的元素會被指定給*所標註的變數。

字典

2011-09-05T22:41:00.001-07:00

在Python中，字典物件是儲存鍵（Key）/值（Value）對應的物件，為dict的實例。直接示範如何以實字建立字典物件：

>>> passwords = {'Justin' : 123456, 'caterpillar' : 933933}
>>> passwords['Justin']
123456
>>> passwords['caterpillar']
933933
>>>
>>> passwords['Hamimi'] = 970221
>>> passwords
{'caterpillar': 933933, 'Hamimi': 970221, 'Justin': 123456}
>>> passwords['Hamimi']
970221
>>> del passwords['caterpillar']
>>> passwords
{'Hamimi': 970221, 'Justin': 123456}
>>>

建立字典時，每個鍵物件（在上例中是字串，也可以是任何不可變動的物件，像是數字或Tuple等）會用來取得對應的值物件，指定鍵物件取得值物件時是使用[]運算子。建立字典物件後，你可以隨時再加入鍵/值。如果要刪除某個鍵/值，則可以使用del。

直接使用[]指定鍵要取得值時，若字典中並沒有該鍵的存在，則會丟出KeyError。可以使用in來測試鍵是否存在於字典中。例如：

>>> passwords['caterpillar']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'caterpillar'
>>> if 'caterpillar' in passwords:
... print(passwords['Justin'])
... else:
... print(None)
...
None
>>> print(passwords.get('caterpillar'))
None
>>> print(passwords.get('caterpillar', 'NO_PASSWORD'))
NO_PASSWORD
>>>

上例中，也示範了字典的get()方法，使用get()方法指定的鍵若不存在，預設會傳回None，get()可以指定預設值，在指定的鍵不存在時就傳回預設值。

可以使用update()將指定的字典物件加入，使用pop()方法可以指定鍵將對應的鍵/值取出並從字典中移除。例如：

>>> passwords
{'Hamimi': 970221, 'Justin': 123456}
>>> passwords.update({'Momor' : 670723})
>>> passwords
{'Hamimi': 970221, 'Justin': 123456, 'Momor': 670723}
>>> passwords.pop('Justin')
123456
>>> passwords
{'Hamimi': 970221, 'Momor': 670723}

如果要取得字典中的鍵/值，則可以使用items()方法，這會以dict_items物件，當中是以Tuple儲存每一對鍵/值。如果要取得鍵，則可以使用keys()方法，這會傳回dict_keys物件，當中包括所有的鍵。如果要取得值，則可以使用values()方法，這會傳回dict_values物件，當中包括所有的值。例如：

>>> for person in passwords:
...     print(passwords[person])
...
970221
670723
>>> passwords.items()
dict_items([('Hamimi', 970221), ('Momor', 670723)])
>>> for item in passwords.items():
...     print(item)
...
('Hamimi', 970221)
('Momor', 670723)
>>> passwords.keys()
dict_keys(['Hamimi', 'Momor'])
>>> for key in passwords.keys():
...     print(key)
...
Hamimi
Momor
>>> list(passwords.keys())
['Hamimi', 'Momor']
>>> passwords.values()
dict_values([970221, 670723])
>>> for value in passwords.values():
...     print(value)
...
970221
670723
>>> list(passwords.values())
[970221, 670723]
>>>

實際上，items()、keys()傳回的物件具有集合（Set）的特性，可以與集合物件進行運算，values()則否，因為值不一定是唯一的（不同的鍵可能有相同的值），所以無法視為集合。例如：

>>> passwords.items() | {'x', 'y'}
{'y', ('Momor', 670723), 'x', ('Hamimi', 970221)}
>>> passwords.keys() | {'x', 'y'}
{'y', 'x', 'Hamimi', 'Momor'}
>>> passwords.values() | {'x', 'y'}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for |: 'dict_values' and 'set'
>>>

除了實字表示方式之外，你也可以使用dict來建立字典。例如：

>>> passwords = dict(justin = 123456, momor = 670723, hamimi = 970221)
>>> passwords
{'hamimi': 970221, 'justin': 123456, 'momor': 670723}
>>> passwords = dict([('justin', 123456), ('momor', 670723), ('hamimi', 970221)])
>>> passwords
{'hamimi': 970221, 'justin': 123456, 'momor': 670723}
>>> dict.fromkeys(['Justin', 'momor'], 'NEED_TO_CHANGE')
{'Justin': 'NEED_TO_CHANGE', 'momor': 'NEED_TO_CHANGE'}
>>>