cyclic data structures

[John Salerno]

I'm having some slight trouble understanding exactly why this creates an
infinite loop:

L = [1, 2]
L.append(L)

In a highly abstract way, I understand it. But if I were asked to write
down what I think L is after the second line executes, I would write:

[1, 2, [1, 2]]

But the correct answer seems to be:

[1, 2, [1, 2 [1, 2 [ .......

I guess what confuses me is that there doesn't seem to be anything
inherent in L itself that would cause this repeat. If you add L to L,
why don't you just get two Ls? Where does the cycle begin? Is this just
a quirk that comes with having a variable include a reference to the
same object the variable references?

 

[Peter Decker]

I'm having some slight trouble understanding exactly why this creates an
infinite loop:

L = [1, 2]
L.append(L)

'L' is a pointer to a list. You are now adding that pointer to the
very list it points to.

What you're looking for is:

L = [1, 2]
L.append(L[:])

 

[John Salerno]

'L' is a pointer to a list. You are now adding that pointer to the
very list it points to.

I understand that, but I guess I just don't see how this creates
anything other than a list that refers to [1, 2], and then refers again
to [1, 2], to create [1, 2, [1, 2]].

L.append(L) basically creates this, I think:

[1, 2, L]

Now, assuming that's correct, and since L points to the list [1, 2], why
can't '[1, 2]' be substituted for the 'L' and then the list is closed?

 

[Fredrik Lundh]

L.append(L) basically creates this, I think:

[1, 2, L]

Now, assuming that's correct, and since L points to the list [1, 2]

L points to [1, 2, L]

</F>

 

[Carsten Haese]

'L' is a pointer to a list. You are now adding that pointer to the
very list it points to.

I understand that, but I guess I just don't see how this creates
anything other than a list that refers to [1, 2], and then refers again
to [1, 2], to create [1, 2, [1, 2]].

L.append(L) basically creates this, I think:

[1, 2, L]

Now, assuming that's correct, and since L points to the list [1, 2], why
can't '[1, 2]' be substituted for the 'L' and then the list is closed?

L is [1,2] before the append. After the append, L is [1,2,L], which is
[1,2,[1,2,L]], which is [1,2,[1,2,[1,2,L]]] etc into infinity. L
literally contains itself after the append.

HTH,

Carsten.

 

[Duncan Booth]

L.append(L) basically creates this, I think:

[1, 2, L]
Correct.

Now, assuming that's correct, and since L points to the list [1, 2],

wrong. You just said it yourself: L is now the list [1, 2, L]

why
can't '[1, 2]' be substituted for the 'L' and then the list is closed?

The append method modifies the list in place. The list which contained 1,2
now has a third element which is a reference to itself.

 

[John Salerno]

L is [1,2] before the append. After the append, L is [1,2,L], which is
[1,2,[1,2,L]], which is [1,2,[1,2,[1,2,L]]] etc into infinity. L
literally contains itself after the append.

Ah, this perfectly explains it now! I guess I was dancing around this
fact, but now that you've typed it out, I see that L actually changed in
place!

Thanks guys!

 

[John Salerno]

The append method modifies the list in place.

That's the key that unlocked the mystery for me.

 

[Ewald R. de Wit]

I'm having some slight trouble understanding exactly why this creates an
infinite loop:

L = [1, 2]
L.append(L)

I tried this with Python 2.3.5 and it handles this tailbiter in a
very pleasantly surprising way:

l = [ 0, 1 ]
l.append( l )
l [0, 1, [...]]
l[2] [0, 1, [...]]
l[2][2][2][2][2][2][2][0]

1

The [...] I have never seen before anywhere, is it documented?