查看關鍵字的方法
查看所有的關鍵字：help("keywords")
>>> help("keywords")
Here is a list of the Python keywords. Enter any keyword to get more help.
False def if raise
None del import return
True elif in try
and else is while
as except lambda with
assert finally nonlocal yield
break for not
class from or
continue global pass
或者
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
關鍵字概述
| 關鍵字 | 含義 |
|---|---|
| and | 為邏輯關系用語，Python具有短路邏輯，不執行后面的語句,False and 返回 False |
| as | 使用標准庫中的模塊,如import cPickle as p |
| assert | 斷言，聲明其布爾值必須為真的判定，如果發生異常就說明表達示為假。 可以理解assert斷言語句為raise-if-not，用來測試表示式，其返回值為假，就會觸發異常。 |
| break | 提前跳出一個塊 |
| class | 定義類 |
| continue | 回到一個塊的開始處 |
| def | def關鍵字進行函數的定義，不用指定返回值的類型。 |
| del | 刪除變量 |
| elif | 和if配合使用的，if語句中的一個分支用elif表示。 |
| else | 用在條件語句中，表明當條件不成立時的分支 |
| except | 和try一起使用，用來捕獲異常。 |
| False | 數據類型bool（布爾）類型的實例對象（值），假 |
| finally | 用於處理異常情況，用來聲明一個基本肯定會被執行到的語句塊 |
| for | 一種循環結構的引導詞 |
| from | 在python用import或者from...import來導入相應的模塊 |
| global | golbal為全局變量，但當單個函數中出現同一變量名時，在單個函數中為局部變量 |
| if | 條件語句的引導詞 |
| import | 導入相應的庫 |
| in | 迭代器 |
| is | is 和 is not 是Python下判斷同一性的關鍵字 |
| lambda | 即匿名函數，不用想給函數起什么名字。提升了代碼的簡潔程度。 |
| None | 空對象，空值是Python里一個特殊的值 |
| nonlocal | 用來在函數或其他作用域中使用外層(非全局)變量 |
| not | 布爾的非 |
| pass | 空語句 do nothing，保證格式完整，保證語義完整 |
| raise | 觸發異常后，后面的代碼就不會再執行 |
| return | 從成員方法中返回數據 |
| True | 數據類型bool（布爾）類型的實例對象（值），真 |
| or | 為邏輯關系用語，Python具有短路邏輯,不執行后面的語句， True or 直接返回True， |
| try | 嘗試一個可能拋出異常的程序塊 |
| while | 用在循環結構中 |
| with | with被用來處理異常 |
| yield | 意思是生產，返回了一個生成器對象，每個生成器只能使用一次 |
判斷、循環
Python的循環及判斷主要包括這些關鍵字：
**if elif else for while break continue and or is not in **
if 語法、while語法、for語法以及and...or語法
if 語法
- if-else的使用格式
if 條件:
滿足條件時要做的事情1
...(省略)...
else:
不滿足條件時要做的事情1
...(省略)...
- elif的功能
if 條件1:
滿足條件1時要做的事情
...
elif 條件2:
不滿足條件1，滿足條件2時要做的事情
...
else:
不滿足條件1，2時要做的事情
...
while語法
while 條件:
條件滿⾜時，做的事情1
條件滿⾜時，做的事情2
條件滿⾜時，做的事情3
...(省略)...
for語法
for 臨時變量 in 列表或者字符串等:
循環滿⾜條件時執⾏的代碼
else:
循環不滿⾜條件時執⾏的代碼
break的作⽤：⽤來結束整個循環
continue的作⽤：⽤來結束本次循環，緊接着執⾏下⼀次的循環
and...or語法
Python的and/or操作與其他語言不同的是它的返回值是參與判斷的兩個值之一，所以我們可以通過這個特性來實現Python下的 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
當bool and a or b相當於bool? a: b
注：但是特殊情況是，若a為假，則不會相當於，而是返回b
解決辦法：用 （bool and [a] or [b]）[0]代替
函數、模塊、類
對於Python的函數及模塊主要包括這些關鍵字：
from import as def pass lambda return class
模塊
Python的編程通常大量使用標准庫中的模塊，使用方法就是使用import 、from以及as 關鍵字。
比如：
import sys # 導入sys模塊
from sys import argv # 從sys模塊中導入argv ，這個在前面介紹腳本傳參數時使用到
import cPickle as p # 將cPickle模塊導入並在此將它簡單命名為p，此后直接可以使用p替代cPickle模塊原名，這個在介紹文件輸入輸出時的存儲器中使用到
- from...import
如 from A import b,相當於
import A
b=A.b
再如：
"from t2 import var1" 相當於:
import t2
var1= t2.var1
在此過程中有一個隱含的賦值的過程
- import......as
import A as B,給予A庫一個B的別稱，幫助記憶
函數
Python中定義函數時使用到def關鍵字，如果你當前不想寫入真實的函數操作，可以使用pass關鍵字指代不做任何操作
def
def function(params):
block
return expression/value
-
在Python中采用def關鍵字進行函數的定義，不用指定返回值的類型。
-
函數參數params可以是零個、一個或者多個，同樣的，函數參數也不用指定參數類型，因為在Python中變量都是弱類型的，Python會自動根據值來維護其類型。
-
return語句是可選的，它可以在函數體內任何地方出現，表示函數調用執行到此結束；如果沒有return語句，會自動返回NONE，如果有return語句，但是return后面沒有接表達式或者值的話也是返回NONE。
pass
- 空語句 do nothing
- 保證格式完整
- 保證語義完整
pass語句在函數中的作用
當你在編寫一個程序時，執行語句部分思路還沒有完成，這時你可以用pass語句來占位，也可以當做是一個標記，是要過后來完成的代碼。比如下面這樣：
def iplaypython():
pass
定義一個函數iplaypython，但函數體部分暫時還沒有完成，又不能空着不寫內容，因此可以用pass來替代占個位置。
pass語句在循環中的作用
pass也常用於為復合語句編寫一個空的主體，比如說你想一個while語句的無限循環，每次迭代時不需要任何操作，你可以這樣寫：
while True:
pass
以上只是舉個例子，現實中最好不要寫這樣的代碼，因為執行代碼塊為pass也就是空什么也不做，這時python會進入死循環。
Lambda
lambda的一般形式是關鍵字lambda后面跟一個或多個參數，緊跟一個冒號，以后是一個表達式。lambda是一個表達式而不是一個語句。它能夠出現在Python語法不允許def出現的地方。作為表達式，lambda返回一個值（即一個新的函數）。lambda用來編寫簡單的函數，而def用來處理更強大的任務。
f = lambda x,y,z : x+y+z
print f(1,2,3) ＃６
g = lambda x,y=2,z=3 : x+y+z
print g(1,z=4,y=5) ＃１０
異常
對於Python的異常主要包括這些關鍵字：
**try except finally raise **
捕捉異常可以使用try/except語句。
try/except語句用來檢測try語句塊中的錯誤，從而讓except語句捕獲異常信息並處理。
如果你不想在異常發生時結束你的程序，只需在try里捕獲它。
try:
<語句> #運行別的代碼
except <名字>：
<語句> #如果在try部份引發了'name'異常
except <名字>，<數據>:
<語句> #如果引發了'name'異常，獲得附加的數據
else:
<語句> #如果沒有異常發生
try的工作原理是，當開始一個try語句后，python就在當前程序的上下文中作標記，這樣當異常出現時就可以回到這里，try子句先執行，接下來會發生什么依賴於執行時是否出現異常。
-
如果當try后的語句執行時發生異常，python就跳回到try並執行第一個匹配該異常的except子句，異常處理完畢，控制流就通過整個try語句（除非在處理異常時又引發新的異常）。
-
如果在try后的語句里發生了異常，卻沒有匹配的except子句，異常將被遞交到上層的try，或者到程序的最上層（這樣將結束程序，並打印缺省的出錯信息）。
-
如果在try子句執行時沒有發生異常，python將執行else語句后的語句（如果有else的話），然后控制流通過整個try語句。
raise關鍵字是在一定的情況下引發異常，通常結合自定義的異常類型使用。
其他
**print del global with assert yield exec **
del
由於python都是引用，而python有GC機制，所以，del語句作用在變量上，而不是數據對象上。del刪除的是變量，而不是數據。
global
當你在函數定義內聲明變量的時候，它們與函數外具有相同名稱的其他變量沒有任何關系，即變量名稱對於函數來說是 局部 的。這稱為變量的 作用域 。所有變量的作用域是它們被定義的塊，從它們的名稱被定義的那點開始。
# 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] view plain copy
$ 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語句，是不可能為定義在函數外的變量賦值的。
只是函數內的局部變量
# 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的值的時候。
只是函數內的局部變量
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如何工作：
# 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__()方法被調用
assert 關鍵字
assert語句是一種插入調試斷點到程序的一種便捷的方式。assert語句用來聲明某個條件是真的,當assert語句失敗的時候，會引發一AssertionError，所以結合try...except我們就可以處理這樣的異常。
>>> 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異常
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的博文！
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()則是內建函數。