摘要：是回調(diào)函數(shù)，當(dāng)鏈接服務(wù)器和相應(yīng)數(shù)據(jù)傳輸完畢時(shí)觸發(fā)本函數(shù)可選。僅僅是針對的，在中，已經(jīng)沒有這個(gè)模塊了，取代它的是。由于以流式讀取文件，從而速度較快，切少占用內(nèi)存，但是操作上稍復(fù)雜，需要用戶實(shí)現(xiàn)回調(diào)函數(shù)。

模塊就是一個(gè)擴(kuò)展名為.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"

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

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

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

如果要作為程序執(zhí)行，則__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__屬性以及相應(yīng)的值，在__all__屬性列表中包含了一個(gè)私有變量的名字和一個(gè)函數(shù)的名字。這是在告訴引用本模塊的解釋器，這兩個(gè)東西是有權(quán)限被訪問的，而且只有這兩個(gè)東西。

包或者庫，應(yīng)該是比“模塊”大的。也的確如此，一般來講，一個(gè)“包”里面會有多個(gè)模塊，當(dāng)然，“庫”是一個(gè)更大的概念了，比如Python標(biāo)準(zhǔn)庫中的每個(gè)庫都有好多個(gè)包，每個(gè)包都有若干個(gè)模塊。

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

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

那些在安裝Python時(shí)就默認(rèn)已經(jīng)安裝好的模塊被統(tǒng)稱為“標(biāo)準(zhǔn)庫”。

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__ #查看模塊的位置，根據(jù)這個(gè)位置查到源代碼

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

    $ python --version # --veriosn就是命令行參數(shù)
    Python 2.7.6

退出當(dāng)前程序.

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

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

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

    >>> 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") #刪除一個(gè)文件，不能是目錄

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

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

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

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

需要注意的是，os.system()是在當(dāng)前進(jìn)程中執(zhí)行命令，直到它執(zhí)行結(jié)束。如果需要一個(gè)新的進(jìn)程，可以使用os.exec或者os.execvp。對此有興趣詳細(xì)了解的讀者，可以查看幫助文檔了解。另外，os.system()是通過shell執(zhí)行命令，執(zhí)行結(jié)束后將控制權(quán)返回到原來的進(jìn)程，但是os.exec()及相關(guān)的函數(shù)，則在執(zhí)行后不將控制權(quán)返回到原繼承，從而使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()：將列表轉(zhuǎn)換為堆

    >>> 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()的聯(lián)合，也就是刪除一個(gè)，同時(shí)加入一個(gè)

    >>> 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() #右邊刪除一個(gè)元素
5
>>> qlst
deque([7, 1, 2, 3, 4])
>>> qlst.popleft() # 左邊刪除一個(gè)元素
7
>>> qlst
deque([1, 2, 3, 4])
    
>>> qlst.rotate(3) #循環(huán)移動n個(gè)位置
>>> 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個(gè)月一行，間隔距離為c。 每日寬度間隔為w字符。每行長度為21* w+18+2* c。l是每星期行數(shù)。

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

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

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

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

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

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

time()獲得的是當(dāng)前時(shí)間（嚴(yán)格說是時(shí)間戳），只不過這個(gè)時(shí)間對人不友好，它是以1970年1月1日0時(shí)0分0秒為計(jì)時(shí)起點(diǎn)，到當(dāng)前的時(shí)間長度（不考慮閏秒）。

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

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

asctime()

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

ctime()

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

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

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

strptime()作用是將字符串轉(zhuǎn)化為時(shí)間元組,其參數(shù)要指定兩個(gè)，一個(gè)是時(shí)間字符串，另外一個(gè)是時(shí)間字符串所對應(yīng)的格式，格式符號用上表中的。

    >>> 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模塊中有幾個(gè)類：

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

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

datetime.datetime：日期時(shí)間類

datetime.timedelta：時(shí)間間隔，即兩個(gè)時(shí)間點(diǎn)之間的時(shí)間長度

datetime.tzinfo：時(shí)區(qū)類

# 生成日期對象
>>> 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
    
# 時(shí)間戳與格式化時(shí)間格式的轉(zhuǎn)換

>>> 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

主要用來做時(shí)間的運(yùn)算。

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

# 對`now`增加5個(gè)小時(shí)；

    >>> 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

# 計(jì)算時(shí)間差：

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

urllib模塊用于讀取來自網(wǎng)上（服務(wù)器上）的數(shù)據(jù)，比如不少人用Python做爬蟲程序，就可以使用這個(gè)模塊。

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

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

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

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

參數(shù)說明一下：

url：遠(yuǎn)程數(shù)據(jù)的路徑，常常是網(wǎng)址

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

proxies：設(shè)置代理

url對其中的字符有嚴(yán)格的編碼要求，要對url進(jìn)行編碼和解碼。

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

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

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

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

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

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

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

將遠(yuǎn)程文件保存在本地存儲器中.

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

url：文件所在的網(wǎng)址

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

reporthook：可選。是回調(diào)函數(shù)，當(dāng)鏈接服務(wù)器和相應(yīng)數(shù)據(jù)傳輸完畢時(shí)觸發(fā)本函數(shù)

data：可選。如果用post方式所發(fā)出的數(shù)據(jù)

函數(shù)執(zhí)行完畢，返回的結(jié)果是一個(gè)元組(filename, headers)，filename是保存到本地的文件名，headers是服務(wù)器響應(yīng)頭信息。

僅僅是針對Python 2的，在Python 3中，已經(jīng)沒有urllib2這個(gè)模塊了，取代它的是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的東西還很多，比如還可以:

設(shè)置HTTP Proxy

設(shè)置Timeout值

自動redirect

處理cookie

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

xml.dom.* 模塊：Document Object Model。適合用于處理 DOM API。它能夠?qū)ML數(shù)據(jù)在內(nèi)存中解析成一個(gè)樹，然后通過對樹的操作來操作XML。但是，這種方式由于將XML數(shù)據(jù)映射到內(nèi)存中的樹，導(dǎo)致比較慢，且消耗更多內(nèi)存。

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

xml.parser.expat：是一個(gè)直接的，低級一點(diǎn)的基于 C 的 expat 的語法分析器。 expat接口基于事件反饋，有點(diǎn)像 SAX 但又不太像，因?yàn)樗慕涌诓⒉皇峭耆?guī)范于 expat 庫的。

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

ElementTree在標(biāo)準(zhǔn)庫中有兩種實(shí)現(xiàn)。一種是純Python實(shí)現(xiàn)：xml.etree.ElementTree ，另外一種是速度快一點(diǎn)：xml.etree.cElementTree 。

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

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

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

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

常用屬性：

tag：string，元素?cái)?shù)據(jù)種類

text：string，元素的內(nèi)容

attrib：dictionary，元素的屬性字典

tail：string，元素的尾形

針對屬性的操作

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

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

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

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

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

針對后代的操作

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

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

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

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

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

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

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

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

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

remove(subelement)：刪除子元素

find(match)

findall(match)

findtext(match, default=None)

getroot()：獲取根節(jié)點(diǎn).

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建構(gòu)于兩種結(jié)構(gòu)：

“名稱/值”對的集合（A collection of name/value pairs）。不同的語言中，它被理解為對象（object），紀(jì)錄（record），結(jié)構(gòu)（struct），字典（dictionary），哈希表（hash table），有鍵列表（keyed list），或者關(guān)聯(lián)數(shù)組 （associative array）。

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

python標(biāo)準(zhǔn)庫中有JSON模塊，主要是執(zhí)行序列化和反序列化功能：

序列化：encoding，把一個(gè)Python對象編碼轉(zhuǎn)化成JSON字符串

反序列化：decoding，把JSON格式字符串解碼轉(zhuǎn)換為Python數(shù)據(jù)對象

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

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

    >>> import tempfile    #臨時(shí)文件模塊
    >>> 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()
#對象轉(zhuǎn)為字典
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網(wǎng)站可以下載第三方庫的源碼,通常會看見一個(gè) setup.py 的文件。

python setup.py install

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

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