2022年 11月 5日

【Python 26】函数的定义和调用

目录

1、函数的创建和调用

2、函数的参数传递

3、函数的返回值

4、函数的参数定义

5、变量的作用域

6、递归函数

 6.1 什么是递归函数

 6.2 递归的组成部分

 6.3 递归的调用过程

 6.4 递归的优缺点

1、函数的创建和调用

(1) 函数是一个完成特定工作的独立程序模块，包括库函数和自定义函数。

(2) 复用代码，隐藏实现细节，提高可维护性
(3) 提高可读性便于调试

  1. # 作   者：要努力，努力，再努力
  2. # 开发日期：2022/4/22 14:41
  3.  
  4. def calc(a, b):  # 形参
  5.     c = a + b
  6.     return c
  7.  
  8.  
  9. result = calc(10, 20)  # 位置实参
  10. print(result)
  11.  
  12.  
  13. rec = calc(b=10, a=20)  # 关键字实参
  14. print(rec)

2、函数的参数传递

如果是不可变对象，在函数体的修改不会影响实参的值
如果是可变对象，在函数体的的修改会影响到实参值的修改

  1. # 作   者：要努力，努力，再努力
  2. # 开发日期：2022/4/22 14:57
  3.  
  4. def fun(arg1, arg2):
  5.     print('arg1', arg1)
  6.     print('arg2', arg2)
  7.     arg1 = 100
  8.     arg2.append(10)
  9.     print('arg1', arg1)
  10.     print('arg2', arg2)
  11.  
  12.  
  13. n1 = 11
  14. n2 = [22, 33, 44]
  15. print('n1', n1)
  16. print('n2', n2)
  17. fun(n1, n2)
  18. print('n1', n1)
  19. print('n2', n2)

3、函数的返回值

  1. # 作   者：要努力，努力，再努力
  2. # 开发日期：2022/4/22 15:07
  3.  
  4. print(bool(0))
  5. print(bool(8))
  6.  
  7.  
  8. def fun(num):
  9.     odd = []  # 存奇数
  10.     even = []  # 存偶数
  11.     for i in num:
  12.         if i % 2:
  13.             odd.append(i)
  14.         else:
  15.             even.append(i)
  16.     return odd, even
  17.  
  18.  
  19. lst = [10, 29, 34, 44, 53, 55]
  20. print(fun(lst))  # 返回的是元组： 元素是列表
  21.  
  22. '''
  23.     (1) 函数可以没有返回值
  24.     (2) 函数的返回值，如果是只有一个，返回原类型
  25.     (3) 函数的返回值，如果是只有多个，返回元组
  26. '''
  27.  
  28.  
  29. def fun():
  30.     print('hello')
  31.  
  32. fun()
  33.  
  34. def fun2():
  35.     return 'hello'
  36.  
  37. ref = fun2()
  38. print(ref)
  39.  
  40.  
  41. def fun3():
  42.     return 'hello','world'
  43.  
  44. print(fun3())
  45.

4、函数的参数定义

默认值参数

  1. # 作   者：要努力，努力，再努力
  2. # 开发日期：2022/4/22 15:23
  3.  
  4. def fun(a, b=10):  # b为默认值形参
  5.     print(a, b)
  6.  
  7.  
  8. fun(100)
  9. fun(10, 20)
  10.  
  11. print('hello', end='\t')
  12. print('world')

 位置参数、关键字参数：

  1. # 作   者：要努力，努力，再努力
  2. # 开发日期：2022/4/22 15:27
  3.  
  4. def fun(*arg):  # 函数定义时，个数可变的位置参数，结果是元组
  5.     print(arg)
  6.     print(arg[0])
  7.  
  8.  
  9. fun(10)
  10. fun(10, 20)
  11. fun(10, 20, 30)
  12.  
  13.  
  14. def fun1(**args): # 函数定义时，个数可变关键字的参数，结果是字典
  15.     print(args)
  16.  
  17.  
  18. fun1(a=10, b=20, c=40)
  19.  
  20.  
  21.  
  22. # def fun2(*args,*a):  # 报错。只能一个位置可变参数
  23.  
  24. # def fun2(**args,**a):  # 报错。只能一个关键字可变参数
  25.  
  26. def fun2(*args,**arg2):
  27.     pass
  28.  
  29. # def fun2(**args,*arg2):   # 报错。在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参，放在个数可变的关键字形参之前
  30. #     pass

 将元素转换为位置实参、关键字实参：

  1. # 作   者：要努力，努力，再努力
  2. # 开发日期：2022/4/22 16:30
  3. def fun(a, b, c):
  4.     print('a=', a)
  5.     print('b=', b)
  6.     print('c=', c)
  7.  
  8.  
  9. fun(10, 20, 30)  # 位置实参
  10. lst = [11, 22, 33]  # 将列表中的每个元素都转化为位置实参
  11. fun(*lst)
  12.  
  13. fun(a=10, b=20, c=30)
  14. dict = {'a': 100, 'b': 200, 'c': 300}
  15. fun(**dict)  # 将字典中的每个元素都转化为关键字实参
  16.  
  17.

在函数定义中，默认值参数、位置参数、关键字参数混合使用：

  1. # 作   者：要努力，努力，再努力
  2. # 开发日期：2022/4/22 16:44
  3. def fun(a, b, c, d):
  4.     print('a=', a)
  5.     print('b=', b)
  6.     print('c=', c)
  7.     print('d=', d)
  8.  
  9.  
  10. fun(10, 20, 30, 40)
  11. fun(a=10, b=20, c=30, d=40)
  12. fun(10, 20, c=30, d=40)
  13.  
  14.  
  15. def fun2(a, b, *, c, d):  # * 之后的用关键字参数传递
  16.     print('a=', a)
  17.     print('b=', b)
  18.     print('c=', c)
  19.     print('d=', d)
  20.  
  21.  
  22. # fun2(10, 20, 30, 40) # TypeError: fun2() takes 2 positional arguments but 4 were given
  23. fun2(a=10, b=20, c=30, d=40)
  24. fun2(10, 20, c=30, d=40)
  25.  
  26.  
  27. def fun3(a, b, *, c, d, **args):
  28.     pass
  29.  
  30.  
  31. def fun4(*args, **args2):
  32.     pass
  33.  
  34.  
  35. def fun5(a, b=4, *args, **args2):
  36.     pass

5、变量的作用域

(1) 局部变量：在程序中使用变量都定义在函数内部，作用范围:被局限于所在函数内。  [  例如：形参就是局部变量。  ]

(2) 全局变量：定义在函数外而不属于任何函数的变量称为全局变量。

作用范围:对所有函数都起作用。生命周期：从开始定义到程序所在文件的结束。

 注意：global 的使用

  1. # 作   者：要努力，努力，再努力
  2. # 开发日期：2022/4/22 16:59
  3.  
  4. def fun(a, b):
  5.     c = a + b  # a,b,c都为局部变量
  6.     print(c)
  7.  
  8.  
  9. name = '杨老师'  # name为全局变量
  10. print(name)
  11.  
  12. def fun2():
  13.     print(name)
  14.  
  15. fun2()
  16.  
  17. def fun3():
  18.     global age  # global 在函数内部定义全局变量
  19.     age = 20
  20.     print(age)
  21.  
  22. fun3()
  23. print(age)
  24.

6、递归函数

 6.1 什么是递归函数

        如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数

 6.2 递归的组成部分

        递归调用与递归终止条件

 6.3 递归的调用过程

        每递归调用一次函数，都会在栈内存分配一个栈帧

        每执行完一次函数，都会释放相应的空间

 6.4 递归的优缺点

        缺点:占用内存多，效率低下

        优点:思路和代码简单
        

下面代码最好设置断点调试：

  1. # 作   者：要努力，努力，再努力
  2. # 开发日期：2022/4/22 17:11
  3. def fun(n):
  4.     if n == 1:
  5.         return 1
  6.     else:
  7.         res = n * fun(n - 1)
  8.         return res
  9.  
  10.  
  11. print(fun(6))

实现菲波那切数列：

原理：第一项为1，第二项为1，从第三项开始为前两项之和。

  1. # 作   者：要努力，努力，再努力
  2. # 开发日期：2022/4/23 7:51
  3.  
  4. def fun(n):
  5.     if n == 3:
  6.         return 1 + 1
  7.     elif n == 2 or n == 1:
  8.         return 1
  9.     else:
  10.         return fun(n - 1) + fun(n - 2)
  11.  
  12.  
  13. for i in range(1, 11, 1):
  14.     num = fun(i)
  15.     print(num, end='\t')
  16.  
  17.