一、簡介

      Python的條件和循環(huán)語句，決定了程序的控制流程，體現(xiàn)結(jié)構(gòu)的多樣性。須重要理解，if、while、for以及與它們相搭配的 else、 elif、break、continue和pass語句。
二、詳解
1、if語句

        Python中的if子句由三部分組成：關(guān)鍵字本身、用于判斷結(jié)果真假的條件表達(dá)式以及當(dāng)表達(dá)式為真或者非零時執(zhí)行的代碼塊。if 語句的語法如下：

if expression:
 expr_true_suite

        if 語句的expr_true_suite代碼塊只有在條件表達(dá)式的結(jié)果的布爾值為真時才執(zhí)行，否則將繼續(xù)執(zhí)行緊跟在該代碼塊后面的語句。
（1）多重條件表達(dá)式
        單個if語句可以通過使用布爾操作符and、or和not，實現(xiàn)多重判斷條件或是否定判斷條件。
（2）單一語句的代碼塊
        如果一個復(fù)合語句（例如if子句、while或for循環(huán)）的代碼塊僅僅包含一行代碼，那么它可以和前面的語句寫在同一行上。如if make_hard_copy: send_data_to_printer()，這樣的單行語句是合法的， 盡管它可能方便，但這樣會使得代碼更難閱讀， 所以推薦將這行代碼移到下一行并合理地縮進(jìn)。另外一個原因就是如果你需要添加新的代碼, 你還是得把它移到下一行。
2、else語句
       Python提供了與if語句搭配使用的else語句，如果if語句的條件表達(dá)式的結(jié)果布爾值為假，那么程序?qū)?zhí)行 else 語句后的代碼。其語法如下：

if expression:
 expr_true_suite
else:
 expr_false_suite

        在C語言中，不會在條件語句范圍外發(fā)現(xiàn)else語句， 但Python不同，可以在while和for循環(huán)中使用else語句，在循環(huán)中使用時，else子句只在循環(huán)完成后執(zhí)行，也就是說break語句也會跳過else塊。
         例：顯示出10到20中的數(shù)字的最大約數(shù)

在CODE上查看代碼片派生到我的代碼片

 #!/usr/bin/env python 
  
 def showMaxFactor(num): 
  count = num / 2 
  while count > 1: 
   if (num % count == 0): 
   print 'largest factor of %d is %d' % (num, count) 
   break 
   count = count - 1 
  else: 
  print eachNum, 'is prime' 
  
 for eachNum in range(10, 21): 
  showMaxFactor(eachNum) 

在CODE上查看代碼片派生到我的代碼片

 largest factor of 10 is 5 
 11 is prime 
 largest factor of 12 is 6 
 13 is prime 
 largest factor of 14 is 7 
 largest factor of 15 is 5 
 largest factor of 16 is 8 
 17 is prime 
 largest factor of 18 is 9 
 19 is prime 
 largest factor of 20 is 10 

3、elif (即else-if )語句
        elif是Python的else-if 語句，它檢查多個表達(dá)式是否為真，并在為真時執(zhí)行特定代碼塊中的代碼。和else一樣，elif 聲明是可選的，然而不同的是if 語句后最多只能有一個else語句，但可以有任意數(shù)量的 elif 語句。

if expression1:
 expr1_true_suite
elif expression2:
 expr2_true_suite
 ...
elif expressionN:
 exprN_true_suite
else:
 none_of_the_above_suite

        在將來的某天，Python可能會支持 switch /case語句，但是完全可以用其他的Python結(jié)構(gòu)來模擬它。在Python中，大量的if-elif 語句并不難閱讀。
在CODE上查看代碼片派生到我的代碼片

 if user.cmd == 'create': 
  action = "create item" 
 elif user.cmd == 'delete': 
  action = 'delete item' 
 elif user.cmd == 'update': 
  action = 'update item' 
 else: 
  action = 'invalid choice... try again!' 

       上面的語句還可以用序列和成員關(guān)系操作符來簡化它：

在CODE上查看代碼片派生到我的代碼片

 if user.cmd in ('create', 'delete', 'update'): 
  action = '%s item' % user.cmd 
 else: 
  action = 'invalid choice... try again!' 

       還可以用Python字典給出更加優(yōu)雅的解決方案，使用映射對象（比如字典）的一個最大好處就是它的搜索操作比類似語句或是 for 循環(huán)這樣的序列查詢要快很多。

在CODE上查看代碼片派生到我的代碼片

 msgs = {'create': 'create item', 
   'delete': 'delete item', 
   'update': 'update item' 
   } 
 default = 'invalid choice... try again!' 
 action = msgs.get(user.cmd, default) 

4、條件表達(dá)式(即"三元操作符")
       三元運算符語法為：X if C else Y，只需要一行完成條件判斷和賦值操作：

在CODE上查看代碼片派生到我的代碼片

 >>> x, y = 4, 3 
 >>> smaller = x if x < y else y 
 >>> smaller 
 3 

5、while語句
      while是一個條件循環(huán)語句，與if聲明相比，如果 if 后的條件為真，就會執(zhí)行一次相應(yīng)的代碼塊。而while中的代碼塊會一直循環(huán)執(zhí)行，直到循環(huán)條件不再為真。
（1）一般語法
       while循環(huán)的語法如下：

while expression:
 suite_to_repeat

        while循環(huán)的suite_to_repeat子句會一直循環(huán)執(zhí)行，直到expression值為布爾假。
（2）計數(shù)循環(huán)

count = 0
while (count < 9):
 print 'the index is:', count
 count += 1

       代碼塊里包含了print和自增語句，它們被重復(fù)執(zhí)行，直到count不再小于9。索引count在每次迭代時被打印出來然后自增 1。
（3）無限循環(huán)

while True:
 handle, indata = wait_for_client_connect()
 outdata = process_request(indata)
 ack_result_to_client(handle, outdata)

       “無限”循環(huán)永遠(yuǎn)不會結(jié)束，但它不一定是壞事，許多通訊服務(wù)器的客戶端/服務(wù)器系統(tǒng)就是通過它來工作的。
6、for語句
        Python提供了的另一個循環(huán)機(jī)制就是for語句，它是Python中最強(qiáng)大的循環(huán)結(jié)構(gòu)。它可以遍歷序列成員，可以用在列表解析和生成器表達(dá)式中，它會自動地調(diào)用迭代器的next()方法，捕獲StopIteration異常并結(jié)束循環(huán)（所有這一切都是在內(nèi)部發(fā)生的）。 Python的for更像是shell或是腳本語言中的foreach循環(huán)。

（1）一般語法
       for循環(huán)會訪問一個可迭代對象（例如序列或是迭代器）中的所有元素,，并在所有條目都處理過后結(jié)束循環(huán)。它的語法如下：
for iter_var in iterable:
    suite_to_repeat
        每次循環(huán)， iter_var迭代變量被設(shè)置為可迭代對象（序列、迭代器或者是其他支持迭代的對象）的當(dāng)前元素，提供給suite_to_repeat 語句塊使用。
（2）用于序列類型
       for循環(huán)可以迭代不同的序列對象，像字符串、 列表、以及元組。
       迭代序列有三種基本方法：
通過序列項迭代
在CODE上查看代碼片派生到我的代碼片

 >>> nameList = ['Walter', "Nicole", 'Steven', 'Henry'] 
 >>> for eachName in nameList: 
 ...  print eachName, "Lim" 
 ... 
 Walter Lim 
 Nicole Lim 
 Steven Lim 
 Henry Lim 

        迭代一個列表.。每次迭代，eacgName變量都被設(shè)置為列表中特定某個元素。
通過序列索引迭代
在CODE上查看代碼片派生到我的代碼片

 >>> nameList = ['Cathy', "Terry", 'Joe', 'Heather','Lucy'] 
 >>> for nameIndex in range(len(nameList)): 
 ...  print "Liu,", nameList[nameIndex] 
 ... 
 Liu, Cathy 
 Liu, Terry 
 Liu, Joe 
 Liu, Heather 
 Liu, Lucy 

      沒有迭代元素, 而是通過列表的索引迭代。但通過直接迭代序列要比索引迭代快。
使用項和索引迭代
在CODE上查看代碼片派生到我的代碼片

 >>> nameList = ['Donn', 'Shirley', 'Ben', 'Janice','David', 'Yen', 'Wendy'] 
 >>> for i, eachLee in enumerate(nameList): 
 ...  print "%d %s Lee" % (i+1, eachLee) 
 ... 
 1 Donn Lee 
 2 Shirley Lee 
 3 Ben Lee 
 4 Janice Lee 
 5 David Lee 
 6 Yen Lee 
 7 Wendy Lee 

（3）用于迭代器類型
        用for循環(huán)訪問迭代器和訪問序列的方法差不多，迭代器并不代表循環(huán)條目的集合，迭代器對象有一個next()方法， 調(diào)用后返回下一個條目。 所有條目迭代完后， 迭代器引發(fā)一個StopIteration異常告訴程序循環(huán)結(jié)束，for語句在內(nèi)部調(diào)用next()并捕獲異常。
        使用迭代器做 for 循環(huán)的代碼與使用序列條目幾乎完全相同。事實上在大多情況下，無法分辨出迭代的是一個序列還是迭代器，因此遍歷一個迭代器時，實際上可能指的是要遍歷一個序列、迭代器或是一個支持迭代的對象（它有 next()方法）。
（4）range()內(nèi)建函數(shù)
        內(nèi)建函數(shù)range()可以把類似foreach的for循環(huán)變成你更加熟悉的語句。
        Python提供了兩種不同的方法來調(diào)用range() ，完整語法要求提供兩個或三個整數(shù)參數(shù)：range(start, end, step =1)，range()會返回一個包含所有k的列表，其中start <= k < end，從start到end ，k每次遞增 ste，step不可以為零，否則將發(fā)生錯誤。 
在CODE上查看代碼片派生到我的代碼片

 >>> range(3, 7) 
 [3, 4, 5, 6] 
 >>> for eachVal in range(2, 19, 3): 
 ...  print "value is:", eachVal 
 ... 
 value is: 2 
 value is: 5 
 value is: 8 
 value is: 11 
 value is: 14 
 value is: 17 

         range() 還有兩種簡略的語法格式：range(end)和range(start, end)。 start 默認(rèn)為0， step默認(rèn)為1。
（5）xrange()內(nèi)建函數(shù)
        xrange()類似range()，不過當(dāng)有一個很大的范圍列表時，xrange() 可能更為適合， 因為它不會在內(nèi)存里創(chuàng)建列表的完整拷貝。 它只被用在 for 循環(huán)中，在 for 循環(huán)外使用它沒有意義。它的性能遠(yuǎn)高出 range()，因為它不生成整個列表。在Python的將來版本中，range()可能會像xrange()一樣，返回一個可迭代對象（不是列表也不是一個迭代器）。

（6）與序列相關(guān)的內(nèi)建函數(shù)
        序列相關(guān)函數(shù)：sorted()、 reversed()、enumerate()和zip()，稱為“序列相關(guān)”是因為其中兩個函數(shù)（sorted() 和 zip()）返回一個序列（列表），而另外兩個函數(shù)（reversed() 和 enumerate()）返回迭代器（類似序列）。
7、break和continue語句
       Python中的break語句可以結(jié)束當(dāng)前循環(huán)然后跳轉(zhuǎn)到下條語句，類似C中的break。常用在當(dāng)某個外部條件被觸發(fā)（一般通過 if 語句檢查），需要立即從循環(huán)中退出時.。break 語句可以用在 while 和 for 循環(huán)中。
       Python里的continue語句和其他高級語言中的傳統(tǒng)continue并沒有什么不同，它可以被用在while和for循環(huán)里。 while循環(huán)是條件
性的，而 for 循環(huán)是迭代的，所以continue在開始下一次循環(huán)前要滿足一些先決條件，否則循環(huán)會正常結(jié)束。
       程序中當(dāng)遇到 continue 語句時, 程序會終止當(dāng)前循環(huán)，并忽略剩余的語句，然后回到循環(huán)的頂端。在開始下一次迭代前，如果是條件循環(huán)，我們將驗證條件表達(dá)式。如果是迭代循環(huán)，將驗證是否還有元素可以迭代。只有在驗證成功的情況下，才會開始下一次迭代。
在CODE上查看代碼片派生到我的代碼片

 #!/usr/bin/env python 
  
 valid = False 
 count = 3 
 passwdList=('abc',) 
 while count > 0 and valid == False: 
  input = raw_input("enter password:").strip() 
  # check for valid passwd 
  for eachPasswd in passwdList: 
   if input == eachPasswd: 
    valid = True 
    break 
   if not valid: # (or valid == 0) 
    print "invalid input" 
    count -= 1 
    continue 
   else: 
     break 

        結(jié)合使用了while、for、if、break以及continue，來驗證用戶輸入。用戶有三次機(jī)會來輸入正確的密碼，阻止用戶猜測密碼。

8、pass語句
        Python中沒有對應(yīng)的空大括號或是分號( ; )來表示如C語言中的“不做任何事”，如果需要子語句塊的地方不寫任何語句， 解釋器會提示語法錯誤。因此，Python 提供了pass語句，它不做任何事情，即NOP（No OPeration），pass同樣也可作為開發(fā)中的小技巧，標(biāo)記以后將要完成的代碼。

def foo_func():
    pass

       這樣的代碼結(jié)構(gòu)在開發(fā)和調(diào)試時很有用，因為編寫代碼的時候可能要先把結(jié)構(gòu)定下來，但又不希望它干擾其他已經(jīng)完成的代碼， 在不需要它做任何事情地方放一個pass，將是一個很好的主意。另外它在異常處理中也被經(jīng)常用到，比如你跟蹤到了一個非致命的錯誤而不想采取任何措施。
9、迭代器和iter()函數(shù)

（1）什么是迭代器

        迭代器為類序列對象提供了一個類序列的接口，可以利用它們的索引從0開始一直"迭代" 到序列的最后一個條目，用"計數(shù)"的方法迭代序列是很簡單的。 Python的迭代無縫地支持序列對象，而且它還允許程序員迭代非序列類型， 包括用戶定義的對象。
        迭代器用起來很靈巧，可以迭代不是序列但表現(xiàn)出序列行為的對象，例如字典的 key 、一個文件的行等等。當(dāng)使用循環(huán)迭代一個對象條目時，不必去關(guān)注它是迭代器還是序列。
（2）為什么要迭代器
         迭代器的定義：提供了可擴(kuò)展的迭代器接口、對列表迭代帶來了性能上的增強(qiáng)、在字典迭代中性能提升、創(chuàng)建真正的迭代接口，而不是原來的隨機(jī)對象訪問、與所有已經(jīng)存在的用戶定義的類以及擴(kuò)展的模擬序列和映射的對象向后兼容、迭代非序列集合（例如映射和文件）時， 可以創(chuàng)建更簡潔可讀的代碼。
（3）如何迭代
       迭代器有一個next()方法的對象，而不是通過索引來計數(shù)。當(dāng)一個循環(huán)機(jī)制（例如 for 語句）需要下一個項時，調(diào)用迭代器的next()方法就可以獲得它。條目全部取出后，會引發(fā)一個StopIteration異常，這并不表示錯誤發(fā)生，只是告訴外部調(diào)用者迭代完成。
       不過，迭代器也有一些限制。 例如不能向后移動，不能回到開始，也不能復(fù)制一個迭代器。如果要再次(或者是同時)迭代同個對象，你只能去創(chuàng)建另一個迭代器對象。不過，還有其他的工具來幫助你使用迭代器。
        reversed()內(nèi)建函數(shù)將返回一個反序訪問的迭代器。enumerate()內(nèi)建函數(shù)同樣也返回迭代器。另外兩個新的內(nèi)建函數(shù)：any()和 all()，如果迭代器中某個/所有條目的值都為布爾真時，則它們返回值為真。
（4）使用迭代器
序列
在CODE上查看代碼片派生到我的代碼片

 >>> myTuple = (123, 'xyz', 45.67) 
 >>> i = iter(myTuple) 
 >>> i.next() 
 123 
 >>> i.next() 
 'xyz' 
 >>> i.next() 
 45.670000000000002 
 >>> i.next() 
 Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
 StopIteration 

       在for循環(huán)中for i in seq:do_something_to(i)，它會自動調(diào)用迭代器的next()方法，并且監(jiān)視StopIteration異常。
字典
       字典和文件是另外兩個可迭代的Python數(shù)據(jù)類型。字典的迭代器會遍歷它的鍵(keys)，語句for eachKey in myDict.keys()可以縮寫為for eachKey in myDict。
        Python還引進(jìn)了三個新的內(nèi)建字典方法來定義迭代： myDict.iterkeys() （通過 keys 迭代）， myDict.itervalues() （通過 values 迭代）以及myDicit.iteritems() （通過key/value 對來迭代 ）。 注意 ： in操作符也可以用于檢查字典的key是否存在，布爾表達(dá)式myDict.has_key(anyKey)可以被簡寫為anyKey in myDict。
文件
        文件對象生成的迭代器會自動調(diào)用readline()方法。這樣，循環(huán)就可以訪問文本文件的所有行?？梢允褂酶唵蔚膄or eachLine in myFile替 換for eachLine in myFile.readlines()。
（5）可變對象和迭代器
       在迭代可變對象的時候修改它們并不是個好主意，這在迭代器出現(xiàn)之前就是一個問題。一個序列的迭代器只是記錄當(dāng)前到達(dá)第幾個元素，所以若在迭代時改變了元素，更新會立即反映到你所迭代的條目上。在迭代字典的key時，絕對不能改變這個字典。 使用字典的keys()方法是可以的，因為keys() 返回一個獨立于字典的列表， 而迭代器是與實際對象綁定在一起的，它將不會繼續(xù)執(zhí)行下去。
（6）如何創(chuàng)建迭代器
       對一個對象調(diào)用iter()就可以得到它的迭代器，它的語法如下：iter(obj)或iter(func, sentinel )。如果傳遞一個參數(shù)給iter()，它會檢查你傳遞的是不是一個序列，如果是則會根據(jù)索引從0一直迭代到序列結(jié)束。另一個創(chuàng)建迭代器的方法是使用類，一個實現(xiàn)__iter__()和next()方法的類可以作為迭代器使用。如果是傳遞兩個參數(shù)給iter()， 它會重復(fù)地調(diào)用func，直到迭代器的下個值等于sentinel。

10、列表解析
       列表解析( List comprehensions或縮略為list comps ) 來自函數(shù)式編程語言Haskell。它是一個非常有用、簡單、而且靈活的工具， 可以用來動態(tài)地創(chuàng)建列表。
       Python支持的函數(shù)式編程特性，例如lambda 、map() 以及filter()等，通過列表解析它們可以被簡化為一個列表解析式子。map()對所有的列表成員應(yīng)用一個操作，filter()基于一個條件表達(dá)式過濾列表成員，lambda()允許快速地創(chuàng)建只有一行的函數(shù)對象。    
       列表解析的語法：[expr for iter_var in iterable]， 它迭代iterable對象的所有條目。其中的expr應(yīng)用于序列的每個成員，最后的結(jié)果值是該表達(dá)式產(chǎn)生的列表，迭代變量并不需要是表達(dá)式的一部分。
在CODE上查看代碼片派生到我的代碼片

 >>> [x ** 2 for x in range(6)] 
 [0, 1, 4, 9, 16, 25] 

        列表解析的表達(dá)式可以取代內(nèi)建的map()函數(shù)以及l(fā)ambda ，而且效率更高。結(jié)合 if語句，列表解析還提供了一個擴(kuò)展版本的語法：[expr for iter_var in iterable if cond_expr]，它在迭代時會過濾/捕獲滿足條件表達(dá)式cond_expr的序列成員。
        挑選出序列中的奇數(shù)：
在CODE上查看代碼片派生到我的代碼片

 >>> seq = [11, 10, 9, 9, 10, 10, 9, 8, 23, 9, 7, 18, 12, 11, 12] 
 >>> filter(lambda x: x % 2, seq) 
 [11, 9, 9, 9, 23, 9, 7, 11] 
 >>> [x for x in seq if x % 2] 
 [11, 9, 9, 9, 23, 9, 7, 11] 

         即使不用filter()和lambda，可以使用列表解析來完成操作，獲得想要的數(shù)字。
       矩陣樣例：迭代一個有三行五列的矩陣，[(x+1,y+1) for x in range(3) for y in range(5)]。
       磁盤文件樣例：若有一個數(shù)據(jù)文件text.txt，需要計算出所有非空白字符的數(shù)目，可以把每行分割( split )為單詞,，然后計算單詞個數(shù)：>>> f = open('hhga.txt', 'r');len([word for line in f for word in line.split()])。快速地計算文件大?。?gt;>>import os;os.stat('text.txt').st_size。把每個單詞的長度加起來：>>>f.seek(0);sum([len(word) for line in f for word in line.split()])。
11、生成器表達(dá)式  

         生成器表達(dá)式是列表解析的一個擴(kuò)展，只用一行代碼就可以創(chuàng)建包含特定內(nèi)容的列表。另一個重要特性是生成器，生成器是特定的函數(shù)，允許返回一個值，然后"暫停"代碼的執(zhí)行，稍后恢復(fù)。
        列表解析的一個不足就是必要生成所有的數(shù)據(jù)，用以創(chuàng)建整個列表。這可能對有大量數(shù)據(jù)的迭代器有負(fù)面效應(yīng)， 生成器表達(dá)式通過結(jié)合列表解析和生成器解決了這個問題。
        生成器表達(dá)式與列表解析非常相似，而且它們的基本語法基本相同。不過它并不真正創(chuàng)建數(shù)字列表而是返回一個生成器，這個生成器在每次計算出一個條目后，把這個條目“產(chǎn)生”(yield)出來。生成器表達(dá)式使用了"延遲計算"(lazy evaluation)，所以它在使用內(nèi)存上更有效。生成器并不會讓列表解析廢棄，它只是一個內(nèi)存使用更友好的結(jié)構(gòu)，基于此,有很多使用生成器地方。
列表解析語法：

[expr for iter_var in iterable if cond_expr]

生成器表達(dá)式語法：

(expr for iter_var in iterable if cond_expr)

        磁盤文件樣例：上述計算文本文件中非空白字符總和，如果這個文件的大小變得很大， 那么這行代碼的內(nèi)存性能會很低，因為要創(chuàng)建一個很長的列表用于存放單詞的長度。為了避免創(chuàng)建龐大的列表，使用生成器表達(dá)式來完成求和操作，優(yōu)化后的代碼：>>> sum(len(word) for line in data for word in line.split())，是把方括號刪除，少了兩字節(jié)， 而且更節(jié)省內(nèi)存。
        交叉配對例子：成器表達(dá)式就好像是懶惰的列表解析（這反而成了它主要的優(yōu)勢），它還可以用來處理其他列表或生成器，如：x_product_pairs = ((i, j) for i in rows for j in cols())。
       重構(gòu)樣例，尋找文件最長的行的例子：
以前的方法：

在CODE上查看代碼片派生到我的代碼片

 #!/usr/bin/env python 
  
 def fun(): 
  f = open('/etc/motd', 'r') 
  longest = 0 
  allLines = [x.strip() for x in f.readlines()] #or allLineLens = [len(x.strip()) for x in f] 
  f.close() 
  for line in allLines: 
   linelen = len(line) 
   if linelen > longest:   #or longest = max(allLineLens) 
    longest = linelen 
  return longest 

新的方法：

       使用生成器表達(dá)式替換列表解析和max()函數(shù)，并去掉文件打開模式（默認(rèn)為讀取）：return max(len(x.strip()) for x in open('/etc/motd'))。
三、總結(jié)
（1）itertools模塊被加入，更加支持了迭代器的應(yīng)用，列表解析和生成表達(dá)式的內(nèi)容可結(jié)合實例分析。
（2）若有不足，請留言，在此先感謝！

最新評論