函数二

不定长参数

• 带*号的形参只能有一个，可以和其他参数配合使用。
• *形参只能接受位置参数，不能接受关键字参数。

  def fun(a,b,*c):
      print(a)
      print(b)
      print(c)
  
  fun(1,3,45,3,7,8)
  >>>
  1
  3
  (45, 3, 7, 8)
  def fun(a,b,*c,d):
      print(a)
      print(b)
      print(c)
      print(d)
  
  fun(1,3,45,3,7,d=8)
  >>>
  1
  3
  (45, 3, 7)
  8
  

• **形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值。
• **形参只有一个，并且必须写在所有参数的后面。

  def fun(*args,**kwargs):
      print(args)
      print(kwargs)
  
  
  fun(1,3,45,3,7,d=8,e=9,f=12)
  >>>
  (1, 3, 45, 3, 7)
  {'d': 8, 'e': 9, 'f': 12}
  
  def fun(*args,e,**kwargs):
      print(args)
      print(kwargs)
      print(e)
  fun(1,3,45,3,7,d=8,e=9,f=12)
  >>>
  (1, 3, 45, 3, 7)
  {'d': 8, 'f': 12}
  9
  

参数的解包

• 传递实参时，也可以在序列类型的参数前添加星号，这样它会自动的将序列中元素依次作为参数传递。
• 要求序列中的元素的个数必须和形参的个数一致。

  def fun(a,b,c):
      print(a)
      print(b)
      print(c)
  tuple=(7,8,9)
  list=[7,8,9]
  fun(*tuple)
  fun(*list)
  >>>
  7
  8
  9
  
  def fun(a,b,c):
      print(a)
      print(b)
      print(c)
  dict1={'a':7,'b':8,'c':9}
  fun(*dict1)
  >>>
  a
  b
  c
  
  
  def fun(a,b,c):
      print(a)
      print(b)
      print(c)
  dict1={'a':7,'b':8,'c':9}
  fun(**dict1)
  >>>
  7
  8
  9
  
  
  def fun(*args,**kwargs):
      print(args)
      print(kwargs)
  dict1={'a':7,'b':8,'c':9}
  fun(**dict1)
  >>>
  ()
  {'a': 7, 'b': 8, 'c': 9}
  
  
  def fun(*args):
      print(args)
  list1=[2,4,64,2,4,67,75]
  fun(*list1)
  >>>
  (2, 4, 64, 2, 4, 67, 75)
  

函数的返回值

• 返回值就是函数执行以后返回的结果。
• 通过return来指定函数的返回值。
• return后面可以跟任意对象，返回值甚至可以是一个函数。
• 函数内当不写return语句和只写一个return的时侯，其返回值是None,return后面的代码不会被执行，return一执行函数自动结束。

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

函数文档字符串

• help()是Python中内置函数，通过help()函数可以查询Python中函数的用法。
• 在定义函数时，可以在函数内部编写文档字符串，文档字符串就是对函数的说明。

  def fun():
      '''
      这是一个fun()函数的说明文件，
      print()为python内置函数
      :return:
      '''
      print('hello')
  
  help(fun)
  >>>
  fun()
      这是一个fun()函数的说明文件，
      print()为python内置函数
      :return:
  

函数的作用域(scope)

• 作用域指的是变量生效的区域。
• 在Python中一共有两种作用域。
  • 全局作用域
  • 全局作用域在程序执行时创建，在程序执行结束时销毁。
  • 所有函数以外的区域都是全局作用域。
  • 在全局作用域中定义的变量，都是全局变量，全局变量可以在程序的任意位置进行访问。
  • 函数作用域
  • 函数作用域在函数调用时创建，在调用结束时销毁。
  • 函数每调用一次就会产生一个新的函数作用域。
  • 在函数作用域中定义的变量，都是局部变量，它只能在函数内部被访问。

  a=12
  def fun(*args):
      global n
      n=9
      r=0
      for i in args:
          r+=i
          def fun1():
              r=19
              return r
      return r
  print(fun(1,2,3))
  print(n)
  >>>
  6
  9
  def fun(*args):
      r=0
      for i in args:
          r+=i
          def fun1():
              r=19
              return r
          fun1()
      return fun1
  print(fun(1,2,3))
  >>>
  19
  def fun(*args):
      r=0
      for i in args:
          r+=i
          def fun1():
              r=19
              return r
          fun1()
      return r
  print(fun(1,2,3))
  >>>
  6
  

命名空间

• 命名空间实际上就是一个字典，是一个专门用来存储变量的字典。
• locals()用来获取当前作用域的命名空间。
• 如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()* 则获取函数命名空间。
• 返回值是一个字典。

  d = locals()
  print(d)
  >>>
  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001A53CD1C2E8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Python/test/T4.py', '__cached__': None, 'd': {...}}
  
  

作业

1. 用函数实现一个判断用户输入的年份是否是闰年的程序,以下2种方法满足一种即为闰年。
   • 能被400整除的年份
   • 能被4整除，但是不能被100整除的年份

   def leap_year():
       while True:
           year = input('请输入年份：')
           if len(year) > 0:
               yearns = int(year)
               if yearns % 400 == 0 or (yearns % 4 == 0 and yearns % 100 != 0):
                   print(f'{yearns}是闰年')
                   break
               else:
                   print(f'{yearns}不是闰年', end='')
                   continue
           else:
               print('年份不能为空', end='')
               continue
   
   
   leap_year()
   

2. 在上一作业基础上给出一组年份，创建函数，用不定长参数结合参数拆包得出一组年份中哪些是闰年的元素。

   def leap_year(*args):
       l1 = []
       for i in args:
           if i % 400 == 0 or (i % 4 == 0 and i % 100 != 0):
               l1.append(i)
       return l1
   
   
   print(leap_year(*[2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008]))
   >>> 
   [2000, 2004, 2008]