数据类呢？此外，它允许您应用类型限制（也称为“类型提示”）。

from dataclasses import dataclass

@dataclass
class Holder:
    obj: your_type # Need any type? Use "obj: object" then.

def foo(ref: Holder):
    ref.obj = do_something()

我同意人们的看法，在大多数情况下，你最好考虑不要使用它。

然而，当我们谈论上下文时，我们有必要知道这一点。

不过，您可以设计显式上下文类。在进行原型设计时，我更喜欢数据类，因为来回序列化它们很容易。

干杯

简单答案：

在类似于python的c++中，当您创建一个对象实例并将其作为参数传递时，不会复制实例本身，因此您可以从函数的外部和内部引用相同的实例，并且可以修改相同对象实例的组件基准，因此外部可以看到更改。

对于基本类型，python和c++的行为也相同，因为现在创建了实例的副本，所以外部看到/修改的实例与函数内部不同。因此，外部看不到内部的变化。

下面是python和c++之间的真正区别：

c++具有地址指针的概念，而c++允许您传递指针，这绕过了对基本类型的复制，因此函数内部可以影响与外部相同的实例，因此外部也可以看到更改。这在python中没有等价的，因此如果没有变通方法（例如创建包装器类型）是不可能的。

这样的指针在python中很有用，但不像在c++中那样有必要，因为在c++中，您只能返回一个实体，而在python中，您可以返回用逗号分隔的多个值（即元组）。因此，在python中，如果您有变量a、b和c，并希望函数持久地修改它们（相对于外部），您可以这样做：

a=4
b=3
c=8

a,b,c=somefunc(a,b,c)
# a,b,c now have different values here

这样的语法在c++中是不容易实现的，因此在c++中您可以这样做：

int a=4
int b=3
int c=8
somefunc(&a,&b,&c)
// a,b,c now have different values here

（编辑-布莱尔更新了他广受欢迎的答案，使其准确无误）

我认为重要的是要注意到，目前获得最多选票的帖子（布莱尔•康拉德），虽然其结果正确，但却具有误导性，并且根据其定义，几乎不正确。虽然有许多语言（如C）允许用户通过引用传递或通过值传递，但Python不是其中之一。

大卫·库尔纳波的回答指向了真正的答案，并解释了为什么布莱尔·康拉德帖子中的行为似乎是正确的，而定义却不正确。

在Python是按值传递的情况下，所有语言都按值传递，因为必须发送一些数据（无论是“值”还是“引用”）。然而，这并不意味着Python是按C程序员会想到的值传递的。

如果你想要这种行为，Blair Conrad的回答很好。但如果你想知道Python既不是通过值传递，也不是通过引用传递的根本原因，请阅读大卫·库尔纳波的答案。

可以用[]传递

dta=“15252”正文=[dta]

问题来自对Python中变量的误解。如果你习惯了大多数传统语言，你会有一个心理模型来描述以下顺序：

a = 1
a = 2

您认为a是存储值1的内存位置，然后更新为存储值2。这不是Python中的工作方式。相反，a开始作为对值为1的对象的引用，然后重新分配为对值为2的对象的参考。这两个对象可能会继续共存，即使a不再指代第一个对象；事实上，它们可以由程序内的任何数量的其他引用共享。

使用参数调用函数时，将创建一个引用传入对象的新引用。这与函数调用中使用的引用不同，因此无法更新该引用并使其引用新对象。在您的示例中：

def __init__(self):
    self.variable = 'Original'
    self.Change(self.variable)

def Change(self, var):
    var = 'Changed'

self.variable是对字符串对象“Original”的引用。当调用Change时，将创建对象的第二个引用变量。在函数内部，您将引用变量重新分配给不同的字符串对象“Changed”，但引用self.variable是独立的，不会更改。

解决此问题的唯一方法是传递一个可变对象。因为两个引用都引用同一个对象，所以对对象的任何更改都会反映在两个位置。

def __init__(self):         
    self.variable = ['Original']
    self.Change(self.variable)

def Change(self, var):
    var[0] = 'Changed'

大多数时候，要通过引用传递的变量是类成员。我建议的解决方案是使用修饰符来添加可变字段和相应的属性。该字段是变量的类包装器。

@refproperty同时添加self_myvar（可变）和self.myvar属性。

@refproperty('myvar')
class T():
    pass

def f(x):
   x.value=6

y=T()
y.myvar=3
f(y._myvar)
print(y.myvar) 

它将打印6。

将其与以下内容进行比较：

class X:
   pass

x=X()
x.myvar=4

def f(y):
    y=6

f(x.myvar)
print(x.myvar) 

在这种情况下，它不起作用。它将打印4。

代码如下：

def refproperty(var,value=None):
    def getp(self):
        return getattr(self,'_'+var).get(self)

    def setp(self,v):
        return getattr(self,'_'+var).set(self,v)

    def decorator(klass):
        orginit=klass.__init__
        setattr(klass,var,property(getp,setp))

        def newinit(self,*args,**kw):
            rv=RefVar(value)
            setattr(self,'_'+var,rv)
            orginit(self,*args,**kw)

        klass.__init__=newinit
        return klass
    return decorator

class RefVar(object):
    def __init__(self, value=None):
        self.value = value
    def get(self,*args):
        return self.value
    def set(self,main, value):
        self.value = value