函數與函數式編程

1 面向對象 　　類-->class　　

2 面向過程 　　過程-->def

3 函數式編程 　　函數-->def

數學中函數的定義：

一般的，在一個變化過程中，假設有兩個變量x、y，如果對於任意一個x都有唯一確定的一個y和它對應，那麽就稱x是自變量，y是x的函數。x的取值範圍叫做這個函數的定義域，相應y的取值範圍叫做函數的值域

編程語言中函數的定義：

函數是邏輯機構化和過程化的一種編程方法。

#python中函數定義方法
def func_test():
    "the function definitions"
    x+=1
    return
 
 x

def :定義函數的關鍵字
func_test:函數體
(): 裏面可以定義形參
"" :文檔描述
x+=1:代碼塊或程序處理邏輯
return :定義返回值 

函數與過程

#定義一個函數
def func_test01():
    "testing"
    print("In the func_test01")
    return 0

#定義一個過程
def func_test02():
    "Testing"
    print("In the func_test02")

#調用 函數名+括號
func_test01()
func_test02()

#過程是沒有返回值的函數
 

#賦值變量
x = func_test01() #有返回值
y = func_test02()
print("In the func_test01 %s" %x) #In the func_test01 0
print("In then func_test02 %s" %y) #In then func_test02 None

使用函數的好處
1.代碼的重復利用
2.可擴展性，保持一致性

#模擬日誌添加功能
def logger():
    with open(‘log.txt‘,‘a+‘) as f:
        f.write(‘end action\n‘)

def test1():
    
 
print("In the test1")
    logger()

def test2():
    print("In the test2")
    logger()

def test3():
    print("In the test3")
    logger()

#調用
test1()
test2()
test3()

#優化添加功能 加上時間的功能 改變一處其它地方進行調用 
import time
def logger():
    time_format = ‘%Y-%m-%d %X‘ #時分秒
    time_current = time.strftime(time_format)
    with open(‘log.txt‘,‘a+‘) as f:
        f.write(‘%s end action\n‘ %time_current)

def test1():
    print("In the test1")
    logger()

def test2():
    print("In the test2")
    logger()

def test3():
    print("In the test3")
    logger()

#調用
test1()
test2()
test3()

函數的返回值

返回值是為了要知道函數的執行結果，後面的程序可以根據返回值進行不同的邏輯操作。

#return和接受返回值 
def test1():
    print("In the test1")
    return 0 #碰到return會終止函數，下面的代碼不會執行
    print("test end") #上面有return語句這個不會執行

test1()
#接受函數的返回值 直接賦值給變量
x = test1()
print(x) # 返回值為0

#return返回值
def test1():
    print("In the test1")

def test2():
    print("In the test2")
    return 0

def test3():
    print("In the test3")
    return 1,‘A‘,[‘A‘,‘B‘],{‘A‘:‘python‘}

x = test1()
y = test2()
z = test3()
print(x) #None 沒有定義返回值返回None 
print(y) #0
print(z) #(1, ‘A‘, [‘A‘, ‘B‘], {‘A‘: ‘python‘}) 返回一個元組tuple

有參數的函數

#有參數的函數
#x y叫形參
def test(x,y):
    print(x)
    print(y)
#1，2叫實參 實際占用空間，真實存在內存中的變量
#位置參數調用 形參和實參是一一對應的關系
test(1,2)
#關鍵字參數調用 關鍵字參數可以無序
test(y=2,x=1)
#組合參數調用 位置參數要在關鍵字參數前面 
test(1,y=2)
test(x=1,2) #這個執行報錯 位置參數在關鍵字參數後面

#默認參數
def test(x,y=2):
    print(x)
    print(y)

test(1) #默認參數可以不傳遞參數
test(1,y=3)

#參數組 實參個數不固定，定義形參
def test(*args):
    print(args)

test(1,2,3,4,5) #(1, 2, 3, 4, 5)   放到一個元組裏面
test(*[1,2,3,4,5]) #(1, 2, 3, 4, 5)

#默認參數
#1.調用函數的時候，默認參數可以不傳遞。
#2.應用場景：如安裝軟件時默認安裝；

def test(x,y=2):
    print(x)
    print(y)
test(1) #默認參數可以不傳遞參數
test(1,y=3)

#*args 參數組 實參個數不固定，定義形參
# 接受N個位置參數,轉換為元組
def test(*args):
    print(args)
test(1,2,3,4,5) #(1, 2, 3, 4, 5)   放到一個元組裏面
test(*[1,2,3,4,5]) #(1, 2, 3, 4, 5)
#與位置參數結合使用
def test(x,*args):
    print(x)
    print(args)
test(1,2,3,4,5,)  #1    (2, 3, 4, 5)

#**kwargs 接受字典的方式 關鍵字轉換為字典的方式
#接受關鍵字參數，轉換為字典
def test(**kwargs):
    print(kwargs)
    print(kwargs[‘name‘])
test(name="A",age=22) #{‘name‘: ‘A‘, ‘age‘: 22}
test(**{‘name‘:‘A‘,‘age‘:22}) #{‘age‘: 22, ‘name‘: ‘A‘}
#組合應用 參數組必須放在其它參數的後面
def test(name,age=18,**kwargs):
    print(name)
    print(age)
    print(kwargs)
test("test") #不指定會接受一個空字典  test {}
test("test",age=22,sex=‘M‘) #test 22 {‘sex‘: ‘M‘}
test("test",sex=‘M‘,age=22) #效果同上

#綜合應用
def test(name,age=18,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)
test(‘test‘,age=22,sex=‘M‘,job=‘IT‘)
test(‘test‘,22,‘cat‘,sex=‘M‘,job=‘IT‘)

#前向引用
#函數action嵌套某一函數logger，該logger必須早於action函數的調用，否則報錯
def action():
    print("In the action")
    logger()
action() #這個會報錯

def logger():
    print("In the logger")
def action():
    print("In the action")
    logger()
action()

全局與局部變量

#局部變量 只在函數裏生效 子程序中定義的變量
def change_name(name):
    print("before change",name) #before change python
    name = "java"
    print("after change",name) #after change java
name = "python"
change_name(name)
print(name) #python

#全局變量 在一開始定義的變量為全局變量
course = ‘python‘
def change_name(name):
    global course #在函數裏面改全局變量 禁用 
    course = ‘php‘
    print("before change",name,course)
    name = "java"
    print("after change",name)
name = "sql"
change_name(name)
print(name)
print(course) #php

#在子程序中定義全局變量
def change_name():
    global name #禁用
    name = "python"
change_name()
print(name) #python

#局部改全局 字符串和數字不能改
names = ["A","B","C"]
def change_name():
    names[0] = "python"
    print(names)
change_name()
print(names) #[‘python‘, ‘B‘, ‘C‘]

遞歸

一個函數在內部調用自身，這個函數就是遞歸函數

遞歸特性：

1.必須有一個明確的結束條件。

2.每次進入更深一層遞歸時，問題規模相比上次遞歸都應有所減少

3.遞歸效率不高，遞歸層次過多會導致棧溢出。

#遞歸函數
def cacl(n):
    print(n)
    if int(n/2) > 0: #int可以把小數變為整數
        return cacl(n/2)
cacl(10)

高階函數

一個函數可以接受另一個函數作為參數，這種函數稱為高階函數。

#高階函數
def add(x,y,f):
    return f(x)+f(y)
res = add(3,-3,abs) #把abs絕對值函數當作一個參數傳給函數add作為參數
print(res) #6

匿名函數

匿名函數就是不需要顯式的指定函數

#函數
def call(n):
    return n*n
print(call(10)) # 100
#轉換成匿名函數
call = lambda n:n*n
print(call(10)) #100

#匿名函數主要是和其它函數搭配使用
result = map(lambda x:x**2,[1,3,5,7])
for i in result:
    print(i) #1 9 25 49

python之旅--函數