python之使用ctypes按值调用python进行ref调用

我正在尝试编写一个程序，向A级学生说明使用Python进行引用调用和按值调用之间的区别。通过将可变对象作为变量传递给函数，我获得了成功，但是发现我也可以使用ctypes库执行相同的操作。

我不太了解它是如何工作的，因为在ctype库中有一个byref()函数，但是在我的示例中它不起作用。但是，通过调用没有byref()的函数就可以了!

**我的工作代码

""" 
Program to illustrate call by ref 
""" 
 
 
from  ctypes import *  #alloews call by ref 
 
test = c_int(56)  #Pytthon call by reference eg addres 
t = 67            #Python call by value eg copy 
 
 
#expects a ctypes argument 
def byRefExample(x): 
    x.value= x.value + 2 
 
 
#expects a normal Python variable 
def byValueExample(x): 
    x = x + 2 
 
 
if __name__ == "__main__": 
 
    print "Before call test is",test 
    byRefExample(test)                 
    print "After call test is",test 
 
    print "Before call t is",t 
    byValueExample(t) 
    print "After call t is",t 

问题:

将普通的Python变量传递给 byValueExample()时，它可以按预期工作。函数参数 t的副本更改，但标头中的变量 t不变。但是，当我通过ctypes变量测试时，局部变量和标头变量都发生了变化，因此它的作用就像C指针变量。尽管我的程序可以运行，但是我不确定在这样使用时 byref()函数如何以及为什么不起作用:

byRefExample(byref(test))

请您参考如下方法:

您实际上使用的是不完全正确的术语，并且可能会引起误解。最后我会解释。但首先，我将根据您的措辞回答。


通过将可变对象作为变量传递给函数，我取得了成功，但是发现我也可以使用ctypes库执行相同的操作。

那是因为那些ctypes对象是可变对象，所以您只是在做已经做过的事情。特别地，ctypes.c_int是一个保存有整数值的可变对象，您可以通过设置其value成员来对其进行突变。因此，您已经在做和ctypes完全一样的事情。

更详细地，比较这些:

def by_ref_using_list(x): 
    x[0] += 1 
value = [10] 
by_ref_using_list(value) 
print(value[0]) 
 
def by_ref_using_dict(x): 
    x['value'] += 1 
value = {'value': 10} 
by_ref_using_list(value) 
print(value['value']) 
 
class ValueHolder(object): 
    def __init__(self, value): 
        self.value = value 
def by_ref_using_int_holder(x): 
    x.value += 1 
value = ValueHolder(10) 
by_ref_using_list(value) 
print(value.value) 

您可能希望所有这三个都将输出11，因为它们只是传递不同种类的可变对象和对其进行突变的三种不同方式。

而这正是您使用 c_int所做的。

您可能想阅读FAQ How do I write a function with output parameters (call by reference)?，尽管您似乎已经知道那里的答案，并且只是想知道 ctypes如何适合…

那么，那么 byref还能做什么呢？

它用于调用C函数，该函数通过使用显式指针类型通过引用C样式获取值。例如:

void by_ref_in_c(int *x) { 
    *x += 1; 
} 

您不能将其传递给 c_int对象，因为它需要一个指向 c_int的指针。而且您不能将其传递给未初始化的 POINTER(c_int)，因为那样的话它将被写入随机内存。您需要获取指向实际 c_int的指针。您可以这样做:

x = c_int(10) 
xp = pointer(x) 
by_ref_in_c(xp) 
print(x) 

那很好。但这太过分了，因为您已经创建了一个额外的Python ctypes对象 xp，您实际上并不需要任何东西。这就是 byref的目的:它为您提供了指向对象的轻量级指针，该指针只能用于通过引用传递该对象:

x = c_int(10) 
by_ref_in_c(byref(x)) 
print(x) 

这就解释了为什么这不起作用:

byRefExample(byref(test)) 

该调用将指向 test的轻量级指针，并将该指针传递给 byRefExample。但是 byRefExample不需要指向 c_int的指针，它想要 c_int。

当然，这全部是在Python中完成的，而不是C语言，因此没有进行静态类型检查。该函数调用可以正常工作，并且您的代码不关心它获得的类型，只要它具有可以增加的 value成员即可。但是 POINTER没有 value成员。 (相反，它有一个 contents成员。)因此，您尝试访问 AttributeError时会得到一个 x.value。

那么，您如何做这种事情？

嗯，使用单个元素列表是一个众所周知的技巧，可以解决以下事实:您需要共享一些可变的东西，但您只有不可变的东西。如果您使用它，经验丰富的Python程序员将了解您的工作。

话虽如此，如果您认为自己需要这个，那通常是错误的。正确的答案通常是只返回新值。对于不变异任何东西的函数，更容易进行推理。您可以将它们以任何所需的方式串在一起，使用生成器和迭代器将它们由内向外翻转，将它们交付给子进程以利用CPU中的那些额外核心，等等。即使您不执行任何通常，即使在您不希望这样做的情况下(例如，删除列表中75％的值)，返回新值通常也比就地修改新值更快。

通常，当您确实确实需要可变值时，它们已经存在一个显而易见的位置，例如类的实例属性。

但是有时候您确实需要单元素列表黑客，因此值得一试。只是在不需要时不使用它。

那么，您的术语出了什么问题？

从某种意义上讲(Ruby和Lisp程序员使用的意义)，Python中的所有内容都是按引用传递的。从另一种意义上(许多Java和VB程序员使用的意义)来说，它们都是按值传递的。但实际上，最好也不要调用它。*您传递的内容既不是变量值的副本，也不是变量的引用，而是值的引用。当您调用 byValueExample(t)函数时，没有像在C语言中那样传递值 67的新整数，而是传递对绑定到名称 67的同一整数 t的引用。如果您可以更改 67(您不能更改，因为int是不可变的)，则调用者将看到更改。

其次，Python名称甚至不是您所考虑的变量。在C语言中，变量是 lvalue。它具有类型，更重要的是，具有地址。因此，您可以传递对变量本身的引用，而不是对其值的引用。在Python中，名称只是名称(通常是模块，本地或对象字典中的键)。没有类型或地址。这不是你可以传递的东西。因此，无法通过引用传递变量 x。**

最后，Python中的 =不是将值复制到变量的赋值运算符；它是一个绑定运算符，为值赋一个名称。因此，在C中，当您编写 x = x + 1时，会将 x + 1值复制到变量 x的位置，但是在Python中，当您编写 x = x + 1时，只需将本地变量 x重新绑定为引用新值 x + 1。这对过去绑定的 x值没有任何影响。 (好吧，如果它是对该值的唯一引用，则垃圾收集器可能会清理它...但仅此而已。)

如果您来自C++，这实际上更容易理解，这实际上迫使您了解rvalues和lvalues以及不同类型的引用，副本构造与副本分配等……在C语言中，这一切看似简单，使得很难意识到它与同等简单的Python有多么大的不同。

* Python社区中的某些人喜欢将其称为“pass-by-sharing”。一些研究人员称其为“通过对象”。其他人选择在描述调用样式之前先区分值语义和引用语义，因此可以将其称为“引用语义传递副本”。但是，尽管至少这些名称不是模棱两可的，但它们也不是众所周知的，因此它们不可能帮助任何人。我认为比起试图找出最好的名字来描述它更好。

**当然，由于Python具有完全的反射性，因此您始终可以直接或间接传递字符串 x及其所在的上下文…如果 byRefExample做了 globals()['x'] = x + 2，那会影响全局 x。但是...不要那样做。