Python知識6 函數式程式設計和裝飾器【多測師】

一、函數式程式設計之高階函數
print(abs(-10))
結果：10
<built-in function abs> —abs(-10)是函數調用 abs是函數本身
獲得函數調用的結果 可以把結果指派給變量
x=abs(-13)
print(x)
結果：13
把函數本身指派給變量
x=abs
print(x)
<built-in function abs>—-結論：函數本身可以指派給變量 變量可以指向函數

通過該變量來調用這個函數
x=abs
print(x(-12))
結論：變量x已經指向了abs函數本身 直接調用abs()函數和調用變量x()完全相同

二、函數名 —函數名也是變量
1.函數名就是指向函數的變量 把abs看成變量 它指向一個可以計算絕對值的函數
2.abs函數定義在import builtins子產品當中

三、函數可以指向變量 (高階函數)
1.舉例一個簡單的高階函數
def add(x,y,a):
    return a(x)+a(y)

print(add(1,-2,abs))
結果：3

四、高階函數之map/reduce
1.Python內建的函數
2.代碼實作：
def f(x):
    return x*x

r=map(f,[1,2,3,4,5])
print(list(r))
3.不用map()函數 直接寫一個循環來進行計算
def f(x):
    return x*x

L=[]
for n in [1,2,3,4,5]:
    L.append(f(n))

print(L)
4.reduce 求一個序列的和
from functools import reduce

def add(x,y):
    return x+y

print(reduce(add,[1,3,5,7,9]))
運作結果：25
5.reduce內建函數
from functools import reduce

def fn(x,y):
    return x*10+y

print(reduce(fn,[1,3,5,7,9]))

五、高階函數之filter
1.python內建filter()函數用于過濾序列
根據傳回值的true和false 決定是否保留或丢棄該元素
def is_odd(n):
    return n%2 == 1

print(list(filter(is_odd,[1,3,5,8,19])))
結果：[1, 3, 5, 19]
2.把序列的空字元串删除
def no_empty(s):
    return s and s.strip()

print(list(filter(no_empty,['A','','B',None,'C',''])))
3.用filter求素數
def _odd_iter():
    n = 1
    while True:
        n = n+2
        yield n

def _not_divisible(n):
    return lambda x:x%n>0

def primas():
    yield 2
    it =_odd_iter()
    while True:
        n = next(it)
        yield n
        it = filter(_not_divisible(n),it)

for n in primas():
    if n <1000:
        print(n)
    else:
        break

六、高階函數之sorted
1.排序算法 sorted排序
print(sorted([36,12,3,6,91]))
2.按絕對值排序 接受一個key函數實作自定義排序
print(sorted([-12,4,7,19,-1],key=abs))
3.字典串排序 傳入key值可以忽略字母的大小寫進行排序
print(sorted(['bob','about','zoo','credit'],key=str.lower))
4.倒叙排序 加上reverse=True
print(sorted(['bob','about','zoo','credit'],key=str.lower,reverse=True))

七、傳回函數
1.傳回函數：函數作為傳回值
def lazy_num(*args):  #在lazy_num中定義了函數sum 内部函數sum可以引用外部函數
    def sum():        #lazy_num的參數和局部變量
        ax = 0
        for n in args:
            ax=ax+n
        return ax
    return sum

p1=lazy_num(1,2,7,12,13)
p2=lazy_num(87,34,1,41)
print(p1())
print(p2())

2.什麼叫閉包？
就是在一個函數裡面定義了一個新的函數，這個新的内部函數可以引用外部函數的參數和局部變量，當外部函數傳回内部函數的時候，相關的參數和變量都儲存在傳回的參數中這種就稱為閉包。。。
3.接上面 傳回的函數在其定義内部引用了局部變量args 當一個函數傳回一個函數後 其内部的局部變量被新函數引用，而且要用p1()調用 直接用p1是調用不了的

八、匿名函數
1.以map()函數為例，計算f(x)=x2時，除了定義一個f(x)的函數外，還可以直接傳入匿名函數：
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
2.匿名函數lambda x: x * x實際上就是：
def f(x):
    return x * x

3. 關鍵字lambda表示匿名函數，冒号前面的x表示函數參數。匿名函數隻能有一個表達式 不用寫return 傳回值就是該表達式的結果
4.匿名函數式一個函數對象，可以把匿名函數指派給一個變量 再利用變量來調用該函數
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25
5.也可以把匿名函數作為傳回值傳回
def build(x, y):
    return lambda: x * x + y * y

九、裝飾器
1.裝飾器：函數也是一個對象 且函數對象可以被指派給變量 是以變量也能調用該函數
>>> def now():
...     print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25
2.函數對象有一個__name__屬性，可以拿到函數的名字
>>> now.__name__
'now'
>>> f.__name__
'now'
3.裝飾器(Decorator)：假設要增強now()函數的功能，又不希望修改now()函數的定義 這種在代碼運作期間動态增加功能的方式稱為：裝飾器(Decorator)

代碼如下：
def log(func):
    def wrapper(*args,**kw):
        print('call %s:' % func.__name__)
        return func(*args,**kw)
    return wrapper

@log
def now():
    print('2018-05-08')

now()

十、偏函數
1.通過設定參數的預設值，降低函數調用的難度
int()函數可以把字元串轉換為整數
>>> int('12345') ---int()函數預設按十進制轉換
12345
print(int('12345',base=8)) ---傳入base參數 可以做2-36進制轉換
2.轉換大量的二進制字元串
def int2(x,base=2):
    return int(x,base)

print(int2('1000000'))
3.建立偏函數 實際上固定了int()函數的關鍵字參數base
import functools

int2=functools.partial(int,base=2)
print(int2('10101'))
4.args=(10,5,6,7,)
print(max(*args))