Python語法詞匯和語法約定

運(yùn)行python

Python程序是有解析器來執(zhí)行的，解析器啟動后將會出現(xiàn)一個命令提示，在此可以開始程序輸入，進(jìn)入簡單的讀入-求值循環(huán)。

In [1]: PRint "Hellow World"Hellow World

Python的交互式模式是最有用的功能之一，以交互方式使用時，特殊變量_用于保存最后一次運(yùn)行的結(jié)果，此變量只在交互模式下才有定義

In [2]: 1+2Out[2]: 3In [3]: _+2Out[3]: 5

Python源文件是普通的文本文件，后綴通常是.py，字符#表示整行都是注釋。在命令行中執(zhí)行python文件，會啟動解析器，并在控制窗口運(yùn)行程序

>python test.pyHello World

變量和算數(shù)表達(dá)式

python是一種動態(tài)類型的云煙，在執(zhí)行過程中，可將變量名稱綁定到不同的值，而且這些值可以屬于不同的類型。賦值運(yùn)算法的作用僅僅是在名稱和值之間創(chuàng)建一種關(guān)聯(lián)，盡管每種值都有一種類型，但是變量名稱是無類型的。例如

In [2]: a = 1In [3]: b = 0.1In [4]: a = a * (a + b)In [5]: aOut[5]: 1.1

a的初始值是整型，但最后的結(jié)果是浮點型，這里不是a的類型改變了，而是a引用的值的類型變了。

一條語句的結(jié)束可以通過換行或者一行上使用分號來間隔開來。

while語句的對隨后的表達(dá)式進(jìn)行測試，然后決定是否執(zhí)行主體，主體是由縮進(jìn)來表示的，Python不會指定縮進(jìn)量，只要在一個代碼塊中保持一致就可以了，最常見是使用4個空格。

在程序輸出時，可利用字符串格式化運(yùn)算符%控制對齊

In [6]: a = 1.2In [7]: b = 1.01In [8]: print "%.2f %.2f" % (a, b)1.20 1.01

格式化字符串包含比普通文本和特殊的格式化字符串序列，如“%d“、 ”%s”和“%f”用于指定特定整型、字符串型、或浮點型數(shù)。特殊的字符包括用于指定寬度和精度的修飾符，如“%3d”將一個整數(shù)格式化為在一個寬度為3的列中右對齊，而“%.2f”將一個浮點型格式化為小數(shù)點后出現(xiàn)兩位數(shù)字。也可以利用format()函數(shù)單獨(dú)格式化每部分

In [16]: print format(a, ".3f"),format(b, ".2f")1.200 1.01

format方法還可以用于一次格式化多個值

In [24]: print "{0:.3f} {1:.2f}".format(a, b)1.200 1.01In [25]: print "{1:.3f} {0:.2f}".format(a, b)1.010 1.20

條件語句

if與else語句可以進(jìn)行簡單的測試，測試條件返回結(jié)果都是True或False

if a<b:	print "a<b"else:	pass

主體用縮進(jìn)表示，else子句是可選的，pass表示占位，空子句。使用不二類型的表達(dá)式or，and，not

if a < b and c=="1" and /(age>4 or grade >90):	print "a<b"else:	pass

上面的反斜杠/表示連接下一行的代碼，當(dāng)一行代碼太長時，可利用行尾添加/
Python沒有專門的switch和case語句，當(dāng)有多個測試用例時，可以使用elif

if a < b:	print "a<b"elif a==b:	passelse:	pass

文件輸入和輸出

打開并讀取文件內(nèi)容

# coding: UTF-8file = open("link.txt")line = file.readline()while line:	print line, #后面跟的','表示忽略換行符	#print(line, end = '')	line = file.readline()file.close()

上述代碼中第一行是進(jìn)行編碼聲明，識別程序中的中文，注意的是聲明必須與文件保存時用到的編碼一致，否則很大概率會出現(xiàn)代碼解析異常，現(xiàn)在的IDE一般會自動處理這種情況，但是文本編輯器就要小心。

open打開一個新的文件對象，調(diào)用該對象的方法readline()讀取文件一行，包括換行符，讀到文件結(jié)尾時返回空字符串。
如果程序在這樣的數(shù)據(jù)集中進(jìn)行循環(huán)，那么通常就稱為迭代，可用專門的for語句來執(zhí)行

for line in open("link.txt"):	print line,

另外，print>>可以指定一個文件，將輸出到文件中，使用'w'寫方式打開文件

file = open("link.txt",'w')print >>file, 'hello'

該語法只能在Python2中使用，也可以使用文件對象函數(shù)write()方法

file = open("link.txt",'w')file.write('hello')

如果想讀取控制臺輸入，則

# coding: UTF-8import syssys.stdout.write("Enter your name:")name = sys.stdin.readline()

在Python2中可以使用

# coding: UTF-8name = raw_input("Enter your name:")

字符串

字符串可以有三種表示方法，單引號、雙引號、三引號

a = 'Hello'b = "Li"c = """ny"""

單引號和雙引號必須在一個邏輯行上，而三引號可以之間的內(nèi)容都屬于字符串，可以出現(xiàn)在多行。

In [1]: print """hello   ...: world"""helloworld

字符串存儲在一個以0開始，使用整數(shù)索引的字符序列總，可以使用索引運(yùn)算符來獲取其中的一個字符

In [5]: a = "Hello world"In [6]: a[4]Out[6]: 'o'

使用切片運(yùn)算符可以獲取子字符串s[i:j]

In [6]: a[4]Out[6]: 'o'In [7]: a[:3]Out[7]: 'Hel'In [8]: a[6:]Out[8]: 'world'In [9]: a[2:7]Out[9]: 'llo w'

使用+可以連接兩個字符串

In [11]: a + " li"Out[11]: 'Hello world li'

Python不會將字符串的值解析為數(shù)值，+表示連接兩個字符串

In [12]: b = "1"In [13]: c = "2"In [14]: b + cOut[14]: '12'

可以使用int()或者float()函數(shù)將字符串轉(zhuǎn)換為數(shù)值

In [15]: int(b) + int(c)Out[15]: 3

使用str()和repr()可以將數(shù)值轉(zhuǎn)化為字符串

In [19]: i = 1.2In [20]: str(i)Out[20]: '1.2'In [21]: repr(i)Out[21]: '1.2'

format()函數(shù)可以利用特定的格式將值轉(zhuǎn)化為字符串

In [25]: format(i, ".5f")Out[25]: '1.20000'

列表

列表是任意對象的序列，列表的建立如下

In [26]: li = ["ya", "nan", "li"]In [27]: liOut[27]: ['ya', 'nan', 'li']In [28]: li[2]Out[28]: 'li'

使用索引同樣可以獲取列表中的值，其他的列表操作方法還有，追加append()，插入insert()，切片，連接+

In [29]: li.append("i")In [30]: liOut[30]: ['ya', 'nan', 'li', 'i']In [31]: li.insert(3,'lv')In [32]: liOut[32]: ['ya', 'nan', 'li', 'lv', 'i']In [34]: a = [1, 2] + [3, 4]In [35]: aOut[35]: [1, 2, 3, 4]

創(chuàng)建空列表

In [36]: li = []In [37]: liOut[37]: []In [38]: li = list()In [39]: liOut[39]: []

列表可以包含任意種類的python對象，嵌套列表需要多層索引才可以訪問

In [40]: a = [1, 'i', [2, 'li', 'yn', [2, 3]], 4]In [41]: a[2]Out[41]: [2, 'li', 'yn', [2, 3]]In [42]: a[2][3]Out[42]: [2, 3]In [43]: a[2][3][1]Out[43]: 3

元組

要創(chuàng)建簡單的數(shù)據(jù)結(jié)構(gòu)，可以使用元組將一組值打包到應(yīng)對象中

In [1]: a = 1In [2]: b = "you"In [3]: c = (a, b)In [4]: cOut[4]: (1, 'you')

沒有括號的情況下也可以識別元組

In [7]: d = a, bIn [8]: dOut[8]: (1, 'you')

0元組和1元組的定義

In [10]: c = () In [11]: d = (a,)In [12]: e = a,

和列表一樣，元組也可以使用數(shù)字索引來提取值，但更常用的做法是分解元組

In [14]: a, b = cIn [15]: aOut[15]: 1In [16]: bOut[16]: 'you'

元組和列表很相似，元組創(chuàng)建后不能修改器內(nèi)容，將其看成由多個部分組成的對象。在創(chuàng)建列表時，系統(tǒng)會為列表分配多一些內(nèi)存，以優(yōu)化添加新項時的操作性能。而元組是不變的，所以會更加緊密，節(jié)約更多內(nèi)存空間。

# coding: UTF-8po = []for line in open("link.csv"):	field = line.split(",")	name = field[0]	age = field[1]	sex = field[2]	node = (field, age, sex)	po.append(node)

集合

集合用于創(chuàng)建一組無序的對象，于列表和元組不同，集合是無序的，也無法通過數(shù)字進(jìn)行索引，并且元素不能重復(fù)，即具有我們在數(shù)學(xué)中所學(xué)的集合的性質(zhì)。

In [23]: a = set("Hello")In [24]: aOut[24]: {'H', 'e', 'l', 'o'} #只有一個l

私用add（）添加一項和update（）可以在集合中添加多項

In [25]: a.add('y')In [26]: aOut[26]: {'H', 'e', 'l', 'o', 'y'}In [27]: a.update([1,4])In [28]: aOut[28]: {1, 4, 'H', 'e', 'l', 'o', 'y'}

集合操作包括并集、交集、差集、對稱集

In [28]: aOut[28]: {1, 4, 'H', 'e', 'l', 'o', 'y'}In [29]: b = set([1,4,5,6])In [30]: a|b #并集Out[30]: {1, 4, 5, 6, 'H', 'e', 'l', 'o', 'y'}In [31]: a&b #交集Out[31]: {1, 4}In [32]: a-b #差集Out[32]: {'H', 'e', 'l', 'o', 'y'}In [33]: a^b #對稱差集Out[33]: {5, 6, 'H', 'e', 'l', 'o', 'y'}

字典

字典就是關(guān)聯(lián)數(shù)組或散列表，其中包含通過關(guān)鍵字索引的對象

In [36]: po = {   ....:     "name" : "li",   ....:     "age" : 23,   ....:     "sex" : "female"   ....: }In [37]: po["name"]Out[37]: 'li'In [38]: po["age"]Out[38]: 23In [39]: po["age"] = 24In [40]: po["age"]Out[40]: 24

創(chuàng)建一個字典，并且使用關(guān)鍵字進(jìn)行索引并修改。除了使用字符串作為關(guān)鍵字，還可以使用數(shù)值和元組，但是其他的對象如列表和字典就不可以，因為它們的內(nèi)容可以發(fā)生變化。
創(chuàng)建空字典

In [44]: a = {}In [45]: a = dict()

使用in可以測試某個內(nèi)容是否在字典成員

In [46]: if "age" in po:   ....:     a = po["age"]   ....: else:   ....:     a = 0   ....:In [47]: aOut[47]: 24In [48]: age = po.get("age", 0) #簡寫形式In [49]: ageOut[49]: 24

將字典關(guān)鍵字轉(zhuǎn)化為列表，或刪除字典元素

In [50]: l = list(po)In [51]: lOut[51]: ['age', 'name', 'sex']In [52]: del po["age"]In [53]: poOut[53]: {'name': 'li', 'sex': 'female'}

字典是Python解析器中最完善的數(shù)據(jù)類型，因此，如果只是在字典中存儲或處理數(shù)據(jù)，使用字典比使用一些自定義的數(shù)據(jù)結(jié)構(gòu)好很多。

迭代于循環(huán)

最常見的迭代形式是循環(huán)一個序列（字符串、列表或元組）的所有成員

In [54]: for n in [1,2,3,4,5]:   ....:     print "2 time the %d is %d" % (n, 2*n)   ....:2 time the 1 is 22 time the 2 is 42 time the 3 is 62 time the 4 is 82 time the 5 is 10

在整數(shù)范圍內(nèi)的執(zhí)行循環(huán)很常見，使用range(i, j, [,step])創(chuàng)建對象i到j(luò)-1的整數(shù)，如果起始值被忽略，默認(rèn)從0開始，第三個數(shù)為增長步長

In [60]: for i in range(10):   ....:     print i,   ....:0 1 2 3 4 5 6 7 8 9In [61]: range(1,10,2)Out[61]: [1, 3, 5, 7, 9]In [62]: range(8,1,-1)Out[62]: [8, 7, 6, 5, 4, 3, 2]

使用range時，Python 2中，它創(chuàng)建的值是已經(jīng)用整數(shù)值完全填滿列表，當(dāng)范圍很大時，很可能會消耗掉所有的內(nèi)存，所以使用xrange比較安全，函數(shù)創(chuàng)建的對象根據(jù)需要計算它所表示的值。在Python 3中，xrange()已經(jīng)更名為range。

for語句還可以起處理其他的各種對象，包括字符串、列表。字典和文件。

In [65]: s = "Hello world"In [66]: for i in s:   ....:     print i,   ....:H e l l o   w o r l dIn [67]: b = ["li", "ya"]In [68]: for i in b:   ....:     print i,   ....:li yaIn [69]: c = {"name":"li", "age":23}In [70]: for i in c:   ....:     print i, c[i],   ....:age 23 name li

函數(shù)

使用def可以創(chuàng)建函數(shù)

In [72]: def fun(a, b):   ....:     c = a + b   ....:     return c   ....: fun(1, 2)   ....:Out[72]: 3

return返回值，調(diào)用函數(shù)時，使用函數(shù)名和參數(shù)即可，當(dāng)想返回多個參數(shù)時，可以使用元組

In [73]: def fun(a, b):   ....:     c = a + b   ....:     d = a * b   ....:     return (c,d)   ....: x, y = fun(4,3)   ....: print x,y   ....:7 12

也可以直接使用一個對象來接收返回的元組。

函數(shù)定義還可以提供缺省參數(shù)

In [77]: def fun(a, b = 2):   ....:     return a*b   ....: fun(3)   ....:Out[77]: 6

在函數(shù)中的變量是局部變量，當(dāng)函數(shù)執(zhí)行完后立刻銷毀，如果想在函數(shù)內(nèi)部修改某個全局變量的值，可以使用global語句

In [83]: a = 0In [84]: def fun():   ....:     a = 1   ....:In [85]: fun()In [86]: aOut[86]: 0In [87]: def fun():   ....:     global a   ....:     a = 1   ....:In [88]: fun()In [89]: aOut[89]: 1

生成器

使用yield語句可以讓函數(shù)生成一個結(jié)果序列，而不僅僅是一個值

In [104]: def fun(n):   .....:     while n > 0:   .....:         if n %2 ==1:   .....:             yield n   .....:         yield n   .....:         n -= 1   .....:In [105]: c = fun(3)In [106]: c.next()Out[106]: 3In [107]: c.next()Out[107]: 3In [108]: c.next()Out[108]: 2In [109]: c.next()Out[109]: 1In [110]: c.next()Out[110]: 1

任何使用yield的函數(shù)都稱為生成器，調(diào)用生成器函數(shù)將創(chuàng)建一個對象，讓該函數(shù)連續(xù)調(diào)用next()方法生成結(jié)果序列，每次調(diào)用都會運(yùn)行到下一條yield語句為止，此過程知道函數(shù)接結(jié)束。通常不會手動調(diào)用next()，而是使用一個for循環(huán)

In [112]: for i in fun(3):   .....:     print i,   .....:3 3 2 1 1

生成器的絕妙之處在于，它經(jīng)常和其他可迭代對象混合在一起，特別是在辨析如for item in s這樣的語句時，s可以表示項目的列表、文件個各行、生成器函數(shù)的結(jié)果，或者可以支持迭代的其他任何對象。能夠在s中插入不同對象，這在創(chuàng)建可擴(kuò)展的程序時可以發(fā)揮巨大的作用。

協(xié)程

函數(shù)運(yùn)行時要用一組輸入?yún)?shù)，但是也可以把函數(shù)編寫成一個任務(wù)，從而能處理發(fā)送給它的一系列輸入，這類函數(shù)稱為協(xié)程。使用（yield）形式創(chuàng)建協(xié)程

In [5]: def print_match(m):   ...:     print "looking for",m   ...:     while True:   ...:         line = (yield)   ...:         if m in line:   ...:             print line   ...:In [6]: matcher = print_match("python")In [7]: matcher.next()looking for pythonIn [8]: matcher.send("Hello world")In [9]: matcher.send("python is cool")python is coolIn [10]: matcher.close() 

使用send來為協(xié)程發(fā)送某個值，（yield）表達(dá)式返回接收到的值，然后繼續(xù)運(yùn)行到遇到下一個（yield），函數(shù)暫停。

對象和類

程序中使用的所有的值都是對象，對象由內(nèi)部數(shù)據(jù)和各種方法組成，方法可以操作數(shù)據(jù)。dir（）函數(shù)可以列出對象可用的方法，是進(jìn)行交互式試驗的有用工具

In [11]: item = [2, 4]In [12]: dir(item)Out[12]:['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__',……

在面向?qū)ο蟮木幊讨校琧lass語句用于定義新的對象類型，如下面類定義

class Stack(object):	"""docstring for Stack"""	def __init__(self):		self.stack = []	def push(self, object):		self.stack.append(object)	def pop(self):		return self.stack.pop()	def length(self):		return len(self.stack)

類定義的第一行中聲明一個類，使用圓括號是Python指定的繼承方式，定義的類Stack繼承object，object也是所有Python類型的根類型。類中使用def來定義方法，每個方法的第一個參數(shù)始終指向類本身，該參數(shù)使用名稱self。涉及對象屬性的所有操作都必須顯示地引用self變量。init用于初始化創(chuàng)建的對象。

s = Stack()		#創(chuàng)建一個棧對象s.push("li")	#調(diào)用方法s.push(22)x = s.pop()del s 			#刪除對象

通常類中定義的方法只用于該類的實例（對象），但是也可以定義不同種類的方法，如

class Handler(object):	@staticmethod	def display():		....Handler.display()

，類也可以直接調(diào)用。

異常

如果程序出現(xiàn)錯誤，就會引發(fā)異常，并顯示追蹤信息，如：

In [20]: a---------------------------------------------------------------------------NameError                                 Traceback (most recent call last)<ipython-input-20-60b725f10c9c> in <module>()----> 1 aNameError: name 'a' is not definedIn [21]:

可以使用異常處理機(jī)制

try:	1/0;except Exception, e:	print e	print "my info: error for divide zero"

當(dāng)執(zhí)行時，出現(xiàn)以下信息，捕獲異常后，可以對異常進(jìn)行處理

>python test.pyinteger division or modulo by zeromy info: error for divide zero

模塊

當(dāng)程序很大時，為便于維護(hù)，需要將它分為多個文件。可將相關(guān)語句和定義放入與模塊同名的文件中（后綴為.py）

# file: test.pydef fun():	pass

文件后綴為py的文件，要在其他程序中使用該模塊，可以使用import將模塊導(dǎo)入

import test

import語句創(chuàng)建了一個新命名空間，并在該命名空間中執(zhí)行與py文件祥光的語句。要在導(dǎo)入后訪問命名空間的內(nèi)容，只要使用該模塊作為前綴，如test.fun，如果想使用不同的名稱導(dǎo)入模塊，可以在導(dǎo)入時添加限定符

import test as foofoo.fun()

如果將需要的定義導(dǎo)入，可以

from test import funfun()

要把模塊的所有內(nèi)容都導(dǎo)入當(dāng)前命名空間，可以

from test import *fun()

利用dir()可以列出模塊的內(nèi)容，是交互式工具。

獲得幫助

使用Python時，可以使用help( )命令來獲取幫助，如help('模塊名')則可以獲取模塊的信息，或help('函數(shù)名')可以獲取該函數(shù)的詳細(xì)信息。每個函數(shù)也都有自己的文檔說明，可以直接打印__doc__屬性

In [15]: help('dir')Help on built-in function dir in module __builtin__:dir(...)    dir([object]) -> list of strings    If called without an argument, return the names in the current scope.。。。。In [16]: print dir.__doc__dir([object]) -> list of stringsIf called without an argument, return the names in the current scope.Else, 。。。。In [17]: