python之路--day8---day9--两日内容

一.不使用函数的问题

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

2，遇到重复的功能只能重复编写实现代码，代码冗余

3，功能需要扩展时，需要找出所有实现该功能的地方修改，无法统一管理且维护难度极大

二.函数是什么？

函数就是具备某一功能的工具------可以重复使用，需要先定义

事先准备工具的过程-------函数的定义

拿来就用-----函数的调用

三.函数的分类

1.内置函数---python解释器已经定义好的函数

2.自定义函数---根据需求，事先定制好的，实现某种功能的函数

四.如何定义函数？

语法：

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

　　'''文档描述'''

　　函数体

　　return 返回的值

def：定义函数的关键字

函数名：用来调用函数的。函数名要能反映其意义

文档描述：推荐写，增强函数的可读性

函数体：函数的功能实现代码

return：函数的返回值

def auth(user:str,password:str)->int:
    '''
    auth function
    :param user: 用户名
    :param password: 密码
    :return: 认证结果
    '''
    if user == 'egon' and password == '123':
        return 1

五，函数使用的原则：先定义，再调用

　　5.1 函数即‘变量’，‘变量’必须先定义后引用。没有定义而直接引用函数，就相当于在引用一个

　　不存在的变量名

　　

#测试一
def foo():
    print('from foo')
    bar()
foo() #报错

#测试二
def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()
foo() #正常

　　结论：函数的使用，必须遵循原则：先定义，后调用

　　在使用函数时，一定要明确区分定义阶段和调用阶段

　　　　##定义阶段

　　　　def foo（）

　　　　　　print（‘from foo’）

　　　　##调用阶段：函数名加括号就是在调用函数

　　　　　foo（）

　　5.2函数在定义阶段只检测语法，不执行代码

　　　　语法错误在函数的定义阶段就会被检测出来，而代码的逻辑错误只有在执行时才会知道

六，定义函数的三种形式

　#1、无参：当函数的代码逻辑不需要函数的调用者参入值，应用场景仅仅只是执行一些操作，比如与用户交互，打印

　#2、有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值、

　#3.空函数：设计代码结构

　　　　结论：

　　　　　　　　　#1、定义时无参，意味着调用时也无需传入参数

　　　　　　　　　#2、定义时有参，意味着调用时也必须传入参数

七.函数的调用

　　1.调用函数-----函数名加括号就是在调用函数

　　　　1.先找到名字  2.根据名字调用函数

　　2.函数的返回值

　　　　无return-----相当于返回None

　　　　return后跟一个值，返回该值本身

　　　　return 逗号分隔多个值----返回元组

　　###调用函数，需要一个明确的结果，则必须要有返回值，有参函数需要有返回值

　　###调用函数，不需要什么明确的结果，则不需要有返回值，通常无参函数不需要返回值

　　3.函数调用的三种形式　　

　　1，语句形式：foo(） 2，表达式形式：3*len（‘hello’）  3，当中另外一个函数的参数：range（len('hello'))

 

 

八，函数的参数

1，形参与实参

　　#形参（形式参数）

　　　　指的是在定义函数是，括号内定义的参数，形参其实就是变量名，

　　#实参（实际参数）

　　　　指的是在调用函数时，括号内传入的值，实参其实就是变量值，

　　注意：实参值和形参的绑定关系，函数调用时，将值绑定到变量名上，关系生效，函数调用结束，解除绑定

 

2，具体应用******************

1.位置参数：按照从左到右的顺序定义的参数

　　位置形参：定义函数时，按照位置定义的形参，称为位置形参

　　　　　　特点：调用函数时必须为其传值，不能多也不能少

　　位置实参：调用函数时，按照位置定义的实参，称为位置实参

　　　　　　注意：位置实参会与形参一一对应

2.关键字参数

　　在调用函数时，按照key=value的形式定义的实参，称为关键字参数

　　注意的问题：

　　1，相当于指名道姓的为形参传值，即使不按照顺序定义，仍然能为指定的参数传值

　　2，调用函数时，位置实参与关键字实参可以混合使用，但是必须　　　　

　　　　　　2.1.关键字实参必须在位置实参右面

　　　　　　2.2对于一个形参不能重复传值

　　　　　　2.3遵循形参的规则

3.默认参数：在定义阶段就已经为某个形参赋值，那么该形参就称为默认参数

　　1，定义阶段已经有值，以为着调用阶段可以不传值

　　2，位置形参必须在默认参数前面

　　3，默认参数的值只在定义阶段赋值一次，也就是说默认参数的值在定义阶段就固定了

　　4，默认参数的值应该设置为不可变类型

4，可变长参数

　　可变长指的是实参值得个数不固定

　　而实参有按照位置和安装关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放他们，分别是*args，**kwargs

形参里面包含*和**
*会将溢出的位置实参全部接收，然后保存成元组的形式赋值给args 
**会将溢出的关键字实参全部接收，然后保存成字典的形式赋值给kwargs     

实参里面包含*和**
一旦碰到实参加*或者**，就把实参的值打散

 ===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)

        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])


        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{'a':1,'b':2,'c':3})


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

        


组合使用：
调用的是wrapper函数，但是实际遵循的是foo函数的规则
===========*args+**kwargs===========

        def foo(x,y):
            print(x,y)

        def wrapper(*args,**kwargs):
            print('====>')
            foo(*args,**kwargs)

 

5，命名关键字参数：*后定义的参数，必须被传值（有默认的除外），且必须按照关键字实参的形式传递--可以保证，传入的参数中一定包含某些关键字