Python學習隨筆（1）之Python簡介

Python語法詞彙和語法約定

運行python

Python程序是有解析器來執行的，解析器啓動後將會出現一個命令提示，在此能夠開始程序輸入，進入簡單的讀入-求值循環。

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

Python的交互式模式是最有用的功能之一，以交互方式使用時，特殊變量_用於保存最後一次運行的結果，此變量只在交互模式下才有定義

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

Python源文件是普通的文本文件，後綴一般是.py，字符#表示整行都是註釋。在命令行中執行python文件，會啓動解析器，並在控制窗口運行程序

>python test.py
Hello World

變量和算數表達式

python是一種動態類型的雲煙，在執行過程當中，可將變量名稱綁定到不一樣的值，並且這些值能夠屬於不一樣的類型。賦值運算法的做用僅僅是在名稱和值之間建立一種關聯，儘管每種值都有一種類型，可是變量名稱是無類型的。例如

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

a的初始值是整型，但最後的結果是浮點型，這裏不是a的類型改變了，而是a引用的值的類型變了。

一條語句的結束能夠經過換行或者一行上使用分號來間隔開來。

while語句的對隨後的表達式進行測試，而後決定是否執行主體，主體是由縮進來表示的，Python不會指定縮進量，只要在一個代碼塊中保持一致就能夠了，最多見是使用4個空格。

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

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

格式化字符串包含比普通文本和特殊的格式化字符串序列，如「%d「、 」%s」和「%f」用於指定特定整型、字符串型、或浮點型數。特殊的字符包括用於指定寬度和精度的修飾符，如「%3d」將一個整數格式化爲在一個寬度爲3的列中右對齊，而「%.2f」將一個浮點型格式化爲小數點後出現兩位數字。也能夠利用format()函數單獨格式化每部分

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.01
In [25]: print "{1:.3f} {0:.2f}".format(a, b)
1.010 1.20

條件語句

if與else語句能夠進行簡單的測試，測試條件返回結果都是True或False

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

主體用縮進表示，else子句是可選的，pass表示佔位，空子句。使用不二類型的表達式or，and，not

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

上面的反斜槓\表示鏈接下一行的代碼，當一行代碼太長時，可利用行尾添加 Python沒有專門的switch和case語句，當有多個測試用例時，可使用elif

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

文件輸入和輸出

打開並讀取文件內容

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

上述代碼中第一行是進行編碼聲明，識別程序中的中文，注意的是聲明必須與文件保存時用到的編碼一致，不然很大機率會出現代碼解析異常，如今的IDE通常會自動處理這種狀況，可是文本編輯器就要當心。

open打開一個新的文件對象，調用該對象的方法readline()讀取文件一行，包括換行符，讀到文件結尾時返回空字符串。
若是程序在這樣的數據集中進行循環，那麼一般就稱爲迭代，可用專門的for語句來執行

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

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

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

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

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

若是想讀取控制檯輸入，則

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

在Python2中可使用

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

字符串

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

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

單引號和雙引號必須在一個邏輯行上，而三引號能夠之間的內容都屬於字符串，能夠出如今多行。

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

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

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

使用切片運算符能夠獲取子字符串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不會將字符串的值解析爲數值，+表示鏈接兩個字符串

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

可使用int()或者float()函數將字符串轉換爲數值

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

使用str()和repr()能夠將數值轉化爲字符串

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

format()函數能夠利用特定的格式將值轉化爲字符串

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

列表

列表是任意對象的序列，列表的創建以下

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

使用索引一樣能夠獲取列表中的值，其餘的列表操做方法還有，追加append()，插入insert()，切片，鏈接+

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

建立空列表

In [36]: li = []
In [37]: li
Out[37]: []
In [38]: li = list()
In [39]: li
Out[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

元組

要建立簡單的數據結構，可使用元組將一組值打包到應對象中

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

沒有括號的狀況下也能夠識別元組

In [7]: d = a, b
In [8]: d
Out[8]: (1, 'you')

0元組和1元組的定義

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

和列表同樣，元組也可使用數字索引來提取值，但更經常使用的作法是分解元組

In [14]: a, b = c
In [15]: a
Out[15]: 1
In [16]: b
Out[16]: 'you'

元組和列表很類似，元組建立後不能修改器內容，將其當作由多個部分組成的對象。在建立列表時，系統會爲列表分配多一些內存，以優化添加新項時的操做性能。而元組是不變的，因此會更加緊密，節約更多內存空間。

# coding: UTF-8
po = []
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)

集合

集合用於建立一組無序的對象，於列表和元組不一樣，集合是無序的，也沒法經過數字進行索引，而且元素不能重複，即具備咱們在數學中所學的集合的性質。

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

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

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

集合操做包括並集、交集、差集、對稱集

In [28]: a
Out[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'}

字典

字典就是關聯數組或散列表，其中包含經過關鍵字索引的對象

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

建立一個字典，而且使用關鍵字進行索引並修改。除了使用字符串做爲關鍵字，還可使用數值和元組，可是其餘的對象如列表和字典就不能夠，由於它們的內容能夠發生變化。
建立空字典

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

使用in能夠測試某個內容是否在字典成員

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

將字典關鍵字轉化爲列表，或刪除字典元素

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

字典是Python解析器中最完善的數據類型，所以，若是隻是在字典中存儲或處理數據，使用字典比使用一些自定義的數據結構好不少。

迭代於循環

最多見的迭代形式是循環一個序列（字符串、列表或元組）的全部成員

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 2
2 time the 2 is 4
2 time the 3 is 6
2 time the 4 is 8
2 time the 5 is 10

在整數範圍內的執行循環很常見，使用range(i, j, [,step])建立對象i到j-1的整數，若是起始值被忽略，默認從0開始，第三個數爲增加步長

In [60]: for i in range(10):
   ....:     print i,
   ....:
0 1 2 3 4 5 6 7 8 9
In [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中，它建立的值是已經用整數值徹底填滿列表，當範圍很大時，極可能會消耗掉全部的內存，因此使用xrange比較安全，函數建立的對象根據須要計算它所表示的值。在Python 3中，xrange()已經改名爲range。

for語句還能夠起處理其餘的各類對象，包括字符串、列表。字典和文件。

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

函數

使用def能夠建立函數

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

return返回值，調用函數時，使用函數名和參數便可，當想返回多個參數時，可使用元組

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

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

函數定義還能夠提供缺省參數

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

在函數中的變量是局部變量，當函數執行完後馬上銷燬，若是想在函數內部修改某個全局變量的值，可使用global語句

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

生成器

使用yield語句可讓函數生成一個結果序列，而不只僅是一個值

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]: 3
In [107]: c.next()
Out[107]: 3
In [108]: c.next()
Out[108]: 2
In [109]: c.next()
Out[109]: 1
In [110]: c.next()
Out[110]: 1

任何使用yield的函數都稱爲生成器，調用生成器函數將建立一個對象，讓該函數連續調用next()方法生成結果序列，每次調用都會運行到下一條yield語句爲止，此過程知道函數接結束。一般不會手動調用next()，而是使用一個for循環

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

生成器的絕妙之處在於，它常常和其餘可迭代對象混合在一塊兒，特別是在辨析如for item in s這樣的語句時，s能夠表示項目的列表、文件個各行、生成器函數的結果，或者能夠支持迭代的其餘任何對象。可以在s中插入不一樣對象，這在建立可擴展的程序時能夠發揮巨大的做用。

協程

函數運行時要用一組輸入參數，可是也能夠把函數編寫成一個任務，從而能處理髮送給它的一系列輸入，這類函數稱爲協程。使用（yield）形式建立協程

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 python
In [8]: matcher.send("Hello world")
In [9]: matcher.send("python is cool")
python is cool
In [10]: matcher.close()

使用send來爲協程發送某個值，（yield）表達式返回接收到的值，而後繼續運行到遇到下一個（yield），函數暫停。

對象和類

程序中使用的全部的值都是對象，對象由內部數據和各類方法組成，方法能夠操做數據。dir（）函數能夠列出對象可用的方法，是進行交互式試驗的有用工具

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

在面向對象的編程中，class語句用於定義新的對象類型，以下面類定義

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來定義方法，每一個方法的第一個參數始終指向類自己，該參數使用名稱self。涉及對象屬性的全部操做都必須顯示地引用self變量。__init__用於初始化建立的對象。

s = Stack()     #建立一個棧對象
s.push("li")    #調用方法
s.push(22)
x = s.pop()
del s           #刪除對象

一般類中定義的方法只用於該類的實例（對象），可是也能夠定義不一樣種類的方法，如

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

上面的例子使用@staticmethod聲明靜態方法，類也能夠直接調用。

異常

若是程序出現錯誤，就會引起異常，並顯示追蹤信息，如：

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

可使用異常處理機制

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

當執行時，出現如下信息，捕獲異常後，能夠對異常進行處理

>python test.py
integer division or modulo by zero
my info: error for divide zero

模塊

當程序很大時，爲便於維護，須要將它分爲多個文件。可將相關語句和定義放入與模塊同名的文件中（後綴爲.py）

# file: test.py
def fun():
    pass

文件後綴爲py的文件，要在其餘程序中使用該模塊，可使用import將模塊導入

import test

import語句建立了一個新命名空間，並在該命名空間中執行與py文件祥光的語句。要在導入後訪問命名空間的內容，只要使用該模塊做爲前綴，如test.fun，若是想使用不一樣的名稱導入模塊，能夠在導入時添加限定符

import test as foo
foo.fun()

若是將須要的定義導入，能夠

from test import fun
fun()

要把模塊的全部內容都導入當前命名空間，能夠

from test import *
fun()

利用dir()能夠列出模塊的內容，是交互式工具。

得到幫助

使用Python時，可使用help( )命令來獲取幫助，如help('模塊名')則能夠獲取模塊的信息，或help('函數名')能夠獲取該函數的詳細信息。每一個函數也都有本身的文檔說明，能夠直接打印__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 strings
If called without an argument, return the names in the current scope.
Else, 。。。。
In [17]: