函數名的使用：
函數名是一個變量, 但它是一個特殊的變量, 與括號配合可以執行函數的變量
函數名的內存地址：
deffunc():pass
print(func) #函數的內存地址
結果：
函數名可以賦值給其他變量：
deffunc():print(1)
a=func
a()
func()#函數名可以當做值賦值給變量
結果：1
1
函數名可以當做容器類的元素：
deffunc():print(1)deffunc2():print(2)
li=[func,func2]print(li) #函數名可以當做元素放到容器里
結果：[, ](打印的是函數的內存地址，列表里的函數可以加括號，打印的是函數執行的結果，及列表的返回的None)deffunc():print(1)deffunc2():print(2)
li=[func(),func2()]print(li) #函數名可以當做元素放到容器里
結果：1
2[None, None]
函數名可以當做函數的參數:
deffunc():print("吃了么")deffunc2(fn):print("我是1")
fn()#執行傳遞過來的fn
print("我是2")
func2(func)#把函數func當成參數傳遞給func2的參數fn.
結果： 我是1
吃了么
我是2
函數名可以作為函數的返回值
deffunc_1():print("這里是函數1")deffunc_2():print("這里是函數2")print("這里是函數3")returnfunc_2
fn=func_1()#執行函數1. 函數1返回的是函數2, 這時fn指向的就是上面函數2
fn() #執行func_2函數
結果：
這里是函數1
這里是函數3
這里是函數2
deffunc():defaa():print(2)returnNonereturn aa() #return None#func() # func() == None
print(func())
結果：2None
例題：
li =[]for i in range(3): #for循環三次，三次最終結果i=2
def func(x): #定義函數，形參為x
print(x*i) #打印形參與i(2)相乘的結果
li.append(func) #將func依此添加到li列表當中，循環三次，添加三個，
#此時，列表里的func雖然外表相同，定義的函數相同，但內存地址不一樣，存在三個內存地址
for func in li: #將列表里的函數循環出來
func(2) #依此執行func函數，實參數為2
結果：4
4
4此時我要想將結果打印為0，2，4，只需定義一個數即可
li=[]for i in range(3): #for循環三次，循環為 i =(0，1，2)
def func(x,y=i): #定義函數，形參為x，y=循環的 i 值
print(x*y) #打印形參與y(0，1，2)相乘的結果
li.append(func) #將func依此添加到li列表當中，循環三次，添加三個，
#此時，列表里的func雖然外表相同，定義的函數相同，但內存地址不一樣，存在三個內存地址
for func in li: #將列表里的函數循環出來
func(2) #依此執行func函數，實參數為2
閉包
什么是閉包? 閉包就是內層函數, 對外層函數(非全局)的變量的引用. 叫閉包
# 1.一個嵌套函數
# 2.在嵌套函數的內部函數使用外部(非全局的變量)
# 滿足以上兩條就是閉包
defwrapper():
a= 10
definner():print(a)print(inner.__closure__) #不是None 就是閉包
inner()
wrapper()
結果:
(,)10
將里邊的函數名當做參數返回給調用者
defouter():
name= "alex"
#內部函數
definner():print(name)returninner
fn= outer() #訪問外部函數, 獲取到內部函數的函數地址
fn() #訪問內部函數
結果：alex
例：
money = 10
#全局里存放會有污染和不安全的現象
defwrapper():
money= 10
definner(num):global money #從全局調用money
money +=numprint(money)returninner
wrapper()(100) #第二個括號是return的返回值inner的執行，實參為100
# python中閉包,會進行內存駐留, 普通函數執行完后就銷毀了
# 全局里存放會有污染和不安全的現象
# 面試必問,裝飾器 -- 裝飾器的本質就是閉包
# 閉包有個弊端:會出現內存泄漏
迭代器
可迭代對象有哪些:str list tuple dic set
可迭代對象：可以被for的就是可迭代對象
# Python 協議
# 具有.__iter__方法的就是可迭代對象
# a = 對象.__iter__ # 創建一個迭代器
# 具有__iter__和__next__就是一個迭代器
可以for循環的就有__iter__方法,包括range
.這里的__iter__是幫助我們獲取到對象的迭代器.我們使用迭代器中的__next__()來獲取到一個迭代器的元素
li = [1,2,3]
a= li.__iter__()print(a.__next__())print(a.__next__()) #一個一個取
print(a.__next__())
結果：1
2
3
我們使用while循環和迭代器來模擬for循環: 必須要會：
lst = [6,5,4]
l= lst.__iter__()while 1:try:
i= l.__next__()print(i)except StopIteration #當遇到報錯的時候，就break退出
break
# 迭代器特性:
# 惰性機制
# 不能從下向上走
# 一次性的,用完就沒了
小總結：
Iterable: 可迭代對象. 內部包含__iter__()函數
? Iterator: 迭代器. 內部包含__iter__() 同時包含__next__().
迭代器的特點:
? 1. 節省內存.
? 2. 惰性機制
? 3. 不能反復, 只能向下執行.
我們可以把要迭代的內容當成子彈. 然后呢. 獲取到迭代器__iter__(), 就把子彈都裝在彈夾中. 然后發射就是__next__()把每一個子彈(元素)打出來. 也就是說, for循環的時候.一開始的 時候是__iter__()來獲取迭代器. 后面每次獲取元素都是通過__next__()來完成的. 當程序遇到 StopIteration將結束循環.
遞歸：
# 1. 自己玩自己 (自己調用自己本身)
# 2. 玩的有限制 (有明確結束條件)
count =0deffunc():globalcount
count+= 1
print(count)if count == 4: #當count=4時，返回
returnfunc()#產生遞歸現象
func()
打印1到100
deffunc(n):
n+=1
print(n)if n == 100:returnfunc(n)
func(0)
例題：
deffunc(age):print(age) #最后打印4
deffunc1(age):print(age) #3
func(age+1) #執行func,實參數位4
deffunc2(age):print(age) #2
func1(age+1) #執行func1，實參數位3
func2(2)
打印結果：2
3
4
作業：
1.寫函數，傳入n個數，返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此題用到max(),min()內置函數)2.寫函數，傳入一個參數n，返回n的階乘
例如:cal(7) 計算7*6*5*4*3*2*1
3.寫函數，返回一個撲克牌列表，里面有52項，每一項是一個元組
例如：[(‘紅心’，2),(‘草花’，2), …(‘黑桃’，‘A’)]4. 相關面試題(先從紙上寫好答案，然后在運行)：def calc(a,b,c,d=1,e=2):return (a+b)*(c-d)+e
請分別寫出下列標號代碼的輸出結果，如果出錯請寫出Error。print(calc(1,2,3,4,5))_____
print(calc(1,2))____
print(calc(e=4,c=5,a=2,b=3))___
print(calc(1,2,3))_____
print(calc(1,2,3,e=4))____
print(calc(1,2,3,d=5,4))_____下面代碼打印的結果分別是_________,________,________.def extendList(val,list=[]):
list.append(val)returnlist
list1= extendList(10)
list2= extendList(123,[])
list3= extendList('a')print('list1=%s'%list1)print('list2=%s'%list2)print('list3=%s'%list3)5.寫代碼完成99乘法表.(升級題)1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9......9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
