Python那些事——Perl 與 Python 知多少！

關於 Perl 與 Python 的起源和特點

Perl 是 Practical Extraction and Report Language 的簡稱，由 1987 年Larry Wall 創建，最初的目的是為了在 UNIX上方便處理報表，經過長期的發展已經成為一種全功能的程序設計語言，當前最新的版本為 Perl5.14.1，Perl作為一種自由而強大的編程語言，其中心思想是： There』s More Than One Way To DoIt。（不只一種方法來做這件事 )，即「 Tim Toady」。作為一種「膠水型」語言，它具有強大的正則表達式和模式匹配功能以及靈活的數據結構，如動態數組、Hash 等，在語法規則上借鑒了C/C++、Basic、Pascal 等語言，其不足之處在於存在一些冗餘語法，代碼的可讀性較差。

Advertisements

Python 是一種基於面向對象的解析性互動式的開源編程語言，它起源於 1989 年末由CWI（阿姆斯特丹國家數學和計算機科學研究所）的研究員 Guido van Rossum 創立，1991年初公開發行，其開源式的發行方式促進了 Python 的較快發展，目前已經形成了一個強大的社區力量。Python開發者的哲學是「用一種方法，最好是只有一種方法來做一件事」。Python具有簡單易學、代碼規範、語法簡單、可移植性強、支持多平台、類庫豐富等優點。

Perl 和 Python都是開源的，但其哲學理念卻剛好相反，因此常被人們將這兩種語言放在一起進行比較。下面的篇章將從基本數據類型、控制流、函數、面向對象、文本處理等方面對這兩種語言進行簡單的比較和鑒別。

Advertisements

Perl 與 Python 的基本數據類型

腳本語言支持多種數據類型，變數無需事先申明，類型根據值來動態確定，一個變數在程序中可以根據上下文環境的不同存儲不同類型的值。

Perl 支持的基本數據類型包括：標量、數組、哈希。在定義的時分別用 $、@、% 表示。

  1. 標量 (scalar)：標量是 Perl中最簡單的數據類型，大多數標量由數字或字元串組成。其中數字類型如整數、浮點數等，字元串有單引號和雙引號內兩種形式，對長度沒有限制。兩者的區別在於在單引號內\n 不代表換行，而代表反斜線和 n 這兩個字元，雙引號內字元串則可以通過反斜線進行轉義。字元串的操作符有 . 拼接操作符和 x重複操作符等。

  2. 數組 (Arrays)：數組用 @ 定義，如 my @array=(「a」,」b」,」c」,」d」); 訪問數組的元素用$array[1]。在 perl 中，數組也可以當做堆棧來處理，支持的操作符包括 pop 和 push，shft 和unshift。兩組操作的區別在於前者對數組的尾部進行處理，而 shift 和 unshift 則針對數組的頭部進行處理。pop得到的是數組的最後一個元素，如 pop（@array）= d，如果數組為空，則返回 undef。而shift(@array)=a。

  3. 哈希：也稱作關聯數組，是根據關鍵碼值 (Key value) 而直接進行訪問的數據結構。用 % 定義，如%my_hash=(「key1」=>」23」,」name」=>」zhang」,」age」=>」24」)，其中鍵以字元串表示，Hash可以是任意大小。

    與 hash 相關的函數有：

    keys：返回 hash 的鍵列表 my @keylist = keys %hash

    value：返回值列表 my @valuelist = values %hash

    each：用兩個元素的列表返回鍵值對。

    Python

    1

    2

    3

    4

    while(($key,$value)=each%hash)

    {

    print「$key=>$value\n」;

    }

Python 支持五種基本數據類型：數字 (Numbers)、字元串 (String)、列表 (List)、元組 (Tuple)和字典 (Dictionary)。其中數字和字元串和 perl 中的標量對應，列表和數組對應，元組可以看做是不可變的列表，字典和hash 對應。

  1. 數字 (Numbers)：Python 支持五種基本數字類型，分別為 int( 有符號整數 ) 、long( 長整數 )、bool( 布爾值 ) 、float( 浮點數 ) 、complex( 複數 )。

  2. 字元串 (String)：Python 與 Perl 一樣也支持單引號和雙引號字元串，但與 Perl不同，轉義字元在單引號中也會起作用。同時 python還支持三引號字元串，它允許一個字元串跨多行，字元串中可以包含換行符，製表符以及其他特殊字元。三引號字元串常用於註釋或者形成文檔。字元串支持成員操作符in，not in，連接操作符 + 以及重複操作符 *。Python 字元串可以當做 list，支持切片操作符 [],[:]和反向索引。如下：

    如 aString=」abcd」；則 aString[0] 的值為 a，aString[1:3]=bc，反向索引aString[-1]=d

  3. 列表 (List)：Pyhon 中的列表與 Perl 中的數組相對應。列表的定義使用 []. 如 li = [「a」, 「b」,「mpilgrim」, 「z」, 「example」] ，支持動態增加和刪除元素以及切片操作。

    增加元素可以使用 li.append(「test」),li.insert(2,」new」) 以及li.extend([「f」,」ggf」])

    刪除元素使用 li.remove(「f」) 和 li.pop() 。但需要注意的是 remove 僅刪除首次出現的，而 pop會刪除 list 最後的一個元素，然後返回刪除的元素的值。

  4. 元組 (Tuple)：元組和列表非常相似，但用（）表示，並且元組是不可變的。

  5. 字典 (Dictionary)：字典跟 Perl 中的 hash一樣，定義了鍵值對之間一對一的關係，變數可以任意取名，Python會在內部記錄其數據類型。定義一個字典：D={「name」:」Jon」,」Family」:」SH」}, 字典中的 key是不能重複的，並且大小寫敏感，同時字典中的元素是無序的。字典也支持增刪操作，往字典中添加元素 D[「age」]=23, 刪除元素del D[『name』]，如果需要刪除所有元素可以使用 D.clear(), 或者 del D 刪除整個字典。

Perl 與 Python 的控制結構

在控制結果方面，Perl 較 Python 豐富，除了支持傳統的 if 、while 、for 控制結構，還支持 until、unless 、foreach 等，Python的控制結構相對要少一些，但已經能夠滿足語言的要求。本節對這些控制結構進行詳細比較。

If 控制結構：

Perl 與 Python 都支持 if 、if-else 、if-else if- else三種結構，兩者在語法上基本類似，但與 Python 不同的是 Perl 中沒有 boolean 類型，零和空表示 False，其餘表示True，而 Python 中除了」、」」、0、()、[]、{}、None 為 False 之外，其他的都是 True。同時Python 直接用縮進表示 block 塊。

表 1. if 控制結構

PERLPYTHON
ifif (expression) {

true_statement;

}

if expression:

if_suite

if-elseif (expression) {

true_statement;

}

if expression:

if_suite

else:

else_suite

If-else if-elseif (expression_A) {

A_true_statement;

} elseif (expression_B) {

B_true_statement;

} else {

false_statement;

}

if expression1:

if_suite

elif expression2:

elif_suite

else:

else_suite

Perl 中還支持 unless 條件控制語句，基本語法如下：

Python

1

2

unless(expression){

stmt_1;}

unless 和 if 不同之處在於當條件表達式的值為假的時候才執行，同時 unless 後面還能跟 else語句。如：

1

2

3

4

5

unless($mon=~/^Feb/){

print「Thismonth has at least thirty days.\n」;

}else{

print「Doyou see what'sgoing on here?\n」;

}

循環控制結構：

  1. For 循環：

Perl 中的 for 循環除了支持傳統的 for 循環，即 for ( 表達式 1; 表達式 2; 表達式 3) ，還支持foreach 語句，基本語法為：

1

2

3

foreach$i(@aList){

stmt_1;

}

python 不支持傳統的 for 循環，但是提供了強大的循環結構可以遍歷序列成員，同時 for 循環後面也可以接 else語句，基本語法如下：

1

2

3

4

forinter_var initerable:

suite_to_repeat

else:

else_statement

  1. while 循環

Perl 循環控制結果還支持 while 和 do-while 以及 until 形式，until 與 while結構相似，區別在於 unitl 會在條件為假的時候重複執行。until 語法如下：

1

2

3

4

until(expression)

{

statement;

}

而 python 只支持 while 形式，但 python 可以在 while 後面接 else 語句。語法如下：

1

2

3

4

Whilecondition:

statements

else:

statements

循環控制符

Perl 有三個循環控制操作符，分別為 Last 、next 、redo。

  1. last：立即終止循環，類似於 c 中的 break。在多層循環中，只對 last 所在的當前循環塊有效；

  2. next：立刻結束當前這次迭代；

  3. redo：將控制返回本循環的頂端，不經過條件測試也不會進去下一次迭代循環，而是重新執行本循環塊。它與 next 最大的區別在於next 會正常繼續下一次迭代，而 redo 會重新執行本次迭代。

Python 也有三個循環控制操作符，分別為 break 、continue 、pass 語句。

  1. break：與 C 中的 break 類似；

  2. continue：continue 語句並不會退出循環結構，而是立即結束本次循環，重新開始下一輪循環，也就是說，跳過循環體中在continue 語句之後的所有語句，繼續下一輪循環；

  3. pass：一般作為佔位符或者創建佔位程序，pass 語句不會執行任何操作。

Perl 與 Python 的函數

Perl 和 Python都支持函數，可以傳遞參數以及在程序中對函數進行調用等。下面從函數的定義，調用，返回值以及參數傳遞等方面對這兩者進行比較。

表 2. Perl 與 Python 函數比較

PERLPYTHON
定義

返回值使用 return 語句顯示返回；如果沒有 return，默認返回最後一次運算的結果使用 return 語句顯示返回，沒有 return 語句，默認返回為 None。如果函數返回多個對象，python把他們聚集起來並以一個元組返回。
調用

函數參數

  1. 基本語法：

    def functionName(arg1,arg2,[…]):

    statement

    [return value]

  2. 內嵌函數：

    Python 支持內嵌函數 , 其方法是在外部函數的定義體內定義函數 , 但整個函數體都在外部函數的作用域之內 .

    def outfun():

    def innerfun():

    Print 「inner fun test」

    print 「out fun test」

  1. 基本語法：

sub functionName{

statement;

[return value]

}

  1. 直接採用 函數名（參數 1，參數 2…..）

  2. 函數名（參數名 1= 值，參數名 2= 值 …….)

& 函數名（參數 1，參數 2，…），如果聲明在前，可以省略&。如果用戶所定義的子過程與內置函數重名，則不能省略 &。

如下例必須使用 &chomp 調用：

sub chomp{

print 「it is my chomp\n」;

}

  1. 按照參數聲明的關鍵字順序直接傳遞；

  2. 通過關鍵字參數 testFun（par1=「2」，par2=「45」）

  3. 默認參數：

    > Python 在傳遞參數的時候支持默認參數，規則是所有的位置參數必須出現在任何一個默認參數之前，如

    def fun(arg1,defarg1=」var1」,defarg2=」12」),如果在調用的時候沒有給出參數值，則會使用默認值

  4. 變長參數：

    一種方法是利用非關鍵字可變長參數 , 可變長的參數元組必須在位置和默認參數之後 , 帶元組的函數語法如下：

    def function_name([formal_args,]*vargs_tuple):

    function_body

    其中 * 之後的形參將作為元組傳遞給函數。另外一種方法是利用關鍵字變數參數，區別是在函數的參數變數里使用 **。

    def dicVarArgs(arg1,arg2=」default」,**theRest):

    print 『formal arg1:』, arg1

    print 『formal arg2:』, arg2

    for eachXtrArg in theRest.keys():

    print 『Xtra arg %s: %s』 % $$eachXtrArg,str(theRest[eachXtrArg]))

  1. 在子程序調用的後面加上被括弧圈引的列表表達式即可，所有的參數都會自動存儲為 @_ 中，其中第一個參數為 $_[0],第二個參數存儲 $_[1]。

  2. 傳遞引用，在參數前加入 \ 表示為引用

Perl 與 Python 的包與模塊

Perl 程序把變數和子程序的名稱存貯到符號表中，Perl 的符號表中名字的集合就稱為 Perl 包(package)。定義語法為：packagemypack；每個符號表有其自己的一組變數、子程序名，各組名字是不相關的，因此可以在不同的 Perl包中使用相同的變數名，而代表的是不同的變數。Perl 模塊有兩種來源，一種是隨 Perl 發行版本一同打包的，另外就是用 CPAN中下載的。Perl 模塊和包的概念並不清晰，兩者有時可以混用。在程序中使用模塊的操作稱為導入模塊；導入模塊關鍵字 use；如：useModuleName；模塊被導入后，其中的子程序和變數就可以直接使用了；要取消一個已經導入了的模塊，可以使用關鍵字 no；如：noModuleName。

一個 .py 文件就是一個 python 模塊。把一堆相關的 python 模塊放在一個目錄下，再加上一個__init__.py 文件就構成了一個 python 包。在 Python 另一個程序中導入模塊用 import module 或者from module import *，兩者的區別在於：import module 會導入 module這個模塊里的所有標識，但是這些標識現在都在 module 名字空間下。from module import * 也會導入 module中所有標識，但是標識放到在當前名字空間里。

導入模塊或包按下面順序進行路徑查找：

1. 當前目錄

2. 環境變數 PYTHONPATH 所指的目錄列表 3.python 解釋器的安裝目錄

Perl 與 Python 中的 OOP

在 Perl 中，類是 Perl 包，含有提供對象方法的類，而方法是 Perl的子程序，類名是其第一個參數，對象是對類中數據項的引用。在 Perl 中創建一個新類，首先要創建一個包，擴展名為 .pm, 在創建perl 包的時候程序的最後一個必須為」1;」；否則該包不會被 Perl 處理。

清單 1. 創建 perl 的類和對象

1

2

3

4

5

6

7

8

9

10

11

12

packageperson;

usestrict;

subnew{

my$class=shift();

print("CLASS = $class\n");

my$self={};

$self->{"name"}=shift();

$self->{"sex"}=shift();

bless$self,$class;

return$self;

}

1;

其中 new()方法是對象的構造函數，是創建該類的對象實例必須被調用的，它返回該對象的引用。將類名與引用相結合稱為」bless」一個對象，其語法為：blessYeReference [,classname]

YeReference 是對被」祝福」的對象的引用，classname是可選項，指定對象獲取方法的包名，其預設值為當前包名。也可以通過函數 bless 來聲明一個構造函數。

1

2

3

4

5

6

7

subnew

{

my$class=shift;

my$self={};

bless$self,$class;

return$self;

}

創建一個對象可以直接使用 new 關鍵字。$object = new Person( 「mohand」, 「sam」,345);

Perl 類中的方法就 Perl 的子函數，規定第一個參數為對象或者被引用的包，分為靜態方法和虛方法。虛方法通常首先把第一個參數 shift 到變數 self 或 this 中，然後將該值作普通的引用使用。一是通過該對象的引用 (虛方法 )，一是直接使用類名 ( 靜態方法 )。如上例中如果類 Person 中有 getContactList 則可以直接使用$object->getContactList() 來調用該方法。

Perl 支持重載，當兩個不同的類中含有相同的方法名稱的時候，可以用 :: 操作符指定使用哪個類中的方法。

Python

1

2

$mess=Qava::grind("whole","lotta","bags");

Qava::grind($mess,"whole","lotta","bags");

由於 Perl 採用了簡單的、基於引用的垃圾回收系統。Perl跟蹤對象的鏈接數目，當某對象的最後一個應用釋放到內存池時，該對象就自動銷毀。因此一般不需要定義類的析構函數。

Perl 通過數組 @ISA 支持繼承。

1

2

3

4

packageEmployee;

usePerson;

usestrict;

our<ahref="http://www.jobbole.com/members/wx2110782611">@ISA</a>=qw(Person);#inherits from Person

當子類繼承父類的時候，繼承了父類的所有方法，但子類也可以覆蓋父類的方法。如加入 Employee 想覆蓋父類的getFirstName：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

#!/usr/bin/perl

packageEmployee;

usePerson;

usestrict;

our<ahref="http://www.jobbole.com/members/wx2110782611">@ISA</a>=qw(Person);#inherits from Person

# Override helper function

subgetFirstName{

my($self)=@_;

# This is child class function.

print"This is child class helper function\n";

return$self->{_firstName};

}

1;

調用直接使用 $firstName = $object->getFirstName(); 如果要調用父類的getFirstName，則可以使用 $object->Person::getFirstName();

在 Python 中創建一個類的基本語法為 :

1

2

classclassName(bases):

classBody

參數 base 可以是一個單繼承或者多繼承的父類，object 是所有類的父類，位於類繼承結構的最上層。類的構造函數為__init__()，其中構造函數中 self 會作為第一個默認的參數。而類的析構函數則是__del__()，訪問類的方法和屬性可以直接使用 . 訪問符。

Python 不支持純虛函數或抽象方法，並且聲明和定義沒有本質區別。一般或者 Python 類的屬性可以通過 __dict__或者 dict（）訪問。常見屬性有 __name__ ，__doc__，__base__，__dict__。Python中創建一個類的實例，不需要關鍵之 new，直接使用類名 () 即可。如 c=myclass()。

Python 不僅僅支持單繼承和多繼承，同時還支持方法的覆蓋 .

1

2

3

4

5

6

classP(object):

def foo(self):

print'Hi, I am P-foo()'

>>>p=P()

>>>p.foo()

Hi,IamP-foo()

現在創建 C 類 , 繼承於 P

1

2

3

4

5

6

classC(P):

def foo(self):

print'Hi, I am C-foo()'

>>>c=C()

>>>c.foo()

Hi,IamC-foo()

當從一個帶構造器 __init()_ 的類派生，如果在子類中覆蓋了 __init__()，當子類被實例化時，基類的__init__() 方法不會被自動調用。如果必須調用基類的構造方法，可以使用父類名 .__init__(self) 方法或者super( 子類名，self).__init__()。 如

1

2

3

def __init__(self):

super(C,self).__init__()

print"calling C's constructor"

Python 類和實例支持一些內建函數，如

Issubclass(sub,sup)：判斷一個類是另一個類的子類或子孫類；

isinstance(obj1,obj2)：判定一個對象是否是另一個給定類的實例；

Perl 與 Python 的正則表達式

正則表達式是 perl 比較突出的一大特色，perl 中正則表達式有三種形式：

匹配：m// （還可以簡寫為 /;/ ，略去 m） 替換：s/// ，為了語法的簡化用 /// 表示，略去 s

轉換：tr/// 這種形式包含一系列的字元— / —同時把它們替換為 。

表 3. Perl 常用匹配模式

語法說明示例
.匹配除換行符以外的所有字元b.c 匹配 bac
x?匹配 0 次或一次 x 字元串b?c 匹配 c 或者 bc
x*匹配 0 次或多次 x 字元串，但匹配可能的最少次數b*c 匹配 c 或者 bbc
x+匹配 1 次或多次 x 字元串，但匹配可能的最少次數b+c 匹配 bc 或者 bbc
.*匹配 0 次或一次的任何字元b.*c 匹配 bgdc 等
.+匹配 1 次或多次的任何字元b.+c 匹配 bgc 等
{m}匹配剛好是 m 個 的指定字元串b{5}c 匹配 bbbbbc
{m,n}匹配在 m 個 以上 n 個 以下 的指定字元串b{1,2} 匹配 b 或者 bb
{m,}匹配 m 個 以上 的指定字元串b{2,} 匹配 bb 或者 bbb 等
[]匹配符合 [] 內的字元b[d]c 匹配 bdc
[^]匹配不符合 [] 內的字元b[^d]c 匹配 bAc
[0-9]匹配所有數字字元b[0-9]c 匹配 b1c
[a-z]匹配所有小寫字母字元b[a-z]c 匹配 bac
^匹配字元開頭的字元^perl 匹配以 perl 開頭的字元
$匹配字元結尾的字元perl$ 匹配以 perl 結尾的字元
\d匹配一個數字的字元，和 [0-9] 語法一樣b\dc 匹配 b1c
\D非數字，其他同 \db\Dc 匹配 bAc
\w英文字母或數字的字元串，和 [a-zA-Z0-9] 語法一樣b\wc 匹配 b1c 等
\W非英文字母或數字的字元串，和 [^a-zA-Z0-9] 語法一樣b\Wc 匹配 b c
\s空格，和 [\n\t\r\f] 語法一樣b\sc 匹配 b c
\S非空格，和 [^\n\t\r\f] 語法一樣b\Sc 匹配 bac 等
\b匹配以英文字母 , 數字為邊界的字元串\bbc\b 匹配 bc 但不匹配 bca
\B匹配不以英文字母 , 數值為邊界的字元串sa\B 將匹配 sand 和 Sally 等字元串，而不能匹配 Melissa.
a|b|c匹配符合 a 字元 或是 b 字元 或是 c 字元 的字元串

abc 匹配含有 abc 的字元串

匹配 a 或者 b 或者 c 等
(pattern) ()這個符號會記住所找尋到的字元串，是一個很實用的語法。第一個 () 內所找到的字元串變成 $1 這個變數或是 \1 變數，第二個() 內所找到的字元串變成 $2 這個變數或是 \2 變數，以此類推下去。b(\d)c 表示匹配的任何數字將存放與 $1 變數中

Python 語言本身不支持正則表達式，依賴 re 模塊（python1.5版本被引入）支持正則表達式。有搜索和匹配兩種方法完成匹配模式。re 模塊常用的函數和方法有complie、match、search、find 與 findall 等。在利用 re 進行匹配之前，模式必須被編譯成 regex對象。

表 4. Python 常用匹配模式

語法說明示例
.匹配除換行符 \n 以外的任意字元b.c 匹配 bac,bdc
*匹配前一個字元 0 次或多次b*c 匹配 c，或者 bbbc
+匹配前一個字元 1 次或多次b+c 匹配 bc 或者 bbbc
？匹配前一個字元 0 或 1 次b?c 匹配 c 或者 bc
{m}匹配前一個字元 m 次b{2}c 匹配 bbc
{m,n}匹配前一個字元 m 至 n 次b{2,5}c 匹配 bbc 或者 bbbbc
[abc]匹配 [] 內的任意字元[bc] 匹配 b 或者 c
\d匹配數字 [0-9]b\dc 匹配 b1c 等
\D匹配非數字，等價於 [^\d]b\Dc 匹配 bAc
\s匹配空白字元b\sc 匹配 b c
\S匹配非空白字元 [\^s]b\Sc 匹配 bac
\w匹配 [A-Za-z0-9_]b\wc 匹配 bAc 等
\W等價於 [^\w]b\Wc 匹配 b c
\轉義字元，b\\c 匹配 b\c
^匹配字元串開頭^bc 匹配句首的 bc
$匹配字元串末尾bc$ 匹配以 bc 結尾的字元串
\A僅匹配字元串開頭\Abc 匹配字元串開頭的 bc
\Z僅僅匹配字元串末尾bc\Z 匹配字元串末尾的 bc
|匹配左右表達式任意一個b|c 匹配 b 或者 c

Perl 與 Python 中的線程

線程是一個單一的執行流程，它是所有程序執行過程中最小的控制單位，即能被 CPU 所調度的最小任務單元。在 Perl中一個線程的生命周期包括創建，運行與退出這三個階段。線程的運行過程與普通函數的執行類似，但新建線程的執行與當前線程的執行是并行的。

在 Perl 中創建線程有兩種方法：

清單 2. 使用 threads 包的 create() 方法

1

2

3

4

5

6

7

usethreads;

subsay_hello

{

printf("Hello thread! @_.\n");

return(rand(10));

}

my$t1=threads->create(\&say_hello,"param1","param2");

清單 3. 使用 async{} 塊創建線程

1

2

3

4

5

#!/usr/bin/perl

usethreads;

my$t4=async{

printf("Hello thread!\n");

};

對於線程的執行控制，有兩種方式，一種是 join()，一種是 detach()。所謂 join()就是在主線程中等待子線程的執行返回值，然後再繼續執行後續代碼，而在調用線程的 join() 方法之前，子線程與主線程的執行是分開的。而detach()則是告訴解釋器主線程不關心子線程的執行結果，所以該子線程在完成任務之後就是自動退出，同時釋放自己所佔有的資源，而不用主線程再操心。

Perl 默認任何數據結構都不是共享的，任何新創建的線程都有當前數據的私有拷貝。如果要共享數據，必須使用threads::shard 進行顯示聲明。

如：

1

2

3

4

my$var:shared=0;# use :share tag to define

my<ahref="http://www.jobbole.com/members/Array">@array</a>:shared=();#use :share tag to define

my%hash=();

share(%hash);# use share() funtion to define

同時 Perl 線程還支持鎖機制，可以使用 lock 方法實現線程間共享數據的鎖機制。Perl 中的Thread::Semaphore 包為線程提供了信號量的支持，Thread::Queue包為線程提供了線程安全的隊列支持。更多使用讀者可以自行查閱相關文檔。

Python 提供了幾個用於多線程編程的模塊，包括 thread, threading 和 Queue 等。thread 和threading 模塊允許程序員創建和管理線程。thread 模塊提供了基本的線程和鎖的支持，而 threading提供了更高級別，功能更強的線程管理的功能。Queue 模塊允許用戶創建一個可以用於多個線程之間共享數據的隊列數據結構。

Python 的線程創建也有兩種方式，一是利用 thread 模塊的 start_new_thread()函數來產生新線程。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

import time

import thread

def timer(no,interval):

cnt=0

whilecnt<10:

print'Thread:(%d) Time:%s/n'%(no,time.ctime())

time.sleep(interval)

cnt+=1

thread.exit_thread()

def test():#Use thread.start_new_thread() to create 2 newthreads

thread.start_new_thread(timer,(1,1))

thread.start_new_thread(timer,(2,2))

if__name__=='__main__':

test()

另一種是創建 threading.Thread 的子類來包裝一個線程對象。

1

2

3

4

5

6

7

8

9

10

11

12

classtimer(threading.Thread):# derived from the classthreading.Thread

def __init__(self,num,interval):

threading.Thread.__init__(self)

self.thread_num=num

self.interval=interval

self.thread_stop=False

def run(self):#Overwrite run() method, put what you want thethread do here

whilenotself.thread_stop:

print'Thread Object(%d),Time:%s/n'%(self.thread_num,time.ctime())

time.sleep(self.interval)

def stop(self):

self.thread_stop=True

Python 線程中也提供同步機制，可以利用 thrading 模塊的 threading.RLock 和hreading.Condition 可以分別實現鎖機制和條件變數。

其中 acquire() 和 release() 方法分別獲取和釋放鎖。

1

2

3

4

5

6

7

8

def run(self):

globalx

lock.acquire()

foriinrange(3):

x=x+1

time.sleep(2)

printx

lock.release()

更多關於線程的內容，讀者可查閱相關文檔。

總結

本文從 Perl 和 Python的起源，基本數據類型、控制結構、函數、包與模塊、面向對象、正則表達式以及線程等方面進行了比較，從而給需要同時掌握這兩種腳本語言的開發人員一定參考，以便更好的理解與應用。

Advertisements

你可能會喜歡

Advertisements