Python函数之传参

Python函数之传参

1.函数的传参

• 实参

  • 位置参数，从左至右，一一对应形参。
  • 关键字参数， 一一对应形参。
  • 混合参数。一一对应形参并且所有的位置参数一定在所有的关键字参数前面。

• 形参

  • 位置参数。从左至右，一一对应实参。
  • 默认值参数。传值则覆盖，不传值则使用默认值。
  • 万能参数。
  • 仅限关键字参数。

• 函数本身就是一个功能，这个功能应该是要更具有拓展性的功能，我们可以将一些数据传递到函数里面，通过函数本身的程序对数据进行处理，最终将处理后的结果返回给函数的执行者。

  # s1 = '12312321321312'
  # ret = len(s1)
  # print(ret)
  

• 函数的执行时，我们传递的参数是实际参数，也叫做实参。

• 函数的定义时，我们会设置形式参数，也称为形参。

  def len_(argv):  # 定义函数  argv 形参
      res = 0
      for i in argv:
          res += 1
      return res
  
  
  s1 = '12312321321312'
  ret = len_(s1)  # 实际参数 实参
  

1.1 实参

• 位置参数， 从左至右，一 一对应。

  def tantan(sex, age, area):
  
      print('设置条件 性别：%s，年龄 %s，地区：%s' % (sex, age, area))
      print('左滑一下')
      print('右滑一下')
      print('锁定目标，双击')
      print('发送信息 约么')
  
  # 从左至右，一一对应。
  ret = tantan('女', '30以上', '东北')
  ret = tantan('女', '18~25', '日本')
  
  
  # 练习：实现一个函数，传递给函数两个整形数据，将最大的那个数据返回。
  
  # def max_(a, b):
  #     if a > b:
  #         return a
  #     else:
  #         return b
  #
  # ret = max_(10, 20)
  # # ret = max_(100, 30)
  # print(ret)
  
  # 简单的if else 我们可以用一行实现。
  
  # a = 100
  # b = 20
  # if a > b:
  #     c = a
  # else:
  #     c = b
  # print(c)
  #
  # # 三元运算优化
  #
  # a = 100
  # b = 200
  #
  # c = a if a > b else b
  # print(c)
  
  # 优化
  def max_(a, b):
      """
      c = a if a > b else b
      return c
      """
      return a if a > b else b
  ret = max_(10, 20)
  # ret = max_(100, 30)
  print(ret)
  

  • 传递给一个函数三个int类型的数据，将这三个数和返回。

    def sum_(a, b, c):
        return a + b + c
    print(sum_(1, 2, 3))
    

  • 错误示例：

    def func(a, b):
        print(a, b)
    
    # func(1)
    func(1,2,3)
    

• 关键字参数。一 一对应。

  def tantan(sex, age, area):
      print('设置条件 性别：%s，年龄 %s，地区：%s' % (sex, age, area))
      print('左滑一下')
      print('右滑一下')
      print('锁定目标，双击')
      print('发送信息 约么')
  tantan(age='20以上', sex='女', area='河北')
  

• 混合参数，一 一对应。所有的位置参数一定在所有的关键字参数前面。

  def tantan(first_name, sex, age, area):
        print('对方必须姓%s' % first_name)
        print('设置条件 性别：%s，年龄 %s，地区：%s' % (sex, age, area))
        print('左滑一下')
        print('右滑一下')
        print('锁定目标，双击')
        print('发送信息 约么')
  
  既有位置参数，又有关键字参数就称之为混合参数。
  tantan('王', '女', area='山东', age='18以上')
  所有的位置参数一定在所有的关键字参数前面。
  tantan(area='山东', '王', '女', age='18以上')
  

• 实参角度

  • 位置参数，从左至右，一一对应。
  • 关键字参数，一一对应。
  • 混合参数，一一对应，所有的位置参数一定要在所有的关键字参数的前面。

1.2 形参

• 位置参数。一一对应。

  从左至右，按照顺序一个一个的设置形参。
  def tantan(sex, age, area):  # sex age area 从左至右，一一设定的参数。
   	print('设置条件 性别：%s，年龄 %s，地区：%s' % (sex, age, area))
   	print('左滑一下')
   	print('右滑一下')
   	print('锁定目标，双击')
  	print('发送信息 约么')
  ret = tantan('女', '30以上', '东北')
  
  错误演示
  # def tantan(sex, age, area, name):
  # def tantan(sex, age):
    	pass
    	
  ret = tantan('女', '30以上', '东北')
  

• 默认值参数。

  # 只要实参给默认值参数传参，则默认值参数使用实参传递的数据，如果不传参，默认使用默认值。
  def func(a, b, c=666):
        print(a)
        print(b)
        print(c)
  
  func(1, 2)
  func(1, 2, 3)
  
  
  
  一般，不经常改变的数据我们会设置成默认值。
  我们简单写一个学生信息登记系统。
  让输入员，一个一个输入学生的姓名，年龄，性别。写入到文件中。
  def register_msg(n, a, s='男'):
  	with open('msg', mode='a', encoding='utf-8') as f1:
  		f1.write("{}|{}|{}\n".format(n, a, s))
  
  
  while 1:
      name = input('请输入姓名：/q或者Q退出').strip()
      if name.upper() == 'Q':
          break
  age = input('请输入年龄：').strip()
  # sex = input('请输入性别：').strip()
  register_msg(name, age)
  

• 万能参数

• 在函数定义时，*代表聚合，一颗星*将实参所有的位置参数全部都聚合成了一个元组，赋值给了*后面的args.；两颗星**将实参所有的关键字参数全部都聚合成了一个字典，赋值给了星后面的kwargs.

  def eat(*args): 
      print(args)
  eat('蒸羊羔','烧鸭', '烧雏鸡', )
  
  
  def eat(**kwargs):  
      print(kwargs)
  
  
  eat(name='barry', age=18, hobby='girl', weight=165)
  
  # 综合一下：
  def func(*args, **kwargs):
      print(args)
      print(kwargs)
  
  
  func('蒸羊羔', '烧鸭', '烧雏鸡', name='barry', age=18, hobby='girl', weight=165)
  

• 仅限关键字参数

  这个形参只能由实参角度的关键字参数给其传参，并且这个形参必须放在*args后面。

  def func(a, b, *args, c):
      print(a, b)
      print(args)
      print(c)
  
  
  func(1, 2, 3, 4, 5,c=666)
  

2.所有形参的顺序

• 到目前为止，我们讲过的形参：位置参数，默认值参数，*args, **kwargs, 仅限关键字参数。那么他们的顺序呢？

  def func(a, b, *args, sex='male'):
      print(a, b)
      print(sex)
      print(args)
  
  
  func(1, 2, 3, 4, 5)
  
  def func(a, b, *args, c, sex='male', **kwargs):
      print(a, b)
      print(args)
      print(c)
      print(sex)
      print(kwargs)
  
  
  func(1, 2, 3, 4, 5, c=666, name='barry', age=19)
  

• 最终的顺序：位置参数，*args, 仅限关键字参数，默认值参数，**kwargs。

3.*的魔法使用

• 函数执行时，*代表打散。一颗星将可迭代对象打散成位置参数，两颗星将字典打散成关键字参数。

  def func(*args):
      print(args)
      
      
  lst = [1, 2, 3, 4]
  s1 = 'barry'
  tu1 = ('barry', '王硕', 333)
  func(lst, 22, 33)
  
  函数的执行，*代表打散。
  
  func(*lst)  # 等同于  func(1, 2, 3, 4)
  func(*s1)  # 等同于 func('b', 'a', 'r', 'r', 'y')
  func(*tu1)  # 等同于 func('b', 'a', 'r', 'r', 'y')
  func(*lst, *s1)
  def func(**kwargs):  # 函数的定义，*代表聚合。
  print(kwargs)
  dic = {'name': 'barry', 'age': 18, 'hobby': 'girl'}
  dic1 = {'a': 'b'}
  
  函数的执行，*代表打散。
  func(**dic)  # 先打散，func(name='barry', age=18, hobby='girl')
  func(**dic, **dic1)  # 先打散，func(name='barry', age=18, hobby='girl', a='b')
  
  def func(*args, **kwargs):  # 函数的定义，*代表聚合。
        print(args)
        print(kwargs)
  
  lst = [1, 2, 3, 4]
  dic = {'name': 'barry', 'age': 18, 'hobby': 'girl'}
  func(*lst, **dic)
  

• * 可以处理剩余元素。

  a, b = [1, 2]
  print(a, b)
  
  a, *b, c = [11, 22, 33, 44, 55, 66]
  print(a, b, c)
  
  *a, b, c = [11, 22, 33, 44, 55, 66]
  print(a, b, c)
  
  a, b, *c = range(1, 11)
  print(a, b, c)
  
  a, *b = (11, 22, 33, 44, 55, 66)
  print(a, b)