博文大綱:

  • 一、函數(shù)
  • 二、變量的作用域
  • 三、內建函數(shù)

一、函數(shù)

Python中的函數(shù)都是語句和表達式的集合。和shell腳本中的函數(shù)功能一致,可以把函數(shù)當做是給一堆代碼起定義了一個別名,當需要執(zhí)行這堆代碼時,直接調用那一堆代碼集合的“別名”即可。
對于腳本中需要重復使用的代碼,需要編寫為自定義函數(shù)以便于重復使用。

1、無參函數(shù)

定義無參函數(shù)的語法格式如下:

            
              def 函數(shù)名稱():
    代碼塊
    return [表達式]
            
          

定義無參函數(shù)是以關鍵字def,后面跟函數(shù)名和小括號,以冒號開頭并縮進,最后使用return退出函數(shù),有表達式則傳遞返回值,沒有則返回None。函數(shù)是以字母、數(shù)字和下劃線組成的字符串,但是不能以數(shù)字開頭。使用函數(shù)必須先定義再調用,否則程序會出現(xiàn)錯誤。

無參函數(shù)舉例:

示例一:

            
              #代碼如下:
def add():              #定義函數(shù)
    op1 = 10
    op2 = 20
    rt = op1 + op2
    print op1, '+', op2 ,'=',rt     
    return
add()    #調用函數(shù)
#執(zhí)行結果如下:
10 + 20 = 30
            
          

也可以將上面的代碼進行修改,使用return語句返回結果值。

            
              #代碼如下:
def add():
    op1 = 10
    op2 = 20
    rt = op1 + op2
    return rt
i = add()         #函數(shù)返回的結果賦值給變量i
print '結果是:',i
#執(zhí)行結果如下:
結果是: 30
            
          

在上面的代碼中,函數(shù)add()使用return語句返回相加的結果值,變量i接收函數(shù)add()返回的值。Python在處理返回值時,如果沒有return語句,會默認返回None,程序并不會報錯。

示例二(九九乘法表):

            
              #代碼如下:
def mutitab():
    a = ( 1,2,3,4,5,6,7,8,9 )
    b = ( 1,2,3,4,5,6,7,8,9 )
    for op1 in a:
        for op2 in b:
            print op1 , '*',op2, '=',op1 * op2
    return
mutitab()          #調用函數(shù)
#執(zhí)行結果如下:
1 * 1 = 1
1 * 2 = 2
1 * 3 = 3
1 * 4 = 4
1 * 5 = 5
1 * 6 = 6
1 * 7 = 7
1 * 8 = 8
1 * 9 = 9
#...........省略部分內容
            
          

示例二(一個簡易的登陸腳本):

            
              #代碼如下:
kgc = {}
def newuser():            #注冊
    prompt1 = "login desired:"
    while True:
        name = raw_input(prompt1)
        if (kgc.has_key(name)):
            prompt1 = '--name taken,try other:'
            continue
        else:
            pwd = raw_input('password:')
            kgc[name] = pwd
            break
def olduser():                     #登陸
    name = raw_input('login:')
    pwd = raw_input('password:')
    password = kgc.get(name)
    if password == pwd:
        print '--welcome back--',name
    else:
        print '--login incorrect--'
def showmenu():                 #菜單
    prompt = '''
        (N)ew User Login
        (E)ntering User Login
        (Q)uit
    Enter choice:'''
    while True:
        choice = raw_input(prompt).strip()[0].lower()
        print '\n--You piked: [%s]' %choice
        if choice not in 'neq':
            print '--invalid option,try again--'
        else:
            if choice=='n':
                newuser()
            elif choice=='e':
                olduser()
            else :
                print 'quit'
                break
if __name__== '__main__':     #程序入口,僅限于腳本執(zhí)行(在這個腳本示例中,可有可無)
    showmenu()

#執(zhí)行結果如下:

        (N)ew User Login
        (E)ntering User Login
        (Q)uit
    Enter choice:n            #輸入n

--You piked: [n]
login desired:zhangsan            #鍵入一個新用戶名和密碼
password:12

        (N)ew User Login
        (E)ntering User Login
        (Q)uit
    Enter choice:e           #輸入e

--You piked: [e]
login:zhangsan            #使用新鍵入的用戶名和密碼登錄
password:12
--welcome back-- zhangsan

        (N)ew User Login
        (E)ntering User Login
        (Q)uit
    Enter choice:q

--You piked: [q]                #按q退出登錄
quit
            
          

使用函數(shù)時會犯的一些錯誤,總結如下:

  • 函數(shù)的定義一定要先于函數(shù)的調用,否則會出錯;
  • 函數(shù)體的代碼是一個整體,要注意縮進;
  • 定義函數(shù)時要使用冒號,但調用時不需要冒號。

2、帶參函數(shù)

定義無參函數(shù)的語法格式如下:

            
              def 函數(shù)名稱(形式參數(shù)列表):
    代碼塊
    return [表達式]
            
          

通過語法可以看出,帶參函數(shù)和無參函數(shù)的區(qū)別是在函數(shù)名稱后面的小括號有形式參數(shù)列表,參數(shù)列表實際上只是占位符,用于體現(xiàn)參數(shù)的個數(shù),每個參數(shù)都沒有提供具體的數(shù)值。

示例1

            
              #代碼如下:
def add(x,y):
    return x + y
print add(3,2)
#執(zhí)行結果如下:
5
            
          

示例2

上一個示例中定義的形式參數(shù)是普通的參數(shù),又稱為位置參數(shù),當調用函數(shù)時,傳遞的實際參數(shù)值是根據(jù)位置來跟函數(shù)定義里的參數(shù)表匹配的,如下:

            
              #代碼如下:
def add(x,y):
    print x,y
add(10,6)
add(6,10)
#執(zhí)行結果如下:
10 6
6 10
            
          

示例3

當程序比較繁瑣時,很容易把參數(shù)的順序搞混,可以使用關鍵字參數(shù)。關鍵字參數(shù)是在調用函數(shù)時,指明參數(shù)賦值給哪個形參,如下:

            
              #代碼如下:
def add(x,y):
    print x,y
add(x=10,y=6)
add(y=6,x=10)
#執(zhí)行結果如下:
10 6
10 6
            
          

在上面的函數(shù)aa(x,y)中,調用時明確指明了參數(shù)的名稱和對應值(x=10,y=6)和(y=6,x=10),與參數(shù)所在的位置無關,明確了實參和形參的對應關系,所以輸出的結果是一樣的。

示例4

調用普通函數(shù)參數(shù)時,傳入的參數(shù)個數(shù)必須和聲明的參數(shù)個數(shù)一致,但關鍵字參數(shù)有一個特殊的作用,可以在定義函數(shù)時設置關鍵字參數(shù)的默認值,此時傳入函數(shù)的參數(shù)就可以和聲明的參數(shù)個數(shù)不一致了,如下:

            
              #代碼如下:
def add(x,y=4):
    print x,y
add(10)
add(x=10)
add(10,6)
add(x=10,y=6)
#執(zhí)行結果如下:
10 4
10 4
10 6
10 6
            
          

在上面函數(shù)中,定義時參數(shù)y的默認值是4,調用函數(shù)時可以不傳遞y的值,只傳遞x的值即可,直接傳值或使用參數(shù)名并賦值都可以,aa(10)和aa(x=10)的結果都是相同的。當傳遞y的值是6時,此時y的默認值不起作用,所以aa(10,6)和aa(x=10,y=6)輸出時,y的值是6。

注意:定義關鍵字參數(shù)默認值需要注意,位置參數(shù)必須出現(xiàn)在默認參數(shù)之前,如下代碼中函數(shù)的定義時錯誤的:

            
              #代碼如下
def add(y=4,x):
    print x,y
add(1,2)
#執(zhí)行時,程序必然報錯,所以說,默認參數(shù)必須在位置參數(shù)的后面,將y=4,放到x參數(shù)之后就可以了
            
          

示例5(綜合示例)

需求如下:

  • 完成一個計算器的程序,用戶輸入兩個數(shù)字和運算符,做加減乘除運算,
  • 為了使程序結構清晰,需要編寫兩個函數(shù),一個是用來處理加減乘除運算,一個是用來處理字符串和數(shù)值轉換。
            
              #完整代碼如下:
def operator(op1,op2,opfu):
    if opfu not in '+-*/':
        return -1
    if opfu =='+':
        result = op1+op2
    elif opfu =='-':
        result = op1-op2
    elif opfu =='*':
        result = op1*op2
    elif opfu =='/':
        if op2 == 0:
            print '錯誤,除數(shù)不能為0!/n'
            result = None
        else:
            result = op1/op2
    return result
def convert(op):
    flag = True
    for ch in op:
        if ch not in '1234567890':
            flag = False
            break
        if flag == True:
                return int(op)
        else:
            return None
if __name__=='__main__':
    str1 = '請輸入第一個數(shù):\n'
    strfu = '請輸入一個算數(shù)運算符:\n'
    str2 = '請輸入第二個數(shù):\n'
    while True:
        print '需要退出程序,請輸入字母q'
        opp1 = raw_input(str1)
        ch = opp1.strip()[0].lower()
        if ch == 'q':
            break
        op1 = convert(opp1)
        if op1 ==None:
            print '輸入錯誤,請輸入整數(shù)!\n'
            continue
        while True:
            opfu = raw_input(strfu)
            if opfu in '+-*/':
                break
            else:
                print '運算符輸入錯誤'
                continue
        while True:
            op2 = convert(raw_input(str2))
            if op2 == None:
                print "輸入錯誤,請輸入整數(shù)!\n"
                continue
            else:
                break
        result = operator(op1,op2,opfu)
        if result <> None:
            print "計算%d %s %d = %d \n" %(op1,opfu,op2,result)
print '程序退出了'
#執(zhí)行結果如下:
需要退出程序,請輸入字母q
請輸入第一個數(shù):
10
請輸入一個算數(shù)運算符:
*
請輸入第二個數(shù):
2
計算10 * 2 = 20 

需要退出程序,請輸入字母q
請輸入第一個數(shù):
q
程序退出了
            
          

現(xiàn)在對上述代碼進行分段解釋:
第一段代碼:

            
              def operator(op1,op2,opfu):
    if opfu not in '+-*/':
        return -1
    if opfu =='+':
        result = op1+op2
    elif opfu =='-':
        result = op1-op2
    elif opfu =='*':
        result = op1*op2
    elif opfu =='/':
        if op2 == 0:
            print '錯誤,除數(shù)不能為0!/n'
            result = None
        else:
            result = op1/op2
    return result
            
          

在上面代碼中,位置1處定義了函數(shù)operator(op1,op2,opfu),參數(shù)op1表示運算符前面的數(shù)值,op2表示運算符后面的數(shù)值,opfu表示運算符,然后先判斷opfu是不是“+-*/”中的其中一個,如果不是,返回值是-1,表示程序出錯。在接下來就是判斷是哪個運算符號,就進行哪種運算處理。但是在判斷除法運算符時,需要加一個條件,就是除數(shù)不能是0,因為除數(shù)是0在數(shù)學上是沒有意義的,最后只要把運算的結果返回即可。

第二段代碼:

            
              def convert(op):
    flag = True
    for ch in op:
        if ch not in '1234567890':
            flag = False
            break
        if flag == True:
                return int(op)
        else:
            return None
            
          

在上面的代碼中,首先定義了一個布爾型變量flag,用于判斷數(shù)值的有效性,在for循環(huán)語句中,op是傳進來的字符串,使用for循環(huán)判斷它的每一個字符是不是在“1234567890”中,如果有一個不再,說明這個字符串不能轉換為數(shù)值,flag的值為False,退出循環(huán),否則flag的值不變,還是True,說明字符串可以轉換為數(shù)值型。然后接下來做了相應的判斷,把字符串op轉換為了整型,使用的是int()函數(shù)。最后是如果不能轉換為整型,返回的是None。

第三段代碼:

            
              if __name__=='__main__':
#以下是定義三個字符串的提示文字
    str1 = '請輸入第一個數(shù):\n'
    strfu = '請輸入一個算數(shù)運算符:\n'
    str2 = '請輸入第二個數(shù):\n'
#下面是主體代碼的無限循環(huán)操作,可以用來進行多次計算
    while True:
        print '需要退出程序,請輸入字母q'
#以下是判斷當鍵盤輸入q時,就退出程序
        opp1 = raw_input(str1)
        ch = opp1.strip()[0].lower()
        if ch == 'q':
            break
#對輸入的第一個字符串進行數(shù)值轉換操作,convert()返回是None,說明不能轉換,使用continue進入到下一次循環(huán)重新輸入。
        op1 = convert(opp1)
        if op1 ==None:
            print '輸入錯誤,請輸入整數(shù)!\n'
            continue
#等待輸入運算符,如果是“+-*/”中的一個,使用break結束循環(huán),否則執(zhí)行continue,重新輸入
        while True:
            opfu = raw_input(strfu)
            if opfu in '+-*/':
                break
            else:
                print '運算符輸入錯誤'
                continue
#下面是輸入第二個數(shù)值,同樣需要做轉換操作,如果不能轉換就需要重新輸入
        while True:
            op2 = convert(raw_input(str2))
            if op2 == None:
                print "輸入錯誤,請輸入整數(shù)!\n"
                continue
            else:
                break
#下面就是調用函數(shù)operator進行運算,result不等于None就說明運算是正常的,顯示出運算結果
        result = operator(op1,op2,opfu)
        if result <> None:
            print "計算%d %s %d = %d \n" %(op1,opfu,op2,result)
print '程序退出了'
            
          

二、變量的作用域

作用域是指變量在程序中的應用范圍,而變量聲明的位置決定它的作用域, Python按作用域區(qū)分有局部變量和全局變量。

1、全局變量:

全局變量是指在一個模塊中最高級別的變量有全局作用域,除非被刪除,否則存活到程序運行結束,所有函數(shù)都能訪問全局變量。

2、局部變量:

局部變量是指定義在函數(shù)內的變量有局部作用域,依賴于定義變量的函數(shù)現(xiàn)階段是否處于活動狀態(tài),調用函數(shù)時,局部變量產(chǎn)生,暫時存在,一旦函數(shù)執(zhí)行完成,局部變量就不存在了。

局部變量的作用域僅限于定義它的函數(shù),全局變量的作用域在整個模塊內部都是可見的。在同一個函數(shù)中,不允許有同名的局部變量,在不同函數(shù)中,可以有同名的局部變量。在同一個程序中,全局變量和局部變量同名時,局部變量具有更高的優(yōu)先級。

示例:

            
              #代碼如下:
def addage(age):
    age += 1
    print 'addage():_age=%d age=%d' %(_age,age)
    return age
_age = input('請輸入年齡:\n')
rt = addage(_age)
print 'main():_age = %d'%_age
print 'main(): rt=%d' %rt
#執(zhí)行結果如下:
請輸入年齡:
10            #輸入一個“10”
addage():_age=10 age=11
main():_age = 10
main(): rt=11
            
          

在上面的代碼中,函數(shù)addage(age)中定義了局部變量age,在全局范圍定義了全局變量_age。_age的值是由我們鍵盤輸入的,它在全局都生效,所以在addage(age)函數(shù)中也可以對它進行引用。當鍵盤輸入是10時,_age的值是10,調用“rt=addage(_age)”,就是把全局變量_age的值10傳給了函數(shù),此時addage(age)的局部變量age的值也是10,執(zhí)行age += 1后,age值成為了11,而全局變量_age的值不發(fā)生變化,打印輸出“_age=10 age=11”,函數(shù)的返回值age的值是11,由rt接收,所以打印“_age=10,rt=11”

通過上面的代碼示例,可以看出Python采用的是值傳遞的方式,但實際上并不是這樣。Python采用的是值傳遞和引用傳遞相結合的方式,當傳遞可變對象時(如字典或者列表),相當于傳引用,而不可變對象(如數(shù)字、字符或元組)就是值傳遞。上面?zhèn)鬟f的是字符串,所以是值傳遞的方式。

在Python中盡量不使用全局變量,因為程序中可以自由的訪問全局變量,其他人并不知道哪個變量是全局變量,非常容易出現(xiàn)引用錯誤,這種錯誤也很難發(fā)現(xiàn)和更正的。

局部變量只有在局部中才能使用,其他范圍是訪問不到的,如上面的代碼匯總age是局部變量,在全局范圍就引用不到,比如在上面程序中加上下面這行代碼,就會報錯。

            
              #在上面代碼末尾加上下面這段代碼:
 # ....................省略部分內容
print 'main():age = %d'%age
#執(zhí)行結果如下:
請輸入年齡:
10
addage():_age=10 age=11
main():_age = 10
main(): rt=11

Traceback (most recent call last):     
  File "C:/Users/Administrator/Desktop/aa.py", line 9, in 
              
                
    print 'main():age = %d'%age 
NameError: name 'age' is not defined      #提示age沒有定義
              
            
          

錯誤顯示age沒有定義,說明在全局范圍age是訪問不到的,這個問題可以使用global關鍵字解決,global的作用是聲明變量為全局變量,即使變量定義在函數(shù)內部,加上global后,也可以在全局范圍訪問,修改后的代碼如下:

            
              def addage(num):
    global age
    age = num+1
    print 'addage():_age=%d age=%d' %(_age,age)
    return age
_age = input('請輸入年齡:\n')
rt = addage(_age)
print 'main():_age = %d'%_age
print 'main(): rt=%d' %rt
print 'main():age = %d'%age
            
          

上面代碼中做了一些調整,主要使用了global定義age,最后在全局引用age時,可以正常使用。

在函數(shù)中,使用global語句聲明的全局變量名不能與其中的局部變量重名,而且盡量要避免在函數(shù)中使用global定義全局變量,減少程序的不可預知性。

三、內建函數(shù)

Python除了本身的語法結構,還提供了常用的內建函數(shù),內建函數(shù)是我們經(jīng)常使用到的方法,可增加程序編寫的效率,如float()函數(shù)就是內建函數(shù)。內建函數(shù)是自動加載的,Python的解釋器可以識別,它不需要導入模塊,不必做任何操作,不需要引用就可以調用。

1、abs()函數(shù)能夠返回一個數(shù)字的絕對值,即整數(shù),如下:

            
              >>> abs(10)
10
>>> abs(-10)
10
>>> bb = -3
>>> abs(bb)
3
            
          

2、bool()函數(shù)返回值是TRUE或FALSE,它是布爾值的簡寫,可以用來判斷字符是否為空,如下:

            
              >>> bool()    #無參數(shù)時返回False
False
>>> bool(0)
False
>>> bool(-3)
True
>>> bool(None)
False
>>> bool('xyz')
True
>>> bool('11,22')
True
            
          

3、float()函數(shù)用于轉換數(shù)據(jù)為float(浮點)類型,字符串和數(shù)字都可以轉換為float類型,如果不能轉換,就會報錯,如下:

            
              >>> float(25)
25.0
>>> float(3)
3.0
>>> float(99.589456)
99.589456
>>> float('99.589456')
99.589456
            
          

4、int()函數(shù)可以將數(shù)據(jù)轉換為整數(shù),如下:

            
              >>> int(199.99)     #浮點數(shù)
199
>>> int('100')     #字符串
100
>>> int('99.99')     #字符串,字符串中只能是整數(shù)格式,如果是浮點型就會報錯

Traceback (most recent call last):
  File "
              
                ", line 1, in 
                
                  
    int('99.99')
ValueError: invalid literal for int() with base 10: '99.99'
                
              
            
          

5、range()函數(shù)可以生成一個列表,如下:

            
              >>> range(0,5)
[0, 1, 2, 3, 4]
>>> range(0,30,3)     #第三位的數(shù)字代表步長,是可選參數(shù)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
>>> range(30,0,-3)
[30, 27, 24, 21, 18, 15, 12, 9, 6, 3]
>>> for i in range(0,5):
    print i

0
1
2
3
4
            
          

6、sum()函數(shù)可以對列表中元素求和,如下:

            
              >>> num = range(0,500,50)   #定義一個元組
>>> num          #查看元組中的值
[0, 50, 100, 150, 200, 250, 300, 350, 400, 450]
>>> print (sum(num))    #對元組中的值進行求和操作
2250
            
          

7、max()函數(shù)可以返回列表、元組或字符串中最大的元素,如下:

            
              >>> num = [6,2,12,7,65]
>>> max(num)
65
>>> str = 'a,d,g,c,D,U,A,N,G'
>>> max(str)
'g'
>>> max(1000,650,98,2689)
2689
            
          

8、min()函數(shù)返回列表、元組或字符串中值最小的元素,和max()正好相反,如下:

            
              >>> min(10,9,7)
7
            
          

9、dir()函數(shù)可以返回關于任何值的相關信息,可以用于任何對象,包括字符串、數(shù)字、函數(shù)、模塊、對象和類。相當于幫助手冊。如下:

            
              >>> dir()                #無參數(shù)時,返回當前范圍內的變量
['__builtins__', '__doc__', '__file__', '__name__', '__package__', '_age', 'addage', 'age', 'bb', 'i', 'num', 'rt', 'str']
>>> dir(rt)                #帶參時,返回的是參數(shù)的屬性、方法列表
['__abs__', '__add__', '__and__', '__class__', '__cmp__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__float__', '__floordiv__', '__format__', '__getattribute__', '__getnewargs__', '__hash__', '__hex__', '__index__', '__init__', '__int__', '__invert__', '__long__', '__lshift__', '__mod__', '__mul__', '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'imag', 'numerator', 'real']
            
          

10、eval()函數(shù)是可以計算表達式的值。如下:

            
              >>> eval('100*9')
900
>>> eval(raw_input("請輸入表達式:"))
請輸入表達式:8+9*2-3
23
            
          

11、len()函數(shù)返回一個對象的長度,如下:

            
              >>> len('lvjianzhao')       #字符串
10
>>> language = ['python','java','c#','vb']       #列表
>>> len(language)
4
>>> person = {'zhangsan':'123','lisi':'234','wangwu':'345'}    #定義一個字典
>>> len(person)
3
            
          

附加——lambda函數(shù)

lambda函數(shù)的作用是創(chuàng)建匿名函數(shù),是一種聲明函數(shù)的特殊方式。
lambda函數(shù)的語法格式如下:

            
              lambda params:expr
            
          

其中params相當于函數(shù)接受的參數(shù)列表,expr是函數(shù)返回值的表達式。

示例:

            
              #代碼如下
def sum1(x,y):
    return x+y
sum2 = lambda x,y:x+y
print sum1(1,2)
print sum2(1,2)
#執(zhí)行結果如下
3
3
            
          

實現(xiàn)的是相同的功能,但lambda函數(shù)更加簡潔,只用一條語句實現(xiàn),所以lambda也稱為lambda表達式,使用lambda只能是表達式,不能包含if、for等條件循環(huán)語句,對于不需要復用、簡單的匿名函數(shù),使用lambda能起到很好的效果。

———————— 本文至此結束,感謝閱讀 ————————