1.對缺省參數的理解。給出代碼
缺省參數在python中是與函數綁定在一起的。
也就是說，一個函數中定義了一個缺省參數，那么這個參數會隨著被調用而改變。
def extendList(val, list=[]):
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123, [])
list3 = extendList('a')
print("list1 = %s" % list1)
print("list2 = %s" % list2)
print("list3 = %s" % list3)
結果為：
list1 = [10, 'a']
list2 = [123]
list3 = [10, 'a']
解釋說明：
許多人會錯誤的認為 list1 應該等于 [10] 以及 list3 應該等于 ['a']。認為 list 的參數會在 extendList 每次被調用的時候會被設置成它的默認值 []。
盡管如此，實際發生的事情是，新的默認列表list僅僅只在函數被定義時創建一次。隨后當 extendList 沒有被指定的列表參數調用的時候，其使用的是同一個列表list。
因此，list1 和 list3 是操作的相同的列表（也就是[]對象的引用相同，id值也就相同）。而list2是操作它創建獨立的列表（通過傳遞它自己的空列表作為list參數的值）
所以這一點一定要切記切記.
下面代碼，我們把list置為None就可以避免一些麻煩了
def extendList(val, list=None):
if list is None:
list = []
list.append(val)
return list
結果為：
list1 = [10]
list2 = [123]
list3 = ['a']
None是一個常量， 是一個不可變對象， 每次調用myfunc()時value都是None。
但是id值每次都是不同的，每次 list都是一個新的 list，因此每次 id(value) 都不一樣。
2.對裝飾器的理解。給出代碼
- 函數
在python中，函數通過def關鍵字、函數名和可選的參數列表定義。通過return關鍵字返回值。我們舉例來說明如何定義和調用一個簡單的函數：
def foo():
return 1
foo()
1
方法體（當然多行也是一樣的）是必須的，通過縮進來表示，在方法名的后面加上雙括號()就能夠調用函數
- 作用域
在python中，函數會創建一個新的作用域。
python開發者可能會說函數有自己的命名空間，差不多一個意思。
這意味著在函數內部碰到一個變量的時候函數會優先在自己的命名空間里面去尋找。讓我們寫一個簡單的函數看一下 本地作用域 和 全局作用域有什么不同：
a_string = "This is a global variable"
def foo():
print locals()
print globals() # doctest: +ELLIPSIS
{, 'a_string': 'This is a global variable'}
foo() # 2
{}
內置的函數globals返回一個包含所有python解釋器知道的變量名稱的字典（為了干凈和洗的白白的，我省略了python自行創建的一些變量）。在#2我調用了函數 foo 把函數內部本地作用域里面的內容打印出來。我們能夠看到，函數foo有自己獨立的命名空間，雖然暫時命名空間里面什么都還沒有。
- 變量解析規則
當然這并不是說我們在函數里面就不能訪問外面的全局變量。在python的作用域規則里面，創建變量一定會在當前作用域里創建一個變量，但是訪問或者修改變量時會先在當前作用域查找變量，沒有找到匹配變量的話會依次向上在閉合的作用域里面進行查找。所以如果我們修改函數foo的實現讓它打印全局的作用域里的變量也是可以的：
a_string = "This is a global variable"
def foo():
print a_string # 1
foo()
This is a global variable
在#1處，python解釋器會嘗試查找變量a_string，當然在函數的本地作用域里面是找不到的，所以接著會去上層的作用域里面去查找。
但是另一方面，假如我們在函數內部給全局變量賦值，結果卻和我們想的不一樣：
a_string = "This is a global variable"
def foo():
a_string = "test" # 1
print locals()
foo()
{'a_string': 'test'}
a_string # 2
'This is a global variable'
我們能夠看到，全局變量能夠被訪問到（如果是可變數據類型(像list,dict這些)甚至能夠被更改）但是賦值不行。在函數內部的#1處，我們實際上新創建了一個局部變量，隱藏全局作用域中的同名變量。我們可以通過打印出局部命名空間中的內容得出這個結論。我們也能看到在#2處打印出來的變量a_string的值并沒有改變。
- 變量生存周期
值得注意的一個點是，變量不僅是生存在一個個的命名空間內，他們都有自己的生存周期，請看下面這個例子：
def foo():
x = 1
foo()
print x # 1
Traceback (most recent call last):
NameError: name 'x' is not defined
#1處發生的錯誤不僅僅是因為作用域規則導致
的（盡管這是拋出了NameError的錯誤的原因）
它還和python以及其它很多編程語言中函數調用
實現的機制有關。在這個地方這個執行時間點并
沒有什么有效的語法讓我們能夠獲取變量x的值，因為它這個時候壓根不存在！函數foo的命名空間隨著函數調用開始而開始，結束而銷毀。
- 函數參數
python允許我們向函數傳遞參數，參數會變成本地變量存在于函數內部。
def foo(x):
print locals()
foo(1)
{'x': 1}
在Python里有很多的方式來定義和傳遞參數，完整版可以查看 python官方文檔。我們這里簡略的說明一下：函數的參數可以是必須的位置參數或者是可選的命名參數（也叫默認參數）或者可變參數或者關鍵字參數。
def foo(x, y=0): # 1
return x - y
foo(3, 1) # 2
2
foo(3) # 3
3
foo() # 4
Traceback (most recent call last):
TypeError: foo() takes at least 1 argument (0 given)
foo(y=1, x=3) # 5
2
在#1處我們定義了函數foo,它有一個位置參數x和一個命名參數y。
在#2處我們能夠通過常規的方式來調用函數，盡管有一個命名參數，但參數依然可以通過位置傳遞給函數。在調用函數的時候，對于命名參數y我們也可以完全不管就像#3處所示的一樣。如果命名參數沒有接收到任何值的話，python會自動使用聲明的默認值也就是0。需要注意的是我們不能省略第一個位置參數x, 否則的話就會像#4處所發生錯誤。
目前還算簡潔清晰吧， 但是接下來可能會有點令人困惑。python支持函數調用時的命名參數（個人覺得應該是命名實參）。看看#5處的函數調用，我們傳遞的是兩個命名實參，這個時候因為有名稱標識，參數傳遞的順序也就不用在意了。
當然相反的情況也是正確的：函數的第二個形參是y，但是我們通過位置的方式傳遞值給它。在#2處的函數調用foo(3,1)，我們把3傳遞給了第一個參數x，把1傳遞給了第二個參數y，盡管第二個參數是一個命名參數。
桑不起，感覺用了好大一段才說清楚這么一個簡單的概念：函數的參數可以有名稱和位置。這意味著在函數的定義和調用的時候會稍稍在理解上有點兒不同。我們可以給只定義了位置參數的函數傳遞命名參數（實參），反之亦然！如果覺得不夠可以查看官方文檔
- 嵌套函數
Python允許創建嵌套函數。這意味著我們可以在函數里面定義函數而且現有的作用域和變量生存周期依舊適用。
def outer():
x = 1
def inner():
print x # 1
inner() # 2
outer()
1
這個例子有一點兒復雜，但是看起來也還行。
想一想在#1發生了什么：python解釋器需找一個叫x的本地變量，查找失敗之后會繼續在上層的作用域里面尋找，這個上層的作用域定義在另外一個函數里面。對函數outer來說，變量x是一個本地變量，但是如先前提到的一樣，函數inner可以訪問封閉的作用域（至少可以讀和修改）。在#2處，我們調用函數inner，非常重要的一點是，inner也僅僅是一個遵循python變量解析規則的變量名，python解釋器會優先在outer的作用域里面對變量名inner查找匹配的變量.
- 函數是python世界里的一級類對象
顯而易見，在python里函數和其他東西一樣都是對象。（此處應該大聲歌唱）啊！包含變量的函數，你也并不是那么特殊！
issubclass(int, object) # all objects in Python inherit from a common baseclass
True
def foo():
pass
foo.__class__ # 1
<type 'function'>
issubclass(foo.__class__, object)
True
你也許從沒有想過，你定義的函數居然會有屬性。沒辦法，函數在python里面就是對象，和其他的東西一樣，也許這樣描述會太學院派太官方了點：在python里，函數只是一些普通的值而已和其他的值一毛一樣。這就是說你可以把函數當參數一樣傳遞給其他的函數或者說從函數里面返回函數！如果你從來沒有這么想過，那看看下面這個例子：
def add(x, y):
return x + y
def sub(x, y):
return x - y
def apply(func, x, y): # 1
return func(x, y) # 2
apply(add, 2, 1) # 3
3
apply(sub, 2, 1)
1
這個例子對你來說應該不會很奇怪。add和sub是非常普通的兩個python函數，接受兩個值，返回一個計算后的結果值。
在#1處你們能看到準備接收一個函數的變量只是一個普通的變量而已，和其他變量一樣。在#2處我們調用傳進來的函數：“()”代表著調用的操作并且調用變量包含的值。
在#3處，你們也能看到傳遞函數并沒有什么特殊的語法。
函數的名稱只是與其他變量一樣的標識符而已。
你們也許看到過這樣的行為：“python把頻繁要用的操作變成函數作為參數進行使用，想通過傳遞一個函數給內置排序函數的key參數，從而來自定義排序規則。”
那把函數當做返回值回事這樣的情況呢：
def outer():
def inner():
print "Inside inner"
return inner # 1
foo = outer() #2
foo # doctest:+ELLIPSIS
<function inner at 0x>
foo()
Inside inner
這個例子看起來也許會更加的奇怪。在#1處我把恰好是函數標識符的變量inner作為返回值返回出來。這并沒有什么特殊的語法：”把函數inner返回出來，否則它根本不可能會被調用到。“還記得變量的生存周期嗎？每次函數outer被調用的時候，函數inner都會被重新定義，如果它不被當做變量返回的話，每次執行過后它將不復存在，也就是沒有變量來接收返回的值。
在#2處我們捕獲住返回值 – 函數inner，將它存在一個新的變量foo里。
我們能夠看到，當對變量foo進行求值，它確實包含函數inner，而且我們能夠對他進行調用。初次看起來可能會覺得有點奇怪，但是理解起來并不困難是吧。堅持住，因為奇怪的轉折馬上就要來了
- 閉包
我們先不急著定義什么是閉包，先來看看一段代碼，僅僅是把上一個例子簡單的調整了一下：
def outer():
x = 1
def inner():
print x # 1
return inner
foo = outer()
foo.func_closure
(<cell at 0x: int object at 0x>,)
在上一個例子中我們了解到，inner作為一個函數被outer返回，保存在一個變量foo，并且我們能夠對它進行調用foo()。不過它會正常的運行嗎？我們先來看看作用域規則。
所有的東西都在python的作用域規則下進行工作：“x是函數outer里的一個局部變量。當函數inner在#1處打印x的時候，python解釋器會在inner內部查找相應的變量，當然會找不到，所以接著會到封閉作用域里面查找，并且會找到匹配。
但是從變量的生存周期來看，該怎么理解呢？我們的變量x是函數outer的一個本地變量，這意味著只有當函數outer正在運行的時候才會存在。根據我們已知的python運行模式，我們沒法在函數outer返回之后繼續調用函數inner，在函數inner被調用的時候，變量x早已不復存在，可能會發生一個運行時錯誤。
萬萬沒想到，返回的函數inner居然能夠正常工作。Python支持一個叫做函數閉包的特性，用人話來講就是，嵌套定義在非全局作用域里面的函數能夠記住它在被定義的時候它所處的封閉命名空間。
這能夠通過查看函數的(py2是func_closure，py3是-closure-)屬性得出結論，這個屬性里面包含封閉作用域里面的值（只會包含被捕捉到的值（或者叫被引用的值），比如x，如果在outer里面還定義了其他的值，封閉作用域里面是不會有的)
記住，每次函數outer被調用的時候，函數inner都會被重新定義。現在變量x的值不會變化，所以每次返回的函數inner會是同樣的邏輯，假如我們稍微改動一下呢？
def outer(x):
def inner():
print x # 1
return inner
print1 = outer(1)
print2 = outer(2)
print1()
1
print2()
2
從這個例子中你能夠看到閉包 – 被函數記住的封閉作用域 – 能夠被用來創建自定義的函數，本質上來說是一個硬編碼的參數。事實上我們并不是傳遞參數1或者2給函數inner，我們實際上是創建了能夠打印各種數字的各種自定義版本。
閉包單獨拿出來就是一個非常強大的功能， 在某些方面，你也許會把它當做一個類似于面向對象的技術：outer像是給inner服務的構造器，x像一個私有變量。
不過，我們現在不會用閉包做這么low的事(⊙o⊙)…！相反，讓我們再爽一次，寫一個高大上的裝飾器!
- 裝飾器
裝飾器其實就是一個閉包，把一個函數當做參數然后返回一個替代版函數。我們一步步從簡到繁來瞅瞅：
def outer(some_func):
def inner():
print "before some_func"
ret = some_func() # 1
return ret + 1
return inner
def foo():
return 1
decorated = outer(foo) # 2
decorated()
before some_func
2
仔細看看上面這個裝飾器的例子。們定義了一個函數outer，它只有一個some_func的參數，在他里面我們定義了一個嵌套的函數inner。inner會打印一串字符串，然后調用some_func，在#1處得到它的返回值。在outer每次調用的時候some_func的值可能會不一樣，但是不管some_func的值如何，我們都會調用它。最后，inner返回some_func() + 1的值 – 我們通過調用在#2處存儲在變量decorated里面的函數能夠看到被打印出來的字符串以及返回值2，而不是期望中調用函數foo得到的返回值1。
我們可以認為變量decorated是函數foo的一個裝飾版本，一個加強版本。事實上如果打算寫一個有用的裝飾器的話，我們可能會想愿意用裝飾版本完全取代原先的函數foo，這樣我們總是會得到我們的”加強版“foo。想要達到這個效果，完全不需要學習新的語法，簡單的賦值給變量foo就行了：
foo = outer(foo)
foo # doctest: +ELLIPSIS
<function inner at 0x>
現在，任何怎么調用都不會牽扯到原先的函數foo，都會得到新的裝飾版本的foo，現在我們還是來寫一個有用的裝飾器。
想象我們有一個庫，這個庫能夠提供類似坐標的對象，也許它們僅僅是一些x和y的坐標對。不過可惜的是這些坐標對象不支持數學運算符，而且我們也不能對源代碼進行修改，因此也就不能直接加入運算符的支持。我們將會做一系列的數學運算，所以我們想要能夠對兩個坐標對象進行合適加減運算的函數，這些方法很容易就能寫出：
class Coordinate(object):
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return "Coord: " + str(self.__dict__)
def add(a, b):
return Coordinate(a.x + b.x, a.y + b.y)
def sub(a, b):
return Coordinate(a.x - b.x, a.y - b.y)
one = Coordinate(100, 200)
two = Coordinate(300, 200)
add(one, two)
Coord: {'y': 400, 'x': 400}
如果不巧我們的加減函數同時也需要一些邊界檢查的行為那該怎么辦呢？搞不好你只能夠對正的坐標對象進行加減操作，任何返回的值也都應該是正的坐標。所以現在的期望是這樣：
one = Coordinate(100, 200)
two = Coordinate(300, 200)
three = Coordinate(-100, -100)
sub(one, two)
Coord: {'y': 0, 'x': -200}
add(one, three)
Coord: {'y': 100, 'x': 0}
我們期望在不更改坐標對象one, two, three的前提下one減去two的值是{x: 0, y: 0}，one加上three的值是{x: 100, y: 200}。與其給每個方法都加上參數和返回值邊界檢查的邏輯，我們來寫一個邊界檢查的裝飾器！
def wrapper(func):
def checker(a, b): # 1
if a.x < 0 or a.y < 0:
a = Coordinate(a.x if a.x > 0 else 0, a.y if a.y > 0 else 0)
if b.x < 0 or b.y < 0:
b = Coordinate(b.x if b.x > 0 else 0, b.y if b.y > 0 else 0)
ret = func(a, b)
if ret.x < 0 or ret.y < 0:
ret = Coordinate(ret.x if ret.x > 0 else 0, ret.y if ret.y > 0 else 0)
return ret
return checker
add = wrapper(add)
sub = wrapper(sub)
sub(one, two)
Coord: {'y': 0, 'x': 0}
add(one, three)
Coord: {'y': 200, 'x': 100}
這個裝飾器能想先前的裝飾器例子一樣進行工作，返回一個經過修改的函數，但是在這個例子中，它能夠對函數的輸入參數和返回值做一些非常有用的檢查和格式化工作，將負值的x和 y替換成0。
顯而易見，通過這樣的方式，我們的代碼變得更加簡潔：將邊界檢查的邏輯隔離到單獨的方法中，然后通過裝飾器包裝的方式應用到我們需要進行檢查的地方。另外一種方式通過在計算方法的開始處和返回值之前調用邊界檢查的方法也能夠達到同樣的目的。但是不可置否的是，使用裝飾器能夠讓我們以最少的代碼量達到坐標邊界檢查的目的。事實上，如果我們是在裝飾自己定義的方法的話，我們能夠讓裝飾器應用的更加有逼格。
Python裙：834179111 進裙領取以下學習資料
視頻資料向管理員獲取
