Python使用一種優(yōu)雅的語法，可讀性強。

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

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

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

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

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

強大的動態(tài)數(shù)據(jù)類型支持，不同數(shù)據(jù)類型相加會引發(fā)一個異常。

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

自動內(nèi)存碎片管理，有效利用內(nèi)存資源。

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

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

Python易于擴展，可以通過C或C++編寫的模塊進行功能擴展。

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

Python可運行在多種計算機平臺和操作系統(tǒng)中，如各位unix，windows，MacOS,OS/2等等。

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

系統(tǒng)編程，提供大量系統(tǒng)接口API，能方便進行系統(tǒng)維護和管理。

圖形處理，有PIL、Tkinter等圖形庫支持，能方便進行圖形處理。

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

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

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

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

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

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

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

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.

    >>> 

    

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

>>>print "hello world"

    hello world

    

以模塊文件方式運行。模塊文件是包含python語句的文本，以.py結(jié)尾。運行模塊文件只要輸入python xxx.py就可以了。

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

#!/usr/local/bin/python

    print "test ............"

    

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

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

在Python中是以縮進來區(qū)分程序功能塊的，縮進的長度不受限制，但就一個功能塊來講，最好保持一致的縮進量。

如果一行中有多條語句，語句間要以分號（;）分隔。

以“#”號開頭的內(nèi)容為注釋，python解釋器會忽略該行內(nèi)容。

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

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

在交互模式下運行python時，一個下劃線字符(_)是特殊標(biāo)識符，它保留了表達式的最后一個計算結(jié)果。

>>> "hello"

    'hello'

    >>> _

    'hello'

    >>> 10+10

    20

    >>> _

    20

    

    

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

def test():

    "this is a document string"

    

    return 100+1000

    

    >>>print test.__doc__

    this is a document string

    

簡單賦值，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僅計算一次，而普通寫法需計算兩次；自變賦值會修改原始對象，而不是創(chuàng)建一個新對象。

整 型---從-2147483648至2147483647，有符號位32位長，可表達的最大數(shù)為2^31-1。 如：number=123，number1=-123。在數(shù)字前加0x或0X 前綴表示十六進制數(shù)，在數(shù)字前加前綴0表示八進制數(shù)，與C/C++ and perl一樣。

	為方便起見，sys模塊包含一個maxint成員，該成員保留了整形變量的最大正數(shù)值。

>>> import sys

    >>> print sys.maxint

    2147483647

    

長整型---python支持任意長度的長整型，長整型的最大值和最小值由可用的內(nèi)存確定。長整型數(shù)在數(shù)字常量尾加L or l，一般都是用L，因為小寫的l太容易與數(shù)字1混淆了。如：long=1232132131231232132132131L。

浮點數(shù)---python支持普通十進制和科學(xué)計數(shù)法表示的浮點數(shù)。如：number=123.456，nubmer1=123.2E10。浮點數(shù)在python中的存儲格式與C中的雙精度數(shù)相同。

復(fù)數(shù)---復(fù)數(shù)的實部和虛部用加號分開，虛部使用后綴j表示，如：number=1.2+2j

字符串在python被看成是單個字符的序列，具有序列對象的特殊功能，字符串是固定的，不可變的。如：string="hello world"。

可在字符串中使用單引號和雙引號。如：string="I'm a boy"。

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

>>> "test \

    ... python"

    'test python'

使用三個單引號或雙引號可使字符串跨行顯示。如：

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

    

使用“+”號可連接字符串。如：string = "hello" + "world"，注意，不能將字符串與其它對象進行連接。如string = "ok" + 5。其實不用“+”號，直接用空格也可連接兩個字符串。如：string="hello" "world"。

可用“*”號重復(fù)字符串，如：'hello'*5會生成'hellohellohellohellohello'。

可用索引訪問字符串中的字符。如：string="hello world"，print string[1]將顯示字符e。

字符串可用in或not in運算符來測試字符是不屬于一個字符串的成員。

可對字符串分片，如string="hello world",print string[6:]將顯示world。分片的格式為：

             string[start:end]

    

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

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

訪問列表可通過索引來引用，如：list[0]將引用列表的第一個值。list[0:1]返回第一和第二個元素。

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

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

>>> [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)。

“+”號可連接兩個列表。

訪問列表的列表(嵌套列表)可用list[1][0]，這將訪問嵌套中的第二個列表的第一個元素。

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

由于列表是可變的，我們可用賦值語句進行操作，如：list[0] = 2。

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

tuple=(1,)，這是單個元素的元組表示，需加額外的逗號。

tuple=1，2，3，4，這也可以是一個元組，在不使用圓括號而不會導(dǎo)致混淆時，Python允許不使用圓括號的元組。

和列表一樣，可對元組進行索引、分片、連接和重復(fù)。也可用len()求元組長度。

	元組的索引用tuple[i]的形式，而不是tuple(i)。

和列表類似，使用tuple(seq)可把其它序列類型轉(zhuǎn)換成元組。

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

比較運算符(<，<=，>，>=，!=，==)也可用于序列。

可通過下標(biāo)(test[1])，切片(test[1:3])和解包來訪問序列的某部份。解包示例如下：

>>>s=1,2,3 

    >>>x,y,z=s 

    >>>print x,y,z

    1,2,3

in運算符可判斷當(dāng)有對象是否序列對象成員，如:

>>>list = [1,2,3]

    >>>1 in list

    1

    >>>4 in list

    0

    

也可通過循環(huán)運算符對序列對象進行迭代操作。如:

for day in days:

    print day

    

字典可嵌套，可以在一個字典里包含另一個字典。如test={"test":{"mytest":10} }

可用鍵訪問字典，如monthdays["Jan"]，可訪問值31。如果沒有找到指定的鍵，則解釋器會引起異常。

字典是可修改，如monthdays["Jan"]=30，可把Jan的值由31改為30。如monthdays["test"]=30可添加一個新鍵值對。

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

字典不屬序列對象，所以不能進行連接和相乘操作。字典是沒有順序的。

字典提供keys和values方法，用來返回字典中定義的所有鍵和值。

和列表一樣，字典也提供了對象方法來對字典進行操作。

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

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

	sys.gettrefcount(obj)函數(shù)可返回給定對象的引用計數(shù)。

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

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

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

>>> z.tolist()

    [1, 2, 3]

    

fromlist(list)方法可把列表項附加到數(shù)組的末尾，如：

>>> z.fromlist([10,11])

    >>> z

    array('b', [1, 2, 3, 10, 11])

    

	如添加的列表類型與數(shù)組類型不同，則fromlist(list)不會把任何項添加到數(shù)組對象中。

tostring()方法，可以把數(shù)組轉(zhuǎn)換為字節(jié)的序列，如：

>>> z.tostring()

    '\x01\x02\x03\n\x0b'

    

fromstring(list)方法剛好與tostring()相反，它獲取一個字節(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)方法用于從文件對象中讀取特定數(shù)目的項，并把它們附加到數(shù)組中，如：

>>> z.fromfile(open("aa","rb"),2)

    >>> z

    array('b', [1, 2, 3, 10, 11, 11, 1, 2])

    

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

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

abs(x)

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

>>>print abs(-100)

    100

    >>>print abs(1+2j)

    2.2360679775

    

callable(object)

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

>>> a="123"

    >>> print callable(a)

    0

    >>> print callable(chr)

    1

    

cmp(x,y)

cmp()函數(shù)比較x和y兩個對象，并根據(jù)比較結(jié)果返回一個整數(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ù)完成除法運算，返回商和余數(shù)。

>>> divmod(10,3)

    (3, 1)

    >>> divmod(9,3)

    (3, 0)

    

isinstance(object,class-or-type-or-tuple) -> bool

測試對象類型

>>> 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ù)返回字符串和序列的長度。

>>> len("aa")

    2

    >>> len([1,2])

    2

    

pow(x,y[,z])

pow()函數(shù)返回以x為底，y為指數(shù)的冪。如果給出z值，該函數(shù)就計算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ù)返回浮點數(shù)x的四舍五入值，如給出n值，則代表舍入到小數(shù)點后的位數(shù)。

>>> round(3.333)

    3.0

    >>> round(3)

    3.0

    >>> round(5.9)

    6.0

    

type(obj)

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

>>> type(a)

    <type 'list'>

    >>> type(copy)

    <type 'module'>

    >>> type(1)

    <type 'int'>

    

xrange([lower,]stop[,step])

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

>>> a=xrange(10)

    >>> print a[0]

    0

    >>> print a[1]

    1

    >>> print a[2]

    2

    

chr(i)

chr()函數(shù)返回ASCII碼對應(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ù)把一個數(shù)字或字符串轉(zhuǎn)換成浮點數(shù)。

>>> float("12")

    12.0

    >>> float(12L)

    12.0

    >>> float(12.2)

    12.199999999999999

    

hex(x)

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

>>> hex(16)

    '0x10'

    >>> hex(123)

    '0x7b'

    

long(x[,base])

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

>>> long("123")

    123L

    >>> long(11)

    11L

    

list(x)

list()函數(shù)可將序列對象轉(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)換成一個整數(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)換成八進制數(shù)。

>>> oct(8)

    '010'

    >>> oct(123)

    '0173'

    

ord(x)

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

>>> ord("a")

    97

    >>> ord(u"a")

    97

    

str(obj)

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

>>> str("4")

    '4'

    >>> str(4)

    '4'

    >>> str(3+2j)

    '(3+2j)'

    

tuple(x)

tuple()函數(shù)把序列對象轉(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)

    

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

filter(function,list)

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

>>> def nobad(s):

    ...     return s.find("bad") == -1

    ... 

    >>> s = ["bad","good","bade","we"]

    >>> filter(nobad,s)

    ['good', 'we']

    

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

map(function,list[,list])

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

>>> import string

    >>> s=["python","zope","linux"]

    >>> map(string.capitalize,s)

    ['Python', 'Zope', 'Linux']

    

map()還可同時應(yīng)用于多個列表。如：

>>> import operator

    >>> s=[1,2,3]; t=[3,2,1]

    >>> map(operator.mul,s,t)   # s[i]*t[j]

    [3, 4, 3]

    

如果傳遞一個None值，而不是一個函數(shù)，則map()會把每個序列中的相應(yīng)元素合并起來，并返回該元組。如：

>>> 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ù)獲得序列中前兩個項，并把它傳遞給提供的函數(shù)，獲得結(jié)果后再取序列中的下一項，連同結(jié)果再傳遞給函數(shù)，以此類推，直到處理完所有項為止。

>>> 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ù)可把兩個或多個序列中的相應(yīng)項合并在一起，并以元組的格式返回它們，在處理完最短序列中的所有項后就停止。

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

    [(1, 4, 7), (2, 5, 8)]

    

如果參數(shù)是一個序列，則zip()會以一元組的格式返回每個項，如：

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

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

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

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

    

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

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

>>>a="11223344"

    >>>print string.replace(a,"1","one")

    oneone2223344

    >>>print string.replace(a,"1","one",1)

    one12223344

    

capitalize(string)

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

>>> import string

    >>> print string.capitalize("python")

    Python

    

split(string,sep=None,maxsplit=-1)

從string字符串中返回一個列表，以sep的值為分界符。

>>> import string

    >>> ip="192.168.3.3"

    >>> ip_list=string.split(ip,'.')

    >>> print ip_list

    ['192', '168', '3', '3']

    

join(string[,sep])

返回用sep連接的字串，默認的sep是空格。

>>> import string

    >>> a = ['a','b','c']

    >>> b = string.join(a,'-')

    >>> b

    'a-b-c'

    >>> a

    ['a', 'b', 'c']

    

time()，以浮點形式返回自Linux新世紀(jì)以來經(jīng)過的秒數(shù)。在linux中，00:00:00 UTC, January 1, 1970是新紀(jì)元的開始。

>>> time.time()

    1150269086.6630149

    >>> time.ctime(1150269086.6630149)

    >>> 'Wed Jun 14 15:11:26 2006'

    

ctime([sec])，把秒數(shù)轉(zhuǎn)換成日期格式，如果不帶參數(shù)，則顯示當(dāng)前的時間。

>>> import time

    >>> time.ctime()

    >>> 'Wed Jun 14 15:02:50 2006'

    >>> time.ctime(1138068452427683)

    'Sat Dec 14 04:51:44 1901'                               

    

sleep(secs)，定時。

>>> time.sleep(10) 

    >>>                #10秒后才會出現(xiàn)>>>提示符 

    

文件的打開或創(chuàng)建

#!/usr/bin/env python

    #-*- encoding:UTF-8 -*-

    

    filehandler = open('test.txt','w')               #以寫模式打開文件，如果文件不存在則創(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')      #以追加模式打開文件，如果文件不存在則創(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')    #以讀方式打開文件，rb為二進制方式(如圖片或可執(zhí)行文件等)

    

    print 'read() function:'              #讀取整個文件

    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個字符，從33個字符開始顯示余下內(nèi)容

    filehandler.seek(32)

    print filehandler.read()

    

    print 'tell() function'               #移位到文件頭，從頭開始顯示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)建一個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 ] ),  #獲取文件最后修改時間

    'LastAccessed':time.ctime( fileStats [ stat.ST_ATIME ] ),  #獲取文件最后訪問時間

    'CreationTime':time.ctime( fileStats [ stat.ST_CTIME ] ),  #獲取文件創(chuàng)建時間

    'Mode':fileStats [ stat.ST_MODE ]                          #獲取文件的模式

    }

    #print fileInfo

    

    for field in fileInfo:                                     #顯示對象內(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 ):     #判斷是否掛接點

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