第1章 函数的基础知识

1.1为何要用函数？

1.     代码的组织结构不清晰，可读性差

2.     代码冗余

3.     可扩展性差

1.2函数的使用：

    必须先定义，后调用

定义的语法：def  函数名（参数1，参数2，）

            代码段

            retrun  返回值

定义函数，就相当于定义了一个变量，会申请内存空间将函数体代码存起来，然后将内存地址绑定给函数名，函数名=函数内存地址

1.3定义函数的三种形式：定义那种形式取决于函数体内部需不需要从外部传值

1.    无参函数

2.    有参函数

3.    空函数

1.4函数的返回值

def max(x,y):
    ifx > y:
        returnx
    else:
        returny

res=max(10,20)
print(res)

1.     return是函数结束的标志，函数内可以有多个return，但只要执行一次return，整个函数就立即结束，并且将return后的返回值当作本次执行的结果

2.     没有return默认返回none

3.     return多个返回值用逗号分隔开，返回一个元祖

第2章 函数参数的使用：

2.1函数参数分为两大类：

1.    形参：在函数定义阶段括号内定义的参数（变量名），

2.    实参：在函数调用阶段括号内传入的值（变量值）

3.    形参与实参的关系：在调用函数时，实参的值会绑定给形参，这种绑定关系在调用结束后立即解除

def func(x,y,z):
    print(x)
    print(y)
    print(z)
func(1,2,3)

2.2形参与实参的细分：

2.2.1位置参数

位置形参：指在函数定义阶段按照从左到右的顺序依次定义的形参

特点：必须被传值，多一个不行，少一个不行

位置实参：指在函数调用阶段从左到右依次传入的值

特点：与形参一一对应

2.2.2关键字实参：

在函数调用阶段，按照key=value的形式为指定形参赋值

特点：可以完全打乱顺序，但仍然能为指定的形参赋值

注意：可以混用位置实参和关键字实参，但是不能为同一个形参重复赋值，并且位置实参必须在关键字实参的前面

def func(x,y,z):
    print(x)
    print(y)
    print(z)
func(z=1,y=2,x=3)

 

2.2.3默认参数：

在函数定义阶段，就已经为形参赋值了

特点：在定义阶段就已经有值，可以不用传值，如果传值，就以传的为准

注意：位置形参必须在默认形参前面

      默认形参的值只在函数定义阶段赋值一次，定义之后的任何改动都无法改变形参的值

默认形参的值通常是不可变类型

m=100
def func(x,y,z=m):
    print(x)
    print(y)
    print(z)
m=200
func(1,2)

2.2.4可变长参数：

指在调用函数时传入的值，个数不固定

Ø  *的用法：

在形参中出现*，*会将溢出的位置实参，存成元祖的形式，赋值给紧跟其后的形参

def func(x,y,*z):
    print(x)
    print(y)
    print(z)
func(1,2,3,4)

在实参中出现*，都会将*后的值，打散成位置实参，然后进行赋值

def func(x,y,z):
    print(x)
    print(y)
    print(z)
func(*{1,2,3})

Ø  **的用法：

在形参中出现**，**会将溢出的关键字实参，存成字典的形式，赋值给紧跟其后的形参

def func(x,y,**z):
    print(x)
    print(y)
    print(z)
func(1,y=2,z=3,a=4,b=5)

在实参中出现**，都将**后的值打散成关键字实参，然后进行赋值

def func(x,y,z):
    print(x)
    print(y)
    print(z)
func(**{'x':1,'y':2,'z':3})

Ø  args,**kwargs特殊用法：

def func(*args,**kwargs):
    print(args)
    print(kwargs)
func(1,2,3,x=1,y=2)

传给外层函数wrapper的参数格式如何原封不动的转嫁给wrapper内部调用的函数index？

def index(a,b,c):
    print('来自index: ',a,b,c)
def wrapper(*args,**kwargs):
    index(*args,**kwargs)
wrapper(1,1,1)

2.2.5命名关键字形参：

在定义函数阶段，但凡是在*与**之间的参数称之为命名关键字形参

特点：在传值时必须按照key=value的形式传值

第3章 函数对象

3.1函数对象指的是：

函数的内存地址可以像变量值一样去使用

3.2函数对象如何使用？

1.     可以被引用

def func():
    print('hello')
f=func
print(f)
f()

2.     可以当作参数传给另外一个函数

def func():
    print('hello')
def bar(x):
    print(x)
    x()
bar(func)

3.     可以当作函数的返回值

def func():
    print('hello')
def bar():
    returnfunc
res=bar()
print(res)

4.     可以当作容器类型的元素

Ø  存到列表中与调用：

def func():
    print('hello')
x=[func,]
print(x)
x[0]()

Ø  存到字典中与调用：

def func():
    print('hello')
x={'y':func}
print(x)
x['y']()

3.3函数对象的应用：

def login():
    print('登陆功能')
def register():
    print('注册功能')
def pay():
    print('支付功能')
func_dic={
    '1':login,
    '2':register,
    '3':pay
}
while True:
    print("""
    0:退出
    1:登陆
    2:注册
    3:支付
    """)
    choice=input('出入命令：').strip()
    ifchoice == '0' : break
    if choicein func_dic:
        func_dic[choice]()
    else:
        print('输入命令有错误')

第4章 函数嵌套

4.1函数的嵌套分为两类：

1.     函数的嵌套定义：在函数内部又定义了一个函数

2.     函数的嵌套调用：在调用一个函数的内部又调用了其他函数

def max(x,y):
    ifx > y:
        returnx
    else:
        returny
def max1(a,b,c,d):
    res1=max(a,b)
    res2=max(res1,c)
    res3=max(res2,d)
    returnres3
print(max1(1,2,3,4))

第5章 名称空间与作用域

5.1什么是名称空间？

存放名字与值的绑定关系的内存空间

5.2名称空间分为三种：

5.2.1内置名称空间：

存放的是python解释器自带的名字（len，print），解释器启动时创建，解释器关闭则销毁

5.2.2全局名称空间：

存放的是全局的名字，没有任何缩进，在顶头定义的名字，python文件执行时创建，文件执行完毕则销毁

5.2.3局部名称空间：

在函数内定义的名字，在函数调用时临时产生，函数调用完毕则立即销毁

5.3三个名称空间总结：

加载顺序：

1.     先产生内置名称空间

2.     再产生全局名称空间

3.     如果调用函数则会产生临时局部名称空间

名字的查找顺序：从当前位置向上查找

函数的局部名称空间彼此隔离，但是全局和内置的名称空间则是所有函数共享的

5.4作用域

全局作用域：内置+全局名称空间，全局有效

局部作用域：局部名称空间，临时存活，函数内有效

global：声明以后，表示修改全局变量

x=111
def func():
    globalx
    x=222
func()
print(x)

nonlocal：声明以后修改上一层中的变量

x=111
def func():
    x=222
    deff2():
        nonlocalx
        x=0
    f2()
    print(x)
func()
print(x)

第6章 闭包函数

6.1什么是闭包函数？

定义在函数内的函数

6.2为什么要用闭包函数？

为了实现装饰器功能

6.3如何用闭包函数？

def outter(x):
    definner():
        print(x)
    returninner
inner=outter(1)