Python基础016--函数的操作、全局变量和局部变量的声明和

函数的定义、创建以及参数的定义,全局变量和局部变量的声明和作用域, *args, **kwargs的使用

• 函数的定义、 创建以及参数的定义

  • 函数的定义：函数是组织好的,可重复使用的,实现单一的,或者相关联功能的代码块
  • 函数的创建
    • 用户自定义的函数是用def语句来创建的
    • 标题行由def关键字、函数的名字(大驼峰、小驼峰等)、以及参数的集合(如果有的话)三部分组成
    • 剩余部分包括一个可选的字符串和一个必须的函数体
  • 参数的定义：从调用的角度分为形式参数和实际参数
    • 形式参数是函数创建和定义的过程中小括号里面的参数
    • 实际参数是函数在被调用过程中传进来的参数

• 函数中参数的定义

  # 函数中参数定义的四种方式
  
  # 常见的参数定义方式,可以定义多个参数;参数之间用逗号隔开;
  def func(arg1,agr2):
      pass
      
  # 传入的参数,给参数一个默认值
  def func(arg1,arg2=value2):
      pass
      
  # 在不知道用多少参数的情况下传入多个参数
  def func(*args):         # *arg表示传入的参数可以为0或者n个,都存在以形参名为标识符的元组中
      pass
      
  # 参数在函数内部被存放在以形参名为标识符的字典中,调用函数采用arg1=value1,arg2=value2的形式即可
  def func(**kwargs):
      pass
      
  In [42]: def func(*arg):
  ...:     print arg
  ...:     
  In [43]: func(1,2,3)
  (1, 2, 3)
  In [44]: def func(**kwargs):
      ...:     print kwargs
      ...:     
  In [45]: func(x=1,y=2,z=3)
  {'y': 2, 'x': 1, 'z': 3}
  
  

• 全局变量和局部变量的声明和作用域

  • 全局变量是在整个py文件中声明,全局范围内都可以访问；
  • 局部变量是在某个函数中声明的,只能在该函数中调用它；
  • 变量的作用域由代码赋值的位置决定
  • 变量可以在三个不同地方,对应三种不同作用域
    • 一个变量在函数内部赋值,它的作用域被定义在函数之内
    • 当变量是在一个嵌套的函数中赋值时,对于这个嵌套的函数来说,这个变量是非本地的
    • 变量在函数外赋值,它的作用域就是当前整个文件的全局变量
  • global语句的作用是重定义全局变量的值或者把局部变量的值声明为全局变量被其他函数调用

  In [46]: total = 0                              total = 1       
  In [47]: def sum(arg1,arg2):                    def func():
      ...:     total = arg1+arg2                      global total    #  重定义全局变量
      ...:     print "局部变量：", total              total = 2   
      ...:     return total                       func()
      ...:                                        print total         # 此时total的结果为2
  In [48]: sum(1,2)                                   
  局部变量： 3
  Out[48]: 3
  
  In [49]: print "函数的全局变量：", total
  函数的全局变量： 0
  
  

• *args、**kwargs的使用

  • 当函数中参数的变量是可变参数时,使用*args和*kwargs,其中*args对应的可变参数不含key,而*kwargs对应的可变参数含有key

  # *args的用法
  In [57]: def fun(*args):
  ...:     for item in args:
  ...:         print item
  ...:         
  
  In [58]: fun(1,'aa',2)
  1
  aa
  2
  
  # **kwargs的用法
  In [61]: def func(**kwargs):
      ...:     for item in kwargs:
      ...:         print '%s:%s' %(item, kwargs[item])
      ...:         
  In [62]: func(a=1,b=2,c=3)
  a:1
  c:3
  b:2
  
  

• 可变长参数的用法

  • args表示这个参数是一个元组参数，默认值为();*kwargs表示这个参数是字典参数，默认值为[];
  • 可以把args、*kwargs看成是两个默认参数；多余的非关键字参数，函数调用时被放在元组参数args中；多余的关键字参数，函数调用时被放在字典参数kwargs中；

In [107]: def foo(arg1,arg2='OK',*tupleArg,**dictArg):
     ...:     print 'arg1=',arg1
     ...:     print 'arg2=',arg2
     ...:     for i,element in enumerate(tupleArg):
     ...:         print 'tupleArg %d-->%s' %(i,str(element))
     ...:     for key in dictArg:
     ...:         print 'dictArg %s-->%s' %(key, dictArg[key])
     ...:         
In [109]: myList=['my1','my2']
In [110]: myDict={'name':'Tom','age':22}
In [111]: foo('formal_args',arg2='argSecond',a=1)
arg1= formal_args
arg2= argSecond
dictArg a-->1
In [113]: foo(123,myList,myDict)
arg1= 123
arg2= ['my1', 'my2']
tupleArg 0-->{'age': 22, 'name': 'Tom'}
In [114]: foo(123,rt=123,*myList,**myDict)
arg1= 123
arg2= my1
tupleArg 0-->my2
dictArg rt-->123
dictArg age-->22
dictArg name-->Tom

• 总结1：上述代码In113中可以看出
  • 元组对象前面如果不带"*"、字典对象如果前面不带"**",则作为普通的对象传递参数
  • 多余的 普通参数，在foo(123,myList,myDict)中，123赋给参数arg1,myList赋给参数arg2,多余的参数myDict默认为元组赋给myList
• 总结2：上述代码In114中可以看出
  • 参数中如果使用"*"元组参数或者"**"字典参数，这两种参数应该放在参数列表的最后；并且"*"元组参数位于"**"字典参数之前
  • 关键字参数rt=123,因为函数foo(arg1,arg2="OK",*tupleArg,**dictArg)中没有rt参数，所以最后也归到字典参数中