Python函數

函數是一段可以重複使用的代碼，通過傳遞的參數返回不同的結果，函數能夠提高應用的模塊性和代碼的重複利用率。

目錄：

函數
1.無參函數
2.帶參函數
變量的作用域
1.全局變量
2.局部變量
lambda函數
內建函數
1.dir()
2.abs（）
3.bool（）
4.float()
5.int（）
6.範圍函數range()
7.求和函數sum()
8.最大值函數max()和最小值函數min()
9.表達式函數eval()
10.長度函數len()

函數

   Python中的函數都是語句和表達式的集合。函數的用法並沒有限制，使用方法就像Python中其他值一樣，對於重複使用的代碼，需要編寫爲自定義函數以便於重複使用。函數包括無參函數和帶參函數。

1.無參函數

1）自定義無參函數，語法格式如下：

def 函數名稱（）：
    代碼塊
    return 表達式

  以關鍵字def開始，後面跟函數名和小括號，以冒號開頭並縮進，最後使用return退出函數，有表達式則傳遞返回值，沒有則返回None。函數是以字母、數字和下劃線組成的字符串，但是不能以數字開頭。

無參函數調用語法如下：

[變量 = ] 函數名稱（）

使用賦值運算符“=”可以獲得函數的返回值，使用函數是必須先定義再調用，否則程序會出現錯誤

演示1：

def add():   //定義無參函數add（）
    op1 =10
    op2 =20
    rt  = op1+op2
    print op1,'+',op2,'=',rt
    return
add()  //調用函數

把演示1修改以下，用return語句返回值，代碼如下：

def add():
    op1 =10
    op2 =20
    rt  = op1+op2
    return rt
i = add()
print '結果是：',i  //函數返回值賦予給i

//執行
結果是： 30

九九乘法表

演示：

def qin():
     for i in range(1,10):
        for j in range(1,i+1):
            print i, "*", j, "=" ,i*j,
        print "\t"
qin()

//執行
1 * 1 = 1 	
2 * 1 = 2 2 * 2 = 4 	
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9 	
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16 	
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25 	
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36 	
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49 	
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64 	
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81 	

2）使用函數時經常會犯的錯誤，總結如下：

• 函數的定義要先於函數的調用，否則會出錯。
• 函數的代碼是一個整體，注意縮進。
• 定義函數時要使用冒號，但調用函數時不能使用冒號。

3）結合上面所學做一下綜合,寫一個用戶登錄頁面的腳本。

kgc={}
def newuser():     //定義創建新用戶的無參函數                                        
    prompt1 = '新的用戶:'
    while True:
        name = raw_input(prompt1)
        if (kgc.has_key(name)):       //has_key：用於判斷name鍵是否存在kgc字典中                      
            prompt1 = '--name taken,try another:'
            continue
        else:
            break
    pwd = raw_input('輸入密碼：')
    kgc[name]=pwd
def olduser():              //定義已有賬號的無參函數                                  
    name = raw_input('用戶:')
    pwd = raw_input('密碼:')
    password = kgc.get(name)     //獲取name在kgc字典中的值          
    if password == pwd:
        print "登入成功"
    else:
        print "請檢查賬號和密碼"
def showmenu():            //定義列表菜單，調用上兩個無參函數                             
    prompt='''
        (N)創建新用戶
        (E)已有用戶登錄
        (Q)退出
    輸入選擇：'''
    while True:
        choice = raw_input(prompt).strip()[0].lower() 
                //strip（）表示去除字符串錢的多餘字符，（）表示空格
                //[0]表示字符串的第一個字符
                //lower（）將字符變成小寫                         
                
        print '\n--您的選擇是:[%s]' %choice
        if choice not in 'neq':
            print '--invalid option,try again--'
        else:
            if choice=='n':
                newuser()
            elif choice=='e':
                olduser()
            else:
                print '成功退出'
                break
if __name__=='__main__':     //定義程序入口                      
    showmenu()

執行腳本

        (N)創建新用戶
        (E)已有用戶登錄
        (Q)退出
    輸入選擇：n

--您的選擇是:[n]
新的用戶:qzt
輸入密碼：111

        (N)創建新用戶
        (E)已有用戶登錄
        (Q)退出
    輸入選擇：e

--您的選擇是:[e]
用戶:qzt
密碼:111
登入成功

        (N)創建新用戶
        (E)已有用戶登錄
        (Q)退出
    輸入選擇：q

--您的選擇是:[q]
成功退出

2.帶參函數

1）帶參函數的語法格式如下：

def 函數名稱（形式參數列表）：
    代碼塊
    return [表達式]

   通過語法，可以看出帶參函數與無參函數的區別就是在函數名稱後的小括號中有形式參數列表，參數列表實際上只是佔位符，用於體現參數的個數，每個參數都沒有提供具體的數值。

帶參函數調用語法如下：

[變量 = ] 函數名稱（ 參數列表）

調用時只需要在每個參數傳遞對應的實際數值，就可以完成函數的調用。

演示1：

def add(x,y):   //定義帶參函數
	return x+y
print add(1,2)  //調用

//執行
3

定義了函數add（），它有兩個形式參數x和y，在函數的語句塊中可以使用x和y，和使用變量是類似的。通過函數名add（）和實際的參數值1和2進行調用，所以返回值是3

2）上面定義的是普通參數，又稱位置參數，當調用函數時，傳遞的實際參數值是根據位置來跟函數定義的參數表匹配的，如下：

def aa(x,y):
    print x,y
aa(10,6)
aa(6,10)

//執行

10 6
6 10
>>> 

在函數aa（x，y）中，輸出x，y值，x在前，y在後。調用aa（1,2）時，x的值是1，y的值是2；當調用aa（10,20）時，x的值是10，y的值是20，所以在最後的輸出結果是不同的。

3）當程序比較繁瑣時，參數的順序是很難記住的，可以使用關鍵字參數。關鍵字參數實在調用函數時，明確指定參數值付給那個形參

語法：函數名稱（形參1=實參1，形參2=實參2…）

如下：

def aa (x,y):
    print x,y
aa(x=10,y=6)
aa(y=6,x=10)

//執行
10 6
10 6
>>>

調用函數aa（x，y）指定了參數的名稱和對應值（x=10，y=6）（y=6，x=10），所以在調用函數時，就不會因爲位置的原因，而錯亂順序。

4）調用普通參數函數時，傳入的參數個數必須和聲明的參數個數一致。但關鍵字參數有一個特殊的作用，可以在定義函數時設置關鍵字參數的默認值，此時傳入函數的參數就可以和聲明的參數個數不一致了。

def aa(x,y=6):
    print x,y
aa(10)
aa(x=10)
//執行
10 6
10 6
>>> 



def aa(x,y=6):
    print x,y
aa(10,5)
aa(x=10,y=5)
//執行
10 5
10 5
>>>

定義時參數y的默認值是6，調用時，可以不傳遞y的值，只傳遞x的值即可，直接傳值或使用參數名並賦值都可以所以,aa(10）和aa（x=10）結果是相同的，如果定義了y的值，則y的默認值將不生效。

注意：定義關鍵字參數默認值時需要注意，位置參數必須出現在默認參數之前，如下的函數定義時錯誤的：

def aa(x=1,y):
    print x,y
aa()

5)綜合案例-計算器程序

①首先編寫用來運算的函數，代碼如下：

def operator(op1,op2,opFU):
         if opFU not in '+-*/':   //位置1
                  return -1
         if opFU == '+':        //位置2
                  result = op1+op2
         elif opFU == '-':
                  result = op1-op2
         elif opFU == '*':
                  result = op1*op2
         elif opFU == '/':
                  if op2 == 0:     //位置3
                           print '錯誤,除數不能爲0! /n'
                           result = None
                  else:
                           result = op1/op2
         return result

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

②字符串轉爲數值型的操作代碼如下：

def convert(op):
         flag = True  //位置1
         for ch in op:  //位置2
                  if ch not in '1234567890':
                           flag = False
                           break
         if flag == True:  //位置3
                  return int(op)
         else:              //位置4
                  return None

在上面的代碼中，首先定義了一個布爾型變量flag，用於判斷數值的有效性，在for循環語句中，op是傳進來的字符串，使用for循環判斷它的每一個字符是不是在“1234567890”中，如果有一個不再，說明這個字符串不能轉換爲數值，flag的值爲False，退出循環，否則flag的值不變，還是True，說明字符串可以轉換爲數值型。然後接下來做了相應的判斷，把字符串op轉換爲了整型，使用的是int（）函數。最後是如果不能轉換爲整型，返回的是None。
③主體代碼如下：

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

把上面三段代碼連接起來，就完成操作了

最終代碼效果如下：

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 '錯誤,除數不能爲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 = '請輸入第一個數:\n'
         strFU = '請輸入一個運算符:\n'
         str2 = '請輸入第二個數:\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 '輸入錯誤，請輸入整數!/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 "輸入錯誤，請輸入整數！\n"
                                    continue
                           else:
                                    break
                  result = operator(op1,op2,opFU)
                  if result <> None:
                           print "計算%d %s %d = %d \n" %(op1,opFU,op2,result)
         print '程序退出了'

測試效果

需要退出程序，請輸入字母q
請輸入第一個數:
11
請輸入一個運算符:
+
請輸入第二個數:
11
計算11 + 11 = 22 

變量的作用域

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

全局變量：最高級別變量，全局有效，存活到程序結束（除非被刪除），所有函數都能訪問全局變量。

局部變量：是在 函數內部定義的變量，只能在函數內部使用（有限制範圍）

 1. 局部變量的作用域僅限於定義它的函數，全局變量的作用域在整個模塊內部都是可見的。在同一個函數中，不允許有同名的局部變量，在不同函數中，可以有同名的局部變量。在同一個程序中，全局變量和局部變量同名時，局部變量具有更高的優先級。

演示：

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

//執行
請輸入年齡：
11
addage():_age=11 age=12
main():_age = 11
main(): rt=12

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

通過上面的代碼示例，可以看出Python採用的是值傳遞的方式，但實際上並不是這樣。Python採用的是值傳遞和引用傳遞相結合的方式，當傳遞可變對象時（如字典或者列表），相當於傳引用，而不可變對象（如數字、字符或元組）就是值傳遞。上面傳遞的是字符串，所以是值傳遞的方式。

在Python中儘量不使用全局變量，因爲程序中可以自由的訪問全局變量，其他人並不知道哪個變量是全局變量，非常容易出現引用錯誤，這種錯誤也很難發現和更正的。

2.局部變量在函數外引用不到

演示：

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():age = %d' %age	\\本行執行會出現錯誤，因age爲局部變量無法執行
print 'main():rt = %d' %rt

3.聲明局部變量到全局

global的作用是聲明變量爲全局變量，即使變量定義在函數內部，加上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語句聲明的全局變量名不能與其中的局部變量重名，而且儘量要避免在函數中使用global定義全局變量，減少程序的不可預知性。

lambda函數

lambda函數的作用是創建匿名函數，是一種聲明函數的特殊方式

語法：lambda params:expr

演示：

def sum1(x,y):
    return x+y

sum2 = lambda x,y : x+y
print sum1(3,4)
print sum2(3,4)

實現的是相同的功能，但lambda函數更加簡潔，只用一條語句實現，所以lambda也稱爲lambda表達式，注意：使用lambda只能是表達式不能包含if、for等條件循環語句，對於不需要複用、簡單的匿名函數，使用lambda能起到很好的效果。 

內建函數

1.dir（）函數可以返回關於任何值的相關信息，可以用於任何對象，包括字符串、數字、函數、模塊、對象和類。相當於幫助手冊。

語法：dir([object])

object是可選參數，無參數時，返回當前範圍內的變量，帶參時，返回的是參數的屬性、方法列表

演示：

>>> dir()  //無參數時，返回當前範圍內的變量
['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'sum1', 'sum2']

>>> dir(sum1)  //帶參時，返回的是參數的屬性、方法列表
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']

dir()函數還有一個功能非常有用，那就是查看內建函數，並查看個別內建函數的詳細用法。

演示：

>>> dir(__builtins__)  // //查看內置函數
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']

利用help查看內建函數詳細用法

>>> help (sum)  //查看sum內建函數的詳細用法
Help on built-in function sum in module __builtin__:

sum(...)
    sum(iterable[, start]) -> value
    
    Return the sum of an iterable or sequence of numbers (NOT strings)
    plus the value of 'start' (which defaults to 0).  When the sequence is
    empty, return start.

2.abs（）函數能夠返回一個數字的絕對值，即整數

演示：

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

3.bool（）函數返回值是True或False，它是布爾值的簡寫，可以用來判斷字符是否爲空。

函數返回值爲True或False；
        當參數爲數字時：0返回False，非0返回True。
        當參數爲字符串時，None或空字符串返回False，否則爲True。
        當參數爲空的列表、元組、字典時，返回False，否則爲True。

演示:

>>> bool()
False
>>> bool(0)
False
>>> bool(5)
True
>>> bool(-5)
True
>>> bool(None)
False
>>> bool('zzz')
True
>>> bool('11,22')
True

4.float()函數用於轉換數據爲float（浮點）類型。

演示：

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

字符串和數字都可以轉換爲float類型，如果不能轉換，就會報錯。

5.int（）函數可以將數據轉換爲整數。

演示：

>>> int(2002.05)  //浮點
2002
>>> int('28') //字符串
28

>>> int('2002.05')  //字符串,帶浮點（報錯）

Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    int('2002.05')
ValueError: invalid literal for int() with base 10: '2002.05'

需要注意當參數爲字符串，參數只能是整數，如果是浮點就會報錯。

6.範圍函數range()

>> range(0,10)  //表示範圍0-9
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(0,150,50)  //第三位的數字代表步長，是可選參數
[0, 50, 100]
>>> range(100,0,-10)  //負數爲倒着輸出
[100, 90, 80, 70, 60, 50, 40, 30, 20, 10]

>>> for i in range(0,5):  //配合for使用
	print i
	
0
1
2
3
4

7.求和函數sum()

演示：

>>> num = range(0,500,50)
>>> num
[0, 50, 100, 150, 200, 250, 300, 350, 400, 450]
>>> print (sum(num))  //對元組中的值進行累加求和操作
2250

8.最大值函數max()和最小值函數min()

演示：

>>> min (50,60,100)   //輸出最小值
50
>>> min ('d','z','g','l')
'd'

>>> max(50,60,100)   //輸出最大值
100
>>> max ('d','z','g','l')
'z'

9.表達式函數eval()

可以計算表達式的值

演示:

>>> eval ('100*9')
900
>>> eval (raw_input("請輸入表達式"))
請輸入表達式9*9+9
90

10.長度函數len()

>>> len ('qinlishzi')
9
>>> aa = ['python','linux','mysql','php']
>>> len(aa)
4
>>> zz={'zhangsan':123,'lisi':456,'wangwu':678}
>>> len(zz)
3

環境：使用python版本2