python中標示符作用詳解
python中的標示符
在python裡，識別符號有字母、數字、下劃線組成。
在python中，所有識別符號可以包括英文、數字以及下劃線（_），但不能以數字開頭。
python中的識別符號是區分大小寫的。
以下劃線開頭的識別符號是有特殊意義的。以單下劃線開頭（_foo）的代表不能直接訪問的類屬性，需通過類提供的介面進行訪問，不能用"fromxxx import *"而匯入；
以雙下劃線開頭的（__foo）代表類的私有成員；以雙下劃線開頭和結尾的（__foo__）代表python裡特殊方法專用的標識，如__init__（）代表類的建構函式。
一、python中的保留字：
1 and
python 中的and從左到右計算表示式，若所有值均為真，則返回最後一個值，若存在假，返回第一個假值。
例子：
(1)print'a' and 'b';
輸出值(返回第一個真值)：
b
(2)print ''and'b
輸出值(返回第一個假值)：
為'空
2 exec
該語句用來執行儲存在字串或檔案中的Python語句。例如，我們可以在執行時生成一個包含Python程式碼的字串，然後使用exec語句執行這些語句。下面是一個簡單的例子
exec 'print"hello world!"'
輸出值（執行了該語句）：
hello world！
3 not
在python中not是邏輯判斷詞，用於布林型True和False，not True為False，notFalse為True，以下是幾個常用的not的用法：
(1) not與邏輯判斷句if連用，代表not後面的表示式為False的時候，執行冒號後面的語句。比如：
a = False
if not a: (這裡因為a是False，所以not a就是True)
print "hello"
這裡就能夠輸出結果hello
(2)判斷元素是否在列表或者字典中，if a not in b，a是元素，b是列表或字典，這句話的意思是如果a不在列表b中，那麼就執行冒號後面的語句，比如：
a = 5
b = [1, 2, 3]
if a not in b:
print "hello"
這裡也能夠輸出結果hello
4 assert
（1）語句用來宣告某個條件是真的。
（2）如果你非常確信某個你使用的列表中至少有一個元素，而你想要檢驗這一點，並且在它非真的時候引發一個錯誤，那麼語句是應用在這種情形下的理想語句。
（3）當assert語句失敗的時候，會引發例如：
buf = ['abc'];
assert len(buf)>=1
buf.pop() #之後buf為長度為0
assert len(buf) ==1#該條件為假，就會引發
輸出結果：
Traceback (most recent call last):
assert len(buf) ==1
AssertionError
5 finally
假如你在讀一個檔案的時候，希望在無論異常發生與否的情況下都關閉檔案，該怎麼做呢？這可以使用塊來完成。
例如：
import time
try:
f=file('poem.txt')
while True:
line =f.readline()
if len(line)== 0:
break
time.sleep(10)
print line,
finally:
f.close()
print "Cleaningup...closed the file"
執行結果：
heheheheheheheeh!!!!!!!!!! Cleaningup...closed the file
特別注意：你所讀取的檔案一定要有資料，否則直接break，不執行休眠10S，另外finally必須和try對齊，python中隊格式要求非常嚴格，因為不同的格式決定該部分屬於不同的分支。
6 or
從左到右計算，返回第一個為真的值。
‘’or'b'#返回值為b
7 break
Python break語句，就像在C語言中，打破了最小封閉for或while迴圈。
break語句用來終止迴圈語句，即迴圈條件沒有False條件或者序列還沒被完全遞迴完，也會停止執行迴圈語句。
break語句用在while和for迴圈中。
如果您使用巢狀迴圈，break語句將停止執行最深層的迴圈，並開始執行下一行程式碼。
8 for
在C/C++中，如果你想要寫for (int i = 0; i < 5; i++)，那麼用Python，你寫成for i in range(0,5)
例如：
import math
i = 0
for i in range(0,10):
print"%d"%i
注意：此處的i會自動加1，列印10次i的值0~9，格式輸出在雙引號外加%+變數
9 pass
空語句 do nothing；保證格式完整；保證語義完整；以if語句為例：
C語言中:
if(true)
; // do nothing
else
{} // do nothing
python中寫法：
if true:
pass # do nothing
else:
print "dosomething."
10 class
#class類
class GrandPa:
def __init__(self):
print"'I\'m GrandPa"
class Father(GrandPa):
def __init__(self):
print"'I\'m Father!"
class Son(Father):
i = 12345
def __init__(self):
print('這是建構函式,son')
def sayHello(self):
return 'hello world'
if __name__ == 'hello':
print""
GrandPa()
Father()
son = Son()
# print"__name__:%s"%__name__
# print"__main__:%s"%'__main__'
# 型別幫助資訊
print"型別幫助資訊:%s"%Son.__doc__
#型別名稱
print"型別名稱:%s"%Son.__name__
#型別所繼承的基類
print"型別所繼承的基類:%s"%Son.__bases__
#型別字典
print"型別字典:%s"%Son.__dict__
#型別所在模組
print"型別所在模組:%s"%Son.__module__
#例項型別
print"例項型別:%s"%Son().__class__
執行輸出：
'I'm GrandPa
'I'm Father!
這是建構函式,son
型別幫助資訊:None
型別名稱:Son
型別所繼承的基類:hello.Father
型別字典:{'i': 12345, '__module__': 'hello', 'sayHello':<function sayHello at 0x0000000002ED9198>, '__doc__': None, '__init__':<function __init__ at 0x0000000002ED9128>}
型別所在模組:hello
這是建構函式,son
例項型別:hello.Son
11 form
在python用import或者from...import來匯入相應的模組。模組其實就是一些函式和類的集合檔案，它能實現一些相應的功能，當我們需要使用這些功能的時候，直接把相應的模組匯入到我們的程式中，我們就可以使用了。這類似於C語言中的include標頭檔案，Python中我們用import匯入我們需要的模組
一般使用import，from import有時會帶來conflict衝突，且不易讀。
12 print
列印字串和變數值進行輸出：
輸出一個字串：
print"hello world";
輸出一個值：
直接輸出值：
a= 10
printa
格式輸出值：
a= 10
print "a=%d"%a
輸出一個浮點數值：
a = 10.46456
print "a=%8.3f"%a
輸出值：
a= 10.465
特別說明：8.3分別指整個寬度為8，精度為3，整個寬度指從5到=右邊的空格共8位，小數點自身算1位，精度3指小數點後3位
13 continue
# 第一個例項
for letter in 'Python':
if letter == 'h':
continue
print '當前字母 :', letter
# 第二個例項
var = 10
while var > 0:
var = var -1
if var == 5:
continue
print '當前變數值 :', var
print "Good bye!"
14 global
global---將變數定義為全域性變數。可以通過定義為全域性變數，實現在函式內部改變變數值。
一個global語句可以同時定義多個變數，如 global x, y, z
globalm
m=10;
print"m=%d"%m;
def func():
m=20;
return m
print "func=%d"%func();
輸出結果：
m=10
func=20
global宣告的全域性變數可以再函式內外改變其值。
15 raise
當程式出現錯誤，python會自動引發異常，也可以通過raise顯示地引發異常。一旦執行了raise語句，raise後面的語句將不能執行。
例子：
#raise
try:
ver = True;
if ver is True:
print ver;
print"raise Sucess!";
raise NameError
print "可執行"
else:
print"No raise!"
except TypeError:
print"空物件"
執行結果：
True
raise Sucess!
NameError
ERROR: Module: hello could not be imported (file:H:\NetLeran\workspace\test\hello.py).
16 def和lambda
python lambda是在python中使用lambda來建立匿名函式，而用def建立的方法是有名稱的，除了從表面上的方法名不一樣外，python lambda還有哪些和def不一樣呢？
1 python lambda會建立一個函式物件，但不會把這個函式物件賦給一個識別符號，而def則會把函式物件賦值給一個變數。
2 python lambda它只是一個表示式，而def則是一個語句。
下面是python lambda的格式，看起來好精簡阿。
1. lambda x: print x
如果你在python 列表解析裡用到pythonlambda，我感覺意義不是很大，因為python lambda它會建立一個函式物件，但馬上又給丟棄了，因為你沒有使用它的返回值，即那個函式物件。也正是由於lambda只是一個表示式，它可以直接作為python 列表或python 字典的成員，比如：
1. info = [lamba a: a**3, lambda b: b**3]
在這個地方沒有辦法用def語句直接代替。因為def是語句，不是表示式不能巢狀在裡面，lambda表示式在“：”後只能有一個表示式。也就是說，在def中，用return可以返回的也可以放在lambda後面，不能用return返回的也不能定義在python lambda後面。因此，像if或for或print這種語句就不能用於lambda中，lambda一般只用來定義簡單的函式。
下面舉幾個python lambda和def的例子吧
1單個引數的：
lambda方法：
gol = lambda b:b*5
print gol(3)
結果是15
def方法：
defgol(x):
return 7*x
print gol(3)
輸出結果是：21
特別說明：網上有這樣的例子
gol =lambda b*3
printgol(3)
我在執行的時候發現錯誤，也許是版本的問題，有高手經過希望解釋？
多個引數的：
#lambda方法：
m = lambda x,y,z: (x-y)*z
print m(3,1,2)
#def方法：
def func1(x,y,z):
return (x-y)*z
m=func1(3,1,2)
print"m2 = %d"%m;
輸出結果是：4
17、if 和else
C和C++中if和else使用
if(a==5)
{/*執行的內容*/}
else
{/*執行的內容*/}
python中if和else使用：
if a is 5:
/*執行的內容*/
else:
/*執行的內容*/
18 return
return語句用來從一個函式 返回 即跳出函式。我們也可選從函式 返回一個值。基本和C相同
19 del
del用於list列表操作，刪除一個或者連續幾個元素：例子
listarr = [1,2,3,4,5,6,7,8,9]del listarr[2:4] #刪除下標從2到4的元素print "listarr:%s"%listarrdel listarr[2] #刪除下標為2的元素print "listarr:%s"%listarrdel listarr[1:5] #刪除下標為1到5的元素print "listarr:%s"%listarr
輸出結果：
listarr:[1, 2, 5, 6, 7, 8, 9]listarr:[1, 2, 6, 7, 8, 9]listarr:[1, 9]
20 import
在python用import或者from...import來匯入相應的模組。模組其實就是一些函式和類的集合檔案，它能實現一些相應的功能，當我們需要使用這些功能的時候，直接把相應的模組匯入到我們的程式中，我們就可以使用了。這類似於C語言中的include標頭檔案，Python中我們用import匯入我們需要的模組。
21 try/except/else/finally語句
與其他語言相同，在python中，try/except語句主要是用於處理程式正常執行過程中出現的一些異常情況，如語法錯誤（python作為指令碼語言沒有編譯的環節，在執行過程中對語法進行檢測，出錯後發出異常訊息）、資料除零錯誤、從未定義的變數上取值等；而try/finally語句則主要用於在無論是否發生異常情況，都需要執行一些清理工作的場合，如在通訊過程中，無論通訊是否發生錯誤，都需要在通訊完成或者發生錯誤時關閉網路連線。儘管try/except和try/finally的作用不同，但是在程式設計實踐中通常可以把它們組合在一起使用try/except/else/finally的形式來實現穩定性和靈活性更好的設計。
預設情況下，在程式段的執行過程中，如果沒有提供try/except的處理，指令碼檔案執行過程中所產生的異常訊息會自動傳送給程式呼叫端，如pythonshell，而python shell對異常訊息的預設處理則是終止程式的執行並列印具體的出錯資訊。這也是在python shell中執行程式錯誤後所出現的出錯列印資訊的由來。
python中try/except/else/finally語句的完整格式如下所示：
try:
Normal executionblock
except A:
Exception A handle
except B:
Exception B handle
except:
Other exceptionhandle
else:
if no exception,get here
finally:
print("finally")
說明：
正常執行的程式在try下面的Normal execution block執行塊中執行，在執行過程中如果發生了異常，則中斷當前在Normal execution block中的執行跳轉到對應的異常處理塊中開始執行；
python從第一個except X處開始查詢，如果找到了對應的exception型別則進入其提供的exception handle中進行處理，如果沒有找到則直接進入except塊處進行處理。except塊是可選項，如果沒有提供，該exception將會被提交給python進行預設處理，處理方式則是終止應用程式並列印提示資訊；
如果在Normal execution block執行塊中執行過程中沒有發生任何異常，則在執行完Normal execution block後會進入else執行塊中（如果存在的話）執行。
無論是否發生了異常，只要提供了finally語句，以上try/except/else/finally程式碼塊執行的最後一步總是執行finally所對應的程式碼塊。
需要注意的是：
1.在上面所示的完整語句中try/except/else/finally所出現的順序必須是try-->exceptX-->except-->else-->finally，即所有的except必須在else和finally之前，else（如果有的話）必須在finally之前，而except X必須在except之前。否則會出現語法錯誤。
2.對於上面所展示的try/except完整格式而言，else和finally都是可選的，而不是必須的，但是如果存在的話else必須在finally之前，finally（如果存在的話）必須在整個語句的最後位置。
3.在上面的完整語句中，else語句的存在必須以except X或者except語句為前提，如果在沒有except語句的try block中使用else語句會引發語法錯誤。也就是說else不能與try/finally配合使用。
4.except的使用要非常小心，慎用。
class AError(Exception):
"""AError---exception"""
print('AError')
try:
#raise AError
df(4)
except AError:
print("Get AError")
except:
print("exception")
else:
print("else")
finally:
print("finally")
print("hello wolrd")
執行結果：
AError
exception
finally
hello wolrd
在上面的程式碼中，Normal execution block中出現了語法錯誤，但是由於使用了except語句，該語法錯誤就被掩蓋掉了。因此在使用try/except是最好還是要非常清楚的知道Normal executionblock中有可能出現的異常型別以進行鍼對性的處理。
如果上述函式中不定義class AError(Exception):函式處理異常，那麼函式執行到try中系統將會自動報錯，最後只執行finally中的內容。
22 elif
elif語句可以檢查多個表示式的真值，並執行一個程式碼塊的條件之一計算結果為true。
if...elif語句是可選的。然而不像else，對此可以有最多一個語句，if語句下邊可以有任意數量elif語句。
if...elif語句的語法是：
var = 100
if var == 200:
print "1 - Got atrue expression value"
print var
elif var == 150:
print "2 - Got atrue expression value"
print var
elif var == 100:
print "3 - Got atrue expression value"
print var
else:
print "4 - Got afalse expression value"
print var
print "Good bye!
執行結果：
3 -Got a true expression value
100
Goodbye!
23 in和is
in和is用處不同
in是判斷某個元素是否在集合中
is是判斷二個引數對像id是否相同，可以把物件id理解為指標
例子：
#in 和is
a=[1,2,3]
b=[1,2,3]
c=d=[1,2,3]
print("a is b:%s"%(a is b))
print("a in b:%s"%(a in b))
print("c is d:%s"%(c is d))
print("c in d:%s"%(c in d))
輸出結果：
a is b:False
a in b:False
c is d:True
c in d:False
從上面可以得出 ：首先a和b是分別定義的，即使它們值相同，也會在記憶體中建立二個對像，所以它們的物件id並不同。
其次c和d已經指明，c＝d，因而是同時建立的，所以二者是指向同個資料區的，即物件id相同
這也就是c is d 結果為ture，而a is b結果為false的原因了；而c in d含義是c是d中的一個元素為True，不是為False，很顯然c是一個和d相同的元組。
24 while
迴圈語句 count = 0while (count < 9):
print 'The count is:%d'%count
count = count + 1
print "Good bye!"
執行結果： The count is:0
The count is:1
The count is:2
The count is:3
The count is:4
The count is:5
The count is:6
The count is:7
The count is:8
Good bye!
25 with
1.緊跟with後面的語句被求值後，返回物件的__enter__()方法被呼叫，這個方法的返回值將被賦值給as後面的變數。當with後面的程式碼塊全部被執行完之後，將呼叫前面返回物件的__exit__()方法file = open("foo.txt")
try:
data = file.read()
print data
print"fileopen:",file
finally:
file.close()
print"fileclose:",file
#使用with as
with open("foo.txt") as fd:
data = fd.read()
print data
print"fdopen:",fd
print"fdclose:",fd
執行結果： open txt!
Sucess!
fileopen: <open file 'foo.txt', mode 'r' at 0x0000000002D3C1E0>
fileclose: <closed file 'foo.txt', mode 'r' at 0x0000000002D3C1E0>
open txt!
Sucess!
fdopen: <open file 'foo.txt', mode 'r' at 0x0000000002D3C030>
fdclose: <closed file 'foo.txt', mode 'r' at 0x0000000002D3C030>
從上面的例子可以看出with as開啟檔案處理後能夠自動將檔案關閉，不需要向第一種方法一樣認為close檔案，程式碼優化且穩定了許多。 2.下面是一個隊with工作原理剖析的一個簡單例子 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
執行結果： In__enter__()
sample: Foo
In__exit__()
26 yield
簡單地講，yield 的作用就是把一個函式變成一個 generator，帶有 yield 的函式不再是一個普通函式，Python 直譯器會將其視為一個 generator，呼叫 fab(5) 不會執行 fab 函式，而是返回一個 iterable 物件！在 for 迴圈執行時，每次迴圈都會執行 fab 函式內部的程式碼，執行到 yield b 時，fab 函式就返回一個迭代值，下次迭代時，程式碼從 yield b 的下一條語句繼續執行，而函式的本地變數看起來和上次中斷執行前是完全一樣的，於是函式繼續執行，直到再次遇到 yield。下面例子可以看出，實質上迭代器每次將b的值付給了n #yield
n=0
def fab(max):
i, a, b = 0, 0, 1
while i < max:
yield b #每次執行到此處都會將值
a, b = b, a + b
#print"b:",b
i = i+1
for n in fab(7):
print "n:",n;
執行結果： n: 1
n: 1
n: 2
n: 3
n: 5
n: 8
n: 13
也可以手動呼叫 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() 的值，不僅程式碼簡潔，而且執行流程異常清晰。
如何判斷一個函式是否是一個特殊的 generator 函式？可以利用 isgeneratorfunction 判斷：
#迭代器
from inspect import isgeneratorfunction
print isgeneratorfunction(fab)
執行結果：
True
歡迎提出問題，指出不足，一起學習一起進步！