摘要：缺省參數就是給參數設定默認值，如果在傳參過程中，缺省參數傳入值的話則依照傳入的值，如果沒有傳入值則按照默認的值。

python基礎3
1、函數基本語法及特性
2、函數參數
3、局部變量和全局變量
4、返回值
嵌套函數
5、遞歸函數
6、匿名函數
7、高階函數
8、內置函數
9、函數式編程

在編程語言中的函數并非數學意義上的函數(總是返回根據參數計算得到的結果)，編程語言中的函數也稱為過程，在使用這個函數的時候有可能不會返回一個結果或者說返回的結果不是數學意義上的函數執行的結果。

抽象是程序能夠被別人理解的關鍵所在(無論對編寫程序還是閱讀程序來說，這都至關重要)。
程序應非常抽象，如下載網頁、計算使用頻率、打印每個單詞的使用頻率。下面將上述簡單描述轉換為一個Python程序：

page = download_page()
freqs = compute_frequencies(page)
for word, freq in freqs:
    print(word, freq)

看到這些代碼，任何人都知道這個程序是做什么的。至于具體該如何做那么我們就得在函數中得出定義。

在比如打印斐波那契數(一種數列，其中每個數都是前兩個數的和)

fibs = [0,1]
for i in range(8):
    fibs.append(fibs[-2] + fibs[-1])
print(fibs)

上述代碼會打印出斐波那契數的前十個，當然你也可以指定要打印數的個數：

num = int(input("How many Fibonacci numbers do you want?"))
fib = [0,1]
for i in range(num-2):
    fibs.append(fibs[-2] + fibs[-1])
print(fibs)

當我們在其他地方想使用這些數的時候，你可能會想到我再把這個循環再寫一次，對于這段代碼是可以的，但是對于更加復雜的代碼你還愿意去重寫嗎？真正的程序員會去抽象程序，把一些想要實現的功能抽象為函數，直接調用這個函數來實現指定的功能，讓程序更加簡潔、易懂并且降低代碼的重復率。真正的程序員會像下面這樣做：

num = int(input("How many Fibonacci numbers do you want?"))
print(fibs(num))

def 函數名():
    函數體

例如：

def hello():
    print("Hello world!")

要給函數編寫文檔，以確保其他人能夠理解，可添加注釋。放在函數開頭的字符串成為文檔字符串(docstring)，將作為函數的一部分存儲起來。例如：

def square(x):
    "Calculates the square of the number x."
    return x * x

可以像下面這樣訪問文檔字符串：

>>> square.__doc__
"Calculates the square of the number x."

特殊的內置函數help很有用。在交互式解釋器中，可使用它獲取有關函數的信息，其中包含函數的文檔字符串。

>>> help(square)
Help on function square in module __main__:
square(x)
Calculates the square of the number x.

為了讓一個函數更通用，在定義函數的時候可以讓函數接收數據，函數接收的數據就是函數的參數。

示例如下：

def add(a,b):
    c = a + b
    print(c)

以上面的add函數為例，我們調用該函數，代碼如下：

def add(a,b):
    c = a + b
    print(c)
   
add(11,22)   #調用帶參數的函數時，需要在小括號中傳遞數據

>>> def test(a,b):
...     print(a,b)
... 
>>> test(1,2)
1 2
>>> test(b=1,a=2)
2 1
>>> 
>>> test(b=1,2)
  File "", line 1
SyntaxError: positional argument follows keyword argument
>>> 
>>>

通過以上代碼我們可以看出，函數的參數在調用的過程中是一一對應的，如果不指定那個實參是那個對應的形參時，會默認按實參的順序將實參賦值給形參。

定義時小括號中的參數，用來接收參數用的，稱為“形參”

調用時小括號中的參數，用來傳遞給函數的，稱為“實參”

調用函數時，缺省參數的值如果沒有傳入，則被認為是默認值。缺省參數就是給參數設定默認值，如果在傳參過程中，缺省參數傳入值的話則依照傳入的值，如果沒有傳入值則按照默認的值。如下代碼：

def sum(a,b=11):
    result = a + b 
    print("%d+%d=%d"%(a,b,result))

sum(11,22)    #調用函數時會將11和22分別賦值給a和b
sum(10,)      #調用函數時，由于只給了一個實參，則10賦值給a，b則用默認的參數值11

程序運行結果如下：

注意：帶有默認值的參數一定要位于參數列表的最后面。

>>> def printinfo(name, age=35, sex):
...     print name
...
  File "", line 1
SyntaxError: non-default argument follows default argument

有時可能需要一個函數能處理比當初聲明時更多的參數，這些參數叫做不定長參數，聲明時不會命名。

基本語法如下：

def functionname([formal_args,] *args, **kwargs):
    "函數_文檔字符串"
    function_suite
    return [expression]

加*號的變量args會存放所有未命名的變量參數，args為元組
加**號的變量kwargs會存放命名參數，即形如key=value的參數，kwargs為字典

可變參數示例：

>>> def fun(a, b, *args, **kwargs):
...     """可變參數演示示例"""
...     print "a =", a
...     print "b =", b
...     print "args =", args
...     print "kwargs: "
...     for key, value in kwargs.items():
...         print key, "=", value
...
>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意傳遞的參數對應
a = 1
b = 2
args = (3, 4, 5)
kwargs: 
p = 8
m = 6
n = 7
>>>
>>>
>>> c = (3, 4, 5)
>>> d = {"m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d)    # 注意元組與字典的傳參方式
a = 1
b = 2
args = (3, 4, 5)
kwargs: 
p = 8
m = 6
n = 7
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星號與上面的區別
a = 1
b = 2
args = ((3, 4, 5), {"p": 8, "m": 6, "n": 7})
kwargs:
>>>
>>>

可變類型與不可變類型的變量分別作為函數參數時，會有什么不同？

Python有沒有類似C語言中的指針傳參？

>>> def selfAdd(a):
...     """自增"""
...     a += a
...
>>> a_int = 1
>>> a_int
1
>>> selfAdd(a_int)
>>> a_int
1
>>> a_list = [1, 2]
>>> a_list
[1, 2]
>>> selfAdd(a_list)
>>> a_list
[1, 2, 1, 2]

Python中函數參數是引用傳遞(注意不是值傳遞)。對于不可變類型，因變量不能修改，所以運算不會影響到變量自身；而對于可變類型來說，函數體中的運算可能會更改傳入的參數變量。

如下代碼示例：

>>> def selfAdd(a):
...     """自增"""
...     a = a + a   # 我們更改了函數體的這句話
...
>>> a_int = 1
>>> a_int
1
>>> selfAdd(a_int)
>>> a_int
1
>>> a_list = [1, 2]
>>> a_list
[1, 2]
>>> selfAdd(a_list)
>>> a_list
[1, 2]      # 想一想為什么沒有變呢？

Python中變量之間的賦值利用到引用，只要是有"="就是引用，引用就是變量中存儲的是地址，而地址指向的內存空間是存真實數據地方。a = a + a會創建一個新的內存空間，然后讓變量a指向這段空間；而a += a是將a所指向的那段空間的值變為a + a。如下demo：

>>> a = [1,2]
>>> id(a)
31329224
>>> a = a + a
>>> a
[1, 2, 1, 2]
>>> id(a)
31991944
>>> b = 2
>>> id(b)
1587990368
>>> b = b + b
>>> b
4
>>> id(b)
1587990432
>>> c = [1,2]
>>> id(c)
31992072
>>> c += c
>>> c
[1, 2, 1, 2]
>>> id(c)
31992072
>>>

局部變量，就是定義在函數內部的變量，其作用單位只是在函數體內；

不同的函數，可以定義相同名字的局部變量，其不會產生影響；

局部變量的作用：為了臨時保存數據需要在函數中定義變量來進行存儲。

示例：

def test1():
    a = 100     #此時的a為局部變量，作用范圍只在test1函數內
def test2():
    print("a=%d"%a)
    
test1()
test2()

此時由于a是局部變量，其做作用范圍只在test1函數中，相當于test2函數中沒有定義變量a，所以上述程序在運行時會報如下錯誤：

如果一個變量既能在函數體中使用，也能在其他函數中使用，這樣的變量稱為全局變量。

示例：

#定義全局變量
a = 100

def test1():
    print("a=%d"%a)

def test2():
    print("a=%d"%a)

#調用函數
test1()
test2()         

由于變量a是全局變量，所以在test1和test2兩個函數中都可以使用變量a，運行結果如下：

當全局變量與局部變量同名時，在定義該局部變量的函數體內以局部變量為主，如下示例：

#定義全局變量
a = 100 

def test1():
    a = 300 
    print("---test1--修改前--a=%d"%a)
    a = 200 
    print("---test1--修改后--a=%d"%a)

def test2():
    print("---test2---a=%d"%a)

test1()
test2()

此時，對于test1函數，函數體內定義了和全部變量同名的局部變量a，此時會以函數中的變量a為根據；對于test2函數，函數體內沒有定義和全局變量同名的局部變量，所以如果test2函數使用變量a，則以全部變量a為根據。運行結果如下：

既然是全局變量，就可以在所有的函數中是，那么是否可以修改呢？看如下代碼：

#定義全局變量
a = 100 

def test1():
    global a
    print("---test1--修改前--a=%d"%a)
    a = 200 
    print("---test1--修改后--a=%d"%a)

def test2():
    print("---test2---a=%d"%a)

test1()
test2()

代碼運行結果如下：

在函數體內利用global這個關鍵字來聲明變量為全局變量，此時在函數體內對該變量的操作就是相當于對全局變量的操作。

看下面兩個代碼示例的區別：

#定義全局變量
a = 100 

def test1():
    print("---test1--修改前--a=%d"%a)
    a = 200 
    print("---test1--修改后--a=%d"%a)

def test2():
    print("---test2---a=%d"%a)

test1()
test2()

上述代碼運行結果為：

#定義全局變量
a = [11,22,33]

def test1():
    print("---test1--修改前--",a)
    a.append(44)
    print("---test1--修改前--",a)

def test2():
    print("---test2--修改前--",a)

test1()
test2()

上述代碼運行結果為：

對于上述兩種情況，列表(list)、字典(dict)這種可變的類型的全局變量不用再函數體內聲明全局變量，在函數體中對該變量的操作就是在對全局變量進行操作；而像數值類型(int,flaot,bool,long)、字符串(str)、元組(tuple)這種不可變類型的操作，要想在函數體內對這種全局變量進行操作，必須在函數體內聲明其為全局變量。

在函數外邊定義的變量叫全局變量

全局變量能夠在所有的函數中進行訪問

如果在函數中修改全局變量，那么就需要使用global進行聲明

如果全局變量的名字和局部變量的名字相同，那么使用的是局部變量的，小技巧強龍不壓地頭蛇

在函數中不使用global聲明全局變量時不能修改全局變量的本質是不能修改全局變量的指向，即不能將全局變量指向新的數據

對于不可變類型的全局變量來說，因其指向的數據不能修改，所以不能使用global時無法修改全局變量

對于可變類型的全局變量來說，因其指向的數據可以修改，所以不使用global時也可修改全局變量

“返回值”，就是程序中函數完成一件事情后，最后給調用者返回的結果。

想要在函數中把結果返回給調用者，需要在函數中使用return
如下示例：

def add2num(a, b):
    c = a+b
    return c
或者
def add2num(a, b):
    return a + b

在程序中，如果一個函數返回了一個數據，那么想要用這個數據，就需要用一個變量來保存函數返回的數據。示例如下：

#定義函數
def add2num(a, b):
    return a+b

#調用函數，順便保存函數的返回值
result = add2num(100,98)

#因為result已經保存了add2num的返回值，所以接下來就可以使用了
print result

3、Python返回多值
看如下代碼：

def test(a,b):
    sum2 = a + b 
    mulit = a * b 
    return [sum2,mulit]

result = test(2,3)
print(result)

運行結果為：

[5,6]

def test(a,b):
    sum2 = a + b 
    mulit = a * b 
    return sum2,mulit

result = test(2,3)
print(result)

運行結果為：

(5,6)

由上述示例我們可以得出，當有多個返回值時，利用列表將結果返回，那么函數就會返回一個列表；當將幾個返回值用逗號隔開返回時，默認返回的是元組。