Python 自定义函数定义、参数与调用全解析

Python 函数的基本定义与结构

在 Python 中，自定义函数是代码复用的核心单元。一个标准的函数定义以 def 关键字开头，后接函数名、圆括号内的参数列表以及冒号。函数体必须缩进，以体现代码块的范围。若函数需要返回结果，则使用 return 语句；若无显式返回值，Python 默认返回 None。

基础函数示例

以下代码展示了无参函数、带返回值函数以及有参函数的基本写法：

''' some basic functions '''
def func1():          # 函数无传入参数
  print("func1")       # 无return值
func1()             # 函数调用

def func2():
  return("func2")       # return 字符串 "func2"
print(func2())

def func3(a,b):         # 需传两个参数
  print("a+b = %d" %(a+b))  # print表达式，无return
func3(3,4)

def func4(a,b):         # 需传两个参数
  return (a+b)        # return a+b 的值
print(func4(4,3))

默认参数与调用规则

Python 允许为函数参数指定默认值。调用函数时，若未提供对应参数，则使用默认值。需注意以下关键点：

1. 参数顺序：必须遵循“先必选参数，后默认参数”的顺序。
2. 解析时机：默认值在函数定义时（而非调用时）被解析。
3. 可变对象陷阱：若默认值是可变对象（如列表、字典），其状态会在多次调用间累积。

默认参数示例：交互式询问

以下函数演示了默认参数的使用，包括重试机制和自定义提示信息：

''' advanced: 简单询问框 '''
def ask_ok(hint, retries=4, complaint='Yes or no, please!'):  # 仅有hint是必须要传入的，retries 和 complaint 均有默认值
  while True:
    u = input(hint)
    if u in ('y','ye','yes'):       # in 的用法；若用户回答在('y','ye','yes') return True 
      return True
    if u in ('n','no','nop','nope'):   # 若用户回答在('n','no','nop','nope') return False
      return False
    retries = retries -1         # 若用户输入不在之前所列，可重试，重试次数-1
    if retries <= 0 :           # 若超出重试次数，raise自定义Error
      raise IOError('refusenik user')
    print(complaint)           # 若用户输入不在之前所列，提示 complaint 信息

result1 = ask_ok("Yes or No?")        # 只给必要的参数值hint，可尝试输入'y' 'no' 等；输入其他的如 'x' 超过4次
print(result1)                # 查看return的值

# result2 = ask_ok("Yes or No?",2)      # 给出retries=2，尝试输入其他的如 'x' 超过2次    

# result3 = ask_ok("Yes or No?",'Y or N?')  # 不可只省略第二个参数，若尝试输入其他的如 'x'，会报错

# result4 = ask_ok("Yes or No?",3,'Y or N?') # 给出所有的参数，可尝试输入'y' 'no' 等；输入其他的如 'x' 超过3次
# print(result4)

默认值的解析时机

默认值在函数定义作用域被解析。若默认值引用外部变量，其值在定义时确定，而非调用时：

'''默认值是在函数定义作用域被解析的'''
i = 5
def print_i(var=i):
  print(var)
i = 6
print_i()    # 输出为5

可变默认参数的陷阱与规避

当默认参数为可变对象（如列表）时，多次调用会共享该对象，导致状态累积。例如：

''' 默认值只被赋值一次。这使得当默认值是可变对象时会有所不同，如列表、字典或大多数类的实例。
  函数在后续调用过程中会累积之前传给它的参数。
'''
def append_L(a,L=[]):     # 必须传参a，L不必须，为list，默认为空
  L.append(a)
  return L
print(append_L(1))      # 给出参数 a=1, 此时 L 已变为 [1]
print(append_L(2))      # 输出 [1,2]
print(append_L(3))      # 输出 [1,2,3]

规避方法：将默认值设为 None，并在函数体内初始化新对象：

''' L缺省时，做改变L，而不是累积值，可像下方这样定义函数 '''
def change_L(a,L=None):
  if L is None:
    L = []
  L.append(a)
  return L
print(change_L(1))      # 给出参数 a=1, L为None
print(change_L(2))      # 给出参数 a=2, L为None  输出 [2]
print(change_L(3,[0]))    # 给出参数 a=1, L=[0]  输出 [0,3]

关键字参数与可变数量参数

Python 支持通过关键字参数调用函数，允许以任意顺序传递参数。此外，使用 *args 可接收任意数量的位置参数，它们被封装为元组。

关键字参数调用

通过指定参数名，可以忽略定义顺序：

def add(a,b):          
   return (a+b)        
 print(add(b=9,a=2))        # 关键字参数定义 b=9 , a=2 与传参顺序无关
 # print(add(b=9,2))        # 会报错

可变数量参数（*args）

*strs 接收多个位置参数，配合关键字参数 sep 实现灵活的字符串连接：

def join_bysep(*strs,sep):    # strs 可为多个参数
  return sep.join(strs)     # 字符串连接函数 sep.join(str)
print(join_bysep("red","blue","green",sep=" "))
print(join_bysep("red","blue",sep=","))
print(join_bysep("red",sep=","))
print(join_bysep(sep=","))    # 无strs传参，为一空的字符串

总结

掌握 Python 函数的定义、参数传递（位置、默认、关键字、可变数量）及调用规则，是编写高质量代码的基础。特别注意默认可变对象的陷阱，合理使用 None 进行初始化，能有效避免难以排查的 bug。以上就是 Python 自定义函数定义、参数与调用全解析的详细内容，更多关于 Python 函数编程的资料请关注本站其它相关文章！