查找对象的实例引用

Astley Le Jasper Schrieb：
为什么需要找到这个？您知道它的名字是"鲍勃"。-Carsten Haesehttp：//informixdb.sourceforge.net

我正在创建mulitple实例，将它们放在列表中，迭代
通过列表将它们发送到处理它们的某些功能
具有某些实例特定参数。与：
鲍勃= someObject()
harry = someObject()
fred = someObject()
parameterdict = {'鲍勃':( 0,1,2)，'harry':( 3,4,5)，'弗雷德':( 6,7,8)}}
people_list =(鲍勃，哈里，弗雷德)
适用于人的人：
add_parameters(人)
def add_parameters(人)
mytuple = parameterdict [??????? instance.name ????]]
person.x = mytuple [0]
person.y = mytuple [1]
person.z = mytuple [2]
...或者，可能有一种非常简单的方法
它。
为什么不简单地做
鲍勃=某些对象(0，1，2)
？
diez

乔·斯特劳特(Joe Strout)在2008年10月16日在星期四11:24:28 -0600写道：简短的答案是您不能。这是因为python的名称(BOB)与对象(modulename.objectName())相关。它们不是变量，因为他们在"其他"编程语言中。

其他哪些编程语言？我从未见过一种OOP语言
与Python的工作方式相同。
但是，这里的"鲍勃"确实是一个变量。这是一个值的变量
(目前)是对某些对象的引用。

传统上，"变量"是一个命名的内存位置。
我必须使用"变量"来描述Python名称/
价值绑定在于它具有会使程序员感到困惑的含义
熟悉类似C的语言的人。例如：
DEF INC(X)：
x += 1
n = 1
INC(N)
断言n == 2
为什么这不起作用？这对任何期待的人来说都是完全神秘的
C样变量。
在这一点上，人们通常会通过声称来使问题感到困惑
"所有python变量都是指针"，这是 *实施
细节*在CPYTHON中，但不在其他实现中，例如PYPY或JYTHON。
否则人们会想象Python在您时制作了变量的副本
调用功能。事实并非如此，实际上是Python明确承诺的
切勿复制一个值，除非您明确地告诉它，但是它似乎
解释以上，至少直到程序员开始 *假设 *呼叫 -
副价值行为并发现了这一点：
Def Inc(Alist)：
alist += [1]#或alist.append(1)如果您喜欢
返回alist
a = [1，2，3]
b = inc(a)
断言a == [1，2，3]
函数是按值呼叫还是通过参考来调用？？？
(答案：都不是。他们是按名称调用的。)
我本人经常谈论变量作为速记。但这是一个坏习惯，
因为这对任何认为自己知道变量的人都有误导
行为，所以当我抓住自己做它时，我会修理并谈论名字
绑定。菜鸟可能不知道这意味着什么，但这是一个功能，不是
一个错误，因为它引起了他们的注意而不是发出错误
假设。
当然，您有权任何您喜欢的任何方式定义"可变"，并且
然后坚持认为Python变量的行为不像其他变量
语言。就个人而言，我认为这对任何人都无济于事。
[狙击]
但这肯定是几乎每个人几乎一直都会想到的。
考虑：
x = 5
y = x + 3
我很确定几乎每个人都会将其读为"分配给x的5，然后
将3添加到X，并将结果分配给Y，而不是：
"将对对象5的引用分配给x，然后删除x以获取
对象5，将其添加到给对象8的对象3，然后分配一个
引用该结果y。
当然是 引擎盖下到底发生了什么，你不能
*正确*理解Python在不理解的情况下的行为。但
我敢肯定，很少有人会自然而然地认为这种方式，尤其是菜鸟。
参考本质上是指指针，学习指针是
众所周知，人们很难。 Python做得很棒
参考文献很容易，但是它几乎总是隐藏了这样的事实
在引擎盖下使用参考。这就是为什么谈论变量如此
诱人和危险：Python的行为通常 *与
大多数新手对具有"变量"的语言的期望。
- -
史蒂文

乔·斯特劳特(Joe Strout)写道：
简短的答案是您不能。这是因为python的名称(BOB)与对象(modulename.objectName())相关。它们不是变量，因为他们在"其他"编程语言中。

其他哪些编程语言？我从未见过一种OOP语言
与Python的工作方式相同。
但是，这里的"鲍勃"确实是一个变量。这是一个值的变量
(目前)是对某些对象的引用。
正确 - 三个变量(a，b和c)，它们都具有相同的值，
即，全部指的是同一对象。这里没有什么神秘的
比
i = j = k = 42
我，j和k都具有相同的价值。 (OP的问题是
就像问"指42的变量的名称是什么？
从理论上讲，虽然您可以制定所有此类列表
变量通过浏览python的内部词，这是有点 一个
愚蠢的事情要做。)
好吧，它们是变量。我在这里没有抓住困难...
除非您(起初)将变量视为持有
对象值，而不是对象引用。确实是
重要的是要掌握的东西，因为它解释了为什么如果您这样做
a = b#其中b是具有属性'foo'的对象...
A.foo = 42
...您现在发现B.Foo也是42。一旦你没有神秘的事
意识到a和b的价值是对某些对象的参考
一个" foo"属性。
不确定这是否对任何人有帮助，但我希望如此！
最好的，
- 乔
对不起，乔，但我恭敬地不同意"不神秘"。我去过
在此列表中已有8年了，每个星期都会出现这个问题/问题
新手。从传统意义上讲，Python名称不是变量。如果他们
然后是：
a = b = c = [42]
将创建三个独立变量，每个变量都包含一个列表
42的单一元素。这不是Python所做的，几乎每个新手
至少被一个事实咬伤一次。
OW许多帖子在这里阅读，人们做这样的事情：
a = [1,2,3,4,5]
b = a
B.Append(6)
并且不知道为什么现在包含[1,2,3,4,5,6]？
他们没有失败，他们认为b = a将a的内容复制到b中。那是，
他们认为A和B是"持有"值的变量。现在这个术语
"变量"可能意味着与大多数其他新手不同的东西
那个经常列出了这个列表，但是他们全部(包括我刚开始时包括我)错过了
起初名称/值绑定的量具(但是男孩是美丽的
当您终于看到灯时)。也许你很幸运，能够掌握
这个相当强大的概念比我们大多数人更容易。
我认为这是关于python最困难的概念之一
来自VB，C，Fortran，Cobol(OOPS在那里显示我的年龄)等的人。我们
训练了我们的思想，以对待"变量"，例如命名的存储桶(或内存位置)。
甚至这里的OP都想询问存储桶中的对象并胁迫它
给他给他的水桶(变量)名称。
正如史蒂文如此雄辩地在另一篇文章中表现出的那样，这个问题是
很难谈论绑定到对象的名称。所以我们回到了
熟悉的语言和使用"可变"，这使许多新手感到困惑，因为
他们对"变量"是什么以及它的作用有先入为主的观念。
问候，
拉里

2008年10月16日，晚上11:23，丹尼斯·李·比伯(Dennis Lee Bieber)写道：
否 - 它将 /引用 /复制到包含该值的对象。
对对象的引用是对象引用的值
多变的。如此好，参数在python中通过byval。
似乎是，以及其他所有现代语言的默认值。
分配将RHS值复制到LHS变量。如果是
对象引用，复制的值是对象引用。
所有"值"都是Python中数据的引用 - 但其中一些
值是不变的对象，因此对它们执行的任何操作
创建
新对象，分配为新参考。
好的，那部分与大多数语言有所不同 - 不在
处理对象的方式，但事实是，即使是简单的值
整数包裹在对象中。但是由于这些是不变的
对象，这主要是内部实现细节。
对于对象引用(包括可能对待的可变的参考
人们)，Python的行为与其他任何语言没有什么不同。我不知道那意味着什么。他们以icantell的价值为单位。 (即使该值可能恰好是参考。)

从技术上讲，正如我回想起"呼叫命名"的定义，他们
不是。 ...
然后，无论何处，按名称调用作为宏扩展
在称为函数中引用。
感谢您的解释。显然，这不是发生的事情 Python。
就我而言，一切都是python中的" ref" ...
否，" ref"参数将意味着这：
def foo(byref x)：
x = x + [42]
a = [1,2,3]
foo(a)
....将导致a = [1,2,3,42]。你只能通过
简单的变量(不是表达式或字面意思)和'x'
内部foo不会是局部变量，而是任何东西的别名
变量已传递。因此，任何作业都会影响
传递的原始变量。
但是，如果Python具有任何此类功能，我就不知道。当然
默认行为是通过所有内容(甚至对象引用)
价值。对他们进行的作业不会影响其他任何事情。
或者，使用 +=的复合操作员之一。那是唯一的
python中的真正"陷阱"，来自另一种语言的人；你
可能天真地期望x += y与x = x +y相同，但在python中
通常情况并非如此；而是 +=是突变操作员，
就像您上面显示的示例一样。
这也是Python也做的。碰巧的是固定
内存中的位置包含一个对象引用。这里没有区别
在Python的对象引用VB.NET的对象引用之间
指针，爪哇对象引用等等。
那是什么意思？它的意思是："更换内容(即
与此名称关联的内存位置的对象引用)
带有所在的内存的内容(即对象引用)
通过将内容从此处复制到此处是关联的。"
这是完全相同的事情。 (并且与其他任何人完全相同
语。)
但是他们没有...
他们真的，真的做。
在大多数所有这些语言中，都必须明确区分
副本和参考之间的区别。
只有当您想到20年前或更长时间的语言时。甚至
在C ++中，虽然对象有不同的kludgy语法
"参考"(因为只是指针)，这是使用的标准
这样的指针到处都可以处理物体。爪哇清理了
通过用适当的引用代替指针，
vb.net，realbasic，可能是Ruby，当然还有Python。
哈，可能是这样。艾达甚至早于我，我并不是
年轻了！
bah ... pascal中I/O的根部需要指示。
嘿，我记得帕斯卡(Pascal)...那是苹果上使用的语言
IIG，回到初中的时候。我还记得花费$ 800
对于40MB的硬盘驱动器。啊，那是日子！
但是，看来，您是唯一一个争论"语义是
一切都一样：" ...这不是暗示他们不一样吗？
不，这向我暗示了Python中有很多混乱
社区。 :)似乎人(a)真的想
认为Python的对象处理特殊且独特
情感原因，或(b)将其与真正古老的语言进行比较
没有任何对象和对象引用的概念。这个
有 导致了新的术语并传播混乱。我是
与其他人一起工作近十年来回到Python
现代语言(包括为一种实施编译器
他们)，我在Python的对象之间根本看不到任何区别
处理和那些。
最好的，
- 乔

乔·斯特劳特(Joe Strout)在2008年10月17日星期五09:56:17 -0600写道：否 - 它将 /引用 /复制到包含该值的对象。

对对象的引用是对象引用的值
多变的。
这是一种奇怪而不自然的观察方式。从
effbot，就像评估孩子的社会安全号码
孩子本人：http：//mail.python.org/pipermail/pyt....ay/204560.html
如果我们执行Python代码行：
x ="鹦鹉"
然后问" x的价值是多少？"，我想你会认为
如果我回答，我故意钝，困难和混乱
"位置0xb7cdeb2c"。
废话。 Python在将参数传递给
功能。您在功能内部获得与外部相同的参数：
....打印ID(x)
...
3083441036
3083441036
我将在这里期待您的回答：您将否认
按值调用意味着将复制列表['some'，''thing']
在传递到功能之前。根据 *一些 *的定义
CBV，您甚至可能是对的。但是根据 *其他 *定义，
包括我在大学里学到的那个，该复制
数据是CBV的重要组成部分。
这些其他定义不一定是某些定义的正式定义
电脑科学家。他们同样有可能是非正式的理解
CBV和CBR的含义是什么："如果是按值调用，请不要传递大数据
结构是因为 它们将被复制，您的代码将很慢"。
分配将RHS值复制到LHS变量。如果是
对象引用，复制的值是对象引用。
不，分配将对象绑定到名称。那就是Python所做的。
当然，在实施级别，可以实现名称绑定
通过复制对象引用。否则可能不会。那是实施
细节在Python级别无关。
或者至少在抽象泄漏之前，它不应该是相关的。 http://www.joelonsoftware.com/articl...tractions.html
[狙击]
这是一个极其广泛的主张。与爪哇没有什么不同吗？好吧，也许。
与LISP没什么不同吗？疑。与福斯没有什么不同？是的，Riiight。
说到Java，Java和Python之间有一个主要区别
关于名称。在诸如Java之类的静态打字语言中，您
在使用之前定义名称，从那时起名称是绑定的
对一个类型和对象。但是与对象的结合是可选的，
这种未结合的名字被认为是无效的。
在像python这样的动态键入语言中，名称仅绑定到
对象。您不能有一个未结合的名字：如果存在一个名称，那一定是
绑定到对象，如果不存在，您会得到一个名称
当您尝试访问它时例外。和对象是键入的，而不是名称。 http://www.ferg.org/projects/python_...e-by-side.html从技术上讲，我回想起"按名称呼叫"的定义，它们也不是。 ...然后按名称调用，无论在所谓的函数中引用的参数何处，都用作宏扩展。

感谢您的解释。显然，这不是发生的事情
Python。
啊，不，那是我的不好。我有一个奇怪而令人不安的口吃
当我的意思是在
最尴尬的时刻。对不起。
- -
史蒂文

在10月17日，5：39*PM，Joe Strout 是的，虽然不是像C和Pascal这样的语言，而没有 *
对象的概念。 *我们真的应该停止提出这些 *
恐龙，而是将Python与任何现代OOP语言进行比较。
不？ *有什么方法可以证明，而无需深入研究python *
源本身？
如果不是，那么我认为您在谈论内部实施 *
细节。

我认为这是"矛盾的 ed示例解决了c/python差异
相当直接(都经过测试)：
---------------------------------------------------
C：
struct {int a;} s1，s2;
int main()
{
S1.A = 1;
S2 = S1;
printf(" s1.a％d s2.a％d \ n"，s1.a，s2.a);
S1.A = 99;
printf(" s1.a％d s2.a％d \ n"，s1.a，s2.a);
}
---------------------------------------------------
Python：
班级Mystruct：
经过
s1 = mystruct()
S1.A = 1
S2 = S1
打印" S1.A％2D S2.A％2D"％(S1.A，S2.A)
S1.A = 99
打印" S1.A％2D S2.A％2D"％(S1.A，S2.A)
------------------------
C输出：
S1.A 1 S2.A 1
S1.A 99 S2.A 1
Python输出：
S1.A 1 S2.A 1
S1.A 99 S2.A 99
请注意，在C(或C ++)中，S2.a的值保持不变，因为
S1的值(S1居住的内存的内容)是
复制到S2的内存位置，然后仅此值
S2.a的改变。在Python中，S2.a被"更改"(但不是真的)
因为事实证明S2只是对象的另一个名称
S1指的是。
因此，没有程序上可以访问的"内存中的位置"
对应于Python中的S1或S2。内存中只有一个位置
这与S1当前指向的对象相对应。在C中，
相比之下，内存中有确定的位置与
变量S1和S2，这些位置始终保持分开，
在整个程序的执行过程中，截然不同且没有变化。
这不是"实施细节"，它是
每种语言。由于C是汇编器上的"改进"，因此变量
名称一直是内存位置的别名(或
寄存器)。您可以在任何C/C ++编译器的输出中看到这一点。
在Python中，变量只是 *参考 *的名称/别名
对象，而不是对象/值本身的名称。变量
名称本身并不直接对应于对象的内存
位置。虽然是的，从技术上讲，那些参考是的确
值必须存储在内存中的某个地方， * *是
实施细节。但不是这些位置 *
参考(即，python *变量 *的位置)是
复制到周围，是参考本身(
复制的Python *对象 *)。
该名称 - >对象映射由什么组成？ *在某种程度上， *
必须有一个存储位置来存储 * *
对象，对吗？
我认为这是在上面回答的，但只是为了开车回家，在Python
变量本身的内存位置(实现
详细信息(持有对象的引用)是无法访问的。
相比之下，在C/C ++中，可变名称直接对应于内存
位置和对象，您可以轻松找到
变量。
在C/C ++中，如果选择，则可能有一个本身的变量
引用/指针指向其他内存/对象。在C中，我们会说
该变量的值是另一个对象的内存地址。
但是，如果需要的话，可以获取指针变量的地址，
哪个指向t的 *地址 * 他的另一个对象。
在Python中，变量仅是对对象的引用。你
无法获得python变量的地址，只有python对象的地址。
希望这能清除一切。
dale

在10月17日，下午5:39，乔·斯特劳特(Joe Strout) 是的，虽然不是像C和Pascal这样的语言
对象的概念。我们真的应该停止提出那些
恐龙，而是将Python与任何现代OOP语言进行比较。
不？有什么方法可以证明这一点，而无需深入研究
源本身？
如果没有，那么我认为您在谈论内部实施
细节。

我认为这个"无限"示例解决了(C/C ++)/Python
差异直接直接。
---------------------------------------------------
C：
struct {int a;} s1，s2;
int main()
{
S1.A = 1;
S2 = S1;
printf(" s1.a％d s2.a％d \ n"，s1.a，s2.a);
S1.A = 99;
printf(" s1.a％d s2.a％d \ n"，s1.a，s2.a);
}
---------------------------------------------------
Python：
班级Mystruct：
经过
s1 = mystruct()
S1.A = 1
S2 = S1
打印" S1.A％2D S2.A％2D"％(S1.A，S2.A)
S1.A = 99
打印" S1.A％2D S2.A％2D"％(S1.A，S2.A)
------------------------
C输出：
S1.A 1 S2.A 1
S1.A 99 S2.A 1
Python输出：
S1.A 1 S2.A 1
S1.A 99 S2.A 99
请注意，在C(或C ++)中，S2.a的值保持不变，因为
S1的值(S1居住的内存的内容)是
复制到S2的内存位置，然后仅此值
S2.a的改变。在Python中，S2.a被"更改"(但不是真的)
因为事实证明S2只是对象的另一个名称
S1指的是。
因此，没有程序上可以访问的"内存中的位置"
对应于Python中的S1或S2。内存中只有一个位置
这与S1当前指向的对象相对应。在C中，
相比之下，内存中有确定的位置与
变量S1和S2，这些位置始终保持分开，
在整个程序的执行过程中，截然不同且没有变化。
这不是"实施细节"，它是
每种语言。由于C是汇编器上的"改进"，因此变量
名称一直是内存位置的别名(或
寄存器)。您可以在任何C/C ++编译器的输出中看到这一点。
在Python中，变量只是 *参考 *的名称/别名
对象，而不是对象/值本身的名称。变量
名称本身并不直接对应于对象的内存
位置。虽然是的，从技术上讲，那些参考是的确
值必须存储在内存中的某个地方， * *是
实施细节。但不是这些位置 *
参考(即，python *变量 *的位置)是
复制到周围，是参考本身(
复制的Python *对象 *)。
该名称 - >对象映射由什么组成？在某种程度上，
必须有一个存储位置来存储对
对象，对吗？
我认为这是回答的 上面，但只是为了开车回家，在python
变量本身的内存位置(实现
详细信息(持有对象的引用)是无法访问的。
相比之下，在C/C ++中，可变名称直接对应于内存
位置和对象，您可以轻松找到
变量，尽管值可以。
在C/C ++中，如果选择，则可能有一个本身的变量
引用/指针指向其他内存/对象/数组。在C中，我们会
说该变量的值是另一个变量的内存地址
目的。但是，如果需要的话，可以获取指针的地址
变量，指向另一个对象的 *地址 *。
在Python中，变量仅是对对象的引用。你
无法获得python变量的地址，只有python对象的地址。
希望这能清除一切。
dale

在2008年10月27日，下午12:19，go *******@gmail.com写道：
是的，但是当然，C是一种数十年的语言，几乎没有
在汇编器上方一步。为了进行公平的比较，请选择任何现代OOP
语言，包括C衍生物(C ++，Objective-C，Java)和
将Python对象与该语言的对象进行比较，而不是
结构。
确切地！在C ++中，这就像一个指针变量。在RB的Java，
或.NET，就像对象引用。
同意。 (这是我回应一个人认为没有的人
存在这样的位置。)
正确的。变量包含对象引用；这些对象
当您将引用传递到一个
功能。这是按价值呼叫。在作业的情况下
参考被复制。该名称 - >对象映射由什么组成？在某种程度上，必须有一个存储位置来存储对theObject的引用，对吗？

我认为这是在上面回答的，但只是为了开车回家，在Python
变量本身的内存位置(实现
详细信息(持有对象的引用)是无法访问的。
正确的。在爪哇，rb，.net等中也是如此讨厌。但是缺乏
指针不会改变呼叫语义。
嗯，不，相当于对象引用的C ++等于：
someclass* foo;
实际上，许多C ++程序员更喜欢打字指向每个指针
班级，因为它是指针(相当于
您几乎总是想要的，而不是
班级本身。因此，实际上是：
SomeClassptr foo;
现在，当您这样做时：
foo2 = foo;
您正在将对象引用从foo复制到foo2，就像在
Python。当您将其传递到一个函数时：
void niftymethod(someclassptr arg){...}
...
niftymethod(foo);
您将对象引用直接复制到呼叫堆栈。这个
按价值传递，简单明了。并且因为它是按价值传递的，所以
您知道NiftyMethod所做的任何事情都无法改变价值
Foo-也就是说，可以指出其他内容。 (可能
更改DAT a它指出的对象包含，如果someclass
对象是可变的，但不能改变foo本身。)
就像Python和其他所有OOP语言一样。
通过引用致电是这样的：
void niftymethod2(someclassptr＆arg){...}
...
niftymethod2(foo);
现在，在这里通过参考传递ARG(就像Byref参数一样
RB或.NET)。这意味着niftymethod2可以很好地改变
传递的价值。它实际上可以指向
其他。
没有python方法可以做到这一点，因为python的论点始终是
通过价值通过。 Python中没有参考的呼叫。时期，
故事的结尾，在这里看不到。
干杯，
- 乔

特别是，记忆是可写细胞的线性序列。在图灵
机器，它们没有地址，访问是通过一次性移动进行的。
随后，给出细胞计数地址为0、1、2，...。
不？有什么方法可以证明这一点，

举证责任在于那些声称积极的人。格兰特和我声称
房间里没有粉红色的大象，我们看上去
周围很彻底。您声称有。向我们展示我们错过的东西。
无论如何，假设您阅读并执行" L123 = [1,2,3]"。你可以，我
假设，在该对象上执行任何列表方法。它在哪里？一些
记忆理论说"分布，尤其是无处不在"。其他人说
"集中，一些特殊的神经元"，但肯定没有什么比
线性计算机内存的"位置"。考虑另一个对象s ='boo'。
哪个地址较低？
Python是一种抽象信息算法语言，没有"源"，
只是语法和语义的规范。 CPYTHON来源是
特定计算机机器实现的来源。任何这样
启动必须抽象地将无位置的对象映射到特定的对象
计算机存储器的块，而无需添加无关的，可访问的python
语义，例如相对位置。
我想你是。给python对象一个整数地址是一个
(可选)实施细节。给他们一个 *固定的 *整数地址
是可选的cpython细节，可制定代码的某些方面
更容易，但可以防止重新定位垃圾收集(我
相信Jython确实如此。
任何人都可以自由地将Python视为线性内存计算机
编程语言(在某些方面，以下不如C)。
但是，我也将其视为一种算法语言，并且
初学者(大约10年前)，迅速将其称为"可执行伪代码"
(在这方面，比C优于C)。
Terry Jan Reedy

很遗憾地说我对这个例子很困惑，但是如果你愿意
就像是
bob = module.Object()
frank = module.Object()
然后知道鲍勃是鲍勃的实例列表，您可以
而是做类似的事情：
适用于Listofnames中的人：
temp = module.Object(人)
list.append(temp)
__init__函数将参数分配给object.nametag或
某物。这样，您可以将名称从索引中检索到
列表，或通过搜索名称来检索索引...
- chuckk
在2008年10月16日星期四下午5:04，阿斯特利·勒·贾斯珀(Astley Le Jasper)
为什么需要找到这个？您知道它的名字是"鲍勃"。-Carsten Haesehttp：//informixdb.sourceforge.net

我正在创建mulitple实例，将它们放在列表中，迭代
通过列表将它们发送到处理它们的某些功能
具有某些实例特定参数。与：
鲍勃= someObject()
harry = someObject()
fred = someObject()
parameterdict = {'鲍勃':( 0,1,2)，'harry':( 3,4,5)，'弗雷德':( 6,7,8)}}
people_list =(鲍勃，哈里，弗雷德)
适用于人的人：
add_parameters(人)
def add_parameters(人)
mytuple = parameterdict [??????? instance.name ????]]
person.x = mytuple [0]
person.y = mytuple [1]
person.z = mytuple [2]
...或者，可能有一种非常简单的方法
它。
-http://mail.python.org/mailman/listinfo/python-list
-http://www.badmuthahubbard.com