return 语句是函数和方法的关键组成部分。可以使函数将 Python对象发送回调用者代码，这些对象被称为函数的返回值。

使用它们在程序中执行进一步的计算或者程序的执行。

整套学习自学教程中应用的数据都是《三國志》、《真·三國無雙》系列游戏中的内容。

Python 函数入门

官方文档定义的函数是将不同类型的代码块返回给调用者的。一系列向调用者返回一些值的语句。它也可以传递零个或多个参数，这些参数可用于执行主体。

函数固定的规则。

def function_name(arg1, arg2,, argN):
    # 函数方法执行代码
    pass

调用函数的固定格式。

function_name(arg1, arg2, , argN)

以上在之前的章节 Python基础必掌握的定义Python函数方法详解 中有明确的讲解。

让函数返回一个值需要使用 return 语句。

return 语句

return 语句由 return 关键字和一个可选的返回值组成。返回值可以是：

• 数值（ int、、float和complex值 ）

• 对象的集合和序列（list、tuple、dictionary）

• set定义（对象、类、函数）

• 模块或包
  
  返回值都是 None 的两种情况：

• 省略函数的返回值并使用return没有返回值的裸函数。

• 省略整个 return 语句。

显式返回语句，即立即终止函数执行并将返回值发送回调用者代码，return 后跟可选的返回值。

# 显式返回语句
def return_1():
    return 1 
return_1() 
1

# 可以在任何表达式中使用该返回值
return_42() * 2
2

隐式返回语句，没有使用显式使用返回值则返回一个固定默认为 None 的值。

# 隐式返回语句
def add_one(x):
    result = x + 1

value = add_one(5)
value

print(value)
None

return 与 print 的差异

# print
def print_():
    print("真·三國無雙")

print_()
真·三國無雙

# return
def return_():
    return "真·三國無雙"

return_()
'真·三國無雙'

def add(a, b):
    result = a + b
    return result
add(1, 1)
2

返回多个值

使用 return 语句从函数返回多个值的时候需要用逗号（ ，）分隔的返回值。

使用统计模块进行计算返回多个值。

import statistics as st

def describe(sample):
    return st.mean(sample), st.median(sample), st.mode(sample)

sample = [10, 2, 4, 7, 9, 3, 9, 8, 6, 7]
mean, median, mode = describe(sample)

mean
6.5

median
7.0

mode
7

desc = describe(sample)
desc
(6.5, 7.0, 7)

type(desc)
<class 'tuple'>

return 语句应用

None显式三种处理返回方法

省略该return语句并依赖于返回的默认行为None。

def _return():
    # 代码逻辑
    pass
print(_return())
None

使用return不带返回值的也返回None。

def _return():
    # 代码逻辑
    return
print(bare_return())
None

明确返回None。

def _return():
    # 代码逻辑
    return None
print(_return())
None

记住返回值

# 某些计算场景需要初始值计算
def template_func(args):
    result = 0  # 初始化返回值
    # 你的业务逻辑
    return result  # 显式返回结果

避免复杂的表达式

# 尽量简化 return 返回的对象，是逻辑清晰
def variance(data, ddof=0):
    mean = sum(data) / len(data)
    return sum((x - mean) ** 2 for x in data) / (len(data) - ddof)

def variance(data, ddof=0):
    mean = sum(data) / len(data)
    v = sum((x - mean) ** 2 for x in data) / (len(data) - ddof)
    return v

def variance(data, ddof=0):
    n = len(data)
    mean = sum(data) / n
    total_square_dev = sum((x - mean) ** 2 for x in data)
    return total_square_dev / (n - ddof)

variance([3, 4, 7, 5, 6, 2, 9, 4, 1, 3])
5.24

返回值与修改全局变量

全局变量不建议修改，修正全局变量使用 global 方法。

counter = 0

def increment():
    global counter
    counter += 1

increment()
counter
1

如果修改外部的全局变量建议重新赋值。

counter = 0

def increment(var):
    return var + 1


increment(counter)
1

counter
0

# 显式地为 counter 分配一个新值
counter = increment(counter)
counter
1

return 条件触发

return 根据评估某些条件的结果执行不同的命令。

def my_abs(number):
    if number > 0:
        return number
    elif number < 0:
        return -number

my_abs(-15)
15

my_abs(15)
15

返回 True 或 False

与 if 语句组合的另一个常见用例 return 布尔值函数时，返回 True 或者 False。

def is_divisible(a, b):
    if not a % b:
        return True
    return False

is_divisible(4, 2)
True

is_divisible(7, 4)
False

谓词函数返回 True 或者 False。

# 方法1
def both_true(a, b):
    return a and b

both_true(1, 2)
2


# 方法2
def both_true(a, b):
    if a and b:
        return True
    return False
both_true(1, 2)
True


# 方法3
def both_true(a, b):
    return True if a and b else False
both_true(1, 2)
True
both_true(1, 0)
False


# 方法4
def both_true(a, b):
    return bool(a and b)
both_true(1, 2)
True
both_true(1, 0)
False

短路评估

中断循环执行并使函数立即返回。

def my_any(iterable):
    for item in iterable:
        if item:
            return True
    return False
    
my_any([0, 0, 1, 0, 0])
True
my_any([0, 0, 0, 0, 0])
False

识别死代码

终止而不执行任何后续代码。

def dead_code():
    return 42
    # 死代码，不会再执行
    print("Hello, World")


dead_code()
42

在 if 条件外就不会认为是死代码。

def no_dead_code(condition):
    if condition:
        return 42
    print("Hello, World")


no_dead_code(True)
42
no_dead_code(False)
Hello, World

返回多个命名对象

return 语句中返回多个值的函数时可以使用collections.namedtuple 对象增加的函数的可读性。

import statistics as st
from collections import namedtuple

def describe(sample):
    Desc = namedtuple("Desc", ["mean", "median", "mode"])
    return Desc(
        st.mean(sample),
        st.median(sample),
        st.mode(sample),
    )

sample = [10, 2, 4, 7, 9, 3, 9, 8, 6, 7]
stat_desc = describe(sample)

stat_desc
Desc(mean=5.7, median=6.0, mode=6)

# 通过属性名称获取平均值
stat_desc.mean
5.7

# 通过其索引获取中位数
stat_desc[1]
6.0

# 将值解压缩为三个变量
mean, median, mode = describe(sample)

mean
5.7
mode
6
median
6.0

返回函数：闭包

将函数作为参数、返回函数作为结果或两者兼有的函数是高阶函数。这种函数接受一些参数并返回一个内部函数，内部函数通常称为闭包。

# 一个简单的乘法函数
def by_factor(factor, number):
    return factor * number

factor 在应用程序很少更改，会发现在每个函数调用中提供相同的因素非常繁琐。因此需要一种方法来保留调用之间的状态或值，by_factor() 并仅在需要时更改它。要保留调用之间的当前值factor，可以使用闭包。

def by_factor(factor):
    def multiply(number):
        return factor * number
    return multiply

double = by_factor(2)
double(3)
6

triple = by_factor(3)
triple(3)
9

使用 lambda 函数来创建闭包。

# lambda函数的使用提供了一种快速简洁的编码方式
def by_factor(factor):
    return lambda number: factor * number

double = by_factor(2)
double(3)
6

装饰器获取和返回函数

装饰器函数将函数对象作为参数并返回一个函数对象。装饰器以某种方式处理被装饰的函数并将其返回或用另一个函数或可调用对象替换它。

# 计算python程序执行时间的装饰器
import time

def my_timer(func):
    def _timer(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"耗时: {end - start}")
        return result
    return _timer


@my_timer
def delayed_mean(sample): # 等价于表达式 my_timer(delayed_mean)
    time.sleep(1)
    return sum(sample) / len(sample)


delayed_mean([10, 2, 4, 7, 9, 3, 9, 8, 6, 7])
耗时: 1.0063526630401611
6.5

返回定义的对象

可以使用自己的自定义对象作为函数的返回值。

常见用例是定义了一个接口，用于动态创建对象以响应在编写程序时无法预测的条件。可以使用一个函数来实现用户定义对象，该函数接受一些初始化参数并根据具体输入返回不同的对象。

# 一个绘画程序
# 动态创建不同的形状
class Circle:
    def __init__(self, radius):
        self.radius = radius

class Square:
    def __init__(self, side):
        self.side = side

可以使用参数列表 ( *args) 和关键字参数 ( **kwargs ) 动态创建一个形状定义一个函数。

def shape_factory(shape_name, *args, **kwargs):
    shapes = {"circle": Circle, "square": Square}
    return shapes[shape_name](*args, **kwargs)

此函数创建具体形状的实例并将其返回给调用者。

circle = shape_factory("circle", radius=20)
type(circle)
<class '__main__.Circle'>
circle.radius
20

square = shape_factory("square", side=10)
type(square)
<class '__main__.Square'>
square.side
10

try…finally 在return中使用

finally 子句始终在 return 语句之前执行。

def func(value):
    try:
        return float(value)
    except ValueError:
        return str(value)
    finally:
        print("在 return 之前运行")


func(9)
在 return 之前运行
9.0

func("one")
在 return 之前运行
'one'

return 在生成器函数中使用

代码主体中带有 yield 语句的 Python 函数是生成器函数。当调用生成器函数时，会返回生成器迭代器。

# 一个生成器，1按需2生成，然后返回3 停止
def gen():
    yield 1
    yield 2
    return 3


g = gen()
g
<generator object gen at 0x7f4ff4853c10>

next(g)
1
next(g)
2

next(g) # 生成器耗尽，得到一个StopIteration
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    next(g)
StopIteration: 3