人生苦短我用Python 第三周 函数周

函数的定义：

1，def 函数名（参数1，参数2......）：

“注释：函数的作用和参数，增加可读性”,

2，函数体

3，返回值

最简单的函数：

def func():
    print('hello world')

函数名后的括号内的参数的顺序是：位置参数，*args，默认参数，**kwargs

函数的调用：函数名（）

def func():
    print('hello world')
 
func()

函数名的本质：函数名相当于变量名指定内存内的一个位置，可以做参数，返回值

函数的参数：

实参：位置传参，关键字传参，动态传参

形参：位置参数（必须传值，不然报错），默认参数（可以不传值，就是默认参数的值，也可以传值，传值就是实参的值），动态参数（*args（必须以位置传参的方式传参，得到的结果是元祖类型），**kwargs（必须以关键字传参，得到的返回值是字典类型））

函数的返回值：

关键字： return 

有返回值：

返回一个值：有一个变量接收

返回多个值：可以用一个变量来接收，也可以用多个变量来接收，有多少个返回值，就用多少个变量来接收。

无返回值：

三种情况：1，不写return 2，只写return 3，写return none

命名空间

命名空间：

　　　　　内置命名空间（存着Python 为我们提前准备好的一些用法 input print等之类的）

　　　　　　全局命名空间

　　　　　 局部命名空间

取值顺序：

在局部命名空间：局部————》全局————》内置

在全局命名空间：全局————》内置

x = 1
def f(x):
    print(x)
 
f(10)
print(x)

输出的f(10)结果是10，print（x）的值是1，全局的取不到局部的值。

作用域

全局作用域（内置命名空间，全局命名空间）

局部作用域（局部命名空间）

global 关键字

a = 10
def func():
    global a
    a = 20
 
print(a)
func()
print(a)

修改掉全局的a=10

函数的嵌套

简单的嵌套：

def f1():
    print("in f1")
    def f2():
        print("in f2")
 
    f2()
f1()

作用域

def f1():
    a = 1
    def f2():
        a = 2
    f2()
    print('a in f1 : ',a)
 
f1()

调用f1得到的是print为a=1，print那个在外部那个作用域，调用不了内部的a=2.

闭包：内部函数包含对外部作用域而非全剧作用域名字的引用，该内部函数称为闭包函数

简单的闭包函数代码：

def func（）：
    a=1
    def func1(a):
        print(a)

开放封闭原则：对修改时封闭的，对扩展是开放点，所以有了装饰器函数

装饰器函数：和伪装时期函数呢？很简单，我理解的就是在不改变你要装饰的那个函数调用方法，和内部函数体的情况下，自己编一个闭包（你编肯定是编不了了，Python已经为你准备好了，你用那个模式就可以了）函数，把要装饰的那个函数变一种方法（这种方法你也想不出来了，Python也帮你想好了，你理解意思就可以了）放到里面，起到到什么作用呢？作用就是在这个函数前后做一些功能达到你想要的结果.

固定的装饰器函数（python给你准备好的）

def wrapper(f):
    def inner(*args,**kwargs):
        '''这个函数执行前要做的额'''
        ret = f(*args,**kwargs) # 这个就是下面要被修饰的函数
        '''这个函数执行之后要做的'''
        return ret
    return wrapper   # 这个就是装饰函数
 
@wrapper  #  func = wrapper(func)  他就是被装饰的函数  语法糖
def func():
    print("henllo world")
 
func()

带参数的装饰器函数

F = False
def outer(flag):
    def wrapper(func):
        def inner(*args,**kwargs):
            if flag:
                print('before')
                ret = func(*args,**kwargs)
                print('after')
            else:
                ret = func(*args, **kwargs)
            return ret
        return inner
    return wrapper
 
@outer(F)  #-->@wrapper  -->hahaha = wrapper(hahaha)  #-->hahaha == inner
def hahaha():
    print('hahaha')
 
@outer(F)   #shuangww = outer(shuangww)
def shuangww():
    print('shuangwaiwai')
 
shuangww()
hahaha()

多个装饰器函数也可以装饰一个函数

def wrapper1(func):
    def inner():
        print('wrapper1 ,before func')
        func()
        print('wrapper1 ,after func')
    return inner
 
def wrapper2(func):
    def inner():
        print('wrapper2 ,before func')
        func()
        print('wrapper2 ,after func')
    return inner
 
@wrapper2
@wrapper1
def f():
    print('in f')
 
f()