Python數(shù)據(jù)分析與數(shù)據(jù)挖掘 第2章 Python語言基礎

第2章Python語言基礎Python數(shù)據(jù)分析與數(shù)據(jù)挖掘2.1

Python語句語句書寫規(guī)則Python程序由Python語句組成，通常一行編寫一條Python語句。例如：print("Hello,

World!")print("I

amPython")Python語句可以沒有結束符，也可以如C語言等使用分號（;）作為結束符，以便將多條語句寫在一行中。例如：#把多個語句寫在一行的例子。print("Hello,

World!");

print("I

am

Python");過長的語句，可以以續(xù)行符（\）連接，寫為多行。例如：score_total

=

score_math

+

score_english

+

score_science

+

\score_art

+

score_physics

+

score_chemistry

+

\score_music語句書寫格式1.縮進縮進指在代碼行前面添加空格或Tab，這樣做可以使程序更有層次、更有結構感，從而使程序更易讀。在Python程序中，強制要求縮進，且縮進不是任意的，平級的語句行（代碼塊）的縮進必須相同。例如，以下語句會報錯：#縮進不規(guī)范print("Hello,")

print("I

amPython")定義數(shù)據(jù)模塊時，則需要必要的縮進，例如在一個循環(huán)體，則需要縮進表明循環(huán)層次，例如：for

i

in

range(9):table.write(i+1,0,

i+1,

style)table.write(0,i+1,

i+1,

style)for

j

in

range(9):table.write(i+1,j+1,(i+1)*(j+1))語句書寫格式1.縮進定義過程或函數(shù)時，也需要進行適當?shù)目s進，例如：def

excel_table_byindex(file="Sample.xls"):#定義函數(shù)，語句塊需要縮進data=open_excel(file)table

=

data.sheets()[0]list

=[]for

r

inrange(1,nrows):

#循環(huán)的語句塊，需要縮進row=table.row_values(r)if

row:

#選擇結構的語句塊，需要縮進for

i

in

range(len(colnames)):#循環(huán)的語句塊，需要縮進list.append(row[i])returnlist語句書寫格式2.注釋說明性注釋Python中的說明性注釋有單行注釋和多行注釋。單行注釋以#開頭，后面跟注釋文字，可以獨占一行或在一行代碼的最后。例如：#這是一個獨占一行的注釋print("Hello,World!")#這是一個句尾注釋，內容是：輸出經(jīng)典字符串多行注釋用三個單引號"""或者三個雙引號"""對排列為多行的注釋進行定界，例如："""這是多行注釋，用三個單引號這是多行注釋，用三個單引號這是多行注釋，用三個單引號"""print("Hello,

World!")語句書寫格式2.注釋特殊注釋特殊注釋不僅為編程人員提示相關信息，也具有一定的設置或配置功能。例如，當需要告訴

Python解釋器，在LINUX系統(tǒng)下，尋找Python翻譯器的路徑，就可以使用：#

!/usr/bin/env

python而告訴Python解釋器，如何解釋字符串中的編碼類型，則可以使用注釋語句：#

-*-coding:utf-8-*-語句書寫格式2.注釋對函數(shù)或類定義的注釋對函數(shù)或類定義的注釋，是為了在使用help()函數(shù)顯示函數(shù)或類的說明信息時提供文字信息。class

SampleClass(object):"""Summaryof

class

here.Longer

class

information....Longer

class

information....Attributes:likes_spam:

A

boolean

indicating

if

we

like

SPAM

or

not.eggs:

An

integer

count

of

the

eggs

we

have

laid."""def

init

(self,

likes

spam=False):"""InitsSampleClasswith

blah."""self.likes_spam

=

likes_spamself.eggs

=

0def

public_method(self):

"""Performs

operation

blah."""2.2基本數(shù)據(jù)類型數(shù)值類型Python語言包括三種數(shù)值類型：整數(shù)類型、浮點數(shù)類型和復數(shù)類型。整數(shù)類型(integer)與數(shù)學中的整數(shù)概念一致，沒有取值范圍限制。例如：

1010,99,-2170x9a,-0X89

(0x,0X開頭表示16進制數(shù))0b010,-0B101

(0b,0B開頭表示2進制數(shù))0o123,-0O456

(0o,0O開頭表示8進制數(shù))浮點數(shù)類型(float)Python語言中浮點數(shù)的數(shù)值范圍存在限制，小數(shù)精度也存在限制。這種限制與在不同計算機系統(tǒng)有關。例如：0.0,

-77.,

-2.1796e4,4.3e-3,9.6E5

（科學計數(shù)法，使用字母"e"或者"E"為冪的符號，以10為基數(shù)）。數(shù)值類型Python語言包括三種數(shù)值類型：整數(shù)類型、浮點數(shù)類型和復數(shù)類型。3.復數(shù)類型(complex)與數(shù)學中的復數(shù)概念一致，z=a+bj，a是實數(shù)部分，b是虛數(shù)部分，a和b都是浮點類型，虛數(shù)部分用j或者J標識。例如：12.3+4j,-5.6+7j對于復數(shù)z，可以用其屬性z.real獲得實數(shù)部分，z.imag獲得虛數(shù)部分，abs(z)獲得模。字符串類型(string)字符串類型的常量用""或""定界符定界。例如：

"小明","江蘇","3234.34"等等。如果在字符串文本中包含系統(tǒng)規(guī)定的定界符，則可以用兩種定界符相結合，定義含定界符字符的字符串。例如：print("有效的學習方法是"學以致用"!")有效的學習方法是"學以致用"!字符串類型(string)字符串中可以包含反斜線"\"符號，和不同的字符結合使用，可以代表不同的涵義，稱為“轉義”。較為常見的轉義含義見表。>>>

print("123456\t12345")>>>

print("123\t12345\n")>>>

print("C:\\PYTHON\\SOURCECODE\\")123456

12345123

12345C:\PYTHON\SOURCECODE\常用轉義符含義\n回車，新的一行\(zhòng)t制表符（Tab）\\一個\\a響鈴Bell\’單引號\”雙引號布爾類型(bool)布爾類型的常量為：True，F(xiàn)alse。這里要注意區(qū)分大小寫。布爾類型常量和變量之間可進行邏輯運算，具體見第2.4節(jié)邏輯運算符部分的內容。“空”類型(NoneType)“空”類型（NoneType）只有一個常量數(shù)值：None。None與其他編程語言中的NULL相類似。2.3標識符與變量標識符與變量的命名76trombones

=

"big

parade"more@

=

10000class

=

"Advanced"#首字母必須為字母或下劃線#必須由字母、數(shù)字、下劃線構成#不能為系統(tǒng)關鍵字(class)標識符是指變量、函數(shù)、模塊等的名字。變量是內存中命名的存儲位置，與常量不同的是變量的值可以動態(tài)變化。Python的標識符命名規(guī)則如下：可以任意長度；不能為系統(tǒng)關鍵字(保留字)；標識符名字可以由字母、下劃線(_)或數(shù)字(0~9)組成，但首字符必須是字母或下劃線；4）標識符名字區(qū)分大小寫，即Score和score是不同的。X

=

1y

=

2my_name

=

"x-man"2.4運算及運算符運算符是程序設計語言的最基本元素，它是構成表達式的基礎。本節(jié)將介紹Python語言運算符和表達式。運算符Python支持算術運算符、賦值運算符、位運算符、比較運算符、邏輯運算符、字符串運算符、成員運算符和身份運算符等基本運算符。運算符1．算術運算符位運算符具體描述例子+相加運算1+2的結果是3-相減運算100-1的結果是99*乘法運算2*2的結果是4/除法運算4/2的結果是2%求模運算10%3的結果是1**冪運算。x**y返回x的y次冪2**3的結果是8//整除運算，即返回商的整數(shù)部分9//2的結果4運算符2．賦值運算符位運算符具體描述例子=直接賦值x=3;將3賦值到變量x中+=加法賦值x+=3;等同于x=x+3;-=減法賦值x-=3;等同于x=x-3;*=乘法賦值x*=3;等同于x=x*3;/=除法賦值x/=3;等同于x=x/3;%=取模賦值x%=3;等同于x=x%3;**=冪賦值x**=3;等同于x=x**3;//=整除賦值x//=3;等同于x=x//3;運算符2．賦值運算符運行結果如下：6393.0【例2-8】x

=3x

+=

3print(x)x

-=

3print(x)x

*=

3print(x)x

/=

3print(x)運算符3．位運算符位運算符具體描述&按位與運算，運算符查看兩個表達式的二進制表示法的值，并執(zhí)行按位

“與”操作。只要兩個表達式的某位都為1，則結果的該位為1；否則，結果的該位為0|按位或運算，運算符查看兩個表達式的二進制表示法的值，并執(zhí)行按位

“或”操作。只要兩個表達式的某位有一個為1，則結果的該位為1；否則，結果的該位為0^按位異或運算。異或的運算法則為：0異或0=0，1異或0=1，0異或1=1，1異或1=0~按位非運算。0取非運算的結果為1；1取非運算的結果為0<<位左移運算，即所有位向左移>>位右移運算，即所有位向右移運算符4．比較運算符比較運算符具體描述==等于運算符（兩個=）。例如a==b，如果a等于b，則返回True；否則返回False!=不等運算符。例如a!=b，如果a不等于b，則返回True；否則返回False<>不等運算符，與!=相同<小于運算符>大于運算符<=小于等于運算符運算符5．邏輯運算符邏輯運算符具體描述and邏輯與運算符。例如a

and

b，當a和b都為True時等于True；否則等于Falseor邏輯或運算符。例如a

or

b，當a和b至少有一個為True時等于True；否則等于Falsenot邏輯非運算符。例如not

a，當a等于True時，表達式等于False；否則等于True運算符5．邏輯運算符【例2-9】x=Truey=Falseprint("x

and

y

=

",

x

and

y)print("x

or

y

=

",

x

or

y)print("not

x

=

",

not

x)print("not

y

=

",

not

y)運行結果如下：x

and

y=Falsex

or

y=Truenot

x

=

Falsenot

y

=

True運算符6．字符串運算符邏輯運算符具體描述+字符串連接*重復輸出字符串[]獲取字符串中指定索引位置的字符，索引從0開始[start:end]截取字符串中的一部分，從索引位置start開始到end結束（不包括end位置的那個字符）in成員運算符，如果字符串中包含給定的字符則返回Truenot

in成員運算符，如果字符串中包含給定的字符返回Truer或者R指定原始字符串。原始字符串是指所有的字符串都是直接按照字面的意思來使用，沒有轉義字符、特殊字符或不能打印的字符。原始字符運算符6．字符串運算符【例2-10】b="hello"a

=

b

+

"world!"print(a)print(a*2)print(r"hello\nworld!")運行結果如下：

hello

world!hello

world!hello

world!hello\nworld!運算符7．運算符優(yōu)先級運算符具體描述**指數(shù)運算的優(yōu)先級最高~

+

-邏輯非運算符和正數(shù)/負數(shù)運算符*

/

%

//乘、除、取模和取整除+

-加和減>>

<<位右移運算和位左移運算&按位與運算^

|按位異或運算和按位或運算>

==

!=大于、等于和不等于%=

/=

//=-=

+=

*=

**=賦值運算符isis

not身份運算符in成員運算符2.5

程序結構選擇結構由if語句結構來搭建。最為常見的是if…else…語句if條件表達式:語句塊1else:語句塊2選擇結構選擇結構由if語句結構來搭建。最為常見的是if…else…語句if條件表達式1:語句塊1elif條件表達式2:語句塊2elif條件表達式3:語句塊3……else:語句塊n選擇結構1.for語句循環(huán)for可迭代表達式:循環(huán)語句體循環(huán)結構#例如，利用for循環(huán)，求1+2+…+100時sum=0for

i

in

range(1,

101):sum

+=

iprint(sum)

#結果：50502.while語句循環(huán)while條件表達式:循環(huán)語句體循環(huán)結構#例如，利用while循環(huán)，求1+2+…+100時，則可以寫成：

i=1sum

=

0while

i

<=

100:sum

+=

ii

+=

1print(sum)

#結果：5050循環(huán)結構3.Continue語句和break語句在for或while循環(huán)中，continue語句會使程序的執(zhí)行直接跳過后續(xù)語句，立即跳轉到for或while循環(huán)的下一次循環(huán)。break語句則會使程序的執(zhí)行直接跳過后續(xù)語句，立即跳出for或while循環(huán)。#例如，算1~100之間偶數(shù)之和，就可以使用continue語句跳過奇數(shù)項：sum=0for

i

in

range(1,

101):if

i%2

==

1:continuesum

+=

iprint(sum)

#結果：2550#這里，continue會使程序執(zhí)行跳過循環(huán)中的sum+=i語句，直接跳轉到第2行。3.Continue語句和break語句#對于break語句，例如求1+2+…+100時，也可以設計死循環(huán)，條件滿足時跳出：

i=1sum

=

0while

True:if

i

>

100:breaksum

+=

ii

+=

1print(sum)#這里，break會使程序執(zhí)行跳轉到最后一行。循環(huán)結構為了保證程序的強壯性，需要通過編程處理在運行過程中所出現(xiàn)的各種異常情況，并根據(jù)所發(fā)生的異常的類型，進行相應的提示或處理。為了使程序的結構清晰，有可讀性，Python設計了一個嘗試運行—拋出異常―捕捉異?！鄳幚淼臋C制，其主要的結構通過try和except關鍵字來搭建，因此也常用try-except結構來代表異常處理結構。try:<try語句塊>except[<異常處理類1>,<異常處理類2>,….]as<異常處理對象a>:<異常處理代碼>except[<異常處理類5>,<異常處理類6>,….]as<異常處理對象b>:<異常處理代碼>else:<沒有異常發(fā)生時的代碼>finally:<無論是否異常都執(zhí)行的代碼>異常處理結構try-except語句例如，語句j=30/(i-10)，當i=10時，會發(fā)生除以0異常，導致程序中斷，拋出一個

ZeroDivisionerror異常。這種情況下，可以將語句放在一個try-except異常處理結構中來進行處理和提示i

=

10try:j

=

30

/

(i

-

10)except

ZeroDivisionerror

as

e:print("執(zhí)行異常:",e)else:

#在else部分的語句塊無異常時會被執(zhí)行到

print("執(zhí)行正常")finally:#在finally部分的語句塊始終會被執(zhí)行到

print(u"執(zhí)行結束")異常處理結構try-except語句如果i=10，則執(zhí)行結果為：執(zhí)行異常:division

by

zero執(zhí)行結束如果i不等于10，則執(zhí)行結果為：執(zhí)行正常執(zhí)行結束2.6面向對象面向對象的概念，就是把數(shù)據(jù)及對數(shù)據(jù)的操作方法放在一起，作為一個相互依存的整體----對象。對同類對象抽象出其共性，就形成了類，是人們對各種具體物體抽象后的一個概念。類的具體化的實例，就是對象。類中所定義數(shù)據(jù)，或者說對象中所擁有的數(shù)據(jù)，從安全和規(guī)范化的角度來說，應該用本類所定義的方法進行訪問和處理。類和對象通過外部接口與外界發(fā)生關系，對象與對象之間通過消息進行通信。類的定義與使用用程序描述一個對象，首先要抽象出該對象所對應的類。在Python語言中，定義類的語句為：class<類名>:<類定義語句>方法與屬性在面向對象的概念中，類具有三要素，即屬性、方法和事件。屬性為類中所特有、所定義和所維護的數(shù)據(jù)。例如，在類Vehicle中，一般需要定義SIN、type、horsepower、cylinder_num等屬性，并通過實例化形成對象，來對該車輛進行定義和描述。方法為這個類所具有的行為、功能和能力，是定義在對象上的操作。例如，在類Vehicle中，可以定義ignite()（點火）、break()（剎車）、steering()（轉向）等方法。類中所定義的方法，在完成類實例化獲得類對象后，采用類似函數(shù)調用的方法進行調用。因此，在本文中，沒有仔細區(qū)分類方法和普通函數(shù)，而使用調用某方法，或調用某函數(shù)來表述。2.7

常用標準庫函數(shù)Python安裝完成后，就已經(jīng)完成了一系列基本的內建（不是在導入的擴展庫中定義的）函數(shù)的定義和實現(xiàn)，這些函數(shù)分為數(shù)學運算、類型轉換、序列操作、對象操作、反射操作、變量操作、交互操作、文件操作、編譯執(zhí)行和裝飾器幾個類別。數(shù)學運算1.求數(shù)值的絕對值abs()>>>

abs(-23.45)23.45數(shù)學運算>>>

divmod(5.5,

-2)(-3.0,

-0.5)2.求商和余數(shù)divmod(x,

y)>>>

divmod(5.5,2)(2.0,

1.5)數(shù)學運算>>>

max(-1,

-2,

0)#傳入3個參數(shù)取3個中較大者>>>

max("1234")#傳入1個可迭代對象，取其最大元素值03.求最大值和最小值max()min()"4">>>min(-1,-2,key=abs)#給出了比較函數(shù)，會對參數(shù)值求絕對值后再取較小者-1數(shù)學運算>>>

pow(2,

3)#等同于2**3>>>

pow(2,

3,

5)#等同于pow(2,3)%5384.求冪運算值pow(base,

exp,

mod=None)參數(shù)base為底；參數(shù)exp為指數(shù)；如果給出參數(shù)mod，則再計算冪運算值對mod的模。數(shù)學運算>>>

round(1314.520,

-2)#保留-2位，即到百位數(shù)>>>

round(1314.520,

1)#保留1位小數(shù)1314.51300.05.求四舍五入求值round(number,

ndigits=None)參數(shù)number為要進行四舍五入運算的數(shù)值，ndigits為要保留的小數(shù)位數(shù)。數(shù)學運算>>>

sum((1.5,2.5,3.5,4.5))#元素類型必須是數(shù)值型>>>

sum((1,2,3,4),

-10)#結果為(1+2+3+4)+(-10)012.06.求數(shù)值之和sum()類型轉換>>>

bool(0)#數(shù)值0、空序列等值為False>>>

bool(5

>

3)TrueFalse1.

bool(x)根據(jù)傳入的參數(shù)的邏輯值創(chuàng)建一個新的布爾值類型轉換>>>

int("1A",

16)#將"1A"以16進制轉換為10進制整數(shù)2.

int(x

[,base])將字符串x以base進制（默認為10進制）轉換為整數(shù)，或將非整數(shù)值x轉換為整數(shù)。注意int()求整數(shù)時，不四舍五入，僅截斷小數(shù)部分。>>>

int("3")+2526>>>

int(3.1415926)3類型轉換>>>

float("434.45353")434.453533.

float(X)將字符串x轉換為浮點數(shù)>>>

float(3)3.0類型轉換>>>complex(1,2)#傳入數(shù)值創(chuàng)建復數(shù)(1+2j)4.

complex()根據(jù)傳入?yún)?shù)創(chuàng)建一個新的復數(shù)>>>complex("1+2j")#傳入字符串創(chuàng)建復數(shù)(1+2j)類型轉換5.

str(X)將x轉換為字符串>>>

str(None)"None">>>

str("abc")"abc">>>

str(3.14159)"3.14159"類型轉換6.

bytearray()根據(jù)傳入的參數(shù)創(chuàng)建一個新的字節(jié)數(shù)組>>>bytearray("中文","utf-8")bytearray(b"\xe4\xb8\xad\xe6\x96\x87")類型轉換7.

bytes()根據(jù)傳入的參數(shù)創(chuàng)建一個新的不可變字節(jié)數(shù)組>>>bytes("中文","utf-8")b"\xe4\xb8\xad\xe6\x96\x87"類型轉換>>>

mv[-1]1038.

memoryview(object)根據(jù)傳入的參數(shù)創(chuàng)建一個新的內存查看對象>>>

mv

=memoryview(b"abcefg")>>>

mv[1]98類型轉換>>>ord("啊")218349.

ord(c)將字符c轉換為對應的ASCII碼>>>

ord("A")65類型轉換>>>chr(0x554a)#即21834"啊"10.

chr(i)將整數(shù)i轉換為其對應ASCII的字符或Unicode字符>>>chr(97)#參數(shù)類型為整數(shù)"a"類型轉換>>>

bin(3)"0b11"11.

bin(i)將整數(shù)i轉換為二進制字符串類型轉換>>>

oct(123)"0o173"12.

oct(i)將整數(shù)i轉換為一個八進制字符串，八進制字符串以0o開頭。例如：>>>

oct(8)"0o10"類型轉換>>>

hex(15)"0xf"13.hex(i)將整數(shù)i轉換為十六進制字符串，十六進制字符串以0x開頭。例如：類型轉換14.tuple()根據(jù)傳入的參數(shù)創(chuàng)建一個新的元組。元組是Python所定義的一個重要的數(shù)據(jù)結構，關于元組的概念和使用，在第3.3節(jié)進行詳細介紹。類型轉換15.list()根據(jù)傳入的參數(shù)創(chuàng)建一個新的列表。列表是Python所定義的一個重要的數(shù)據(jù)結構，關于列表的概念和使用，在第3.2節(jié)進行詳細介紹。類型轉換16.dict()根據(jù)傳入的參數(shù)創(chuàng)建一個新的字典。字典是Python所定義的一個重要的數(shù)據(jù)結構，關于字典的概念和使用，在第3.5節(jié)進行詳細介紹。類型轉換17.set()根據(jù)傳入的參數(shù)創(chuàng)建一個新的集合。集合是Python所定義的一個重要的數(shù)據(jù)結構，關于集合的概念和使用，在第3.4節(jié)進行詳細介紹。類型轉換18.

frozenset()根據(jù)傳入的參數(shù)創(chuàng)建一個新的不可變集合。關于不可變集合的概念和使用，在第3.4節(jié)（第65頁）進行詳細介紹。類型轉換>>>list(enumerate(seasons,start=1))

#指定index序號的起始值[(1,

"Spring"),

(2,

"Summer"),

(3,

"Fall"),

(4,

"Winter")]19.

enumerate()根據(jù)可迭代對象創(chuàng)建帶有index序號的枚舉對象>>>

seasons

=

["Spring",

"Summer",

"Fall",

"Winter"]>>>

list(enumerate(seasons))[(0,

"Spring"),

(1,

"Summer"),

(2,

"Fall"),

(3,

"Winter")]類型轉換20.

range(start,

stop[,

step])創(chuàng)建一個以參數(shù)start開始，以參數(shù)stop終止，步長為step的range對象，各參數(shù)值必須為整數(shù)。>>>

list(range(10))[0,

1,

2,

3,

4,

5,

6,

7,

8,

9]>>>

list(range(1,10))[1,

2,

3,

4,

5,

6,

7,

8,

9]>>>

list(range(1,10,3))[1,

4,

7]類型轉換>>>next(a);next(a);next(a);next(a)#共4個元素"a""b""c""d"21.

iter(iterable)根據(jù)傳入的參數(shù)創(chuàng)建一個新的可迭代對象>>>a=iter("abcd")#字符串序列>>>

a<str_iterator

object

at

0x03FB4FB0>>>>next(a)#前面已經(jīng)遍歷到最后一個元素，繼續(xù)調用next()則會拋出異常Traceback

(most

recent

call

last):File

"<pyshell#29>",

line

1,

in

<module>next(a)StopIteration類型轉換22.

slice(start,

stop[,step])創(chuàng)建一個以參數(shù)start開始，參數(shù)stop終止，步長為step的切片對象>>>s=slice(1,10,3)

#切片為取第1,4,7個元素>>>list(range(1,30,4)[s])#對range(1,30,4)應用s[5,

17,

29]類型轉換23.

super()根據(jù)傳入的參數(shù)創(chuàng)建一個新的子類和父類關系的代理對象>>>

class

A(object):

#定義父類Adef

init

(self):print("A.

init

")>>>

class

B(A):

#定義子類B，繼承Adef

init

(self):print("B.

init

")super().

init

()>>>b=B()

#super調用父類方法B.

init

A.

init

類型轉換24.

object()創(chuàng)建一個新的object對象>>>

a

=

object()>>>

print(a)<object

object

at

0x000000001EE4B8D0>序列操作>>>

all([1,2])#列表中每個元素邏輯值均為True，返回True>>>

all([0,1,2])#列表中0的邏輯值為False，返回FalseFalseTrue1.

all(iterable,

/)判斷可迭代對象的每個元素是否都為True值序列操作>>>

any([0,

0])#列表元素全部為False，則返回FalseFalse判斷可迭代對象的元素是否有為True值的元素>>>any([0,1,2])

#列表元素有一個為True，則返回TrueTrue2.

any(iterable,

/)序列操作>>>def

is_odd(x):

#定義奇數(shù)判斷函數(shù)return

x%2==1>>>

list(filter(is_odd,

range(1,10)))#篩選range()生成的序列中的奇數(shù)[1,

3,

5,

7,

9]3.

filter()使用指定方法過濾可迭代對象的元素序列操作>>>

list(map(abs,[1,-2,3,-4,5]))[1,

2,

3,

4,

5]4.

map(func,

*iterables)將指定方法運用到可迭代對象的每個元素，以生成新的可迭代對象>>>

list(map(ord,"abcd"))[97,

98,

99,

100]序列操作>>>

a

=

iter("abc")>>>

r

=

0>>>

while

r

!=

-1:#將-1作為結束標記r

=

next(a,

-1)print(r)abc-15.

next(iterator[,

default])返回可迭代對象中的下一個元素值。當已全部返回可迭代對象中的元素，再次調用next()時，如果設置了參數(shù)default，則返回該值，否則會拋出異常（見第2.7.2節(jié)中iter()部分的內容）。序列操作6.

reversed(sequence,

/)反轉序列生成新的可迭代對象>>>

list(reversed(range(10)))[9,

8,

7,

6,

5,

4,

3,

2,

1,

0]序列操作>>>sorted([3,4,1,2],key=np.sin)#按取sin()值排序[4,

3,

1,

2]7.

sorted(iterable,

/,

*,

key=None,

reverse=False)對可迭代對象iterable，按運用了參數(shù)key規(guī)定的方式處理后的值進行排序，并根據(jù)參數(shù)

reverse設置決定是否反轉，返回一個新的列表。>>>

a

=

["a","b","d","c","B","A"]>>>sorted(a,key=str.lower)#按轉換成小寫后排序，默認按字符ascii碼排序["a",

"A",

"b",

"B",

"c",

"d"]序列操作>>>x=["a","b","c"]

#長度38]

#長度5>>>

y

=

[4,

5,

6,

7,>>>list(zip(x,y))

#按x、y中較小長度組成zip列表注意，在Python3中，zip()返回的是zip迭代器對象，只能被遍歷一次。如果需要重復遍歷，可以使用list()轉換成列表。[("a",

4),

("b",

5),

("c",

6)]8.

zip(*iterables)聚合傳入的每個迭代器中相同位置的元素，返回一個新的元組類型迭代器。對象操作1.

help()返回對象的幫助信息。對象操作2.

dir([object])返回對象或者當前作用域內的屬性列表>>>

import

math>>>

dir(math)["

doc

",

"

loader

",

"

name

",

"

package

",

"

spec

",

"acos",

"acosh",

"asin","asinh",

"atan",

"atan2",

"atanh",

"ceil",

"copysign",

"cos",

"cosh",

"degrees",

"e",

"erf","erfc",

"exp",

"expm1",

"fabs",

"factorial",

"floor",

"fmod",

"frexp",

"fsum",

"gamma","gcd",

"hypot",

"inf",

"isclose",

"isfinite",

"isinf",

"isnan",

"ldexp",

"lgamma",

"log","log10",

"log1p",

"log2",

"modf",

"nan",

"pi",

"pow",

"radians",

"sin",

"sinh",

"sqrt","tan",

"tanh",

"trunc"]對象操作>>>str1="這是一個變量">>>

str1,

id(str1)#輸出str1及其地址>>>str2=str1

#將str1賦值給str2>>>str2,id(str2)

#輸出str2及其地址，可以看出str2與str1地址相同("這是一個變量",129094056)("這是一個變量",129094056)3.

id(obj,

/)返回對象的唯一標識符?？梢允褂胕d()函數(shù)輸出變量的地址。對象操作>>>

hash("good

good

study")2555302400646370674.

hash()獲取對象的哈希值對象操作>>>

type(124)#返回對象的類型5.

type(object)返回對象的類型，或者根據(jù)傳入的參數(shù)創(chuàng)建一個新的類型。<class

"int">>>>

type("abc")<class

"str">>>>

type(False)<class

"bool">對象操作6.

len()返回對象的長度。例如，以下6個對象的長度均為4：>>>len("abcd")

#字符串>>>len(bytes("abcd","utf-8"))

#字節(jié)數(shù)組>>>len((1,2,3,4))

#元組>>>len(range(1,5))

#range對象>>>len({"a":1,"b":2,"c":3,"d":4})#字典>>>len(frozenset("abcd"))

#不可變集合10>>>len(bytes("abcd字節(jié)","utf-8"))#漢字的utf編碼，每個字的字節(jié)數(shù)為310對象操作>>>

ascii(1)>>>

ascii("&")""&"""1"7.

ascii()返回對象的可打印表字符串表現(xiàn)方式>>>

ascii(9000000)"9000000">>>ascii("中文")#非ascii字符""\\u4e2d\\u6587""對象操作8.

format(value,

format_spec="",

/)將參數(shù)value所指定的字符串、數(shù)值等，按照format_spec所規(guī)定的格式（見下一頁表），轉換為字符串。例如，下面代碼中，將字符串以一定格式轉換輸出時，使用格式字符串‘s’來規(guī)定轉換格式。>>>format("some

string","18s")

#輸出寬度為18，不足以空格補齊"some

string

"對象操作8.

format(value,

format_spec="",

/)格式字符含義示例"s"轉化為字符串"b"轉化為二進制>>>format(123,"b")#十進制轉換成二進制

"1111011""c"轉化為unicode字符>>>format(0x4e2d,"c")"中""d"或"n"轉化為十進制，默認值。>>>format(0x4e2d,"n")#與"d"作用相同

"20013""o"轉化為八進制>>>format(0x4e2d,"o")#十六進制轉換成八進制

"47055""x"或"X"轉化為十六進制>>>format(123,"x");format(123,"X")#十轉十六進制

"7b""7B""e"或"E"轉化為科學計數(shù)法，默認保留6位小數(shù)。>>>

format(314159267,"e");format(314159267,"0.2E")"3.141593e+08""3.14E+08"

#保留2位小數(shù)，大寫E"f"或"F"轉化為小數(shù)點計數(shù)法，默認保留6位小數(shù)。>>>format(31415,"f");format(3.14,"0.10f")"31415.000000"

#默認保留6位小數(shù)"3.1400000000"

#保留10位小數(shù)"g"或"G"定義較特殊設p為格式中指定的保留小數(shù)位數(shù)，先嘗試采用科學計數(shù)法格式化，得到冪指數(shù)e，如果-

4<=e<p，則采用小數(shù)計數(shù)法，并保留p-1-e位小數(shù)，否則按小數(shù)計數(shù)法計數(shù)，并按p-1保留小對象操作9.

vars()返回當前作用域內的局部變量與該變量值組成的字典，或者返回對象的屬性列表。#在新打開的IDLE環(huán)境中運行vars()，得到以下結果：>>>

vars(){"

name

":

"

main

",

"

doc

":

None,

"

package

":

None,

"

loader

":

<class"_frozen_importlib.BuiltinImporter">,

"

spec

":

None,

"

annotations

":

{},"

builtins

":

<module

"builtins"

(built-in)>}反射操作1.

import

動態(tài)導入模塊。>>>

math

=

import

("math")>>>

math.sqrt(23)4.795831523312719反射操作2.

isinstance(obj,

class_or_tuple,

/)判斷對象obj是否是參數(shù)class_or_tuple所指明的類或類型元組中任意類元素的實例。>>>

isinstance(123,

int)True>>>

isinstance(123,

str)False>>>

isinstance(123,

(int,str))True反射操作>>>

issubclass(bool,

int)#bool為int類的子類>>>

issubclass(bool,

str)#bool不是str類的子類FalseTrue3.

issubclass(obj,

class_or_tuple,

/)判斷類obj是否是參數(shù)class_or_tuple所指明的類或類型元組中任意類元素的子類。>>>

issubclass(bool,

(str,int))#bool是(str,int)之一的子類True反射操作>>>s

=

Student("Aim")>>>

hasattr(s,

"name")#創(chuàng)建類Student的實例，以查看是否有某屬性#s含有name屬性>>>

hasattr(s,

"age")#s不含有age屬性FalseTrue4.

hasattr(obj,

name,

/)檢查對象obj是否含有屬性name。>>>

classStudent:

#定義類Adef

init

(self,name):

=

name反射操作def

init

(self,name):

=

name>>>s=Student("Aim")#創(chuàng)建實例>>>getattr(s,"name")#屬性name的值>>>getattr(s,"age")

#不存在屬性age，未提供默認值，拋出異常Traceback(most

recent

call

last):File

"<pyshell#54>",

line

1,

in

<module>getattr(s,"age")

#不存在屬性age，未提供默認值，調用報錯AttributeError:"Student"object

has

no

attribute"age""Aim"5.

getattr(object,

name[,

default])獲取對象object的屬性name的值，如果不存在，則返回default值。>>>class

Student:#定義類Student6>>>getattr(s,"age",6)

#不存在屬性age，但提供了默認值，返回默認值反射操作#設置實例s的name屬性值>>>

setattr(s,

"name",

"Bob")>>>

"Bob"6.

setattr(obj,

name,

value,

/)將對象obj的屬性name的值設為value。>>>

classStudent:

#定義類Studentdef

init

(self,name):

=

name>>>s=Student("Kim")

#創(chuàng)建類實例s>>>

#獲得實例s的name屬性值"Kim"反射操作7.

delattr(obj,

name,

/)刪除對象obj的name屬性。>>>class

A:

#定義類Adef

init

(self,name):

=

name>>>

a

=A("Bob")>>>

"Bob">>>delattr(a,"name")

#刪除實例a的屬性name>>>

#訪問實例a的屬性name，出錯Traceback

(most

recent

call

last):File

"<pyshell#52>",

line

1,

in

<module>AttributeError:

"A"

object

has

no

attribute

"name"反射操作8.

callable(obj,

/)檢測類和對象obj是否可被調用（即檢測是否類或對象實例可以被直接調用，是否定義了

call

()函數(shù)）。>>>

class

B:

#定義類B:def

call

(self):print("instances

are

callable

now.")>>>callable(B)

#檢測類B是否是可調用的,類B是可調用對象True>>>b=B()

#調用類B>>>callable(b)

#檢測實例b是否是可調用的,實例b是可調用對象True>>>b()

#調用實例b,成功instances

are

callable

now.變量操作1.

globals()返回當前作用域內的全局變量與該變量的值組成的字典。>>>

globals(){"

spec

":

None,

"

package

":

None,

"

builtins

":

<module

"builtins"

(built-in)>,"

name

":

"

main

",

"

doc

":

None,

"

loader

":

<class"_frozen_importlib.BuiltinImporter">}>>>

a

=

1>>>globals()

#多了一個a{"

spec

":

None,

"

package

":

None,

"

builtins

":

<module

"builtins"

(built-in)>,"a":

1,

"

name

":

"

main

",

"

doc

":

None,

"

loader

":

<class"_frozen_importlib.BuiltinImporter">}變量操作2.

locals()返回當前作用域內的局部變量與該變量的值組成的字典。>>>

def

f():a

=

1print("after

define

a")print(locals())

#作用域內有一個a變量，值為1>>>

f()after

define

a{"a":

1}交互操作1.

print()標準輸出，輸出一個變量或對象的內容。函數(shù)原型為：print(value,

…,

sep="

",

end="\n",

file=sys.stdout,

flush=False)參數(shù)value為所輸出的變量或對象，可以有多個；參數(shù)sep指定多項輸出間的間隔；參數(shù)end為輸出內容的末尾的控制符，默認為換行，如果不使輸出內容換行，可以令end=""。>>>#例如，輸出內容之間用"+"分隔（連接）：>>>

print(1,

2,

3,

sep="+",

end="=?")1+2+3=?交互操作>>>

s"Ain"2.

input(prompt=None,

/)標準鍵盤輸入，提示內容由參數(shù)prompt指定，讀入為字符串。>>>

s

=

input("please

input

your

name:

")please

input

your

name:

Ain文件操作>>>

a.close()1.

open()使用指定的模式和編碼打開文件，返回文件讀寫對象。詳細內容見第4.2.3節(jié)（第124頁）的介紹。>>>a=open("test.txt","rt") #t為文本讀寫，b為二進制讀寫>>>

a.read()"some

text"文件操作fd

=

open("test.txt","rt")lns

=

fd.readlines()for

ln

in

lns:print(ln)2.

readlines()從文件中讀入各行。詳細內容見第4.2節(jié)的介紹。編譯執(zhí)行>>>

code

=

"for

i

in

range(0,10):

print(i,end="

")">>>

compile

=

compile(code,

"",

"exec")>>>

exec(compile)0

1

2

3

4

5

6

7

8

91.

compile(source,

filename,

mode,

flags=0,

……)將字符串編譯為代碼或者AST對象，使之能夠通過exec語句來執(zhí)行或者eval進行求值。編譯執(zhí)行>>>

compile

=

compile(code,

"",

"eval")>>>

eval(compile)102.

eval(source,

globals=None,

locals=None,

/)執(zhí)行動態(tài)表達式source求值，計算該字符串中的有效Python表達式，并返回結果。>>>

code

=

"1

+

2

+

3

+

4">>>

eval(code)10編譯執(zhí)行>>>exec("a=1+2;print(a)")#執(zhí)行語句33.

exec(source,

globals=None,

locals=None,

/)執(zhí)行動態(tài)語句塊source。編譯執(zhí)行4.

repr(obj,

/)將對象轉換為可打印字符串，即返回一個對象的字符串表現(xiàn)形式（給解釋器），返回轉換完成后的字符串。參數(shù)obj是待轉換的對象。>>>

a

=

"some

text">>>

a"some

text">>>

repr(a)""some

text""主要是作用是把類中的一個方法變?yōu)轭愔械囊粋€屬性，使定義屬性、讀取屬性值和設置屬性值更加容易。>>>class

C:

#定義一個類def

init

(self):self._name

=

""@property

#將name()裝飾為屬性def

name(self):return

self._name@name.setterdef

name(self,

value):self._name

=

value>>>

c

=

C()>>>="abc"

#將name作為屬性使用>>>

"abc"屬性裝飾器@property裝飾器類方法裝飾器@classmethod可以不需實例化類，就可以直接使用類名.方法名()的方法來調用經(jīng)裝飾器裝飾的函數(shù)。這樣可以將屬于某個類的函數(shù)，放到該類的命名中去，有利于組織代碼，保持命名空間的整潔。#定義一個類>>>

class

A(object):bar

=

1def

foo(self):print

("foo")@classmethod

#將func()裝飾為類方法def

func(cls):print

("func")print(cls.bar)cls().foo()#調用foo方法>>>A.func()#不需要實例化類A，可以直接調用類函數(shù)，其中還可以使用類變量func1foo類方法裝飾器@classmethod裝飾器靜態(tài)方法裝飾器@staticmethod可以將函數(shù)標示為靜態(tài)函數(shù)，可以不需實例化類，就可以直接使用類名.方法名()的方法來調用經(jīng)裝飾器裝飾的函數(shù)。與@classmethod的區(qū)別在于，

@classmethod標示的函數(shù)，必須帶有表示自身的cls參數(shù)，而@staticmethod則不必，就如

同定義和使用一個普通函數(shù)。class

A(object):

#定義一個類def

init

(self,

name):

=

name@staticmethod

#將print_out()裝飾為靜態(tài)方法def

print_out(param):print(param)A.print_out("Hello

World!")#不實例化類A，以靜態(tài)方法調用print_out()a=A("Tom")a.print_out("calling

from

instance!")靜態(tài)方法裝飾器@statisticmethod裝飾器2.8

自定義函數(shù)在Python語言中，除了提供豐富的系統(tǒng)函數(shù)外，還允許用戶創(chuàng)建和使用自定義函數(shù)。函數(shù)（function）由若干條語句組成，用于實現(xiàn)特定的功能。函數(shù)包含函數(shù)名、若干參數(shù)和返回值。使用函數(shù)，便于共享代碼，減少重復編碼，提高開發(fā)效率，同時使代碼的結構變得更為簡潔清晰，可讀性好。在完成較為龐雜的編程任務時，將任務分解成較小的、功能相對獨立、單一的模塊，即函數(shù)，可使編程工作更加容易把握。函數(shù)設計

函數(shù)（function）由若干條語句組成，用于實現(xiàn)特定的功能。函數(shù)包含函數(shù)名、若干參數(shù)和返回值。

一旦定義了函數(shù)，就可以在程序中需要實現(xiàn)該功能的位置調用該函數(shù)，給程序員共享代碼帶來了很大方便。

在Python語言中，除了提供豐富的系統(tǒng)函數(shù)外，還允許用戶創(chuàng)建和使用自定義函數(shù)。聲明函數(shù)def

function_name(parameter1[=default

value],

parameter2[=default

value],…):function

bodyreturn

value1,

value2,

…def為聲明函數(shù)的關鍵字，function_name為所定義的函數(shù)名，其隨后的()內的內容為定義函數(shù)時所給定的參數(shù)，稱為形式參數(shù)。在定義形式參數(shù)時，還可以為其指定默認值，成為默認參數(shù)值。聲明函數(shù)聲明可以使用def關鍵字來創(chuàng)建Python自定義函數(shù)，其基本語法結構如下：def函數(shù)名(參數(shù)列表):函數(shù)體參數(shù)列表可以為空，即沒有參數(shù)可以包含多個參數(shù)，參數(shù)之間使用逗號（,）分隔函數(shù)體由一組語句組成【例】創(chuàng)建一個非常簡單的函數(shù)PrintWelcome，它的功能是打印字符串“歡迎使用Python”，代碼如下：def

PrintWelcome():print("歡迎使用Python")聲明函數(shù)聲明在函數(shù)體中，參數(shù)可以像其他變量一樣被使用?！纠慷x函數(shù)PrintString()，通過參數(shù)決定要打印的內容。def

PrintString(str):print(str)變量str是函數(shù)的參數(shù)。聲明函數(shù)聲明可以在函數(shù)中定義多個參數(shù)，參數(shù)之間使用逗號分隔。【例】定義一個函數(shù)sum()，用于計算并打印兩個參數(shù)之和。函數(shù)sum()包含兩個參數(shù)。參數(shù)num1和num2，代碼如下：def

sum(num1,

num2):print(num1

+

num2)調用函數(shù)函數(shù)調用時，要為函數(shù)設置與形式參數(shù)所對應的參數(shù)，稱為實際參數(shù)。函數(shù)調用時的參數(shù)傳遞的關系如圖2

5所示。如果調用時不指定某參數(shù)項，則函數(shù)的形式參數(shù)會使用函數(shù)定義時指定的默認參數(shù)值，即缺省參數(shù)。這里給出了結果返回的形式和調用函數(shù)后接收返回值的關系和方式。例如，函數(shù)返回多項返回值，而調用時用單個變量進行接收（如圖中所示的變量ret），則會將多個返回值組織為元組；如果用與多項返回值個數(shù)相配的多個變量進行接收（如圖中的變量

s,a），則會分別接收返回值。參數(shù)和返回值按值傳遞

調用函數(shù)時將常量或變量的值（實參）傳遞給函數(shù)的參數(shù)（形參）。

實參與形參分別存儲在各自的內存空間中，是兩個不相關的獨立變量。在函數(shù)內部改變形參的值時，實參的值一般是不會改變的?！纠吭诤瘮?shù)中按值傳遞參數(shù)def

func(num):num

+=

1a

=

10func(a)print(a)結果：before

calling

func(),

a=

10after

calling

func(),

a=

10自定義函數(shù)自定義函數(shù)參數(shù)和返回值按值傳遞【例】在函數(shù)中按值傳遞參數(shù)def

func(num):print("形參地址：",id(num))num+=1a

=

10print("before

calling

func(),a=",a)print("實參地址：",id(a))func(a)print("after

calling

func(),

a=",a)結果：before

calling

func(),a=10實參地址：1476252864形參地址：1476252864after

calling

func(),a=10自定義函數(shù)參數(shù)和返回值用列表和字典傳遞參數(shù)按值傳遞【例】用列表作為函數(shù)參數(shù)def

sum(list):total

=

0for

x

in

range(len(list)):print(list[x],"+",end="")total+=list[x]print("=",

total)list

=

[15,

25,

35,

65]sum(list)結果：15

+25

+35

+65

+=

140自定義函數(shù)4.參數(shù)和返回值【例】用列表作為函數(shù)參數(shù)def

print_dict(dict):for

(k,

v)

in

dict.items():print("dict[%s]

="

%

k,

v)dict

=

{"a"

:

"apple","b"

:

"banana","g"

:

"grape","o":"orange"}print_dict(dict)結果：dict[a]

=

appledict[b]

=

bananadict[g]

=

grapedict[o]

=

orange自定義函數(shù)參數(shù)和返回值在函數(shù)中修改列表參數(shù)【例】用列表作為函數(shù)參數(shù)def

swap(list):list[0],list[1]

=

list[1],list[0]list

=

[1,2]print("before,

list=",list)swap(list)print("after,list=",list)結果：before,

list=

[1,

2]after,

list=

[2,

1]自定義函數(shù)參數(shù)和返回值在函數(shù)中修改字典【例】用字典作為函數(shù)參數(shù)def

changeA(dict):dict["a"]

=

22d

=

{"a":

10,

"b":

20,

"c":

30}print("before

change:",d)changeA(d)print("afterchange:",d)結果：beforechange:

{"a":

10,

"b":

20,

"c":

30}after

change:

{"a":

22,

"b":

20,

"c":

30}自定義函數(shù)參數(shù)和返回值函數(shù)參數(shù)中的默認值

在Python中，可以為函數(shù)的參數(shù)設置默認值?？梢栽诙x函數(shù)時，直接在參數(shù)后面使用“=”為其設置默認值。在調用函數(shù)時可以不指定擁有默認值的參數(shù)的值，此時在函數(shù)體中以默認值作為