Python基礎(chǔ)培訓(xùn)教程課件

Python簡介Python的官方介紹

Python是一種簡單易學(xué)，功能強大的編程語言，它有高效率的高層數(shù)據(jù)結(jié)構(gòu)，簡單而有效地實現(xiàn)面向?qū)ο缶幊?。Python簡潔的語法和對動態(tài)輸入的支持，再加上解釋性語言的本質(zhì)，使得它在大多數(shù)平臺上的許多領(lǐng)域都是一個理想的腳本語言，特別適用于快速的應(yīng)用程序開發(fā)。Python的特色

簡單

Python是一種代表簡單主義思想的語言。閱讀一個良好的Python程序就感覺像是在讀英語一樣，盡管這個英語的要求非常嚴格！Python的這種偽代碼本質(zhì)是它最大的優(yōu)點之一。它使你能夠?qū)Ｗ⒂诮鉀Q問題而不是去搞明白語言本身。

易學(xué)就如同你即將看到的一樣，Python極其容易上手。前面已經(jīng)提到了，Python有極其簡單的語法。

免費、開源Python是FLOSS（自由/開放源碼軟件）之一。簡單地說，你可以自由地發(fā)布這個軟件的拷貝、閱讀它的源代碼、對它做改動、把它的一部分用于新的自由軟件中。FLOSS是基于一個團體分享知識的概念。這是為什么Python如此優(yōu)秀的原因之一——它是由一群希望看到一個更加優(yōu)秀的Python的人創(chuàng)造并經(jīng)常改進著的。

高層語言當(dāng)你用Python語言編寫程序的時候，你無需考慮諸如如何管理你的程序使用的內(nèi)存一類的底層細節(jié)。

可移植性由于它的開源本質(zhì)，Python已經(jīng)被移植在許多平臺上（經(jīng)過改動使它能夠工作在不同平臺上）。如果你小心地避免使用依賴于系統(tǒng)的特性，那么你的所有Python程序無需修改就可以在下述任何平臺上面運行。這些平臺包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、PalmOS、QNX、VMS、Psion、AcomRISCOS、VxWorks、PlayStation、SharpZaurus、WindowsCE甚至還有PocketPC！2022/12/171Python簡介Python的官方介紹2022/12/16Python簡介

解釋性一個用編譯性語言比如C或C++寫的程序可以從源文件（即C或C++語言）轉(zhuǎn)換到一個你的計算機使用的語言（二進制代碼，即0和1）。這個過程通過編譯器和不同的標記、選項完成。當(dāng)你運行你的程序的時候，連接/轉(zhuǎn)載器軟件把你的程序從硬盤復(fù)制到內(nèi)存中并且運行。

而Python語言寫的程序不需要編譯成二進制代碼。你可以直接從源代碼運行程序。在計算機內(nèi)部，Python解釋器把源代碼轉(zhuǎn)換成稱為字節(jié)碼的中間形式，然后再把它翻譯成計算機使用的機器語言并運行。事實上，由于你不再需要擔(dān)心如何編譯程序，如何確保連接轉(zhuǎn)載正確的庫等等，所有這一切使得使用Python更加簡單。由于你只需要把你的Python程序拷貝到另外一臺計算機上，它就可以工作了，這也使得你的Python程序更加易于移植。

面向?qū)ο驪ython即支持面向過程的編程也支持面向?qū)ο蟮木幊?。在面向過程的語言中，程序是由過程或僅僅是可重用代碼的函數(shù)構(gòu)建起來的。在面向?qū)ο蟮恼Z言中，程序是由數(shù)據(jù)和功能組合而成的對象構(gòu)建起來的。與其他主要的語言如C++和Java相比，Python以一種非常強大又簡單的方式實現(xiàn)面向?qū)ο缶幊獭?/p>

可擴展性如果你需要你的一段關(guān)鍵代碼運行得更快或者希望某些算法不公開，你可以把你的部分程序用C或C++編寫，然后在你的Python程序中使用它們。

可嵌入性你可以把Python嵌入你的C/C++程序，從而向你的程序用戶提供腳本功能。

豐富的庫Python標準庫確實很龐大。它可以幫助你處理各種工作，包括正則表達式、文檔生成、單元測試、線程、數(shù)據(jù)庫、網(wǎng)頁瀏覽器、CGI、FTP、電子郵件、XML、XML-RPC、HTML、WAV文件、密碼系統(tǒng)、GUI（圖形用戶界面）、Tk和其他與系統(tǒng)有關(guān)的操作。記住，只要安裝了Python，所有這些功能都是可用的。這被稱作Python的“功能齊全”理念。除了標準庫以外，還有許多其他高質(zhì)量的庫，如wxPython、Twisted和Python圖像庫等等。2022/12/172Python簡介 解釋性一個用編譯性語言比如C或C+常量：如5、1.23、9.25e-3這樣的數(shù)，或者如同‘Thisisastring’、“It‘sastring!”這樣的字符串，不能改變它的值。數(shù)：在Python中有4種類型的數(shù)——整數(shù)、長整數(shù)、浮點數(shù)和復(fù)數(shù)，依次如下：2、1000000、3.23和52.3E-4、(-5+4j)和(2.3-4.6j)。字符串：使用單引號（'）使用雙引號（"）使用三引號（'''或"""）

利用三引號，你可以指示一個多行的字符串，你可以在三引號中自由的使用單引號和雙引號。

如：‘Quotemeonthis‘"What'syourname?“'''Thisisamulti-linestring.Thisisthefirstline.

Thisisthesecondline.

"What'syourname?,"Iasked.

Hesaid"Bond,JamesBond."

'''2022/12/173基本概念常量：如5、1.23、9.25e-3這樣的數(shù)，或者如同‘Th基本概念轉(zhuǎn)義符

假設(shè)你想要在一個字符串中包含一個單引號,就要用到轉(zhuǎn)義符如'What\'syourname?'。自然字符串

如果你想要指示某些不需要如轉(zhuǎn)義符那樣的特別處理的字符串，那么你需要指定一個自然字符串。自然字符串通過給字符串加上前綴r或R來指定。例如r"Newlinesareindicatedby\n"。變量僅僅使用字面意義上的常量很快就會引發(fā)煩惱——我們需要一種既可以儲存信息又可以對它們進行操作的方法。這是為什么要引入變量。變量就是我們想要的東西——它們的值可以變化，即你可以使用變量存儲任何東西。變量只是你的計算機中存儲信息的一部分內(nèi)存。與字面意義上的常量不同，你需要一些能夠訪問這些變量的方法，因此你給變量名字。2022/12/174基本概念轉(zhuǎn)義符2022/12/164基本概念縮進空白在Python中是重要的。事實上行首的空白是重要的。它稱為縮進。在邏輯行首的空白（空格和制表符）用來決定邏輯行的縮進層次，從而用來決定語句的分組。這意味著同一層次的語句必須有相同的縮進。每一組這樣的語句稱為一個塊。我們將在后面的章節(jié)中看到有關(guān)塊的用處的例子。你需要記住的一樣?xùn)|西是錯誤的縮進會引發(fā)錯誤。

如下：

SyntaxError:invalidsyntax

x=10defchangeString():globalxx=20print'x---->',x

2022/12/175基本概念2022/12/165運算符2022/12/176運算符與表達式運算符名稱說明例子+加兩個對象相加3+5得到8。'a'+'b'得到'ab'。-減得到負數(shù)或是一個數(shù)減去另一個數(shù)-5.2得到一個負數(shù)。50-24得到26。*乘兩個數(shù)相乘或是返回一個被重復(fù)若干次的字符串2*3得到6。'la'*3得到'lalala'。**冪返回x的y次冪3**4得到81（即3*3*3*3）/除x除以y4/3得到1（整數(shù)的除法得到整數(shù)結(jié)果）。4.0/3或4/3.0得到1.3333333333333333//取整除返回商的整數(shù)部分4//3.0得到1.0%取模返回除法的余數(shù)8%3得到2。-25.5%2.25得到1.5<<左移把一個數(shù)的比特向左移一定數(shù)目（每個數(shù)在內(nèi)存中都表示為比特或二進制數(shù)字，即0和1）2<<2得到8?！?按比特表示為10>>右移把一個數(shù)的比特向右移一定數(shù)目11>>1得到5?！?1按比特表示為1011，向右移動1比特后得到101，即十進制的5。運算符2022/12/166運算符與表達式運算符名稱說明例子運算符與表達式&按位與數(shù)的按位與5&3得到1。|按位或數(shù)的按位或5|3得到7。^按位異或數(shù)的按位異或5^3得到6~按位翻轉(zhuǎn)x的按位翻轉(zhuǎn)是-(x+1)~5得到6。<小于返回x是否小于y。所有比較運算符返回1表示真，返回0表示假。這分別與特殊的變量True和False等價。注意，這些變量名的大寫。5<3返回0（即False）而3<5返回1（即True）。比較可以被任意連接：3<5<7返回True。>大于返回x是否大于y5>3返回True。如果兩個操作數(shù)都是數(shù)字，它們首先被轉(zhuǎn)換為一個共同的類型。否則，它總是返回False。<=小于等于返回x是否小于等于yx=3;y=6;x<=y返回True。>=大于等于返回x是否大于等于yx=4;y=3;x>=y返回True。==等于比較對象是否相等x=2;y=2;x==y返回True。x='str';y='stR';x==y返回False。x='str';y='str';x==y返回True。!=不等于比較兩個對象是否不相等x=2;y=3;x!=y返回True。not布爾“非”如果x為True，返回False。如果x為False，它返回True。x=True;noty返回False。and布爾“與”如果x為False，xandy返回False，否則它返回y的計算值。x=False;y=True;xandy，由于x是False，返回False。在這里，Python不會計算y，因為它知道這個表達式的值肯定是False（因為x是False）。這個現(xiàn)象稱為短路計算。or布爾“或”如果x是True，它返回True，否則它返回y的計算值。x=True;y=False;xory返回True。短路計算在這里也適用。2022/12/177運算符與表達式&按位與數(shù)的按位與5&3得到1。|按位或數(shù)運算符與表達式運算符優(yōu)先級

下面這個表給出Python的運算符優(yōu)先級，從最低的優(yōu)先級（最松散地結(jié)合）到最高的優(yōu)先級（最緊密地結(jié)合）。這意味著在一個表達式中，Python會首先計算表中較下面的運算符，然后在計算列在表上部的運算符。2022/12/178運算符描述lambdaLambda表達式or布爾“或”and布爾“與”notx布爾“非”in，notin成員測試is，isnot同一性測試<，<=，>，>=，!=，==比較|按位或^按位異或&按位與<<，>>移位+，-加法與減法*，/，%乘法、除法與取余+x，-x正負號~x按位翻轉(zhuǎn)**指數(shù)x.attribute屬性參考x[index]下標x[index:index]尋址段f(arguments...)函數(shù)調(diào)用(experession,...)綁定或元組顯示[expression,...]列表顯示{key:datum,...}字典顯示'expression,...'字符串轉(zhuǎn)換運算符與表達式運算符優(yōu)先級2022/12/168運算符描述l運算符與表達式表達式

#!/usr/bin/python

#Filename:expression.py

length=5

breadth=2

area=length*breadth

print'Areais',area

print'Perimeteris',2*(length+breadth)矩形的長度與寬度存儲在以它們命名的變量中。我們借助表達式使用它們計算矩形的面積和邊長。我們表達式length*breadth的結(jié)果存儲在變量area中，然后用print語句打印。在另一個打印語句中，我們直接使用表達式2*(length+breadth)的值。

2022/12/179運算符與表達式表達式2022/12/169在Python中有三種控制流語句——if、for和while。if語句if語句用來檢驗一個條件，如果條件為真，我們運行一塊語句（稱為if-塊），否則我們處理另外一塊語句（稱為else-塊）。else從句是可選的。

例子：

ifguess==number:

elifguess<number:

else:while語句只要在一個條件為真的情況下，while語句允許你重復(fù)執(zhí)行一塊語句。while語句是所謂循環(huán)語句的一個例子。while語句有一個可選的else從句。例子：

whilerunning:

else:2022/12/1710控制流在Python中有三種控制流語句——if、for和while控制流for循環(huán)for..in是另外一個循環(huán)語句，它在一序列的對象上遞歸即逐一使用隊列中的每個項目。

例子：

foriinrange(1,5):

printi#range(1,5)給出序列[1,2,3,4]

2022/12/1711結(jié)果：1234控制流for循環(huán)2022/12/1611結(jié)果：break語句break語句是用來終止循環(huán)語句的，即哪怕循環(huán)條件沒有稱為False或序列還沒有被完全遞歸，也停止執(zhí)行循環(huán)語句。

例子：

whileTrue:

s=raw_input('Entersomething:')

ifs=='quit':

breakcontinue語句continue語句被用來告訴Python跳過當(dāng)前循環(huán)塊中的剩余語句，然后繼續(xù)進行下一輪循環(huán)。例子：whileTrue:

s=raw_input('Entersomething:')

ifs=='quit':

break

iflen(s)<3:

continue

print

'Inputisofsufficientlength'

2022/12/1712控制流break語句2022/12/1612控制流函數(shù)定義函數(shù)函數(shù)通過def關(guān)鍵字定義。

例子：

defsayHello():

print'HelloWorld!'局部變量當(dāng)你在函數(shù)定義內(nèi)聲明變量的時候，它們與函數(shù)外具有相同名稱的其他變量沒有任何關(guān)系，即變量名稱對于函數(shù)來說是局部的。這稱為變量的作用域。所有變量的作用域是它們被定義的塊，從它們的名稱被定義的那點開始。

例子：

deffunc(x):

print'xis',x

x=2

print'Changedlocalxto',x2022/12/1713函數(shù)定義函數(shù)2022/12/1613使用global語句如果你想要為一個定義在函數(shù)外的變量賦值，那么你就得告訴Python這個變量名不是局部的，而是全局的。我們使用global語句完成這一功能。沒有g(shù)lobal語句，是不可能為定義在函數(shù)外的變量賦值的。你可以使用定義在函數(shù)外的變量的值（假設(shè)在函數(shù)內(nèi)沒有同名的變量）。然而，我并不鼓勵你這樣做，并且你應(yīng)該盡量避免這樣做，因為這使得程序的讀者會不清楚這個變量是在哪里定義的。使用global語句可以清楚地表明變量是在外面的塊定義的。

例子： x=50

deffunc():

globalx

print'xis',x

x=2

print'Changedlocalxto',x

func()

printx

2022/12/1714函數(shù)結(jié)果：xis50Changedlocalxto22使用global語句2022/12/1614函數(shù)結(jié)果：默認參數(shù)值對于一些函數(shù)，你可能希望它的一些參數(shù)是可選的，如果用戶不想要為這些參數(shù)提供值的話，這些參數(shù)就使用默認值。這個功能借助于默認參數(shù)值完成。你可以在函數(shù)定義的形參名后加上賦值運算符（=）和默認值，從而給形參指定默認參數(shù)值。注意，默認參數(shù)值應(yīng)該是一個參數(shù)。更加準確的說，默認參數(shù)值應(yīng)該是不可變的——這會在后面的章節(jié)中做詳細解釋。從現(xiàn)在開始，請記住這一點。

例子：

defsay(message,times=1):

printmessage*times

say('Hello')

say('World',5)return語句return語句用來從一個函數(shù)返回即跳出函數(shù)。我們也可選從函數(shù)返回一個值。2022/12/1715函數(shù)結(jié)果：HelloWorldWorldWorldWorldWorld默認參數(shù)值2022/12/1615函數(shù)結(jié)果：函數(shù)DocStrings

Python有一個很奇妙的特性，稱為文檔字符串，它通常被簡稱為docstrings。DocStrings是一個重要的工具，由于它幫助你的程序文檔更加簡單易懂，你應(yīng)該盡量使用它。你甚至可以在程序運行的時候，從函數(shù)恢復(fù)文檔字符串！defprintMax(x,y):

'''Printsthemaximumoftwonumbers.

Thetwovaluesmustbeintegers.'''

x=int(x)#converttointegers,ifpossible

y=int(y)

ifx>y:

printx,'ismaximum'

else:

printy,'ismaximum'

printMax(3,5)

printprintMax.__doc__

結(jié)果：5ismaximum

Printsthemaximumoftwonumbers.Thetwovaluesmustbeintegers.

2022/12/1716函數(shù)DocStrings2022/12/1616使用sys模塊importsys

sys.path包含輸入模塊的目錄名列表。字節(jié)編譯的.pyc文件輸入一個模塊相對來說是一個比較費時的事情，所以Python做了一些技巧，以便使輸入模塊更加快一些。一種方法是創(chuàng)建字節(jié)編譯的文件，這些文件以.pyc作為擴展名。字節(jié)編譯的文件與Python變換程序的中間狀態(tài)有關(guān)（是否還記得Python如何工作的介紹？）。當(dāng)你在下次從別的程序輸入這個模塊的時候，.pyc文件是十分有用的——它會快得多，因為一部分輸入模塊所需的處理已經(jīng)完成了。另外，這些字節(jié)編譯的文件也是與平臺無關(guān)的。所以，現(xiàn)在你知道了那些.pyc文件事實上是什么了。2022/12/1717模塊使用sys模塊2022/12/1617模塊模塊from..import語句如果你想要直接輸入argv變量到你的程序中（避免在每次使用它時打sys.），那么你可以使用fromsysimportargv語句。如果你想要輸入所有sys模塊使用的名字，那么你可以使用fromsysimport*語句。這對于所有模塊都適用。一般說來，應(yīng)該避免使用from..import而使用import語句，因為這樣可以使你的程序更加易讀，也可以避免名稱的沖突。

fromsysimport*或者fromsysimportargv或者importsys模塊的__name__每個模塊都有一個名稱，在模塊中可以通過語句來找出模塊的名稱。這在一個場合特別有用——就如前面所提到的，當(dāng)一個模塊被第一次輸入的時候，這個模塊的主塊將被運行。假如我們只想在程序本身被使用的時候運行主塊，而在它被別的模塊輸入的時候不運行主塊，我們該怎么做呢？這可以通過模塊的__name__屬性完成。

例子：

if__name__=='__main__':

2022/12/1718模塊from..import語句2022/12/1618制造你自己的模塊創(chuàng)建你自己的模塊是十分簡單的，你一直在這樣做！每個Python程序也是一個模塊。你已經(jīng)確保它具有.py擴展名了。下面這個例子將會使它更加清晰。例8.3如何創(chuàng)建你自己的模塊#!/usr/bin/python

#Filename:mymodule.py

defsayhi():

print'Hi,thisismymodulespeaking.'

version='0.1'

#Endofmymodule.py上面是一個模塊的例子。你已經(jīng)看到，它與我們普通的Python程序相比并沒有什么特別之處。我們接下來將看看如何在我們別的Python程序中使用這個模塊。記住這個模塊應(yīng)該被放置在我們輸入它的程序的同一個目錄中，或者在sys.path所列目錄之一。

importmymodule

frommymoduleimport* mymodule.sayhi()

print'Version',mymodule.version2022/12/1719模塊制造你自己的模塊2022/12/1619模塊dir()函數(shù)你可以使用內(nèi)建的dir函數(shù)來列出模塊定義的標識符。標識符有函數(shù)、類和變量。當(dāng)你為dir()提供一個模塊名的時候，它返回模塊定義的名稱列表。如果不提供參數(shù)，它返回當(dāng)前模塊中定義的名稱列表。

例子：

$python

>>>importsys

>>>dir(sys)#getlistofattributesforsysmodule

['__displayhook__','__doc__','__excepthook__','__name__','__stderr__',

'__stdin__','__stdout__','_getframe','api_version','argv',

'builtin_module_names','byteorder','call_tracing','callstats',

'copyright','displayhook','exc_clear','exc_info','exc_type',

'excepthook','exec_prefix','executable','exit','getcheckinterval',

'getdefaultencoding','getdlopenflags','getfilesystemencoding',

'getrecursionlimit','getrefcount','hexversion','maxint','maxunicode',

'meta_path','modules','path','path_hooks','path_importer_cache',

'platform','prefix','ps1','ps2','setcheckinterval','setdlopenflags',

'setprofile','setrecursionlimit','settrace','stderr','stdin','stdout',

'version','version_info','warnoptions']

2022/12/1720模塊dir()函數(shù)2022/12/1620模塊數(shù)據(jù)結(jié)構(gòu)數(shù)據(jù)結(jié)構(gòu)基本上就是——它們是可以處理一些數(shù)據(jù)的結(jié)構(gòu)?；蛘哒f，它們是用來存儲一組相關(guān)數(shù)據(jù)的。在Python中有三種內(nèi)建的數(shù)據(jù)結(jié)構(gòu)——列表、元組和字典。我們將會學(xué)習(xí)如何使用它們，以及它們?nèi)绾问咕幊套兊煤唵巍Ａ斜韑ist是處理一組有序項目的數(shù)據(jù)結(jié)構(gòu)，即你可以在一個列表中存儲一個序列的項目。假想你有一個購物列表，上面記載著你要買的東西，你就容易理解列表了。只不過在你的購物表上，可能每樣?xùn)|西都獨自占有一行，而在Python中，你在每個項目之間用逗號分割。列表中的項目應(yīng)該包括在方括號中，這樣Python就知道你是在指明一個列表。一旦你創(chuàng)建了一個列表，你可以添加、刪除或是搜索列表中的項目。由于你可以增加或刪除項目，我們說列表是可變的數(shù)據(jù)類型，即這種類型是可以被改變的。

例子：

2022/12/1721數(shù)據(jù)結(jié)構(gòu)數(shù)據(jù)結(jié)構(gòu)基本上就是——它們是可以處理一些數(shù)據(jù)結(jié)構(gòu)

2022/12/1722

shoplist=['apple','mango','carrot','banana']print'Ihave',len(shoplist),'itemstopurchase.'

print'Theseitemsare:',#Noticethecommaatendoftheline

foriteminshoplist:

printitem,

print'\nIalsohavetobuyrice.'

shoplist.append('rice')

print'Myshoppinglistisnow',shoplist

print'Iwillsortmylistnow'

shoplist.sort()

print'Sortedshoppinglistis',shoplist

print'ThefirstitemIwillbuyis',shoplist[0]

olditem=shoplist[0]

delshoplist[0]

print'Iboughtthe',olditem

print'Myshoppinglistisnow',shoplist結(jié)果：Ihave4itemstopurchase.

Theseitemsare:applemangocarrotbanana

Ialsohavetobuyrice.

Myshoppinglistisnow['apple','mango','carrot','banana','rice']

Iwillsortmylistnow

Sortedshoppinglistis['apple','banana','carrot','mango','rice']

ThefirstitemIwillbuyisapple

Iboughttheapple

Myshoppinglistisnow['banana','carrot','mango','rice']數(shù)據(jù)結(jié)構(gòu)

2022/12/1622shoplist=元組元組和列表十分類似，只不過元組和字符串一樣是不可變的即你不能修改元組。元組通過圓括號中用逗號分割的項目定義。元組通常用在使語句或用戶定義的函數(shù)能夠安全地采用一組值的時候，即被使用的元組的值不會改變。

例子：

zoo=('wolf','elephant','penguin')print'Numberofanimalsinthezoois',len(zoo)

print'Allanimalsinzooare',zoo字典字典類似于你通過聯(lián)系人名字查找地址和聯(lián)系人詳細情況的地址簿，即，我們把鍵（名字）和值（詳細情況）聯(lián)系在一起。注意，鍵必須是唯一的，就像如果有兩個人恰巧同名的話，你無法找到正確的信息。

2022/12/1723數(shù)據(jù)結(jié)構(gòu)結(jié)果：Numberofanimalsinthezoois3Allanimalsinzooare(‘monkey’,‘dolphin’,‘penguin’)

元組2022/12/1623數(shù)據(jù)結(jié)構(gòu)結(jié)果：

2022/12/1724數(shù)據(jù)結(jié)構(gòu)結(jié)果：Swaroop'saddressisswaroopch@

Thereare4contactsintheaddress-book

ContactSwaroopatswaroopch@

ContactMatsumotoatmatz@

ContactLarryatlarry@

ContactGuidoatguido@

Guido'saddressisguido@ab={

'Swaroop'

:'swaroopch@',

'Larry'

:'larry@',

'Matsumoto'

:'matz@',

'Spammer'

:'spammer@'

}

print"Swaroop'saddressis%s"%ab['Swaroop']

#Addingakey/valuepair

ab['Guido']='guido@'

#Deletingakey/valuepair

delab['Spammer']

print'\nThereare%dcontactsintheaddress-book\n'%len(ab)

forname,addressinab.items():

print'Contact%sat%s'%(name,address)

if'Guido'inab:#ORab.has_key('Guido')

print"\nGuido'saddressis%s"%ab['Guido']

2022/12/1624數(shù)據(jù)結(jié)構(gòu)結(jié)果：ab數(shù)據(jù)結(jié)構(gòu)序列

列表、元組和字符串都是序列，但是序列是什么，它們?yōu)槭裁慈绱颂貏e呢？序列的兩個主要特點是索引操作符和切片操作符。索引操作符讓我們可以從序列中抓取一個特定項目。切片操作符讓我們能夠獲取序列的一個切片，即一部分序列。shoplist=['apple','mango','carrot','banana']

#Indexingor'Subscription'operation

print'Item0is',shoplist[0]

print'Item1is',shoplist[1]

print'Item2is',shoplist[2]

print'Item3is',shoplist[3]

print'Item-1is',shoplist[-1]

print'Item-2is',shoplist[-2]

#Slicingonalist

print'Item1to3is',shoplist[1:3]

print'Item2toendis',shoplist[2:]

print'Item1to-1is',shoplist[1:-1]

print'Itemstarttoendis',shoplist[:]

#Slicingonastring

name='swaroop'

print'characters1to3is',name[1:3]

print'characters2toendis',name[2:]

print'characters1to-1is',name[1:-1]

print'charactersstarttoendis',name[:]2022/12/1725結(jié)果：Item0isapple

Item1ismango

Item2iscarrot

Item3isbanana

Item-1isbanana

Item-2iscarrot

Item1to3is['mango','carrot']

Item2toendis['carrot','banana']

Item1to-1is['mango','carrot']

Itemstarttoendis['apple','mango','carrot','banana']

characters1to3iswa

characters2toendisaroop

characters1to-1iswaroo

charactersstarttoendisswaroop數(shù)據(jù)結(jié)構(gòu)序列2022/12/1625結(jié)果：數(shù)據(jù)結(jié)構(gòu)參考

當(dāng)你創(chuàng)建一個對象并給它賦一個變量的時候，這個變量僅僅參考那個對象，而不是表示這個對象本身！也就是說，變量名指向你計算機中存儲那個對象的內(nèi)存。這被稱作名稱到對象的綁定。

一般說來，你不需要擔(dān)心這個，只是在參考上有些細微的效果需要你注意。這會通過下面這個例子加以說明。 print'SimpleAssignment'

shoplist=['apple','mango','carrot','banana']

mylist=shoplist#mylistisjustanothernamepointingtothesameobject!

delshoplist[0]

print'shoplistis',shoplist

print'mylistis',mylist

#noticethatbothshoplistandmylistbothprintthesamelistwithout

#the'apple'confirmingthattheypointtothesameobject

print'Copybymakingafullslice'

mylist=shoplist[:]#makeacopybydoingafullslice

delmylist[0]#removefirstitem

print'shoplistis',shoplist

print'mylistis',mylist

#noticethatnowthetwolistsaredifferent2022/12/1726結(jié)果：SimpleAssignment

shoplistis['mango','carrot','banana']

mylistis['mango','carrot','banana']

Copybymakingafullslice

shoplistis['mango','carrot','banana']

mylistis['carrot','banana']數(shù)據(jù)結(jié)構(gòu)參考2022/12/1626結(jié)果：數(shù)據(jù)結(jié)構(gòu)更多字符串的內(nèi)容

我們已經(jīng)在前面詳細討論了字符串。我們還需要知道什么呢？那么，你是否知道字符串也是對象，同樣具有方法。這些方法可以完成包括檢驗一部分字符串和去除空格在內(nèi)的各種工作。

你在程序中使用的字符串都是str類的對象。這個類的一些有用的方法會在下面這個例子中說明。如果要了解這些方法的完整列表，請參見help(str) name='Swaroop'#Thisisastringobject

ifname.startswith('Swa'):

print'Yes,thestringstartswith"Swa"'

if'a'inname:

print'Yes,itcontainsthestring"a"'

ifname.find('war')!=-1:

print'Yes,itcontainsthestring"war"'

delimiter='_*_'

mylist=['Brazil','Russia','India','China']

printdelimiter.join(mylist)2022/12/1727結(jié)果：Yes,thestringstartswith"Swa"

Yes,itcontainsthestring"a"

Yes,itcontainsthestring"war"

Brazil_*_Russia_*_India_*_China數(shù)據(jù)結(jié)構(gòu)更多字符串的內(nèi)容2022/12/1627結(jié)果：面向?qū)ο蟮木幊痰侥壳盀橹?，在我們的程序中，我們都是根?jù)操作數(shù)據(jù)的函數(shù)或語句塊來設(shè)計程序的。這被稱為面向過程的編程。還有一種把數(shù)據(jù)和功能結(jié)合起來，用稱為對象的東西包裹起來組織程序的方法。這種方法稱為面向?qū)ο蟮木幊汤砟?。在大多?shù)時候你可以使用過程性編程，但是有些時候當(dāng)你想要編寫大型程序或是尋求一個更加合適的解決方案的時候，你就得使用面向?qū)ο蟮木幊碳夹g(shù)。類和對象是面向?qū)ο缶幊痰膬蓚€主要方面。類創(chuàng)建一個新類型，而對象這個類的實例。這類似于你有一個int類型的變量，這存儲整數(shù)的變量是int類的實例（對象）。類

創(chuàng)建一個類

classPerson:

pass

p=Person()

printp2022/12/1728結(jié)果：<__main__.Personinstanceat0xf6fcb18c>面向?qū)ο蟮木幊痰侥壳盀橹?，在我們的程序中，我們都是根?jù)操作數(shù)面向?qū)ο蟮木幊虒ο蟮姆椒?/p>

classPerson:

defsayHi(self):

print'Hello,howareyou?'

p=Person()

p.sayHi()__init__方法在Python的類中有很多方法的名字有特殊的重要意義。現(xiàn)在我們將學(xué)習(xí)__init__方法的意義。__init__方法在類的一個對象被建立時，馬上運行。這個方法可以用來對你的對象做一些你希望的初始化。注意，這個名稱的開始和結(jié)尾都是雙下劃線。2022/12/1729面向?qū)ο蟮木幊虒ο蟮姆椒?022/12/1629面向?qū)ο蟮木幊填惻c對象的方法我們已經(jīng)討論了類與對象的功能部分，現(xiàn)在我們來看一下它的數(shù)據(jù)部分。事實上，它們只是與類和對象的名稱空間

綁定的普通變量，即這些名稱只在這些類與對象的前提下有效。有兩種類型的域

——類的變量和對象的變量，它們根據(jù)是類還是對象擁有這個變量而區(qū)分。類的變量由一個類的所有對象（實例）共享使用。只有一個類變量的拷貝，所以當(dāng)某個對象對類的變量做了改動的時候，這個改動會反映到所有其他的實例上。對象的變量由類的每個對象/實例擁有。因此每個對象有自己對這個域的一份拷貝，即它們不是共享的，在同一個類的不同實例中，雖然對象的變量有相同的名稱，但是是互不相關(guān)的。2022/12/1730面向?qū)ο蟮木幊填惻c對象的方法2022/12/1630面向?qū)ο蟮木幊?!/usr/bin/python

#Filename:objvar.py

classPerson:

'''Representsaperson.'''

population=0

def__init__(self,name):

'''Initializestheperson'sdata.'''

=name

print'(Initializing%s)'%

#Whenthispersoniscreated,he/she

#addstothepopulation

Person.population+=1

def__del__(self):

'''Iamdying.'''

print'%ssaysbye.'%

Person.population-=1

ifPerson.population==0:

print'Iamthelastone.'

else:

print'Therearestill%dpeopleleft.'%Person.population

2022/12/1731面向?qū)ο蟮木幊?!/usr/bin/python

#Fil面向?qū)ο蟮木幊?/p>

defsayHi(self):

'''Greetingbytheperson.

Really,that'sallitdoes.'''

print'Hi,mynameis%s.'%

defhowMany(self):

'''Printsthecurrentpopulation.'''

ifPerson.population==1:

print'Iamtheonlypersonhere.'

else:

print'Wehave%dpersonshere.'%Person.population

swaroop=Person('Swaroop')

swaroop.sayHi()

swaroop.howMany()

kalam=Person('AbdulKalam')

kalam.sayHi()

kalam.howMany()

swaroop.sayHi()

swaroop.howMany()

2022/12/1732結(jié)果：(InitializingSwaroop)

Hi,mynameisSwaroop.

Iamtheonlypersonhere.

(InitializingAbdulKalam)

Hi,mynameisAbdulKalam.

Wehave2personshere.

Hi,mynameisSwaroop.

Wehave2personshere.

AbdulKalamsaysbye.

Therearestill1peopleleft.

Swaroopsaysbye.

Iamthelastone.面向?qū)ο蟮木幊?/p>

defsayHi(self):

面向?qū)ο蟮木幊汤^承

面向?qū)ο蟮木幊處淼闹饕锰幹皇谴a的重用，實現(xiàn)這種重用的方法之一是通過繼承機制。繼承完全可以理解成類之間的類型和子類型關(guān)系。

假設(shè)你想要寫一個程序來記錄學(xué)校之中的教師和學(xué)生情況。他們有一些共同屬性，比如姓名、年齡和地址。他們也有專有的屬性，比如教師的薪水、課程和假期，學(xué)生的成績和學(xué)費。

你可以為教師和學(xué)生建立兩個獨立的類來處理它們，但是這樣做的話，如果要增加一個新的共有屬性，就意味著要在這兩個獨立的類中都增加這個屬性。這很快就會顯得不實用。

一個比較好的方法是創(chuàng)建一個共同的類稱為SchoolMember然后讓教師和學(xué)生的類繼承這個共同的類。即它們都是這個類型（類）的子類型，然后我們再為這些子類型添加專有的屬性。

使用這種方法有很多優(yōu)點。如果我們增加/改變了SchoolMember中的任何功能，它會自動地反映到子類型之中。例如，你要為教師和學(xué)生都增加一個新的身份證域，那么你只需簡單地把它加到SchoolMember類中。然而，在一個子類型之中做的改動不會影響到別的子類型。另外一個優(yōu)點是你可以把教師和學(xué)生對象都作為SchoolMember對象來使用，這在某些場合特別有用，比如統(tǒng)計學(xué)校成員的人數(shù)。一個子類型在任何需要父類型的場合可以被替換成父類型，即對象可以被視作是父類的實例，這種現(xiàn)象被稱為多態(tài)現(xiàn)象。2022/12/1733面向?qū)ο蟮木幊汤^承2022/12/1633面向?qū)ο蟮木幊?!/usr/bin/python

#Filename:inherit.py

classSchoolMember:

'''Representsanyschoolmember.'''

def__init__(self,name,age):

=name

self.age=age

print'(InitializedSchoolMember:%s)'%

deftell(self):

'''Tellmydetails.'''

print'Name:"%s"Age:"%s"'%(,self.age),

classTeacher(SchoolMember):

'''Representsateacher.'''

def__init__(self,name,age,salary):

SchoolMember.__init__(self,name,age)

self.salary=salary

print'(InitializedTeacher:%s)'%

deftell(self):

SchoolMember.tell(self)

print'Salary:"%d"'%self.salary

2022/12/1734面向?qū)ο蟮木幊?!/usr/bin/python

#Fil面向?qū)ο蟮木幊蘡lassStudent(SchoolMember):

'''Representsastudent.'''

def__init__(self,name,age,marks):

SchoolMember.__init__(self,name,age)

self.marks=marks

print'(InitializedStudent:%s)'%

deftell(self):

SchoolMember.tell(self)

print'Marks:"%d"'%self.marks

t=Teacher('Mrs.Shrividya',40,30000)

s=Student('Swaroop',22,75)

print#printsablankline

members=[t,s]

formemberinmembers:

member.tell()#worksforbothTeachersandStudents2022/12/1735結(jié)果：(InitializedSchoolMember:Mrs.Shrividya)

(InitializedTeacher:Mrs.Shrividya)

(InitializedSchoolMember:Swaroop)

(InitializedStudent:Swaroop)

Name:"Mrs.Shrividya"Age:"40"Salary:"30000"

Name:"Swaroop"Age:"22"Marks:"75"面向?qū)ο蟮木幊蘡lassStudent(SchoolMem輸入/輸出文件你可以通過創(chuàng)建一個file類的對象來打開一個文件，分別使用file類的read、readline或write方法來恰當(dāng)?shù)刈x寫文件。對文件的讀寫能力依賴于你在打開文件時指定的模式。最后，當(dāng)你完成對文件的操作的時候，你調(diào)用close方法來告訴Python我們完成了對文件的使用。

例子：

poem='''\

Programmingisfun

Whentheworkisdone

'''

f=file('poem.txt','w')#openfor'w'riting

f.write(poem)#writetexttofile

f.close()#closethefile

f=file('poem.txt')

#ifnomodeisspecified,'r'eadmodeisassumedbydefault

whileTrue:

line=f.readline()

iflen(line)==0:#ZerolengthindicatesEOF

break

printline,

#NoticecommatoavoidautomaticnewlineaddedbyPython

f.close()#closethefile

2022/12/1736輸入/輸出文件2022/12/1636輸入/輸出儲存器 Python提供一個標準的模塊，稱為pickle。使用它你可以在一個文件中儲存任何Python對象，之后你又可以把它完整無缺地取出來。這被稱為持久地儲存對象。

還有另一個模塊稱為cPickle，它的功能和pickle模塊完全相同，只不過它是用C語言編寫的，因此要快得多（比pickle快1000倍）。你可以使用它們中的任一個，而我們在這里將使用cPickle模塊。記住，我們把這兩個模塊都簡稱為pickle模塊。2022/12/1737輸入/輸出儲存器2022/12/1637輸入/輸出importcPickleasp

#importpickleasp

shoplistfile='shoplist.data'

#thenameofthefilewherewewillstoretheobject

shoplist=['apple','mango','carrot']

#Writetothefile

f=file(shoplistfile,'w')

p.dump(shoplist,f)#dumptheobjecttoafile

f.close()

delshoplist#removetheshoplist

#Readbackfromthestorage

f=file(shoplistfile)

storedlist=p.load(f)

printstoredlist2022/12/1738結(jié)果：['apple','mango','carrot']輸入/輸出importcPickleasp

#impo異常處理異常我們可以使用try..except語句來處理異常。我們把通常的語句放在try-塊中，而把我們的錯誤處理語句放在except-塊中。

例子：

#!/usr/bin/python

#Filename:try_except.py

importsys

try:

f=open(‘python.py’)

except:

print’fileisnotexistence

'

2022/12/1739異常處理異常2022/12/1639異常引發(fā)異常你可以使用raise語句引發(fā)異常。你還得指明錯誤/異常的名稱和伴隨異常觸發(fā)的異常對象。你可以引發(fā)的錯誤或異常應(yīng)該分別是一個Error或Exception類的直接或間接導(dǎo)出類。

例子：

classShortInputException(Exception):

'''Auser-definedexceptionclass.'''

def__init__(self,length,atleast):

Exception.__init__(self)

self.length=length

self.atleast=atleast

try:

s=raw_input('Entersomething-->')

iflen(s)<3:

raiseShortInputException(len(s),3)

#Otherworkcancontinueasusualhere

exceptEOFError:

print'\nWhydidyoudoanEOFonme?'

exceptShortInputException,x:

print'ShortInputException:Theinputwasoflength%d,\

wasexpectingatleast%d'%(x.length,x.atleast)

else:

print'Noexceptionwasraised.'2022/12/1740結(jié)果：Entersomething-->ab

ShortInputException:Theinputwasoflength2,wasexpectingatleast3

Entersomething-->abc

Noexceptionwasraised.異常引發(fā)異常2022/12/1640結(jié)果：異常try..finally假如你在讀一個文件的時候，希望在無論異常發(fā)生與否的情況下都關(guān)閉文件，該怎么做呢？這可以使用finally塊來完成。注意，在一個try塊下，你可以同時使用except從句和finally塊。如果你要同時使用它們的話，需要把一個嵌入另外一個。

f=Nonetry:f=file(‘a(chǎn)bc.txt')except:print‘a(chǎn)nexceptionoccured'finally:iff!=None:f.close()print'Cleaningup...closedthefile'2022/12/1741結(jié)果：anexceptionoccurredCleaningup...closedthefile異常try..finally2022/12/1641結(jié)果：Python標準庫Python標準庫Python標準庫是隨Python附帶安裝的，它包含大量極其有用的模塊。熟悉Python標準庫是十分重要的，因為如果你熟悉這些庫中的模塊，那么你的大多數(shù)問題都可以簡單快捷地使用它們來解決。sys模塊sys模塊包含系統(tǒng)對應(yīng)的功能。 sys.path獲取當(dāng)前sys.exit函數(shù)退出正在運行的程序。2022/12/1742Python標準庫Python標準庫2022/12/1642Python標準庫os模塊這個模塊包含普遍的操作系統(tǒng)功能。如果你希望你的程序能夠與平臺無關(guān)的話，這個模塊是尤為重要的。即它允許一個程序在編寫后不需要任何改動，也不會發(fā)生任何問題，就可以在Linux和Windows下運行。一個例子就是使用os.sep可以取代操作系統(tǒng)特定的路徑分割符。os.getcwd()函數(shù)得到當(dāng)前工作目錄，即當(dāng)前Python腳本工作的目錄路徑。os.getenv()和os.putenv()函數(shù)分別用來讀取和設(shè)置環(huán)境變量。os.listdir()返回指定目錄下的所有文件和目錄名。os.remove()函數(shù)用來刪除一個文件。os.system()函數(shù)用來運行shell命令。os.linesep字符串給出當(dāng)前平臺使用的行終止符。例如，Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'。os.path.split()函數(shù)返回一個路徑的目錄名和文件名。>>>os.path.split('/home/swaroop/byte/code/poem.txt')

('/home/swaroop/byte/code','poem.txt')os.path.isfile()和os.path.isdir()函數(shù)分別檢驗給出的路徑是一個文件還是目錄。類似地，os.path.existe()函數(shù)用來檢驗給出的路徑是否真地存在。2022/12/1743Python標準庫os模塊2022/12/1643更多Python的內(nèi)容特殊的方法在類中有一些特殊的方法具有特殊的意義，比如__init__和__del__方法。一般說來，特殊的方法都被用來模仿某個行為。例如，如果你想要為你的類使用x[key]這樣的索引操作（就像列表和元組一樣），那么你只需要實現(xiàn)__getitem__()方法就可以了。想一下，Python就是對list類這樣做的！lambda形式lambda語句被用來創(chuàng)建新的函數(shù)對象，并且在運行時返回它們。

例子：

defmake_repeater(n):

returnlambdas:s*n

twice=make_repeater(2)

printtwice(5)

>>>g=lambdax:x*2>>>g(3)2022/12/1744更多Python的內(nèi)容特殊的方法2022/12/1644更多Python的內(nèi)容列表綜合

通過列表綜合，可以從一個已有的列表導(dǎo)出一個新的列表。例如，你有一個數(shù)的列表，而你想要得到一個對應(yīng)的列表，使其中所有大于2的數(shù)都是原來的2倍。對于這種應(yīng)用，列表綜合是最理想的方法。例子：listone=[2,3,4]

listtwo=[2*iforiinlistoneifi>2]

printlisttwo在函數(shù)中接收元組和列表

當(dāng)要使函數(shù)接收元組或字典形式的參數(shù)的時候，有一種特殊的方法，它分別使用*和**前綴。這種方法在函數(shù)需要獲取可變數(shù)量的參數(shù)的時候特別有用。由于在變量前有*前綴，所有多余的函數(shù)參數(shù)都會作為一個元組存儲在變量中。如果使用的是**前綴，多余的參數(shù)則會被認為是一個字典的鍵/值對。2022/12/1745結(jié)果：[6,8]更多Python的內(nèi)容列表綜合2022/12/1645結(jié)果