摘要：這里面調用的時候就產生了一個閉包并且該閉包持有自由變量，因此這也意味著，當函數的生命周期結束之后，這個變量依然存在，因為它被閉包引用了，所以不會被回收。

在熟悉了Python中常用的一些內置函數, 那接下來我們定義一個自己的函數吧

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

函數語法

def functonname(parameters):
    ...
    return result

定義空函數

def nop():
    pass

實際上 pass 是用來作為占位符的. 比如現在還沒想好怎么寫函數的代碼, 就可以先放一個pass, 讓其他代碼可以運行起來.

函數也是Object

def pow(x, y):
    result = 1
    for i in range(0, y):
        result = result * x
    return result

print(pow) #

函數也是內存中的一塊區域, 函數名指向這塊區域.

fn = pow
print(fn) #
print(fn(2, 10)) #1024

必選參數

默認參數

可變參數

關鍵字參數

命名關鍵字參數

def pow(x, y):
    result = 1
    for i in range(0, y):
        result = result * x
    return result

t = pow(2, 3)
print(t) # 8

上面函數中, 需要兩個參數分別是 x, y. 這兩個參數都是必選參數, 缺一不可.
pow函數中 x 為底數, y 為指數, 現在我想讓指數默認為 2

def pow(x, y = 2):
    result = 1
    for i in range(0, y):
        result = result * x
    return result

t = pow(2)
print(t) # 4

設, 我要求多個數的和. 具體有多個參數, 我也不知道

def sum_1(numbers):
    s = 0
    for x in numbers:
        s += x
    return s

def sum_2(*numbers):
    s = 0
    for x in numbers:
        s += x
    return s

arr = [1, 2, 4]
print(sum_1(arr))
print(sum_2(1, 2, 4))
print(sum_2(*arr))

可變參數允許你傳入0個或任意個參數，這些可變參數在函數調用時自動組裝為一個tuple。而關鍵字參數允許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝為一個dict

def person(name, age, **kw) :  # ** => dict
    print("kw tyep is", type(kw))
    if "city" in kw : 
        print("city :", kw["city"])
    if "job" in kw:
        print("job :", kw.get("job"))
    print("name:", name, ", age:", age, ", other:", kw)


person("Jion", 18, city = "Beijing")
person(name = "Tom", city = "Beijing", age = 17)
extra = {"city": "Beijing", "job": "Engineer"}
person("Jion", 18, **extra)

如果要限制關鍵字參數的名字，就可以用命名關鍵字參數，例如，只接收city和job作為關鍵字參數

def person(name, age, *, city, job):
    print(name, age, city, job)

命名關鍵字參數需要一個特殊分隔符 * ，* 后面的參數被視為命名關鍵字參數。

>>> person("Jack", 24, city="Beijing", job="Engineer")
Jack 24 Beijing Engineer

如果函數定義中已經有了一個可變參數，后面跟著的命名關鍵字參數就不再需要一個特殊分隔符 * 了.

def person(name, age, *, city = "Beijing", job):
    # 要限制關鍵字參數的名字, 就要用到 "命名關鍵字參數"
    # * 后的參數, 被視為"命名關鍵字參數"
    print(name, age, city, job)
person("Jack", 24, job = "Engineer")
x = {"city":"Shanghai", "job":"Engineer"}
person("Jack", 23, **x)
person("Jack", 23, city = "Beijing", job = "Engineer")

def person(name, age, *args, city, job):
    print(name, age, args, city, job)
x = {"A":1, "B":2, "C":3}
# 當實參為 *x 時, 會將實參中的key以tuple(元組)的形式, 傳遞到方法內
# person("Jack", 23, *x, city = "Beijing", job = "Engineer") # Jack 23 ("A", "B", "C") Beijing Engineer

# 當實參為 x 時, 會將實參的整體內容做為tuple(元組)的一個元素, 傳遞到方法內
person("Jack", 23, x, city = "Beijing", job = "Engineer") # Jack 23 ({"A": 1, "B": 2, "C": 3},) Beijing Engineer

def abs(x):
    if(x >= 0):
        return x
    else:
        retrun -x

print(abs(-1)) #1

return 類似出棧操作, return之后的語句則不被執行

def show(x, y, z):
    return x  * y * z, x + y + z

x = show(2, 3, 4)
print(x[0], x[1]) #24 9
print(x) #(24, 9)

當函數返回多個值時, 實際上是把多個需要返回的值, 封裝成一個tuple

剛剛說過, 函數也是一個Object, 所以也可以作為返回值進行返回

遞歸

def trim(s):
    if (s == ""):
        return ""
    if (ord(s[:1]) == 32):
        return trim(s[1:])
    elif (ord(s[-1:]) == 32):
        return trim(s[:-1])
    else:
        return s

這是一個去除字符串前后空格的函數, 首先檢測字符串的第一位是不是空格, 如果是去掉第一位, 再次檢查新字符串的第一位 直至不是后, 檢查字符串的最后一位, 如果是, 則去掉最后一位, 再次檢測新字符串的最后一位.直到最后一位,不再是空格.

閉包

def make_adder(addend):
    def adder(augend):
        return augend + addend
    return adder

p = make_adder(23)
q = make_adder(44)

print(p(100)) #123
print(q(100)) #144

閉包: 可以形象的把它理解為一個封閉的包裹，這個包裹就是一個函數，當然還有函數內部對應的邏輯，包裹里面的東西就是自由變量，自由變量可以在隨著包裹到處游蕩。當然還得有個前提，這個包裹是被創建出來的。
在通過Python的語言介紹一下，一個閉包就是你調用了一個函數A，這個函數A返回了一個函數B給你。這個返回的函數B就叫做閉包。你在調用函數A的時候傳遞的參數就是自由變量。

def func(name):
    def inner_func(age):
        print "name:", name, "age:", age
    return inner_func

bb = func("the5fire")
bb(26)  # >>> name: the5fire age: 26

這里面調用func的時候就產生了一個閉包——inner_func,并且該閉包持有自由變量——name，因此這也意味著，當函數func的生命周期結束之后，name這個變量依然存在，因為它被閉包引用了，所以不會被回收。

def hellocounter (name):
    count = 0
    def counter():
        # 如果不加 nonlocal 會報錯
        # UnboundLocalError: local variable "count" referenced before assignment
        nonlocal count
        count += 1
        print ("Hello {0}, {1} access!".format(name, count))
    return counter

hello = hellocounter("ysisl")
hello()
hello()
hello()

在閉包函數內, 可以直接訪問父函數作用域下的變量, 但不可以修改.
python3里面,引入了一個關鍵字:nonlocal,這個關鍵字是干什么的? 就是告訴python程序, 我的這個count變量是再外部定義的, 你去外面找吧. 然后python就去外層函數找, 然后就找到了count = 0 這個定義和賦值, 程序就能正常執行了.

裝飾器

裝飾器: 是對閉包的一種實際運用的場景.

def makebold(fn):
    def wrapped():
        return "" + fn() + ""
    return wrapped

def makeitalic(fn):
    def wrapped():
        return "" + fn() + ""
    return wrapped

@makebold
@makeitalic
def hello():
    return "hello world"

print hello() # hello world

相當于 makebold(makeitalic(hello()))

import time

def timecost(func):
    def wrapper(*args, **kw):
        def fn(*args, **kw):
            start = int(time.time())
            print("Call {0}() Before [{1}]".format(func.__name__, time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(int(time.time())))))
            func(*args, **kw)
            print("Call {0}() After [{1}]".format(func.__name__, time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(int(time.time())))))
            end = int(time.time())
            print("Run Cost Time {0}s".format(end - start))

        return fn(*args, **kw)
    return wrapper

@timecost
def now_datetime(format):
    now = int(time.time())
    print(time.strftime(format, time.localtime(now)))

now_datetime("%H:%M:%S")

# Call now_datetime() Before [2018-01-15 00:24:17]
# 00:24:17
# Call now_datetime() After [2018-01-15 00:24:17]
# Run Cost Time 0s
# 在方法前后加入自己想要的內容, 哈哈, 這就是傳說中的AOP嗎?