一、函數的返回值

In [4]: def add(x, y):
   ...:     return x+y
   ...: 

In [5]: add(1, 2)
Out[5]: 3


In [8]: def add(x, y):
   ...:     return x+y
   ...:     print(x+y)
   ...:     

In [9]: add(1, 2)
Out[9]: 3

In [16]: def add(x, y):
    ...:     return "abc", x+y
    ...:     return x+y
    ...:     

In [17]: add(1, 2)
Out[17]: (‘abc‘, 3)

  
In [18]: def add(x, y):
    ...:     return
    ...: 
    ...:     

In [19]: add(1, 2)

In [20]: a = add(1, 2)

In [21]: a

In [22]: type(a)
Out[22]: NoneType


In [25]: def add(x, y):
    ...:     return None
    ...: 

In [26]: add(1, 2)

In [27]: type(add(1, 2))
Out[27]: NoneType

關鍵字：return

return只能出現在函數中，可以返回任何對象，可以作為元祖變相的返回多個值

所有函數都有返回值，如果沒定義return則默認返回值None

return語句除了返回值之外還會結束函數

1個函數可以有多個return語句，但只會執行一個

二、作用域

1、函數嵌套

函數可以嵌套定義

In [28]: def outter():
    ...:     def inner():
    ...:         print(‘inner‘)
    ...:     print(‘outter‘)
    ...:     inner()
    ...:     

In [29]: outter()
outter
inner

2、作用域

作用域是一個變量的可見範圍

函數內部是一個局部作用域，外面叫全局作用域

不同作用域變量不可見，但是上級作用域的變量對下級只讀可見

In [32]: x = 1

In [33]: def inc():
    ...:     x += 1   # x此時是局部變量，不能直接使用全局作用域的變量
    ...:     

In [34]: inc()
---------------------------------------------------------------------------
UnboundLocalError                         Traceback (most recent call last)
<ipython-input-34-ae671e6b904f> in <module>()
----> 1 inc()

<ipython-input-33-661b9217054c> in inc()
      1 def inc():
----> 2     x += 1
      3 

UnboundLocalError: local variable ‘x‘ referenced before assignment


In [40]: x = 1

In [41]: def fn():
    ...:     print(x)   
    ...:     

In [42]: fn()    # 為什麽這裏能打印出來，不拋出錯誤呢
1

變量的作用域為定義此變量的作用域：

In [43]: def fn():
    ...:     name = "xxj"
    ...:     print(name)
    ...:     

In [44]: fn()
xxj

In [45]: name
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-45-18697449d7c4> in <module>()
----> 1 name

NameError: name ‘name‘ is not defined

上級作用域對下級作用域是只讀可見的

In [46]: def fn():
    ...:     xx = 1
    ...:     print(xx)
    ...:     def inner():
    ...:         print(xx)
    ...:     inner()
    ...:     

In [47]: fn()
1
1


In [48]: def fn():
    ...:     xx = 1
    ...:     print(xx)
    ...:     def inner():
    ...:         xx = 2
    ...:         print(xx)
    ...:     inner()
    ...:     print(xx)
    ...:     

In [49]: fn()
1
2
1

函數中可以顯式定義提升變量作用域，global的提升只在本作用域及上級作用域有效：

In [53]: xx = 1

In [54]: def fn():
    ...:     global xx    # global關鍵字能顯式的提升1個變量的作用域
    ...:     xx += 1
    ...:     

In [55]: fn()

In [56]: xx
Out[56]: 2

In [57]: fn()

In [58]: xx
Out[58]: 3



In [68]: xxj
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-68-bc382da45e82> in <module>()
----> 1 xxj

NameError: name ‘xxj‘ is not defined

In [69]: def fn():
    ...:     global xxj     # 如果此變量沒有定義，則此提升變量作用域沒有意義 
    ...:     
    ...:     

In [70]: fn()

In [71]: xxj
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-71-bc382da45e82> in <module>()
----> 1 xxj

NameError: name ‘xxj‘ is not defined

除非你清楚的知道global會帶來什麽，並且明確的知道沒有global不行的話，否則不要用global；就是不建議使用global關鍵字

3、命名空間與LEGB

1）命名空間

理解Python的LEGB原則是理解Python命名空間的關鍵，而理解Python的命名空間又是理解Python中許多語法規定的關鍵。所以，Python的LEGB原則就成為Python中一個非常核心的內容

白話一點講：命名空間是對變量名的分組劃分。
不同組的相同名稱的變量視為兩個獨立的變量，因此隸屬於不同分組（即命名空間）的變量名可以重復。
命名空間可以存在多個，使用命名空間，表示在該命名空間中查找當前名稱。

命名空間表示變量的可見範圍，一個變量名可以定義在多個不同的命名空間，相互之間並不沖突，但同一個命名空間中不能有兩個相同的變量名。

比如：兩個叫“張三”的學生可以同時存在於班級A和班級B中，如果兩個張三都是一個班級，那麽帶來的麻煩復雜很多了，在Python中你不能這麽幹。

在Python中用字典來表示一個命名空間，命名空間中保存了變量（名字）和對象的映射關系，在Python中命名空間出現在哪些地方呢？有函數範圍內的命名空間（local），有模塊範圍內的命名空間（global），有python內建的命名空間（built-in），還有類對象的所有屬性組成的命名空間

Python一切皆對象，所以在Python中變量名是字符串對象

例如：

表示建立字符串對象a與Number對象10之間的對應關系。由於這是一種映射關系，所以，可以使用鍵-值的形式來表示，即{name : object}。
前面已經說過，命名空間是對變量名的分組劃分，所以，Python的命名空間就是對許多鍵-值對的分組劃分，即，鍵值對的集合，因此：

Python的命名空間是一個字典，字典內保存了變量名稱與對象之間的映射關系

2）命名空間的生命周期

所有的命名空間都是有生命周期的，對於python內建的命名空間，python解析器啟動時創建，一直保留直至直python解析器退出時才消亡。而對於函數的local命名空間是在函數每次被調用的時候創建，調用完成函數返回時消亡，而對於模塊的global命名空間是在該模塊被import的時候創建，解析器退出時消亡。

3）作用域

一個作用域是指一段程序的正文區域，可以是一個函數或一段代碼。

一個變量的作用域是指該變量的有效範圍。Python的作用域是靜態作用域，因為它是由代碼中得位置決定的，而命名空間就是作用域的動態表現。

函數定義了本地作用域，而模塊定義了全局作用域：

每個模塊都是一個全局作用域，因此，全局作用域的範圍僅限於單個程序文件

每次對函數的調用都會創建一個新的本地作用域，賦值的變量除非聲明為全局變量，否則均為本地變量

所有的變量名都可以歸納為本地，全局或內置的（由__builtin__模塊提供）

4）LEGB原則

LEGB含義解釋：
L-Local(function)；函數內的名字空間
E-Enclosing function locals；外部嵌套函數的名字空間(例如closure)
G-Global(module)；函數定義所在模塊（文件）的名字空間
B-Builtin(Python)；Python內置模塊的名字空間，builtin作用域，對應builtin命名空間，python內部定義的最頂層的作用域，在這個作用域裏面定義了各種內建函數：open、range、xrange、list等等

前面講到，Python的命名空間是一個字典，字典內保存了變量名與對象之間的映射關系，

因此，查找變量名就是在命名空間字典中查找鍵-值對。
Python有多個命名空間，因此，需要有規則來規定，按照怎樣的順序來查找命名空間，LEGB就是用來規定命名空間查找順序的規則。

LEGB規定了查找一個名稱的順序為：local-->enclosing function locals-->global-->builtin

三、閉包

當一個函數結束了，函數的內部部分變量引用還存在，這就叫閉包

python的閉包可以使用可變容器實現，這也是python2唯一的方式

In [91]: def counter():
    ...:     c = [0]
    ...:     def inc():
    ...:         c[0] += 1
    ...:         return c
    ...:     return inc
    ...: 

In [92]: type(counter)
Out[92]: function

In [93]: type(counter())
Out[93]: function

In [94]: type(counter()())
Out[94]: list

In [95]: f = counter()

In [96]: f()
Out[96]: [1]

In [97]: f()
Out[97]: [2]

In [98]: f()
Out[98]: [3]

nonlocal關鍵字：

nonlocal用於標記一個變量由它的上級作用域定義，通過nonlocal標記的變量可讀可寫

如果nonlocal標記的變量不存在則會拋出語法錯誤

In [102]: def counter():
     ...:     x = 0
     ...:     def inc():
     ...:         nonlocal x
     ...:         x += 1
     ...:         return x
     ...:     return inc
     ...: 

In [103]: f = counter()

In [104]: f()
Out[104]: 1

In [105]: f()
Out[105]: 2

In [106]: f()
Out[106]: 3

【函數】02、函數進階