摘要：根據(jù)我們已知的運(yùn)行模式，我們沒(méi)法在函數(shù)返回之后繼續(xù)調(diào)用函數(shù)，在函數(shù)被調(diào)用的時(shí)候，變量早已不復(fù)存在，可能會(huì)發(fā)生一個(gè)運(yùn)行時(shí)錯(cuò)誤。萬(wàn)萬(wàn)沒(méi)想到，返回的函數(shù)居然能夠正常工作。

在Python中，文件的操作應(yīng)用非常多，比如大數(shù)據(jù)領(lǐng)域，涉及許多數(shù)據(jù)處理請(qǐng)求，基本上都是從一個(gè)文件對(duì)數(shù)據(jù)進(jìn)行分析、抽取、重寫(xiě)進(jìn)行梳理數(shù)據(jù)

文件的讀寫(xiě)分幾步?如何把大象放冰箱

下面我們來(lái)拆分下：

打開(kāi)文件：python中打開(kāi)文件使用open函數(shù)

        open(filename,[access_mode],[buffering]
        filename:要看打開(kāi)的文件路徑
        access_mode:選填，打開(kāi)文件的模式，r只讀，w只寫(xiě)，a讀寫(xiě) 等..
        buffering:選填，緩沖大小 0為不寄存 1 寄存行 大于1 為寄存區(qū)的緩沖大小
        例：f=open("song.txt","r",encoding="utf-8")
        理解：open函數(shù)返回的是一個(gè)File對(duì)象，有file對(duì)象才能進(jìn)行后續(xù)的讀寫(xiě)操作

通過(guò)句柄對(duì)文件進(jìn)行操作

        讀：fileObject.read([count]) #count為字節(jié)數(shù)，不傳遞默認(rèn)讀取整個(gè)文件,當(dāng)文件太大的時(shí)候我們不建議直接通過(guò)read一次讀取完成
        讀：fileObject.readline() #讀取下一行，需要配合for in 來(lái)使用
        讀：fileObject.readlines() #讀取整個(gè)文件到一個(gè)迭代器以供我們遍歷
        寫(xiě)：fileObject.write("啦啦
啦啦啦") 
        注意：讀寫(xiě)操作需要看下open函數(shù)設(shè)置的打開(kāi)模式，是讀還是寫(xiě)
        

關(guān)閉文件

        顯示關(guān)閉：fileObject.close();
        注意：一般情況下一個(gè)文件對(duì)象在退出程序后會(huì)自動(dòng)關(guān)閉，但是為了安全起見(jiàn)，我們通過(guò)close方法關(guān)閉文件
        覺(jué)得太過(guò)繁瑣？python也這么覺(jué)得，所以給我們提供了另外一種方式，自動(dòng)幫你close(): 
        with open("song.txt","r",encoding="utf-8") as f:    
                for line in f:
                        print(line)
   

函數(shù)是組織好的、可重復(fù)使用的、用來(lái)實(shí)現(xiàn)單一或相關(guān)聯(lián)功能的代碼段，能夠提高應(yīng)用的模塊性和代碼的重復(fù)利用率

如何定義函數(shù)

#sayhi為函數(shù)名，小括號(hào)里面用來(lái)定義函數(shù)所需要的參數(shù)
def sayhi():
    #函數(shù)體
    print("hello world");

sayhi(); #調(diào)用函數(shù)，如果沒(méi)有調(diào)用函數(shù)體不會(huì)執(zhí)行

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

#-----------第一種：必須參數(shù)------------------
#calc參數(shù)我們稱(chēng)為形參 （x , y）
def calc(x,y):
    print(x+y);

#1 ，2 我們稱(chēng)為實(shí)參，形參和實(shí)參必須要一一對(duì)應(yīng)
calc(1,2);

#-----------第二種：默認(rèn)參數(shù)------------------
def calc(x,y=10):
    print(x+y);
calc(2);#如果不傳遞第二個(gè)參數(shù)，則默認(rèn)值為10，如果傳遞了以你傳遞的為準(zhǔn)

#-----------第三種：關(guān)鍵參數(shù)------------------
def calc(x,y):
    print("x:",x);
    print("y:", y);
calc(y=2,x=1);#注意當(dāng)通過(guò)指定參數(shù)名傳遞的時(shí)候，名字必須一致不能寫(xiě)錯(cuò)

#-----------第四種：可變參數(shù)------------------
def calc(x,y,*arg): #加了*號(hào)的變量會(huì)存放所有未命名的變量參數(shù)，如果沒(méi)有多余的參數(shù)，這種arg是一個(gè)空元組
    print("x:",x);
    print("y:", y);
    print("arg:", arg);
calc(1,2,"zhangsan",20) #輸出結(jié)果為x: 1   y: 2   arg: ("zhangsan", 20)

函數(shù)的返回值
函數(shù)我們可以理解為一個(gè)獨(dú)立的盒子，那么我們的外界和盒子里面如何進(jìn)行溝通呢，我們可以通過(guò)返回值的方式，把想要的結(jié)果從盒子里面返回回來(lái)。

def calc(x,y):
    return x+y; #注意：在函數(shù)體內(nèi)出現(xiàn)return會(huì)停止后續(xù)代碼的執(zhí)行
    print("here") #這一句永遠(yuǎn)不會(huì)被執(zhí)行到，因?yàn)樯弦痪湟呀?jīng)return 終止了

sum=calc(1,2);#calc函數(shù)有返回值，需要有東西接收返回回來(lái)的結(jié)果
print(sum)

局部變量和全局變量

局部變量：在函數(shù)內(nèi)部定義的變量只能在函數(shù)內(nèi)部使用，不能在函數(shù)外使用，這個(gè)變量的作用域是局部的

全局變量：在函數(shù)外，一段代碼最開(kāi)始賦值的變量可以被多個(gè)函數(shù)引用。

count=1;#全局變量
def calc(x,y):
   #count=2; #這個(gè)count并不會(huì)改到全局的count
   #如何修改全局變量count?
   global count
   count=4; #修改到全局的變量
   sum=x+y; #sum為局部變量
   print(sum)
calc(1,2)
print(sum) #無(wú)法輸出，因?yàn)閟um為局部變量
print(count)#輸出結(jié)果為4 

注意：雖然我們?cè)诤瘮?shù)內(nèi)部可以操作全局變量，但是我們不建議這樣修改，因?yàn)楹瘮?shù)的通用性，你不知道什么地方改了全局變量。

在一個(gè)函數(shù)的內(nèi)部調(diào)用自己，這個(gè)函數(shù)稱(chēng)為遞歸函數(shù)，形象點(diǎn)想想其實(shí)我們?cè)缍贾肋f歸，比如從前有座山，山里有座廟，廟里有個(gè)老和尚在講故事，在講什么呢，從前有座山...

我們來(lái)用代碼看下

def say():
    print("從前有座山，山里有座廟，廟里有個(gè)老和尚在講故事，在講什么呢")
    return say()
say()
#通過(guò)遞歸計(jì)算1-100的和
def Calc(i):
    if i==1:
        return 1
    else:    
        return i+Calc(i-1)
print(Calc(100))  
#通過(guò)遞歸進(jìn)行字符串反轉(zhuǎn)
str = input("請(qǐng)輸入若干字符：")
def f(x):
    if x == -1:
        return ""
    else:
        return str[x] + f(x-1)
print(f(len(str)-1))  

#順序查找
def search(arr,n):
    for s in arr:
        if s==n:
            print("找到")

search([1,4,7,8,10,39,2],7)

#二分查找
arr=[1,4,7,9,10,20,50]

def FindNumber(low,high,n):
    mid = (low + high)// 2
    if arr[mid] == n:
        return mid
    if n > arr[mid]: #你要找的值大于中間數(shù)的時(shí)候
        return FindNumber(mid+1,high,n)
    if n < arr[mid]: #你要找的值小于中間數(shù)的時(shí)候
        return FindNumber(low,mid-1,n)
    
print(FindNumber(0,len(arr),7))
#優(yōu)化后的版本
# arr=[1,3,6,9,10,20,30]
# def binary_search(data_source,find_n):
#     #取中位數(shù)
#     mid=int(len(data_source)/2)
#     if len(data_source)>=1:
#         if data_source[mid]>find_n:  #中位數(shù)大于要查找的數(shù)，則要查找的數(shù)在左半部分，繼續(xù)調(diào)用二分算法進(jìn)行查找
#             binary_search(data_source[:mid],find_n)
#         elif data_source[mid]number:
#         h=mid
#         return findnumber(l,mid-1,number) 
#     else:
#         print("沒(méi)有找到")

# findnumber(0,len(arr)-1,30)        

#冒泡排序
arr=[1,4,2,10,33,99,20,0,100]
#外層循環(huán)
for i in range(0,len(arr)-1):
    for j in range(0,len(arr)-1-i):
        if arr[j]>arr[j+1]:
            n=arr[j]
            arr[j]=arr[j+1]
            arr[j+1]=n
          
print(arr)

匿名函數(shù)其實(shí)很好理解，匿名的話就是沒(méi)有名字的函數(shù)，定義的時(shí)候也不用def
Python使用lambda創(chuàng)建匿名函數(shù)，lambda只是一個(gè)表達(dá)式，語(yǔ)法也很簡(jiǎn)單

#正常函數(shù)
def calc(x,y):
    return x+y;
#使用lambda表達(dá)式
n=lambda x,y:x+y    #x,y為所需要的參數(shù)，:為分割符 x+y 則是返回值
print(n(2,3))

通過(guò)上面的代碼我們發(fā)現(xiàn)使用lambda表達(dá)式定義匿名函數(shù)編寫(xiě)的代碼比使用def要少
那么什么情況下使用匿名函數(shù)：

程序一次使用

用匿名函數(shù)可以節(jié)省內(nèi)存中變量定義的空間

讓代碼更加簡(jiǎn)潔

嵌套我們都知道，就是在一個(gè)函數(shù)里面再通過(guò)def定義一個(gè)函數(shù)

#函數(shù)嵌套
def outer():
　　def inner():
　　　　print("inner")
　　print("outer")
　　inner()
outer()
inner() #這句會(huì)報(bào)錯(cuò)，因?yàn)閕nner的作用域只在outer內(nèi)
#函數(shù)調(diào)用
def inner():
　　print("inner")
def outer():
　　print("outer")
    inner();

outer()

函數(shù)嵌套這塊有個(gè)注意事項(xiàng)就是作用域的問(wèn)題，第二個(gè)就是只有通過(guò)def在內(nèi)部定義才是嵌套，直接寫(xiě)函數(shù)名是函數(shù)調(diào)用

一個(gè)函數(shù)接收另一個(gè)函數(shù)作為參數(shù)，這種函數(shù)就稱(chēng)之為高階函數(shù)

def sayhi():
    print("hello")
def outer(func):
    func();#執(zhí)行傳遞進(jìn)來(lái)的函數(shù)
outer(sayhi)  #運(yùn)行結(jié)果輸出hello      

我們先不急著定義什么是閉包，先來(lái)看看一段代碼

def outer():
     x = 1
     def inner():
         print(x) #輸出1
     return inner
foo = outer()

我們來(lái)解讀下，x是函數(shù)outer里的一個(gè)局部變量。當(dāng)函數(shù)inner在#1處打印x的時(shí)候，python解釋器會(huì)在inner內(nèi)部查找相應(yīng)的變量，當(dāng)然會(huì)找不到，所以接著會(huì)到封閉作用域里面查找，并且會(huì)找到匹配

但是從變量的生存周期來(lái)看，該怎么理解呢？我們的變量x是函數(shù)outer的一個(gè)本地變量，這意味著只有當(dāng)函數(shù)outer正在運(yùn)行的時(shí)候才會(huì)存在。根據(jù)我們已知的python運(yùn)行模式，我們沒(méi)法在函數(shù)outer返回之后繼續(xù)調(diào)用函數(shù)inner，在函數(shù)inner被調(diào)用的時(shí)候，變量x早已不復(fù)存在，可能會(huì)發(fā)生一個(gè)運(yùn)行時(shí)錯(cuò)誤。

萬(wàn)萬(wàn)沒(méi)想到，返回的函數(shù)inner居然能夠正常工作。Python支持一個(gè)叫做函數(shù)閉包的特性，用人話來(lái)講就是，嵌套定義在非全局作用域里面的函數(shù)能夠記住它在被定義的時(shí)候它所處的封閉命名空間。這能夠通過(guò)查看函數(shù)的func_closure屬性得出結(jié)論，這個(gè)屬性里面包含封閉作用域里面的值（只會(huì)包含被捕捉到的值，比如x，如果在outer里面還定義了其他的值，封閉作用域里面是不會(huì)有的)

記住，每次函數(shù)outer被調(diào)用的時(shí)候，函數(shù)inner都會(huì)被重新定義。現(xiàn)在變量x的值不會(huì)變化，所以每次返回的函數(shù)inner會(huì)是同樣的邏輯，假如我們稍微改動(dòng)一下呢？

def outer(x):
     def inner():
         print x # 1
     return inner
print1 = outer(1)
print2 = outer(2)
print1()
1
print2()
2

裝飾器本質(zhì)上來(lái)說(shuō)也是函數(shù)（裝飾其他函數(shù)）就是為其他函數(shù)添加附加功能。裝飾器其實(shí)就是一個(gè)閉包，把一個(gè)函數(shù)當(dāng)做參數(shù)然后返回一個(gè)替代版函數(shù)。

使用裝飾器有兩個(gè)原則：

不能修改被裝飾的函數(shù)的源代碼

不能修改被裝飾的函數(shù)的調(diào)用方式

根據(jù)上面我們高階函數(shù)和嵌套函數(shù)的理解，我們先試著寫(xiě)一個(gè)裝飾器出來(lái)

#定義一個(gè)函數(shù)
def test1():
    print("in the test 1 ");
#現(xiàn)在需求給test1添加一些擴(kuò)展功能，同時(shí)滿(mǎn)足裝飾器的兩個(gè)使用原則
def main(func): #傳進(jìn)來(lái)的test1=func
    def deco():
        print("我是新加的功能");
        func();  
        print("我也是");  
    return deco; #deco為main函數(shù)的嵌套函數(shù)    
#怎么使用，注意test1不能加小括號(hào)
test1=main(test1)   
test1() 

上面代碼我們通過(guò)高階函數(shù)+嵌套函數(shù)完成了裝飾器，有沒(méi)有簡(jiǎn)潔一點(diǎn)的寫(xiě)法，python給我們提供了一個(gè)語(yǔ)法糖

@main  #這個(gè)地方的main就是你裝飾的新功能，等同上面代碼里面的  test1=main(test1)  
def test1():
    print("in the test 1 ");
test1()    

但是如果我的函數(shù)需要參數(shù)該如何使用呢，在deco加上*args 非固定參數(shù)即可。

user,pwd="admin","123"
#login為一個(gè)裝飾器
def login(func):
    def wrapper(*args):
        username=input("請(qǐng)輸入賬號(hào):").strip()
        password=input("請(qǐng)輸入密碼:").strip()
        if(user==username and pwd==password):
            print("登錄成功")
            func(*args)
        else:
            print("驗(yàn)證失敗")  
    return wrapper;
@login    
def home():
    print("in the home")
    
home() #模擬首頁(yè)訪問(wèn)                  

最后補(bǔ)充一個(gè)知識(shí)點(diǎn)，如果裝飾器帶參數(shù)該如何使用呢？@login(參數(shù))即可

只有在調(diào)用的時(shí)候才會(huì)生成相應(yīng)的數(shù)據(jù)

#生成器
generator1 = ( i*i for i in range(10) )
for i in generator1:
    print(i)
#生成器函數(shù):斐波那契數(shù)列
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b #因?yàn)槭褂昧藋ield，它便不能再稱(chēng)之為函數(shù)，而應(yīng)該稱(chēng)之為生成器
        a, b = b, a + b
        n += 1
    return "done"
fib_generator = fib(20)
print(fib_generator)   

我們通過(guò)一幅圖來(lái)理解下python中的變量、函數(shù)等對(duì)應(yīng)內(nèi)存中的存儲(chǔ)

我們可以看到，當(dāng)我們定義一個(gè)變量的時(shí)候，會(huì)在內(nèi)存中開(kāi)辟一塊空間，存放我們的值，可以把這個(gè)內(nèi)存空間理解為一個(gè)大廈中的小房間，那么每個(gè)房間都有一個(gè)門(mén)牌號(hào)，就是我們上圖中的name

我們要如何找到這個(gè)變量呢，通過(guò)name(門(mén)牌號(hào))，函數(shù)也是一樣，把函數(shù)體存放在一個(gè)空間內(nèi)，匿名函數(shù)不同，沒(méi)有門(mén)牌號(hào)，所以匿名函數(shù)運(yùn)行完會(huì)被系統(tǒng)回收，那么其他的name和函數(shù)在沒(méi)有引用的時(shí)候也會(huì)被回收(也就是門(mén)牌號(hào)被摘掉了的時(shí)候，沒(méi)人引用了，就會(huì)被系統(tǒng)回收)