函式

程式語言中函式定義：函式是邏輯結構化和過程化的一種程式設計方法。先定義一個數函式，然後按照這個數學模型用程式語言去實現它。

def test(x):
    "The function definitions"
    x+=1
    return x
#def :定義函式的關鍵字
#test:函式名
#():內可定義形參
#"": 文件描述
#x+=1：函式體，泛指程式碼塊或程式處理邏輯
#return：定義返回值

#程式碼的重複利用
#列印日誌及時間
import time
def logger():
    time_format='%Y-%m-%d %X'
    time_current=time.strftime(time_format)
    with open('a.txt','a+') as f:
        f.write('%s end ation\n' %time_current)

def text1():
    print('in the text1')
    logger()

def text2():
    print('in the text2')
    logger()

def text3():
    print('in the text3')
    logger()

text1()
text2()
text3()
 

函式返回值： 返回值為0:返回None 返回值為1：返回object 為什麼要有返回值： 後面的其他程式邏輯需要根據返回值的結果來進行不同的操作

def hanshu():
   return 5,6,'sss',{'ff','gg'}['r','t']
 
 m=hanshu()
 #結果返回  ：
 5,6,'sss',{'ff','gg'}['r','t'] 

形參：形式引數，不是實際存在的，是虛擬變數。在定義函式和函式體的時候使用形參，目的是在函式呼叫時接收實參，實參個數，型別與實參相對應 實參：實際引數，呼叫函式時傳給函式的引數，可以是常量，變數，表示式，函式，傳給形參 區別：形參是虛擬的，不佔用記憶體空間，形參變數只要在被呼叫時才分配記憶體單元，實參是一個變數，佔用記憶體空間，資料傳輸單向，實參傳給形參，不能形參傳給實參。

關鍵字引數是不能寫在位置引數前面

def test(x,y):
    print(x)
    print(y)
 test(y=2,x=1)#與形參順序無關關鍵字呼叫
 test(1,2)  #與形參一一對應，位置呼叫
 #關鍵子呼叫和位置一起呼叫，按照位置的來，關鍵字引數是不能寫在位置引數前面
 

預設引數特特點： 呼叫函式時，預設引數非必須傳遞 用途：1 預設安裝值 2

引數組： 引數個數不固定，可接收多個實參 *args接收n個位置引數，轉換成元組形式

def text(*args)

test(1,2,3,4,5)

或者 test(*[1,2,3,4,5])#args=tuple([1,2,3,4,5])

def test(x,*args)

接收字典： 功能，**kwargs 把n個關鍵字引數轉換成字典的方式 def test2(kwargs): print(kwargs) test2(name=‘ss’,age=1,sex=‘n’) #關鍵字引數 test2（name=‘aa’,age=5,sex=‘s’) test2({‘name’:‘aa’,‘age’:8}

def test2(**kwargs):
     print(kwargs)
     print(kwargs['name'])
     print(kwargs['sex'])
     print(kwargs['age'])

test2(name='aa',sex='d',age =4)

#跟位置引數一起呼叫
def test3(name,**kwargs):
    print(name)
    print(kwargs)

test3('bb') #不需要指定後面的返回值： bb  {}
test3('cc',s='3')

#跟預設引數一起
def test4(name,age=1,**kwargs):  #引數組一定放到最後   def test4(name,**kwargs,age=1)錯誤寫法
    print(name)
    print(age)
    print(kwargs)

test4('dd',sex='v',data='ee')
test('dd',3,sex='v',data='ee')

def test5(name.age=3,*args,**kwargs):
    print(name)
    print(age)
    print(kwargs)
    print(args)
 test('dd',age=3,sex='v',data='ee',s=33)

區域性變數和全域性變數： 區域性變數：只在函式體內生效，這個函式就是這個變數的作用域，然後釋放，只是針對字元，數字，變數是集合，字典，陣列中是可以改變的 全域性變數：在函式體內是改變不了的，如果硬改： global 加上這個關鍵字 在函式體內改一個全域性變數，程式都呼叫這個函式，變數，不容易找到出錯區

遞迴 ：在函式內部，可以呼叫其他函式，如果一個函式在內部呼叫自身本身，這個函式就是遞迴函式 遞迴特性： 1 必須有一個明確的結束條件 2 每次進入更深一層遞迴時，問題規模相比上次遞迴夠應有所減少 3 遞迴效率不高，遞迴層次過多會導致棧溢位（在計算機中，函式呼叫是通過棧這種資料結構實現，每當進入一個函式呼叫，棧就會加一層棧幀，每當函式 返回，棧就會減一層棧幀，由於棧的大小不適宜無限的，所以遞迴呼叫的次數過多會導致棧溢位

ef calc(n):
    print(n)
    if int(n/2)==0:
        return n
    return calc(int(n/2))

calc(10)

匿名函式：不需要顯式的指定函式，主要是和其他函式搭配使用

#原求值幾次方
def  locals(n):
    return n**n
print(locals(10))
#改為匿名函式
locals=lambda n:n**n
print(locals(10))

#搭配使用
res=map(lambda x:x**2,[1,3,7,4,8])
for i in res:
    print(i)

函數語言程式設計：

函式是Python內建支援的一種封裝，我們通過把大段程式碼拆成函式，通過一層一層的函式呼叫，就可以把複雜任務分解成簡單的任務，這種分解可以稱之為面向過程的程式設計。函式就是面向過程的程式設計的基本單元。 函數語言程式設計，可以歸結到買你想過程的程式設計，但是其思想更接近數學計算 在計算機的層次上，CPU執行的是加減乘除的指令程式碼，以及各種條件判斷和跳轉指令，所以組合語言是最貼近計算機語言 計算則是數學意義上的計算，越是抽象的計算，離計算機硬體越遠 ‘對應到程式語言，就是越低階的語言，越貼近計算機。抽象程度低，執行效率高，比如C語言，越高階的語言越貼近計算，抽象程度越高，執行效率越低，比如ISP語言 函數語言程式設計就是抽象程度很高的程式設計正規化，純粹的函數語言程式設計語言編寫的函式沒有變數，因此，任意一個函式，只要輸入是確定的，輸出就是確定的，這種純函式我們稱之為沒有副作用，而允許使用變數的程式設計語言，由於函式內部的變數狀態不確定，同樣的輸入，可能得到不同的輸出結果，因此，這種函式是有副作用的。

函數語言程式設計中的函式這個術語不是指計算機中的函式（實際上是Subroutine），而是指數學中的函式，即自變數的對映。也就是說一個函式的值僅決定於函式引數的值，不依賴其他狀態。比如sqrt(x)函式計算x的平方根，只要x不變，不論什麼時候呼叫，呼叫幾次，值都是不變的。 函數語言程式設計"是一種"程式設計正規化"（programming paradigm），也就是如何編寫程式的方法論。 主要思想是把運算過程儘量寫成一系列巢狀的函式呼叫 Python對函數語言程式設計提供部分支援。由於Python允許使用變數，因此，Python不是純函數語言程式設計語言 　 var result = subtract(multiply(add(1,2), 3), 4); 再演進: add(1,2).multiply(3).subtract(4) 高階函式： 變數可以指向函式，函式的引數能接收變數，那麼一個函式就可以接收另一個函式作為引數，這種函式就稱之為高階函式 def add(x,y,f): return f(x) + f(y)

res = add(3,-6,abs) print(res)