python 函数的参数、形参、实参、缺省参数、不定长参数、参数的拆包与函数返回值及嵌套调用

一、函数的参数与返回值模式

在Python中，函数可以根据参数和返回值的存在与否分为以下四种模式：

• 无参数无返回值
  函数既不接受任何参数，也不返回任何值。
  它通常执行某种操作，但不需要外部输入，也不产生调用外部使用的结果

  def function():
      pass  # 这里可以是你想执行的操作
  

  def add():
  	a = 20
  	b = 30
  	result = a + b
  	print('%d + %d = %d' % (a, b, result )
  	
  if __name__ == '__main__':
  	add()
  

• 无参数有返回值
  该函数不接受参数，但执行后会返回一个值。该函数通常基于内部逻辑或数据产生结果。

  def function():
     # 执行操作
     return result  # 返回一个值或表达式的结果
  

  def add():
  	a = 20
  	b = 30
  	result = a + b
  	return result
  	
  if __name__ == '__main__':
  	add()
  

• 有参数无返回值
  此类型的函数接受一个或多个参数，基于这些参数的操作执行，但不返回任何值。

  def function(parameter1, parameter2, ...):  # 可以有多个参数
      pass  # 根据参数执行操作
  

  def add(a, b):
  	result = a + b
  	print('%d + %d = %d' % (a, b, result )
  	
  if __name__ == '__main__':
  	add(3, 5)
  

• 有参数有返回值
  这是最常见的函数类型。它接受参数，并基于这些参数产生并返回一个结果。

  def function(parameter1, parameter2, ...):  # 可以有多个参数
      # 执行操作
      return result  # 返回基于参数的值或表达式的结果
  

  def add(a, b):
  	result = a + b
  	return result
  	
  if __name__ == '__main__':
  	add(3, 5)
  

二、形参、实参、缺省参数、不定长参数

2.1 参数类型和概念

• 形参(形式参数）
  形参是函数定义中指定的参数。它们只是占位符，并没有实际的值。当调用函数时，形参会接收实参的值。

  def greet(name):  # 'name' 是形参
      print(f"Hello, {name}!")
  

• 实参（实际参数）
  实参是在函数调用时传递的实际值。这些值被传递给形参。

  greet("Alice")  # "Alice" 是实参
  

• 默认参数(缺省参数)
  函数定义中的参数参数有一个默认值。
  如果在调用函数时没有为这个参数提供值，就可以使用这个默认值。
  否则，使用确定的值

  def greet(name="Guest"):
      print(f"Hello, {name}!")
      
  if __name__ == '__main__':
  	greet()         # 输出: Hello, Guest!
  	greet("Bob")    # 输出: Hello, Bob!
  

• 不定长参数（可变长度参数）
  不确定可能会提供多少参数给函数时，可以使用不定长的参数
  *args：对于非关键字参数，将它们保存为元组
  **kwargs：用于关键字参数，将它们保存为字典

  def func(*args, **kwargs):
      for arg in args:
          print(arg)
  
      for key, value in kwargs.items():
          print(f"{key} = {value}")
  
  if __name__ == '__main__':
  	func(1, 2, 3, a=4, b=5)
  
  1
  2
  3
  a = 4
  b = 5
  

• 拆包
  拆包允许我们将元组和字典的元素分解，使其可以作为单独的参数传递给函数
  拆元组：实参掺入元组在变量前加*，定义时以元组保存
  拆字典：实参掺入元组在变量前加**， 定义时以字典保存

  如果不使用相应的*或**，参数会作为单个元素（例如整个元组或整个字典）传递

  def func3(a, b, *args, **kwargs):
      print("Positional:", a, b)
      print("From tuple:", args)
      print("From dictionary:", kwargs)
  
  if __name__ == '__main__':
  	# 定义一个元组和字典
  	A = (55, 66, 77)
  	B = {'name':'laowang', 'age':33, 'address':'隔壁'}
  	
  	# 未拆包传递
  	func3(33, 44, A, B)
  	print('--------拆包后传递----------')
  	# 拆包传递
  	func3(33, 44, *A, **B)
  
  Positional: 33 44
  From tuple: ((55, 66, 77), {'name': 'laowang', 'age': 33, 'address': '隔壁'})
  From dictionary: {}
  --------拆包后传递----------
  Positional: 33 44
  From tuple: (55, 66, 77)
  From dictionary: {'name': 'laowang', 'age': 33, 'address': '隔壁'}
  

三、函数的返回值

• 函数内部定义的变量是局部的，只在该函数内可用。要在一个函数中使用另一个函数的结果

  在源函数中return所需的结果。
  在调用源函数时，捕获其返回值。
  将此返回值作为参数传递给目标函数
  

  def function1():
      result = 10
      return result
  
  def function2(value):
      print(value)
  
  func1 = function1()
  func2(func1)
  

• 函数中的多个return

  def using_list(): # 多个return，只运行到第一个return，其后的函数return都不执行
      return [1, 2, 3]
  	return (1, 2, 3)
  	return {"a": 1, "b": 2, "c": 3} # 使用字典
  

• 函数的嵌套调用
  函数的嵌套调用指的是在一个函数的定义或调用中，又调用了其他的函数。
  这样做的目的通常是为了模块化代码，使其更加清晰、简洁并提高代码的复用性、可读性。

  场景，计算一个三角形的面积。面积计算需要基础的三角形公式：面积 = 0.5 * base * height。
  同时，您可能想根据三角形的三条边计算其高

  def calculate_height(a, b, c):
      # 这里简化为假设a为底边，b和c为其他两边，实际情况可能需要更复杂的计算
      # 返回三角形的高
      return (2 * (b**2 - (0.5 * a)**2)**0.5) / a
  
  def triangle_area(a, b, c):
      height = calculate_height(a, b, c)
      return 0.5 * a * height
  
  area = triangle_area(3, 4, 5)
  print(area)
  

  首先调用triangle_area函数，它内部又调用了calculate_height函数。这就是函数的嵌套调用