why does this unpacking work

[John Salerno]

I'm a little confused, but I'm sure this is something trivial. I'm
confused about why this works:

>>t = (('hello', 'goodbye'),

('more', 'less'),
('something', 'nothing'),
('good', 'bad'))

>>t

(('hello', 'goodbye'), ('more', 'less'), ('something', 'nothing'),
('good', 'bad'))

>>for x in t:

print x
('hello', 'goodbye')
('more', 'less')
('something', 'nothing')
('good', 'bad')

>>for x,y in t:

print x,y
hello goodbye
more less
something nothing
good bad

>>>

I understand that t returns a single tuple that contains other tuples.
Then 'for x in t' returns the nested tuples themselves.

But what I don't understand is why you can use 'for x,y in t' when t
really only returns one thing. I see that this works, but I can't quite
conceptualize how. I thought 'for x,y in t' would only work if t
returned a two-tuple, which it doesn't.

What seems to be happening is that 'for x,y in t' is acting like:

for x in t:
for y,z in x:
#then it does it correctly

But if so, why is this? It doesn't seem like very intuitive behavior.

Thanks.

[johnzenger]

It's just sequence unpacking. Did you know that this works?:

pair = ("California"," San Francisco")
state, city = pair
print city
# 'San Francisco'
print state
# 'California'

John Salerno wrote:

I'm a little confused, but I'm sure this is something trivial. I'm
confused about why this works:

>>t = (('hello', 'goodbye'),

('more', 'less'),
('something', 'nothing'),
('good', 'bad'))

>>t

(('hello', 'goodbye'), ('more', 'less'), ('something', 'nothing'),
('good', 'bad'))

>>for x in t:

print x
('hello', 'goodbye')
('more', 'less')
('something', 'nothing')
('good', 'bad')

>>for x,y in t:

print x,y
hello goodbye
more less
something nothing
good bad

>>>

I understand that t returns a single tuple that contains other tuples.
Then 'for x in t' returns the nested tuples themselves.

But what I don't understand is why you can use 'for x,y in t' when t
really only returns one thing. I see that this works, but I can't quite
conceptualize how. I thought 'for x,y in t' would only work if t
returned a two-tuple, which it doesn't.

What seems to be happening is that 'for x,y in t' is acting like:

for x in t:
for y,z in x:
#then it does it correctly

But if so, why is this? It doesn't seem like very intuitive behavior.

Thanks.

[Carsten Haese]

On Fri, 2006-10-20 at 15:14, John Salerno wrote:

I'm a little confused, but I'm sure this is something trivial. I'm
confused about why this works:

>>t = (('hello', 'goodbye'),

('more', 'less'),
('something', 'nothing'),
('good', 'bad'))

>>t

(('hello', 'goodbye'), ('more', 'less'), ('something', 'nothing'),
('good', 'bad'))

>>for x in t:

print x
('hello', 'goodbye')
('more', 'less')
('something', 'nothing')
('good', 'bad')

>>for x,y in t:

print x,y
hello goodbye
more less
something nothing
good bad

>>>

I understand that t returns a single tuple that contains other tuples.

t doesn't "return" anything, t *is* a nested tuple.

Then 'for x in t' returns the nested tuples themselves.

It again doesn't "return" anything. It assigns each element of tuple t
to x, one by one, executing the loop body for each element.

But what I don't understand is why you can use 'for x,y in t' when t
really only returns one thing. I see that this works, but I can't quite
conceptualize how. I thought 'for x,y in t' would only work if t
returned a two-tuple, which it doesn't.

You're thinking of "x,y = t".

What seems to be happening is that 'for x,y in t' is acting like:

for x in t:
for y,z in x:
#then it does it correctly

No, it's actually behaving like

for x in t:
y,z = t
# do something with y and z

You seem to have difficulty distinguishing the concept of looping over a
tuple from the concept of unpacking a tuple. This difficulty is
compounded by the fact that, in your example above, you are looping over
a tuple of tuples and unpacking each inner tuple on the fly.

Hope this helps,

Carsten.

[Carsten Haese]

On Fri, 2006-10-20 at 15:37, Carsten Haese wrote:

for x in t:
y,z = t
# do something with y and z

Typo here, of course I mean y,z = x.

-Carsten

[Jon Clements]

John Salerno wrote:

I'm a little confused, but I'm sure this is something trivial. I'm
confused about why this works:

>>t = (('hello', 'goodbye'),

('more', 'less'),
('something', 'nothing'),
('good', 'bad'))

>>t

(('hello', 'goodbye'), ('more', 'less'), ('something', 'nothing'),
('good', 'bad'))

>>for x in t:

print x
('hello', 'goodbye')
('more', 'less')
('something', 'nothing')
('good', 'bad')

>>for x,y in t:

print x,y
hello goodbye
more less
something nothing
good bad

>>>

I understand that t returns a single tuple that contains other tuples.
Then 'for x in t' returns the nested tuples themselves.

But what I don't understand is why you can use 'for x,y in t' when t
really only returns one thing. I see that this works, but I can't quite
conceptualize how. I thought 'for x,y in t' would only work if t
returned a two-tuple, which it doesn't.

What seems to be happening is that 'for x,y in t' is acting like:

for x in t:
for y,z in x:
#then it does it correctly

But if so, why is this? It doesn't seem like very intuitive behavior.

It makes perfect sense: in fact, you have kind of explained it
yourself!

Think of the for statement as returning the next element of some
sequence; in this case it's a tuple. Then on the left side, the
unpacking occurs. Using "for x in t", means that effectively no
unpackig occurs, so you get the tuple. However, since the in is
returning a tuple, using "for x,y in t", the tuple returned gets
unpacked.

Hope that helps.

Jon.

[Gabriel Genellina]

At Friday 20/10/2006 16:14, John Salerno wrote:

>I'm a little confused, but I'm sure this is something trivial. I'm
confused about why this works:

>>t = (('hello', 'goodbye'),

('more', 'less'),
('something', 'nothing'),
('good', 'bad'))
I understand that t returns a single tuple that contains other tuples.
Then 'for x in t' returns the nested tuples themselves.

But what I don't understand is why you can use 'for x,y in t' when t
really only returns one thing. I see that this works, but I can't quite
conceptualiz e how. I thought 'for x,y in t' would only work if t
returned a two-tuple, which it doesn't.

You can think of

for x in t:
whatever

as meaning "for each element contained in t, name it x and do whatever"

The other concept involved is unpacking:

>>w = (1,2,3)
x,y,z = w
x

1

When you say "for x,y in t:" there is an implicit unpacking, it means
"for each element contained in t, unpack it into x and y and do whatever"

>What seems to be happening is that 'for x,y in t' is acting like:

for x in t:
for y,z in x:
#then it does it correctly

No, it acts like:

for w in t:
x,y = w
...
--
Gabriel Genellina
Softlab SRL

_______________ _______________ _______________ _____
Correo Yahoo!
Espacio para todos tus mensajes, antivirus y antispam ¡gratis!
¡Abrí tu cuenta ya! - http://correo.yahoo.com.ar

[John Salerno]

jo********@gmai l.com wrote:

It's just sequence unpacking. Did you know that this works?:

pair = ("California"," San Francisco")
state, city = pair
print city
# 'San Francisco'
print state
# 'California'

Yes, I understand that. What confused me was if it had been written like
this:

pair = (("California", "San Francisco"))

[John Salerno]

Carsten Haese wrote:

You seem to have difficulty distinguishing the concept of looping over a
tuple from the concept of unpacking a tuple.

I think you're right. It's starting to make more sense now. I think when
I saw:

for x,y in t

I was expecting 't' to be a two-tuple for it to work. Maybe writing it as:

for (x,y) in t

sort of helps to show that '(x,y)' is equivalent to one object in 't'.
That makes it look a little more cohesive in my mind, I guess, or helps
me to see it map out against 't' better.

[Marc 'BlackJack' Rintsch]

In <%b************ ****@news.tufts .edu>, John Salerno wrote:

jo********@gmai l.com wrote:

>It's just sequence unpacking. Did you know that this works?:

pair = ("California"," San Francisco")
state, city = pair
print city
# 'San Francisco'
print state
# 'California'

Yes, I understand that. What confused me was if it had been written like
this:

pair = (("California", "San Francisco"))

Uhm, you mean::

pair = (("California", "San Francisco"),)

Note the extra comma to make that "a tuple in a tuple".

Ciao,
Marc 'BlackJack' Rintsch

[Gabriel Genellina]

At Friday 20/10/2006 17:29, John Salerno wrote:

>I was expecting 't' to be a two-tuple for it to work. Maybe writing it as:

for (x,y) in t

sort of helps to show that '(x,y)' is equivalent to one object in 't'.
That makes it look a little more cohesive in my mind, I guess, or helps
me to see it map out against 't' better.

Note that it's the *comma* in an expression list what creates a
tuple, *not* the parens. A similar rule applies on the target side of
an assignment:

x,y = (1,2)
(x,y) = [1,2]
[x,y] = 1,2

and all variations are all equivalent.
The left part of a for statement is like an assignment.
With this in mind, it's not surprise that

for (x,y) in t: pass
for x,y in t: pass

are exactly the same.

<http://docs.python.org/ref/exprlists.html>
<http://docs.python.org/ref/assignment.html >
--
Gabriel Genellina
Softlab SRL

_______________ _______________ _______________ _____
Correo Yahoo!
Espacio para todos tus mensajes, antivirus y antispam ¡gratis!
¡Abrí tu cuenta ya! - http://correo.yahoo.com.ar