[TOC]
# 函數
## 文法
* ` def 函數名():`
~~~ python
def hello():
print 'Hello Shihongji'
hello()
~~~
## 參數
* func(無預設值形參, 有預設值形參, 元組參數*args, 字典參數**args)
* 例：`def func(x, y, z = 1, *tupleArgs, **dicArgs1)`
~~~ python
'''
普通參數
* def hello(參數1,參數2,參數3....)
'''
def sayHello(name):
print 'Hello ' + str(name)
sayHello('Shihongji')
sayHello(123)
'''
預設參數(設定預設值的參數)
* def hello(name='123')
* 當函數有多個參數時，如果你想給部分參數提供預設參數，那麼這些參數必須在參數的末尾。
* def func(a, b=5) 可以
* def func(a=5, b) 不可以
'''
def sayHello1(name = 'World'):
print 'Hello ' + str(name)
sayHello1()
sayHello1("Shihongji")
'''
元組參數
* def func(*args)
'''
def calcSum(*args):
sum = 0
for i in args:
sum += i
print i
print sum
calcSum(1,2,3,4,5,6,7,8,9)
'''
字典參數
* func(**kargs)
* 把參數以鍵值對字典的形式傳入
* 字典是無序的，是以輸出的結果不是按照順序輸出的
'''
def printAll(**args):
for key in args:
print key,':',args[key]
printAll(a=1,b=2,c=3,d=4)
'''
四種方式混合使用
* 形參順序(必須遵守)：func(無預設值形參, 有預設值形參, 元組參數*args, 字典參數**args)
* 可以省略某種類型的參數，但仍需保證此順序規則。
在函數被調用時，參數的傳遞過程為：
* 按順序把無指定參數的實參指派給形參；
* 把指定參數名稱(arg=v)的實參指派給對應的形參；
* 将多餘的無指定參數的實參打包成一個 tuple 傳遞給元組參數(*args)；
* 将多餘的指定參數名的實參打包成一個 dict 傳遞給字典參數(**kargs)。
'''
def func(x,y=5,*a,**b):
print x,y,a,b
func(1) #結果：1 5 () {}
func(1,2) #結果：1 2 () {}
func(1,2,3) #結果：1 2 (3,) {}
func(1,2,3,4) #結果：1 2 (3, 4) {}
func(x=1) #結果：1 5 () {}
func(x=1,y=1) #結果：1 1 () {}
func(x=1,y=1,a=1) #結果：1 1 () {'a': 1}
func(x=1,y=1,a=1,b=1) #結果：1 1 () {'a': 1, 'b': 1}
func(1,y=1) #結果：1 1 () {}
func(1,2,3,4,a=1) #結果：1 2 (3, 4) {'a': 1}
func(1,2,3,4,k=1,t=2,o=3) #結果：1 2 (3, 4) {'k': 1, 't': 2, 'o': 3}
~~~
## 參數反轉
* 使用*号運算符
~~~ python
def add(x, y):
return x + y
>>> params = (1, 2)
>>> print add( *params ) # 3
~~~
* 使用**運算符
~~~ python
def hello(name = 'shihongji', greeting = 'Hello'):
print greeting, name
>>> params = {'name':'hongji', 'greeting':'Well met'}
>>> hello( **params ) # hongji Well met
~~~
~~~ python
def foo(x, y, z, m = 0, n = 0):
print x, y, z, m, n
>>> tup = (1,2,3)
>>> dic = {'m':1, 'n':2}
>>> foo(*tup, **dic)
結果：
======================
1 2 3 1 2
======================
~~~
# vars()函數
* 變量和所對應的值是個不可見的字典，vars()函數可以傳回該字典
~~~ python
>>> ccc = 1 # 實質是一個不可見的字典
>>> dic = vars()
>>> print dic
>>> print dic['ccc']
結果：
==================================
>>> {'ccc': 1}
>>> 1
==================================
~~~
# globals()函數
* 傳回全局變量的字典
~~~ python
>>> hello = 'Hello'
>>> hongji = 'hongji'
>>> print globals()
結果：
=================================
>>> {'hongji': 'hongji', 'hello': 'Hello'}
=================================
~~~
* 如果局部變量或參數的名字和想要通路的全局變量名相同的話， 可以使用globals()函數擷取全局變量值
~~~ python
>>> parameter = 'berry'
def combin(parameter):
print parameter , globals()['parameter']
>>> combin('Shrub') # Shrub berry
~~~
# global 全局變量語句
* Python中如果在函數内部給全局變量指派，那該變量會自動轉為局部變量
~~~ python
>>> x = 1
def add():
x = x + 1
print x
>>> add()
>>> print x
結果：
==================================
>>> local variable 'x' referenced before assignment 的異常
代碼 x = x + 1: 在函數内給全局變量x指派，導緻變量x自動轉為了局部變量
x + 1 中x變量還沒有被聲明就開始使用，是以會報錯
=================================
~~~
* 函數内使用golbal 通路全局變量
~~~ python
>>> x = 1
def abcd():
global x
x = x + 1
print x # 2
>>> print x # 1
>>> abcd()
>>> print x # 2
~~~
# 嵌套作用域
* Python中函數可以嵌套
* 在需要用一個函數建立另一個函數時使用
* 外層函數傳回裡層函數
* 傳回的函數還可以通路他定義所在的作用域(它帶着它的相關環境和先關局部變量)
* 每次調用外層函數，它内部的函數都會被重新定義
~~~ python
def mul(factor):
def mulByFactor(number):
print factor * number
return mulByFactor # 傳回裡層函數mulByFactor
>>> mbf = mul(5)
>>> print type(mbf)
>>> mbf(5) # 25
>>> mul(10)(2) # 20
~~~
傳回頂部