摘要：是回調函數，當鏈接服務器和相應數據傳輸完畢時觸發本函數可選。僅僅是針對的，在中，已經沒有這個模塊了，取代它的是。由于以流式讀取文件，從而速度較快，切少占用內存，但是操作上稍復雜，需要用戶實現回調函數。

模塊就是一個擴展名為.py的Python程序。

#!/usr/bin/env python
# coding=utf-8

lang = "python"

>>> import sys
>>> sys.path.append("~/Documents/VBS/StartLearningPython/2code/pm.py")
>>> import pm
>>> pm.lang
"python"

當Python解釋器讀取了.py文件，先將它變成由字節碼組成的.pyc文件，然后這個.pyc文件交給一個叫做Python虛擬機的東西去運行（那些號稱編譯型的語言也是這個流程，不同的是它們先有一個明顯的編譯過程，編譯好了之后再運行）。如果.py文件修改了，Python解釋器會重新編譯，只是這個編譯過程不是完全顯示給你看的。

我這里說的比較籠統，要深入了解Python程序的執行過程，可以閱讀這篇文章：說說Python程序的執行過程

有了.pyc文件后，每次運行就不需要重新讓解釋器來編譯.py文件了，除非.py文件修改了。這樣，Python運行的就是那個編譯好了的.pyc文件。

如果要作為程序執行，則__name__ == "__main__"；如果作為模塊引入，則pm.__name__ == "pm"，即屬性__name__的值是模塊名稱。

>>> import sys
>>> import pprint
>>> pprint.pprint(sys.path)  #查看所有模塊的位置

    # /usr/bin/env python
    # coding:utf-8

    __all__ = ["_private_variable", "public_teacher"]

    public_variable = "Hello, I am a public variable."
    _private_variable = "Hi, I am a private variable."

    def public_teacher():
        print "I am a public teacher, I am from JP."    #Python 3: print("I am a public teacher, I am from JP.")

    def _private_teacher():
        print "I am a private teacher, I am from CN."    #Python 3:  print("I am a private teacher, I am from CN.")

__all__屬性以及相應的值，在__all__屬性列表中包含了一個私有變量的名字和一個函數的名字。這是在告訴引用本模塊的解釋器，這兩個東西是有權限被訪問的，而且只有這兩個東西。

包或者庫，應該是比“模塊”大的。也的確如此，一般來講，一個“包”里面會有多個模塊，當然，“庫”是一個更大的概念了，比如Python標準庫中的每個庫都有好多個包，每個包都有若干個模塊。

一個包是由多個模塊組成，即多個.py的文件，那么這個所謂“包”也就是我們熟悉的一個目錄罷了。現在就需要解決如何引用某個目錄中的模塊問題了。解決方法就是在該目錄中放一個__init__.py文件。__init__.py是一個空文件，將它放在某個目錄中，就可以將該目錄中的其它.py文件作為模塊被引用。

在Python被安裝的時候，就有不少模塊也隨著安裝到本地的計算機上了。這些東西就如同“能源”、“電力”一樣，讓Python擁有了無限生機，能夠非常輕而易舉地免費使用很多模塊。所以，稱之為“自帶電池”。

那些在安裝Python時就默認已經安裝好的模塊被統稱為“標準庫”。

import pprint #引入模塊

from pprint import pprint #引入該模塊下的方法

from pprint import * #引入該模塊下的所有方法

import pprint as pr #重命名模塊

from pprint import pprint as pt  #重命名方法

dir(),查看對象的屬性和方法

help()查看對象的含義

print pprint.__doc__  #查看文檔
print pprint.__file__ #查看模塊的位置，根據這個位置查到源代碼

sys.argv是專門用來向python解釋器傳遞參數，名曰“命令行參數”。

    $ python --version # --veriosn就是命令行參數
    Python 2.7.6

退出當前程序.

在大多數函數中會用到return，其含義是終止當前的函數，并向調用函數的位置返回相應值（如果沒有就是None）。但是sys.exit()的含義是退出當前程序——不僅僅是函數，并發起SystemExit異常。這就是兩者的區別了。

如果使用sys.exit(0)表示正常退出。若需要在退出的時候有一個對人友好的提示，可以用sys.exit("I wet out at here.")，那么字符串信息就被打印出來。

與Python中的函數功能對照，sys.stdin獲得輸入（等價于Python 2中的raw_input()，Python 3中的input()），sys.stdout負責輸出。

    >>> f = open("stdout.md", "w")
    >>> sys.stdout = f  #重定向到文件
    >>> print "Learn Python: From Beginner to Master"        #Python 3: print("Learn Python: From Beginner to Master")
    >>> f.close()

import copy
copy.copy() #淺拷貝
copy.deepcopy() #深拷貝

import os
os.rename("22201.py", "newtemp.py") #重命名文件
os.remove("123.txt") #刪除一個文件，不能是目錄

os.listdir：顯示目錄中的內容（包括文件和子目錄）
os.getcwd：獲取當前工作目錄；
os.pardir:獲得上一級目錄
os.chdir：改變當前工作目錄
os.makedirs, os.removedirs：創建和刪除目錄

os.stat(p)顯示文件或目錄的屬性
os.chmod()改變權限

os模塊中提供了這樣的方法，許可程序員在Python程序中使用操作系統的命令。

    >>> p
    "/home/qw/Documents/VBS/StarterLearningPython"
    >>> command = "ls " + p #命令復制給Command變量
    >>> command
    >>> os.system(command) #執行命令

需要注意的是，os.system()是在當前進程中執行命令，直到它執行結束。如果需要一個新的進程，可以使用os.exec或者os.execvp。對此有興趣詳細了解的讀者，可以查看幫助文檔了解。另外，os.system()是通過shell執行命令，執行結束后將控制權返回到原來的進程，但是os.exec()及相關的函數，則在執行后不將控制權返回到原繼承，從而使Python失去控制。

#!/usr/bin/env python
# coding=utf-8

import webbrowser
webbrowser.open("http://www.baidu.com") #跨平臺打開瀏覽器

    >>> import heapq
    >>> heapq.__all__
    ["heappush", "heappop", "heapify", "heapreplace", "merge", "nlargest", "nsmallest", "heappushpop"]

heappush(heap, x)：將x壓入堆heap

    >>> import heapq
    >>> heap = []    
    >>> heapq.heappush(heap, 3)
    >>> heapq.heappush(heap, 9)
    >>> heapq.heappush(heap, 2)
    >>> heapq.heappush(heap, 4)
    >>> heapq.heappush(heap, 0)
    >>> heapq.heappush(heap, 8)
    >>> heap
    [0, 2, 3, 9, 4, 8]

heappop(heap)：刪除最小元素

    >>> heapq.heappop(heap)
    0
    >>> heap
    [2, 4, 3, 9, 8]

heapify()：將列表轉換為堆

    >>> hl = [2, 4, 6, 8, 9, 0, 1, 5, 3]
    >>> heapq.heapify(hl)
    >>> hl
    [0, 3, 1, 4, 9, 6, 2, 5, 8]

heapreplace()是heappop()和heappush()的聯合，也就是刪除一個，同時加入一個

    >>> heap
    [2, 4, 3, 9, 8]
    >>> heapq.heapreplace(heap, 3.14)
    2
    >>> heap
    [3, 4, 3.14, 9, 8]

>>> qlst.append(5)        #從右邊增加
>>> qlst
deque([1, 2, 3, 4, 5])
>>> qlst.appendleft(7)    #從左邊增加
>>> qlst
deque([7, 1, 2, 3, 4, 5])
    
>>> qlst.pop() #右邊刪除一個元素
5
>>> qlst
deque([7, 1, 2, 3, 4])
>>> qlst.popleft() # 左邊刪除一個元素
7
>>> qlst
deque([1, 2, 3, 4])
    
>>> qlst.rotate(3) #循環移動n個位置
>>> qlst
deque([2, 3, 4, 1])

import calendar
cal = calendar.month(2016,8)
print cal

    August 2016
Mo Tu We Th Fr Sa Su
 1  2  3  4  5  6  7
 8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31

calendar(year,w=2,l=1,c=6)
返回year年的年歷，3個月一行，間隔距離為c。 每日寬度間隔為w字符。每行長度為21* w+18+2* c。l是每星期行數。

isleap(year)判斷是否為閏年，是則返回true，否則false.

leapdays(y1, y2)返回在y1，y2兩年之間的閏年總數，包括y1，但不包括y2.

month(year, month, w=2, l=1)返回year年month月日歷，兩行標題，一周一行。每日寬度間隔為w字符。每行的長度為7* w+6，l是每星期的行數。

monthcalendar(year,month)返回一個列表，列表內的元素還是列表。每個子列表代表一個星期，都是從星期一到星期日，如果沒有本月的日期，則為0。

monthrange(year, month)返回一個元組，里面有兩個整數。第一個整數代表著該月的第一天從星期幾是（從0開始，依次為星期一、星期二，直到6代表星期日）。第二個整數是該月一共多少天。

weekday(year,month,day)輸入年月日，知道該日是星期幾（注意，返回值依然按照從0到6依次對應星期一到星期六）。

time()獲得的是當前時間（嚴格說是時間戳），只不過這個時間對人不友好，它是以1970年1月1日0時0分0秒為計時起點，到當前的時間長度（不考慮閏秒）。

localtime()得到的結果可以稱之為時間元組（也有括號），其各項的含義是：

gmtime()localtime()得到的是本地時間，如果要國際化，就最好使用格林威治時間。

asctime()

    >>> time.asctime()
    "Mon May  4 21:46:13 2015"
    
    time.asctime(h) #參數必須是時間元組，即localtime返回的值

ctime()

>>> time.ctime()
"Mon May  4 21:52:22 2015"
    
 >>> time.ctime(1000000)  #參數是時間戳
"Mon Jan 12 21:46:40 1970"

mktime()mktime()也是以時間元組為參數，但是它返回的是時間戳

strftime()將時間元組按照指定格式要求轉化為字符串。如果不指定時間元組，就默認為localtime()值。

strptime()作用是將字符串轉化為時間元組,其參數要指定兩個，一個是時間字符串，另外一個是時間字符串所對應的格式，格式符號用上表中的。

    >>> today = time.strftime("%y/%m/%d")
    >>> today
    "15/05/05"
    >>> time.strptime(today, "%y/%m/%d")
    time.struct_time(tm_year=2015, tm_mon=5, tm_mday=5, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=125, tm_isdst=-1)

datetime模塊中有幾個類：

datetime.date：日期類，常用的屬性有year/month/day

datetime.time：時間類，常用的有hour/minute/second/microsecond

datetime.datetime：日期時間類

datetime.timedelta：時間間隔，即兩個時間點之間的時間長度

datetime.tzinfo：時區類

# 生成日期對象
>>> import datetime
>>> today = datetime.date.today()
>>> today
datetime.date(2015, 5, 5)

# 操作日期對象

>>> print today        #Python 3: print(today)
2015-05-05
>>> print today.ctime()        #Python 3: print(today.ctime())
Tue May  5 00:00:00 2015
>>> print today.timetuple()        #Python 3: print(today.timetuple())
time.struct_time(tm_year=2015, tm_mon=5, tm_mday=5, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=125, tm_isdst=-1)
>>> print today.toordinal()        #Python 3: print(today.toordinal())
735723
    
>>> print today.year
2015
>>> print today.month
5
>>> print today.day
5
    
# 時間戳與格式化時間格式的轉換

>>> to = today.toordinal()
>>> to
735723
>>> print datetime.date.fromordinal(to)
2015-05-05

>>> import time
>>> t = time.time()
>>> t
1430787994.80093
>>> print datetime.date.fromtimestamp(t)
2015-05-05

# 修改日期。

>>> d1 = datetime.date(2015,5,1)
>>> print d1
2015-05-01
>>> d2 = d1.replace(year=2005, day=5)
>>> print d2
2005-05-05

# 生成time對象

>>> t = datetime.time(1,2,3)
>>> print t
01:02:03

# 常用屬性：

>>> print t.hour
1
>>> print t.minute
2
>>> print t.second
3
>>> t.microsecond
0
>>> print t.tzinfo
None

主要用來做時間的運算。

    >>> now = datetime.datetime.now()
    >>> print now        #Python 3: print(now)
    2015-05-05 09:22:43.142520

# 對`now`增加5個小時；

    >>> b = now + datetime.timedelta(hours=5)
    >>> print b        #Python 3: print(b)
    2015-05-05 14:22:43.142520

# 增加兩周；

    >>> c = now + datetime.timedelta(weeks=2)
    >>> print c        #Python 3: print(c)
    2015-05-19 09:22:43.142520

# 計算時間差：

    >>> d = c - b
    >>> print d        #Python 3: print(d)
    13 days, 19:00:00

urllib模塊用于讀取來自網上（服務器上）的數據，比如不少人用Python做爬蟲程序，就可以使用這個模塊。

# 在Python 2中，這樣操作：
    >>> import urllib
    >>> itdiffer =  urllib.urlopen("http://www.itdiffer.com")

# 但是如果讀者使用的是Python 3，必須換個姿勢：

    >>> import urllib.request
    >>> itdiffer = urllib.request.urlopen("http://www.itdiffer.com")
    
    >>> print itdiffer.read() #得到網頁的內容

urlopen()主要用于打開url文件，然后就獲得指定url的數據，然后就如同在操作文件那樣來操作,得到的對象叫做類文件對象。

參數說明一下：

url：遠程數據的路徑，常常是網址

data：如果使用post方式，這里就是所提交的數據

proxies：設置代理

url對其中的字符有嚴格的編碼要求，要對url進行編碼和解碼。

quote(string[, safe])：對字符串進行編碼。參數safe指定了不需要編碼的字符

urllib.unquote(string) ：對字符串進行解碼

quote_plus(string [ , safe ] ) ：與urllib.quote類似，但這個方法用"+"來替換空格" "，而quote用"%20"來代替空格

unquote_plus(string ) ：對字符串進行解碼；

urllib.urlencode(query[, doseq])：將dict或者包含兩個元素的元組列表轉換成url參數。例如{"name": "laoqi", "age": 40}將被轉換為"name=laoqi&age=40"

pathname2url(path)：將本地路徑轉換成url路徑

url2pathname(path)：將url路徑轉換成本地路徑

將遠程文件保存在本地存儲器中.

urllib.urlretrieve(url[, filename[, reporthook[, data]]])

url：文件所在的網址

filename：可選。將文件保存到本地的文件名，如果不指定，urllib會生成一個臨時文件來保存

reporthook：可選。是回調函數，當鏈接服務器和相應數據傳輸完畢時觸發本函數

data：可選。如果用post方式所發出的數據

函數執行完畢，返回的結果是一個元組(filename, headers)，filename是保存到本地的文件名，headers是服務器響應頭信息。

僅僅是針對Python 2的，在Python 3中，已經沒有urllib2這個模塊了，取代它的是urllib.request。

Request類

>>>req = urllib2.Request("http://www.itdiffer.com")

# Python2
    >>> response = urllib2.urlopen(req)
    >>> page = response.read()
    >>> print page

Python 3:

    >>> response = urllib.request.urlopen(req)
    >>> page = response.read()
    >>> print(page)

urllib2或者urllib.request的東西還很多，比如還可以:

設置HTTP Proxy

設置Timeout值

自動redirect

處理cookie

Python提供了多種模塊來處理XML。

xml.dom.* 模塊：Document Object Model。適合用于處理 DOM API。它能夠將XML數據在內存中解析成一個樹，然后通過對樹的操作來操作XML。但是，這種方式由于將XML數據映射到內存中的樹，導致比較慢，且消耗更多內存。

xml.sax.* 模塊：simple API for XML。由于SAX以流式讀取XML文件，從而速度較快，切少占用內存，但是操作上稍復雜，需要用戶實現回調函數。

xml.parser.expat：是一個直接的，低級一點的基于 C 的 expat 的語法分析器。 expat接口基于事件反饋，有點像 SAX 但又不太像，因為它的接口并不是完全規范于 expat 庫的。

xml.etree.ElementTree (以下簡稱 ET)：元素樹。它提供了輕量級的Python式的API，相對于DOM，ET快了很多
，而且有很多令人愉悅的API可以使用；相對于SAX，ET也有ET.iterparse提供了 “在空中” 的處理方式，沒有必要加載整個文檔到內存，節省內存。ET的性能的平均值和SAX差不多，但是API的效率更高一點而且使用起來很方便。

ElementTree在標準庫中有兩種實現。一種是純Python實現：xml.etree.ElementTree ，另外一種是速度快一點：xml.etree.cElementTree 。

如果使用的是Python 2，可以像這樣引入模塊：

    try:
        import xml.etree.cElementTree as ET
    except ImportError:
        import xml.etree.ElementTree as ET

如果是Python 3以上，就沒有這個必要了，只需要一句話import xml.etree.ElementTree as ET即可，然后由模塊自動來尋找適合的方式。顯然Python 3相對Python 2有了很大進步。

ET里面的屬性和方法不少，這里列出常用的，供使用中備查。

常用屬性：

tag：string，元素數據種類

text：string，元素的內容

attrib：dictionary，元素的屬性字典

tail：string，元素的尾形

針對屬性的操作

clear()：清空元素的后代、屬性、text和tail也設置為None

get(key, default=None)：獲取key對應的屬性值，如該屬性不存在則返回default值

items()：根據屬性字典返回一個列表，列表元素為(key, value）

keys()：返回包含所有元素屬性鍵的列表

set(key, value)：設置新的屬性鍵與值

針對后代的操作

append(subelement)：添加直系子元素

extend(subelements)：增加一串元素對象作為子元素

find(match)：尋找第一個匹配子元素，匹配對象可以為tag或path

findall(match)：尋找所有匹配子元素，匹配對象可以為tag或path

findtext(match)：尋找第一個匹配子元素，返回其text值。匹配對象可以為tag或path

insert(index, element)：在指定位置插入子元素

iter(tag=None)：生成遍歷當前元素所有后代或者給定tag的后代的迭代器

iterfind(match)：根據tag或path查找所有的后代

itertext()：遍歷所有后代并返回text值

remove(subelement)：刪除子元素

find(match)

findall(match)

findtext(match, default=None)

getroot()：獲取根節點.

iter(tag=None)

iterfind(match)

parse(source, parser=None)：裝載xml對象，source可以為文件名或文件類型對象.

write(file, encoding="us-ascii", xml_declaration=None, default_namespace=None,method="xml")　

    
        
        Giada De Laurentiis
        2005
        30.00
    
    
        
        J K. Rowling
        2005
        29.99
    
    
        
        Erik T. Ray
        2003
        39.95
    

#!/usr/bin/env python
# coding=utf-8

import xml.etree.ElementTree as ET

fd = open("xml.xml")

data = fd.read()

tree = ET.ElementTree(file="xml.xml")
print tree

#獲得根元素
root = tree.getroot()
print root.tag
print root.attrib

#獲得根元素下面的元素
for child in root:
    print child.tag,child.attrib
    for gen in child:
        print gen.tag,gen.text

JSON建構于兩種結構：

“名稱/值”對的集合（A collection of name/value pairs）。不同的語言中，它被理解為對象（object），紀錄（record），結構（struct），字典（dictionary），哈希表（hash table），有鍵列表（keyed list），或者關聯數組 （associative array）。

值的有序列表（An ordered list of values）。在大部分語言中，它被理解為數組（array）。

python標準庫中有JSON模塊，主要是執行序列化和反序列化功能：

序列化：encoding，把一個Python對象編碼轉化成JSON字符串

反序列化：decoding，把JSON格式字符串解碼轉換為Python數據對象

data_json = json.dumps(data)
json.dumps(data, sort_keys=True, indent=2) #格式化輸出json數據

如果數據不是很大，上面的操作足夠了。但現在是所謂“大數據”時代了，隨便一個什么業務都在說自己是大數據，顯然不能總讓JSON很小，事實上真正的大數據，再“大”的JSON也不行了。前面的操作方法是將數據都讀入內存，如果數據太大了就會內存溢出。怎么辦？JSON提供了load()和dump()函數解決這個問題，注意，跟上面已經用過的函數相比，是不同的，請仔細觀察。

    >>> import tempfile    #臨時文件模塊
    >>> data
    [{"lang": ("python", "english"), "age": 40, "name": "qiwsir"}]
    >>> f = tempfile.NamedTemporaryFile(mode="w+")
    >>> json.dump(data, f)
    >>> f.flush()
    >>> print open(f.name, "r").read()        #Python 3: print(open(f.name, "r").read())
    [{"lang": ["python", "english"], "age": 40, "name": "qiwsir"}]

{"code":20,"data":"liuguoquan","person":[{"name":"zhang","age":19,"sex":"male"},{"name":"zhang","age":20,"sex":"male"}]}

#!/usr/bin/env python
# coding=utf-8

import json

class B(object):
    def __init__(self):
        self.age = 0
        self.name = ""
        self.sex = ""

class A(object):  
    def __init__(self):
        self.code = 2
        self.data = ""
        self.person = []
    

f = open("sample.json")
value = f.read();
print value

ret = json.loads(value)
print type(ret)

a = A()
#對象轉為字典
a.__dict__ = ret
print a.code
print a.data
print a.person
print type(a.person)

for item in a.person:
    b = B()
    b.__dict__ = item;
    print b.age
    print b.name
    print b.sex

在github.com網站可以下載第三方庫的源碼,通常會看見一個 setup.py 的文件。

python setup.py install

pip是一個以Python計算機程序語言寫成的軟件包管理系統，它可以安裝和管理軟件包，另外不少的軟件包也可以在“Python軟件包索引”（英語：Python Package Index，簡稱PyPI）中找到。

pip install XXXXXX（XXXXXX代表第三方庫的名字）即可安裝第三方庫。