摘要：局部變量只能在其被聲明的函數(shù)內(nèi)部訪問(wèn)，而全局變量可以在整個(gè)程序范圍內(nèi)訪問(wèn)。調(diào)用函數(shù)時(shí)，所有在函數(shù)內(nèi)聲明的變量名稱(chēng)都將被加入到作用域中。

函數(shù)
（一）定義函數(shù)
你可以定義一個(gè)由自己想要功能的函數(shù)，以下是簡(jiǎn)單的規(guī)則：
（1）函數(shù)代碼塊以?def?關(guān)鍵詞開(kāi)頭，后接函數(shù)標(biāo)識(shí)符名稱(chēng)和圓括號(hào)()。
（2）任何傳入?yún)?shù)和自變量必須放在圓括號(hào)中間。圓括號(hào)之間可以用于定義參數(shù)。
（3）函數(shù)的第一行語(yǔ)句可以選擇性地使用文檔字符串—用于存放函數(shù)說(shuō)明。
（4）函數(shù)內(nèi)容以冒號(hào)起始，并且縮進(jìn)。
（5）return結(jié)束函數(shù)，選擇性地返回一個(gè)值給調(diào)用方。不帶表達(dá)式的return相當(dāng)于返回 None。

 語(yǔ)法：
   def functionname( parameters ):
       "函數(shù)_文檔字符串"
       function_suite
       return [expression]

默認(rèn)情況下，參數(shù)值和參數(shù)名稱(chēng)是按函數(shù)聲明中定義的的順序匹配起來(lái)的。

練習(xí)1：沒(méi)有返回return的函數(shù)，返回none

      >>> def sum(a,b):
      ...     print a+b
      >>> print sum(5,4)
      

練習(xí)2：返回列表及元組

 >>> def bar():
  ...     return "abc",[42,"python"],"guido"
 >>> def foo():
  ...     return ["hello",1000,-98.6]

注：bar()函數(shù)返回一個(gè)元組,foo()函數(shù)返回一個(gè)列表，由于元組語(yǔ)法上不一定帶上圓括號(hào)，所以讓人覺(jué)得返回了多個(gè)值。所以可以適當(dāng)加上括號(hào)。

從返回值的角度看可以通過(guò)以下三種方式進(jìn)行數(shù)據(jù)的存儲(chǔ)：
（在對(duì)x,y,z 和a,b,c的賦值中每個(gè)變量會(huì)接收對(duì)應(yīng)的返回值，而tuple1會(huì)隱式地返回整個(gè)元組）

 >>>tuple1=bar()
 >>> x,y,z=bar()
 >>> (a,b,c)=bar()

（二）調(diào)用函數(shù)
定義一個(gè)函數(shù)只給了函數(shù)一個(gè)名稱(chēng)，指定了函數(shù)里包含的參數(shù)，和代碼塊結(jié)構(gòu)。這個(gè)函數(shù)的基本結(jié)構(gòu)完成以后，你可以通過(guò)另一個(gè)函數(shù)調(diào)用執(zhí)行，也可以直接從Python提示符執(zhí)行。

>>> def printme(str):
...     print str;
...     Return
>>> printme("調(diào)用自定義的函數(shù)")
   

練習(xí)3：求列表中第二大的數(shù)
方法一：

>>> a=[10,50,-1,3,2,10]
>>> def secNum(lista):
...     lista.sort()
...     return lista[-2]
...
>>> print secNum(a)
10

方法二：

>>> def secNum(lista):
...     max_number=max(lista)
...     lista.remove(max_number)
...     return max(lista)

方法三：
算法：
1 比較列表中前2個(gè)數(shù)，大的作為為列表中暫時(shí)的最大數(shù)，小的
作為次大數(shù)，分別存在2個(gè)變量里
2 遍歷列表從第三個(gè)數(shù)開(kāi)始以后后的值，去和最大值去比較，存在2種可能
3 如果大于，當(dāng)前值作為列表中暫時(shí)的最大數(shù)，以前最大的變?yōu)?br>次大的。
4 如果小于，和次大的比較，大于它就是次大值，小于繼續(xù)遍歷
后續(xù)值。

#coding=utf-8
a=[10,10,10,0,10,10,0]
def?secondBiggestNumber(lista):

???? #判斷是否是列表或元組
???? if?not?isinstance(lista,(list,tuple)):
???????? return?None
??? ?#判斷是否有2個(gè)以上元素
??? ?if?len(lista)<=1:
???????? return?None
???? #判斷每個(gè)元素的的值是否為數(shù)字
???? for?i?in?lista:
???????? if?isinstance(i,(int,float)):
???????????? continue
???????? else:
???????????? return?None
???? #比較列表中前2個(gè)數(shù)，大的作為為列表中暫時(shí)的最大數(shù)，小的
???? #作為次大數(shù)，分別存在2個(gè)變量里
???? if?lista[0]>lista[1]:
???????? biggest_number=lista[0]
???????? second_biggest_number=lista[1]
???? else:
???????? biggest_number=lista[1]
???????? second_biggest_number=lista[0]
???? #遍歷列表從第三個(gè)數(shù)開(kāi)始以后后的值，去和最大值去比較
???? for?i?in?lista[2:]:
??????? #如果大于，當(dāng)前值作為列表中暫時(shí)的最大數(shù)，以前最大的變?yōu)?br>?????? ?#次大的。
??????? if?i?>?biggest_number:
??????????? second_biggest_number=biggest_number
??????????? biggest_number=i
?????? #如果小于，和次大的比較，大于它就是次大值，小于繼續(xù)遍歷
????? ?#后續(xù)值。
??????? elif?i?==?biggest_number:
??????????? continue
?????? ?else:
??????????? if?biggest_number==second_biggest_number:
??????????????? second_biggest_number=i
?????????? ?if?i?>second_biggest_number:
??????????????? second_biggest_number=i
???? return?second_biggest_number

    print?secondBiggestNumber(a)

練習(xí)4：計(jì)算10000次浮點(diǎn)數(shù)運(yùn)算的耗時(shí)

import time
import random
>>> def compute_float_time_consume():
...     start_time=time.time()
...     for i in range(10000):
...         random.random()**2
...     end_time=time.time()
...     return end_time-start_time

(三）參數(shù)傳遞
在Python中，類(lèi)型屬于對(duì)象，變量是沒(méi)有類(lèi)型的：

  a=[1,2,3]
  a="Runoob"

以上代碼中，[1,2,3]?是 List 類(lèi)型，"Runoob"?是 String 類(lèi)型，而變量 a 是沒(méi)有類(lèi)型，她僅僅是一個(gè)對(duì)象的引用（一個(gè)指針），可以是 List 類(lèi)型對(duì)象，也可以指向 String 類(lèi)型對(duì)象。
(1)可更改(mutable)與不可更改(immutable)對(duì)象

在 python 中，strings, tuples, 和 numbers 是不可更改的對(duì)象，而 list,dict 等則是可以修改的對(duì)象。

不可變類(lèi)型：變量賦值?a=5?后再賦值?a=10，這里實(shí)際是新生成一個(gè) int 值對(duì)象 10，再讓 a 指向它，而5被丟棄，不是改變a的值，相當(dāng)于新生成了a。
可變類(lèi)型：變量賦值?la=[1,2,3,4]?后再賦值?la[2]=5?則是將 list la 的第三個(gè)元素值更改，本身la沒(méi)有動(dòng)，只是其內(nèi)部的一部分值被修改了。

(2)python 函數(shù)的參數(shù)傳遞：
不可變類(lèi)型：類(lèi)似 c++ 的值傳遞，如 整數(shù)、字符串、元組。如fun（a），傳遞的只是a的值，沒(méi)有影響a對(duì)象本身。比如在 fun（a）內(nèi)部修改 a 的值，只是修改另一個(gè)復(fù)制的對(duì)象，不會(huì)影響a本身。
可變類(lèi)型：類(lèi)似 c++ 的引用傳遞，如列表，字典。如 fun（a），則是將 a 真正的傳過(guò)去，修改后fun外部的a也會(huì)受影響
python 中一切都是對(duì)象，嚴(yán)格意義我們不能說(shuō)值傳遞還是引用傳遞，我們應(yīng)該說(shuō)傳不可變對(duì)象和傳可變對(duì)象。

練習(xí)3：傳不可變對(duì)象

>>> def ChangeInt(a):
...     a=10
>>> b=2
>>> ChangeInt(b)
>>> print b    #結(jié)果是2

練習(xí)4：傳可變對(duì)象

>>> def changeme(mylist):
...     mylist.append([1,2,3,4])
...     print mylist
...     return
>>> mylist=[10,20,30]
>>> changeme(mylist)      #[10, 20, 30, [1, 2, 3, 4]]
>>> print mylist           #[10, 20, 30, [1, 2, 3, 4]]

注：實(shí)例中傳入函數(shù)的和在末尾添加新內(nèi)容的對(duì)象用的是同一個(gè)引用
（2）參數(shù)類(lèi)型
python中函數(shù)傳遞參數(shù)有四種形式：
fun1(a,b,c)
fun1(a,b,c)是直接將實(shí)參賦予行參，根據(jù)位置做匹配，即嚴(yán)格要求實(shí)參的數(shù)量與行參的數(shù)量位置相等，比較一般，大多數(shù)語(yǔ)言常用這種方式。

>>> def a(x,y):print x,y
>>> a(4,5)      #4 5

fun2(a=1,b=2,c=3)
fun2(a=1,b=2,c=3)根據(jù)鍵值對(duì)的形式做實(shí)參與行參的匹配，通過(guò)這種式就可以忽略了參數(shù)的位置關(guān)系，直接根據(jù)關(guān)鍵字來(lái)進(jìn)行賦值，同時(shí)該種傳參方式還有個(gè)好處就是可以在調(diào)用函數(shù)的時(shí)候作為個(gè)別選填項(xiàng)，不要求數(shù)量上的相等，即可以fun5(3,4)來(lái)調(diào)用fun2函數(shù)，這里關(guān)鍵就是前面的3,4覆蓋了原來(lái)a、b兩個(gè)行參的值，但c還是不變采用原來(lái)的默認(rèn)值3，這種模式相較第一種更加靈活，不僅可以通過(guò)fun6(c=5,a=2,b=7)來(lái)打亂行參的位置，而且可以在但沒(méi)有對(duì)應(yīng)行參傳遞的時(shí)候常用定義函數(shù)時(shí)的默認(rèn)值。

>>> def a(x,y=3):print x,y
>>> a(4)           #4 3

注：Python傳可變對(duì)象-傳默認(rèn)參數(shù)會(huì)記住值-這是坑須知道

#coding=utf-8
def add_end(L=[]):                     #或者Ｌ＝[1, 2, 3]
    L.append("END")
    return L
print add_end([1, 2, 3])
print add_end(["x", "y", "z"])
print add_end()
print add_end()
print add_end()

只有在默認(rèn)參數(shù)時(shí)候，L才會(huì)記住每次append的值
如果你每次都傳入值，L就會(huì)每次顯示你傳入的數(shù)據(jù)而不會(huì)記住你上一次傳入的值
改成如下：

def add_end(L=None):
    if L is None:
        L=[]
        L.append("END")
    return L

解析：
Python傳默認(rèn)參數(shù)需注意：
默認(rèn)參數(shù)是[]，但是函數(shù)似乎每次都”記住了”上次添加了’END’后的list；
Python函數(shù)在定義的時(shí)候，默認(rèn)參數(shù)的值就被計(jì)算出來(lái)了即[]；
因?yàn)槟J(rèn)參數(shù)L也是一個(gè)變量，它指向?qū)ο骩]，每次調(diào)用該函數(shù)，如果改變了L的內(nèi)容，則下次調(diào)用時(shí)，默認(rèn)參數(shù)的內(nèi)容就變了，不在是函數(shù)定義時(shí)的[]了；
定義默認(rèn)參數(shù)必須牢記一點(diǎn)：默認(rèn)參數(shù)必須指向不變對(duì)象！
所以：函數(shù)的默認(rèn)參數(shù)最好別用可變對(duì)象，否則存在累加操作結(jié)果
的情況

fun3(*args)--元組參數(shù)
fun3(*args)，這傳參方式是可以傳入任意個(gè)參數(shù)，這些若干參數(shù)都被放到了tuple元組中賦值給行參args，之后要在函數(shù)中使用這些行參，直接操作args這個(gè)tuple元組就可以了，這樣的好處是在參數(shù)的數(shù)量上沒(méi)有了限制，但是因?yàn)槭莟uple，其本身還是有次序的，這就仍然存在一定的束縛，在對(duì)參數(shù)操作上也會(huì)有一些不便。

>>> def a(*x):print x
>>> a(1,2,3)
(1, 2, 3)
>>> a(x=1,y=2,z=3)
Traceback (most recent call last):
File "", line 1, in 
TypeError: a() got an unexpected keyword argument "x"

注：不管有多少個(gè)，在函數(shù)內(nèi)部都被存放在以形參名為標(biāo)識(shí)符的元組中。

練習(xí)5：累計(jì)乘法

>>>?def?mul(*arg):
...?????result=1
...?????for?i?in?arg:
...?????????if?not?isinstance(i,(int,float,long)):
...?????????????return?None
...?????????else:
...?????????????result*=i
...?????return?result
...
>>>?mul(1,2,3,4)
24 

fun4(**kargs)--參數(shù)是字典
fun4(*kargs)最為靈活，形參名前加兩個(gè)表示，參數(shù)在函數(shù)內(nèi)部將被存放在以形式名為標(biāo)識(shí)符的dictionary中，這時(shí)調(diào)用函數(shù)的方法則需要采用arg1=value1,arg2=value2這樣的形式。

>>> def a(**x):print x
>>> a(x=1,y=2,z=3)
{"y": 2, "x": 1, "z": 3}
>>> a(1,2,3)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: a() takes exactly 0 arguments (3 given)

綜合練習(xí)3：mul(1,2,3,4,5,a=6,b=7)實(shí)現(xiàn)連乘函數(shù)，需要用到arg，*kw,且函數(shù)有固定2個(gè)參數(shù)：a,b

def mul(a, b, *arg, **kw):
    result=1
    if not isinstance(a, (int, float, long)) and not isinstance(b, (int,             float, long)):
        return None
    else:
        result=a*b
    for i in arg:
        if not isinstance(i, (int, float, long)):
            return None
        else:
            result *= i
    for j in kw.values():
        if  not isinstance(j, (int, float, long)):
            return None
        else:
            result *= j
    return result

調(diào)用函數(shù)的方式：
（1）mul(10,20,20,34,c=40,d=50)
（2）mul(10,20,(20,34),*{"c":40,"d":50})
（3）mul(10,20,30,40,f=20,(20,34),*{"c":40,"d":50})
等價(jià)于 tup=(20,34) dic={"c":40,"d":50}
mul(10,20,30,40,f=40,tup,*dic)

注意我們的元組和字典參數(shù)僅僅是被調(diào)函數(shù)中最終接收的元組和字典的子集

（四）匿名函數(shù)
python使用lambda來(lái)創(chuàng)建匿名函數(shù)。
（1）lambda只是一個(gè)表達(dá)式，函數(shù)體比def簡(jiǎn)單很多。
（2）lambda的主體是一個(gè)表達(dá)式，而不是一個(gè)代碼塊。僅僅能在lambda表達(dá)式中封裝有限的邏輯進(jìn)去。
（3）lambda函數(shù)擁有自己的命名空間，且不能訪問(wèn)自有參數(shù)列表之外或全局命名空間里的參數(shù)。
（4）雖然lambda函數(shù)看起來(lái)只能寫(xiě)一行，卻不等同于C或C++的內(nèi)聯(lián)函數(shù)，后者的目的是調(diào)用函數(shù)時(shí)不占用棧內(nèi)存從而增加運(yùn)行效率。
（5）lambda函數(shù)返回一個(gè)函數(shù)對(duì)象，如果沒(méi)有變量接受這個(gè)返回值，它很快就被丟棄，也正是由于lambda是一個(gè)表達(dá)式，所以它可以直接作為L(zhǎng)ist,dict的成員

def與lambda區(qū)別：
注：在def中，用return可以返回的可以放在lambda后面，不能用return返回的不能定義在lambda后.因此,像if或for或print這種語(yǔ)句就不能用于lambda中，lambda一般只用來(lái)定義簡(jiǎn)單的函數(shù)。

語(yǔ)法：
lambda函數(shù)的語(yǔ)法只包含一個(gè)語(yǔ)句：
lambda[arga,arg2……]:expression
幾個(gè)規(guī)則：
1.一般也就一行表達(dá)式，必須有返回值

不能有return?

可以沒(méi)有參數(shù)，可以有一個(gè)或多個(gè)參數(shù)

練習(xí)6：x的y次方

 >>> sum=lambda x,y:x**y
 >>> print sum(10,20)

練習(xí)7：

def make_repeater(n):
    return lambda s: s*n
twice = make_repeater(2)     #等價(jià)lambda s: s*2
print twice("word")          ##等價(jià)lambda s: "word"*2
print twice(5)              ###等價(jià)lambda s: 5*2

（五）全局變量和局部變量
定義在函數(shù)內(nèi)部的變量擁有一個(gè)局部作用域，定義在函數(shù)外的擁有全局作用域。
局部變量只能在其被聲明的函數(shù)內(nèi)部訪問(wèn)，而全局變量可以在整個(gè)程序范圍內(nèi)訪問(wèn)。調(diào)用函數(shù)時(shí)，所有在函數(shù)內(nèi)聲明的變量名稱(chēng)都將被加入到作用域中。

>>> total=0
>>> def sum(a,b):
...     total=a+b
...     print total
...     return total
>>> sum(10,20)            #結(jié)果 30 30
>>> print total             #結(jié)果 0

>>> total=0
>>> def sum(a,b):
...     global total
...     total=a+b
...     print total
...     return total
>>> sum(10,20)        #結(jié)果 30 30
>>> print total       #結(jié)果 30

總結(jié)：
1 函數(shù)中使用全局變量，聲明為global
2 否則當(dāng)局部變量使用，且局部變量都要在函數(shù)開(kāi)始的地方做賦值
3 如果函數(shù)中的變量沒(méi)有聲明為global，且在外部有同名的變量
則可以直接使用，如果進(jìn)行了賦值操作，則此變量變?yōu)榫植孔兞?br>且在使用前必須初始化賦值。