函数def

函数:把执行一定功能的动作封装到一起>>> def 函数名(形参)      通过一个    函数名(实参)         去调用它,传参来执行功能.动作,输出结果

.定义：def 关键词开头，空格之后接函数名称和圆括号()。
.参数：圆括号用来接收参数。若传入多个参数，参数之间用逗号分割。
　　　　参数可以定义多个，也可以不定义。
　　　　参数有很多种，如果涉及到多种参数的定义，应始终遵循位置参数、*args、默认参数、**kwargs顺序定义。
　　　　如上述定义过程中某参数类型缺省，其他参数依旧遵循上述排序
.注释：函数的第一行语句应该添加注释。
.函数体：函数内容以冒号起始，并且缩进。
.返回值：return [表达式] 结束函数。不带表达式的return相当于返回 None.一旦遇到return，结束整个函数。
def 函数名(参数1,参数2,*args,默认参数(a=b),**kwargs):
        """注释：函数功能和参数说明"""
        函数体
        ……
        return 返回值(默认为None)

函数的调用

.函数名()    函数名后面+圆括号就是函数的调用。
.参数：圆括号用来接收参数。
     若传入多个参数：
        应先按位置传值，再按关键字传值(有关键传值则改变默认关键字,没有使用默认值)
.返回值 return
    如果函数有返回值，还应该定义“变量”接收返回值 变量=函数名()  >>>  为函数的返回值
    如果返回值有多个，也可以用多个变量来接收，变量数应和返回值数目一致

无返回值的情况：
函数名()

有返回值的情况：
变量 = 函数名()

返回的多个值会被组织成元组被返回，也可以用多个值来接收

变量1，变量2，... = 函数名()

变量=函数名()   ,变量为一个元祖(变量1,变量2...)

函数的参数

当函数的关键字参数默认为可变数据类型时
def func(a,l=[]):   #在函数创建全局空间中l
    l.append(a)     #每一次添加实在全局l中改变
    return l         #在为终止运行前,l会随着操作变化
lis=func(1)          #第一次运行给全局中l加1
print(lis)
lis1=func(10)        #继续运行第二次找到全局l再次加10
print(lis1)
lis2=func(1,[1,2,3])   #本次函数空间自带关键字参数,不在找全局,在自己空间列表添加,返回结果
print(lis)

#避免出现问题导之结果改变,可设置关键字为空,通过判断关键字状态来每次清空列表来重新填值
def func(q=1,w=2,a=None):
    if not a:
         a=[]
    a.append(q+w)
    print(a)
func(2)
func(3)
func(2,3)
func(5,3)

函数名func为一个内存地址,可以作为参数,返回值,列表.元素,字典的值.

命名空间 作用域

函数的内存使用:
     当遇到函数定义的时候解释器只是象征性的将函数名读入内存，表示知道这个函数的存在了，至于函数内部的变量和逻辑解释器根本不关心。
     等执行到函数调用的时候，python解释器会再开辟一块内存来存储这个函数里的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量会存储在新开辟出来的内存中。
函数中的变量只能在函数的内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
　　
这个“存放名字与值的关系”的空间——叫做命名空间

在python解释器启动时收先加载的空间,叫内置命名空间　　　
　　　py文件创建的存储“变量名与值的关系”的空间叫做全局命名空间(一个py文件开始运行时开辟的空间)，
　　　　　　　在py文件中的函数被调用时开辟的临时的函数运行空间叫做局部命名空间,内存在全局空间内

py的内存加载的顺序为       py内置空间---->文件加载时开辟的全局命名空间---->函数运行时需求开辟的位于全局文件空间内的局部命名空间

　　　　　　　　　　　　　　内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)

　　函数查找时顺序为        先找自己局部空间是否有变量---->自己没有来上一级函数空间来找需求变量---->还没有找py内置的空间

作用域

作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。

全局作用域：包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效

局部作用域：局部名称空间，只能在局部范围内生效

global   找到要修改的变量,在局部修改(全局,永久有效),没有就创建一个

a =                     #全局变量
def func():
    global a
    a =               #要再函数内部 更改全局变量
                                  # 先用global 变量名 声明修改全局变量
print(a)                    #>>>     函数执行前无变化
func()                       #执行函数,而函数的动作时修改全局变量a
print(a)                     #>>>        函数修改后的a

global关键字

 nonlocal 在局部空间(函数内)向上寻找修改最近的变量值

def f1():
    a =
    def f2():
        nonlocal a          # 修改最近的上层函数变量值,没有一直到函数最顶层,再没有报错
                                   #          但是不能为全局变量,报错
        a =
    f2()
    print('a in f1 : ',a)     

f1()                             #>>>a in f1:                                                                   

查看函数的注释信息

 def index():
     '''这是一个主页信息'''
     print('from index')

 print(index.__doc__)    #查看函数注释的方法
 print(index.__name__)   #查看函数名的方法

闭包

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

函数的嵌套:定义在内部的函数无法直接在全局被调用,

　  闭包的常用方法:返回内部函数名,给函数外部调用内部函数

闭包函数的本质:

***** 外层函数返回的内层函数名不仅仅一个函数对象地址,在该函数外部还包裹了一层作用域,
　　　　这使得内部函数不管在什么地方被调用,都优先使用自己原本外层包裹(原外层函数)的作用域

****  函数初始化创建者def给与函数空间,执行函数的父级也就是创建者空间,而不是调用者的空间,

　　      调用者空间有地址指针指向已有的闭包函数空间,已有的闭包函数找父级也是从他的创建者空间

函数做返回值        为函数创建一块区域,并为其维护保存自己的数据,可以被外部调用,执行(相对于被内存清除)

def func(i):
    def inner():
        print(i)
    return inner    >>>返回一个函数地址(inner)
v=func(i)            >>>v=func()返回inner 函数地址
v()                 >>>相当于inner地址函数加括号,调用,外部调用inner内部函数,
                        执行内部函数,输出结果,其中的变量自己没有可以去上级作用域找

        *内部函数执行时内存空间被创建,执行后,如果内部数据仍被外部引用时,空间会被保留(内存泄露)

 1 #闭包中的外层函数可以包裹多个内层函数,每一个内层函数引用超出自己函数空间的变量,与相对于自己空间的
外层函数空间产生连接,并被外层函数返回内层函数地址,这时外层函数返回值,内层函数即是闭包函数,整个函数执行
结束后会携带外层空间打包保存,等待外部调用,而不会被消除空间.但是,只能与函数空间内变量联系,全局空间变量引用不是闭包.
 2 #当把一个主函数名当作外层函数参数,在内层函数内部添加功能执行主函数,且外层函数返回内层函数,此时为装饰器,
外层函数传递主函数,内层函数传参,并修改,执行主函数,返回内层函数名,语法糖自动执行外层函数,包裹内层闭包函数,等待执行
 3 def wrapper():
 4     money = 1000
 5     def func():
 6         name = 'eva'
 7         print(func.__closure__)
 8         def inner():
 9             print(name,money)
10             print(inner.__closure__)
11         return inner
12     return func
13
14 f = wrapper()
15 i = f()
16 i()
本题中inner对func/wrapper都有引用建立连接,每一次引用有一个闭包地址,func只是wrapper的内层,引用wrapper生成一个闭包,共三个

#输出的__closure__有cell元素 ：是闭包函数
def func():
    name = 'eva'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f = func()
f()
本函数对自己父级空间内存变量引用,建立连接,执行结束后,内层函数被打包保存

#输出的__closure__为None ：不是闭包函数
name = 'egon'
def func2():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f2 = func2()
f2()
本函数内部对全局引用,不是闭包,在函数内部空间并无连接

2.高阶函数 ​ 把函数当作参数传递/把函数当作返回值/对函数进行赋值