posts - 73,  comments - 55,  trackbacks - 0

          Python基礎(chǔ)篇

          整理:Jims of 肥肥世家

          Copyright © 2004,2005,2006 本文遵從GNU 的自由文檔許可證(Free Document License)的條款,歡迎轉(zhuǎn)載、修改、散布。

          發(fā)布時(shí)間:2004年07月10日

          更新時(shí)間:2006年06月14日,把參考篇的內(nèi)容合并進(jìn)來(lái)。

          Abstract

          現(xiàn) 時(shí)國(guó)內(nèi)python的中文資料極少,使學(xué)習(xí)Python較困難。國(guó)外的資料雖多,但都是英文的,使我們學(xué)習(xí)起來(lái)很不方便。有鑒于此,我開(kāi)始了Python 中文資料庫(kù)的整理工作,以推動(dòng)Python的發(fā)展和在中國(guó)的應(yīng)用。在自由的世界里,正因?yàn)橛心愕闹С趾蛶椭攀刮业靡圆粩嗲斑M(jìn)。我相信我們每人一小步就 可帶動(dòng)python在中國(guó)前進(jìn)一大步。


          Table of Contents

          1. 緒論
          1.1. Python歷史
          1.2. Python功能簡(jiǎn)介
          1.3. 應(yīng)用范圍
          1.4. 如何開(kāi)始?
          2. Python編程習(xí)慣與特點(diǎn)
          2.1. 代碼風(fēng)格
          2.2. 保留字
          2.3. Python運(yùn)算符和表達(dá)式
          2.3.1. Python運(yùn)算符
          2.3.2. 運(yùn)算符優(yōu)先順序
          2.3.3. 真值表
          2.3.4. 復(fù)合表達(dá)式
          2.4. 給變量賦值
          3. Python內(nèi)建對(duì)象類型
          3.1. Number數(shù)值型
          3.2. String字符串型
          3.2.1. 字符串的格式化
          3.2.2. 轉(zhuǎn)義字符
          3.2.3. Unicode字符串
          3.2.4. 原始字符串
          3.3. List列表
          3.4. Tuple元組
          3.5. 序列對(duì)象
          3.6. Dictionary字典
          3.7. File文件
          3.8. 理解引用
          3.9. copy and deepcopy
          3.10. 標(biāo)識(shí)數(shù)據(jù)類型
          3.11. 數(shù)組對(duì)象
          4. 控制語(yǔ)句
          5. 函數(shù)
          5.1. 常用函數(shù)
          5.2. 內(nèi)置類型轉(zhuǎn)換函數(shù)
          5.3. 序列處理函數(shù)
          6. 模塊
          6.1. String模塊
          6.2. time模塊
          7. 類
          8. 異常處理
          9. 文件處理
          9.1. 文件處理的函數(shù)和方法
          9.2. 示例
          10. 正則表達(dá)式
          10.1. 基本元素
          10.2. 操作
          11. 調(diào)試
          12. HOW-TO

          List of Tables

          1.1. Python命令行選項(xiàng)
          2.1. Python運(yùn)算符列表
          2.2. 運(yùn)算符優(yōu)先順序列表(從最高到最低)
          2.3.
          3.1. 字符串格式化代碼
          3.2. python支持的轉(zhuǎn)義字符表
          3.3. 列表對(duì)象支持的方法
          3.4. 字典方法
          3.5. 數(shù)組類型代碼
          9.1. mode
          9.2. bufsize
          9.3. 文件對(duì)象方法
          10.1. 正則表達(dá)式基本字符
          10.2. 匹配限定符
          10.3. 組和運(yùn)算符
          10.4. 特殊字符序列
          10.5. 正則表達(dá)式聲明
          10.6. 處理標(biāo)志
          10.7. MatchObject對(duì)象方法
          10.8. 正則式對(duì)象方法/屬性

          Chapter 1. 緒論

          1.1. Python歷史

          Python 是一種開(kāi)源的面向?qū)ο蟮哪_本語(yǔ)言,它起源于1989年末,當(dāng)時(shí),CWI(阿姆斯特丹國(guó)家數(shù)學(xué)和計(jì)算機(jī)科學(xué)研究所)的研究員Guido van Rossum需要一種高級(jí)腳本編程語(yǔ)言,為其研究小組的Amoeba分布式操作系統(tǒng)執(zhí)行管理任務(wù)。為創(chuàng)建新語(yǔ)言,他從高級(jí)數(shù)學(xué)語(yǔ)言ABC(ALL BASIC CODE)汲取了大量語(yǔ)法,并從系統(tǒng)編程語(yǔ)言Modula-3借鑒了錯(cuò)語(yǔ)處理機(jī)制。Van Rossum把這種新的語(yǔ)言命名為Python(大蟒蛇)---來(lái)源于BBC當(dāng)時(shí)正在熱播的喜劇連續(xù)劇“Monty Python”。

          Python 于1991年初公開(kāi)發(fā)行,由于功能強(qiáng)大和采用開(kāi)源方式發(fā)行,Python的發(fā)展得很快,用戶越來(lái)越多,形成了一個(gè)強(qiáng)大的社區(qū)力量。2001年, Python的核心開(kāi)發(fā)團(tuán)隊(duì)移師Digital Creations公司,該公司是Zope(一個(gè)用Python編寫的web應(yīng)用服務(wù)器)的創(chuàng)始者。現(xiàn)在最新的版本是python2.3.4,大家可到http://www.python.org上了解最新的Python動(dòng)態(tài)和資料 。

          1.2. Python功能簡(jiǎn)介

          Python是一種解析性的,交互式的,面向?qū)ο蟮木幊陶Z(yǔ)言,類似于Perl、Tcl、Scheme或Java。

          Python一些主要功能介紹:

          • Python使用一種優(yōu)雅的語(yǔ)法,可讀性強(qiáng)。

          • Python是一種很靈活的語(yǔ)言,能幫你輕松完成編程工作。并可作為一種原型開(kāi)發(fā)語(yǔ)言,加快大型程序的開(kāi)發(fā)速度。

          • 有 多種數(shù)據(jù)類型:numbers (integers, floating point, complex, and unlimited-length long integers), strings (ASCII 和 Unicode), lists, dictionaries。

          • Python支持類和多層繼承等的面向?qū)ο缶幊碳夹g(shù)。

          • 代碼能打包成模塊和包,方便管理和發(fā)布。

          • 支持異常處理,能有效捕獲和處理程序中發(fā)生的錯(cuò)誤。

          • 強(qiáng)大的動(dòng)態(tài)數(shù)據(jù)類型支持,不同數(shù)據(jù)類型相加會(huì)引發(fā)一個(gè)異常。

          • Python支持如生成器和列表嵌套等高級(jí)編程功能。

          • 自動(dòng)內(nèi)存碎片管理,有效利用內(nèi)存資源。

          • 強(qiáng)大的類庫(kù)支持,使編寫文件處理、正則表達(dá)式,網(wǎng)絡(luò)連接等程序變得相當(dāng)容易。

          • Python的交互命令行模塊能方便地進(jìn)行小代碼調(diào)試和學(xué)習(xí)。

          • Python易于擴(kuò)展,可以通過(guò)C或C++編寫的模塊進(jìn)行功能擴(kuò)展。

          • Python解析器可作為一個(gè)編程接口嵌入一個(gè)應(yīng)用程序中。

          • Python可運(yùn)行在多種計(jì)算機(jī)平臺(tái)和操作系統(tǒng)中,如各位unix,windows,MacOS,OS/2等等。

          • Python是開(kāi)源的,可自由免費(fèi)使用和發(fā)布,并且可用于商業(yè)用途以獲取利潤(rùn)。如想詳細(xì)了解Python的許可協(xié)議可到以下網(wǎng)址查詢http://www.python.org/psf/license.html

          1.3. 應(yīng)用范圍

          • 系統(tǒng)編程,提供大量系統(tǒng)接口API,能方便進(jìn)行系統(tǒng)維護(hù)和管理。

          • 圖形處理,有PIL、Tkinter等圖形庫(kù)支持,能方便進(jìn)行圖形處理。

          • 數(shù)學(xué)處理,NumPy擴(kuò)展提供大量與許多標(biāo)準(zhǔn)數(shù)學(xué)庫(kù)的接口,

          • 文本處理,python提供的re模塊能支持正則表達(dá)式,還提供SGML,XML分析模塊,許多程序員利用python進(jìn)行XML程序的開(kāi)發(fā)。

          • 數(shù) 據(jù)庫(kù)編程,程序員可通過(guò)遵循Python DB-API(數(shù)據(jù)庫(kù)應(yīng)用程序編程接口)規(guī)范的模塊與Microsoft SQL Server,Oracle,Sybase,DB2,Mysql等數(shù)據(jù)庫(kù)通信。python自帶有一個(gè)Gadfly模塊,提供了一個(gè)完整的SQL環(huán)境。

          • 網(wǎng)絡(luò)編程,提供豐富的模塊支持sockets編程,能方便快速地開(kāi)發(fā)分布式應(yīng)用程序。

          • 作為Web應(yīng)用的開(kāi)發(fā)語(yǔ)言,支持最新的XML技術(shù)。

          • 多媒體應(yīng)用,Python的PyOpenGL模塊封裝了“OpenGL應(yīng)用程序編程接口”,能進(jìn)行二維和三維圖像處理。PyGame模塊可用于編寫游戲軟件。

          1.4. 如何開(kāi)始?

          • 進(jìn)入交互命令行方式。如果是linux類的系統(tǒng),python解析器應(yīng)該已經(jīng)安裝在/usr/local/bin/python中,直接打python就可進(jìn)入交互式命令行界面,如下所示:

            Python 2.3.3 (#1, Apr 27 2004, 15:17:58) 
            [GCC 3.2 20020903 (Red Hat Linux 8.0 3.2-7)] on linux2
            Type "help", "copyright", "credits" or "license" for more information.
            >>>

            “>>>”符號(hào)是Python命令行界面的提示符,可按CTRL+D退出,如果是windows環(huán)境的話就要按CTRL+Z了。還可以用以下命令退出命令行界面:“import sys;sys.exit()”。如果是windows系統(tǒng),可到http://www.python.org/download/下載最新的安裝程序進(jìn)行安裝。安裝完成后直接打python也可進(jìn)入命令行界面。命令行是python最簡(jiǎn)單直觀,也是最方便的一種執(zhí)行環(huán)境,我們可以在這里學(xué)習(xí)python語(yǔ)法和調(diào)試程序。如果要打印"hello world"可以輸入以下命令:

            >>>print "hello world"
            hello world
          • 以模塊文件方式運(yùn)行。模塊文件是包含python語(yǔ)句的文本,以.py結(jié)尾。運(yùn)行模塊文件只要輸入python xxx.py就可以了。

          • 以linux腳本方式運(yùn)行。和shell腳本差不多,以vi或其它文本編輯器輸入以下內(nèi)容:

            #!/usr/local/bin/python
            print "test ............"

            存盤后,把文件屬性改為可執(zhí)行,就可象shell腳本一樣執(zhí)行了。

          • Table 1.1. Python命令行選項(xiàng)

            選項(xiàng)作用
            -c cmd 在命令行直接執(zhí)行python代碼。如python -c 'print "hello world"'。
            -d 腳本編譯后從解釋器產(chǎn)生調(diào)試信息。同PYTHONDEBUG=1。
            -E 忽略環(huán)境變量。
            -h 顯示python命令行選項(xiàng)幫助信息。
            -i 腳本執(zhí)行后馬上進(jìn)入交互命令行模式。同PYTHONINSPECT=1。
            -O 在執(zhí)行前對(duì)解釋器產(chǎn)生的字節(jié)碼進(jìn)行優(yōu)化。同 PYTHONOPTIMIZE=1。
            -OO 在執(zhí)行前對(duì)解釋器產(chǎn)生的字節(jié)碼進(jìn)行優(yōu)化,并刪除優(yōu)化代碼中的嵌入式文檔字符串。
            -Q arg 除法規(guī)則選項(xiàng),-Qold(default),-Qwarn,-Qwarnall,-Qnew。
            -S 解釋器不自動(dòng)導(dǎo)入site.py模塊。
            -t 當(dāng)腳本的tab縮排格式不一致時(shí)產(chǎn)生警告。
            -u 不緩沖stdin、stdout和stderr,默認(rèn)是緩沖的。同PYTHONUNBUFFERED=1。
            -v 產(chǎn)生每個(gè)模塊的信息。如果兩個(gè)-v選項(xiàng),則產(chǎn)生更詳細(xì)的信息。同PYTHONVERBOSE=x。
            -V 顯示Python的版本信息。
            -W arg 出錯(cuò)信息控制。(arg is action:message:category:module:lineno)
            -x 忽略源文件的首行。要在多平臺(tái)上執(zhí)行腳本時(shí)有用。
            file 執(zhí)行file里的代碼。
            - 從stdin里讀取執(zhí)行代碼。

          Chapter 2. Python編程習(xí)慣與特點(diǎn)

          2.1. 代碼風(fēng)格

          • 在Python 中,每行程序以換行符代表結(jié)束,如果一行程序太長(zhǎng)的話,可以用“"”符號(hào)擴(kuò)展到下一行。在python中以三引號(hào)(""")括起來(lái)的字符串,列表,元組和 字典都能跨行使用。并且以小括號(hào)(...)、中括號(hào)[...]和大括號(hào){...}包圍的代碼不用加“"”符也可擴(kuò)展到多行。如:

          • 在Python中是以縮進(jìn)來(lái)區(qū)分程序功能塊的,縮進(jìn)的長(zhǎng)度不受限制,但就一個(gè)功能塊來(lái)講,最好保持一致的縮進(jìn)量。

          • 如果一行中有多條語(yǔ)句,語(yǔ)句間要以分號(hào)(;)分隔。

          • 以“#”號(hào)開(kāi)頭的內(nèi)容為注釋,python解釋器會(huì)忽略該行內(nèi)容。

          • 在python中,所有標(biāo)識(shí)符可以包括英文、數(shù)字以及下劃線(_),但不能以數(shù)字開(kāi)頭。python中的標(biāo)識(shí)符是區(qū)分大小寫的。

          • 以 下劃線開(kāi)頭的標(biāo)識(shí)符是有特殊意義的。以單下劃線開(kāi)頭(_foo)的代表不能直接訪問(wèn)的類屬性,需通過(guò)類提供的接口進(jìn)行訪問(wèn),不能用“from xxx import *”而導(dǎo)入;以雙下劃線開(kāi)頭的(__foo)代表類的私有成員;以雙下劃線開(kāi)頭和結(jié)尾的(__foo__)代表python里特殊方法專用的標(biāo)識(shí),如 __init__()代表類的構(gòu)造函數(shù)。

          • 在交互模式下運(yùn)行python時(shí),一個(gè)下劃線字符(_)是特殊標(biāo)識(shí)符,它保留了表達(dá)式的最后一個(gè)計(jì)算結(jié)果。

            >>> "hello"
            'hello'
            >>> _
            'hello'
            >>> 10+10
            20
            >>> _
            20

          • 在python中,函數(shù)、類、模塊定義的第一段代碼如果是字符串的話,就把它叫作文件字串,可通過(guò)__doc__屬性訪問(wèn)。如:

            def test():
            "this is a document string"

            return 100+1000

            >>>print test.__doc__
            this is a document string

          2.2. 保留字

          	and		elif		global		or          yield
          assert else if pass
          break except import print
          class exec in raise
          continue finally is return
          def for lambda try
          del from not while

          2.3. Python運(yùn)算符和表達(dá)式

          2.3.1. Python運(yùn)算符

          Table 2.1. Python運(yùn)算符列表

          運(yùn)算符描述
          x+y,x-y 加、減,“+”號(hào)可重載為連接符
          x*y,x**y,x/y,x%y 相乘、求平方、相除、求余,“*”號(hào)可重載為重復(fù),“%”號(hào)可重載為格式化
          <,<=,>,>=,==,<>,!= 比較運(yùn)算符
          +=,-=,*=,/=,%=,**=,<<=,>>=,&=,^=,|= 自變運(yùn)算符
          x|y 按位或
          x^y 按位異或
          x&y 按位與
          ~x 按位取反
          x<<,x>>y x向左或向右移y位
          is, is not 等同測(cè)試
          in, not in 是否為成員測(cè)試
          or,and,not 邏輯運(yùn)算符
          x[i],x[i:j],x.y,x(...) 索引,分片,限定引用,函數(shù)調(diào)用
          (...),[...],{...},'...' 元組,列表,字典,轉(zhuǎn)化為字符串

          2.3.2. 運(yùn)算符優(yōu)先順序

          Table 2.2. 運(yùn)算符優(yōu)先順序列表(從最高到最低)

          運(yùn)算符描述
          'expr' 字符串轉(zhuǎn)換
          {key:expr,...} 字典
          [expr1,expr2...] 列表
          (expr1,expr2,...) 元組
          function(expr,...) 函數(shù)調(diào)用
          x[index:index] 切片
          x[index] 下標(biāo)索引取值
          x.attribute 屬性引用
          ~x 按位取反
          +x,-x 正,負(fù)
          x**y
          x*y,x/y,x%y 乘,除,取模
          x+y,x-y 加,減
          x<<y,x>>y 移位
          x&y 按位與
          x^y 按位異或
          x|y 按位或
          x<y,x<=y,x==y,x!=y,x>=y,x>y 比較
          x is y,x is not y 等同測(cè)試
          x in y,x not in y 成員判斷
          not x 邏輯否
          x and y 邏輯與
          x or y 邏輯或
          lambda arg,...:expr Lambda匿名函數(shù)

          2.3.3. 真值表

          Table 2.3. 

          對(duì)象/常量
          ""
          "string"
          0
          >=1
          <=-1
          ()空元組
          []空列表
          {}空字典
          None

          2.3.4. 復(fù)合表達(dá)式

          • 對(duì)于and,當(dāng)計(jì)算a and b時(shí),python會(huì)計(jì)算a,如果a為假,則取a值,如果a為真,則python會(huì)計(jì)算b且整個(gè)表達(dá)式會(huì)取b值。如:

            >>> a,b=10,20
            >>> a and b #a is true
            20
            >>> a,b=0,5 #a is false
            >>> a and b
            0
          • 對(duì)于or,當(dāng)計(jì)算a or b時(shí),python會(huì)計(jì)算a,如果a為真,則整個(gè)表達(dá)式取a值,如果a為假,表達(dá)式將取b值。如:

            >>> a,b=10,20
            >>> a or b
            10
            >>> a,b=0,5
            >>> a or b
            5
          • 對(duì)于not,not將反轉(zhuǎn)表表達(dá)式的“實(shí)際值”,如果表達(dá)式為真,not為返回假,如為表達(dá)式為假,not為返回真。如:

            >>> not 2
            False
            >>> not 0
            True
            >>> not "test"
            False
            >>> not ""
            True
          • 注意: a and b or c  是根據(jù)a的bool值來(lái)取b或c,a為true取b,a為false取c。

          2.4. 給變量賦值

          • 簡(jiǎn)單賦值,Variable(變量)=Value(值)。

            >>>a=1
            >>>b=2
            >>>print a,b
            1 2
          • 多變量賦值,Variable1,variable2,...=Value1,Value2,...

            >>>a,b,c=1,2,3
            >>>print a
            1
            >>>print b
            2
            >>>print c
            3

            多變量賦值也可用于變量交換,接上例:

            >>>a,b,c=c,b,a
            >>>print a
            3
            >>>print b
            2
            >>>print c
            1
          • 多目標(biāo)賦值,a=b=variable

            >>> a=b=1
            >>> a
            1
            >>> b
            1
            >>> a=2
            >>> a
            2
            >>> b
            1
          • 自變賦值,如+=,-=,*=等。在自變賦值中,python僅計(jì)算一次,而普通寫法需計(jì)算兩次;自變賦值會(huì)修改原始對(duì)象,而不是創(chuàng)建一個(gè)新對(duì)象。

          Chapter 3. Python內(nèi)建對(duì)象類型

          在Python中,所有數(shù)據(jù)都是對(duì)象,數(shù)據(jù)有各種類型,如數(shù)值型、列表型、字符串型等。除系統(tǒng)內(nèi)建的數(shù)據(jù)類型外,程序員也可以創(chuàng)建自已的數(shù)據(jù)類型。以下主要介紹Python內(nèi)建的數(shù)據(jù)類型。

          3.1. Number數(shù)值型

          在python中,數(shù)值有四種類型,分別是整型、長(zhǎng)整形、浮點(diǎn)型和復(fù)數(shù)。

          • 整 型---從-2147483648至2147483647,有符號(hào)位32位長(zhǎng),可表達(dá)的最大數(shù)為2^31-1。如:number=123,number1 =-123。在數(shù)字前加0x或0X 前綴表示十六進(jìn)制數(shù),在數(shù)字前加前綴0表示八進(jìn)制數(shù),與C/C++ and perl一樣。

            [Note]
            為方便起見(jiàn),sys模塊包含一個(gè)maxint成員,該成員保留了整形變量的最大正數(shù)值。
            >>> import sys
            >>> print sys.maxint
            2147483647
          • 長(zhǎng)整型---python支持任意長(zhǎng)度的長(zhǎng)整型,長(zhǎng)整型的最大值和最小值由可用的內(nèi)存確定。長(zhǎng)整型數(shù)在數(shù)字常量尾加L or l,一般都是用L,因?yàn)樾懙膌太容易與數(shù)字1混淆了。如:long=1232132131231232132132131L。

          • 浮點(diǎn)數(shù)---python支持普通十進(jìn)制和科學(xué)計(jì)數(shù)法表示的浮點(diǎn)數(shù)。如:number=123.456,nubmer1=123.2E10。浮點(diǎn)數(shù)在python中的存儲(chǔ)格式與C中的雙精度數(shù)相同。

          • 復(fù)數(shù)---復(fù)數(shù)的實(shí)部和虛部用加號(hào)分開(kāi),虛部使用后綴j表示,如:number=1.2+2j

          3.2. String字符串型

          • 字符串在python被看成是單個(gè)字符的序列,具有序列對(duì)象的特殊功能,字符串是固定的,不可變的。如:string="hello world"。

          • 可在字符串中使用單引號(hào)和雙引號(hào)。如:string="I'm a boy"。

          • 字符串內(nèi)部的一個(gè)反斜杠“"”可允許把字符串放于多行:如:

            >>> "test "
            ... python"
            'test python'
          • 使用三個(gè)單引號(hào)或雙引號(hào)可使字符串跨行顯示。如:

            helptext="""this a help test.if you have any quesions.
            please call me anytime.I will help you.I
            like python.I hope so as you."""
          • 使用“+”號(hào)可連接字符串。如:string = "hello" + "world",注意,不能將字符串與其它對(duì)象進(jìn)行連接。如string = "ok" + 5。其實(shí)不用“+”號(hào),直接用空格也可連接兩個(gè)字符串。如:string="hello" "world"。

          • 可用“*”號(hào)重復(fù)字符串,如:'hello'*5會(huì)生成'hellohellohellohellohello'。

          • 可用索引訪問(wèn)字符串中的字符。如:string="hello world",print string[1]將顯示字符e。

          • 字符串可用in或not in運(yùn)算符來(lái)測(cè)試字符是不屬于一個(gè)字符串的成員。

          • 可對(duì)字符串分片,如string="hello world",print string[6:]將顯示world。分片的格式為:

                         string[start:end]

            分片和索引的規(guī)則如下:

            • 返回的字符串包含從start起始到end但不包括end結(jié)束的所有字符。

            • 若指定了start但未指定end,則一直向后分片,直至字符串結(jié)束。

            • 若指定了end但未指定start,則從0開(kāi)始分片直至end,但不包括end指定的字符。

            • 若start和end為負(fù)數(shù),則索引從字符串尾部開(kāi)始算起,最后一個(gè)字符為-1。

          python提供了一個(gè)string模塊來(lái)進(jìn)行字符串處理。

          3.2.1. 字符串的格式化

          象C 中的sprintf函數(shù)一樣,可以用“%”來(lái)格式化字符串。

          Table 3.1. 字符串格式化代碼

          格式描述
          %% 百分號(hào)標(biāo)記
          %c 字符及其ASCII碼
          %s 字符串
          %d 有符號(hào)整數(shù)(十進(jìn)制)
          %u 無(wú)符號(hào)整數(shù)(十進(jìn)制)
          %o 無(wú)符號(hào)整數(shù)(八進(jìn)制)
          %x 無(wú)符號(hào)整數(shù)(十六進(jìn)制)
          %X 無(wú)符號(hào)整數(shù)(十六進(jìn)制大寫字符)
          %e 浮點(diǎn)數(shù)字(科學(xué)計(jì)數(shù)法)
          %E 浮點(diǎn)數(shù)字(科學(xué)計(jì)數(shù)法,用E代替e)
          %f 浮點(diǎn)數(shù)字(用小數(shù)點(diǎn)符號(hào))
          %g 浮點(diǎn)數(shù)字(根據(jù)值的大小采用%e或%f)
          %G 浮點(diǎn)數(shù)字(類似于%g)
          %p 指針(用十六進(jìn)制打印值的內(nèi)存地址)
          %n 存儲(chǔ)輸出字符的數(shù)量放進(jìn)參數(shù)列表的下一個(gè)變量中
          [Note]

          %格式化符也可用于字典,可用%(name)引用字典中的元素進(jìn)行格式化輸出。

          [Note]

          負(fù)號(hào)指時(shí)數(shù)字應(yīng)該是左對(duì)齊的,“0”告訴Python用前導(dǎo)0填充數(shù)字,正號(hào)指時(shí)數(shù)字總是顯示它的正負(fù)(+,-)符號(hào),即使數(shù)字是正數(shù)也不例外。

          [Note]

          可指定最小的字段寬度,如:"%5d" % 2。也可用句點(diǎn)符指定附加的精度,如:"%.3d" % 3。

          3.2.2. 轉(zhuǎn)義字符

          在需要在字符中使用特殊字符時(shí),python用反斜杠(")轉(zhuǎn)義字符。如下表:

          Table 3.2. python支持的轉(zhuǎn)義字符表

          轉(zhuǎn)義字符描述
          "(在行尾時(shí)) 續(xù)行符
          "" 反斜杠符號(hào)
          "' 單引號(hào)
          "" 雙引號(hào)
          "a 響鈴
          "b 退格(Backspace)
          "e 轉(zhuǎn)義
          "000
          "n 換行
          "v 縱向制表符
          "t 橫向制表符
          "r 回車
          "f 換頁(yè)
          "oyy 八進(jìn)制數(shù)yy代表的字符,例如:"o12代表?yè)Q行
          "xyy 十進(jìn)制數(shù)yy代表的字符,例如:"x0a代表?yè)Q行
          "other 其它的字符以普通格式輸出

          3.2.3. Unicode字符串

          在python2.0中才完全支持Unicode字符串,Unicode字符采用16位(0---65535)值表示,能進(jìn)行多語(yǔ)言支持。要使用Unicode字符串,只要在字符串前加上“u”即可。如:

          >>> a=u"test"
          >>> print a
          test

          原始Unicode字符串用ur前綴,如:

          >>> u'hello world"0020' 
          u'hello world"x020'
          >>> ur'hello world"0020'
          u'hello world""0020'

          3.2.3.1. Unicode轉(zhuǎn)換

          只要和Unicode連接,就會(huì)產(chǎn)生Unicode字串。如:

          >>> 'help'
          'help'
          >>> 'help,' + u'python'
          u'help,python'

          對(duì)于ASCII(7位)兼容的字串,可和內(nèi)置的str()函數(shù)把Unicode字串轉(zhuǎn)換成ASCII字串。如:

          >>> str(u'hello world')
          'hello world'
          [Note]
          轉(zhuǎn)換非ASCII兼容的字串會(huì)出錯(cuò)。編碼和譯碼字符串時(shí)的錯(cuò)誤引發(fā)UnicodeError異常。

          可使用encode()函數(shù)轉(zhuǎn)換Unicode字串格式:

          u'unicode"xb1"xe0"xc2"xeb"xb2"xe2"xca"xd4'
          >>> a.encode('utf-8') #轉(zhuǎn)換成utf-8,顯示結(jié)果會(huì)根據(jù)終端的字符集支持不同而不同,下面是在GB18030下的顯示結(jié)果
          'unicode"xc2"xb1"xc3"xa0"xc3"x82"xc3"xab"xc2"xb2"xc3"xa2"xc3"x8a"xc3"x94'

          可使用unicode()函數(shù)把字符串轉(zhuǎn)換成unicode格式,如:

          >>> a=u'unicode測(cè)試'
          >>> a
          u'unicode"xb2"xe2"xca"xd4'
          >>> a.encode('utf-8') #把unicode字串轉(zhuǎn)換成utf-8
          'unicode"xc2"xb2"xc3"xa2"xc3"x8a"xc3"x94'
          >>> b=a.encode('utf-8') #給變量b賦值
          >>> b
          'unicode"xc2"xb2"xc3"xa2"xc3"x8a"xc3"x94'
          >>>unicode(b,'utf-8') #用unicode()函數(shù)把utf-8格式字串轉(zhuǎn)換回unicode格式。
          u'unicode"xb2"xe2"xca"xd4' #和原始的這是a相同

          ord()支持unicode,可以顯示特定字符的unicode號(hào)碼,如:

          >>>ord('A')
          65

          使用unichr()函數(shù)可將unicode號(hào)碼轉(zhuǎn)換回unicode字符,如:

          >>> unichr(65)
          u'A'

          3.2.4. 原始字符串

          有時(shí)我們并不想讓轉(zhuǎn)義字符生效,我們只想顯示字符串原來(lái)的意思,這就要用r和R來(lái)定義原始字符串。如:

          print r'"t"r'

          實(shí)際輸出為“"t"r”。

          3.3. List列表

          • 列表是序列對(duì)象,可包含任意的Python數(shù)據(jù)信息,如字符串、數(shù)字、列表、元組等。列表的數(shù)據(jù)是可變的,我們可通過(guò)對(duì)象方法對(duì)列表中的數(shù)據(jù)進(jìn)行增加、修改、刪除等操作。可以通過(guò)list(seq)函數(shù)把一個(gè)序列類型轉(zhuǎn)換成一個(gè)列表。列表的幾個(gè)例子:

            • list = [ "a", "b", "c" ],這是字符列表。

            • list = [ 1, 2, 3, 4 ],這是數(shù)字列表。

            • list = [ [1,2,3,4], ["a","b","c"] ],這是列表的列表。

            • list = [ (1,2,3,4), ("a","b","c") ],這是元組列表。

            • list((1,2))把一個(gè)元組轉(zhuǎn)換成一個(gè)列表[1,2],list('test')可把字符串轉(zhuǎn)換成['t','e','s','t']列表。

          • 訪問(wèn)列表可通過(guò)索引來(lái)引用,如:list[0]將引用列表的第一個(gè)值。list[0:1]返回第一和第二個(gè)元素。

          • 用range()和xrange()函數(shù)可自動(dòng)生成列表,具體用法請(qǐng)參考“python參考篇”的內(nèi)容。

          • 可 通過(guò)列表綜合來(lái)創(chuàng)建列表,該功能是在python2.0版本中新增加的。如果想對(duì)列表中的每個(gè)項(xiàng)進(jìn)行運(yùn)算并把結(jié)果存儲(chǔ)在一個(gè)新列表中,可者想創(chuàng)建一個(gè)僅包 含特定滿足某種條件的項(xiàng),采用該方法是很適合的。如:[x*x for x in range(1,10)]會(huì)得到一個(gè)X的平方的新列表;我們還可添加if條件控制輸出,如:[x*x for x in range(1,10) if x%2==0];還可在列表中使用多個(gè)for語(yǔ)句,如:

            >>> [x+y for x in "123" for y in "abc"]
            ['1a', '1b', '1c', '2a', '2b', '2c', '3a', '3b', '3c']

            x,y值可取列表或元組等,以構(gòu)成更復(fù)雜的結(jié)構(gòu)。

          • “+”號(hào)可連接兩個(gè)列表。

          • 訪問(wèn)列表的列表(嵌套列表)可用list[1][0],這將訪問(wèn)嵌套中的第二個(gè)列表的第一個(gè)元素。

          • 可用數(shù)字與列表相乘以復(fù)制內(nèi)容,如:list*2會(huì)得到一個(gè)[1,2,3,4,1,2,3,4]的列表。注意,不能用列表與列表相乘。

          • 由于列表是可變的,我們可用賦值語(yǔ)句進(jìn)行操作,如:list[0] = 2。

          • 列表對(duì)象方法可對(duì)列表進(jìn)行操作,如列表內(nèi)容的添加,刪除,排序等。如list.sort()可對(duì)list列表進(jìn)行排序。

            Table 3.3. 列表對(duì)象支持的方法

            方法描述
            append(x) 在列表尾部追加單個(gè)對(duì)象x。使用多個(gè)參數(shù)會(huì)引起異常。
            count(x) 返回對(duì)象x在列表中出現(xiàn)的次數(shù)。
            extend(L) 將列表L中的表項(xiàng)添加到列表中。返回None。
            Index(x) 返回列表中匹配對(duì)象x的第一個(gè)列表項(xiàng)的索引。無(wú)匹配元素時(shí)產(chǎn)生異常。
            insert(i,x) 在索引為i的元素前插入對(duì)象x。如list.insert(0,x)在第一項(xiàng)前插入對(duì)象。返回None。
            pop(x) 刪除列表中索引為x的表項(xiàng),并返回該表項(xiàng)的值。若未指定索引,pop返回列表最后一項(xiàng)。
            remove(x) 刪除列表中匹配對(duì)象x的第一個(gè)元素。匹配元素時(shí)產(chǎn)生異常。返回None。
            reverse() 顛倒列表元素的順序。
            sort() 對(duì)列表排序,返回none。bisect模塊可用于排序列表項(xiàng)的添加和刪除。

          3.4. Tuple元組

          Tuple(元組)和List(列表)很相似,但元組是不可變的。不能對(duì)元組中的元素進(jìn)行添加,修改和刪除操作。如果需修改元組內(nèi)容只有重建元組。元組用小括號(hào)來(lái)表示。如tuple=(1,2,3)。

          • tuple=(1,),這是單個(gè)元素的元組表示,需加額外的逗號(hào)。

          • tuple=1,2,3,4,這也可以是一個(gè)元組,在不使用圓括號(hào)而不會(huì)導(dǎo)致混淆時(shí),Python允許不使用圓括號(hào)的元組。

          • 和列表一樣,可對(duì)元組進(jìn)行索引、分片、連接和重復(fù)。也可用len()求元組長(zhǎng)度。

            [Note]
            元組的索引用tuple[i]的形式,而不是tuple(i)。
          • 和列表類似,使用tuple(seq)可把其它序列類型轉(zhuǎn)換成元組。

          3.5. 序列對(duì)象

          上面介紹的字符串、列表和元組的對(duì)象類型均屬于稱為序列的Python對(duì)象。它是一種可使用數(shù)字化索引進(jìn)行訪問(wèn)其中元素的對(duì)象。

          • 可用算術(shù)運(yùn)算符聯(lián)接或重復(fù)序列。

          • 比較運(yùn)算符(<,<=,>,>=,!=,==)也可用于序列。

          • 可通過(guò)下標(biāo)(test[1]),切片(test[1:3])和解包來(lái)訪問(wèn)序列的某部份。解包示例如下:

            >>>s=1,2,3 
            >>>x,y,z=s
            >>>print x,y,z
            1,2,3
          • in運(yùn)算符可判斷當(dāng)有對(duì)象是否序列對(duì)象成員,如:

            >>>list = [1,2,3]
            >>>1 in list
            1
            >>>4 in list
            0
          • 也可通過(guò)循環(huán)運(yùn)算符對(duì)序列對(duì)象進(jìn)行迭代操作。如:

            for day in days:
            print day

          有關(guān)序列的處理函數(shù)請(qǐng)參考“python參考篇”相關(guān)內(nèi)容,這里就不詳細(xì)講了。

          3.6. Dictionary字典

          字典是一個(gè)用大括號(hào)括起來(lái)的鍵值對(duì),字典元素分為兩部份,鍵(key)和值。字典是python中唯一內(nèi)置映射數(shù)據(jù)類型。通過(guò)指定的鍵從字典訪問(wèn)值。如:

          monthdays = { "Jan":31, "Feb":28, "Mar":31, "Apr":30, "May":31, "Jun":30, "Jul":31, "Aug":31, "Sep":30, "Oct":31, "Nov":30,"Dec":31 }
          • 字典可嵌套,可以在一個(gè)字典里包含另一個(gè)字典。如test={"test":{"mytest":10} }

          • 可用鍵訪問(wèn)字典,如monthdays["Jan"],可訪問(wèn)值31。如果沒(méi)有找到指定的鍵,則解釋器會(huì)引起異常。

          • 字典是可修改,如monthdays["Jan"]=30,可把Jan的值由31改為30。如monthdays["test"]=30可添加一個(gè)新鍵值對(duì)。

          • del monthdays["test"]可刪除字典條目。

          • 字典不屬序列對(duì)象,所以不能進(jìn)行連接和相乘操作。字典是沒(méi)有順序的。

          • 字典提供keys和values方法,用來(lái)返回字典中定義的所有鍵和值。

          • 和列表一樣,字典也提供了對(duì)象方法來(lái)對(duì)字典進(jìn)行操作。

            Table 3.4. 字典方法

            方法描述
            has_key(x) 如果字典中有鍵x,則返回真。
            keys() 返回字典中鍵的列表
            values() 返回字典中值的列表。
            items() 返回tuples的列表。每個(gè)tuple由字典的鍵和相應(yīng)值組成。
            clear() 刪除字典的所有條目。
            copy() 返回字典高層結(jié)構(gòu)的一個(gè)拷貝,但不復(fù)制嵌入結(jié)構(gòu),而只復(fù)制對(duì)那些結(jié)構(gòu)的引用。
            update(x) 用字典x中的鍵值對(duì)更新字典內(nèi)容。
            get(x[,y]) 返回鍵x,若未找到該鍵返回none,若提供y,則未找到x時(shí)返回y。

          3.7. File文件

          可用內(nèi)置的open()函數(shù)對(duì)文件進(jìn)行操作。如:

          input = open("test.txt")
          for line in input.readlines():
          print line
          input.close()

          3.8. 理解引用

          • Python把一塊數(shù)據(jù)存儲(chǔ)在對(duì)象中,變量是對(duì)象的唯一引用;它們是計(jì)算機(jī)內(nèi)存中特殊地點(diǎn)的名字。所有對(duì)象都具有唯一的身份號(hào)、類型和值。對(duì)象的類型不會(huì)改變,對(duì)于可變類型而言,它的值是可變的。id(obj)函數(shù)可用于檢索對(duì)象的身份,也就是內(nèi)存中的對(duì)象的地址。

          • 每 個(gè)對(duì)象都包含引用計(jì)數(shù)器,它記錄當(dāng)前有多少個(gè)變量正在引用該對(duì)象。當(dāng)給對(duì)象指定一個(gè)變量或使對(duì)象成為列表或其它包容器的成員時(shí),引用計(jì)數(shù)就增加;當(dāng)從包容 器中撤消、重新分配或刪除對(duì)象時(shí),引用計(jì)數(shù)減少。當(dāng)引用計(jì)數(shù)達(dá)到0值時(shí)(即沒(méi)有任何變量引用這個(gè)對(duì)象),python的回收機(jī)制會(huì)自動(dòng)回收它使用的內(nèi)存。 注意,del可用來(lái)刪除變量,但不能刪除對(duì)象。

            [Note]
            sys.getrefcount(obj)函數(shù)可返回給定對(duì)象的引用計(jì)數(shù)。

          3.9. copy and deepcopy

          通過(guò)給列表分配一個(gè)變量能創(chuàng)建對(duì)列表的引用,如果要?jiǎng)?chuàng)建列表的副本就要理解淺副本和深副本的概念。

          • 列表或其他包容器對(duì)象的淺副本(Shallow)能夠生成對(duì)象本身的副本,但也會(huì)創(chuàng)建對(duì)由列表包含的對(duì)象的引用。可用分片(object[:])和copy模塊的copy(obj)函數(shù)創(chuàng)建。

          • 列表或其他對(duì)象包容器對(duì)象的深副本能夠生成對(duì)象本身的副本,并遞歸地生成所有子對(duì)象的副本。可用copy模塊的deepcopy(obj)函數(shù)創(chuàng)建。

          比較兩種副本,一般情況下表現(xiàn)一樣,但當(dāng)列表內(nèi)包含另一個(gè)列表的情況下,父列表的淺副本將包含對(duì)子列表引用,而不是獨(dú)立副本。其結(jié)果是,當(dāng)更改內(nèi)部列表時(shí),從父列表的兩個(gè)副本中都可見(jiàn),如:

          >>> a=[1,2,3,[4,5]]
          >>> b=a[:]
          >>> b
          [1, 2, 3, [4, 5]]
          >>> a[3].remove(4)
          >>> a
          [1, 2, 3, [5]]
          >>> b
          [1, 2, 3, [5]]

          如果是深副本,就不會(huì)出現(xiàn)這種情況。如:

          >>> a=[1,2,3,[4,5]]
          >>> b=copy.deepcopy(a)
          >>> b
          [1, 2, 3, [4, 5]]
          >>> a[3].remove(4)
          >>> a
          [1, 2, 3, [5]]
          >>> b
          [1, 2, 3, [4, 5]]

          3.10. 標(biāo)識(shí)數(shù)據(jù)類型

          可通過(guò)type(obj)函數(shù)標(biāo)識(shí)數(shù)據(jù)類型,如:

          >>> type(a)
          <type 'list'>
          >>> type(copy)
          <type 'module'>
          >>> type(1)
          <type 'int'>

          types模塊包含Python的內(nèi)置數(shù)據(jù)類型的類型對(duì)象。如:

          >>> import types
          >>> types.ListType
          <type 'list'>
          >>> types.IntType
          <type 'int'>

          3.11. 數(shù)組對(duì)象

          數(shù)組對(duì)象與列表類似,但數(shù)組只包含某些類型的簡(jiǎn)單數(shù)據(jù)。所以當(dāng)數(shù)據(jù)較簡(jiǎn)單,且要求性能好的情況下,使用數(shù)組是一個(gè)好的選擇。

          Table 3.5. 數(shù)組類型代碼

          代碼等價(jià)的C類型以字節(jié)為單位的最小尺寸
          c char 1
          b(B) byte(unsigned byte) 1
          h(H) short(unsigned short) 2
          i(I) int(unsigned int) 2
          l(L) long(unsigned long) 4
          f float 4
          d double 8

          數(shù)組創(chuàng)建方法如下:

          >>> import array
          >>> z=array.array("b")
          >>> z.append(1)
          >>> z
          array('b', [1])

          數(shù)組的itemsize和typecode成員可分別檢索數(shù)組項(xiàng)的大小和數(shù)組對(duì)象的類型代碼,如:

          >>> z.itemsize
          1
          >>> z.typecode
          'b'

          3.1. 數(shù)組類型與其它數(shù)據(jù)類型的轉(zhuǎn)換

          • tolist()方法可把數(shù)組轉(zhuǎn)換為列表,如:

            >>> z.tolist()
            [1, 2, 3]

            fromlist(list)方法可把列表項(xiàng)附加到數(shù)組的末尾,如:

            >>> z.fromlist([10,11])
            >>> z
            array('b', [1, 2, 3, 10, 11])
            [Note]
            如添加的列表類型與數(shù)組類型不同,則fromlist(list)不會(huì)把任何項(xiàng)添加到數(shù)組對(duì)象中。
          • tostring()方法,可以把數(shù)組轉(zhuǎn)換為字節(jié)的序列,如:

            >>> z.tostring()
            '"x01"x02"x03"n"x0b'

            fromstring(list)方法剛好與tostring()相反,它獲取一個(gè)字節(jié)串,并把它們轉(zhuǎn)換為數(shù)組的值。如:

            >>> z.fromstring(""x0b")
            >>> z
            array('b', [1, 2, 3, 10, 11, 11])
          • tofile(file)方法可把數(shù)組轉(zhuǎn)換為字節(jié)的序列,并把它們寫入文件,如:

            >>> f=open("aa","wb")
            >>> z.tofile(f)
            >>> f.close()

            fromfile(file,count)方法用于從文件對(duì)象中讀取特定數(shù)目的項(xiàng),并把它們附加到數(shù)組中,如:

            >>> z.fromfile(open("aa","rb"),2)
            >>> z
            array('b', [1, 2, 3, 10, 11, 11, 1, 2])

            當(dāng)取數(shù)項(xiàng)大于文件數(shù)據(jù)項(xiàng)時(shí),formfile會(huì)產(chǎn)生EOFError異常。

          • 數(shù)組對(duì)象支持列表中的很多相同函數(shù)和方法:len,append等。訪問(wèn)成員的方法也可列表一樣,可用下標(biāo)和分片。

          Chapter 4. 控制語(yǔ)句

          流程控制是程序設(shè)計(jì)中一個(gè)重要的內(nèi)容,Python支持三種不同的控制結(jié)構(gòu):if,for和while。

          • if語(yǔ)句判斷表達(dá)式是否為真,如果為真則執(zhí)行指定語(yǔ)句。if語(yǔ)句的格式如下:

            if   EXPRESSION1:
            STATEMENT1
            elif EXPRESSION2:
            STATEMENT2
            else:
            STATEMENT3

            如果第一個(gè)表達(dá)式為真,則執(zhí)行statement1,否則進(jìn)行進(jìn)一步的測(cè)試,如果第二個(gè)表達(dá)式為真則執(zhí)行statement2,否則執(zhí)行statement3。

            [Note]
            注意語(yǔ)句的縮進(jìn)量要保持一致。在python中沒(méi)有switch和case語(yǔ)句,我們可通過(guò)多重elif來(lái)達(dá)到相同的效果。

            示例:

            #!/usr/bin/env python

            mytest = raw_input("please input a number:")
            mytest = int(mytest)
            if mytest == 10:
            print "you input number is ten."
            elif mytest == 20:
            print "you input number is twenty."
            else:
            print "another number."

            腳本的執(zhí)行效果:
            t03:~# python test.py
            please input a number:10
            you input number is ten.
            t03:~# python test.py
            please input a number:20
            you input number is twenty.
            t03:~# python test.py
            please input a number:777
            another number.
          • while進(jìn)行循環(huán)控制,它對(duì)表達(dá)式進(jìn)行測(cè)試,如果為真,則循環(huán)執(zhí)行循環(huán)體。格式如下:

            while EXPRESSION:
            STATEMENT
            else:
            STATEMENT

            如果測(cè)試為假,則會(huì)執(zhí)行else塊。如果循環(huán)被中斷(break),則else塊不會(huì)執(zhí)行。

            示例:

            >>> a = 0
            >>> while a < 5:
            ... a = a + 1
            ... print a
            ... else:
            ... print "a's value is five"
            ...
            1
            2
            3
            4
            5
            a's value is five
          • for循環(huán)可遍歷對(duì)象,并可進(jìn)行迭代操作。語(yǔ)名格式如下:

            for TARGET in OBJECTS:
            STATEMENT
            else:
            STATEMENT

            和while一樣,在循環(huán)正常退出時(shí),會(huì)執(zhí)行else塊。

            示例:

            >>> mylist = "for statement"
            >>> for word in mylist:
            ... print word
            ... else:
            ... print "End list"
            ...
            f
            o
            r

            s
            t
            a
            t
            e
            m
            e
            n
            t
            End list
          • 在循環(huán)的過(guò)程中,我們可使用循環(huán)控制語(yǔ)句來(lái)控制循環(huán)的執(zhí)行。有三個(gè)控制語(yǔ)句,分別是break、continue和pass。它們的作用分別是:

            • break語(yǔ)句會(huì)立即退出當(dāng)前循環(huán),不會(huì)執(zhí)行else塊的內(nèi)容。

              示例:

              >>> mylist = ["zope","python","perl","Linux"]
              >>> for technic in mylist:
              ... if technic == "perl":
              ... break
              ... else:
              ... print technic
              ...
              zope
              python
            • continue語(yǔ)句會(huì)忽略后面的語(yǔ)句,強(qiáng)制進(jìn)入下一次循環(huán)。

              示例:

              >>> mylist = ["zope","python","perl","Linux"]
              >>> for technic in mylist:
              ... if technic == "perl":
              ... continue
              ... else:
              ... print technic
              ...
              zope
              python
              Linux
            • pass不做任何事情。

              示例:

              >>> for technic in mylist:
              ... if technic == "perl":
              ... pass
              ... else:
              ... print technic
              ...
              zope
              python
              Linux

          Chapter 5. 函數(shù)

          函數(shù)是一個(gè)能完成特定功能的代碼塊,可在程序中重復(fù)使用,減少程序的代碼量和提高程序的執(zhí)行效率。在python中函數(shù)定義語(yǔ)法如下:

          def function_name(arg1,arg2[,...]):
          statement
          [return value]
          [Note]
          返回值不是必須的,如果沒(méi)有return語(yǔ)句,則Python默認(rèn)返回值None。

          函數(shù)名的命名規(guī)則:

          • 函數(shù)名必須以下劃線或字母開(kāi)頭,可以包含任意字母、數(shù)字或下劃線的組合。不能使用任何的標(biāo)點(diǎn)符號(hào);

          • 函數(shù)名是區(qū)分大小寫的。

          • 函數(shù)名不能是保留字。

          Python使用名稱空間的概念存儲(chǔ)對(duì)象,這個(gè)名稱空間就是對(duì)象作用的區(qū)域, 不同對(duì)象存在于不同的作用域。下面是不同對(duì)象的作用域規(guī)則:

          • 每個(gè)模塊都有自已的全局作用域。

          • 函數(shù)定義的對(duì)象屬局部作用域,只在函數(shù)內(nèi)有效,不會(huì)影響全局作用域中的對(duì)象。

          • 賦值對(duì)象屬局部作用域,除非使用global關(guān)鍵字進(jìn)行聲明。

          LGB規(guī)則是Python查找名字的規(guī)則,下面是LGB規(guī)則:

          • 大多數(shù)名字引用在三個(gè)作用域中查找:先局部(Local),次之全局(Global),再次之內(nèi)置(Build-in)。

            >>> a=2
            >>> b=2
            >>> def test(b):
            ... test=a*b
            ... return test
            >>>print test(10)
            20

            b在局部作用域中找到,a在全局作用域中找到。

          • 如想在局部作用域中改變?nèi)肿饔糜虻膶?duì)象,必須使用global關(guān)鍵字。

            #沒(méi)用global時(shí)的情況
            >>> name="Jims"
            >>> def set():
            ... name="ringkee"
            ...
            >>> set()
            >>> print name
            Jims

            #使用global后的情況
            >>> name="Jims"
            >>> def set1():
            ... global name
            ... name="ringkee"
            ...
            >>> set1()
            >>> print name
            ringkee
          • 'global'聲明把賦值的名字映射到一個(gè)包含它的模塊的作用域中。

          函數(shù)的參數(shù)是函數(shù)與外部溝通的橋梁,它可接收外部傳遞過(guò)來(lái)的值。參數(shù)傳遞的規(guī)則如下:

          • 在一個(gè)函數(shù)中對(duì)參數(shù)名賦值不影響調(diào)用者。

            >>> a=1
            >>> def test(a):
            ... a=a+1
            ... print a
            ...
            >>> test(a)
            2
            >>> a
            1 # a值不變
          • 在一個(gè)函數(shù)中改變一個(gè)可變的對(duì)象參數(shù)會(huì)影響調(diào)用者。

            >>> a=1
            >>> b=[1,2]
            >>> def test(a,b):
            ... a=5
            ... b[0]=4
            ... print a,b
            ...
            >>> test(a,b)
            5 [4, 2]
            >>> a
            1
            >>> b
            [4, 2] # b值已被更改

          參數(shù)是對(duì)象指針,無(wú)需定義傳遞的對(duì)象類型。如:

          >>> def test(a,b):
          ... return a+b
          ...
          >>> test(1,2) #數(shù)值型
          3
          >>> test("a","b") #字符型
          'ab'
          >>> test([12],[11]) #列表
          [12, 11]

          函數(shù)中的參數(shù)接收傳遞的值,參數(shù)可分默認(rèn)參數(shù),如:

          def function(ARG=VALUE)

          元組(Tuples)參數(shù):

          def function(*ARG)

          字典(dictionary)參數(shù):

          def function(**ARG)

          一些函數(shù)規(guī)則:

          • 默認(rèn)值必須在非默認(rèn)參數(shù)之后;

          • 在單個(gè)函數(shù)定義中,只能使用一個(gè)tuple參數(shù)(*ARG)和一個(gè)字典參數(shù)(**ARG)。

          • tuple參數(shù)必須在連接參數(shù)和默認(rèn)參數(shù)之后。

          • 字典參數(shù)必須在最后定義。

          5.1. 常用函數(shù)

          • abs(x)

            abs()返回一個(gè)數(shù)字的絕對(duì)值。如果給出復(fù)數(shù),返回值就是該復(fù)數(shù)的模。

            >>>print abs(-100)
            100
            >>>print abs(1+2j)
            2.2360679775
          • callable(object)

            callable()函數(shù)用于測(cè)試對(duì)象是否可調(diào)用,如果可以則返回1(真);否則返回0(假)。可調(diào)用對(duì)象包括函數(shù)、方法、代碼對(duì)象、類和已經(jīng)定義了“調(diào)用”方法的類實(shí)例。

            >>> a="123"
            >>> print callable(a)
            0
            >>> print callable(chr)
            1
          • cmp(x,y)

            cmp()函數(shù)比較x和y兩個(gè)對(duì)象,并根據(jù)比較結(jié)果返回一個(gè)整數(shù),如果x<y,則返回-1;如果x>y,則返回1,如果x==y則返回0。

            >>>a=1
            >>>b=2
            >>>c=2
            >>> print cmp(a,b)
            -1
            >>> print cmp(b,a)
            1
            >>> print cmp(b,c)
            0
          • divmod(x,y)

            divmod(x,y)函數(shù)完成除法運(yùn)算,返回商和余數(shù)。

            >>> divmod(10,3)
            (3, 1)
            >>> divmod(9,3)
            (3, 0)
          • isinstance(object,class-or-type-or-tuple) -> bool

            測(cè)試對(duì)象類型

            >>> a='isinstance test'
            >>> b=1234
            >>> isinstance(a,str)
            True
            >>> isinstance(a,int)
            False
            >>> isinstance(b,str)
            False
            >>> isinstance(b,int)
            True
          • len(object) -> integer

            len()函數(shù)返回字符串和序列的長(zhǎng)度。

            >>> len("aa")
            2
            >>> len([1,2])
            2
          • pow(x,y[,z])

            pow()函數(shù)返回以x為底,y為指數(shù)的冪。如果給出z值,該函數(shù)就計(jì)算x的y次冪值被z取模的值。

            >>> print pow(2,4)
            16
            >>> print pow(2,4,2)
            0
            >>> print pow(2.4,3)
            13.824
          • range([lower,]stop[,step])

            range()函數(shù)可按參數(shù)生成連續(xù)的有序整數(shù)列表。

            >>> range(10)
            [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
            >>> range(1,10)
            [1, 2, 3, 4, 5, 6, 7, 8, 9]
            >>> range(1,10,2)
            [1, 3, 5, 7, 9]
          • round(x[,n])

            round()函數(shù)返回浮點(diǎn)數(shù)x的四舍五入值,如給出n值,則代表舍入到小數(shù)點(diǎn)后的位數(shù)。

            >>> round(3.333)
            3.0
            >>> round(3)
            3.0
            >>> round(5.9)
            6.0
          • type(obj)

            type()函數(shù)可返回對(duì)象的數(shù)據(jù)類型。

            >>> type(a)
            <type 'list'>
            >>> type(copy)
            <type 'module'>
            >>> type(1)
            <type 'int'>
          • xrange([lower,]stop[,step])

            xrange()函數(shù)與range()類似,但xrnage()并不創(chuàng)建列表,而是返回一個(gè)xrange對(duì)象,它的行為與列表相似,但是只在需要時(shí)才計(jì)算列表值,當(dāng)列表很大時(shí),這個(gè)特性能為我們節(jié)省內(nèi)存。

            >>> a=xrange(10)
            >>> print a[0]
            0
            >>> print a[1]
            1
            >>> print a[2]
            2

          5.2. 內(nèi)置類型轉(zhuǎn)換函數(shù)

          • chr(i)

            chr()函數(shù)返回ASCII碼對(duì)應(yīng)的字符串。

            >>> print chr(65)
            A
            >>> print chr(66)
            B
            >>> print chr(65)+chr(66)
            AB
          • complex(real[,imaginary])

            complex()函數(shù)可把字符串或數(shù)字轉(zhuǎn)換為復(fù)數(shù)。

            >>> complex("2+1j")
            (2+1j)
            >>> complex("2")
            (2+0j)
            >>> complex(2,1)
            (2+1j)
            >>> complex(2L,1)
            (2+1j)
          • float(x)

            float()函數(shù)把一個(gè)數(shù)字或字符串轉(zhuǎn)換成浮點(diǎn)數(shù)。

            >>> float("12")
            12.0
            >>> float(12L)
            12.0
            >>> float(12.2)
            12.199999999999999
          • hex(x)

            hex()函數(shù)可把整數(shù)轉(zhuǎn)換成十六進(jìn)制數(shù)。

            >>> hex(16)
            '0x10'
            >>> hex(123)
            '0x7b'
          • long(x[,base])

            long()函數(shù)把數(shù)字和字符串轉(zhuǎn)換成長(zhǎng)整數(shù),base為可選的基數(shù)。

            >>> long("123")
            123L
            >>> long(11)
            11L
          • list(x)

            list()函數(shù)可將序列對(duì)象轉(zhuǎn)換成列表。如:

            >>> list("hello world")
            ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
            >>> list((1,2,3,4))
            [1, 2, 3, 4]
          • int(x[,base])

            int()函數(shù)把數(shù)字和字符串轉(zhuǎn)換成一個(gè)整數(shù),base為可選的基數(shù)。

            >>> int(3.3)
            3
            >>> int(3L)
            3
            >>> int("13")
            13
            >>> int("14",15)
            19
          • min(x[,y,z...])

            min()函數(shù)返回給定參數(shù)的最小值,參數(shù)可以為序列。

            >>> min(1,2,3,4)
            1
            >>> min((1,2,3),(2,3,4))
            (1, 2, 3)
          • max(x[,y,z...])

            max()函數(shù)返回給定參數(shù)的最大值,參數(shù)可以為序列。

            >>> max(1,2,3,4)
            4
            >>> max((1,2,3),(2,3,4))
            (2, 3, 4)
          • oct(x)

            oct()函數(shù)可把給出的整數(shù)轉(zhuǎn)換成八進(jìn)制數(shù)。

            >>> oct(8)
            '010'
            >>> oct(123)
            '0173'
          • ord(x)

            ord()函數(shù)返回一個(gè)字符串參數(shù)的ASCII碼或Unicode值。

            >>> ord("a")
            97
            >>> ord(u"a")
            97
          • str(obj)

            str()函數(shù)把對(duì)象轉(zhuǎn)換成可打印字符串。

            >>> str("4")
            '4'
            >>> str(4)
            '4'
            >>> str(3+2j)
            '(3+2j)'
          • tuple(x)

            tuple()函數(shù)把序列對(duì)象轉(zhuǎn)換成tuple。

            >>> tuple("hello world")
            ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
            >>> tuple([1,2,3,4])
            (1, 2, 3, 4)

          5.3. 序列處理函數(shù)

          • 常用函數(shù)中的len()、max()和min()同樣可用于序列。

          • filter(function,list)

            調(diào)用filter()時(shí),它會(huì)把一個(gè)函數(shù)應(yīng)用于序列中的每個(gè)項(xiàng),并返回該函數(shù)返回真值時(shí)的所有項(xiàng),從而過(guò)濾掉返回假值的所有項(xiàng)。

            >>> def nobad(s):
            ... return s.find("bad") == -1
            ...
            >>> s = ["bad","good","bade","we"]
            >>> filter(nobad,s)
            ['good', 'we']

            這個(gè)例子通過(guò)把nobad()函數(shù)應(yīng)用于s序列中所有項(xiàng),過(guò)濾掉所有包含“bad”的項(xiàng)。

          • map(function,list[,list])

            map()函數(shù)把一個(gè)函數(shù)應(yīng)用于序列中所有項(xiàng),并返回一個(gè)列表。

            >>> import string
            >>> s=["python","zope","linux"]
            >>> map(string.capitalize,s)
            ['Python', 'Zope', 'Linux']

            map()還可同時(shí)應(yīng)用于多個(gè)列表。如:

            >>> import operator
            >>> s=[1,2,3]; t=[3,2,1]
            >>> map(operator.mul,s,t) # s[i]*t[j]
            [3, 4, 3]

            如果傳遞一個(gè)None值,而不是一個(gè)函數(shù),則map()會(huì)把每個(gè)序列中的相應(yīng)元素合并起來(lái),并返回該元組。如:

            >>> a=[1,2];b=[3,4];c=[5,6]
            >>> map(None,a,b,c)
            [(1, 3, 5), (2, 4, 6)]
          • reduce(function,seq[,init])

            reduce()函數(shù)獲得序列中前兩個(gè)項(xiàng),并把它傳遞給提供的函數(shù),獲得結(jié)果后再取序列中的下一項(xiàng),連同結(jié)果再傳遞給函數(shù),以此類推,直到處理完所有項(xiàng)為止。

            >>> import operator
            >>> reduce(operator.mul,[2,3,4,5]) # ((2*3)*4)*5
            120
            >>> reduce(operator.mul,[2,3,4,5],1) # (((1*2)*3)*4)*5
            120
            >>> reduce(operator.mul,[2,3,4,5],2) # (((2*2)*3)*4)*5
            240
          • zip(seq[,seq,...])

            zip()函數(shù)可把兩個(gè)或多個(gè)序列中的相應(yīng)項(xiàng)合并在一起,并以元組的格式返回它們,在處理完最短序列中的所有項(xiàng)后就停止。

            >>> zip([1,2,3],[4,5],[7,8,9])
            [(1, 4, 7), (2, 5, 8)]

            如果參數(shù)是一個(gè)序列,則zip()會(huì)以一元組的格式返回每個(gè)項(xiàng),如:

            >>> zip((1,2,3,4,5))
            [(1,), (2,), (3,), (4,), (5,)]
            >>> zip([1,2,3,4,5])
            [(1,), (2,), (3,), (4,), (5,)]

          Chapter 6. 模塊

          模塊可把一個(gè)復(fù)雜的程序按功能分開(kāi),分別存放到不同文件中,使程序更容易維護(hù)和管理。在Python中的模塊是一個(gè)以.py結(jié)尾的Python代碼文件。可通過(guò)import命令輸入,如:

          import sys

          import會(huì)完成以下三個(gè)操作:

          • 創(chuàng)建新的名稱空間(namespace),該名稱空間中擁有輸入模塊中定義的所有對(duì)象;

          • 執(zhí)行模塊中的代碼;

          • 創(chuàng)建該名稱空間的變量名。

          import語(yǔ)句可同時(shí)輸入多個(gè)模塊,如:

          import os,sys,system

          也可寫成:

          import os
          import sys
          import system

          有些模塊的名稱很長(zhǎng),我們可在輸入時(shí)給它起個(gè)簡(jiǎn)單的別名,這樣在使用模塊中的對(duì)象就方便很多,如:

          import ftplib as ftp

          有時(shí)我們可能只想使用模塊中某個(gè)對(duì)象,又不想把整個(gè)模塊輸入,則可以用from...import語(yǔ)句輸入特定對(duì)象。如:

          from ftplib import FTP

          這樣,我們就可直接使用FTP(),而不用帶前綴。

          如果裝載模塊出錯(cuò),會(huì)引發(fā)ImportError異常。我們可捕獲該異常進(jìn)行相應(yīng)處理。

          Python 腳本和模塊都是一個(gè)以.py結(jié)束的文件,那程序是如何判斷一個(gè).py文件是作為腳本還是模塊呢?關(guān)鍵是一個(gè)名為_(kāi)_name__的變量,如果它的值是 __main__,則不能作為模塊,只能作為腳本直接運(yùn)行。所以在很多腳本的最后都有一段類似下面的語(yǔ)句,限制只能以腳本方式運(yùn)行,不作為模塊:

          if __name__ == '__main__':
          main()

          幾個(gè)功能相近的模塊我們可組成一個(gè)Python包,存放到一個(gè)目錄結(jié)構(gòu)中,通過(guò)輸入包的路徑來(lái)調(diào)用對(duì)象。要定義包,就要建一個(gè)與包名同 名的目錄,接著在該目錄下創(chuàng)建__init__.py文件。該文件是包的初始化文件,可以為空,也可定義一個(gè)代碼。例如一個(gè)WebDesign包的目錄如 下:

          /WebDesign
          __init_.py
          design.py
          draw.py
          ...

          我們可通過(guò)以下語(yǔ)句輸入design模塊:

          import WebDesign.design

          6.1. String模塊

          • replace(string,old,new[,maxsplit])

            字符串的替換函數(shù),把字符串中的old替換成new。默認(rèn)是把string中所有的old值替換成new值,如果給出maxsplit值,還可控制替換的個(gè)數(shù),如果maxsplit為1,則只替換第一個(gè)old值。

            >>>a="11223344"
            >>>print string.replace(a,"1","one")
            oneone2223344
            >>>print string.replace(a,"1","one",1)
            one12223344
          • capitalize(string)

            該函數(shù)可把字符串的首個(gè)字符替換成大字。

            >>> import string
            >>> print string.capitalize("python")
            Python
          • split(string,sep=None,maxsplit=-1)

            從string字符串中返回一個(gè)列表,以sep的值為分界符。

            >>> import string
            >>> ip="192.168.3.3"
            >>> ip_list=string.split(ip,'.')
            >>> print ip_list
            ['192', '168', '3', '3']
          • join(string[,sep])

            返回用sep連接的字串,默認(rèn)的sep是空格。

            >>> import string
            >>> a = ['a','b','c']
            >>> b = string.join(a,'-')
            >>> b
            'a-b-c'
            >>> a
            ['a', 'b', 'c']

          6.2. time模塊

          內(nèi)置模塊time包含很多與時(shí)間相關(guān)函數(shù)。我們可通過(guò)它獲得當(dāng)前的時(shí)間和格式化時(shí)間輸出。

          • time(),以浮點(diǎn)形式返回自Linux新世紀(jì)以來(lái)經(jīng)過(guò)的秒數(shù)。在linux中,00:00:00 UTC, January 1, 1970是新紀(jì)元的開(kāi)始。

            >>> time.time()
            1150269086.6630149
            >>> time.ctime(1150269086.6630149)
            >>> 'Wed Jun 14 15:11:26 2006'
          • ctime([sec]),把秒數(shù)轉(zhuǎn)換成日期格式,如果不帶參數(shù),則顯示當(dāng)前的時(shí)間。

            >>> import time
            >>> time.ctime()
            >>> 'Wed Jun 14 15:02:50 2006'
            >>> time.ctime(1138068452427683)
            'Sat Dec 14 04:51:44 1901'
          • sleep(secs),定時(shí)。

            >>> time.sleep(10) 
            >>> #10秒后才會(huì)出現(xiàn)>>>提示符

          Chapter 7. 類

          類是面向?qū)ο缶幊痰囊粋€(gè)重要概念。通過(guò)類的創(chuàng)建和繼承,可重用代碼,減少代碼復(fù)雜度。Python是一種面向?qū)ο蟮哪_本語(yǔ)言,用class語(yǔ)句可創(chuàng)建類,語(yǔ)法規(guī)則如下:

          class classnmae([class_parent,...]):
          ...
          def method():
          ...
          ...

          一個(gè)例子:

          #!/usr/bin/python
          #-*- encoding:utf-8 -*-

          class test: #定義一個(gè)test類
          desc = "這是一個(gè)測(cè)試類。" #在類中定義一個(gè)屬性desc

          def __init__(self,name1): #對(duì)象構(gòu)造函數(shù),初始化類
          self.name1 = name1

          def show(self,name2): #在類中定義一個(gè)方法show()
          print "hello world"
          print 'name1:',self.name1
          print 'name2:',name2

          instance = test('這是傳遞給name1的值') #生成test類的實(shí)例對(duì)象instance

          print instance.desc #調(diào)用類中的desc屬性

          instance.show('這是傳遞給name2的值') #調(diào)用類中的show()方法

          把該腳本命名為test.py,并用chmod +x test.py使腳本有執(zhí)行的權(quán)限 ,運(yùn)行該腳本結(jié)果如下:

          debian:~/python# ./test.py
          這是一個(gè)測(cè)試類。
          hello world
          name1: 這是傳遞給name1的值
          name2: 這是傳遞給name2的值

          這里只是Python語(yǔ)言中類的一個(gè)簡(jiǎn)單介紹。詳細(xì)介紹可參考網(wǎng)站上自由文檔欄目中的Python資料。

          Chapter 8. 異常處理

          Python的異常處理能力是很強(qiáng)大的,可向用戶準(zhǔn)確反饋出錯(cuò)信息。在Python中,異常也是對(duì)象,可對(duì)它進(jìn)行操作。所有異常都是基類Exception的成員。異常處理的try語(yǔ)法有兩種,一種是:

          try:
          block
          except [exception,[data...]]:
          block
          else:
          block

          該種異常處理語(yǔ)法的規(guī)則是:

          • 執(zhí)行try下的語(yǔ)句,如果引發(fā)異常,則執(zhí)行過(guò)程會(huì)跳到第一個(gè)except語(yǔ)句。

          • 如果第一個(gè)except中定義的異常與引發(fā)的異常匹配,則執(zhí)行該except中的語(yǔ)句。

          • 如果引發(fā)的異常不匹配第一個(gè)except,則會(huì)搜索第二個(gè)except,允許編寫的except數(shù)量沒(méi)有限制。

          • 如果所有的except都不匹配,則異常會(huì)傳遞到下一個(gè)調(diào)用本代碼的最高層try代碼中。

          • 如果沒(méi)有發(fā)生異常,則執(zhí)行else塊代碼。

          try語(yǔ)句的第二種語(yǔ)法是:

          try:
          block
          finally:
          block

          該語(yǔ)句的執(zhí)行規(guī)則是:

          • 執(zhí)行try下的代碼。

          • 如果發(fā)生異常,在該異常傳遞到下一級(jí)try時(shí),執(zhí)行finally中的代碼。

          • 如果沒(méi)有發(fā)生異常,則執(zhí)行finally中的代碼。

          第二種try語(yǔ)法在無(wú)論有沒(méi)有發(fā)生異常都要執(zhí)行代碼的情況下是很有用的。例如我們?cè)趐ython中打開(kāi)一個(gè)文件進(jìn)行讀寫操作,我在操作過(guò)程中不管是否出現(xiàn)異常,最終我都是要把該文件關(guān)閉的。

          除了系統(tǒng)引發(fā)的異常外,我們還可用raise語(yǔ)句手工引發(fā)一個(gè)異常:

          raise [exception[,data]]

          Chapter 9. 文件處理

          文件是我們儲(chǔ)存信息的地方,我們經(jīng)常要對(duì)文件進(jìn)行讀、寫、刪除等的操作,在Python中,我們可用Python提供的函數(shù)和方法方便地操作文件。

          9.1. 文件處理的函數(shù)和方法

          使用Open()函數(shù)可打開(kāi)文件,語(yǔ)法格式如下:

          file_handler = open(filename,[,mode[,bufsize]]

          filename是你要操作的文件名,如果不在當(dāng)前路徑,需指出具體路徑。mode是打開(kāi)文件的模式,表示你要如何操作文件,bufsize表示是否使用緩存。

          Table 9.1. mode

          模式描述
          r 以讀方式打開(kāi)文件,可讀取文件信息。
          w 以寫方式打開(kāi)文件,可向文件寫入信息。
          a 以追加方式打開(kāi)文件,文件指針自動(dòng)移到文件尾。
          r+ 以讀寫方式打開(kāi)文件,可對(duì)文件進(jìn)行讀和寫操作。
          w+ 消除文件內(nèi)容,然后以讀寫方式打開(kāi)文件。
          a+ 以讀寫方式打開(kāi)文件,并把文件指針移到文件尾。
          b 以二進(jìn)制模式打開(kāi)文件,而不是以文本模式。該模式只對(duì)Windows或Dos有效,類Unix的文件是用二進(jìn)制模式進(jìn)行操作的。

          Table 9.2. bufsize

          bufsize取值描述
          0 禁用緩沖
          1 行緩沖
          >1 指定緩沖區(qū)的大小
          <1 系統(tǒng)默認(rèn)的緩沖區(qū)大小

          open()函數(shù)返回一個(gè)文件對(duì)象,我們可通過(guò)read()或write()函數(shù)對(duì)文件進(jìn)行讀寫操作,下面是一些文件對(duì)象方法:

          Table 9.3. 文件對(duì)象方法

          方法描述
          f.close() 關(guān)閉文件,記住用open()打開(kāi)文件后一定要記得關(guān)閉它,否則會(huì)占用系統(tǒng)的可打開(kāi)文件句柄數(shù)。
          f.fileno() 獲得文件描述符
          f.flush() 刷新輸出緩存
          f.isatty() 如果文件是一個(gè)交互終端,則返回True,否則返回False。
          f.read([count]) 讀出文件,如果有count,則讀出count個(gè)字節(jié)。
          f.readline() 讀出一行信息。
          f.readlines() 讀出所有行,也就是讀出整個(gè)文件的信息。
          f.seek(offset[,where]) 把文件指針移動(dòng)到相對(duì)于where的offset位置。offset為0表示文件開(kāi)始處,這是默認(rèn)值 ;1表示當(dāng)前位置;2表示文件結(jié)尾。
          f.tell() 獲得文件指針位置。
          f.truncate([size]) 截取文件,使文件的大小為size。
          f.write(string) 把string字符串寫入文件。
          f.writelines(list) 把list中的字符串一行一行地寫入文件。

          9.2. 示例

          • 文件的打開(kāi)或創(chuàng)建

            #!/usr/bin/env python
            #-*- encoding:UTF-8 -*-

            filehandler = open('test.txt','w') #以寫模式打開(kāi)文件,如果文件不存在則創(chuàng)建
            filehandler.write('this is a file open/create test."nthe second line.')

            filehandler.close()
            #!/usr/bin/env python
            #-*- encoding:UTF-8 -*-

            filehandler = open('test.txt','a') #以追加模式打開(kāi)文件,如果文件不存在則創(chuàng)建

            filehandler.write('"nappend the text in another line."n')

            filehandler.close()
          • 讀取文件

            #!/usr/bin/env python
            #-*- encoding:UTF-8 -*-

            filehandler = open('test.txt','r') #以讀方式打開(kāi)文件,rb為二進(jìn)制方式(如圖片或可執(zhí)行文件等)

            print 'read() function:' #讀取整個(gè)文件
            print filehandler.read()

            print 'readline() function:' #返回文件頭,讀取一行
            filehandler.seek(0)
            print filehandler.readline()

            print 'readlines() function:' #返回文件頭,返回所有行的列表
            filehandler.seek(0)
            print filehandler.readlines()

            print 'list all lines' #返回文件頭,顯示所有行
            filehandler.seek(0)
            textlist = filehandler.readlines()
            for line in textlist:
            print line

            print 'seek() function' #移位到第32個(gè)字符,從33個(gè)字符開(kāi)始顯示余下內(nèi)容
            filehandler.seek(32)
            print filehandler.read()

            print 'tell() function' #移位到文件頭,從頭開(kāi)始顯示2位字符
            filehandler.seek(0)
            print filehandler.readline() #顯示第一行內(nèi)容
            print filehandler.tell() #顯示當(dāng)前位置
            print filehandler.readline() #顯示第二行內(nèi)容
            print filehandler.read() #顯示余下所有內(nèi)容

            filehandler.close() #關(guān)閉文件句柄
          • 文件系統(tǒng)操作

            #!/usr/bin/env python
            #-*- encoding:utf-8 -*-

            import os,fnmatch,glob

            for fileName in os.listdir ( '/root' ): #列出/root目錄內(nèi)容,不包括.和..
            print fileName

            os.mkdir('py') #在當(dāng)前目錄下創(chuàng)建一個(gè)py目錄,且只能創(chuàng)建一層
            os.rmdir( 'py') #在當(dāng)前目錄下刪除py目錄,且只能刪除一層
            os.makedirs('py/aa') #可創(chuàng)建多層目錄
            os.removedirs('py/aa') #可刪除多層目錄


            print 'demonstration fnmatch module'
            for fileName in os.listdir ( '/root/python/file' ):
            if fnmatch.fnmatch(fileName,'*.txt'): #利用UNIX風(fēng)格的通配,只顯示后綴為txt的文件
            print fileName

            print 'demonstration glob module'
            for fileName in glob.glob ( '*.txt' ): #利用UNIX風(fēng)格的通配,只顯示后綴為txt的文件
            print fileName
          • 獲取文件狀態(tài)

            #!/usr/bin/env python
            #-*- encoding:UTF-8 -*-

            import os,time,stat

            fileStats = os.stat ( 'test.txt' ) #獲取文件/目錄的狀態(tài)
            fileInfo = {
            'Size':fileStats [ stat.ST_SIZE ], #獲取文件大小
            'LastModified':time.ctime( fileStats [ stat.ST_MTIME ] ), #獲取文件最后修改時(shí)間
            'LastAccessed':time.ctime( fileStats [ stat.ST_ATIME ] ), #獲取文件最后訪問(wèn)時(shí)間
            'CreationTime':time.ctime( fileStats [ stat.ST_CTIME ] ), #獲取文件創(chuàng)建時(shí)間
            'Mode':fileStats [ stat.ST_MODE ] #獲取文件的模式
            }
            #print fileInfo

            for field in fileInfo: #顯示對(duì)象內(nèi)容
            print '%s:%s' % (field,fileInfo[field])

            #for infoField,infoValue in fileInfo:
            # print '%s:%s' % (infoField,infoValue)
            if stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ): #判斷是否路徑
            print 'Directory. '
            else:
            print 'Non-directory.'

            if stat.S_ISREG ( fileStats [ stat.ST_MODE ] ): #判斷是否一般文件
            print 'Regular file.'
            elif stat.S_ISLNK ( fileStats [ stat.ST_MODe ] ): #判斷是否鏈接文件
            print 'Shortcut.'
            elif stat.S_ISSOCK ( fileStats [ stat.ST_MODe ] ): #判斷是否套接字文件
            print 'Socket.'
            elif stat.S_ISFIFO ( fileStats [ stat.ST_MODe ] ): #判斷是否命名管道
            print 'Named pipe.'
            elif stat.S_ISBLK ( fileStats [ stat.ST_MODe ] ): #判斷是否塊設(shè)備
            print 'Block special device.'
            elif stat.S_ISCHR ( fileStats [ stat.ST_MODe ] ): #判斷是否字符設(shè)置
            print 'Character special device.'
            #!/usr/bin/env python
            #-*- encoding:UTF-8 -*-

            import os.path

            fileStats = 'test.txt'

            if os.path.isdir ( fileStats ): #判斷是否路徑
            print 'Directory.'
            elif os.path.isfile ( fileStats ): #判斷是否一般文件
            print 'File.'
            elif os.path.islink ( fileStats ): #判斷是否鏈接文件
            print 'Shortcut.'
            elif os.path.ismount ( fileStats ): #判斷是否掛接點(diǎn)
            print 'Mount point.'

            stat模塊描述了os.stat(filename)返回的文件屬性列表中各值的意義。我們可方便地根據(jù)stat模塊存取os.stat()中的值。

          • 串行化文件

            #!/usr/bin/env python
            #-*- encoding:UTF-8 -*-

            import pickle

            filehandler = open('pickle.txt','w')

            text = ['this is a pickle demonstrate','aa','bb']

            pickle.dump(text,filehandler) #把text的內(nèi)容序列化后保存到pickle.txt文件中

            filehandler.close()

            filehandler2 = open('pickle.txt')

            textlist = pickle.load(filehandler2) #還原序列化字符串
            print textlist

            filehandler2.close()

            #cpickle是用C寫的pickle模塊,比標(biāo)準(zhǔn)的pickle速度快很多,使用方法同pickle。
          • 內(nèi)存文件

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

            import StringIO

            fileHandle = StringIO.StringIO ( "Let freedom ring." ) #create file in memory

            print fileHandle.read() # "Let freedom ring."

            fileHandle.close()

            #cStringIO是用C寫的StringIO模塊,執(zhí)行速度比StringIO快。

          shutil模塊是一個(gè)高級(jí)的文件處理模塊,可實(shí)現(xiàn)文件的拷貝、刪除等操作。

          Chapter 10. 正則表達(dá)式

          正則表達(dá)式是一個(gè)很有用的工具,可處理復(fù)雜的字符匹配和替換工作。在Python中內(nèi)置了一個(gè)re模塊以支持正則表達(dá)式。

          正則表達(dá)式有兩種基本的操作,分別是匹配和替換。

          • 匹配就是在一個(gè)文本字符串中搜索匹配一特殊表達(dá)式;

          • 替換就是在一個(gè)字符串中查找并替換匹配一特殊表達(dá)式的字符串。

          10.1. 基本元素

          正則表達(dá)式定義了一系列的特殊字符元素以執(zhí)行匹配動(dòng)作。

          Table 10.1. 正則表達(dá)式基本字符

          字符描述
          text 匹配text字符串
          . 匹配除換行符之外的任意一個(gè)單個(gè)字符
          ^ 匹配一個(gè)字符串的開(kāi)頭
          $ 匹配一個(gè)字符串的末尾

          在正則表達(dá)式中,我們還可用匹配限定符來(lái)約束匹配的次數(shù)。

          Table 10.2. 匹配限定符

          最大匹配最小匹配描述
          * *? 重復(fù)匹配前表達(dá)式零次或多次
          + +? 重復(fù)匹配前表達(dá)式一次或多次
          ? ?? 重復(fù)匹配前表達(dá)式零次或一次
          {m} {m}? 精確重復(fù)匹配前表達(dá)式m次
          {m,} {m,}? 至少重復(fù)匹配前表達(dá)式m次
          {m,n} {m,n}? 至少重復(fù)匹配前表達(dá)式m次,至多重復(fù)匹配前表達(dá)式n次

          據(jù) 上所述,".*"為最大匹配,能匹配源字符串所有能匹配的字符串。".*?"為最小匹配,只匹配第一次出現(xiàn)的字符串。如:d.*g能匹配任意以d開(kāi)頭,以 g結(jié)尾的字符串,如"debug"和"debugging",甚至"dog is walking"。而d.*?g只能匹配"debug",在"dog is walking"字符串中,則只匹配到"dog "。

          在一些更復(fù)雜的匹配中,我們可用到組和運(yùn)算符。

          Table 10.3. 組和運(yùn)算符

          描述
          [...] 匹配集合內(nèi)的字符,如[a-z],[1-9]或[,./;']
          [^...] 匹配除集合外的所有字符,相當(dāng)于取反操作
          A|B 匹配表達(dá)式A或B,相當(dāng)于OR操作
          (...) 表達(dá)式分組,每對(duì)括號(hào)為一組,如([a-b]+)([A-Z]+)([1-9]+)
          "number 匹配在number表達(dá)式組內(nèi)的文本

          "有兩個(gè)作用:

          1,取消元字符的特殊意義(元字符包括 . ^ $ * + ? { } [ ] ( ) \ |); 2,用于下面的特殊字符序列


          有一組特殊的字符序列,用來(lái)匹配具體的字符類型或字符環(huán)境。如"b匹配字符邊界,food"b匹配"food"、"zoofood",而和"foodies"不匹配。

          Table 10.4. 特殊字符序列

          字符描述
          "A 只匹配字符串的開(kāi)始
          "b 匹配一個(gè)單詞邊界
          "B 匹配一個(gè)單詞的非邊界
          "d 匹配任意十進(jìn)制數(shù)字字符,等價(jià)于r'[0-9]'
          "D 匹配任意非十進(jìn)制數(shù)字字符,等價(jià)于r'[^0-9]'
          "s 匹配任意空格字符(空格符、tab制表符、換行符、回車、換頁(yè)符、垂直線符號(hào))
          "S 匹配任意非空格字符
          "w 匹配任意字母數(shù)字字符下劃線
          "W 匹配任意非字母數(shù)字字符下劃線
          "Z 僅匹配字符串的尾部
          "" 匹配反斜線字符

          有一套聲明(assertion)對(duì)具體事件進(jìn)行聲明。

          Table 10.5. 正則表達(dá)式聲明

          聲明描述
          (?iLmsux) 匹配空字符串,iLmsux字符對(duì)應(yīng)下表的正則表達(dá)式修飾符。
          (?:...) 匹配圓括號(hào)內(nèi)定義的表達(dá)式,但不填充字符組表。
          (?P<name>) 匹配圓括號(hào)內(nèi)定義的表達(dá)式,但匹配的表達(dá)式還可用作name標(biāo)識(shí)的符號(hào)組。
          (?P=name) 匹配所有與前面命名的字符組相匹配的文本。
          (?#...) 引入注釋,忽略圓括號(hào)內(nèi)的內(nèi)容。
          (?=...) 如果所提供的文本與下一個(gè)正則表達(dá)式元素匹配,這之間沒(méi)有多余的文本就匹配。這允許在一個(gè)表達(dá)式中進(jìn)行超前操作,而不影響正則表達(dá)式其余部分的分析。如"Martin"其后緊跟"Brown",則"Martin(?=Brown)"就只與"Martin"匹配。
          (?!...) 僅當(dāng)指定表達(dá)式與下一個(gè)正則表達(dá)式元素不匹配時(shí)匹配,是(?=...)的反操作。
          (?<=...) 如果字符串當(dāng)前位置的前綴字符串是給定文本,就匹配,整個(gè)表達(dá)式就在當(dāng)前位置終止。如(?<=abc)def表達(dá)式與"abcdef"匹配。這種匹配是對(duì)前綴字符數(shù)量的精確匹配。
          (?<!...) 如果字符串當(dāng)前位置的前綴字符串不是給定的正文,就匹配,是(?<=...)的反操作。

          正則表達(dá)式還支持一些處理標(biāo)志,它會(huì)影響正則式的執(zhí)行方法。

          Table 10.6. 處理標(biāo)志

          標(biāo)志描述
          I或IGNORECASE 忽略表達(dá)式的大小寫來(lái)匹配文本。

          10.2. 操作

          通過(guò)re模塊,我們就可在python中利用正則式對(duì)字符串進(jìn)行搜索、抽取和替換操作。如:re.search()函數(shù)能執(zhí)行一個(gè)基本的搜索操作,它能返回一個(gè)MatchObject對(duì)象。re.findall()函數(shù)能返回匹配列表。

          >>> import re
          >>> a="this is my re module test"
          >>> obj = re.search(r'.*is',a)
          >>> print obj
          <_sre.SRE_Match object at 0xb7d7a218>
          >>> obj.group()
          'this is'
          >>> re.findall(r'.*is',a)
          ['this is']

          MatchObject對(duì)象方法

          Table 10.7. MatchObject對(duì)象方法

          方法描述
          expand(template) 展開(kāi)模板中用反斜線定義的內(nèi)容。
          m.group([group,...]) 返回匹配的文本,是個(gè)元組。此文本是與給定group或由其索引數(shù)字定義的組匹配的文本,如果沒(méi)有組定組名,則返回所有匹配項(xiàng)。
          m.groups([default]) 返回一個(gè)元組,該元組包含模式中與所有組匹配的文本。如果給出default參數(shù),default參數(shù)值就是與給定表達(dá)式不匹配的組的返回值。default參數(shù)的默認(rèn)取值為None。
          m.groupdict([default]) 返回一個(gè)字典,該字典包含匹配的所有子組。如果給出default參數(shù),其值就是那些不匹配組的返回值。default參數(shù)的默認(rèn)取值為None。
          m.start([group]) 返回指定group的開(kāi)始位置,或返回全部匹配的開(kāi)始位置。
          m.end([group]) 返回指定group的結(jié)束位置,或返回全部匹配的結(jié)束位置。
          m.span([group]) 返回兩元素組,此元組等價(jià)于關(guān)于一給定組或一個(gè)完整匹配表達(dá)式的(m.start(group),m.end(group)))列表
          m.pos 傳遞給match()或search()函數(shù)的pos值。
          m.endpos 傳遞給match()或search()函數(shù)的endpos值。
          m.lastindex  
          m.lastgroup  
          m.re 創(chuàng)建這個(gè)MatchObject對(duì)象的正則式對(duì)象
          m.string 提供給match()或search()函數(shù)的字符串。

          使用sub()或subn()函數(shù)可在字符串上執(zhí)行替換操作。sub()函數(shù)的基本格式如下:

          sub(pattern,replace,string[,count])

          示例

          >>> str = 'The dog on my bed'
          >>> rep = re.sub('dog','cat',str)
          >>> print rep
          The cat on my bed

          replace參數(shù)可接受函數(shù)。要獲得替換的次數(shù),可使用subn()函數(shù)。subn()函數(shù)返回一個(gè)元組,此元組包含替換了的文本和替換的次數(shù)。

          如果需用同一個(gè)正則式進(jìn)行多次匹配操作,我們可把正則式編譯成內(nèi)部語(yǔ)言,提高處理速度。編譯正則式用compile()函數(shù)來(lái)實(shí)現(xiàn)。compile()函數(shù)的基本格式如下:

          compile(str[,flags])

          str表示需編譯的正則式串,flags是修飾標(biāo)志符。正則式被編譯后生成一個(gè)對(duì)象,該對(duì)象有多種方法和屬性。

          Table 10.8. 正則式對(duì)象方法/屬性

          方法/屬性描述
          r.search(string[,pos[,endpos]]) 同search()函數(shù),但此函數(shù)允許指定搜索的起點(diǎn)和終點(diǎn)
          r.match(string[,pos[,endpos]]) 同match()函數(shù),但此函數(shù)允許指定搜索的起點(diǎn)和終點(diǎn)
          r.split(string[,max]) 同split()函數(shù)
          r.findall(string) 同findall()函數(shù)
          r.sub(replace,string[,count]) 同sub()函數(shù)
          r.subn(replace,string[,count]) 同subn()函數(shù)
          r.flags 創(chuàng)建對(duì)象時(shí)定義的標(biāo)志
          r.groupindex 將r'(?Pid)'定義的符號(hào)組名字映射為組序號(hào)的字典
          r.pattern 在創(chuàng)建對(duì)象時(shí)使用的模式

          轉(zhuǎn)義字符串用re.escape()函數(shù)。

          通過(guò)getattr獲取對(duì)象引用

          >>> li=['a','b']
          >>> getattr(li,'append')
          >>> getattr(li,'append')('c') #相當(dāng)于li.append('c')
          >>> li
          ['a', 'b', 'c']
          >>> handler=getattr(li,'append',None)
          >>> handler
          <built-in method append of list object at 0xb7d4a52c>
          >>> handler('cc') #相當(dāng)于li.append('cc')
          >>> li
          ['a','b','c','cc']
          >>>result = handler('bb')
          >>>li
          ['a','b','c','cc','bb']
          >>>print result
          None

          Chapter 11. 調(diào)試

          Python自帶了一個(gè)調(diào)試器叫pdb,和gcc的調(diào)試工具gdb(GNU symbolic debugger)類似。下面用一個(gè)簡(jiǎn)單的程序來(lái)演示pdb的功能。程序代碼如下:

          #!/usr/bin/python

          import pdb
          a = "aaa"
          pdb.set_trace()
          b = "bbb"
          c = "ccc"
          final = a + b + c
          print final

          該程序已導(dǎo)入pdb模塊,并在代碼中添加的pdb.set_trace()跟蹤點(diǎn)。現(xiàn)在讓我們來(lái)運(yùn)行該程序。

          localhost:~/python/pdb# python pdbtest.py
          --Return--
          > /usr/lib/python2.3/pdb.py(992)set_trace()->None
          -> Pdb().set_trace() # 從跟蹤點(diǎn)開(kāi)始執(zhí)行
          (Pdb) n # n 讀入下一行代碼
          > /root/python/pdb/pdbtest.py(6)?()
          -> b = "bbb"
          (Pdb) n
          > /root/python/pdb/pdbtest.py(7)?()
          -> c = "ccc"
          (Pdb) p b # p 打印變量值
          'bbb'
          (Pdb) l # l 顯示當(dāng)前執(zhí)行位置
          2
          3 import pdb
          4 a = "aaa"
          5 pdb.set_trace()
          6 b = "bbb"
          7 -> c = "ccc"
          8 final = a + b + c
          9 print final
          10
          [EOF]
          (Pdb) n
          > /root/python/pdb/pdbtest.py(8)?()
          -> final = a + b + c
          (Pdb) n # 如果命令和上次的一樣,也可直接按回車,不用輸入'n'
          > /root/python/pdb/pdbtest.py(9)?()
          -> print final
          (Pdb) n
          aaabbbccc
          --Return--
          > /root/python/pdb/pdbtest.py(9)?()->None
          -> print final
          (Pdb) p a,b,c,final
          ('aaa', 'bbb', 'ccc', 'aaabbbccc')
          (Pdb)
          ('aaa', 'bbb', 'ccc', 'aaabbbccc')
          (Pdb) n
          localhost:~/python/pdb# # 返回shell

          pdb還有很多命令,用help命令就可以列出所有的pdb命令,用help p可以查詢p命令的說(shuō)明。

          Chapter 12. HOW-TO

          本章內(nèi)容記錄Python的一些小技巧小知識(shí)。來(lái)源是網(wǎng)上摘錄或自己學(xué)習(xí)所得。

          • 如何判斷操作系統(tǒng)類型

            import sys
            print sys.platform
            print sys.version
          • 顯示和修改python的Module搜索路徑

            >>> import sys
            >>> print sys.path
            ['', '/usr/lib/python23.zip', '/usr/lib/python2.3', '/usr/lib/python2.3/plat-linux2',
            '/usr/lib/python2.3/lib-tk', '/usr/lib/python2.3/lib-dynload', '/usr/local/lib/python2.3/site-packages',
            '/usr/lib/python2.3/site-packages']
            >>> sys.path.append('/usr/lib/mypath')
            >>> print sys.path
            ['', '/usr/lib/python23.zip', '/usr/lib/python2.3', '/usr/lib/python2.3/plat-linux2',
            '/usr/lib/python2.3/lib-tk', '/usr/lib/python2.3/lib-dynload', '/usr/local/lib/python2.3/site-packages',
            '/usr/lib/python2.3/site-packages', '/usr/lib/mypath']
          • 運(yùn)行系統(tǒng)程序,可以用內(nèi)置的exec方法或者os.system()方法

            >>>import os
            >>>os.system('ls') #用os.system()可執(zhí)行系統(tǒng)命令
            >>>exec "os.system('ls')" #用exec可執(zhí)行字符串中的命令,兩個(gè)命令的效果一樣。

            以上兩個(gè)命令的輸出都是直接顯示在屏幕上,不能保存到變量中,如果我們要把輸出保存起來(lái),可用os.popen()函數(shù)。

            >>>cmd = '/usr/bin/mkntpwd %s' % password
            >>>handler = os.popen(cmd,'r')
            >>>passwordString=handler.read() #passwordString為mkntpwd程序的輸出結(jié)果

            使用commands模塊也可以獲取程序的輸出,它包含一些基于os.popen()的封裝函數(shù),使我們能更方便地獲取運(yùn)行系統(tǒng)命令和獲取命令的輸出,但該模塊只在Unix系統(tǒng)下有效,不能用于Windows平臺(tái)

            >>> import commands
            >>> status,output = commands.getstatusoutput('ls -l')
            >>> print output
            總計(jì) 96564
            -rw-r--r-- 1 root root 4459 2005-12-01 10:23 2005.sxw
            -rw-r--r-- 1 root root 27511 2006-04-12 16:54 20060412_user.ods
            -rw-r--r-- 1 root root 202258 2006-01-06 16:48 2006風(fēng)景-1月.jpg
            ...
            >>> print status
            0

            在Python2.4中引入一個(gè)新的模塊叫subprocess,用于取代os.system、os.spawn*、os.popen*、popen2.*、commands.*。

            • exec, eval, repr
                    exec語(yǔ)句用來(lái)執(zhí)行儲(chǔ)存在字符串或文件中的Python語(yǔ)句。eval語(yǔ)句用來(lái)計(jì)算存儲(chǔ)在字符串中的有效python表達(dá)式, 例如:
            >>> exec 'print "Hello World"'
            Hello World
            >>> eval('2*3')
            6
                    reprepr函數(shù)用來(lái)取得對(duì)象的規(guī)范字符串表示。反引號(hào)(也稱轉(zhuǎn)換符)可以完成相同的功能。注意,在大多數(shù)時(shí)候有eval(repr(object)) == objectr函數(shù)用來(lái)取得對(duì)象的規(guī)范字符串表示。反引號(hào)(也稱轉(zhuǎn)換符)可以完成相同的功能。注意,在大多數(shù)時(shí)候有eval(repr(object)) == object
            >>> i = []
            >>> i.append('item')
            >>> `i`
            "['item']"
            >>> repr(i)
            "['item']"
            >>>eval(repr(i))
            ['item']

          • 通過(guò)getattr可以得到一個(gè)在運(yùn)行時(shí)才知道具體函數(shù)名的對(duì)象的引用,能增強(qiáng)我們程序的靈活性。

            >>> li=['a','b']
            >>> getattr(li,'append')
            >>> getattr(li,'append')('c') #相當(dāng)于li.append('c')
            >>> li
            ['a', 'b', 'c']
            >>> handler=getattr(li,'append',None)
            >>> handler
            <built-in method append of list object at 0xb7d4a52c>
            >>> handler('cc') #相當(dāng)于li.append('cc')
            >>> li
            ['a','b','c','cc']
            >>>result = handler('bb')
            >>>li
            ['a','b','c','cc','bb']
            >>>print result
            None

            編程示例:

            import statsout

            def output(data, format="text"):
            output_function = getattr(statsout, "output_%s" % format)
            return output_function(data)

            以上代碼表示,output函數(shù)接收一個(gè)data參數(shù)和format參數(shù),根據(jù)format參數(shù)的值,從statsout模塊中取出 output_text函數(shù)運(yùn)行,data參數(shù)通過(guò)output_function(data)傳遞給了statsout模塊中的output_text 函數(shù)。format取不同值可從statsout模塊中取出不同的函數(shù)運(yùn)行(output_xxxx)。也就是說(shuō)我們要運(yùn)行的函數(shù)是在程序運(yùn)行后才確定 的。這樣我們可把不同的函數(shù)以output_xxx形式命名放在statout模塊中,通過(guò)以上程序可動(dòng)態(tài)調(diào)用各種函數(shù)。

          • __dict__記錄模塊或類中所有對(duì)象的信息,它以字典{name:object}的形式記錄這些信息,如果wikiaction是一個(gè)模塊,則可以這樣顯示:

            >>>import wikiaction
            >>>print wikiaction.__dict__
            {'do_test': <function do_test at 0xb7c10534>, 'do_diff': <function do_diff at 0xb7c0ef0c>, 'do_refresh': <fun
            ction do_refresh at 0xb7c1025c>, 'do_userform': <function do_userform at 0xb7c103e4>, 'getHandler': <function
            getHandler at 0xb7c105a4>, 'do_raw': <function do_raw at 0xb7c10454>, 'do_chart': <function do_chart at 0xb7
            c104c4>, 're': <module 're' from '/usr/lib/python2.3/re.pyc'>, 'pysupport': <module 'MoinMoin.util.pysupport'
            from '/usr/lib/python2.3/site-packages/MoinMoin/util/pysupport.pyc'>, 'config': <module 'MoinMoin.config' fr
            om '/usr/lib/python2.3/site-packages/MoinMoin/config.pyc'>}
          • python中的浮點(diǎn)數(shù)問(wèn)題:
            >>> 0.1
            0.10000000000000001

            >>> round(1.0/3, 2)
            0.33000000000000002
            >>> round(11.0/3, 2)
            3.6699999999999999

                注意所有的編程語(yǔ)言都有這個(gè)問(wèn)題。這是浮點(diǎn)數(shù)在計(jì)算機(jī)中的存儲(chǔ)問(wèn)題。

               考慮十進(jìn)制是0.125這個(gè)小數(shù),其二進(jìn)制表示為0.001,這兩個(gè)數(shù)是完全等同的。    但是不是所有的小數(shù)都有這樣的特性,大多數(shù)的小數(shù)不能用二進(jìn)制精確的表示,其結(jié)果就是,所有十進(jìn)制小數(shù)在計(jì)算機(jī)中都是用其最最近似的方式存儲(chǔ)表示的。
                考慮分?jǐn)?shù)1/3,可以用十進(jìn)制近似成0.3,或者0.33,或者0.333。

            注:小數(shù)部分由十進(jìn)制轉(zhuǎn)二進(jìn)制的方法就是一直去掉整數(shù)部分,小數(shù)部分乘2,直到小數(shù)部分為0為止。
            如:0.625轉(zhuǎn)為二進(jìn)制:
            0.625*2 = 1.25,  整數(shù)部分為1,小數(shù)部分為0.25
            0.25 * 2 = 0.5 ,  整數(shù)部分為0,小數(shù)部分為0.5
            0.5  * 2 = 1   ,    整數(shù)部分為1,小數(shù)部分為0
            所以0.625轉(zhuǎn)為二進(jìn)制的結(jié)果就是0.101
            但是,有些小數(shù),如0.2,再怎么乘2,小數(shù)部分也不會(huì)得到0的,所以,就有誤差了。

            因此,考慮小數(shù)0.1,它不能用二進(jìn)制精確的表示,而是表示成了:

            0.0001100110011001100110011001100110011001100110011...  所以你才看到了最開(kāi)始的情況:

            >>> 0.10.10000000000000001

              注意當(dāng)沒(méi)有使用print時(shí),python解釋器使用repr方法獲得它需要顯示的對(duì)象的字符串形式,對(duì)浮點(diǎn)數(shù)來(lái)說(shuō),

            repr(float)取到小數(shù)點(diǎn)后17位;如果使用print,調(diào)用的是str方法:

            >>> print 0.1
            0.1

              使用round方法并不能取得預(yù)期效果,是因?yàn)?.10000000000000001已經(jīng)是1/10的最近似的數(shù)了,它總是

            取最好的結(jié)果。

            再看一個(gè)示例:

            >>> sum=0.0
            >>> for i in range(10):
             sum+= 0.1

             
            >>> sum
            0.99999999999999989

              很多的浮點(diǎn)數(shù)運(yùn)算有這樣類似的“奇怪”結(jié)果。

              解決辦法是使用python的decimal模塊:

            >>> 0.1*0.5
            0.050000000000000003

            >>> from decimal import *

            >>> Decimal("0.1")*Decimal("0.5")
            Decimal("0.05")

              這個(gè)模塊的功能也比較全面和強(qiáng)大。不予詳細(xì)說(shuō)明。
          • 如何定義static的方法?
            定義static的方法很簡(jiǎn)單,不過(guò)要比在Java和C#中實(shí)現(xiàn)要復(fù)雜一些,因?yàn)樗峭ㄟ^(guò)利用staticmehod(function)的重定義實(shí)現(xiàn),而非關(guān)鍵字。如下所示:
            >>> class Clazz:
                 def methodA(): <-------- 不能有self
                     print "Hello, World."
                 methodA = staticmethod(methodA)  <--------------表示設(shè)為類函數(shù)

            >>> Clazz.methodA()
            Hello, World.
            >>> clazz = Clazz()
            >>> clazz.methodA()
            Hello, World.
          • 類中的特殊方法:
          • 一般說(shuō)來(lái),特殊的方法都被用來(lái)模仿某個(gè)行為。例如,如果你想要為你的類使用x[key]這樣的索引操作(就像列表和元組一樣),那么你只需要實(shí)現(xiàn)__getitem__()方法就可以了。想一下,Python就是對(duì)list類這樣做的!

            下面這個(gè)表中列出了一些有用的特殊方法。如果你想要知道所有的特殊方法,你可以在《Python參考手冊(cè)》中找到一個(gè)龐大的列表。

            名稱                     說(shuō)明
            ---------------------------------------------------------
            __init__(self,...)      這個(gè)方法在新建對(duì)象恰好要被返回使用之前被調(diào)用。
            __del__(self)           恰好在對(duì)象要被刪除之前調(diào)用。
            __str__(self)           在我們對(duì)對(duì)象使用print語(yǔ)句或是使用str()的時(shí)候調(diào)用。
            __lt__(self,other)      當(dāng)使用 小于 運(yùn)算符(<)的時(shí)候調(diào)用。類似地,對(duì)于所有的運(yùn)算符(+,>等等)都有特殊的方法。
            __getitem__(self,key)   使用x[key]索引操作符的時(shí)候調(diào)用。
            __len__(self)           對(duì)序列對(duì)象使用內(nèi)建的len()函數(shù)的時(shí)候調(diào)用。
            __repr__(s)             repr() and `...` conversions
            __cmp__(s, o)           Compares s to o and returns <0, 0, or >0.
                                    Implements >, <, == etc...
            __hash__(s)             Compute a 32 bit hash code; hash() and dictionary ops
            __nonzero__(s)          Returns 0 or 1 for truth value testing
            __getattr__(s, name)    called when attr lookup doesn't find <name>
            __setattr__(s, name, val) called when setting an attr
                                    (inside, don't use "self.name = value"
                                    use "self.__dict__[name] = val")
            __delattr__(s, name)    called to delete attr <name>
            __call__(self, *args)   called when an instance is called as function.

          posted on 2007-09-02 16:18 保爾任 閱讀(5080) 評(píng)論(0)  編輯  收藏 所屬分類: Python

          只有注冊(cè)用戶登錄后才能發(fā)表評(píng)論。


          網(wǎng)站導(dǎo)航:
           

          <2007年9月>
          2627282930311
          2345678
          9101112131415
          16171819202122
          23242526272829
          30123456

          常用鏈接

          留言簿(4)

          隨筆分類

          隨筆檔案

          文章分類

          文章檔案

          搜索

          •  

          最新評(píng)論

          閱讀排行榜

          評(píng)論排行榜

          主站蜘蛛池模板: 穆棱市| 泾阳县| 阿拉善盟| 汝州市| 乃东县| 宜川县| 巫溪县| 黄平县| 溆浦县| 通城县| 调兵山市| 手机| 昌宁县| 合肥市| 玉龙| 渭源县| 玉林市| 锡林浩特市| 泊头市| 宁都县| 隆德县| 阿尔山市| 增城市| 综艺| 铜山县| 上栗县| 乌恰县| 中阳县| 齐齐哈尔市| 邵阳市| 塘沽区| 句容市| 怀远县| 苏尼特右旗| 温宿县| 台南县| 平昌县| 丰城市| 张家川| 太白县| 阳春市|