python第三天回顾之函数

一、函数

　　介绍：

　　　　《不用函数的程序，无组织结构，代码冗余，可读性差，无法统一管理且维护成本高。》

　　　　　函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

　　　　　函数能提高应用的模块性，和代码的重复利用率。　　　　

　　函数有两种： 内置函数,自定义函数

　　内置函数有：

　　　　　　例如：　

　　　　　　　　max(),lower(),upper(),len()等系统已经定义好的相关函数。

　　1>自定义函数又分为: 无参函数，有参函数，空函数。　　《在使用函数时，要先定义后使用，若未定义而使用，则相当于引用了一个没有的变量名》

　　　　*函数代码块以def关键词开头，后接函数标识符名称和圆括号（）。

　　　　*任何传入参数和自变量放在圆括号中间。圆括号之间可以用于定义参数。

　　　　*函数的第一行语句可以选择性的使用文档字符串---用于存放函数说明

　　　　*函数内容以冒号起始，并且缩进。

　　　　* return[表达式] 结果函数，选择性的返回一个值给调用方，不带表达式的return相当于返回None

　　　　自定义函数，例如：
　　　　def hello():
      　　　　print("hello world!")

　　　　hello()

　　无参函数：　　　　《若函数功能只是执行一些操作，则不需要返回值》

　　　　def　函数名（）：
　　　　　　"""文档注释"""
　　　　　　函数体

　　2> 定义有参函数:　　《函数的功能 依赖于外部传入的参数》　　　　

　　　　def  函数名（参数1,参数2,......）:
   　　　　 """文档注释"""
    　　　　    函数体
     　return 返回值

　　3>空函数：　　空函数一般在初部写函数时可以用。

       def 函数名():
            pass        

　　《注：　　定义函数时无参，则调用时无参数，定义时有参，调用时必须有参数，函数中可以调用函数的表达式形式，函数可以当作参数来调用。》

　　4>函数的返回值：

　　　　函数中没有return 返回为None  <==> return  <==> return None

　　　　函数中有return 一个值函数调用返回的结果为字符串的形式， 多个值返回结果是元组的形式

        #return #返回一个值
        def ab():
            x=1
            return x
        res=ab()
        print(res)            

　　　　#return 返回多个值
　　　　def ab():
　　　　    x=1
　　　　    return 1,[2,3],(4,5),{}
　　　　res=ab()
　　　　print(res)
　　　　a,b,c,d=ab()
　　　　print(d)

　　　　t=(1,2,3)
　　　　a,_,_=t
　　　　print(a)

　　　　 t=(1,2,3,4,5,6,7,8,9)
　　　　a,*_,c=t
　　　　print(a)
　　　　print(c)　　#return 值1，值2，值3,...  返回结果：（值1，值2，值3，......）

　　5>参数：

　　　　参数分为两种，实参和形参 《注：形参相当于变量名，实参相当于值》

　　　　　　形参：定义阶段只检测函数体的语法。

　　　　　　实参：将值传给形参，进行函数体操作.

　　　　　　

　　　　def abc(x)　　#定义阶段（即定义函数）
   　　　　 print(x)

　　　　abc(1) # 调用阶段（即调用函数）

 

　　　　函数的五种参数：

　　　　　　位置，关键字，默认，可变长（*args,**kwargs）,命名关键字

　　　　　　位置参数：

　　　　　　　　　　位置形参：必须被值传的参数，即实参中也有相应的值与之对应。

　　　　　　　　　　位置实参：与形参一一对应。

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

　　　　abc(1,5,9)#位置实参，与形参一一对应

 　　　　　　关键字参数：　　

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

　　    ab(x=2,z=5,y=6) #《关键字参数实参必须在位置实参后面，不能重复对形参传值》    

 　　　　　　默认参数：

　　　　　　　　　　在函数的形参中使用，默认参数必须在非默认参数之后，默认参数的值通常定义成不可变类型

　　　　def ab(x,y=10) #默认参数在定义阶段就已经赋值了，而且只在定义阶段赋值一次。
 　　   　　print(x,y)

　　　　ab(1)
　或
　　　　a=10
　　　　def ab(x,y=a)
　　　　　　print(x,y)
　　　　ab(1)

　　　　　　可变长参数：

　　　　　　　　　　*args: 　*会把溢出的按位置定义的实参都接收《以元组的形式赋值给args》

　　　　　　　　　　一般针对于位置实参的。

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

         def add(*args):
             res=0
             for i in args:
                 res+=i
             return res
         print(add(1,2,3,4))
         print(add(1,2))

　　　　　　　　　　**kwargs:　　**把溢出的按关键字定义的实参都接收《以字典的形式赋值给kwargs》

　　　　　　　　　　一般针对于关键字实参来使用。

   　　  def foo(x, y, **kwargs):  
  　　       print(x, y)
  　　       print(kwargs)
 　　    foo(1,2,a=1,name='jack',age=18)


  　　   def foo(name,age,**kwargs):
 　　        print(name,age)
  　　       if 'sex' in kwargs:
  　　           print(kwargs['sex'])
  　　       if 'height' in kwargs:
   　　          print(kwargs['height'])

   　　  foo('jack',18,sex='male',height='185')
   　　  foo('jack',18,sex='male')

　　　　　　命名关键字参数：

　　　　　　　　def foo(name,age,*,sex,height):

　　　　　　　　　　　　*后面定义的参数为命名关键字参数，这类参数必须被传值，且必须以关键字实参的形式去传值。

    # def foo(name,age,*,sex='male',height):
    #     print(name,age)
    #     print(sex)
    #     print(height)

    # foo('egon',17,height='185')
    #返回结果：
    #    egon 17
    #    male
    #    185

函数中的示例：

1 # def foo(name,age=10,*args,sex='male',height,**kwargs):
2 # 　　　　 print(name)
3 #         print(age)
#         print(args)
#         print(sex)
#         print(height)
#         print(kwargs)
#
#    foo('alex',1,2,3,4,5,sex='female',height='150',a=1,b=2,c=3)
#返回结果为：
# alex
# 1
# (2, 3, 4, 5)
# female
# 150
# {'a': 1, 'b': 2, 'c': 3}

#     def foo(*args):
#         print(args)

#     foo(1,2,3,4) # 1,2,3,4 <=====>*(1,2,3,4)
5 #　　　将foo内的实参（1，2，3，4） 传给形参args

    # def foo(x,y,z):
    #     print(x,y,z)
    #
    # # foo(*[1,2,3]) #foo(1,2,3)
　　　 #返回结果为：1 2 3
    # foo(*[1,2]) #foo(1,2)以位置参数为基准，少一个实参所以会报少参数的错误。  

    # def foo(**kwargs):
    #     print(kwargs)

    # foo(x=1,y=2)
    # 返回结果：{'x': 1, 'y': 2}  
    # #x=1,y=2  <====>**{'y': 2, 'x': 1}  

    # def foo(x,y,z):
    #     print(x,y,z)
    # 
    # foo(**{'z':3,'x':1,'y':2})《==》 #foo(x=1,z=3,y=2)
    # # foo(**{'z':3,'x':1})   #foo(x=1,z=3)  以关键字函数为基准，但少一个实参y与形参对应，所以会报错

     # def wrapper(*args,**kwargs):
     #     print(args)
     #     print(kwargs)
     #
     #
     # wrapper(1,2,3,a=1,b=2)
 　　 # 返回值：
     #   (1, 2, 3)
     #  {'a': 1, 'b': 2}    
10　　　# *args： *会把位置参数传给args，以元组的形式存放
11　　　# **kwargs: **会把关键字参数传给kwargs，以字典的形式存放

    # def foo(x,y,z):
    #     print('from foo',x,y,z)
    # def wrapper(*args,**kwargs):
    #     print(args) #args=(1,2,3)
    #     print(kwargs) #kwargs={'a':1,'b':2}
    #     foo(*args,**kwargs) #foo(*(1,2,3),**{'a':1,'b':2})     #foo(1,2,3,b=2,a=1)
    # # wrapper(1,2,3,a=1,b=2)
            #返回结果为
            #    (1, 2, 3)  #---print(args)
            #   {'a': 1, 'b': 2}# ---print(kwargs)
            #调用的foo()在传参时报错，foo形参中没有做kwargs实参对应的形参接收
    # wrapper(1,z=2,y=3)
            #返回结果为：
            #       (1,)
            #        {'z': 2, 'y': 3}
            #      from foo 1 3 2