6.1_8 Python3.x入门 P8 【函数】

相关链接

• 目录
• Mac M1 Python环境搭建
• Python3.x入门 P1 【基础】基础语法、注释、标识符、变量、数据类型、键盘录入input
• Python3.x入门 P2 【基础】运算符
• Python3.x入门 P3 【基础】流程语句【循环结构】
• Python3.x入门 P4 【基础】序列 - 公共方法总结
• Python3.x入门 P5 【基础】可变序列（列表list、字典dict、集合set）
• Python3.x入门 P6 【基础】不可变序列（元组tuple、字符串str）
• Python3.x入门 P7 【字符串格式化】四种方式（手动、%-formatting、str.format()、f-String）
• Python3.x入门 P8 【函数】
• Python3.x入门 P9 【异常Error】常见Error、异常捕获try catch

---

---

一、函数的定义与调用

1. def是英文define的缩写
2. 函数名称应该能够表达函数封装代码的功能，方便后续的调用
3. 函数调用必须在函数定义的下方（python属于解释型语言，逐行解析、逐行运行）
4. 函数名称的命名应该符合 标识符的命名规则
  a. 可以由字母、下划线和数字组成
  b. 不能以数字开头
  c. 不能与关键字重名

"""
 @author GroupiesM
 @date 2022/6/29 15:49
 @introduction
    函数：完成指定功能的一段代码
    优点：复用代码、隐藏实现逻辑、提高可维护性、提高可读性便于调试
    语法：
        def 函数名(变量1:类型1,变量2:类型2,...):
            函数体
            返回体 return xxx
    语法简写：
        def 函数名(变量1,变量2,...):
            函数体
            返回体 return xxx
    P.S:
        1.可以没有变量，根据实际业务场景决定
        2.可以没有返回体，根据实际业务场景决定
"""
# 1.定义函数(有返回值）
def sum(a, b):
    c = a * 2 + b
    return c
# 1.调用函数(有返回值）
print(sum(10, 20))  # 40

# 2.定义函数(无返回值）
def print_sum(a, b): print(a * 2 + b)
# 2.调用函数(无返回值）
print_sum(10, 20)  # 40

1.1 函数的注释

  根据PEP 8（Python官方代码风格文档）要求，函数上方、下方各保留2个空行，并且函数名下方使用三引号注释。

import random


def print_params(arg1: str, arg2: str):
    """文档注释：打印参数（函数上方、下方均要空两行，文档注释使用三引号）

    :param arg1: 第一个参数
    :param arg2: 第二个参数
    """
    print(arg1, arg2, sep='\n')


def r_int():
    """文档注释：随即获取1~100的正整数"""
    return random.randrange(1, 100, 1)


print_params(r_int(), r_int())

  可以通过点击代码，选择 View -> Quick Documentation （也可以点击快捷键，但我的MacPro M1没有f1键）快速查看函数的注释内容。

  显示效果如下：

---

二、函数的参数

2.1 参数传递

"""
 @author GroupiesM
 @date 2022/6/29 17:32
 @introduction
    形参：定义函数时，定义的参数变量
    实参：调用函数时，传递的参数
"""
'''定义函数
形参：a,b
'''
def sum(a, b):
    c = a * 2 + b
    return c

'''调用函数
实参：10，20
未指定形参，按函数形参顺序赋值
'''
result = sum(10, 20)
print(result)  # 40

'''
指定形参，按指定赋值
'''
result = sum(b=10, a=20)
print(result)  # 50

2.2 参数默认值

"""
 @author GroupiesM
 @date 2022/6/30 10:10
 @introduction
"""
# 形参b指定默认值为10
def func(a, b=10):
    print(a, b)

"""函数的调用
 形参有默认值的情况下(b=10)，
    1.如果实参没有传递值，则使用默认值(b=10)
    2.如果实参指定了值(b=30)，则使用指定值(30)
"""
func(100) # 100 10
func(20, 30) # 20 30
# func(a=20, 30) # 报错 - 如果指定参数，需要指定全部参数

2.3 可变参数

"""
 @author GroupiesM
 @date 2022/6/30 10:17
 @introduction
 规则：
    1.从*之后，调用函数时，只能采用关键字进行参数传递

 一、可变参数-位置参数（元组）
    1.定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
    2.使用*定义个数可变的位置形参
    3.结果为一个元组tuple(v1,v2,...)
    4.参考：解压元组
        tup = (4127, 4098, 8637678)
        print(14, 'Jack: {}; Sjoerd: {}; ''Dcab: {}'
              .format(*tup))  # Jack: 4127; Sjoerd: 4098; Dcab: 8637678

二、可变参数-关键字形参（字典）
    1.定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
    2.使用**定义个数可变的关键字形参
    3.结果为一个字典dict{k1:v1,...}
    4.参考：解压元组
        table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
        print(6, 'Jack: {Jack}; Sjoerd: {Sjoerd}; Dcab: {Dcab}'
              .format(**table))  # Jack: 4098; Sjoerd: 4127; Dcab: 8637678
"""
#  一、可变参数-位置参数（元组）
def function_tuple(*args):
    print(args)

function_tuple(10)  # (10,)
function_tuple(10, 20, 30)  # (10, 20, 30)

# 二、可变参数-关键字形参（字典）
def function_dict(**arg):
    print(arg)

function_dict(a=10)  # {'a': 10}
function_dict(a=10, b=20, c=30)  # {'a': 10, 'b': 20, 'c': 30}

def funciton_test(*arg1,**arg2):
    pass

# def funciton_test(*arg1,*arg2): # 两种可变参数，一个函数中只能分别出现1次

2.4 参数*

"""
 @author GroupiesM
 @date 2022/6/30 10:17
 @introduction
 规则：
    1.从*之后，调用函数时，只能采用关键字进行参数传递
"""
def function_star(a, b, *, c, d):
    print(f'{a=},{b=},{c=},{d=}')

function_star(10, 20, d=30, c=40)  # a=10,b=20,c=40,d=30

2.5 多种参数混合

"""
 @author GroupiesM
 @date 2022/6/30 11:29
 @introduction
 规则：
    1. * 和 *args 互斥，不能同时出现
        def func1(a, * , *args): pass # 报错
"""
def func1(a, b): pass

def func2(a, b=10): pass # 有默认值的函数
func2(10,20)

def func3(*args): pass # 可变参数-位置形参
func3(10)
func3(10,)
func3(10,20)

def func4(**args): pass # 可变参数-关键字形参
func4(x=10,y=20)

print('func5')
def func5(a, b, *, c, d, **args2): print(f"{a=},{b=},{c=},{d=},{args2=}") # 混合
func5(10,20,c=30,d=40,f=50) # a=10,b=20,c=30,d=40,args2={'f': 50}

def func6(*args1, **args2): pass # 混合
func6(10,c=50)

print('func7:')
def func7(a, b, *args1, **args2): print(f"{a=},{b=},{args1=},{args2=}")  # 混合
func7(10,20,30,d=40) # a=10,b=20,args1=(30,),args2={'d': 40}

print('func8:')
def func8(a, b=10, *args1, **args2): print(f'{a=},{b=},{args1=},{args2=}') # 混合
func8(10,20,30,d=40) # a=10,b=20,args1=(30,),args2={'d': 40}

三、函数返回值

"""
 @author GroupiesM
 @date 2022/6/29 17:44
 @introduction
    函数的返回值
        函数返回多个值时，结果为元组tuple(v1,v2,...)
"""
# 一、没有返回值
def funcOne():
    print("hello")
funcOne() # hello

# 二、返回一个值
def funcTwo():
   return 'hello'
print(funcTwo()) # hello

# 三、返回多个值
def funcThree():
    return 'hello','python'
print(funcThree()) # ('hello', 'python')

# 三、返回多个值(拆分基数和偶数)
def num_split(num: list):
    odd = []  # 存放奇数
    even = []  # 存放偶数
    obj = []  # 存放其他类型
    for i in num:
        if type(i) == int:
            if i % 2:
                odd.append(i)
            else:
                even.append(i)
        else:
            obj.append(i)
    return odd, even, obj

print(num_split([3, 4, 6, 12, 3.14, 'luna', True, {'doom': 18}]))
'''测试结果
([3], [4, 6, 12], [3.14, 'luna', True, {'doom': 18}])
'''

---

四、变量的作用域

"""
 @author GroupiesM
 @date 2022/6/30 11:44
 @introduction
 变量的作用域：
    1.程序代码能访问该变量的区域
    2.根据变量的有效范围可分为：全局变量、局部变量
        2.1 全局变量
            函数体外定义的变量，可做用于函数内外
        2.2 局部变量
            在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会成为全局变量
"""
# 1.全局变量
name ='luna'
def fun2():
    age=16 # 2.局部变量
    global money # 1.全局变量
    money = 10000
    # 引用1.全局变量 + 2.局部变量
    print(name,age)
fun2()
'''测试结果
luna 16
'''

# 引用1.全局变量
print(name,money)
'''测试结果
luna 10000
'''

# 引用2.局部变量
# print(age) # 不能在函数体外引用局部变量

---

五、递归函数

嵌套调用函数：一个函数里面又调用了另一个函数。
递归函数：一个函数里面调用了函数自身。

---

5.1 阶乘

"""
 @author GroupiesM
 @date 2022/6/30 13:41
 @introduction
 递归函数：
    1.函数体内调用了函数本身，这个函数称为递归函数
    2.递归函数需要：递归调佣、递归终止条件
    3.每递归调用一次函数，都会在栈内分配一个栈帧
    4.每执行完一次函数，都会释放相应的空间
"""


# 案例：阶乘
def factorial(num:int):
    if num < 1 :
        print("参数错误，请输入大于1的数字")
        return None
    if num == 1:
        return 1
    else:
        result = num * factorial(num - 1)
        return result

print(factorial(5)) # 120

5.2 斐波那契函数

"""
@author GroupiesM
@date 2022/6/30 14:13
@introduction
斐波那契函数 : 从第三个数起，每个数是前两个数之和

数值      1   1   2  3   5   8   13   21 ...
递归次数   0   0  1   2   3   4   5    6
"""


def _trans_lst_to_dct(lst: list):
   """list格式斐波那契数列转dict格式输出

   :param lst:list形式斐波那契数列
   :return:
   """
   dct = {}
   for i in range(len(lst)):
       dct[f'第{i + 1}位'] = lst[i]
   return dct


def fibonacci(length: int, type: int = 0):
   """获取斐波那契数列

   :param length: 斐波那契数列长度
   :param type: 0=数组格式 1=字典格式
   :return:
   """
   if length < 1 or type not in [0, 1]:
       print('参数异常，请检查传参格式。 length>1，type（0=数组格式 1=字典格式）')
       return
   if type == 0:  # type==0 数组
       if length == 1:
           return [1]
       elif length == 2:
           return [1, 2]
       else:
           lst = _fibonacci_recursion(length - 1)
           return lst
   elif type == 1:  # type==1 字典
       if length == 1:
           return {'第1位': 1}
       elif length == 2:
           return {'第1位': 1, '第2位': 1}
       else:
           lst = _fibonacci_recursion(length - 1)
           return _trans_lst_to_dct(lst)


def _fibonacci_recursion(_recursion_times: int, _lst=None, _order_number=3):
   """斐波那契数列递归方法

   :param _recursion_times: 剩余递归次数
   :param _lst: 存放结果
   :param _order_number:已递归次数
   :return:
   """
   if _lst is None:
       _lst = [1, 1]  # 初始化数列，前两个值为1，1
   if _recursion_times == 1:
       return _lst
   else:
       _lst.append(_lst[len(_lst) - 2] + _lst[len(_lst) - 1])  # 存放当前递归结果：前两位之和
       result = _fibonacci_recursion(_recursion_times - 1, _lst, _order_number=_order_number + 1)  # 获取下一个数字
   return result


print(fibonacci(3))  # [1, 1, 2]
print(fibonacci(5, 0))  # [1, 1, 2, 3, 5]
print(fibonacci(6, 1))  # {'第1位': 1, '第2位': 1, '第3位': 2, '第4位': 3, '第5位': 5, '第6位': 8}

---

22/06/30

M