Python（青铜时代）——函数的进阶与递归

函数的返回值

返回值

• 在程序开发中，有时候，会希望一个函数执行结束后，告诉调用者一个结果，以便调用者针对结果作后续的处理

• 返回值 是函数 完成工作后，最后给调用者的一个结果

• 在函数中使用 return 关键字可以返回结果

• 调用者 可以使用变量 来接收函数的返回结果

返回值示例

# 单返回值示例
def test1():
  name="zs"
  return name

n=test1()
print("名字是:%s" %n)


# 多返回值，返回元组
def test2():
  name="zs"
  age=12
  return name,age

n,a=test2()
print("名字是：%s,年龄是：%d" %(n,a))

#第二种返回值接收形式
result=test2()
print(result)
print("名字是：%s,年龄是：%d" %(result[0],result[1]))


# 多返回值，返回元组2,与上一个函数返回的结果是一样的
def test3():
  name="zs"
  age=12
  return (name,age)
n,a=test3()
print("名字是：%s,年龄是：%d" %(n,a))

输出结果

交换变量的值

a=100
b=10

# 形式一
b,a=a,b
print(b,a)

# 形式二,注： 其实两种方式是一样的，只是看起来一个加了括号一个没加，但其实后面都是用的元组
b,a=(a,b)
print(b,a)

函数的参数

不可变与可变参数

• 在函数内部，针对参数使用 赋值语句，不会影响调用函数时传递的 实参变量

• 不管是可变还是不可变类型的参数，针对参数使用 赋值语句，会在函数内部修改局部变量的引用，不会影响 外部变量的引用

• 当参数是 可变类型时，在函数内部，使用 方法 修改了数据的内容，会影响到外部的数据

示例

# 可变与不可变类型参数，使用赋值语句 不会影响外部调用时的 变量
def test1(num,num_list):
  num=10
  num_list=[4,5,6]
  print("函数内部num值：%d" %num)
  print("函数内部num_list值：",num_list)

gl_num=3
gl_num_list=[1,2,3]
test1(gl_num,gl_num_list)
print("函数外部num值：%d" %gl_num)
print("函数外部num_list值：",gl_num_list)


# 可变类型的参数，使用 方法赋值，会影响外部调用时的 变量
def test2(num_list):
  # 形式一
  num_list.append(9)
  # 形式二
  num_list.extend([2,2,2])
  # 形式三（默认使用的也是 extend）
  num_list+=[3,3,3]
  print("函数内部调用后的值是：",num_list)

gl_num_list2=[1,1,1]
test2(gl_num_list2)
print("函数外部调用后的值是：",gl_num_list2)

输出结果

缺省参数

• 定义函数时，可以给 某个参数 指定一个默认值，具有默认值的参数就叫 缺省参数

• 调用函数时，如果没有传入缺省参数的值，则在函数内部会使用 参数的默认值

• 函数的缺省参数，将常见的值设置为参数的缺省值，从而 简化函数的调用

• 缺省参数的定义位置，应该放在参数列表的末尾

• 如果有 多个缺省参数，调用时需要指定参数名，这样解释器才能知道参数的对应关系

def test1(name,work="工程师",gender="男"):
  print("名字是：%s,职位是：%s,性别是：%s" %(name,work,gender))

test1("张三",gender="女")
test1("李四",work="设计师")
test1("王五",work="设计师",gender="人妖")

输出结果

多值参数

• 参数名前增加一个 * 可以接收 元组

• 参数名前增加 两个 * 可以接收 字典

• 一般在给多值参数命名时，习惯使用以下两个名字

  • *args  存放 元组 参数，前面有一个 *

  • **kwargs  存放 字典 参数，前面有两个 *

• args 是 arguments 的缩写，有变量的含义

• kw 是 keyword 的缩写，kwargs 可以记忆 键值对参数

示例

# 测试普通参数，元组，字典传参
def test(num,*args,**kwargs):
  print(num)
  print(args)
  print(kwargs)


test(1,2,3,4,5,nmae="zs",age="12")

输出结果

元组和字典的拆包

• 在调用带有多值参数的函数时，如果希望：

  • 将一个 元组变量，直接传递给 args

  • 将一个 字典变量，直接传递给 kwargs

• 就可以使用 拆包，简化参数的传递，拆包的方式是：

  • 在 元组变量前，增加一个 *

  • 在 字典变量前，增加两个 *

示例

def test(*args,**kwargs):
  print(args)
  print(kwargs)

# 不使用拆包
test(1,2,3,name="zs",age=12)

# 使用拆包
t_tuple=(1,2,3)
d_dict={"name":"zs","age":12}
test(*t_tuple,**d_dict)

输出结果

递归

• 一个函数，内部自己调用自己

• 当 参数满足一个条件时，函数不再执行，这个非常重要，通常被称为 递归的出口，否则 就会出现 死循环

示例

# 使用递归 计算累加  1+2+3....num
def sum_num(num):
  # 定义出口
  if num==1:
    return 1

  tmp=sum_num(num-1)
  return num+tmp

total=sum_num(10)
print("累加的值是:",total)

输出结果

程序猿与投资生活实录已改名为  程序猿知秋，WX同款，欢迎关注！