5.python函數

函數介紹

定義:  函數是指將一組語句的集合通過一個名字(函數名)封裝起來，要想執行這個函數，只需調用其函數名即可。

特性：減少重復代碼、使程序變的可擴展、使程序變得易維護

 1.普通參數

def func(name):     #name是形式參數
    print(name)      #函數體

func('derek')       #執行函數，'derek'是傳入的實參

2.默認參數

定義了默認參數后，在函數調用時不需要再傳入，默認參數放在最后面

def info(name,age,country = 'CN'):   #country定義了一個默認參數
    print('姓名:',name)
    print('年齡:',age)
    print('國籍：',country)

info('derek',22)     #調用時，沒穿實參countrty，就用默認的參數

3.關鍵參數

 正常情況下，給函數傳參數要按順序，不想按順序就可以用關鍵參數，只需指定參數名即可，但記住一個要求就是，關鍵參數必須放在位置參數之后

def info(name,age,country = 'CN'):
    print('姓名:',name)
    print('年齡:',age)
    print('國籍：',country)

info(age=22,name='derek')   #使用關鍵參數，可以不按順序

4.*args

def info(name,age,*args):     #*args會把多傳入的參數變成一個元祖形式
    print(name, age,args)

info("derek","22","CN","Python")     #derek 22 ('CN', 'Python')

5.**kwargs

def info(name, *args, **kwargs):  # **kwargs 會把多傳入的參數變成一個dict形式
    print(name, args)    #derek (22, 'CN', 'Python')
    print(kwargs)        #{'sex': 'Male', 'province': 'HeBei'}

info("derek", 22, "CN", "Python", sex="Male", province="HeBei")

6.局部變量

作用域在函數內部，不影響外部

name = 'derek1'

def change_name(name):
    print('before change:',name)
    name = 'derek2'
    print('after change:',name)

change_name(name)
print('最后還是沒改',name)


結果：
before change: derek1
after change: derek2
最后還是沒改 derek1

遞歸函數

如果一個函數在內部調用自身，那么這個函數就叫做遞歸函數。

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

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

3.遞歸效率不高，遞歸層次過多會導致棧溢出（在計算機中，函數調用是通過棧（stack）這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。由於棧的大小不是無限的，所以，遞歸調用的次數過多，會導致棧溢出

#遞歸實現階乘n! = (n-1)! × n
def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)
print(factorial(5))

結果：120

過程：
factorial(5)                        # 第 1 次調用使用 5
5 * factorial(4)                    # 第 2 次調用使用 4
5 * (4 * factorial(3))              # 第 3 次調用使用 3
5 * (4 * (3 * factorial(2)))        # 第 4 次調用使用 2
5 * (4 * (3 * (2 * factorial(1))))  # 第 5 次調用使用 1 
5 * (4 * (3 * (2 * 1)))             # 從第 5 次調用返回
5 * (4 * (3 * 2))                   # 從第 4 次調用返回
5 * (4 * 6)                         # 從第 3次調用返回
5 * 24                              # 從第 2 次調用返回
120                                 # 從第 1 次調用返回

高階函數

滿足下列條件之一就可稱函數為高階函數

• 某一函數當做參數傳入另一個函數中

• 函數的返回值包含一個或多個函數

#簡單的高階函數

def func():
    print('in the func')
    return foo()
def foo():
    print('in the foo()')
    return 666

res = func()
print(res)

結果：
in the func
in the foo()
666

 map()函數

map()是 Python 內置的高階函數，它接收一個函數 f 和一個list，並通過把函數 f 依次作用在 list 的每個元素上，得到一個新的 list 並返回

def func(x):
    return x * x
a= map(func,range(1,10))
print(list(a))

結果：
[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce()函數

reduce()函數也是Python內置的一個高階函數。reduce()函數接收的參數和 map()類似，一個函數 f，一個list，但行為和 map()不同，reduce()傳入的函數 f 必須接收兩個參數，reduce()對list的每個元素反復調用函數f，並返回最終結果值

from functools import reduce
def f(x,y):
    return x + y
a = reduce(f,[1,3,5,7,9,10])
print(a)

結果：
35

filter()函數

filter()函數是 Python 內置的另一個有用的高階函數，filter()函數接收一個函數 f 和一個list，這個函數 f 的作用是對每個元素進行判斷，返回 True或 False，filter()根據判斷結果自動過濾掉不符合條件的元素，返回由符合條件元素組成的新list

def is_odd(x):
    return x % 2 == 1
a = filter(is_odd,[1,2,3,4,5,6,7,8])
print(list(a))

結果：[1, 3, 5, 7]

匿名函數lambda

lambda 函數是一種快速定義單行的最小函數，可以用在任何需要函數的地方

優點：讓代碼更加精簡，不需要考慮命名的問題

#常規函數
def fun(x,y):
    return x + y

#匿名函數
a = lambda x,y:x + y
print(fun(2,3))

 內嵌函數和作用域

定義：在一個函數體內創建另外一個函數，這種函數就叫內嵌函數

實例

def foo():
    print("in the foo")
    def bar():
        print("in the bar")
    bar()

foo()


結果：
in the foo
in the bar

局部作用域和全局作用域的訪問順序

x = 0
def grandpa():
    x = 1
    def dad():
        x = 2
        def son():
            x = 3
            print(x)
        son()
    dad()
grandpa()
print(x)


結果：
3
0