### 6. 簡單語句 簡單語句包含在單一的一個邏輯行中。幾個簡單語句可以用分號分隔出現在單一的一行中。簡單語句的語法是： ~~~ simple_stmt ::= expression_stmt | assert_stmt | assignment_stmt | augmented_assignment_stmt | pass_stmt | del_stmt | print_stmt | return_stmt | yield_stmt | raise_stmt | break_stmt | continue_stmt | import_stmt | global_stmt | exec_stmt ~~~ ### 6.1. 表達式語句 表達式語句用于（主要用于交互式地）計算和寫入一個值，或者（通常）調用一個過程（返回結果沒有意義的函數；在Python中，過程返回None值）。其它表達式語句的使用也是允許的，但是很少有意義。表達式語句的語法是： ~~~ expression_stmt ::= expression_list ~~~ 表達式語句計算表達式列表的值（也可能是一個單一的表達式）。 在交互模式下，如果值不是None，它將被內建的[repr()](# "repr: Alternate repr() implementation with size limits.")函數轉換為一個字符串，產生的字符串被寫到標準輸出（參見[*print語句*](#)) 的一行上。（生成None 的表達式不會被輸出，因此過程調用不會帶來任何輸出。） ### 6.2. 賦值語句 賦值語句用于（重新）綁定名稱到具體的值以及修改可變對象的屬性或元素： ~~~ assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" target_list ")" | "[" target_list "]" | attributeref | subscription | slicing ~~~ （最后三種符號的定義參見[*初級操作*](#)一節。） 賦值語句計算expression_list（記住，它可以是一個單一的表達式也可以是一個逗號分隔的序列，后者生成一個元組）并且從左到右把單一的結果對象賦值給target_list的每一個元素。 賦值是遞歸定義的，取決于目標（序列）的形式。當目標是可變對象的一部分時（屬性引用，下標或者切片），最終必須由該可變對象做賦值操作并決定其合法性，如果賦值不可接受可以拋出一個異常。各種類型遵守的規則以及拋出的異常根據對象類型的定義給出（參見[*標準類型的層次*](#)一節）。 賦值一個對象給一個目標序列按如下方式遞歸定義： - 如果對象列表是單一的目標：對象賦值給該目標。 - 如果目標序列是逗號分隔的序列：對象必須是可迭代的且元素個數與目標序列中目標個數相同，然后元素從左向右賦值給對應的目標。 賦值一個對象給一個單一的目標按如下方式遞歸定義。 - 如果目標是一個標識符（名稱）： - 如果名稱沒有出現在當前代碼塊的[global](#)語句中：名稱綁定到當前局部命名空間中的對象。 - 否則：名稱綁定到當前全局命名空間的對象。 如果名稱已經綁定，那么它將重新綁定。這可能導致之前綁定到該名稱的對象的引用計數變為零，引起該對象被釋放并調用它的析構函數（如果有的話）。 - 如果目標是一個包含在圓括號或者方括號中的目標序列：對象必須是可迭代的且元素個數與目標序列中目標個數相同，然后元素從左向右賦值給對應的目標。 - 如果目標是屬性引用：計算引用中的初級表達式。它產生的對象應該具有一個可以賦值的屬性；如果情況不是這樣，則拋出[TypeError](# "exceptions.TypeError")異常。然后要求該對象將被賦值的對象賦值給給定的屬性；如果不能做此操作，它會拋出一個異常（通常是[AttributeError](# "exceptions.AttributeError")，但不一定）。 注意：如果對象是類的實例且屬性引用出現在賦值運算符的兩側，那么右側的表達式a.x既可以訪問實例屬性（如果不存在實例屬性）也可以訪問類屬性。左側的目標將a.x永遠設置成實例的屬性，如果必要將創建它。因此，a.x的兩次出現不是一定會引用同一個屬性：如果右側表達式引用的是一個類屬性，左側的表達式將創建一個新的實例屬性作為賦值的目標。 ~~~ class Cls: x = 3 # class variable inst = Cls() inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3 ~~~ 這里的描述不一定適用描述器屬性，例如[property()](# "property")創建的屬性。 - 如果目標是下標操作符：計算引用中的初級表達式。它應該生成一個可變的序列對象（例如列表）或者映射對象（例如字典）。然后，計算下標表達式。 如果primary是一個可變的序列對象（例如一個列表），則下標必須產生一個普通的整數。如果它是負數，將會加上序列的長度。結果值必須是一個小于序列長度的非負整數，然后將要求序列賦值該對象給具有那個索引的元素。如果索引超出范圍，則引發[IndexError](# "exceptions.IndexError")異常（給序列下標賦值不能添加新的元素到序列中）。 如果primary 是一個映射對象（例如一個字典），下標必須具有和映射的關鍵字類型兼容的類型，然后要求映射創建一個鍵/值對將下標映射到賦值的對象。這既可以替換一個具有相同鍵值得已存在鍵/值對，也可以插入一個新的鍵/值對（如果不存在相同的鍵）。 - 如果目標是一個切片：計算引用中的初級表達式。它應該產生一個可變序列對象（例如列表）。被賦值的對象應該是相同類型的序列對象。下一步，如果存在，則計算下邊界和上邊界表達式；默認是零和序列的長度。邊界計算的值應該是（小）整數。如果任意一個邊界為復數，則會給它加上序列的長度。結果求得的邊界在零和序列的長度之間，包括邊界在內。最后，要求序列對象用賦值的序列元素替換切片。切片的長度可能不同于賦值的序列的長度，因此如果對象允許則改變目標序列的長度。 **CPython實現細節：**在目前的實現中，目標的語法和表達式的語法相同，不合法的語法將在代碼生成階段被排除，導致不夠詳細的錯誤信息。 警告：雖然賦值的定義暗示左側和右側之間的交叉賦值是‘安全的’（例如，a,b=b,a交換兩個變量），但是賦值目標集的*內部*有交叉則是不安全的！例如，下面的程序將打印[0,2]： ~~~ x = [0, 1] i = 0 i, x[i] = 1, 2 print x ~~~ #### 6.2.1. 增強的賦值語句 增強的賦值是將二元操作和賦值語句組合成一個單一的語句。 ~~~ augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|=" ~~~ （最后三個符號的語法定義參見[*初級操作*](#)一節。） 增強的賦值將先求值target（和普通的賦值語句不同，它不可以是一個可拆分的對象）和expression_list，然后完成針對兩個操作數的二元操作，最后將結果賦值給初始的target。target只計算一次。 像x+=1這樣增強的賦值表達式可以重寫成x=x+1以達到類似但不完全等同的效果。在增強版本中，x只計算一次。還有，如果可能，真實的操作是*原地的*，意思是不創建一個新的對象并賦值給target，而是直接修改舊的對象。 除了不可以在一個語句中賦值給元組和多個目標，增強的賦值語句完成的賦值和普通的賦值以相同的方式處理。類似地，除了可能出現的*原地*行為，增強的賦值完成的二元操作和普通的二元操作相同。 如果target是屬性引用，[*關于類和實例屬性的注意事項*](#)同樣適用于正常的賦值。 ### 6.3.?[assert](#) 語句 Assert語句是插入調試斷言到程序中的一種便捷方法： ~~~ assert_stmt ::= "assert" expression ["," expression] ~~~ 其簡單形式，assertexpression，等同于 ~~~ if __debug__: if not expression: raise AssertionError ~~~ 其擴展形式，assertexpression1,expression2，等同于 ~~~ if __debug__: if not expression1: raise AssertionError(expression2) ~~~ 這些等價的語句假定[__debug__](# "__debug__")和[AssertionError](# "exceptions.AssertionError")引用的是同名的內建變量。在當前的實現中，內建的變量[__debug__](# "__debug__")在正常情況下為為True，在要求優化時（命令行選項 -o）為False。在編譯時刻，當要求優化時，目前的代碼生成器不會為斷言語句生成任何代碼。注：不必把失敗的表達式的源代碼包含進錯誤信息；它將作為棧回溯的一部分顯示出來。 給[__debug__](# "__debug__")賦值是非法的。內建變量的值在解釋器啟動的時候就已決定。 ### 6.4. [pass](#) 語句 ~~~ pass_stmt ::= "pass" ~~~ [pass](#)是一個空操作 — 執行它的時候，什么都沒有發生。它的用處是當語法上要求有一條語句但是不需要執行任何代碼的時候作為占位符，例如： ~~~ def f(arg): pass # a function that does nothing (yet) class C: pass # a class with no methods (yet) ~~~ ### 6.5. [del](#) 語句 ~~~ del_stmt ::= "del" target_list ~~~ 刪除是遞歸定義的，和賦值的定義方式非常相似。這里就不詳細講述完整的細節，只給出一些注意事項。 刪除目標將從左向右遞歸刪除每一個目標。 刪除一個名稱將從局部或全局命名空間中刪除該名稱的綁定，取決于名稱是否出現在相同代碼塊的[global](#)語句中。如果名稱沒有綁定，將拋出一個[NameError](# "exceptions.NameError") 異常。 如果名稱作為自由變量出現在嵌套的代碼塊中，從局部命名空間中刪除它是非法的。 屬性引用、下標和切片的刪除將傳遞給原始的對象；切片的刪除在一般情況下等同于賦予一個右邊類型的空切片（但即使這點也是由切片的對象決定）。 ### 6.6. [print](#) 語句 ~~~ print_stmt ::= "print" ([expression ("," expression)* [","]] | ">>" expression [("," expression)+ [","]]) ~~~ [print](#)依次計算每一個表達式并將求得的對象寫入標準輸出（參見下文）。如果對象不是字符串，那么首先使用字符串轉換規則將它轉換成字符串。然后輸出（求得的或者原始的）字符串。在（轉換和）輸出每個對象之前會輸出一個空格，除非輸出系統認為它位于一行的開始。這些情況包括（1）還沒有字符寫入到標準輸出，（2）寫入到標準輸出的最后一個字符是除''以外的空白字符，或者（3）最后向標準輸出寫入的操作不是[print](#)語句。（在某些情況下由于這個原因向標準輸出寫入一個空白字符串可能是有用的。） 注意 行為像文件對象但是不是內建的文件對象的對象通常不會恰當地模擬文件對象的這方面行為，所以最好不要依賴這個行為。 在結尾會寫入一個'\n'字符，除非[print](#)語句以逗號結束。如果語句只包含關鍵字[print](#)，這將是唯一的行為。 標準輸出定義為內建模塊[sys](# "sys: Access system-specific parameters and functions.")中名為stdout的對象。如果不存在該對象，或者它沒有write()方法，將拋出一個[RuntimeError](# "exceptions.RuntimeError")異常。 [print](#)同樣有一種擴展的形式，由上面描述的語法的第二部分定義。這種形式有時被稱為“[print](#) chevron。”在這種形式中，>>之后的第一個表達式必須是一個“類文件”對象，具體點就是具有上面提到的write()方法的對象。通過這種擴展形式，隨后的表達式被輸入到該文件對象。如果第一個表達式求值為None，那么使用sys.stdout作為輸出的文件。 ### 6.7. [return](#) 語句 ~~~ return_stmt ::= "return" [expression_list] ~~~ [return](#)在語法上只可以出現在函數定義中，不可以出現在類定義中。 如果存在expression_list，則計算它，否則使用None替換。 [return](#)離開當前的函數調用時以expression_list（或None）作為返回值。 當[return](#)將控制傳出帶有[finally](#)子句的[try](#)語句時，在真正離開函數之前會執行[finally](#)子句。 在生成器函數中，[return](#)語句不允許包含[expression_list](#)。在這種情況下，空的[return](#)表明生成器已經完成并將導致[StopIteration](# "exceptions.StopIteration")異常拋出。 ### 6.8. [yield](#) 語句 ~~~ yield_stmt ::= yield_expression ~~~ [yield](#)語句只在定義生成器函數是使用，且只在生成器函數的函數體中使用。在函數定義中使用[yield](#)語句就足以創建一個生成器函數而不是普通函數。 當調用生成器函數時，它返回一個稱為生成器迭代器的迭代器，或者通常就叫做生成器。生成器函數體的執行通過重復調用生成器的[next()](# "next")方法直到它拋出一個異常。 當執行一個[yield](#)語句時，生成器的狀態將凍結起來并且將[expression_list](#)的值返回給[next()](# "next")的調用者。“凍結”的意思是所有局部的狀態都會被保存起來，包括當前局部變量的綁定、指令指針、內部的計算棧：保存足夠的信息以使得下次調用[next()](# "next")時，函數可以準確地繼續，就像[yield](#)語句只是另外一個外部調用。 從Python 2.5版開始，[yield](#)語句允許在出現在[try](#) ... [finally](#)結構的[try](#)子句中。如果生成器在終結（引用數達到零或者被當作垃圾回收）之前沒有恢復，將調用生成器迭代器的close()方法， 這允許任何掛起的[finally](#)子句可以執行。 [yield](#)語義的完整細節，參考[*Yield表達式*](#)一節。 注意 在Python 2.2中，[yield](#)語句只有當generators功能啟用了時才允許。__future__導入語句用來啟用該功能： ~~~ from __future__ import generators ~~~ 另請參閱 [**PEP 0255**](http://www.python.org/dev/peps/pep-0255) - 簡單的生成器添加生成器和[yield](#)語句到Python中的提議。[**PEP 0342**](http://www.python.org/dev/peps/pep-0342) - 通過增強的生成器實現協程該提議提出，除了其它的生成器的增強之外，允許[yield](#)出現在[try](#) ... [finally](#)代碼塊的內部。 ### 6.9. [raise](#) 語句 ~~~ raise_stmt ::= "raise" [expression ["," expression ["," expression]]] ~~~ 如果沒有表達式，[raise](#) 重新拋出當前作用域中最后一個激活的異常。如果當前作用域中沒有活著的異常，則拋出[TypeError](# "exceptions.TypeError")異常以表示這是一個錯誤（如果在IDLE中運行，則會拋出[Queue.Empty](# "Queue.Empty")異常）。 否則，[raise](#)計算后面的表達式以得到三個對象，使用None作為省略的表達式的值。前面的兩個對象用于決定異常的*類型*和*值*。 如果第一個對象是一個實例，那么異常的類型是實例的類，實例本身是值，第二個對象必須是None。 如果第一個對象是一個類，那么它將成為異常的類型。第二個對象用于決定異常的值：如果它是類的實例，那么該實例將成為異常的值。如果第二個對象是一個元組，它用于類構造函數的參數列表；如果它是None，則使用一個空的參數列表，如果是其它任何對象則被當做構造函數的一個單一的參數。通過調用構造函數創建的實例將用作該異常的值。 如果存在第三個對象且不為None，那么它必須是一個回溯對象（參見[*標準類型的層次*](#)一節）， 且它將替換當前異常發生的位置。如果存在第三個對象且值不是回溯對象或者None，將會拋出[TypeError](# "exceptions.TypeError") 異常。具有三個表達式形式的[raise](#)用于在except子句中顯式地重新拋出異常，但是如果重新拋出的異常是當前作用域中最近激活的異常則應該優先使用不帶表達式的[raise](#)。 關于異常的更多信息可以在[*異常*](#)一節中找到，如何處理異常的信息在[*try語句*](#)一節。 ### 6.10. [break](#) 語句 ~~~ break_stmt ::= "break" ~~~ [break](#)在語法上只可以出現在[for](#)或者[while](#)循環中，但不能嵌套在這些循環內的函數和類定義中。 它終止最相近的循環，如果循環有[else](#)子句將跳過。 如果[break](#)終止了一個[for](#)循環，控制循環的目標保持當前的值。 當[break](#)將控制傳出帶有[finally](#)子句的[try](#)語句時，在離開循環之前會執行[finally](#)子句。 ### 6.11. [continue](#) 語句 ~~~ continue_stmt ::= "continue" ~~~ [continue](#)在語法上只可以出現在[for](#)或[while](#)循環中，但不能嵌套在這些循環內的函數定義、類定義和[finally](#)子句中。它繼續最內層循環的下一輪。 當[continue](#)將控制傳出帶有[finally](#)子句的[try](#)語句時，在真正開始下一輪循環之前會執行[finally](#)子句。 ### 6.12. [import](#) 語句 ~~~ import_stmt ::= "import" module ["as" name] ( "," module ["as" name] )* | "from" relative_module "import" identifier ["as" name] ( "," identifier ["as" name] )* | "from" relative_module "import" "(" identifier ["as" name] ( "," identifier ["as" name] )* [","] ")" | "from" module "import" "*" module ::= (identifier ".")* identifier relative_module ::= "."* module | "."+ name ::= identifier ~~~ import語句分兩步執行：（1）找到模塊，如果必要則進行初始化；（2）定義（[import](#)語句所在作用域的）局部命名空間中的名稱。該語句有兩種形式，區別在于有沒有使用[from](#)關鍵字。第一種形式（沒有[from](#)）針對序列中的每個標識符重復執行這些步驟。具有[from](#)的形式將先執行一次步驟（1），然后重復執行步驟（2）。 為了理解步驟（1）如何發生，你必須首先理解Python如何處理模塊的分層命名。為了幫助組織模塊并提供一套命名的層級，Python有一個包的概念。包可以包含其它包和模塊，但是模塊不可以包含其它模塊或者包。從文件系統的角度，包是目錄而模塊是文件。原始的[包的說明](http://www.python.org/doc/essays/packages.html)仍然可以閱讀，盡管自從該文檔的編寫以來小的細節已經發生了變化。 一旦知道模塊的名字（除非特別指出，“模塊”這個詞兼指包和模塊），模塊或者包的搜索就可以開始。首先檢查的地方是[sys.modules](# "sys.modules")，這里是之前已經導入的所有模塊的緩存。如果找到該模塊，那么將在導入的步驟（2）使用它。 如果在緩存中沒有找到該模塊，則搜索[sys.meta_path](# "sys.meta_path")（[sys.meta_path](# "sys.meta_path")的說明可以在[**PEP 302**](http://www.python.org/dev/peps/pep-0302)中找到）。該對象是[*finder*](#)對象的一個列表，通過以模塊的名稱調用它們的find_module()方法可以知道如何加載模塊。如果模塊正好包含在某個包中（由名稱中存在的點號表示），那么父包中的__path__屬性將作為find_module()?第二個參數給出（正在導入的模塊的名字中，最后一個點號之前的所有內容）。如果某個finder能夠找到該模塊，它將返回一個[*loader*](#)（后面討論）或者None。 If none of the finders on [sys.meta_path](# "sys.meta_path") are able to find the module then some implicitly defined finders are queried.Implementations of Python vary in what implicit meta path finders are defined.The one they all do define, though, is one that handles [sys.path_hooks](# "sys.path_hooks"), [sys.path_importer_cache](# "sys.path_importer_cache"), and [sys.path](# "sys.path"). The implicit finder searches for the requested module in the “paths” specified in one of two places (“paths” do not have to be file system paths).If the module being imported is supposed to be contained within a package then the second argument passed to find_module(), __path__ on the parent package, is used as the source of paths.If the module is not contained in a package then [sys.path](# "sys.path") is used as the source of paths. Once the source of paths is chosen it is iterated over to find a finder that can handle that path.The dict at [sys.path_importer_cache](# "sys.path_importer_cache") caches finders for paths and is checked for a finder.If the path does not have a finder cached then [sys.path_hooks](# "sys.path_hooks") is searched by calling each object in the list with a single argument of the path, returning a finder or raises [ImportError](# "exceptions.ImportError").If a finder is returned then it is cached in [sys.path_importer_cache](# "sys.path_importer_cache") and then used for that path entry.If no finder can be found but the path exists then a value of None is stored in [sys.path_importer_cache](# "sys.path_importer_cache") to signify that an implicit, file-based finder that handles modules stored as individual files should be used for that path.If the path does not exist then a finder which always returns None is placed in the cache for the path. If no finder can find the module then [ImportError](# "exceptions.ImportError") is raised.Otherwise some finder returned a loader whose load_module() method is called with the name of the module to load (see [**PEP 302**](http://www.python.org/dev/peps/pep-0302) for the original definition of loaders).A loader has several responsibilities to perform on a module it loads.First, if the module already exists in [sys.modules](# "sys.modules") (a possibility if the loader is called outside of the import machinery) then it is to use that module for initialization and not a new module.But if the module does not exist in [sys.modules](# "sys.modules") then it is to be added to that dict before initialization begins.If an error occurs during loading of the module and it was added to [sys.modules](# "sys.modules") it is to be removed from the dict.If an error occurs but the module was already in [sys.modules](# "sys.modules") it is left in the dict. The loader must set several attributes on the module.__name__ is to be set to the name of the module.__file__ is to be the “path” to the file unless the module is built-in (and thus listed in [sys.builtin_module_names](# "sys.builtin_module_names")) in which case the attribute is not set.If what is being imported is a package then __path__ is to be set to a list of paths to be searched when looking for modules and packages contained within the package being imported.__package__ is optional but should be set to the name of package that contains the module or package (the empty string is used for module not contained in a package).__loader__ is also optional but should be set to the loader object that is loading the module. If an error occurs during loading then the loader raises [ImportError](# "exceptions.ImportError") if some other exception is not already being propagated.Otherwise the loader returns the module that was loaded and initialized. 當步驟（1）結束時沒有拋出異常，步驟（2）就可以開始。 [import](#)語句的第一種形式將局部命名空間中的模塊名綁定到模塊對象，然后如果有下一個標識符則繼續導入。如果模塊后面帶有[as](#)，則[as](#)后面的名稱將用于模塊的局部名稱。 [from](#)形式不綁定模塊的名稱：它遍歷標識符序列，在步驟（1）中找到的模塊中逐一查找它們，然后綁定局部命名空間中的名稱到找到的對象。與第一種形式的[import](#)類似，可以通過“[as](#) localname”提供另外一個名稱。如果找不到名稱，則引發[ImportError](# "exceptions.ImportError")。如果用星號('*')替換標識符序列，那么模塊中定義的所有公開的名稱都將被綁定到[import](#)語句所在的局部命名空間。 模塊定義的*公開的名稱*通過檢查模塊命名空間中一個名為__all__的變量決定；如果定義，它必須是一個字符串序列，它們是該模塊定義或者導入的名稱。__all__中給出的名稱都被認為是公開的且要求必須存在。如果__all__沒有定義，那么公開的名稱集合包括模塊命名空間中找到的所有不是以下劃線字符 ('_')開始的名稱。__all__應該包含全部的公開API。它的意圖是避免意外地導出不是API的部分（例如模塊內部導入和使用的庫模塊）。 帶有*的[from](#) 形式只可以出現在模塊作用域中。如果通配符形式的導入— import* — 在函數中使用并且函數包含或者是一個帶有自由變量的嵌套代碼塊，編譯器將拋出[SyntaxError](# "exceptions.SyntaxError")。 在指出你要導入的模塊時，你不必指明模塊的絕對路徑名。當一個模塊或者包包含在另外一個包中時，可以在同一個等級的包中使用相對導入而不需要提及包的名字。通過在[from](#)之后指定的模塊或包中使用前導的點號，你可以指定相對當前包層級向上