一 集合

1 集合定義：

1 如果花括號為空，則是字典類型

2 定義一個(gè)空集合，使用set 加小括號

使用B方式定義集合時(shí)，集合內(nèi)部的數(shù)必須是可迭代對象，數(shù)值類型的不可以

其中的值必須是可迭代對象，其中的元素必須是可hash，其中s=set([1,2,3,4,5,6]) 的含義是其是列表，其列表是可迭代，且其獲取到的是其中的元素，不是列表。

2 set 和線性結(jié)構(gòu)

線性結(jié)構(gòu)的查詢時(shí)間復(fù)雜度是O(n)，即隨著數(shù)據(jù)規(guī)模的增大而增加耗時(shí)

set、dict 等結(jié)構(gòu)，內(nèi)部使用hash值做為key，時(shí)間復(fù)雜度可以做到O(1)，查詢時(shí)間和數(shù)據(jù)規(guī)模無關(guān)

可hash的對象
數(shù)值類型 int float complex
布爾型 True False
字符串 string bytes
tuple
None
以上都是不可變類型，稱為可哈西類型，hashable
set 的元素必須是可hash的。

2 集合的簡單應(yīng)用

實(shí)現(xiàn)對集合內(nèi)元素的去重操作，此操作可應(yīng)用于對列表的去重
1 使用集合對列表進(jìn)行去重操作

2 使用字典的鍵不重復(fù)性對列表進(jìn)行去重

3集合的增刪改查

1 集合的增：

A add 實(shí)現(xiàn)對非可變類型數(shù)據(jù)的添加操作（除列表，字典）

B update 實(shí)現(xiàn)對可迭代對象的加入操作（數(shù)值類型則不能加入其中）

2 刪

A pop()支持對集合的無序刪除操作

B remove 支持對集合的指定元素的刪除工作，若不存在，則報(bào)錯(cuò)

C discard 刪除集合中指定元素，如果不存在，則無反應(yīng)

D clear 清空集合

例題應(yīng)用：

要求輸入一個(gè)數(shù)，使其成為1-1000之間產(chǎn)生隨機(jī)數(shù)的個(gè)數(shù)的總和個(gè)數(shù)，并對這些數(shù)進(jìn)行排序（有小到大）

1
[root@www ~]# cat a.py

#!/usr/bin/env python #coding=utf-8 import random #導(dǎo)入該模塊，用于生成1到1000的隨機(jī)數(shù) l1=[] s=set() N=input("請輸入數(shù)字總和N:") for i in range(N): #進(jìn)行循環(huán)的總數(shù)N1=random.randint(1,1000) # 生成1-1000內(nèi)的隨機(jī)數(shù)N個(gè) s.add(N1)l1=list(s)l1.sort() #使用列表的內(nèi)置方法進(jìn)行排序 print l1

2
[root@www ~]# cat a.py

#!/usr/bin/env python #coding=utf-8 import random l1=[] s=set() N=input("請輸入數(shù)字總和N:") for i in range(N):N1=random.randint(1,1000)s.add(N1)l1=list(s) print sorted(l1) 使用內(nèi)置函數(shù)進(jìn)行排序

3 查（關(guān)系測試）

1 交集 （輸出兩個(gè)集合中共有的元素）

2 并集（輸出列個(gè)集合中所有存在的元素）

3 差集（輸出第一個(gè)集合中與第二個(gè)集合不同的元素）

4 對等差分 （輸出兩個(gè)集合中各不存在但對方存在的元素）

集合關(guān)系判斷（子集，父集）

4 練習(xí)

隨機(jī)產(chǎn)生2個(gè)各10個(gè)數(shù)字的列表，要求如下：
1 每個(gè)數(shù)字取值范圍是[10,20]
2 統(tǒng)計(jì)20個(gè)數(shù)字中，一共多少個(gè)不同的數(shù)字
3 2組中，不重復(fù)的數(shù)字有幾個(gè)，分別是多少
4 2 組中，重復(fù)的數(shù)字有幾個(gè)，分別是什么

import random l1=[] l2=[] for i in range(10): # 生成10個(gè)隨機(jī)數(shù)，其取值范圍是10，20l1.append(random.randint(10,20))l2.append(random.randint(10,20))print ("不同數(shù)字個(gè)數(shù)為{},不重復(fù)數(shù)字有{}個(gè),分別是{},重復(fù)數(shù)字為{}，共{}個(gè)".format(set(set(l1)|set(l2)),(len(set(l1)^set(l2))),(set(l1)^set(l2)),(set(l1)&set(l2)),len(set(l1)&set(l2))))# 不重復(fù)表示是對等差集

二 總結(jié)：

1 可變數(shù)據(jù)類型：列表，字典，集合
2 不可變數(shù)據(jù)類型：數(shù)值類型，元祖，字符串

可變數(shù)據(jù)類型實(shí)現(xiàn)某個(gè)功能，直接改變可變的數(shù)據(jù)
不可變數(shù)據(jù)類型實(shí)現(xiàn)某些功能，需要將結(jié)果賦值給另一個(gè)變量

可迭代數(shù)據(jù)類型（能實(shí)現(xiàn)for 循環(huán)）：str list tuple dict set
不可迭代數(shù)據(jù)類型：數(shù)值類型

是否支持索引，切片，鏈接，重復(fù)特性
有序的數(shù)據(jù)類型：str list tuple
無序的數(shù)據(jù)類型：dict set

二 解析式

1 列表解析 list comprehension

1 概述

列表解析式是一種語法糖
編譯器會優(yōu)化，不會因?yàn)楹唽懚绊懶?#xff0c;反而因優(yōu)化而提高了效率
減少程序員工作量，減少出錯(cuò)
簡化了代碼，但可讀性增強(qiáng)

2 語法

語法：
[ 返回值 for 元素 in 可迭代對象 if 條件]
使用中括號[]，內(nèi)部是for循環(huán)，if 條件語句可選
返回一個(gè)新的列表

3 進(jìn)階

[item for item in iterable if cond1 if cond2] #等價(jià)于ret=[] for item in iterable:if cond1:if cond2:ret.append(item)[ (i*j) for i in iterable1 for j in iterable2] #等價(jià)于 ret=[] for i in iterable1:for j in iterable2:ret.append(i*j)

4 練習(xí)

1 返回1-10平方的列表

In [1]: [pow(i,2) for i in range(1,11)] Out[1]: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2 有一個(gè)列表lst=[1,4,9,16,2,5,10,15]，生成一個(gè)新列表，要求新列表的元素是lst相鄰2項(xiàng)的和

In [15]: lst=[1,4,9,16,2,5,10,15] In [16]: [lst[i]+lst[i+1] for i in range(len(lst)-1)] Out[16]: [5, 13, 25, 18, 7, 15, 25]

3 打印九九乘法表

In [5]: [print ("{}*{}={:<3}{}".format(j,i,j*i,'\n' if i==j else " "),end="") for i...: in range(1,10) for j in range(1,i+1)] 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

4 "0001.abcdefghij" 是ID格式，要求ID格式是以點(diǎn)好分割，左邊是4位從1開始的整數(shù)，右邊是10位隨機(jī)小寫英文字母，請以此生成前100個(gè)id的列表。

In [1]: import random In [2]: import string In [3]: ["{:04}.{}".format(i,"".join(random.sample(string.ascii_lowercase,10))) for i...: in range(1,101)] Out[3]: ['0001.wzmedfgach','0002.teandiuzbq','0003.mgvprdwtbz','0004.hdcjryliun','0005.rkbdanezip','0006.yabquwrjfm','0007.xhriugvyfl','0008.yjosmvrxuf','0009.oepwvfyzxj','0010.hzcigsnqkw','0011.kygrvidtla','0012.tpsjmzdvca','0013.mhwixqprdy','0014.rmgvxubklj','0015.crtwsnpubg','0016.tpcmeoxgzf','0017.ulovngcyki','0018.njiagycwvd','0019.sbjcutgvxr','0020.cazqujrdtk','0021.fnteuvaozd','0022.zlsiqxwcoa','0023.lxzojifvqb','0024.zpudanijfm','0025.zdjsawlurp','0026.viqekcsfyr','0027.psgitcvwlq','0028.xnwyjvstdp','0029.jdnbazgrxo','0030.ifshwdnmpy','0031.dfchqxuvbj','0032.jdkehycosl','0033.bjhnofwxgd','0034.kbucwogptl','0035.ctosfdqaie','0036.plcgqbvnzr','0037.lbygqswtjo','0038.clgqzrmfpe','0039.xynsopwfld','0040.lzqxkeycjg','0041.azexdhpwqf','0042.sqxubrijdo','0043.xrdbtspiac','0044.unvjbchdsi','0045.xwfrtduobv','0046.fmjgwnahyz','0047.qjcvluokpw','0048.depfjnyviw','0049.fyhvctzneb','0050.grblkwfioq','0051.mvlfdaengp','0052.bxlnkfuoqh','0053.kicejmfqxn','0054.qxzpjolvkw','0055.sptuwycjrx','0056.bhljztgdfi','0057.htrjiqxfdv','0058.hfqdnurxbp','0059.kygirhzjbe','0060.gkilhandxs','0061.okbmcgzqwv','0062.lkujswvyra','0063.jeqvbuczap','0064.asqfmkrjpn','0065.tdaufvkrie','0066.axlgjumfbe','0067.kgwvhlodrt','0068.psvwahceiz','0069.srtufplwaj','0070.lvhouijnxw','0071.ofkmaiugqc','0072.awfpcyogie','0073.agckzpbxyf','0074.zpmsajbxld','0075.jskbpqzxcv','0076.cgevhqjkfr','0077.uwirenmlhk','0078.gnbozqvmif','0079.hbjtcrpxds','0080.qkvwluazfm','0081.dileuwsmfh','0082.djmgswhytp','0083.pictkgmefh','0084.aqijzmpkny','0085.bwmgudzclt','0086.omzwylnbxp','0087.nhvgfbrdyq','0088.sdaiwoqzht','0089.xiqetyjprf','0090.qaidkozlmg','0091.xwarkuylfo','0092.dqmkpobfia','0093.owqausrpnb','0094.gxazkslifh','0095.dtxfepmylv','0096.olejwvhsfp','0097.excdapiyvb','0098.zoq***ytbu','0099.euhjblfqkn','0100.pzhejmwybg']

2 集合解析式

1 語法

{ 返回值 for 元素 In 可迭代對象 if 條件}立即返回一個(gè)集合

2 練習(xí)

返回一個(gè)1到10的平方的集合

In [1]: {pow(i,2) for i in range(1,11)} Out[1]: {1, 4, 9, 16, 25, 36, 49, 64, 81, 100}

3 字典解析式

1 語法

{返回值 for 元素 In 可迭代對象 if 條件 } 使用key,value 形式接受 立即返回一個(gè)字典

2 練習(xí)

In [2]: {str(i):i for i in range(10)} Out[2]: {'0': 0,'1': 1,'2': 2,'3': 3,'4': 4,'5': 5,'6': 6,'7': 7,'8': 8,'9': 9}In [3]: {str(i):[i,i+1] for i in range(10)} Out[3]: {'0': [0, 1],'1': [1, 2],'2': [2, 3],'3': [3, 4],'4': [4, 5],'5': [5, 6],'6': [6, 7],'7': [7, 8],'8': [8, 9],'9': [9, 10]}In [4]: {str(i):[j] for i in range(10) for j in range(10,21)} # 此處會覆蓋，因?yàn)榍懊嬉恢痹谫x值。 Out[4]: {'0': [20],'1': [20],'2': [20],'3': [20],'4': [20],'5': [20],'6': [20],'7': [20],'8': [20],'9': [20]}

三 生成器表達(dá)式

1 和列表解析式的區(qū)別

生成器表達(dá)式是按需計(jì)算（或成為惰性求值，延遲計(jì)算），需要的時(shí)候才計(jì)算值
列表解析式是立即返回值，生成器從前到后走完一遍后，不能回頭。列表解析從簽到后走完一邊后可以回頭迭代。
生成器 是可迭代對象，是迭代器
迭代器只能使用一次，但可迭代對象不能使用next（）方法
能用next，必須是迭代器，
可迭代對象不一定是迭代器，但迭代器一定是可迭代對象

2 語法

(返回值 for 元素 in 可迭代對象 if 條件)
列表解析式中括號換成了小括號
返回一個(gè)生成器

3 練習(xí)

由上述可知，生成器只能迭代一次，而列表解析式可以重復(fù)迭代

In [6]: it=("{}".format(i+1) for i in range(2)) In [7]: next(it) Out[7]: '1'In [8]: next(it) Out[8]: '2'In [10]: it=("{}".format(i+1) for i in range(2)) In [11]: for i in it: ...: print (i) ...: 1 2

四 函數(shù)

1 無參數(shù)的函數(shù)

函數(shù)的定義：
def 函數(shù)名（）：
函數(shù)體

函數(shù)的調(diào)用：
函數(shù)名()

定義函數(shù)時(shí)，函數(shù)不執(zhí)行，調(diào)用函數(shù)時(shí)，函數(shù)才執(zhí)行

2 有參數(shù)的函數(shù)

1 形參

在def 函數(shù)定義時(shí)使用的參數(shù)稱為形式參數(shù)，不具備實(shí)際的意義，
def a1(x,y):
....: print x+y

此時(shí)的x,y被稱為形式參數(shù)
形參的分類

A 必須參數(shù)
def a1(x,y):
....: print x+y

---

B 默認(rèn)參數(shù)

In [59]: def a4(x,y=1): #y=1 用于當(dāng)只傳入一個(gè)參數(shù)時(shí)，此y=1則會發(fā)生作用，若傳入兩個(gè)參數(shù)，則失效
....: print x,y
....:

In [60]: a4(1)
1 1

In [61]: a4(1,2)
1 2

---

C 可變參數(shù)

In [38]: def a2(*x): 可以同時(shí)傳輸多個(gè)參數(shù)，其產(chǎn)生的結(jié)果是一個(gè)元祖
....: print x
....:

In [39]: a2(1,2,3,4,5,6)
(1, 2, 3, 4, 5, 6)

a2([1,2,3,4,5])
([1, 2, 3, 4, 5],)

---

D 關(guān)鍵字參數(shù)：

In [57]: def a3(**x):
....: print x #其返回值是一個(gè)字典
....:

In [58]: a3(a=1,b=2,c=3)
{'a': 1, 'c': 3, 'b': 2}

函數(shù)定義時(shí)，若有多種類型的參數(shù)需要定義，則必須要遵循：必須參數(shù)--默認(rèn)參數(shù)--可變參數(shù)--關(guān)鍵字參數(shù)

2 實(shí)參

在調(diào)用函數(shù)時(shí)傳入函數(shù)體內(nèi)部的參數(shù)稱為實(shí)參，有實(shí)際的效果的參數(shù)
In [35]: a1(1,2)
3
In [36]: a=1;b=3
In [37]: a1(a,b)
4
此時(shí)的1,2 和 a,b 都是實(shí)參

應(yīng)用，用于數(shù)之和
In [41]: def a2(*x):
....: sum=0
....: for i in x:
....: sum+=i
....: print sum
....:

In [42]: a2(1,2,3,4,5,6,7,8,9)
45

3返回值

函數(shù)中沒有return時(shí)，默認(rèn)返回None

1 返回多個(gè)值

#!/usr/bin/env python #coding=utf-8 def a1(\*args):''' 返回最大值和最小值 :param args: 要求輸入多個(gè)數(shù)作比較 :return: 返回最大值和最小值''' return max(args) ,min(args) print a1(1,2,3,4,10,20,100)

4 函數(shù)的變量作用域

作用域 ： 一個(gè)標(biāo)識符的可見范圍，這就是標(biāo)識符的作用域，一般常說的是變量的作用域。
全局作用域：
在整個(gè)程序運(yùn)行環(huán)境中均可見

局部作用域：
在函數(shù)/類等內(nèi)部可見
局部變量使用范圍不能超過其所在的局部作用域

In [1]: def x(): ...: a=1 ...: In [2]: def y(): ...: print (a) ...: In [3]: print (a) #在函數(shù)x中定義的局部變量在外部不能調(diào)用 NameError Traceback (most recent call last) <ipython-input-3-cb9bacd097d9> in <module> ----> 1 print (a)NameError: name 'a' is not definedIn [4]: y() # 在函數(shù)x中定義的局部變量在函數(shù)y中不能被調(diào)用 --------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-4-6fa9c8f97a35> in <module> ----> 1 y()<ipython-input-2-455e1fcd2512> in y()1 def y(): ----> 2 print (a)3 NameError: name 'a' is not defined

重點(diǎn)

In [1]: x=5 In [2]: def a(): ...: y= x+1 ...: print (x) ...: In [3]: a() 5In [4]: def b(): ...: x=x+1 ...: print (x) ...: In [5]: b Out[5]: <function __main__.b()>In [6]: b() --------------------------------------------------------------------------- UnboundLocalError Traceback (most recent call last) <ipython-input-6-3bf86fc5afda> in <module> ----> 1 b()<ipython-input-4-b0b3ab5ae26b> in b()1 def b(): ----> 2 x=x+13 print (x)4 UnboundLocalError: local variable 'x' referenced before assignment

x+=1 可以轉(zhuǎn)換為x=x+1, x= 相當(dāng)于定義了新的變量x，其相當(dāng)于賦值前引用變量。一般是先賦值，后引用。

解決方式
1 定義全局變量

x=5 In [7]: def b(): ...: global x # 全局變量中必須要有，否則出錯(cuò)...: x=x+1 ...: print (x) ...: In [8]: b() 6 In [1]: x=5 In [2]: def a(): ...: global x ...: x=10 ...: x+=1 ...: print (x) ...: In [3]: a() 11In [4]: print (x) 11

此時(shí)內(nèi)部的x=10相當(dāng)于覆蓋了外部的x=5，因此其值會變成此種情況

global 關(guān)鍵字必須要先聲明，再使用

#!/usr/bin/env python #coding=utf-8x=1 def a1(x):x=2print x

print x 其結(jié)果是x=1
a1(x) 其結(jié)果是x=2 ，因?yàn)樵谡{(diào)用函數(shù)內(nèi)部時(shí)，此x=2是局部變量，其優(yōu)先級高于x=1

global總結(jié)：

x+=1 這中特殊形式產(chǎn)生的原因是先引用后賦值，而python中動態(tài)語言是賦值之后才有意義，才能被引用，解決方式有兩種，第一種是直接在內(nèi)部定義覆蓋外部，第二種是使用global 進(jìn)行聲明，讓其去外部尋找該變量然后完成運(yùn)算，

內(nèi)部作用域賦值全局作用域的變量，其會覆蓋全局變量在本函數(shù)內(nèi)的變量值，而使用global 聲明其為全局的，一旦內(nèi)部進(jìn)行重新賦值，則該值成為全局變量的值。

---

global使用規(guī)則：

1 外部作用域變量會在內(nèi)部作用域可見，但也不要在這個(gè)內(nèi)部的局部作用域中直接使用，因?yàn)楹瘮?shù)的目的就是封裝，而應(yīng)該盡量與外界隔離。
2 如果函數(shù)需要使用外部全局變量，則建議使用形參傳遞參數(shù)解決，盡量不適用定義。
3 不建議使用global

5 默認(rèn)值作用域

1 實(shí)例

實(shí)例1

In [1]: def a(x=1): ...: print (x) ...: In [2]: a() 1In [3]: a() 1In [4]: print (x) --------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-4-606ad02f996c> in <module> ----> 1 print (x)NameError: name 'x' is not defined

此處因?yàn)閤是局部變量，及默認(rèn)形式參數(shù)是局部變量

實(shí)例2

In [1]: def a(x=[]): ...: x.append(1) ...: print (x) ...: In [2]: a() [1]In [3]: a() [1, 1]In [4]: a() [1, 1, 1]

上述實(shí)例中，原本的結(jié)果應(yīng)該是每次調(diào)用其值都是一個(gè)列表，因?yàn)楹瘮?shù)在調(diào)用完成后便會自動消失，但次上述出問題的原因是其默認(rèn)作用域的原因，因?yàn)楹瘮?shù)也是對象，python將函數(shù)的默認(rèn)值放置在了屬性中，這個(gè)屬性就伴隨著函數(shù)對象的整個(gè)生命周期，a.defaults表示了函數(shù)對象的屬性，及保存其默認(rèn)屬性值的位置，

實(shí)例3

In [1]: def a(x=[],y=1,z=2): ...: x.append(1) ...: print (x) ...: In [2]: print (a(),id(a)) [1] None 139758163502216In [3]: print (a.__defaults__) ([1], 1, 2)In [4]: print (a(),id(a)) [1, 1] None 139758163502216In [5]: print (a.__defaults__) ([1, 1], 1, 2)

上述結(jié)果可得，其函數(shù)的地址沒變，及函數(shù)對象沒變，調(diào)用屬性defaults使用元祖保存其default默認(rèn)值，但元祖中有列表，其元祖中的列表是可變的，因此其會發(fā)生變化

實(shí)例4

In [1]: def a(x,y=1,z=2): ...: y=2 ...: z=3 ...: print (x,y,z) ...: In [2]: print (a.__defaults__) (1, 2)In [3]: a(10) 10 2 3In [4]: print (a.__defaults__) (1, 2)

由此可知： 可變類型默認(rèn)值，如果使用默認(rèn)值，則就可能修改這個(gè)默認(rèn)值，某些時(shí)候是不需要的，解決方式如下：

1 影子拷貝

In [1]: def a(x=[],y=1,z=2): ...: print (id(x)) ...: x=x[:] #使用影子拷貝，其返回的是一個(gè)全新的列表，和切片一樣，其比較浪費(fèi)內(nèi)存資源。...: print (id(x)) ...: x.append(1) ...: print (x) ...: In [2]: a() 140285447782088 140285501277768 [1]In [3]: print (a.__defaults__) ([], 1, 2)In [4]: a([10]) 140285501944072 140285481599304 [10, 1]In [5]: print (a.__defaults__) ([], 1, 2)In [6]: a([10,20]) 140285447692488 140285447654920 [10, 20, 1]In [7]: print (a.__defaults__) ([], 1, 2)

2 使用不可變類型進(jìn)行處理

In [1]: def a(x=None,y=1,z=2): ...: if x is None: ...: x=[] ...: x.append(1) ...: print (x) ...: In [2]: a() [1]In [3]: a() [1]In [4]: a.__defaults__ Out[4]: (None, 1, 2)In [5]: a([10]) # 此處只能傳入列表 [10, 1]In [6]: a.__defaults__ Out[6]: (None, 1, 2)

如果是傳入一個(gè)缺省值則創(chuàng)建一個(gè)列表，如果傳入一個(gè)列表，則修改此列表，此種方式常用，此是在原有列表的基礎(chǔ)上修改，較影子拷貝相比更加節(jié)省資源。

6 函數(shù)銷毀

1 全局函數(shù)銷毀
重新定義同名函數(shù)

def foo(xyz=[],u='abc',z=123):xyz.append(1)return xyz print (foo(),id(foo),foo.__defaults__)def foo(xyz=[]): # 當(dāng)?shù)诙€(gè)定義后，第一個(gè)函數(shù)將會漂浮在哪里沒人用了，直到垃圾回收器對其進(jìn)行相關(guān)的回收xyz.append(1)return xyz print (foo(),id(foo),foo.__defaults__)

結(jié)果如下

Del 語句刪除函數(shù)對象

def foo(xyz=[],u='abc',z=123):xyz.append(1)return xyz print (foo(),id(foo),foo.__defaults__) del foo # 使用del刪除函數(shù)的地址引用，當(dāng)其地址引用為0時(shí)，其會被垃圾回收器回收 print (foo(),id(foo),foo.__defaults__)

結(jié)果如下

程序結(jié)束時(shí)

2局部函數(shù)銷毀
重新在上級作用域中定義同名函數(shù)

def foo(xyz=[],u='abc',z=123):xyz.append(1)def foo1():passprint (id(foo1))def foo1(u='acd'): # 重新定義嵌套函數(shù)print (xyz)print (id(foo1))return foo1bar=foo() print (id(bar),foo.__defaults__) # 其中id(bar)指的是foo1的函數(shù)內(nèi)存位置，其默認(rèn)使用下面的函數(shù)

結(jié)果如下：

del 語句刪除函數(shù)對象

def foo(xyz=[],u='abc',z=123):xyz.append(1)def foo1():passprint (id(foo1))return foo1 bar=foo() print (id(bar),foo.__defaults__) # 其中id(bar)指的是foo1的函數(shù)內(nèi)存位置 del bar prnt (id(bar),foo.__defaults__)

結(jié)果如下

上級作用域銷毀時(shí)

7 遞歸函數(shù)

1 函數(shù)執(zhí)行流程

def foo(b,b1=3):print ("foo called",b,b1)def foo1(c):foo2(c)print ("foo1 called",c)def foo2(d):print ("foo2 called",d)def main():print ("main called") # 進(jìn)入上述LEGB進(jìn)行尋找，最后找到build-in后調(diào)用print 返回上述結(jié)果，其會將字面常量壓到棧中，# 內(nèi)存中是分堆和棧的，棧是函數(shù)的，是一個(gè)先進(jìn)后出的，后進(jìn)先出的，main函數(shù)的棧直接被壓在了main之上，當(dāng)print執(zhí)行后# 其將被彈出，彈出后，main函數(shù)中的其他內(nèi)容將會被繼續(xù)執(zhí)行foo(100,101) #python中沒有常量，但其有字面常量，只要敢定義，就敢變。將foo進(jìn)行壓棧，將常量依次壓棧，若有變量，則進(jìn)行#load，調(diào)用函數(shù)foo，創(chuàng)建棧幀，為此函數(shù)在棧中創(chuàng)建一段（棧幀），print壓棧，然后調(diào)用，后彈出。foo1(200) #下面同上print ("main ending") main()

2 遞歸 recursion

函數(shù)直接或間接調(diào)用自身就是遞歸
遞歸需要有邊界條件，遞歸前進(jìn)段，遞歸返回段
遞歸一定要有邊界條件
當(dāng)邊界條件不滿足時(shí)，遞歸前進(jìn)
當(dāng)邊界條件滿足時(shí)，遞歸返回

實(shí)例 ：
1 斐波那契數(shù)列

def x(a):if a<2:return aelse:return x(a-1)+x(a-2) # 下一個(gè)數(shù)等于前兩個(gè)之和for i in range(1,10): #通過for不斷生成下一個(gè)數(shù)print (x(i))

結(jié)果如下

2 階乘

def x(a):if a==1:return aelse:return a*x(a-1)x(10)

結(jié)果如下

3 將一個(gè)數(shù)逆序放入列表中
1234 -> [4，3，2，1]

核心思想，使用數(shù)字的處理方式將其每一位截取出來，然后進(jìn)行相關(guān)的操作即可。

def x(n,l1=[]):if n<10:l1.append(n)return l1 # 最終返回值else:l1.append(n%10)return x(n//10,l1) #調(diào)用函數(shù)遞歸 print (x(1234))

結(jié)果如下

4 字典的扁平化

def d1(c1,c2=dict(),k=""): # 此處定義的空字典用于接受字典，此處的k用于接受字典的鍵（key）if type(c1)==dict:for i,j in c1.items(): # 通過此處判斷字典的值，若其值為字典類型，則繼續(xù)進(jìn)行遞歸操作，直到其值不為字典時(shí)為止，if type(j)==dict:d1(j,c2,k+i)#此處的k+i及就是對兩個(gè)字符串進(jìn)行組合，而后通過點(diǎn)號將其分離else:c2[".".join(k+i)]=jreturn c2 print (d1({'a': {'b': 1, 'c':{'i':10}}, 'd': {'e': 3, 'f': {'g':{'h':5}}}}))

結(jié)果如下

8 總結(jié)

名稱空間：一個(gè)變量所能夠生效的作用域
本地作用域：只能在函數(shù)內(nèi)部使用
模塊定義：全局作用域
函數(shù)定義：本地作用域
變量名解析：LEGB 原則：
變量名引用分三個(gè)作用域進(jìn)行： 首先是本地。之后是函數(shù)內(nèi)，接著是全局，最后是內(nèi)置
Python 創(chuàng)建、改變或查找變量名都是在名稱空間中進(jìn)行
在代碼中變量名被賦值的位置決定了其能被訪問到的返回
函數(shù)定義了本地作用域，而模塊定義了全局作用域
每個(gè)模塊都是一個(gè)全局作用域，因此，全局作用域的范圍僅限于單個(gè)程序文件
每次對函數(shù)的調(diào)用都會創(chuàng)建一個(gè)人新的本地作用域，賦值的變量除非聲明為全局變量，否則均為本地變量
所有的變量都可以歸納為本地、全局或內(nèi)置的（由_builtin_模塊所提供的）

轉(zhuǎn)載于:https://blog.51cto.com/11233559/2059485

總結(jié)

以上是生活随笔為你收集整理的Python之集合、解析式，生成器，函数的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。