Python語言編程基礎(chǔ)(上)

Python語言編程基礎(chǔ)

張瑞內(nèi)容目錄1.Python簡介2.Python基本語法3.函數(shù)和函數(shù)式編程4.類和面向?qū)ο缶幊蘌ython簡介Python2和3Python安裝編譯器1.Python簡介1.Python簡介-起源是一種面向?qū)ο蟮慕忉屝陀嬎銠C程序設(shè)計語言，由荷蘭人GuidovanRossum于1989年發(fā)明，第一個公開發(fā)行版發(fā)行于1991年。（來自百度百科1989年，為了打發(fā)圣誕節(jié)假期，Guido開始寫Python語言的編譯/解釋器。Python來自Guido所摯愛的電視劇MontyPython'sFlyingCircus1.Python簡介-語言類型Python是一種解釋型、可移植、開源的腳本編程語言編譯型語言：在程序執(zhí)行之前，有一個單獨的編譯過程，將程序翻譯成機器語言，以后執(zhí)行這個程序的時候，就不用再進(jìn)行翻譯了。例如C、C++解釋型語言：在運行的時候?qū)⒊绦蚍g成機器語言，所以運行速度相對于編譯型語言要慢；例如Perl、Python、MATLAB等；源代碼編譯目標(biāo)代碼執(zhí)行輸出源代碼解釋器輸出1.Python簡介-特點特點高級：高級語言（開發(fā)效率高）面向?qū)ο罂缮壙蓴U展可移植1.Python簡介-特點優(yōu)點（1）易讀：Python語句比較符合人類閱讀習(xí)慣，具有偽代碼本質(zhì)；（2）易學(xué)：python雖然是用c語言寫的，但是它擯棄了c中非常復(fù)雜的指針，簡化了python的語法；（3）開源：可以閱讀它的源代碼、對它做改動、用于新軟件中等；（4）可移植性：由于它的開源本質(zhì)，Python已經(jīng)被移植在許多平臺上；（5）Python既支持面向過程的函數(shù)編程也支持面向?qū)ο蟮某橄缶幊?。?）可擴展性和可嵌入性：你可以把你的部分程序用C或C++編寫，然后在你的Python程序中使用它們。你可以把Python嵌入你的C/C++程序，從而向你的程序用戶提供腳本功能。（7）豐富的庫：包括正則表達(dá)式、文檔操作、數(shù)據(jù)庫等等；1.Python簡介-特點缺點：（1）強制縮進(jìn)：Python設(shè)計時受C和ABC語言的影響，強制縮進(jìn)來源于ABC語言；（2）運行速度：運行速度慢，C程序運行1秒鐘，Java程序可能需要2秒，而Python程序可能就需要10秒。（3）python的開源性使其不能加密；1.Python簡介-用途網(wǎng)站后端程序員：使用Python搭建網(wǎng)站、后臺服務(wù)會比較容易維護(hù)。有不少知名網(wǎng)站都使用了Python開發(fā)，如：知乎、豆瓣、Youtube自動化運維游戲開發(fā)自動化測試：對于測試來說，要掌握Script的特性，會在設(shè)計腳本中，有更好的效果。Python是目前比較流行的Script。網(wǎng)頁爬蟲：當(dāng)你需要獲取大批量數(shù)據(jù)或者批量處理的時候，Python爬蟲可以快速做到這些，從而節(jié)省你的重復(fù)勞動時間。2.Python2和3的區(qū)別（1）Python3中去除print語句，加入print()函數(shù)實現(xiàn)相同的功能和新功能；作用python2（print語句）python3（print函數(shù)）輸出空行printprint()輸出一個值print’abc’print(’abc’)#輸出abc使用空格分割輸出的兩個值print’abc’,’123’print(’abc’,’123’)#輸出abc123重定向print>>file,strprint(str,file)句尾加符號Print’abc’,’…’print(’abc’,end=’…’)2.Python2和3的區(qū)別（2）py2默認(rèn)ASCII編碼，py3默認(rèn)采用了unicode作為默認(rèn)編碼。ASCII編碼最早只有127個字母被編碼到計算機里，也就是大小寫英文字母、數(shù)字和一些符號，這個編碼表被稱為ASCII編碼中文GB2312編碼日文shift_JIS……處理中文一個字節(jié)不夠，要處理中文至少需要兩個字節(jié)，而且還不能和ASCII編碼沖突，中國制定了GB2312編碼，而其他語言也有自己一套編碼，多語言混合時有亂碼問題unicode編碼Unicode通常為兩個字節(jié)編碼（如果要用到非常偏僻的字符需要4個字節(jié)），它把所有語言都統(tǒng)一到一套編碼里，避免亂碼問題。utf-8編碼UTF-8編碼把一個Unicode字符根據(jù)字符的不同編碼成1-6個字節(jié)，英文通常為1個字節(jié)，漢字為3個字節(jié)；若源代碼中包含中文，一般在代碼頭部指定為utf-8編碼（下列方式任選一種都可以）：2.Python2和3的區(qū)別（3）其他：a=3b=4print(a/b,type(a/b))print(a//b,type(a//b))輸出：0.75<class'float'>0<class'int'>改變了除法規(guī)則捕獲異常pythonExceptionase和Exception,e捕獲一個異常對象ase是python2.5之后的方案3.Python的安裝-版本選擇（1）選擇py2還是py3？Python的兩個版本版本是不兼容的，所以許多py2.x版本的代碼要修改后才能在py3.x上運行，所以，目前有許多第三方庫還暫時無法在3.x上使用。在我看來，語言的更新速度更快，沒有必要停留在過去不向前看，所以我選擇了更多新特性的Python3.x（2）如何安裝py3.7？windows版本安裝：3.Python的安裝-windows版本（1）登入下載網(wǎng)址/（2）運行下載的MSI安裝包，在選擇安裝組件的一步時，勾上所有的組件；（3）檢查是否安裝成功：打開cmd，輸入python若安裝成功，則出現(xiàn)下圖若出現(xiàn)下圖，則表示安裝失敗，需手動設(shè)置環(huán)境變量出現(xiàn)原因和解決辦法：在安裝時漏掉了勾選Addpython.exetoPath，那就要手動把python.exe所在的路徑添加到Path中。3.Python的安裝-linux版本（1）打開虛擬機安裝特定版本的Python，在終端輸入：sudoapt-getinstallpython3.74.編譯器推薦使用IDE工具推薦使用公認(rèn)最智能好用的PythonIDE，Pycharm，支持windows和mac用戶下載鏈接：/pycharm/，選擇社區(qū)版免費的，專業(yè)版付費的。官網(wǎng)快速上手的中文視頻：/pycharm/documentation/輸入和輸出語句與語法基本數(shù)據(jù)類型控制流上下文管理器2.Python基本語法1.輸入和輸出（1）輸出：print()函數(shù)>>>print("HelloWorld")HelloWorld>>>print('HelloWorld')HelloWorld>>>print("Hello'World'")Hello'World'>>>print('Hello"World"')Hello"World"print(str1)print(str1,str2)#print()遇到逗號輸出一個空格>>>print("zhang","rui")zhangruiprint()數(shù)字或算數(shù)表達(dá)式的結(jié)果>>>print(3.14)3.14>>>print(4+2*3)10print()重定向>>>fw=open("1.txt","w")>>>print("123",file=fw)>>>fw.close()>>>print(open("1.txt").read())1231.輸入和輸出print(str1)>>>print("mynameis%s"%"zhangrui")mynameiszhangrui>>>print("myageis%d"%25)myageis251.輸入和輸出formatpython2.6開始，新增了一種格式化字符串的函數(shù)str.format()key和value的形式下標(biāo)形式居中右對齊填充>>>"{},{}".format("python","test")'python,test'>>>"{name},{value},{name}".format(name="python",value=2.7)'python,2.7,python'>>>alist=["python","2.7"]>>>"{0[0]},{0[1]},{0[0]}".format(alist)'python,2.7,python'>>>"{:^10}".format("123")'123'>>>"{:>10}".format("123")'123'>>>"{:x<10}".format("123")'123xxxxxxx'1.輸入和輸出（1）輸入：input()函數(shù)>>>input("pleaseinputyourname:")pleaseinputyourname:zhangrui'zhangrui'>>>b=input()123>>>b’123’input()：數(shù)值raw_input()：字符串input()：字符串python2python32.語句與語法（1）注釋與縮進(jìn)python2當(dāng)語句以冒號結(jié)尾時，縮進(jìn)的語句為代碼塊；縮進(jìn)可用空格或Tab，但不可混用，一般約定使用4個空格的縮進(jìn)；（使用編輯器時可以進(jìn)行設(shè)置）注意：復(fù)制粘貼python代碼時，可能因為縮進(jìn)問題運行報錯；python代碼區(qū)分大小寫；2.語句與語法（2）繼續(xù)和分隔python2一行寫不下分多行：可以使用反斜杠\或者()進(jìn)行續(xù)寫>>>b='abcd'\ '1234'>>>print(b)abcd1234>>>c=("1234" "5678")

>>>print(c)

12345678>>>d=str(c)\ +b

>>>print(d)

12345678abcd12341.函數(shù)內(nèi)或同一代碼段中，空行行數(shù)1，空行規(guī)則以分隔不同功能和模塊為準(zhǔn)2.多個函數(shù)之間，空行行數(shù)13.類之間，空行行數(shù)2分隔3.基本數(shù)據(jù)類型（1）常量與變量python2常量：常量是一塊只讀的內(nèi)存區(qū)域，常量一旦被初始化就不能被改變。例如，字符串常量’changliang’;數(shù)字常量等等；變量:變量是計算機內(nèi)存中的一塊區(qū)域，變量可以存儲規(guī)定范圍內(nèi)的值，而且值可以改變；a=1 #整型變量b=“123” #字符串變量c=True #布爾值變量python中的數(shù)據(jù)類型不需要(顯示)的聲明，解釋器根據(jù)變量的賦值確定變量的類型；Python變量是無類型的，x=10，變量x是無類型的，相當(dāng)于指針，指向int數(shù)據(jù)類型的值python中，strings,tuples,和numbers是不可更改的對象，而list,dict等則是可以修改的對象3.基本數(shù)據(jù)類型（2）基本數(shù)據(jù)類型包括以下幾種python2整型(int):a=0浮點型(float):a=9.9字符串(str):a=’string’,a=”string”,a=’’’string’’’布爾值(Boolean):a=True,a=False列表(list):a=[1,2,3,4]字典(dict):a={intA:1,floatA:9.9,strA:”string”}元組(tuple):a=(1,2,3,4)集合(set):a=set([1,2,3])如何確定數(shù)據(jù)變量的類型？內(nèi)部type函數(shù)的使用3.基本數(shù)據(jù)類型-列表（1）列表(list)：一個有序的可變更的數(shù)據(jù)結(jié)構(gòu)python2

例如，a=[1,2,3,4]訪問列表中的元素：使用下標(biāo)索引:list[index] a[0] #第1個元素 a[3] #第4個元素 a[-1] #最后一個元素添加元素

：append(value):在列表末尾添加一個元素 a.append(5) #[1,2,3,4,5]insert(index,value):在指定位置插入一個元素 a.insert(1,5) #[1,5,2,3,4]修改元素:使用下標(biāo)索引直接賦值a[3]=0 #[1,2,3,0]刪除元素:remove(元素)刪除單個元素pop(位)按位刪除，根據(jù)索引刪除,返回被刪除的元素delstr[位]

、delstr[n:m]或delstr根據(jù)索引刪除；也可以刪除指定范圍內(nèi)的值（包頭不包尾）；刪除整個數(shù)據(jù)對象（列表、集合等）

a.remove(4)#[1,2,3]

a.pop(2)#[1,2,4]

dela[2] #[1,2,4]字符轉(zhuǎn)換：list1=["1",2,"3",4]list2=[str(i)foriinlist1]list3=''.join(list2)映射：list1=["1",2,"3"]list2=[li*2forliinlist1]3.基本數(shù)據(jù)類型-列表python2其他操作將list2的元素擴充到list1中l(wèi)ist1.extend(list2)列表反向list.reverse()列表排序list.sort()統(tǒng)計某個元素出現(xiàn)的個數(shù)list.count(obj)3.基本數(shù)據(jù)類型-列表python2列表的特點有序可重復(fù)可變內(nèi)存占用相對字典更小效率較低（遍歷）3.基本數(shù)據(jù)類型-列表python2若列表a=[1,2,3,4]，分別進(jìn)行下面的操作，（1）b=a（2）c=a[:]（3）d=a*1（4）importcopye=copy.copy(a)（5）f=[a]*1若此時a.append(5)，此時b、c、d、e、f分別是多少？問題思考：b=[1,2,3,4,5]#a、b和f指向同一個列表c=[1,2,3,4] #c.d.e都是對a的淺復(fù)制，對原來引用的對象進(jìn)行了復(fù)制，但是不再引用同一對象地址d=[1,2,3,4] 注：要熟悉掌握“引用、淺復(fù)制、深復(fù)制”概念！e=[1,2,3,4]f=[1,2,3,4,5]3.基本數(shù)據(jù)類型-列表python2問題思考：A[:2]:

[['Sunday''00:00:00''0''0''noevent']

['Sunday''00:30:00''1''0''noevent']]

A[:,2]:

['0''1''0'...'0''0''1']A=[['Sunday''00:00:00''0''0''noevent']

['Sunday''00:30:00''1''0''noevent']

['Sunday''01:00:00''0''0''noevent']

...

['Saturday''22:30:00''0''0''noevent']

['Saturday''23:00:00''0''0''noevent']

['Saturday''23:30:00''1''0''noevent']]print("A[:2]:",A[:2])print("A[:,2]:",A[:,2])

3.基本數(shù)據(jù)類型-字典（2）字典(dict)：一種使用映射關(guān)系的可變?nèi)萜髂Ｐ?，又稱關(guān)聯(lián)數(shù)組或哈希表python2字典的結(jié)構(gòu)為{鍵:值,….}，鍵不可重復(fù)，創(chuàng)建時如果同一個鍵被賦值兩次，后一個值會被記住；鍵必須不可變，所以可以用數(shù)，字符串或元組充當(dāng)，列表就不行a={k1:v1,k2:v2,k3:v3}訪問字典中的元素：使用key的名稱:dict[key] a[k2] #v2添加元素:直接添加新的keya[k4]=v4 #{k1:v1,k2:v2,k3:v3,k4:v4}修改元素:使用key的名稱直接賦值a[k1]=0 #{k1:0,k2:v2,k3:v3}刪除元素:使用del和pop刪除指定鍵的元素 dela[k3] #{k1:0,k2:v2} a.pop(k2) #{k1:0,k3:v3}其他操作字典合并dict1.update(dict2)字典排序sorted(dict.items(),key=lambdae:e[0],reverse=True)#按鍵排序，倒序sorted(dict.items(),key=lambdae:e[1],reverse=True)#按值排序，倒序3.基本數(shù)據(jù)類型-字典python2字典的特點無序不可重復(fù)不可變內(nèi)存占用較大效率高（hash）3.基本數(shù)據(jù)類型-字典與列表之間的轉(zhuǎn)換python2dit={'name':'zxf','age':'22','gender':'male','address':'shanghai'}

#將字典的key轉(zhuǎn)換成列表

lst=list(dit.keys())

print(lst)#['name','age','gender','address']

#將字典的value轉(zhuǎn)換成列表

lst2=list(dit.values())

print(lst2)#['zxf','22','male','shanghai']

#將字典的key和value轉(zhuǎn)成列表

lis3=list(dit.items())

print(lis3)字典可以直接使用list轉(zhuǎn)換成列表3.基本數(shù)據(jù)類型-字典與列表之間的轉(zhuǎn)換python2使用zip()函數(shù)：將a和b兩個列表內(nèi)的元素兩兩組合成鍵值對。當(dāng)兩個列表的長度不一致時，多出的元素在另一個列表無匹配的元素時就不展示多出的元素。使用嵌套列表轉(zhuǎn)換為字典：a和b列表內(nèi)只能有兩個元素，將列表內(nèi)的元素自行組合成鍵值對a=['a1','a2','a3','a4']

b=['b1','b2','b3']

d=zip(a,b)

print(dict(d))#{'a1':'b1','a2':'b2','a3':'b3'}#a=['a','b']

#b=['1','2']

#c=[a,b]

#print(dict(c))#{'a':'b','1':'2'}相當(dāng)于遍歷子列表

#

#print("遍歷：")

#dit={}

#foriinc:

#dit[i[0]]=i[1]

#print(dit)3.基本數(shù)據(jù)類型-元組python2元組(tuple)：一個有序的不變更的數(shù)據(jù)結(jié)構(gòu)元組和列表十分相似，不同之處為元組在初始化之后就不能被修改了

a=(1,2,3,4) a=tuple(1,2,3,4) a=1,2,3,4訪問元素：使用下標(biāo)索引:tuple[index] a[0] #1 a[3] #4

3.基本數(shù)據(jù)類型-元組python2程序輸出3.基本數(shù)據(jù)類型-集合python2集合(set):由不同元素構(gòu)成的無序的數(shù)據(jù)集合，集合分為可變集合和不可變集合創(chuàng)建集合 a=set('1234ac') #可變集合

b=frozenset(['1','3','a','b','c','d']) #不可變集合訪問元素:由于是無序的遍歷或使用in和notin

foriina:

print(i)

添加元素:

使用add()方法

a.add(‘56’) #

set(['a','c','1','3','2','56','4'])使用update()方法

a.update(‘xX’) #

set(['a','c','1','3','2','4','X','x'])刪除元素:使用remove()方法 a.remove(‘1’) #set(['a','c','3','2','4'])其他操作聯(lián)合兩個集合s=a.union(b) #set(['a','c','b','d','1','3','2','4'])交集s=ersection(b) #set(['a','1','c','3'])差集s=a.difference(b) #set(['2','4'])對稱差集s=a.symmetric_difference(b) #set(['b','d','2','4'])3.基本數(shù)據(jù)類型-判斷數(shù)據(jù)類型python2判斷數(shù)據(jù)類型：type(object),isinstance(object,class_or_type_or_tuple):type(object):參數(shù)說明：(對象名稱),返回值：對象類型(非字符串) a=1 print(type(a))

----------------->>

<type'int'>isinstance(object,class_or_type_or_tuple):參數(shù)說明：(對象名稱,類型),返回值：True/False

a=1 print(isinstance(a,int))

----------------->>

Truetype和isinstance的異同：type返回對象類型(未知)，而isinstance判斷對象是否等于某個類型(已知)isinstance的效率略高于type(毫秒級)3.基本數(shù)據(jù)類型-數(shù)據(jù)類型轉(zhuǎn)換python2類型轉(zhuǎn)換：數(shù)字轉(zhuǎn)數(shù)字:整型轉(zhuǎn)浮點型float()，浮點型轉(zhuǎn)整型int() a=1 b=2.2 print(float(a)) #----------------->>1.0 print(int(b)) #----------------->>

2字符串轉(zhuǎn)數(shù)字:int()/float() a="1" print(int(a)) #----------------->>1 print(float(a)) #----------------->>

1.0數(shù)字轉(zhuǎn)字符串:str()

a=1.0

print(str(a))

#----------------->>‘1’4.控制流python2熟練掌握控制流的應(yīng)用是python編程的基礎(chǔ)Python的控制流包括：條件語句，循環(huán)，遍歷，嵌套，異常處理，上下文管理器等等4.控制流-條件語句python2（1）條件語句if表達(dá)式:

elif表達(dá)式:else:a=0ifa==None: print(None)elifa==0: print(True)else: print(False)輸出結(jié)果為：True*注：python中沒有switch/case語句4.控制流-遍歷python2（2）遍歷

遍歷的語法格式為:for變量in迭代器/列表/字典/…:deftra_while(string):

index=0

whileindex<len(string):

print(string[index])

index+=1name=“python”tra(name)輸出結(jié)果：pythondeftra_for(string): forcharinstring:

print(char)4.控制流-循環(huán)python2（3）循環(huán)

循環(huán)的語法格式為:while表達(dá)式:i=0whilei<10: print(i) i+=1這里定義了一個int變量i,初始值為0當(dāng)i<10時，繼續(xù)循環(huán)，當(dāng)i>=10時，退出循環(huán)最終結(jié)果為:0123456789 4.控制流-嵌套python2（4）嵌套

包括循環(huán)的嵌套，函數(shù)的嵌套foriinrange(10): forjinrange(5): print(i+j)結(jié)果為：012341234523456345674567856789678910789101189101112910111213循環(huán)嵌套函數(shù)嵌套defnest(i,j): ifi+j<100: print(i+j) nest(i+j,j+i)nest(2,3)結(jié)果為：5102040804.控制流-pass,continue,breakpython2（5）pass表示,繼續(xù)執(zhí)行，不做任何操作；continue表示，跳過本次循環(huán)，進(jìn)入下一次循環(huán)；break表示,退出循環(huán)i=0while1: ifi==0: pass ifi==2:

i+=1 continue ifi==10: break print(i) i+=1輸出結(jié)果為:013456789*注：使用continue操作時，需注意continue會跳過之后的所有語句，因此一些影響程序邏輯的語句需要放到continue之前執(zhí)行5.上下文管理器python2上下文管理器（ContextManager）：可以通過上下文管理器來定義/控制代碼塊執(zhí)行前的準(zhǔn)備動作，以及執(zhí)行后的收尾動作__enter__和__exit__with語句：在代碼運行前執(zhí)行__enter__，在代碼執(zhí)行后執(zhí)行__exit__具有內(nèi)置方法__enter__和__exit__的類型，比如file#fw=open("123.txt","w")#fw.write("123")#fw.close()withopen("123.txt","w")asfw:fw.write("123")5.上下文管理器python2自定義類型的上下文classTest:def__init__(self,num):self.num=numdef__enter__(self):self.num+=1print("_enter_:%s"%self.num)returnself.numdef__exit__(self,*param):#會話管理器在代碼塊執(zhí)行完成好后調(diào)用（不同于__del__）(必須是4個參數(shù))self.num*=2print("_exit_:%s"%self.num)withTest(2)asb:print(b)運行結(jié)果：_enter_:33_exit_:6函數(shù)函數(shù)式編程3.函數(shù)和函數(shù)式編程1.函數(shù)python2定義：函數(shù)是指一段在一起的、可以做某一件事兒的程序。也叫做子程序、方法。函數(shù)是組織好的，可重復(fù)使用的，用來實現(xiàn)單一，或相關(guān)聯(lián)功能的代碼段用關(guān)鍵字def開頭，

后面接‘函數(shù)名稱’及用()括起來的’函數(shù)參數(shù)’，最后以:結(jié)尾用關(guān)鍵字return，表示函數(shù)結(jié)束并返回一個或多個數(shù)據(jù)，沒有return則默認(rèn)返回None作用：合理的使用函數(shù)，可以提高代碼的運行效率，可讀性及復(fù)用率分類：內(nèi)置函數(shù)、自定義函數(shù)1.函數(shù)python2調(diào)用：直接使用函數(shù)名生成函數(shù)實例來調(diào)用函數(shù)的參數(shù)：形參：函數(shù)定義時定義的參數(shù)實參：函數(shù)調(diào)用時傳入的參數(shù)deffunction_test(): return"thisistestfunction"printfunction_test()輸出結(jié)果：thisistestfunction1.函數(shù)python2函數(shù)參數(shù)傳遞：

可變類型，則類似c++的引用，如list、dict。如fun（la），則是將la真正的傳過去，修改后fun外部的la也會受影響

不可變類型，則類似c++的值傳遞，如int。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在fun（a）內(nèi)部修改a的值，只是修改另一個復(fù)制的對象，不會影響a本身參數(shù)類型：普通參數(shù)(必填參數(shù))：函數(shù)定義時的普通參數(shù)，這種參數(shù)必須傳值，且順序固定缺省參數(shù)：函數(shù)定義時進(jìn)行了賦值的參數(shù)。這種參數(shù)在調(diào)用時可以傳入實參也可以不傳，但缺省參數(shù)必須寫在所有普通參數(shù)的后面。格式如：param1=‘value’不定長參數(shù)：可以存放若干個參數(shù)的參數(shù)(建議使用元組和列表代替此種參數(shù)，增加程序可讀性)。不定長參數(shù)(元組參數(shù))：用*在參數(shù)名之前表示，格式如：*argv關(guān)鍵字參數(shù)(字典參數(shù))：用**在參數(shù)名之前表示，格式如：**argvs(不定長參數(shù)和缺省參數(shù)不可共存)1.函數(shù)python2普通參數(shù)實例：deffunc(a,b):print('a=%d,b=%d'%(a,b))func(10,20)#不使用參數(shù)名，需要按參數(shù)順序傳遞func(a=10,b=20)#使用參數(shù)名可以不按順序傳遞func(b=20,a=10)#結(jié)果：a=10,b=20a=10,b=20a=10,b=201.函數(shù)python2缺省參數(shù)實例：deffunction_test2(paramNormal,paramDefault="default"): print"paramNormal:%s"%paramNormal print"paramDefault:%s"%paramDefaultfunction_test2("normal")輸出結(jié)果：paramNormal:normalparamDefault:default1.函數(shù)python2元組參數(shù)實例：deffunc(*args):#這種定義會把傳遞的參數(shù)包成元組

print(args,type(args))func(10,20)#結(jié)果：#(10,20)<class'tuple'>deffunc(a,b):

print('a=%d,b=%d'%(a,b))a=(10,20)func(*a)#在調(diào)用函數(shù)使用`*`則會把元組解包成單個變量按順序傳入函數(shù)#結(jié)果：a=10,b=20總結(jié)：*號在定義函數(shù)參數(shù)時，傳入函數(shù)的參數(shù)會轉(zhuǎn)換成元組，如果

*號在調(diào)用時則會把元組解包成單個元素1.函數(shù)python2關(guān)鍵字字典參數(shù)實例：deffunc(**kw):#使用**定義參數(shù)會把傳入?yún)?shù)包裝成字典dictprint(kw,type(kw))func(a=10,b=20)#這種函數(shù)在使用時必須指定參數(shù)值，使用key=value這種形式#結(jié)果：{'b':20,'a':10}<class'dict'>deffunc(a,b):print('a=%d,b=%d'%(a,b))d={'a':10,'b':20}func(**d)#在調(diào)用時使用**會把字典解包成變量傳入函數(shù)?？偨Y(jié)：**號在定義函數(shù)參數(shù)時，傳入函數(shù)的參數(shù)會轉(zhuǎn)換成字典，如果

**號在調(diào)用時則會把字典解包成單個元素1.函數(shù)python2lambda表達(dá)式在python中某些簡單的函數(shù)可以用lambda表達(dá)式來表示lambda

[arg1[,arg2,.....argn]]:expression例如：等價于靈活使用lambda表達(dá)式可以使代碼更加簡潔func_sum=lambdax,y:x+yprint(func_sum(1,2))deffunc_sum(x,y): returnx+yprint(func_sum(1,2))1.函數(shù)python2變量的作用域全局變量：定義在函數(shù)或類外部的變量，作用域為整個程序生命周期局部變量：定義在函數(shù)或類內(nèi)部的變量，作用域為函數(shù)/類生命周期gNum=100defsum_num(): num=10 print("localvariable:",num) print("globalvariable:",gNum)sum_num()輸出結(jié)果：localvariable:10globalvariable:100num=3defsum_num(): num=4 print("numinsum_num:",num)sum_num()print("num:",num)輸出結(jié)果：numinsum_num:4num:3#當(dāng)全局變量在函數(shù)內(nèi)部再次被定義時，該變量在函數(shù)中作為局部變量使用1.函數(shù)python2global關(guān)鍵字python中的global關(guān)鍵字并不是用來聲明全局變量的，而是用來修改全局變量的值;

global是對整個環(huán)境下的變量起作用，而不是對函數(shù)類的變量起作用x=0defouter():x=1definner():

globalxx=2print("inner:",x)inner()print("outer:",x)outer()print("global:",x)#inner:2#outer:1#global:21.函數(shù)python2nonlocal關(guān)鍵字函數(shù)里面再嵌套了一個函數(shù)。當(dāng)使用nonlocal時，就聲明了該變量不只在嵌套函數(shù)inner（）里面才有效，而是在整個大函數(shù)里面都有效，對全局變量無效注：nonlocal它只是作用于嵌套作用域，而且只是作用在函數(shù)里面；在Python2.x中，閉包只能讀外部函數(shù)的變量，而不能改寫它，nonlocal關(guān)鍵字Python3.x才引入#inner:2#outer:2

#global:0x=0defouter():x=1definner():nonlocalxx=2print("inner:",x)inner()print("outer:",x)outer()print("global:",x)1.函數(shù)python2私有函數(shù)以兩個下劃線開頭的函數(shù)為私有函數(shù)，例如def__init__(self):私有函數(shù)的作用域py文件中的私有函數(shù)，作用域為整個py文件，但無法被其他py文件引用class中的私有函數(shù)，作用域為整個類，無法被class以外的成員調(diào)用右側(cè)的代碼為class私有函數(shù)的例子：從代碼可以看出，調(diào)用Sum類的普通成員函數(shù)sum_func()，成功返回計算結(jié)果3。調(diào)用Sum類的私有成員函數(shù)__private_func()，返回錯誤“Suminstancehasnoattribute'__private_func'”classSum:def__init__(self):passdefsum_func(self,num1,num2):returnself.__private_func(num1,num2)def__private_func(self,num1,num2):returnnum1+num2SUM=Sum()print("SUM.sum_func:%s"%SUM.sum_func(1,2))try:print("SUM.sum_func:%s"%SUM.__private_func(1,2))exceptExceptionase:print(e)1.函數(shù)python2函數(shù)的嵌套函數(shù)的嵌套就是在函數(shù)中定義其他函數(shù)內(nèi)層函數(shù)可以訪問外部函數(shù)的變量，但不能賦值可以使用nonlocal關(guān)鍵字對外部變量進(jìn)行賦值1.函數(shù)pyth1534320684.8018491inthetest11534320687輸出.8020205on2高階函數(shù)把一個函數(shù)名做為實參傳遞給另一個函數(shù)

importtimedefdeco(func):start_time=time.time()print(start_time)func()stop_time=time.time()print(stop_time)print('thefunctionruntimeis%s'%(stop_time-start_time))deftest1():time.sleep(3)print('inthetest1')deco(test1)輸出1534321241.7507045inthetest11534321244.7518764thefunctionruntimeis3.0011718273162841.函數(shù)python2遞歸遞歸就是在函數(shù)內(nèi)部調(diào)用函數(shù)自身defrec(sun):ifsun>=10:returnelse:print(sun)sun+=1rec(sun)rec(1)注意：在寫遞歸的時候一定要設(shè)置好退出條件，否則程序會陷入死循環(huán)1.函數(shù)python2裝飾器Python中可以使用裝飾函數(shù)來在指定函數(shù)的前后附加特定的功能，比如函數(shù)執(zhí)行計時功能語法格式如下：

@timer

:裝飾器語法糖importtime#裝飾器timerdeftimer(func):defdeco():start_time=time.time()func()stop_time=time.time()print("thefunctionruntimeis%s"%(stop_time-start_time))returndeco@timer#在python里，用@+裝飾器函數(shù)名，放在被裝飾函數(shù)上面，實際等同于test1=timer(test1)deftest1():time.sleep(3)print("inthetest1")test1()1.函數(shù)python2內(nèi)置函數(shù)的調(diào)用

兩種調(diào)用方法 importsomemodule

fromsomemoduleimportfunction1,function2,... fromsomemoduleimport*一般說來，應(yīng)該避免使from..import而使用import語句，因為這樣可以使你的程序更加易讀，也可以避免名稱的沖突2.函數(shù)式編程python2定義函數(shù)式編程是種編程范式，它將電腦運算視為函數(shù)的計算。函數(shù)編程語言最重要的基礎(chǔ)是λ演算（lambdacalculus）。而且λ演算的函數(shù)可以接受函數(shù)當(dāng)作輸入（參數(shù)）和輸出（返回值）。特點代碼簡潔，開發(fā)效率高容易理解可維護(hù)性強可復(fù)用性強2.函數(shù)式編程python2#-*-coding:utf-8-*-importosimportsysprint(os.path.abspath(os.getcwd()))#-*-coding:utf-8-*-importosimportsysdefprint_cwd(): print(os.path.abspath(os.getcwd()))if__name__=="__main__": print_cwd()定義函數(shù)的原則在函數(shù)式編程中，除了導(dǎo)入語句，全局變量，注釋，盡量不要出現(xiàn)在函數(shù)之外的代碼2.函數(shù)式編程python2#-*-coding:utf-8-*-importosimportsysdefprint_cwd(): print(os.path.abspath(os.getcwd()))

defprint_sum(a,b): print(a+b)if__name__=="__main__": print_cwd() print_sum(1,2)定義函數(shù)的原則聚合一個函數(shù)中最好只包含一個功能或制作一件事2.函數(shù)式編程python2deffun1(num): returnnumdeffun2(num): returnnum*2deffun3(num): returnnum/2

if__name__=="__main__": printfun3(fun2(fun1(2)))定義函數(shù)的原則耦合參數(shù)輸入，return輸出(讓函數(shù)減少外部依賴，獨立運行)2.函數(shù)式編程python2if__name__==“__main__”:這句話是什么意思?__name__是一個內(nèi)置變量，作為一個標(biāo)識存在假設(shè)有一個test.py當(dāng)test.py文件作為主程序執(zhí)行時，__name__的值為__main__當(dāng)test.py文件作為一個模塊被引用時，__name__的值為test當(dāng)py作為主程序執(zhí)行時，該語句作用等同于main()當(dāng)py被引用是，該語句會被忽略有什么好處我們可以為所有py文件編寫測試代碼，而不用擔(dān)心py文件在作為非主程序時測試代碼被執(zhí)行所以建議使用該語句代替main()2.函數(shù)式編程python2定義函數(shù)的原則需要重復(fù)調(diào)用或有復(fù)用價值的功能，編寫到函數(shù)中不同函數(shù)中不要出現(xiàn)重復(fù)的功能，如果出現(xiàn)盡量規(guī)整到單一函數(shù)中2.函數(shù)式編程python2函數(shù)式編程的建議高聚合，低耦合盡量避免在函數(shù)中修改全局變量的值避免在函數(shù)中修改可變變量(直接修改dict或list，傳出一個新的變量)避免在函數(shù)中修改其他模塊的變量(建立新的變量)單個函數(shù)的代碼行數(shù)最好控制在100行以內(nèi)，如果發(fā)現(xiàn)函數(shù)較長，嘗試細(xì)分函數(shù)功能，將某些工具形成子函數(shù)提取出來。盡量讓讀者在一頁中看到整個函數(shù)函數(shù)較多時，將相關(guān)聯(lián)的函數(shù)放在一起，并使用注釋說明，方便閱讀和維護(hù)函數(shù)很多時，重新審視代碼，嘗試將函數(shù)放在不同的模塊中(py文件中),即進(jìn)行簡單的框架設(shè)計。保證在一個py文件中，能夠很方便的查閱代碼。4.類和面向?qū)ο缶幊填惖慕榻B類的方法類的繼承內(nèi)置方法面向?qū)ο缶幊?.類的介紹python2類的定義類（Class）是面向?qū)ο蟪绦蛟O(shè)計（OOP，Object-OrientedProgramming）實現(xiàn)信息封裝的基礎(chǔ)。類是一種用戶定義類型，也稱類類型。每個類包含數(shù)據(jù)說明和一組操作數(shù)據(jù)或傳遞消息的函數(shù)。類的實例稱為對象。類可以是一件事，一個功能，一組數(shù)據(jù)，一組對象，對一些具有共同特征實物的抽象通常情況下，類可以作為面向?qū)ο笤O(shè)計的基本單位Python中使用關(guān)鍵字class定義類，格式如下: class<類名>:

屬性

方法類的實例如果想要使用類，則需要給類創(chuàng)建實例，格式如下： classTest: …

T

=Test()1.類的介紹python2類的變量、實例變量類變量：指定義在類的內(nèi)部，但不包含在函數(shù)之內(nèi)的變量，此變量可以通過類直接訪問實例變量：值定義在類的__init__函數(shù)內(nèi)部，通過self修飾的變量，此變量必須通過類的實例才能訪問classSun: num=0 def__init__(self): self.num=1 defsum_fun(self,num1,num2): returnself.__private_func(num1,num2) def__private_func(self,num1,num2): returnnum1+num2print("類變量:",Sun.num)SUM=Sun()print("實例變量：",SUM.num)1.類的介紹python2類變量和實例變量classSun: num=0 def__init__(self): self.num1=2print("類調(diào)用:",Sun.num)SUM=Sun()print("實例調(diào)用：",SUM.num)類調(diào)用:0實例調(diào)用：0classSun: num=0 def__init__(self): self.num1=2try: SUM=Sun() print("實例調(diào)用：",SUM.num1) print("類調(diào)用:",Sun.num1)exceptExceptionasex: print(ex)實例調(diào)用：2typeobject'Sun'hasnoattribute'num1'1.類的介紹python2類的屬性、實例屬性Python中可以使用內(nèi)置函數(shù)dir(),和類的字典屬性__dict__來查看類屬性和實例屬性類屬性和實例屬性的區(qū)別

類屬性包括類變量和類中所有內(nèi)置函數(shù)和自定義函數(shù)

實例屬性值包括實例變量classSun: num=0 def__init__(self): self.num=1 defsum_fun(self,num1,num2): returnself.__private_func(num1,num2) def__private_func(self,num1,num2): returnnum1+num2SUM=Sun()print("類屬性（__dict__）",Sun.__dict__)print("類屬性（dir）:",dir(Sun))print("實例屬性：",SUM.__dict__)1.類的介紹python2類的屬性、實例屬性Python中可以使用內(nèi)置函數(shù)dir(),和類的字典屬性__dict__來查看類屬性和實例屬性類屬性和實例屬性的區(qū)別

類屬性包括類變量和類中所有內(nèi)置函數(shù)和自定義函數(shù)

實例屬性值包括實例變量classSun: num=0 def__init__(self): self.num=1 defsum_fun(self,num1,num2): returnself.__private_func(num1,num2) def__private_func(self,num1,num2): returnnum1+num2SUM=Sun()print("類屬性（__dict__）",Sun.__dict__)print("類屬性（dir）:",dir(Sun))print("實例屬性：",SUM.__dict__)1.類的介紹python2dir()和__dict__的區(qū)別dir()返回一個list,__dict__返回一個字典__dict__是dir()的一部分，是它的子集實例的__dict屬性，只包括實例相關(guān)的屬性類的__dict__屬性，只包括類相關(guān)的屬性dir()返回對象的所有屬性，包括繼承的父類屬性1.類的介紹python2保護(hù)變量和私有變量保護(hù)變量定義在類中，以單個下劃線開頭的變量_test=1保護(hù)變量其實和普通變量一樣，此種變量只是告訴外部人員我是保護(hù)變量，請不要修改，但實際上還是能夠訪問和修改的私有變量定義在類中，以兩個下劃線開頭的變量__test=1類實例能內(nèi)部訪問到私有變量類的實例不能外部訪問到私有變量但對于python來說并沒有實際意義的私有話，私有變量仍然可以通過某種方式訪問到，因為python會把私有變量改寫成_className__privateName的形式1.類的介紹python2保護(hù)變量和私有變量classTestParent: def__init__(self): self._protectVar="tect" self.__privateVar="self.private" defprint_Var(self): print("實例內(nèi)部調(diào)用保護(hù)變量：",self._protectVar) print("實例內(nèi)部調(diào)用私有變量：",self.__privateVar)TP=TestParent()try: TP.print_Var() print("實例外部調(diào)用保護(hù)變量：",TP._protectVar) print("實例外部調(diào)用私有變量：",TP.__privateVar)exceptExceptionase: print(e)print("實例外部調(diào)用私有變量_TestParent_privateVar：",TP._TestParent__privateVar)2.類的方法python2類方法、靜態(tài)方法、實例方法實例方法

：通過類的實例才能訪問的方法(函數(shù)),即為實例方法類方法：可以通過類訪問的方法，為類方法，使用裝飾器@classmethod來標(biāo)記，類方法同樣可被實例訪問。需注意類方法不要在參數(shù)的第一個參數(shù)寫入實例對象self，但要寫入一個參數(shù)表示類，一般用cls來表示靜態(tài)方法：靜態(tài)方法是一種普通函數(shù)，就位于類定義的命名空間中，它不會對任何實例類型進(jìn)行操作。因此今靜態(tài)方法可被多個實例共享。使用裝飾器@staticmethod定義靜態(tài)方法。靜態(tài)方法同樣可被實例訪問。需注意靜態(tài)方法不要在參數(shù)中寫入實例對象或類對象classSum: num=0 def__init__(self): self.num=1 defsum_func(self,num1,num2): returnnum1+num2 @classmethod defsum_func_classmethod(cls,num1,num2): returnnum1+num2 @staticmethod defsum_func_staticmethod(num1,num2): returnnum1+num2SUM=Sum()print("實例方法：",SUM.sum_func(1,2))print("實例調(diào)用類方法：",SUM.sum_func_classmethod(1,2))print("實例調(diào)用靜態(tài)方法：",SUM.sum_func_staticmethod(1,2))print("類方法：",Sum.sum_func_classmethod(1,2))print("類調(diào)用靜態(tài)方法",Sum.sum_func_staticmethod(1,2))2.類的方法python2類方法的作用一些和類相關(guān)的操作，但不與實例交互的操作classKls(): no=0 def__init__(self): #self.no=self.no+1 Kls.no=Kls.no+1

@classmethod defget_no(cls): returncls.noik1=Kls()print(ik1.get_no())print(Kls.get_no())2.類的方法python2靜態(tài)方法的作用一些和類相關(guān)，但既不需要與類交互，也不需要與實例交互的方法。importtimeclassTimeTest(object):def__init__(self,hour,minute,second):self.hour=hourself.minute=minuteself.second=second@staticmethoddefshowTime():returntime.strftime("%H:%M:%S",time.localtime())print(TimeTest.showTime())t=TimeTest(2,10,10)nowTime=t.showTime()print(nowTime)右邊靜態(tài)方法，然而方法體中并沒使用（也不能使用）類或?qū)嵗膶傩裕ɑ蚍椒ǎＨ粢@得當(dāng)前時間的字符串時，并不一定需要實例化對象2.類的方法python2普通方法和私有方法普通方法，是共享的，可被外部調(diào)用，無需多說私有方法，非共享，不可被外部調(diào)用。使用兩個下劃線開頭，例：__private_test()classTestFunc:def__init__(self):="TestFunc"def__private_test(self):print()deftest(self):print()TF=TestFunc()try: TF.test() TF.__private_test()exceptExceptionasex:print(ex)2.類的方法python2構(gòu)造函數(shù)和析構(gòu)函數(shù)構(gòu)造函數(shù)(初始化):def__init__(self):當(dāng)類的實例對象創(chuàng)建時被調(diào)用理論上構(gòu)造函數(shù)里可以做任何事，但一般情況下構(gòu)造函數(shù)用于聲明變量，初始化變量等操作2.類的方法python2析構(gòu)函數(shù)def__del__(self):當(dāng)類的實例被銷毀時，自動調(diào)用析構(gòu)函數(shù)通常情況下，析構(gòu)函數(shù)用來，釋放對象，銷毀內(nèi)存等操作(由于python有垃圾回收機制，因此一般來說，不需要重寫析構(gòu)函數(shù))3.類的繼承python2類的繼承繼承：python使用class派生類名(基類名)來實現(xiàn)類的繼承，可以理解為基類是派生類的父類，派生類繼承了父類的一切屬性繼承的一些特點：在繼承中基類的構(gòu)造（__init__()方法）不會被自動調(diào)用，它需要在其派生類的構(gòu)造中親自專門調(diào)用。（先繼承，后重構(gòu)）在調(diào)用基類的方法時，需要加上基類的類名前綴，且需要帶上self參數(shù)變量。區(qū)別于在類中調(diào)用普通函數(shù)時并不需要帶上self參數(shù)Python總是首先查找對應(yīng)類型的方法，如果它不能在派生類中找到對應(yīng)的方法，它才開始到基類中逐個查找。

3.類的繼承python2繼承中的覆蓋在子類中覆蓋父類的方法例如：在父類中有一個talk方法，我們在子類又創(chuàng)建了一個talk方法，這時子類的talk方法就覆蓋了父類的talk方法(但并不是改寫了父類的talk方法)classPerson(object):def__init__(self,name,age):=nameself.age=agedeftalk(self):print("%sistalking...."%)classChinese(Person):def__init__(self,name,age,language):Person.__init__(self,name,age)#繼承父類的構(gòu)造方法，也可以寫成：super(Chinese,self).__init__(name,age)super().__init__(name,age)self.language=languagedeftalk(self):print("%sistalking..."%)c=Chinese("zhangrui",22,"chinese")c.talk()3.類的繼承python2多重繼承python允許子類繼