参数是通过引用传递还是通过值传递？如何通过引用传递，以便下面的代码输出“Changed”而不是“Original”？
class PassByReference:
def __init__(self):
self.variable = 'Original'
self.change(self.variable)
print(self.variable)
def change(self, var):
var = 'Changed'
另请参阅：为什么函数可以修改调用者感知的某些参数，而不能修改其他参数？
当前回答
def i_my_wstring_length(wstring_input:str = "", i_length:int = 0) -> int:
i_length[0] = len(wstring_input)
return 0
wstring_test = "Test message with 32 characters."
i_length_test = [0]
i_my_wstring_length(wstring_test, i_length_test)
print("The string:\n\"{}\"\ncontains {} character(s).".format(wstring_test, *i_length_test))
input("\nPress ENTER key to continue . . . ")
其他回答
大多数时候，要通过引用传递的变量是类成员。我建议的解决方案是使用修饰符来添加可变字段和相应的属性。该字段是变量的类包装器。
@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
如果没有Python中的此功能，这可能是一个优雅的面向对象解决方案。一个更优雅的解决方案是让您从中创建子类。或者你可以把它命名为“大师班”。但是不要有一个变量和一个布尔值，让它们成为某种类型的集合。我修改了实例变量的命名，以符合PEP8。
class PassByReference:
def __init__(self, variable, pass_by_reference=True):
self._variable_original = 'Original'
self._variable = variable
self._pass_by_reference = pass_by_reference # False => pass_by_value
self.change(self.variable)
print(self)
def __str__(self):
print(self.get_variable())
def get_variable(self):
if pass_by_reference == True:
return self._variable
else:
return self._variable_original
def set_variable(self, something):
self._variable = something
def change(self, var):
self.set_variable(var)
def caller_method():
pbr = PassByReference(variable='Changed') # this will print 'Changed'
variable = pbr.get_variable() # this will assign value 'Changed'
pbr2 = PassByReference(variable='Changed', pass_by_reference=False) # this will print 'Original'
variable2 = pbr2.get_variable() # this will assign value 'Original'
您只能使用空类作为实例来存储引用对象，因为内部对象属性存储在实例字典中。请参见示例。
class RefsObj(object):
"A class which helps to create references to variables."
pass
...
# an example of usage
def change_ref_var(ref_obj):
ref_obj.val = 24
ref_obj = RefsObj()
ref_obj.val = 1
print(ref_obj.val) # or print ref_obj.val for python2
change_ref_var(ref_obj)
print(ref_obj.val)
我通常使用的一个简单技巧是将其包装在列表中：
def Change(self, var):
var[0] = 'Changed'
variable = ['Original']
self.Change(variable)
print variable[0]
（是的，我知道这可能很不方便，但有时这样做很简单。）
数据类呢？此外，它允许您应用类型限制（也称为“类型提示”）。
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()
我同意人们的看法，在大多数情况下，你最好考虑不要使用它。
然而，当我们谈论上下文时，我们有必要知道这一点。
不过，您可以设计显式上下文类。在进行原型设计时，我更喜欢数据类，因为来回序列化它们很容易。
干杯
