一.函数定义

def 函数名(arg1,arg2):        =============>函数定义
    ‘描述信息‘                 =============>print(函数名.__doc__)   显示注释
    函数体                     =============>函数主体
    return 1                  =============>返回值可以是任意类型

1.空函数

　　def 函数名():   

　　　　pass
　　一定要加上pass，一般在函数功能定义出来，方便以后扩展编写

2.内置函数

　　内置在Python解释器中，可以直接被调用的builtins

3.返回值相关

　　a.不写return 实际上是会返回None

　　b.return 多个值   会返回一个元组

　　c.函数只能执行一次return

4.插播一句变量解压：
　　a.  a,b,c,d = [1,2,3,4]      ===> a=1 b=2 c=3 d=4

　　b.  head,*_=[1,2,3,4]      ===>head=1

　　c. def fun():
    　　　　return 1,2,3

   　　a,b,c = fun()         ===> a=1 b=2 c=3

二.函数参数

函数定义时括号中的变量名是形式参数；函数调用时传递进括号的参数是实际参数，传递进去的实际参数数量上一定与形式参数一样

不建议传递一个可变类型的参数作为函数的实际参数，尽量限定函数的功能只跟自身相关，不要改变同一级的全局变量的内容。

• 实际参数：(调用时传值)

　　　　1.按位置传值 f(1,2)
　　　　2.按关键字传值 f(x=1,y=2)
　　　　3.混合使用，按位置传值必须在按关键字传值之前 f(1,y=2)

• 形式参数：(定义时定义)  

　　　　1.每一个形式参数都要被传值进来
　　　　2.默认参数 def fun(x,y=1) 位置参数必须在默认参数之前;

　　　　把常用的参数设置成默认参数，调用时就可以不必传值进去，但是仍然可以传值进去
　　　　例如 fun(5)或者fun(5,5)

• 动态参数：

　　　　1.*args 除去按位置传值，可以接收多个参数到一个元组

　　　　形参方使用
            def foo(*args):
                print(args)
            foo(1,2,3)        ===> args = (1,2,3)

　　　　实参方使用
            def bar(x,y,z)
                print(x,y,z)   ===>1 2 3
             bar(*(1,2,3))
　　　　即*args实际上对应了多个位置参数，而args是多个位置参数组合成为的一个元组

　　　　2.**kwargs 除去按关键字传值，接收到的其他参数到一个字典中

　　　　形参方使用
            def foo(x=2,**kwargs):
                print(x)
                print(kwargs)
             foo(x=1,y=2,z=3)      ===> x = 1   kwargs = {‘y‘:2,‘z‘:3}

　　　　实参方使用
            def bar(x,y,z):
                print(x,y,z)
             bar(**{‘x‘:1,‘y‘:2,‘z‘:3}) ===> x = 1  y = 2  z = 3

　　　　即**kwargs实际上对应了多个关键字参数，而kwargs是多个关键字参数组合成为的一个字典

　　　　3.混合使用
　　　　def foo(*args,**kwargs):
 　　　　　　print(args)
            　　print(kwargs)
         foo(1,2,3,a=5,b=6,c=7)          ===>args = (1,2,3)  kwargs = {‘a‘: 5, ‘b‘: 6, ‘c‘: 7}

　　　　(*args,**kwargs)实际上可以接收任意多的位置参数和任意多的关键字参数，增加了函数参数的灵活性

Python之路-函数基础和参数