函数

1、什么是函数

　　程序具备某一功能的工具——>>函数
　　事先准备好工具——————>>函数的定义
　　遇到应用场景，拿来就用——>>函数的调用

　　分为两大类:
　　　　1，内置函数
　　　　2，自定义函数

 

2、为何要用函数

　　1，代码冗余
　　2，程序的组织结构不清晰，可读性差
　　3，扩展性差，后期维护麻烦

3、如何用函数

　　函数的使用必须遵循一个原则

　　　　1，先定义
　　　　　　　　定义的语法：
　　　　　　　　　　　def 函数名（参数1，参数2，....）
　　　　　　　　　　　      '''
　　　　　　　　　　　　   文档注释
　　　　　　　　　　　　  '''
　　　　　　　　　　　　　代码1
                                               代码2
　　　　　　　　　　　　　代码3
　　　　　　　　　　　　　.....
　　　　　　　　　　　　　return 值

　　　　2，后调用
　　　　　　　　　　函数名（）

一、定义阶段（只检测代码，不执行代码）

二、调用阶段（开始执行代码）

三、函数的三种形式

　　　　1，有参函数

def max(a,b):
    if a>b:
        print(a)
    else:
        print(b)
max(1,3)
   >>3


为什么运行这种情况没有输出
def foo(x,y):
    if x<y:
        return x
    else:
        return y
foo(1,3)
******************    执行完函数，没有需要输出的指令，
res=foo(1,3)
print(res)

 

　　　　2，无参函数

 

　　　　3，空函数 　　　在创建软件初期，搭建基本构建时用

def foo():
    pass
a=foo()
print(a)

学会用pass避免报错

 

四、调用函数的三种形式

　　1 语句形式
                 print（函数名）　　　　　　　　打印函数的内存地址
　　　　   print（函数名（））　　　　　   打印返回值
　

　　2 表达式形式

def foo(x,y):
    if x>y:
        return x
    else:
        return y
res=foo(3000,5000)*30
print(res)

 

　　3 函数的调用可以当作另外一个函数的参数传入

def foo(x,y):
    if x>y:
        return x
    else:
        return y
res=foo(foo(1,2),6)
print(res)

 

五、函数的返回值

　　1、什么是函数的返回值
　　　　　　返回值是函数体运行代码后的结果

　　2、为何有返回值
　　　　　　需要拿到函数的处理结果做进一步的处理，则函数必须有返回值

　　3、如何用
　　　　　　1、返回值没有任何类型限制，也没有个数限制
　　　　　　　　　　1.return后没值或者没有return：      返回值为None
　　　　　　　　　　2.return后的值：   返回的就是该值
　　　　　　　　　　3.return后有多个值（值1，值2，.....）：    返回元组（值1，值2，.....），此时可以直接解压赋值

　　　　　　2、return是函数结束标志，函数可以有多个return，但是执行完第一个return后该函数立即结束，

六、函数的参数分为两大类

　　1，形参：在定义函数是在括号内指定参数（变量名），
　　2，实参：在调用函数时括号内传入的值（变量值）
　　　　 二者关系：在调用函数时，实参值（变量值）会传给形参（变量名），
　　　　　　　　　　这种绑定关系在调用函数时生效，调用结束后绑定结束。

　　　　1)形参：
　　　　　　　　1.位置形参：在定义阶段，按照从左到右的顺序依次定义
　　　　　　　　　　大原则：必须被传值
　　　　　　　　　　　　　　def func(x,y,z):

　　　　　　　　2.默认参数：在定义阶段，就已经为某个形参赋值
　　　　　　　　　　特点：调用阶段可以不为其传值
　　　　　　　　　　　　　　def func(x,y=2):
　　　　　　　　　　注意：位置形参必须在默认形参的前边

　　　　　　　　3.形参中*也**的用法

　　　　　　　　　　形参中带* ：会将溢出的位置实参存成元组的形式然后赋值给其后的变量名

　　　　　　　　　　　　　　*args     *后跟args,要遵循这种规范

def func(x,y,*args):
     print(x,y,args)

 func(1,2,3,4,5,6)

    >>1 2(3,4,5,6)

　　　　　　　　　　形参中的**：会将溢出的关键字实参存成字典的格式然后赋值给其后变量

　　　　　　　　　　　　　*kwargs　　要遵循这种规范

 

 

　　　　2）实参
　　　　　　　　1.位置实参：在调用阶段，按照从左到右的顺序一次传入的值
　　　　　　　　　   特点：这种传值方式与形参一 一对应

　　　　　　　　2.关键字实参：在调用阶段，按照key=values的方式传值
　　　　　　　　　   特点：可以完全打乱位置，仍然为指定的形参传值
　　　　　　　　　　　　func=(x=1,y=2,z=3)

　　　　　　　　　　　　注意：位置实参与关键字实参可以混用，
　　　　　　　　　　　   　　　　同一个形参只能被赋值一次
　　　　　　　　　　　   　　　　位置实参必须在关键字实参的前边

　　　　　　　　3.实参中的*和**的用法

　　　　　　　　　　　　　实参中带*：先将实参打散成位置实参，然后再与形参做对应

 def func(x,y,z):
     print(x,y,z)

 func(*[1,2,3])         #func(1,2,3)
 func(*'hel')             #func('h','e','l')




*相当于for循环取出其后的每个元素
所以只要能被for循环的数据类型都可以被*取出

　　　　　　　　　　　　

　　　　　　　　　　　　　实参中带**：先将实参打散成关键字实参，然后再与形参做对应

 def func(x,y,z):
     print(x,y,z)

 func(**{'x':1,'z':3,'y':2})           #func(z=3,y=2,x=1)

    

　　　　　　　　　　　　实参*与**套用

def index(x,y,z,o,p):
    print(x,y,z,o,p)
************************************************************************
def wrapper(*args,**kwargs):              # args=(1,2,3,4,5) kwargs={'c':3,'b':2,'a':1}
    index(*args,**kwargs)                    #index(*(1,2,3,4,5),**{'c':3,'b':2,'a':1}) 
 wrapper(1,2,3,4,5,a=1,b=2,c=3)

  溢出的位置实参，溢出的关键字实参会被*和**存成元组和字典
  然后又被*和**打散，其实把输入的值原模原样的返回