求幫助，Python閉包和返回函數(shù)問題

（1）unpack tuple和list, 可以讓函數(shù)返回多個值

成都創(chuàng)新互聯(lián)服務(wù)項目包括和平網(wǎng)站建設(shè)、和平網(wǎng)站制作、和平網(wǎng)頁制作以及和平網(wǎng)絡(luò)營銷策劃等。多年來，我們專注于互聯(lián)網(wǎng)行業(yè)，利用自身積累的技術(shù)優(yōu)勢、行業(yè)經(jīng)驗、深度合作伙伴關(guān)系等，向廣大中小型企業(yè)、政府機(jī)構(gòu)等提供互聯(lián)網(wǎng)行業(yè)的解決方案，和平網(wǎng)站推廣取得了明顯的社會效益與經(jīng)濟(jì)效益。目前，我們服務(wù)的客戶以成都為中心已經(jīng)輻射到和平省份的部分城市，未來相信會繼續(xù)擴(kuò)大服務(wù)區(qū)域并繼續(xù)獲得客戶的支持與信任！

def count():

return (1, 2, 3) # 或者 return [1, 2, 3]

# 把列表解包，把1 2 3 分別賦值給 a b c

a, b, c = count()

print a, b, c

# 輸出 1, 2, 3

（2）假設(shè)你知道Python的dict類型。Python中，在函數(shù)中定義一個變量的時候，會在一個隱藏的叫l(wèi)ocals的dict里面插入key-value，其中key是變量名，value是變量值。而引用一個變量的時候，則首先會在這個叫l(wèi)ocals的dict里面，根據(jù)變量名作為key，去查對應(yīng)的值。

var = 1 # 你可以認(rèn)為這里進(jìn)行了 locals['var'] = 1 的操作

print var # 在對var變量進(jìn)行求值的時候，就在locals['var']里面找var變量對應(yīng)的值

（3）for循環(huán)中，每次循環(huán)只是給 `i` 重新綁定值

for i in (1, 2, 3):

print i

print i

# 一次輸入 1 2 3 3

每次`for i in (1, 2, 3)`相當(dāng)于在`print i`之前，進(jìn)行了

`locals['i'] = 1`

`locals['i'] = 2`

`locals['i'] = 3`

的操作

所以最后的`print i`再去locals字典里面找`i`的時候，就變成 3 了。

（4）閉包是 一個函數(shù)加上這個函數(shù)引用的外部變量

var = 1

def f():

print var

# 這里的閉包是函數(shù) f 和 f 引用的外部變量 var

def count():

var2 = 2

def f():

print var2

# 這里的閉包是函數(shù) f 和 f 引用的外部變量 var2

return f

拿第一個函數(shù) f 來說。在 f 運(yùn)行的時候，解釋器拿著'var'這個字符串去locals字典里面找，發(fā)現(xiàn)找不到，于是在closure字典里面找，最后closure字典里面找，你可以認(rèn)為就是找closure['var']，然后發(fā)現(xiàn)找到對應(yīng)的值。count里面的 f 函數(shù)同理。

（為了容易理解，我這里說謊了。實際上 f 壓根沒有closure，count里面的 f 才有。其實closure壓根不是像locals那樣的字典）

（5）函數(shù)定義時，函數(shù)只是記錄變量的名字。

要區(qū)分什么是名字，什么是值。

`i = 1`這里 i 只是名字，只是一個字符串 'i' 。這句話運(yùn)行完，locals['i'] = 1，就說 i 對應(yīng)的值是1

def count():

fs = []

for i in range(1, 4):

# 定義一個函數(shù)，等價于運(yùn)行了 locals['f'] = 真正生成的函數(shù)

# 每次循環(huán)，這里都會重新生成一個函數(shù)，然后把重新生成的函數(shù)賦值給 locals['f']

def f():

return i * i # 引用了'i'這個名字，但并不是引用了'i'對應(yīng)的值

# 等價于 locals['fs'].append(locals['f'])

# f 不是函數(shù)，它只是一個名字'f'。f 引用的東西，也就是locals['f']才是真正的函數(shù)

fs.append(f)

# 于是這個for循環(huán)生成了三個函數(shù)，這三個函數(shù)是沒有名字的，這個函數(shù)運(yùn)行完后，它們跟'f'這個名字就毛關(guān)系都沒有了(是的我說慌了，但可以先不管)

# 把整個列表返回，這個列表包含了三個函數(shù)

return fs

# count()返回三個函數(shù)的列表，unpack 列表的語法把列表中的三個函數(shù)抽出來，重新給他們命名為 f1, f2, f3

# 也就是說，

# locals['f1'] = 列表中的第1個函數(shù)

# locals['f2'] = 列表中的第2個函數(shù)

# locals['f3'] = 列表中的第3個函數(shù)

# 這三個函數(shù)跟'f'這個名字現(xiàn)在毛關(guān)系都沒有。（其實是有的，但為了說明需要簡化，現(xiàn)在你可以完全不管括號里面說的話）

f1, f2, f3 = count()

print f1(), f2(), f3()

# 好了我們運(yùn)行它們，輸入都是 9

# def f():

# return i * i

這是因為 f1 現(xiàn)在對應(yīng)的函數(shù)，里面引用了 'i' 這個字符串，我們根據(jù) 'i '這個字符串去找它對應(yīng)的值，先找到 f 當(dāng)前的locals字典，發(fā)現(xiàn)沒有，因為函數(shù)定義的時候沒有定義 i 變量。然后再去closure['i']里面找，因為Python是通過closure字典實現(xiàn)閉包的（就當(dāng)它是對的好不好），所以我們可以在closure['i']找到值，這個值就是我們上一次運(yùn)行的時候count函數(shù)里面殘留的locals['i']，而由于for循環(huán)三遍之后，locals['i'] == 3，所以找到 i 的值就是3。所以最后輸出都是9

python函數(shù)的返回值？

題主你好,

關(guān)鍵點在于函數(shù)如果沒有明確使用return關(guān)鍵字指定函數(shù)的返回值,則默認(rèn)返回值是none.

-----

所以temp = hello()這句的理解就是: 執(zhí)行hello()這個函數(shù), 并且把函數(shù)的返回值賦給變量temp, 但hello()函數(shù)中沒有return語句, 所以hello()函數(shù)的返回值為默認(rèn)的none.

-----

題主還可以在hello()函數(shù)最后加一個: return 123

然后再行一下看看,就明白了.

=====

希望可以幫到題主, 歡迎追問.

Python 里為什么函數(shù)可以返回一個函數(shù)內(nèi)部定義的函數(shù)

“在Python中，函數(shù)本身也是對象”

這一本質(zhì)。那不妨慢慢來，從最基本的概念開始，討論一下這個問題：

1. Python中一切皆對象

這恐怕是學(xué)習(xí)Python最有用的一句話。想必你已經(jīng)知道Python中的list, tuple, dict等內(nèi)置數(shù)據(jù)結(jié)構(gòu)，當(dāng)你執(zhí)行：

alist = [1, 2, 3]

時，你就創(chuàng)建了一個列表對象，并且用alist這個變量引用它：

當(dāng)然你也可以自己定義一個類:

class House(object):

def __init__(self, area, city):

self.area = area

self.city = city

def sell(self, price):

[...] #other code

return price

然后創(chuàng)建一個類的對象：

house = House(200, 'Shanghai')

OK，你立馬就在上海有了一套200平米的房子，它有一些屬性(area, city)，和一些方法(__init__, self)：

2. 函數(shù)是第一類對象

和list, tuple, dict以及用House創(chuàng)建的對象一樣，當(dāng)你定義一個函數(shù)時，函數(shù)也是對象：

def func(a, b):

return a+b

在全局域，函數(shù)對象被函數(shù)名引用著，它接收兩個參數(shù)a和b，計算這兩個參數(shù)的和作為返回值。

所謂第一類對象，意思是可以用標(biāo)識符給對象命名，并且對象可以被當(dāng)作數(shù)據(jù)處理，例如賦值、作為參數(shù)傳遞給函數(shù)，或者作為返回值return 等

因此，你完全可以用其他變量名引用這個函數(shù)對象：

add = func

這樣，你就可以像調(diào)用func(1, 2)一樣，通過新的引用調(diào)用函數(shù)了：

print func(1, 2)

print add(1, 2) #the same as func(1, 2)

或者將函數(shù)對象作為參數(shù)，傳遞給另一個函數(shù)：

def caller_func(f):

return f(1, 2)

if __name__ == "__main__":

print caller_func(func)

可以看到，

函數(shù)對象func作為參數(shù)傳遞給caller_func函數(shù)，傳參過程類似于一個賦值操作f=func；

于是func函數(shù)對象，被caller_func函數(shù)作用域中的局部變量f引用，f實際指向了函數(shù)func；cc

當(dāng)執(zhí)行return f(1, 2)的時候，相當(dāng)于執(zhí)行了return func(1, 2)；

因此輸出結(jié)果為3。

3. 函數(shù)對象 vs 函數(shù)調(diào)用

無論是把函數(shù)賦值給新的標(biāo)識符，還是作為參數(shù)傳遞給新的函數(shù)，針對的都是函數(shù)對象本身，而不是函數(shù)的調(diào)用。

用一個更加簡單，但從外觀上看，更容易產(chǎn)生混淆的例子來說明這個問題。例如定義了下面這個函數(shù)：

def func():

return "hello,world"

然后分別執(zhí)行兩次賦值：

ref1 = func #將函數(shù)對象賦值給ref1

ref2 = func() #調(diào)用函數(shù)，將函數(shù)的返回值("hello,world"字符串)賦值給ref2

很多初學(xué)者會混淆這兩種賦值，通過Python內(nèi)建的type函數(shù)，可以查看一下這兩次賦值的結(jié)果：

In [4]: type(ref1)

Out[4]: function

In [5]: type(ref2)

Out[5]: str

可以看到，ref1引用了函數(shù)對象本身，而ref2則引用了函數(shù)的返回值。通過內(nèi)建的callable函數(shù)，可以進(jìn)一步驗證ref1是可調(diào)用的，而ref2是不可調(diào)用的：

In [9]: callable(ref1)

Out[9]: True

In [10]: callable(ref2)

Out[10]: False

傳參的效果與之類似。

4. 閉包LEGB法則

所謂閉包，就是將組成函數(shù)的語句和這些語句的執(zhí)行環(huán)境打包在一起時，得到的對象

聽上去的確有些復(fù)雜，還是用一個栗子來幫助理解一下。假設(shè)我們在foo.py模塊中做了如下定義：

#foo.py

filename = "foo.py"

def call_func(f):

return f() #如前面介紹的，f引用一個函數(shù)對象，然后調(diào)用它

在另一個func.py模塊中，寫下了這樣的代碼：

#func.py

import foo #導(dǎo)入foo.py

filename = "func.py"

def show_filename():

return "filename: %s" % filename

if __name__ == "__main__":

print foo.call_func(show_filename) #注意：實際發(fā)生調(diào)用的位置，是在foo.call_func函數(shù)中

當(dāng)我們用python func.py命令執(zhí)行func.py時輸出結(jié)果為：

chiyu@chiyu-PC:~$ python func.py

filename:func.py

很顯然show_filename()函數(shù)使用的filename變量的值，是在與它相同環(huán)境(func.py模塊)中定義的那個。盡管foo.py模塊中也定義了同名的filename變量，而且實際調(diào)用show_filename的位置也是在foo.py的call_func內(nèi)部。

而對于嵌套函數(shù)，這一機(jī)制則會表現(xiàn)的更加明顯：閉包將會捕捉內(nèi)層函數(shù)執(zhí)行所需的整個環(huán)境：

#enclosed.py

import foo

def wrapper():

filename = "enclosed.py"

def show_filename():

return "filename: %s" % filename

print foo.call_func(show_filename) #輸出：filename: enclosed.py

實際上，每一個函數(shù)對象，都有一個指向了該函數(shù)定義時所在全局名稱空間的__globals__屬性：

#show_filename inside wrapper

#show_filename.__globals__

{

'__builtins__': module '__builtin__' (built-in), #內(nèi)建作用域環(huán)境

'__file__': 'enclosed.py',

'wrapper': function wrapper at 0x7f84768b6578, #直接外圍環(huán)境

'__package__': None,

'__name__': '__main__',

'foo': module 'foo' from '/home/chiyu/foo.pyc', #全局環(huán)境

'__doc__': None

}

當(dāng)代碼執(zhí)行到show_filename中的return "filename: %s" % filename語句時，解析器按照下面的順序查找filename變量：

Local - 本地函數(shù)(show_filename)內(nèi)部，通過任何方式賦值的，而且沒有被global關(guān)鍵字聲明為全局變量的filename變量；

Enclosing - 直接外圍空間(上層函數(shù)wrapper)的本地作用域，查找filename變量(如果有多層嵌套，則由內(nèi)而外逐層查找，直至最外層的函數(shù))；

Global - 全局空間(模塊enclosed.py)，在模塊頂層賦值的filename變量；

Builtin - 內(nèi)置模塊(__builtin__)中預(yù)定義的變量名中查找filename變量；

在任何一層先找到了符合要求的filename變量，則不再向更外層查找。如果直到Builtin層仍然沒有找到符合要求的變量，則拋出NameError異常。這就是變量名解析的：LEGB法則。

總結(jié)：

閉包最重要的使用價值在于：封存函數(shù)執(zhí)行的上下文環(huán)境；

閉包在其捕捉的執(zhí)行環(huán)境(def語句塊所在上下文)中，也遵循LEGB規(guī)則逐層查找，直至找到符合要求的變量，或者拋出異常。

5. 裝飾器語法糖(syntax sugar)

那么閉包和裝飾器又有什么關(guān)系呢？

上文提到閉包的重要特性：封存上下文，這一特性可以巧妙的被用于現(xiàn)有函數(shù)的包裝，從而為現(xiàn)有函數(shù)更加功能。而這就是裝飾器。

還是舉個例子，代碼如下：

#alist = [1, 2, 3, ..., 100] -- 1+2+3+...+100 = 5050

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

我們定義了一個函數(shù)lazy_sum，作用是對alist中的所有元素求和后返回。alist假設(shè)為1到100的整數(shù)列表：

alist = range(1, 101)

但是出于某種原因，我并不想馬上返回計算結(jié)果，而是在之后的某個地方，通過顯示的調(diào)用輸出結(jié)果。于是我用一個wrapper函數(shù)對其進(jìn)行包裝：

def wrapper():

alist = range(1, 101)

def lazy_sum():

return reduce(lambda x, y: x+y, alist)

return lazy_sum

lazy_sum = wrapper() #wrapper() 返回的是lazy_sum函數(shù)對象

if __name__ == "__main__":

lazy_sum() #5050

這是一個典型的Lazy Evaluation的例子。我們知道，一般情況下，局部變量在函數(shù)返回時，就會被垃圾回收器回收，而不能再被使用。但是這里的alist卻沒有，它隨著lazy_sum函數(shù)對象的返回被一并返回了(這個說法不準(zhǔn)確，實際是包含在了lazy_sum的執(zhí)行環(huán)境中，通過__globals__)，從而延長了生命周期。

當(dāng)在if語句塊中調(diào)用lazy_sum()的時候，解析器會從上下文中(這里是Enclosing層的wrapper函數(shù)的局部作用域中)找到alist列表，計算結(jié)果，返回5050。

當(dāng)你需要動態(tài)的給已定義的函數(shù)增加功能時，比如：參數(shù)檢查，類似的原理就變得很有用：

def add(a, b):

return a+b

這是很簡單的一個函數(shù)：計算a+b的和返回，但我們知道Python是 動態(tài)類型+強(qiáng)類型 的語言，你并不能保證用戶傳入的參數(shù)a和b一定是兩個整型，他有可能傳入了一個整型和一個字符串類型的值：

In [2]: add(1, 2)

Out[2]: 3

In [3]: add(1.2, 3.45)

Out[3]: 4.65

In [4]: add(5, 'hello')

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

/home/chiyu/ipython-input-4-f2f9e8aa5eae in module()

---- 1 add(5, 'hello')

/home/chiyu/ipython-input-1-02b3d3d6caec in add(a, b)

1 def add(a, b):

---- 2 return a+b

TypeError: unsupported operand type(s) for +: 'int' and 'str'

于是，解析器無情的拋出了一個TypeError異常。

動態(tài)類型：在運(yùn)行期間確定變量的類型，python確定一個變量的類型是在你第一次給他賦值的時候；

強(qiáng)類型：有強(qiáng)制的類型定義，你有一個整數(shù)，除非顯示的類型轉(zhuǎn)換，否則絕不能將它當(dāng)作一個字符串(例如直接嘗試將一個整型和一個字符串做+運(yùn)算)；

因此，為了更加優(yōu)雅的使用add函數(shù)，我們需要在執(zhí)行+運(yùn)算前，對a和b進(jìn)行參數(shù)檢查。這時候裝飾器就顯得非常有用：

import logging

logging.basicConfig(level = logging.INFO)

def add(a, b):

return a + b

def checkParams(fn):

def wrapper(a, b):

if isinstance(a, (int, float)) and isinstance(b, (int, float)): #檢查參數(shù)a和b是否都為整型或浮點型

return fn(a, b) #是則調(diào)用fn(a, b)返回計算結(jié)果

#否則通過logging記錄錯誤信息，并友好退出

logging.warning("variable 'a' and 'b' cannot be added")

return

return wrapper #fn引用add，被封存在閉包的執(zhí)行環(huán)境中返回

if __name__ == "__main__":

#將add函數(shù)對象傳入，fn指向add

#等號左側(cè)的add，指向checkParams的返回值wrapper

add = checkParams(add)

add(3, 'hello') #經(jīng)過類型檢查，不會計算結(jié)果，而是記錄日志并退出

注意checkParams函數(shù)：

首先看參數(shù)fn，當(dāng)我們調(diào)用checkParams(add)的時候，它將成為函數(shù)對象add的一個本地(Local)引用；

在checkParams內(nèi)部，我們定義了一個wrapper函數(shù)，添加了參數(shù)類型檢查的功能，然后調(diào)用了fn(a, b)，根據(jù)LEGB法則，解釋器將搜索幾個作用域，并最終在(Enclosing層)checkParams函數(shù)的本地作用域中找到fn；

注意最后的return wrapper，這將創(chuàng)建一個閉包，fn變量(add函數(shù)對象的一個引用)將會封存在閉包的執(zhí)行環(huán)境中，不會隨著checkParams的返回而被回收；

當(dāng)調(diào)用add = checkParams(add)時，add指向了新的wrapper對象，它添加了參數(shù)檢查和記錄日志的功能，同時又能夠通過封存的fn，繼續(xù)調(diào)用原始的add進(jìn)行+運(yùn)算。

因此調(diào)用add(3, 'hello')將不會返回計算結(jié)果，而是打印出日志：

chiyu@chiyu-PC:~$ python func.py

WARNING:root:variable 'a' and 'b' cannot be added

有人覺得add = checkParams(add)這樣的寫法未免太過麻煩，于是python提供了一種更優(yōu)雅的寫法，被稱為語法糖：

@checkParams

def add(a, b):

return a + b

這只是一種寫法上的優(yōu)化，解釋器仍然會將它轉(zhuǎn)化為add = checkParams(add)來執(zhí)行。

6. 回歸問題

def addspam(fn):

def new(*args):

print "spam,spam,spam"

return fn(*args)

return new

@addspam

def useful(a,b):

print a**2+b**2

首先看第二段代碼：

@addspam裝飾器，相當(dāng)于執(zhí)行了useful = addspam(useful)。在這里題主有一個理解誤區(qū)：傳遞給addspam的參數(shù)，是useful這個函數(shù)對象本身，而不是它的一個調(diào)用結(jié)果；

再回到addspam函數(shù)體：

return new 返回一個閉包，fn被封存在閉包的執(zhí)行環(huán)境中，不會隨著addspam函數(shù)的返回被回收；

而fn此時是useful的一個引用，當(dāng)執(zhí)行return fn(*args)時，實際相當(dāng)于執(zhí)行了return useful(*args)；

最后附上一張代碼執(zhí)行過程中的引用關(guān)系圖，希望能幫助你理解：

python字典操作函數(shù)

字典是一種通過名字或者關(guān)鍵字引用的得數(shù)據(jù)結(jié)構(gòu)，其鍵可以是數(shù)字、字符串、元組，這種結(jié)構(gòu)類型也稱之為映射。字典類型是Python中唯一內(nèi)建的映射類型，基本的操作包括如下：

(1)len()：返回字典中鍵—值對的數(shù)量；

(2)d[k]:返回關(guān)鍵字對于的值；

(3)d[k]=v:將值關(guān)聯(lián)到鍵值k上；

(4)del d[k]:刪除鍵值為k的項；

(5)key in d:鍵值key是否在d中，是返回True，否則返回False。

(6)clear函數(shù)：清除字典中的所有項

(7)copy函數(shù)：返回一個具有相同鍵值的新字典；deepcopy()函數(shù)使用深復(fù)制，復(fù)制其包含所有的值，這個方法可以解決由于副本修改而使原始字典也變化的問題

(8)fromkeys函數(shù)：使用給定的鍵建立新的字典，鍵默認(rèn)對應(yīng)的值為None

(9)get函數(shù)：訪問字典成員

(10)has_key函數(shù)：檢查字典中是否含有給出的鍵

(11)items和iteritems函數(shù):items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表

(12)keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

(13)pop函數(shù)：刪除字典中對應(yīng)的鍵

(14)popitem函數(shù)：移出字典中的項

(15)setdefault函數(shù)：類似于get方法，獲取與給定鍵相關(guān)聯(lián)的值，也可以在字典中不包含給定鍵的情況下設(shè)定相應(yīng)的鍵值

(16)update函數(shù)：用一個字典更新另外一個字典

(17)?values和itervalues函數(shù)：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重復(fù)的元素

一、字典的創(chuàng)建

1.1 直接創(chuàng)建字典

d={'one':1,'two':2,'three':3}

printd

printd['two']

printd['three']

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1.2 通過dict創(chuàng)建字典

# _*_ coding:utf-8 _*_

items=[('one',1),('two',2),('three',3),('four',4)]

printu'items中的內(nèi)容:'

printitems

printu'利用dict創(chuàng)建字典，輸出字典內(nèi)容:'

d=dict(items)

printd

printu'查詢字典中的內(nèi)容:'

printd['one']

printd['three']

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

items中的內(nèi)容:

[('one',1), ('two',2), ('three',3), ('four',4)]

利用dict創(chuàng)建字典，輸出字典內(nèi)容:

{'four':4,'three':3,'two':2,'one':1}

查詢字典中的內(nèi)容:

或者通過關(guān)鍵字創(chuàng)建字典

# _*_ coding:utf-8 _*_

d=dict(one=1,two=2,three=3)

printu'輸出字典內(nèi)容:'

printd

printu'查詢字典中的內(nèi)容:'

printd['one']

printd['three']

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

輸出字典內(nèi)容:

{'three':3,'two':2,'one':1}

查詢字典中的內(nèi)容:

二、字典的格式化字符串

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

print"three is %(three)s."%d

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

threeis3.

三、字典方法

3.1?clear函數(shù)：清除字典中的所有項

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

d.clear()

printd

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

{}

請看下面兩個例子

3.1.1

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d={}

printd

printdd

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{'two':2,'one':1}

3.1.2

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d.clear()

printd

printdd

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{}

3.1.2與3.1.1唯一不同的是在對字典d的清空處理上，3.1.1將d關(guān)聯(lián)到一個新的空字典上，這種方式對字典dd是沒有影響的，所以在字典d被置空后，字典dd里面的值仍舊沒有變化。但是在3.1.2中clear方法清空字典d中的內(nèi)容，clear是一個原地操作的方法，使得d中的內(nèi)容全部被置空，這樣dd所指向的空間也被置空。

3.2?copy函數(shù)：返回一個具有相同鍵值的新字典

# _*_ coding:utf-8 _*_

x={'one':1,'two':2,'three':3,'test':['a','b','c']}

printu'初始X字典：'

printx

printu'X復(fù)制到Y(jié)：'

y=x.copy()

printu'Y字典：'

printy

y['three']=33

printu'修改Y中的值，觀察輸出：'

printy

printx

printu'刪除Y中的值，觀察輸出'

y['test'].remove('c')

printy

printx

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

初始X字典：

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

X復(fù)制到Y(jié)：

Y字典：

{'test': ['a','b','c'],'one':1,'three':3,'two':2}

修改Y中的值，觀察輸出：

{'test': ['a','b','c'],'one':1,'three':33,'two':2}

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

刪除Y中的值，觀察輸出

{'test': ['a','b'],'one':1,'three':33,'two':2}

{'test': ['a','b'],'three':3,'two':2,'one':1}

注：在復(fù)制的副本中對值進(jìn)行替換后，對原來的字典不產(chǎn)生影響，但是如果修改了副本，原始的字典也會被修改。deepcopy函數(shù)使用深復(fù)制，復(fù)制其包含所有的值，這個方法可以解決由于副本修改而使原始字典也變化的問題。

# _*_ coding:utf-8 _*_

fromcopyimportdeepcopy

x={}

x['test']=['a','b','c','d']

y=x.copy()

z=deepcopy(x)

printu'輸出：'

printy

printz

printu'修改后輸出：'

x['test'].append('e')

printy

printz

運(yùn)算輸出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

輸出：

{'test': ['a','b','c','d']}

{'test': ['a','b','c','d']}

修改后輸出：

{'test': ['a','b','c','d','e']}

{'test': ['a','b','c','d']}

3.3?fromkeys函數(shù)：使用給定的鍵建立新的字典，鍵默認(rèn)對應(yīng)的值為None

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'])

printd

運(yùn)算輸出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':None,'two':None,'one':None}

或者指定默認(rèn)的對應(yīng)值

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'],'unknow')

printd

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':'unknow','two':'unknow','one':'unknow'}

3.4?get函數(shù)：訪問字典成員

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.get('one')

printd.get('four')

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1

None

注：get函數(shù)可以訪問字典中不存在的鍵，當(dāng)該鍵不存在是返回None

3.5?has_key函數(shù)：檢查字典中是否含有給出的鍵

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.has_key('one')

printd.has_key('four')

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

True

False

3.6?items和iteritems函數(shù):items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

list=d.items()

forkey,valueinlist:

printkey,':',value

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

three :3

two :2

one :1

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

it=d.iteritems()

fork,vinit:

print"d[%s]="%k,v

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

d[three]=3

d[two]=2

d[one]=1

3.7?keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printu'keys方法：'

list=d.keys()

printlist

printu'\niterkeys方法：'

it=d.iterkeys()

forxinit:

printx

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

keys方法：

['three','two','one']

iterkeys方法：

three

two

one

3.8?pop函數(shù)：刪除字典中對應(yīng)的鍵

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.pop('one')

printd

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'three':3,'two':2}

3.9?popitem函數(shù)：移出字典中的項

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.popitem()

printd

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'two':2,'one':1}

3.10?setdefault函數(shù)：類似于get方法，獲取與給定鍵相關(guān)聯(lián)的值，也可以在字典中不包含給定鍵的情況下設(shè)定相應(yīng)的鍵值

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.setdefault('one',1)

printd.setdefault('four',4)

printd

運(yùn)算結(jié)果：

{'three':3,'two':2,'one':1}

{'four':4,'three':3,'two':2,'one':1}

3.11?update函數(shù)：用一個字典更新另外一個字典

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3

}

printd

x={'one':1}

d.update(x)

printd

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':123}

{'three':3,'two':2,'one':1}

3.12?values和itervalues函數(shù)：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重復(fù)的元素

# _*_ coding:utf-8 _*_

d={

'one':123,

'two':2,

'three':3,

'test':2

}

printd.values()

運(yùn)算結(jié)果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

[2,3,2,123]

文章標(biāo)題：python返回函數(shù)名字,python函數(shù)可以作為函數(shù)的返回值
分享路徑：http://aaarwkj.com/article44/dsiiche.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供服務(wù)器托管、網(wǎng)站排名、域名注冊、響應(yīng)式網(wǎng)站、關(guān)鍵詞優(yōu)化、營銷型網(wǎng)站建設(shè)

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)