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

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

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

函數(shù)語法

def functonname(parameters):
    ...
    return result

定義空函數(shù)

def nop():
    pass

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

函數(shù)也是Object

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

print(pow) #

函數(shù)也是內(nèi)存中的一塊區(qū)域, 函數(shù)名指向這塊區(qū)域.

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

必選參數(shù)

默認(rèn)參數(shù)

可變參數(shù)

關(guān)鍵字參數(shù)

命名關(guān)鍵字參數(shù)

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

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

上面函數(shù)中, 需要兩個參數(shù)分別是 x, y. 這兩個參數(shù)都是必選參數(shù), 缺一不可.
pow函數(shù)中 x 為底數(shù), y 為指數(shù), 現(xiàn)在我想讓指數(shù)默認(rèn)為 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

設(shè), 我要求多個數(shù)的和. 具體有多個參數(shù), 我也不知道

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))

可變參數(shù)允許你傳入0個或任意個參數(shù)，這些可變參數(shù)在函數(shù)調(diào)用時自動組裝為一個tuple。而關(guān)鍵字參數(shù)允許你傳入0個或任意個含參數(shù)名的參數(shù)，這些關(guān)鍵字參數(shù)在函數(shù)內(nèi)部自動組裝為一個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)

如果要限制關(guān)鍵字參數(shù)的名字，就可以用命名關(guān)鍵字參數(shù)，例如，只接收city和job作為關(guān)鍵字參數(shù)

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

命名關(guān)鍵字參數(shù)需要一個特殊分隔符 * ，* 后面的參數(shù)被視為命名關(guān)鍵字參數(shù)。

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

如果函數(shù)定義中已經(jīng)有了一個可變參數(shù)，后面跟著的命名關(guān)鍵字參數(shù)就不再需要一個特殊分隔符 * 了.

def person(name, age, *, city = "Beijing", job):
    # 要限制關(guān)鍵字參數(shù)的名字, 就要用到 "命名關(guān)鍵字參數(shù)"
    # * 后的參數(shù), 被視為"命名關(guān)鍵字參數(shù)"
    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}
# 當(dāng)實參為 *x 時, 會將實參中的key以tuple(元組)的形式, 傳遞到方法內(nèi)
# person("Jack", 23, *x, city = "Beijing", job = "Engineer") # Jack 23 ("A", "B", "C") Beijing Engineer

# 當(dāng)實參為 x 時, 會將實參的整體內(nèi)容做為tuple(元組)的一個元素, 傳遞到方法內(nèi)
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之后的語句則不被執(zhí)行

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)

當(dāng)函數(shù)返回多個值時, 實際上是把多個需要返回的值, 封裝成一個tuple

剛剛說過, 函數(shù)也是一個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

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

閉包

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

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

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

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

這里面調(diào)用func的時候就產(chǎn)生了一個閉包——inner_func,并且該閉包持有自由變量——name，因此這也意味著，當(dāng)函數(shù)func的生命周期結(jié)束之后，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()

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

裝飾器

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

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

相當(dāng)于 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
# 在方法前后加入自己想要的內(nèi)容, 哈哈, 這就是傳說中的AOP嗎?