摘要：根據我們已知的運行模式，我們沒法在函數返回之后繼續調用函數，在函數被調用的時候，變量早已不復存在，可能會發生一個運行時錯誤。萬萬沒想到，返回的函數居然能夠正常工作。

在Python中，文件的操作應用非常多，比如大數據領域，涉及許多數據處理請求，基本上都是從一個文件對數據進行分析、抽取、重寫進行梳理數據

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

下面我們來拆分下：

打開文件：python中打開文件使用open函數

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

通過句柄對文件進行操作

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

關閉文件

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

函數是組織好的、可重復使用的、用來實現單一或相關聯功能的代碼段，能夠提高應用的模塊性和代碼的重復利用率

如何定義函數

#sayhi為函數名，小括號里面用來定義函數所需要的參數
def sayhi():
    #函數體
    print("hello world");

sayhi(); #調用函數，如果沒有調用函數體不會執行

函數的參數

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

#1 ，2 我們稱為實參，形參和實參必須要一一對應
calc(1,2);

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

#-----------第三種：關鍵參數------------------
def calc(x,y):
    print("x:",x);
    print("y:", y);
calc(y=2,x=1);#注意當通過指定參數名傳遞的時候，名字必須一致不能寫錯

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

函數的返回值
函數我們可以理解為一個獨立的盒子，那么我們的外界和盒子里面如何進行溝通呢，我們可以通過返回值的方式，把想要的結果從盒子里面返回回來。

def calc(x,y):
    return x+y; #注意：在函數體內出現return會停止后續代碼的執行
    print("here") #這一句永遠不會被執行到，因為上一句已經return 終止了

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

局部變量和全局變量

局部變量：在函數內部定義的變量只能在函數內部使用，不能在函數外使用，這個變量的作用域是局部的

全局變量：在函數外，一段代碼最開始賦值的變量可以被多個函數引用。

count=1;#全局變量
def calc(x,y):
   #count=2; #這個count并不會改到全局的count
   #如何修改全局變量count?
   global count
   count=4; #修改到全局的變量
   sum=x+y; #sum為局部變量
   print(sum)
calc(1,2)
print(sum) #無法輸出，因為sum為局部變量
print(count)#輸出結果為4 

注意：雖然我們在函數內部可以操作全局變量，但是我們不建議這樣修改，因為函數的通用性，你不知道什么地方改了全局變量。

在一個函數的內部調用自己，這個函數稱為遞歸函數，形象點想想其實我們早都知道遞歸，比如從前有座山，山里有座廟，廟里有個老和尚在講故事，在講什么呢，從前有座山...

我們來用代碼看下

def say():
    print("從前有座山，山里有座廟，廟里有個老和尚在講故事，在講什么呢")
    return say()
say()
#通過遞歸計算1-100的和
def Calc(i):
    if i==1:
        return 1
    else:    
        return i+Calc(i-1)
print(Calc(100))  
#通過遞歸進行字符串反轉
str = input("請輸入若干字符：")
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]: #你要找的值大于中間數的時候
        return FindNumber(mid+1,high,n)
    if n < arr[mid]: #你要找的值小于中間數的時候
        return FindNumber(low,mid-1,n)
    
print(FindNumber(0,len(arr),7))
#優化后的版本
# arr=[1,3,6,9,10,20,30]
# def binary_search(data_source,find_n):
#     #取中位數
#     mid=int(len(data_source)/2)
#     if len(data_source)>=1:
#         if data_source[mid]>find_n:  #中位數大于要查找的數，則要查找的數在左半部分，繼續調用二分算法進行查找
#             binary_search(data_source[:mid],find_n)
#         elif data_source[mid]number:
#         h=mid
#         return findnumber(l,mid-1,number) 
#     else:
#         print("沒有找到")

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

#冒泡排序
arr=[1,4,2,10,33,99,20,0,100]
#外層循環
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)

匿名函數其實很好理解，匿名的話就是沒有名字的函數，定義的時候也不用def
Python使用lambda創建匿名函數，lambda只是一個表達式，語法也很簡單

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

通過上面的代碼我們發現使用lambda表達式定義匿名函數編寫的代碼比使用def要少
那么什么情況下使用匿名函數：

程序一次使用

用匿名函數可以節省內存中變量定義的空間

讓代碼更加簡潔

嵌套我們都知道，就是在一個函數里面再通過def定義一個函數

#函數嵌套
def outer():
　　def inner():
　　　　print("inner")
　　print("outer")
　　inner()
outer()
inner() #這句會報錯，因為inner的作用域只在outer內
#函數調用
def inner():
　　print("inner")
def outer():
　　print("outer")
    inner();

outer()

函數嵌套這塊有個注意事項就是作用域的問題，第二個就是只有通過def在內部定義才是嵌套，直接寫函數名是函數調用

一個函數接收另一個函數作為參數，這種函數就稱之為高階函數

def sayhi():
    print("hello")
def outer(func):
    func();#執行傳遞進來的函數
outer(sayhi)  #運行結果輸出hello      

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

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

我們來解讀下，x是函數outer里的一個局部變量。當函數inner在#1處打印x的時候，python解釋器會在inner內部查找相應的變量，當然會找不到，所以接著會到封閉作用域里面查找，并且會找到匹配

但是從變量的生存周期來看，該怎么理解呢？我們的變量x是函數outer的一個本地變量，這意味著只有當函數outer正在運行的時候才會存在。根據我們已知的python運行模式，我們沒法在函數outer返回之后繼續調用函數inner，在函數inner被調用的時候，變量x早已不復存在，可能會發生一個運行時錯誤。

萬萬沒想到，返回的函數inner居然能夠正常工作。Python支持一個叫做函數閉包的特性，用人話來講就是，嵌套定義在非全局作用域里面的函數能夠記住它在被定義的時候它所處的封閉命名空間。這能夠通過查看函數的func_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

裝飾器本質上來說也是函數（裝飾其他函數）就是為其他函數添加附加功能。裝飾器其實就是一個閉包，把一個函數當做參數然后返回一個替代版函數。

使用裝飾器有兩個原則：

不能修改被裝飾的函數的源代碼

不能修改被裝飾的函數的調用方式

根據上面我們高階函數和嵌套函數的理解，我們先試著寫一個裝飾器出來

#定義一個函數
def test1():
    print("in the test 1 ");
#現在需求給test1添加一些擴展功能，同時滿足裝飾器的兩個使用原則
def main(func): #傳進來的test1=func
    def deco():
        print("我是新加的功能");
        func();  
        print("我也是");  
    return deco; #deco為main函數的嵌套函數    
#怎么使用，注意test1不能加小括號
test1=main(test1)   
test1() 

上面代碼我們通過高階函數+嵌套函數完成了裝飾器，有沒有簡潔一點的寫法，python給我們提供了一個語法糖

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

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

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

最后補充一個知識點，如果裝飾器帶參數該如何使用呢？@login(參數)即可

只有在調用的時候才會生成相應的數據

#生成器
generator1 = ( i*i for i in range(10) )
for i in generator1:
    print(i)
#生成器函數:斐波那契數列
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b #因為使用了yield，它便不能再稱之為函數，而應該稱之為生成器
        a, b = b, a + b
        n += 1
    return "done"
fib_generator = fib(20)
print(fib_generator)   

我們通過一幅圖來理解下python中的變量、函數等對應內存中的存儲

我們可以看到，當我們定義一個變量的時候，會在內存中開辟一塊空間，存放我們的值，可以把這個內存空間理解為一個大廈中的小房間，那么每個房間都有一個門牌號，就是我們上圖中的name

我們要如何找到這個變量呢，通過name(門牌號)，函數也是一樣，把函數體存放在一個空間內，匿名函數不同，沒有門牌號，所以匿名函數運行完會被系統回收，那么其他的name和函數在沒有引用的時候也會被回收(也就是門牌號被摘掉了的時候，沒人引用了，就會被系統回收)