03 函数定义和调用

函数定义和调用

• [1. 函数定义](#1. 函数定义)
• • [1.1 无返回值](#1.1 无返回值)
  • [1.2 单一返回值](#1.2 单一返回值)
  • [1.3 多个返回值](#1.3 多个返回值)
  • [1.4 嵌套调用](#1.4 嵌套调用)
• [2. 函数进阶](#2. 函数进阶)
• • [2.1 函数 - 变量的作用域](#2.1 函数 - 变量的作用域)
  • [2.2 函数 - 传参方式](#2.2 函数 - 传参方式)
  • [2.3 函数 - 默认参数](#2.3 函数 - 默认参数)
  • [2.4 函数 - 位置不定长参数( *args 元组)](#2.4 函数 - 位置不定长参数( *args 元组))
  • [2.5 函数 - 关键字位定长 参数(**args 字典)](#2.5 函数 - 关键字位定长 参数(**args 字典))
• 3.匿名函数
• • [3.1 定义匿名函数lambda](#3.1 定义匿名函数lambda)
  • [3.2 匿名函数使用](#3.2 匿名函数使用)
• [4. 类型注解](#4. 类型注解)
• • [4.1 字面量的类型注解](#4.1 字面量的类型注解)
  • [4.2 函数的类型注解](#4.2 函数的类型注解)
• 5.类型推断

1. 函数定义

注意: 函数定义的时候并不会执行, 只有在调用函数的时候, 函数体的逻辑才会执行 ; 函数必须先定义, 后调用;

1.1 无返回值

# 函数定义
def out_line():
    print("------------------------------------------------")
    print("------------------------------------------------")

# 函数调用
out_line()

1.2 单一返回值

# 函数的参数与返回值
# 函数1: 计算圆的面积 -- 半径
def circle_area(r):
    area = 3.14 * r ** 2
    return area

area = circle_area(10)
print(area)

> 314.0

1.3 多个返回值

# 函数3: 计算圆的面积, 周长 -- 半径 ----> 如果返回值有多个, 多个返回值之间逗号分隔 ---> 多个返回值会封装到元组之中
def circle_area_len(r):
    """
    根据圆的半径, 计算圆的面积和周长
    :param r: 半径
    :return: 圆的面积, 圆的周长
    """
    return round(3.14 * r * r, 1), round(2 * 3.14 * r, 1)
#
al = circle_area_len(10)
print(al)
print(type(al))

> (314.0, 62.8)
  <class 'tuple'>

1.4 嵌套调用

# 函数的嵌套调用
def function_a():
    print("a ... before")
    function_b()
    print("a ... after")

def function_b():
    print("b ... before")
    function_c()
    print("b ... after")

def function_c():
    print("c ...")

function_a()

print("函数调用完毕 ~")


> a ... before
b ... before
c ...
b ... after
a ... after
函数调用完毕 ~

2. 函数进阶

2.1 函数 - 变量的作用域

# 全局变量 : 在函数外部 或 函数的内部都是可以访问的 ;
num = 100

# 定义函数
def circle_area(r):
    # 布局变量: 只能在函数内部使用
    pi = 3.14
    area = pi * r * r
    print("num = ", num) # 10000

    return area

# 调用函数
c_area = circle_area(10)
print(c_area)

print("num = ", num) # 10000

2.2 函数 - 传参方式

# 定义函数
def reg_stu(name, age, gender, city):
    print(f"注册成功, 姓名: {name}, 年龄: {age}, 性别: {gender}, 城市: {city}")
    return {"name": name, "age": age, "gender": gender, "city": city}

# 传参方式一: 位置参数
stu = reg_stu("张三", 18, "男", "北京")
print(stu)

# 传参方式二: 关键字参数
stu = reg_stu(name="王林", age=28, gender="男", city="北京")
print(stu)

stu = reg_stu(age=20, gender="女", city="北京", name="李慕婉")
print(stu)

# 传参方式三: 位置参数 + 关键字参数 ---> 位置参数在前, 关键字参数在后
stu = reg_stu("李慕婉", 20, gender="女", city="北京")
print(stu)

2.3 函数 - 默认参数

# 定义函数
def reg_stu(name, age, gender="男", city="北京"):
    print(f"注册成功, 姓名: {name}, 年龄: {age}, 性别: {gender}, 城市: {city}")
    return {"name": name, "age": age, "gender": gender, "city": city}

# 调用函数
stu = reg_stu("王林", 20)
print(stu)

stu = reg_stu("李慕婉", 18, "女")
print(stu)

stu = reg_stu("韩立", 22, city="上海")
print(stu)

2.4 函数 - 位置不定长参数( *args 元组)

实际数据参数:

# 需求: 根据传入的这批数据, 计算这批数据的最小值, 最大值, 平均值
def calc_data(*args):
    min_data = min(args)
    max_data = max(args)
    avg_data = sum(args) / len(args)
    return min_data, max_data, round(avg_data, 1)

# 调用函数
print(calc_data(2, 7, 9, 10, 45))

print(calc_data(2, 7, 9, 10, 45, 73, 37, 93, 92, 111, 222))

2.5 函数 - 关键字位定长 参数(**args 字典)

关键字参数:

# 需求: 根据传入的这批数据, 计算这批数据的最小值, 最大值, 平均值
def calc_data(*args, **kwargs):
    """
    根据传入的这批数据, 计算这批数据的最小值, 最大值, 平均值
    :param args: 不定长位置参数, 需要计算的这批数据
    :param kwargs: 不定长关键字参数
         round: 保留的小数位个数
         print: 是否打印输出
    :return: 最小值, 最大值, 平均值
    """
    min_data = min(args)
    max_data = max(args)
    avg_data = sum(args) / len(args)

    if kwargs.get("round") is not None:
        avg_data = round(avg_data, kwargs.get("round"))

    if kwargs.get("print"):
        print(f"计算出来的最小值: {min_data}, 最大值: {max_data}, 平均值:{avg_data}")

    return min_data, max_data, avg_data

# 调用函数
# print(calc_data(2, 7, 9, 10, 45, round=3, print=True))

print(calc_data(2, 7, 9, 10, 45, 73, 37, 93, 92, 111, 222, round=4, print=False))

3.匿名函数

3.1 定义匿名函数lambda

lambma 参数列表 : 函数体

只能是单行表达式

# 不能换行
out_line = lambda : print("--------------------------------------")
out_line()

# 计算两个参数的和
add = lambda x, y : x + y
print(add(100,200))

3.2 匿名函数使用

#函数作为sort排序方法入参,其按照长度排序
data_list.sort(key=lambda item : len(item)) 

4. 类型注解

4.1 字面量的类型注解

类型注解只是起到语法提示作用,并不会影响程序的运行结果

关键字: 类型 = 值

# 变量定义 - 指定类型注解
a2: int = 596
score2: float = 98.5
hobby2: str = "Python"
flag2: bool = True
pic2: None = None


# 元素类型可以是str类型和int类型
names2: list[str | int] = ["A", "C", "E"]
# str类型集合
phones2: set[str] = {"13309091111", "15209101902", "18809019201"}
# str代表key的类型;int代表value类型
options2: dict[str, int] = {"count":2 , "total":10}
# 定义元组中数据的类型
goods2: tuple[str, int, int] = ("手机", 6999, 1)

4.2 函数的类型注解

# 其中r代表入参,float代表入参的类型, tuple[float, float]代表返回值类型
def circle_area_len(r: float) -> tuple[float, float]:
    return round(3.14 * r * r, 1), round(2 * 3.14 * r, 1)

5.类型推断

变量赋值后,解释器会自动判断类型,这时候就不用赋值

hobby = "Python"
flag = True