0.寫在前面的話

學習一門語言最重要的功課是練習與複習，在《笨方法學Python》中第三十七節雖然沒有教你任何內容，但是它提醒我們：“學了這麼多，你還能記得多少？該複習了！”

下面我們就對這一節的第一部分“關鍵字”來做個複習：

Python中的關鍵字包括如下：

and       del        from      not      while    as        elif       global    or       with       assert    else       if        pass     yield   break     except     import    print    class     exec       in        raise    continue  finally    is        return   def       for        lambda    try

你想看看有哪些關鍵字？OK，開啟一個終端，就像這樣～

[email protected]:~$ python
Python 2.7.3 (default, Jan  2 2013, 16:53:07) 
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import keyword
>>> keyword.kwlist
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
>>> 

============================== 華麗的 正文分隔符 ========================================

看到這些關鍵字你還能記得多少？你不妨自己一個一個對照想想它的用法，下面是我總結的，我根據前面的學習筆記將上述關鍵字分為以下幾類：

1.判斷、迴圈

對於Python的迴圈及判斷主要包括這些關鍵字：

if    elif    else        for    while    break    continue    and    or       is       not          in        

這幾個關鍵字在前面介紹 if 語法、while語法、for語法以及and...or語法

中已有介紹，下面再一筆帶過：

1.1 if 語法

if語法與C語言、shell指令碼之下的非常類似，最大的區別就是冒號以及嚴格的縮排，當然這兩點也是Python區別於其他語言的地方：

if  condition1:                                

        do something

elif  condition2:

        do another thing

else:

        also do something 

1.2 while  語法

Python的while語法區別於C、shell下的while除了冒號及縮排之外，還有一點就是while可以攜帶一個可選的else語句：

while condition：

        do something

else：

        do something

注：else語句是可選的，但是使用while語句時一定要注意判斷語句可以跳出！

1.3 for 語法

與while類似，Python的for迴圈也包括一個可選的else語句（跳出for迴圈時執行，但是如果是從break語句跳出則不執行else語句塊中的程式碼！），而且for 加上 關鍵字in就組成了最常見的列表解析用法（以後會寫個專門的部落格）。

下面是for的一般用法：

for  i in range（1，10，2）：

        do something

        if  condition:

              break

else:

       do something 

for的列表解析用法：

for items in list: 

      print items

1.4 and...or 語法

Python的and/or操作與其他語言不同的是它的返回值是參與判斷的兩個值之一，所以我們可以通過這個特性來實現Python下的 a ? b : c !

有C語言基礎的知道 “ a ? b : c ! ” 語法是判斷 a，如果正確則執行b，否則執行 c！

而Python下我們可以這麼用：“ a and b or c ”（此方法中必須保證b必須是True值），python自左向右執行此句，先判斷a and b ：如果a是True值，a and b語句仍需要執行b，而此時b是True值！所以a and b的值是b，而此時a and b or c就變成了b or c，因b是True值，所以b or c的結果也是b；如果a是False值，a and b語句的結果就是a，此時 a and b or c就轉化為a or c,因為此時a是 False值，所以不管c是True 還是Flase，a or c的結果就是c！！！捋通邏輯的話，a and b or c 是不是就是Python下的a ? b : c ! 用法？

1.5 is ,not

is 和 is not 是Python下判斷同一性的關鍵字，通常用來判斷 是 True 、False或者None（Python下的NULL）！

比如  if alue is True ： ...

2.函式、模組、類

對於Python的函式及模組主要包括這些關鍵字：

from     import       as            def            pass      lambda      return      class   

那麼你還能記得它們麼？下面簡單介紹一下：

2.1 模組

Python的程式設計通常大量使用標準庫中的模組，使用方法就是使用import 、from以及as 關鍵字。

比如：  import sys  # 匯入sys模組

             from sys import argv   # 從sys模組中匯入argv ，這個在前面介紹指令碼傳引數時使用到

             import cPickle as p     # 將cPickle模組匯入並在此將它簡單命名為p，此後直接可以使用p替代cPickle模組原名，這個在介紹檔案輸入輸出時的儲存器中使用到

2.2 函式

Python中定義函式時使用到def關鍵字，如果你當前不想寫入真實的函式操作，可以使用pass關鍵字指代不做任何操作：

def  JustAFunction：

        pass

當然，在需要給函式返回值時就用到了return關鍵字，這裡簡單提一下Python下的函式返回值可以是多個（接收返回值時用相應數量的變數接收！）！

此外Python下有個神奇的Lambda函式，它允許你定義單行的最小函式，這是從Lisp中借用來的，可以用在任何需要函式的地方。比如：

g = lambda x : x*2   # 定義一個Lambda函式用來計算引數的2倍並返回！

print g(2)                 # 使用時使用lambda函式返回的變數作為這個函式的函式名，括號中帶入相應引數即可！

3.異常

對於Python的異常主要包括這些關鍵字：

 try   except     finally     raise        

異常這一節還是比較簡單的，將可能出現的異常放在 try： 後面的語句塊中，使用except關鍵字捕獲一定的異常並在接下來的語句塊中做相應操作，而finally中接的是無論出現什麼異常總在執行最後做finally： 後面的語句塊（比如關閉檔案等必要的操作！）

raise關鍵字是在一定的情況下引發異常，通常結合自定義的異常型別使用。

4.其他

上面的三類過後，還剩下這些關鍵字：

print      del            global        with       assert           yield       exec        

首先print 在前面的筆記或者任何地方你都能見到，所以還是比較熟悉的，此處就不多介紹了！

del 關鍵字在前面的筆記中已有所涉及，比如刪除列表中的某項，我們使用 “ del mylist[0] ”

可能這些剩下來的關鍵字你比較陌生，所以下面來介紹一下：

4.1.global 關鍵字

當你在函式定義內宣告變數的時候，它們與函式外具有相同名稱的其他變數沒有任何關係，即變數名稱對於函式來說是 區域性 的。這稱為變數的 作用域 。所有變數的作用域是它們被定義的塊，從它們的名稱被定義的那點開始。

eg.

#!/usr/bin/python
# Filename: func_local.py

def func(x):
    print 'x is', x
    x = 2
    print 'Changed local x to', x

x = 50
func(x)
print 'x is still', x

執行的結果是這樣的：

$ python func_local.py
x is 50						# 執行func函式時，先列印x的值，此時帶的值是作為引數帶入的外部定義的50，所以能正常列印 x=50 
Changed local x to 2   		# 在func函式中將x賦2，並列印
x is still 50				# 執行完func函式，列印x的值，此時x的值仍然是之前賦給的50，而不是func函式中修改過的2，因為在函式中修改的只是函式內的區域性變數

那麼為什麼我們要在這提到區域性變數呢？bingo，聰明的你一下就猜到這個global就是用來定義全域性變數的。也就是說如果你想要為一個在函式外定義的變數賦值，那麼你就得告訴Python這個變數名不是區域性的，而是 全域性 的。我們使用global語句完成這一功能。沒有global語句，是不可能為定義在函式外的變數賦值的。
eg.

#!/usr/bin/python
# Filename: func_global.py

def func():
    global x
    print 'x is', x
    x = 2
    print 'Changed local x to', x

x = 50
func()
print 'Value of x is', x

執行的結果是這樣的：

$ python func_global.py
x is 50
Changed global x to 2
Value of x is 2				# global語句被用來宣告x是全域性的——因此，當我們在函式內把值賦給x的時候，這個變化也反映在我們在主塊中使用x的值的時候。

你可以使用同一個global語句指定多個全域性變數。例如global x, y, z。

4.2.with 關鍵字      

有一些任務，可能事先需要設定，事後做清理工作。對於這種場景，Python的with語句提供了一種非常方便的處理方式。一個很好的例子是檔案處理，你需要獲取一個檔案控制代碼，從檔案中讀取資料，然後關閉檔案控制代碼。
如果不用with語句，開啟一個檔案並讀檔案的程式碼如下：

	file = open("/tmp/foo.txt")
	data = file.read()
	file.close()

當然這樣直接開啟有兩個問題：一是可能忘記關閉檔案控制代碼；二是檔案讀取資料發生異常，沒有進行任何處理。下面是新增上異常處理的版本：

	file = open("/tmp/foo.txt")
	try:
	    data = file.read()
	finally:
	    file.close()

雖然這段程式碼執行良好，但是太冗餘了。這時候就是with一展身手的時候了。除了有更優雅的語法，with還可以很好的處理上下文環境產生的異常。下面是with版本的程式碼：

	with open("/tmp/foo.txt") as file:
	    data = file.read()

這看起來充滿魔法，但不僅僅是魔法，Python對with的處理還很聰明。基本思想是with所求值的物件必須有一個__enter__()方法，一個__exit__()方法。

with語句的執行邏輯如下：緊跟with後面的語句被求值後，返回物件的__enter__()方法被呼叫，這個方法的返回值將被賦值給as後面的變數。當with後面的程式碼塊全部被執行完之後，將呼叫前面返回物件的__exit__()方法。


下面例子可以具體說明with如何工作：

#!/usr/bin/python
# with_example01.py
 
class Sample:
    def __enter__(self):
        print "In __enter__()"
        return "Foo"
 
    def __exit__(self, type, value, trace):
        print "In __exit__()"
 
def get_sample():
    return Sample()
 
with get_sample() as sample:
    print "sample:", sample

執行程式碼，輸出如下

$python with_example01.py   
In __enter__()           # __enter__()方法被執行
sample: Foo              # __enter__()方法返回的值 - 這個例子中是"Foo"，賦值給變數'sample',執行程式碼塊，列印變數"sample"的值為 "Foo"
In __exit__()            # __exit__()方法被呼叫

4.3.assert 關鍵字          

assert語句是一種插入除錯斷點到程式的一種便捷的方式。assert語句用來宣告某個條件是真的,當assert語句失敗的時候，會引發一AssertionError，所以結合try...except我們就可以處理這樣的異常。
eg. 
>>> mylist         # 此時mylist是有三個元素的列表
['a', 'b', 'c']
>>> assert len(mylist) is not None  # 用assert判斷列表不為空，正確無返回
>>> assert len(mylist) is  None     # 用assert判斷列表為空
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module>
AssertionError                      # 引發AssertionError異常

4.4.yield 關鍵字       

我們先看一個示例：

 def fab(max): 
    n, a, b = 0, 0, 1 
    while n < max: 
        yield b 
        # print b 
        a, b = b, a + b 
        n = n + 1 
'''

使用這個函式：

 >>> for n in fab(5): 
 ...     print n 
 ... 
 1 
 1 
 2 
 3 
 5

簡單地講，yield 的作用就是把一個函式變成一個 generator（生成器），帶有 yield 的函式不再是一個普通函式，Python 直譯器會將其視為一個 generator，呼叫 fab(5) 不會執行 fab 函式，而是返回一個 iterable（可迭代的）物件！在 for 迴圈執行時，每次迴圈都會執行 fab 函式內部的程式碼，執行到 yield b 時，fab 函式就返回一個迭代值，下次迭代時，程式碼從 yield b 的下一條語句繼續執行，而函式的本地變數看起來和上次中斷執行前是完全一樣的，於是函式繼續執行，直到再次遇到 yield。
也可以手動呼叫 fab(5) 的 next() 方法（因為 fab(5) 是一個 generator 物件，該物件具有 next() 方法），這樣我們就可以更清楚地看到 fab 的執行流程：
 

>>> f = fab(5) 
 >>> f.next() 
 1 
 >>> f.next() 
 1 
 >>> f.next() 
 2 
 >>> f.next() 
 3 
 >>> f.next() 
 5 
 >>> f.next() 
 Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
 StopIteration

當函式執行結束時，generator 自動丟擲 StopIteration 異常，表示迭代完成。在 for 迴圈裡，無需處理 StopIteration 異常，迴圈會正常結束。

我們可以得出以下結論：
一個帶有 yield 的函式就是一個 generator，它和普通函式不同，生成一個 generator 看起來像函式呼叫，但不會執行任何函式程式碼，直到對其呼叫 next()（在 for 迴圈中會自動呼叫 next()）才開始執行。雖然執行流程仍按函式的流程執行，但每執行到一個 yield 語句就會中斷，並返回一個迭代值，下次執行時從 yield 的下一個語句繼續執行。看起來就好像一個函式在正常執行的過程中被 yield 中斷了數次，每次中斷都會通過 yield 返回當前的迭代值。

yield 的好處是顯而易見的，把一個函式改寫為一個 generator 就獲得了迭代能力，比起用類的例項儲存狀態來計算下一個 next() 的值，不僅程式碼簡潔，而且執行流程異常清晰。 

注：如果看完此段你還未明白yield，沒問題，因為yield是初學者的一個難點，那麼你下一步需要做的就是……看一看下面參考資料中給的關於yield的博文！

4.5.exec 關鍵字     

官方文件對於exec的解釋: "This statement supports dynamic execution of Python code."也就是說使用exec可以動態執行Python程式碼（也可以是檔案）。

>>> longer = "print \"Hello World ,my name is longer\""     # 比如說我們定義了一個字串
>>> longer
'print "Hello World ,my name is longer"'
>>> exec(longer)                                            # 使用exec 動態執行字串中的程式碼
Hello World ,my name is longer
>>> exec(sayhi)                                             # 使用exec直接開啟檔名（指定sayhi，sayhi.py以及"sayhi.py"都會報一定的錯，但是我覺得直接帶sayhi報錯非常典型）
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: exec: arg 1 must be a string, file, or code object   # python IDE報錯，提示exec的第一個參
數必須是一個字串、檔案或者一個程式碼物件
>>> f = file("sayhi.py")                                    # 使用file開啟sayhi.py並建立f例項
>>> exec(f)                     # 使用exec直接執行檔案描述符f，執行正常！！
Hi, this is [''] script

上述給的例子比較簡單，注意例子中exec語句的用法和eval_r(), execfile()是不一樣的. exec是一個關鍵字（要不然我怎麼會在這裡介紹呢～～～）, 而eval_r()和execfile()則是內建函式。更多關於exec的使用請詳看引用資料或者Google之。

================================================

參考資料：

global 參考：《Python簡明教程》第七章 函式 - 區域性函式