Python 中的引用传递：背景和最佳实践

目录

在熟悉 Python 之后，您可能会注意到函数不会像预期的那样修改参数的情况，尤其是在您熟悉其他编程语言的情况下。某些语言将函数参数作为对现有变量的引用来处理，这称为通过引用传递。其他语言将它们作为独立值处理，这种方法称为按值传递。

如果您是一名中级 Python 程序员，希望了解 Python 处理函数参数的特殊方式，那么本教程适合您。您将在 Python 中实现按引用传递构造的实际用例，并学习几个最佳实践以避免函数参数中的陷阱。

在本教程中，您将学习：

• 通过引用传递意味着什么以及为什么要这样做
• 按引用传递与按值传递和Python 的独特方法有何不同
• 如何函数参数的行为在Python
• 如何使用某些可变类型在 Python 中按引用传递
• 在 Python 中复制引用传递的最佳实践是什么

定义按引用传递

在深入研究按引用传递的技术细节之前，通过将其分解为多个组件来仔细研究该术语本身会很有帮助：

• Pass表示为函数提供参数。
• 引用意味着您传递给函数的参数是对内存中已存在的变量的引用，而不是该变量的独立副本。

由于您为函数提供了对现有变量的引用，因此对该引用执行的所有操作都将直接影响它所引用的变量。让我们看一些在实践中如何工作的例子。

下面，您将看到如何在 C# 中通过引用传递变量。请注意在突出显示的行中使用ref关键字：

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by reference.
        // The value of arg in Main is changed.
        arg = 4;
        squareRef(ref arg);
        Console.WriteLine(arg);
        // Output: 16
    }

    static void squareRef(ref int refParameter)
    {
        refParameter *= refParameter;
    }
}

可以看到，refParameterofsquareRef()必须用ref关键字声明，调用函数时也必须使用关键字。然后参数将通过引用传入并且可以就地修改。

Python 没有ref关键字或与之等效的任何东西。如果您尝试在 Python 中尽可能接近地复制上述示例，那么您将看到不同的结果：

>>> def main():
...     arg = 4
...     square(arg)
...     print(arg)
...
>>> def square(n):
...     n *= n
...
>>> main()
4

在这种情况下，arg变量不会就地更改。Python 似乎将您提供的参数视为独立值，而不是对现有变量的引用。这是否意味着 Python 按值而不是按引用传递参数？

不完全的。Python 既不是通过引用也不是通过值传递参数，而是通过赋值。下面，在更仔细地研究 Python 的方法之前，您将快速探索按值传递和按引用传递的细节。之后，您将了解一些最佳实践，以在 Python 中实现等效于按引用传递的效果。

对比引用传递和值传递

当您通过引用传递函数参数时，这些参数只是对现有值的引用。相反，当您按值传递参数时，这些参数将成为原始值的独立副本。

让我们重温一下 C# 示例，这次不使用ref关键字。这将导致程序使用按值传递的默认行为：

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/passing-parameters
class Program
{
    static void Main(string[] args)
    {
        int arg;

        // Passing by value.
        // The value of arg in Main is not changed.
        arg = 4;
        squareVal(arg);
        Console.WriteLine(arg);
        // Output: 4
    }

    static void squareVal(int valParameter)
    {
        valParameter *= valParameter;
    }
}

在这里，您可以看到squareVal()没有修改原始变量。相反，valParameter是原始变量的独立副本arg。虽然这与您在 Python 中看到的行为相匹配，但请记住，Python 并不完全按值传递。让我们证明一下。

Python 的内置id()返回一个整数，表示所需对象的内存地址。使用id()，您可以验证以下断言：

1. 函数参数最初引用与其原始变量相同的地址。
2. 在函数内重新分配参数会为其提供一个新地址，而原始变量保持不变。

在下面的例子中，注意 的地址x最初与的地址匹配，n但在重新分配后发生变化，而 的地址n从不改变：

>>> def main():
...     n = 9001
...     print(f"Initial address of n: {id(n)}")
...     increment(n)
...     print(f"  Final address of n: {id(n)}")
...
>>> def increment(x):
...     print(f"Initial address of x: {id(x)}")
...     x += 1
...     print(f"  Final address of x: {id(x)}")
...
>>> main()
Initial address of n: 140562586057840
Initial address of x: 140562586057840
  Final address of x: 140562586057968
  Final address of n: 140562586057840

调用时n和的初始地址x相同的increment()事实证明该x参数不是按值传递的。否则，n并且x会有不同的内存地址。

在了解 Python 如何处理参数的细节之前，让我们先看一下按引用传递的一些实际用例。

使用传递引用结构

通过引用传递变量是您可以用来实现某些编程模式的几种策略之一。虽然很少需要，但通过引用传递可能是一个有用的工具。

在本节中，您将了解按引用传递是一种实用方法的三种最常见模式。然后，您将看到如何使用 Python 实现这些模式中的每一个。

using System;

class Program
{
    static void Main(string[] args)
    {
        int counter = 0;

        // Passing by reference.
        // The value of counter in Main is changed.
        Console.WriteLine(greet("Alice", ref counter));
        Console.WriteLine("Counter is {0}", counter);
        Console.WriteLine(greet("Bob", ref counter));
        Console.WriteLine("Counter is {0}", counter);
        // Output:
        // Hi, Alice!
        // Counter is 1
        // Hi, Bob!
        // Counter is 2
    }

    static string greet(string name, ref int counter)
    {
        string greeting = "Hi, " + name + "!";
        counter++;
        return greeting;
    }
}

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     counter += 1
...     return f"Hi, {name}!"
...
>>> main()
Hi, Alice!
Counter is 0
Hi, Bob!
Counter is 0

>>> def multiple_return():
...     return 1, 2
...
>>> t = multiple_return()
>>> t  # A tuple
(1, 2)

>>> # You can unpack the tuple into two variables:
>>> x, y = multiple_return()
>>> x
1
>>> y
2

>>> def main():
...     counter = 0
...     print(greet("Alice", counter))
...     print(f"Counter is {counter}")
...     print(greet("Bob", counter))
...     print(f"Counter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
('Hi, Alice!', 1)
Counter is 0
('Hi, Bob!', 1)
Counter is 0

>>> def main():
...     counter = 0
...     greeting, counter = greet("Alice", counter)
...     print(f"{greeting}\nCounter is {counter}")
...     greeting, counter = greet("Bob", counter)
...     print(f"{greeting}\nCounter is {counter}")
...
>>> def greet(name, counter):
...     return f"Hi, {name}!", counter + 1
...
>>> main()
Hi, Alice!
Counter is 1
Hi, Bob!
Counter is 2

创建条件多返回函数

这是返回多个值的特定用例，其中该函数可以在条件语句中使用，并且具有额外的副作用，例如修改作为参数传入的外部变量。

考虑C# 中的标准Int32.TryParse函数，它返回一个布尔值并同时操作对整数参数的引用：

public static bool TryParse (string s, out int result);

此函数尝试string使用out关键字将 a转换为 32 位有符号整数。有两种可能的结果：

1. 如果解析成功，则输出参数将设置为结果整数，函数将返回true。
2. 如果解析失败，则输出参数将设置为0，函数将返回false。

您可以在以下示例中在实践中看到这一点，该示例尝试转换许多不同的字符串：

using System;

// Source:
// https://docs.microsoft.com/en-us/dotnet/api/system.int32.tryparse?view=netcore-3.1#System_Int32_TryParse_System_String_System_Int32__
public class Example {
    public static void Main() {
        String[] values = { null, "160519", "9432.0", "16,667",
                            "   -322   ", "+4302", "(100);", "01FA" };
        foreach (var value in values) {
            int number;

            if (Int32.TryParse(value, out number)) {
                Console.WriteLine("Converted '{0}' to {1}.", value, number);
            }
            else {
                Console.WriteLine("Attempted conversion of '{0}' failed.",
                                   value ?? "<null>");
            }
        }
    }
}

上面的代码试图通过 将不同格式的字符串转换为整数TryParse()，输出如下：

Attempted conversion of '<null>' failed.
Converted '160519' to 160519.
Attempted conversion of '9432.0' failed.
Attempted conversion of '16,667' failed.
Converted '   -322   ' to -322.
Converted '+4302' to 4302.
Attempted conversion of '(100);' failed.
Attempted conversion of '01FA' failed.

要在 Python 中实现类似的功能，您可以使用之前看到的多个返回值：

def tryparse(string, base=10):
    try:
        return True, int(string, base=base)
    except ValueError:
        return False, None

这tryparse()将返回两个值。第一个值指示转换是否成功，第二个值保存结果（None如果失败，则为 ）。

但是，使用此函数有点笨拙，因为您需要在每次调用时解压缩返回值。这意味着您不能在if语句中使用该函数：

>>> success, result = tryparse("123")
>>> success
True
>>> result
123

>>> # We can make the check work
>>> # by accessing the first element of the returned tuple,
>>> # but there's no way to reassign the second element to `result`:
>>> if tryparse("456")[0]:
...     print(result)
...
123

尽管它通常通过返回多个值来工作，tryparse()但不能用于条件检查。这意味着您还有一些工作要做。

您可以利用 Python 的灵活性并简化函数以根据转换是否成功返回不同类型的单个值：

def tryparse(string, base=10):
    try:
        return int(string, base=base)
    except ValueError:
        return None

由于 Python 函数能够返回不同的数据类型，您现在可以在条件语句中使用此函数。但是如何？难道您不必先调用函数，分配其返回值，然后检查值本身吗？

通过利用 Python 在对象类型方面的灵活性，以及Python 3.8 中的新赋值表达式，您可以在条件if语句中调用这个简化的函数，并在检查通过时获取返回值：

>>> if (n := tryparse("123")) is not None:
...     print(n)
...
123
>>> if (n := tryparse("abc")) is None:
...     print(n)
...
None

>>> # You can even do arithmetic!
>>> 10 * tryparse("10")
100

>>> # All the functionality of int() is available:
>>> 10 * tryparse("0a", base=16)
100

>>> # You can also embed the check within the arithmetic expression!
>>> 10 * (n if (n := tryparse("123")) is not None else 1)
1230
>>> 10 * (n if (n := tryparse("abc")) is not None else 1)
10

哇！这个 Python 版本tryparse()比 C# 版本更强大，允许您在条件语句和算术表达式中使用它。

通过一点点独创性，您已经复制了一个特定且有用的传递引用模式，而实际上并没有通过引用传递参数。事实上，在使用赋值表达式 operator( ) 并直接在 Python 表达式中使用返回值时，您又一次赋值了返回值:=。

到目前为止，您已经了解了按引用传递的含义，它与按值传递有何不同，以及 Python 的方法与两者有何不同。现在您已准备好仔细研究 Python 如何处理函数参数！

在 Python 中传递参数

Python 通过赋值传递参数。也就是说，当你调用一个 Python 函数时，每个函数参数都变成了一个变量，传递的值会被赋值给这个变量。

因此，您可以通过了解赋值机制本身的工作原理，甚至在函数外部，了解有关 Python 如何处理函数参数的重要细节。

from sys import getrefcount

print("--- Before  assignment ---")
print(f"References to value_1: {getrefcount('value_1')}")
print(f"References to value_2: {getrefcount('value_2')}")
x = "value_1"
print("--- After   assignment ---")
print(f"References to value_1: {getrefcount('value_1')}")
print(f"References to value_2: {getrefcount('value_2')}")
x = "value_2"
print("--- After reassignment ---")
print(f"References to value_1: {getrefcount('value_1')}")
print(f"References to value_2: {getrefcount('value_2')}")

--- Before  assignment ---
References to value_1: 3
References to value_2: 3
--- After   assignment ---
References to value_1: 4
References to value_2: 3
--- After reassignment ---
References to value_1: 3
References to value_2: 4

>>> def show_locals():
...     my_local = True
...     print(locals())
...
>>> show_locals()
{'my_local': True}

>>> def show_locals(my_arg):
...     my_local = True
...     print(locals())
...
>>> show_locals("arg_value")
{'my_arg': 'arg_value', 'my_local': True}

>>> from sys import getrefcount

>>> def show_refcount(my_arg):
...     return getrefcount(my_arg)
...
>>> getrefcount("my_value")
3
>>> show_refcount("my_value")
5

使用 Python 复制引用传递

在上一节中检查了命名空间后，您可能会问为什么global没有提到作为一种修改变量的方法，就像它们通过引用传递一样：

>>> def square():
...     # Not recommended!
...     global n
...     n *= n
...
>>> n = 4
>>> square()
>>> n
16

使用该global语句通常会影响代码的清晰度。它可能会产生许多问题，包括：

• 自由变量，看似无关
• 所述变量没有显式参数的函数
• 不能与其他变量或参数一起使用的函数，因为它们依赖于单个全局变量
• 使用全局变量时缺乏线程安全性

将前面的示例与以下示例进行对比，该示例显式返回一个值：

>>> def square(n):
...     return n * n
...
>>> square(4)
16

好多了！您避免了全局变量的所有潜在问题，并且通过要求参数，您可以使您的函数更清晰。

尽管既不是按引用传递的语言也不是按值传递的语言，Python 在这方面没有任何缺点。它的灵活性足以应对挑战。

def square(n):
    # Accept an argument, return a value.
    return n * n

x = 4
...
# Later, reassign the return value:
x = square(x)

def greet(name, counter):
    # Return multiple values
    return f"Hi, {name}!", counter + 1

counter = 0
...
# Later, reassign each return value by unpacking.
greeting, counter = greet("Alice", counter)

最佳实践：使用对象属性

对象属性在 Python 的赋值策略中占有一席之地。Python 的赋值语句语言参考指出，如果目标是支持赋值的对象属性，则将要求该对象对该属性执行赋值。如果将对象作为参数传递给函数，则可以就地修改其属性。

编写接受具有属性的对象的函数，然后直接对这些属性进行操作，如下例所示：

>>> # For the purpose of this example, let's use SimpleNamespace.
>>> from types import SimpleNamespace

>>> # SimpleNamespace allows us to set arbitrary attributes.
>>> # It is an explicit, handy replacement for "class X: pass".
>>> ns = SimpleNamespace()

>>> # Define a function to operate on an object's attribute.
>>> def square(instance):
...     instance.n *= instance.n
...
>>> ns.n = 4
>>> square(ns)
>>> ns.n
16

注意square()需要写成直接对一个属性进行操作，修改后不需要重新赋值返回值。

值得重申的是，您应该确保该属性支持赋值！这是与 相同的示例namedtuple，其属性是只读的：

>>> from collections import namedtuple
>>> NS = namedtuple("NS", "n")
>>> def square(instance):
...     instance.n *= instance.n
...
>>> ns = NS(4)
>>> ns.n
4
>>> square(ns)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in square
AttributeError: can't set attribute

尝试修改不允许修改的属性会导致AttributeError.

此外，您应该注意类属性。它们将保持不变，并且将创建和修改实例属性：

>>> class NS:
...     n = 4
...
>>> ns = NS()
>>> def square(instance):
...     instance.n *= instance.n
...
>>> ns.n
4
>>> square(ns)
>>> # Instance attribute is modified.
>>> ns.n
16
>>> # Class attribute remains unchanged.
>>> NS.n
4

由于类属性在通过类实例修改时保持不变，因此您需要记住引用实例属性。

最佳实践：使用字典和列表

Python中的字典是与所有其他内置类型不同的对象类型。它们被称为映射类型。Python 的映射类型文档提供了对该术语的一些了解：

甲映射对象映射可哈希值到任意对象。映射是可变对象。目前只有一种标准映射类型，即字典。（来源）

本教程不涉及如何实现自定义映射类型，但您可以使用简陋的字典复制通过引用传递。这是一个使用直接对字典元素进行操作的函数的示例：

>>> # Dictionaries are mapping types.
>>> mt = {"n": 4}
>>> # Define a function to operate on a key:
>>> def square(num_dict):
...     num_dict["n"] *= num_dict["n"]
...
>>> square(mt)
>>> mt
{'n': 16}

由于您将值重新分配给字典键，因此对字典元素进行操作仍然是一种赋值形式。使用字典，您可以获得通过相同字典对象访问修改后的值的额外实用性。

虽然列表不是映射类型，但由于两个重要特征：下标性和可变性，您可以以类似于字典的方式使用它们。这些特性值得多解释一下，但让我们先来看看使用 Python 列表模拟按引用传递的最佳实践。

要使用列表复制引用传递，请编写一个直接对列表元素进行操作的函数：

>>> # Lists are both subscriptable and mutable.
>>> sm = [4]
>>> # Define a function to operate on an index:
>>> def square(num_list):
...     num_list[0] *= num_list[0]
...
>>> square(sm)
>>> sm
[16]

由于您将值重新分配给列表中的元素，因此对列表元素进行操作仍然是一种赋值形式。与字典类似，列表允许您通过相同的列表对象访问修改后的值。

现在让我们探索可订阅性。当可以通过索引位置访问其结构的子集时，对象是可下标的：

>>> subscriptable = [0, 1, 2]  # A list
>>> subscriptable[0]
0
>>> subscriptable = (0, 1, 2)  # A tuple
>>> subscriptable[0]
0
>>> subscriptable = "012"  # A string
>>> subscriptable[0]
'0'
>>> not_subscriptable = {0, 1, 2}  # A set
>>> not_subscriptable[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object is not subscriptable

列表、元组和字符串是可下标的，但集合不是。尝试访问不可下标的对象元素将引发TypeError.

可变性是一个更广泛的主题，需要额外的探索和文档参考。简而言之，如果一个对象的结构可以就地更改而不是需要重新分配，则该对象是可变的：

>>> mutable = [0, 1, 2]  # A list
>>> mutable[0] = "x"
>>> mutable
['x', 1, 2]

>>> not_mutable = (0, 1, 2)  # A tuple
>>> not_mutable[0] = "x"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

>>> not_mutable = "012"  # A string
>>> not_mutable[0] = "x"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

>>> mutable = {0, 1, 2}  # A set
>>> mutable.remove(0)
>>> mutable.add("x")
>>> mutable
{1, 2, 'x'}

列表和集合是可变的，字典和其他映射类型也是如此。字符串和元组是不可变的。尝试修改不可变对象的元素将引发TypeError.

结论

Python 与支持按引用或按值传递参数的语言不同。函数参数成为分配给传递给函数的每个值的局部变量。但这并不妨碍您获得在其他语言中通过引用传递参数时所期望的相同结果。

在本教程中，您学习了：

• Python 如何处理给变量赋值
• Python中如何通过赋值传递函数参数
• 为什么返回值是复制通过引用传递的最佳实践
• 如何使用属性、字典和列表作为替代最佳实践

您还学习了一些在 Python 中复制传递引用结构的其他最佳实践。您可以使用这些知识来实现​​传统上需要支持按引用传递的模式。

为了继续您的 Python 之旅，我鼓励您深入研究您在这里遇到的一些相关主题，例如可变性、赋值表达式以及Python 命名空间和作用域。

保持好奇，我们下期再见！