python -【四】函数

函数

一、函数的基础

函数：是组织好的，可以重复使用的，用来实现特定功能的代码段

语法

def 函数名(入参):
    return 出参

# 定义函数
def out_hello():
    print('hello ~~~')

# 调用/使用/执行函数
out_hello()

练习题

自定义一个函数，返回一个整型数字，输入一个字符串

# 定义函数
def convert(str_):
    print(f'输入的内容是：{str_}, 类型：{type(str_)}')
    return int(str_)

# 执行函数
v = convert('123')
print(f'输出的内容是：{v}, 类型：{type(v)}')


"""
输入的内容是：123, 类型：<class 'str'>
输出的内容是：123, 类型：<class 'int'>
"""

二、函数的参数

def add(x, y):
    z = x + y
    print(f' {x} + {y} = {z}')

add(5, 5)


"""
x, y : 形参
5, 5: 实参
输出结果：5 + 5 = 10
"""

三、函数的返回值

def add(x, y):
    return x + y

v = add(5, 5)
print(v)


"""
输出结果：10
"""

def none_func_1():
    print('')


def none_func_2():
    print('')
    return None


res = none_func_2()
print(f'无返回值的函数返回结果是：{res}, 返回结果类型是：{type(res)}')
res2 = none_func_1()
print(f'无返回值的函数返回结果是：{res2}, 返回结果类型是：{type(res2)}')


"""
无返回值的函数1返回结果是：None, 返回结果类型是：<class 'NoneType'>
无返回值的函数2返回结果是：None, 返回结果类型是：<class 'NoneType'>
"""

四、None 使用场景

None：在函数内，无论有没有写 return 语句，默认都是有 return 语句的，只是 return None

# 1. 声明变量的初始值为 None
name = None


# 2. None 用于条件表达式
def check_age(age):
    if age >= 18:
        return 'SUCCESS'
    else:
        # 3. 函数的返回值
        return None
    
    
result = check_age(16)
# 表示 None 的时候进入，False 
if not result:
    print('未成年，无法入内 ...')

五、函数的注释

def add(x, y):
    """
    两数之和
    :param x: x
    :param y: y
    :return: x + y
    """
    z = x + y
    print(f' {x} + {y} = {z}')

六、函数的嵌套

def func_1():
    print(1)


def func_2():
    print(2)


def func_3():
    print(3)


def func():
    func_1()
    func_2()
    func_3()
    

func()

"""
1
2
3
"""

七、局部变量

局部变量：函数内的变量，作用在函数内，函数调用结束后局部变量失效

def test_num():
    num = 100
    # 正常输出
    print(f'函数内部 num={num}')


test_num()
# NameError: name 'num' is not defined. Did you mean: 'sum'?
print(f'函数外部 num={num}')

八、全局变量

全局变量：函数内和函数外都能使用该变量

# 定义全局变量 num
num = 100

# 函数内使用 num 变量
def test_num():
    print(f'函数内部 num={num}')

# 执行 test_num 函数
test_num()
# 函数外部访问 num
print(f'函数外部 num={num}')

九、global 关键字

global 关键字作用：在函数体内修改全局变量，会导致该全局变量在外部无法文档修改后的内容，效果如下：

count = 200


def read_count():
    print(f'read_count 函数内 count = {count}')


def modify_count():
    count = 3000
    print(f'modify_count 函数内 count = {count}')

# 1. 读取函数，count = 200
read_count()
# 2. 修改，count = 3000
modify_count()
# 3. count = 200 第二步种修改的无法作用到函数外
print(f'函数外 count = {count}')

"""
read_count 函数内 count = 200
modify_count 函数内 count = 3000
函数外 count = 200
"""

在 modify_count 函数内，加上 global 关键字后
global 语法：global 被指定的全局变量名

count = 200


def read_count():
    print(f'read_count 函数内 count = {count}')


def modify_count():
    # 如下：将 count 本次的修改指向全局
    global count
    count = 3000
    print(f'modify_count 函数内 count = {count}')


read_count()
modify_count()
print(f'函数外 count = {count}')

"""
read_count 函数内 count = 200
modify_count 函数内 count = 3000
函数外 count = 3000
"""

十、函数综合案例

"""
综合案例：ATM 机

主菜单
----------主菜单-----------
张三，您好，欢迎进入 ATM 系统，请选择：
查询余额    [输入1]
取款       [输入2]
取款       [输入3]
退出       [输入4]
请输入您的选择：

查询余额

----------查询余额-----------
张三，您好，您的余额剩余：100元

----------存款-----------
张三，您好，您存款 200元
张三，您好，您的余额剩余：300元

----------取款-----------
张三，您好，您取款 200元
张三，您好，您的余额剩余：100元
"""

money = 0


def read_in(str_):
    return int(input(str_))


def main_menu():
    menu = """
    ----------主菜单-----------
    张三，您好，欢迎进入 ATM 系统，请选择：
    查询余额    [输入1]
    存款       [输入2]
    取款       [输入3]
    退出       [输入4]
    """
    print(menu)


def query_money():
    menu = f"""
    ----------查询余额-----------
    张三，您好，您的余额剩余：{money}元
    """
    print(menu)


def save_money(m: float):
    global money
    money += m
    menu = f"""
    ----------存款-----------
    张三，您好，您存款 {m}元
    张三，您好，您的余额剩余：{money}元
    """
    print(menu)


def draw_money(m: float):
    global money
    money -= m
    menu = f"""
    ----------取款-----------
    张三，您好，您取款 {m}元
    张三，您好，您的余额剩余：{money}元
    """
    print(menu)


def main_func():
    while True:
        main_menu()
        op = read_in('请输入您的选择: ')
        if op == 1:
            query_money()
        elif op == 2:
            m = read_in('请输入您的存款金额: ')
            save_money(m)
        elif op == 3:
            m = read_in('请输入您的取款金额: ')
            draw_money(m)
        elif op == 4:
            break
    print('已退出ATM系统...')


if __name__ == '__main__':
    main_func()

十一、函数多返回值

def multi_result():
    return 1, 2


x, y = multi_result()
print(f'x={x}, y={y}')


def multi_result_2():
    return 1, '哈哈哈', [1, 2, 3], True


a, b, c, d = multi_result_2()
print(f'a={a}, b={b}, c={c}, d={d}')

"""
x=1, y=2
a=1, b=哈哈哈, c=[1, 2, 3], d=True
"""

十二、参数传递

函数 ‘建=值’ 传参

# 不能省略的参数
def params(name, age, worker):
    print(f'params函数内：name={name}, age={age}, worker={worker}')


# 缺省参数：设置缺省参数必要让被指定的参数在形参列表中最后面，否则会报错，如下
# def params_2(name='王五', age, worker):
def params_2(name, age, worker='码农'):
    print(f'params_2函数内：name={name}, age={age}, worker={worker}')


# 调用方式1，顺序传参
params('张三', 20, '码农')
# 方式2：k=v传参，无序顺序指定
params(age=25, worker='码农', name='张三')
# 缺省参数
params_2(age=30, name='李四')

不定长参数

不定长参数:
位置不定长：*args 元组
参数不定长：**kwargs k=v

# 位置不定长
def args_func(*args):
    print(f'位置不定长:{args}, 类型是：{type(args)}')


# 参数不定长
def kwargs_func(**kwargs):
    print(f'参数不定长:{kwargs}, 类型是：{type(kwargs)}')


args_func('张三', 18.0, '码农', ['alibaba', 'bytedance'])
kwargs_func(name='张三', age=18.0, worker='码农', company=['alibaba', 'bytedance'])

"""
位置不定长:('张三', 18.0, '码农', ['alibaba', 'bytedance']), 类型是：<class 'tuple'>
参数不定长:{'name': '张三', 'age': 18.0, 'worker': '码农', 'company': ['alibaba', 'bytedance']}, 类型是：<class 'dict'>
"""

函数作为参数传递

"""
函数作为参数进行传递
"""


def calc(x, y):
    return x + y


def test_calc(calc_func):
    print(f'calc的类型是：{type(calc_func)}')
    return calc_func(2, 1)


res = test_calc(calc)
print(f'计算结果：{res}')

lambda 匿名函数

lambda 函数
语法：lambda 传入参数：函数体(一行代码)
lambda 函数体只能写一行，且不可重复调用

def test_lambda(add_func):
    print(f'add_func 的类型是：{type(add_func)}')
    return add_func(2, 1)


# 调用匿名函数
result = test_lambda(lambda x, y: x + y)
print(f'匿名函数返回结果：{result}')


# 定义多参数的匿名函数
def test_lambda_2(add_func):
    print(f'add_func 的类型是：{type(add_func)}')
    return add_func(2, 1, 3, 4)


# 调用匿名函数
result = test_lambda_2(lambda x, y, z, a: x + y + z + a)
print(f'匿名函数返回结果：{result}')
result_2 = test_lambda_2(lambda x, y, z, a: x + y + z - a)
print(f'匿名函数返回结果：{result_2}')

"""
calc的类型是：<class 'function'>
计算结果：3
add_func 的类型是：<class 'function'>
匿名函数返回结果：3
add_func 的类型是：<class 'function'>
匿名函数返回结果：10
add_func 的类型是：<class 'function'>
匿名函数返回结果：2
"""

十三、类型注释

13.1 基础类型的类型注解

帮助第三方 IDE 工具对代码进行类型推断，协助做代码提示
帮助开发者自身对变量进行类型注释
不会对程序有任何影响，只是作为提示，仅此而已

方式1：指定变量类型            语法：变量名：类型 = 值

方式2：使用注释指定类型     语法：i = 10 # type: int

"""
方式1：变量名：类型 = 值
"""

# 容器的类型注解
my_list: list[int] = [1, 2, 3, 4]
my_tuple: tuple[str, int, bool] = ('a', 1, True)
my_set: set[int] = {1, 2, 3, 4}
my_dict: dict[str, int] = {'a': 1, 'b': 2}
my_str: str = '123456'

# 基础类型的注解
va_1: int = 10
va_2: str = '123456'
va_3: bool = True
va_4: float = 2.3


# 类的注解
class Path:
    pass


pa: Path = Path()

"""
方式2：i = 10 # type: int
"""

m = random.randint(1, 100)  		# type: int
j = json.loads('{"name":"张三"}')  	# type: dict[str, str]


def func():
    return 1


f = func() 									 # type: int

13.2 函数的类型注解

# data: dict[str, int]  表示输入的类型是 dict[str, int]
#  idx: int  表示输入的类型是 int
# -> list[str]  表示返回值的类型是 list[str]
def func(data: dict[str, int], idx: int) -> list[str]:
    print(f'dict:{data}, idx:{idx}')
    return list(data.keys())

13.3 Union 类型注解

首先看一个例子：

my_list = [1, 2, 3, 4, '北京', 'GPT4', True]
以上的 my_list 是一个复合类型的容器，想要表述这种类型就需要用到 Union 类型的注解

from typing import Union

# 在变量中展示
# 在变量中展示
my_list: list[Union[str, int, bool]] = [1, 2, 3, 4, '北京', 'GPT4', True]

my_dict: dict[str, Union[str, int, bool]] = {
    'name': '张三',
    'age': 20,
    'good_student': True
}
    
   
# 在函数中展示
def func(data: Union[str, int]) -> Union[str, int]:
    return data


print(f'func(1) 返回值类型是：{type(func(1))}') # func(1) 返回值类型是：<class 'int'>
print(f'func("哈") 返回值类型是：{type("哈")}') # func("哈") 返回值类型是：<class 'str'>