函数语法笔记

定义和使用函数

• 不带参函数

def f1():
    print('我是一个函数')

print(f1) # <function f1 at 0x10bd5beb0>
print(type(f1)) # <class 'function'>
f1() # 调用函数

def f2():
    print('我是一个带返回值的函数')
    return 'hello world'

print(f2()) # hello world

• 带参数函数（注意 * 和 ** 的使用）

def f3(a, b):
    return a * b

print(f3(1, 2)) # 2
print(f3('a', 3)) # aaa
#print(f3('a', 'b')) 报错

def f3(a, b=10): # 缺省第2个参数时，默认 10
    return a * b


print(f3(1, 2))  # 2
print(f3(10)) # 100

def f4(*args):
    print("不定长参数的类型为：", type(args)) # 不定长参数的类型为： <class 'tuple'>
    print("不定长参数为：", args) # 不定长参数为： (1, 2, 'a', False)

f4(1,2,'a',False) 

# 接收多个数据，得到的类型为字典类型
def fun(**kwargs):
    print(type(kwargs)) #<class 'dict'>
    print(kwargs)

d1 = dict(a=1, b=True)
fun(**d1) #调用函数，传入类型为dict
fun(name="jack") #调用函数，传入类型为键值对

• return可以返回多个值

# 函数返回多个值的类型为元组
def fun():
    a = 1
    b = 'jack'
    c = True
    return a,b,c

r = fun()
print(type(r))  # <class 'tuple'>
print(r) # (1, 'jack', True)

常用的内置函数

• filter(function, iterable)

l1 = list(range(1, 20, 3))
b = filter(lambda x:x % 2 == 0, l1)
print(type(b)) # <class 'filter'>
print(list(b)) # [4, 10, 16]

• map(function, iterable, …)

mylst = [1,3,2,4,1]

result = map(lambda x: x+1, mylst)

print(type(result)) # <class 'map'>

print(list(result)) # [2, 4, 3, 5, 2]

• reversed(seq)

rev = reversed([1,4,2,3,1])
print(type(rev)) # <class 'list_reverseiterator'>
for i in rev:
    print(i, end=' ') # 1 3 2 4 1 

• sorted(iterable, *, key=None, reverse=False)

函数对象

函数,就是一个高级点的数据容器,一个变量能干啥，函数就能干啥
1.函数可以被引用
2.函数可以作为元素,放到列表,元组,集合,字典中
3.函数可以作为参数,传给别的函数
4.函数可以作为一个返回值

进阶用法 - 闭包与装饰器

闭: 封闭,闭包函数指的是在一个嵌套函数里的内层函数(在里面的那个函数)
包: 用内层函数来操作外层函数的数据
作用: 通过间接的方式，给函数传参或进行操作，闭包函数一般就是配合装饰器来使用的，单纯闭包是没啥意义,也不怎么使用的.可以说闭包就是为了装饰器而生
https://www.cnblogs.com/huxi/archive/2011/03/01/1967600.html
https://www.cnblogs.com/Jerry-Chou/archive/2012/05/23/python-decorator-explain.html
https://www.cnblogs.com/cotyb/p/5243252.html
https://www.cnblogs.com/rhcad/archive/2011/12/21/2295507.html

闭包的标准格式:
	def 外层函数名():
		def 内层函数名():
			代码块
		return 内层函数名

	def fun():
 		def kylin():
     		print("我是打工仔,我骄傲")
 		return kylin

装饰器，类似java中的代理模式，即增强了原有函数的功能，为什么要使用装饰器，主要原因是编码过程中要遵循开闭原则 “对修改关闭，对扩展开放”，在不修改原代码的情况下增加功能

例子：定义一个函数 target()，在调用target之前之后记录日志

• 方案1 - 直接修改原代码 （不推荐）

def target():
    print("--- target函数开始调用 ---")
    print('调用了目标函数')
    print("--- target函数结束调用 ---")

target()

• 方案2 - 包装原函数 （不推荐）

def target():
    print('调用了目标函数')

def proxy(): # 相当于静态代理
    print("--- target函数开始调用 ---")
    target()
    print("--- target函数结束调用 ---")

proxy()

• 方案3 - 将目标函数作为参数（还可以）

def target():
    print('调用了目标函数')

def proxy(f): # 相当于静态代理
    print("--- target函数开始调用 ---")
    f()
    print("--- target函数结束调用 ---")

proxy(target)

• 方案4 - 闭包与装饰器（推荐）

def target():
    print('调用了目标函数')

def proxy(f):
    def inner_proxy():
        print("--- target函数开始调用 ---")
        f()
        print("--- target函数结束调用 ---")
    return inner_proxy

target = proxy(target)  # 增强了原函数
target()

• 方案4 - 语法糖

def proxy(f):
    def inner_proxy(*args, **kwargs):
        print("--- target函数开始调用 ---")
        f(*args, **kwargs)
        print("--- target函数结束调用 ---")
    return inner_proxy

@proxy #相当于把 proxy装饰到下面的函数了 ==> target = proxy(target)
def target():
    print('调用了目标函数')

target()