list of lists

[Tom]

Hi,

I have a list that consists of lists.
E.g. T=[[1, 2, 3], [4, 5], [6]]
Is there a way to address the a specific component in the "inner" list
directly?
E.g. right now I want to get the second value of the first list.
Unfortunately I have to save it to a variable first and then read it.
a = T[0]
print a[1]

That kind of sucks, becaus I have to read a lot of values from a lot of
lists! :-(
Is there a faster way than my saving it to a "help variable" first?

Thanks folks!!

Regards, Tom

 

[Paul Osman]

Hi,

I have a list that consists of lists.
E.g. T=[[1, 2, 3], [4, 5], [6]]
Is there a way to address the a specific component in the "inner" list
directly?
E.g. right now I want to get the second value of the first list.
Unfortunately I have to save it to a variable first and then read it.
a = T[0]
print a[1]

That kind of sucks, becaus I have to read a lot of values from a lot of
lists! :-(
Is there a faster way than my saving it to a "help variable" first?

Thanks folks!!

Regards, Tom

Hi Tom,

Do you mean this?

T=[[1, 2, 3], [4, 5], [6]]
T[0][1] 2
print T[0][1] 2
print T[1][1]

5

HTH,

--
Paul Osman
(e-mail address removed)
http://perl.eval.ca

"Idealists...foolish enough to throw caution
to the winds...have advanced mankind and have
enriched the world."
- Emma Goldman

 

[Zachary Beane]

Hi,

I have a list that consists of lists.
E.g. T=[[1, 2, 3], [4, 5], [6]]
Is there a way to address the a specific component in the "inner" list
directly?
E.g. right now I want to get the second value of the first list.
Unfortunately I have to save it to a variable first and then read it.
a = T[0]
print a[1]

That kind of sucks, becaus I have to read a lot of values from a lot of
lists! :-(
Is there a faster way than my saving it to a "help variable" first?

To use your example:

T=[[1, 2, 3], [4, 5], [6]]
print T[0][1]

Zach

 

[Johannes Gijsbers]

Hi,

I have a list that consists of lists. E.g. T=[[1, 2, 3], [4, 5], [6]]
Is there a way to address the a specific component in the "inner" list
directly?
E.g. right now I want to get the second value of the first list.
Unfortunately I have to save it to a variable first and then read it. a =
T[0]
print a[1]

Try using T[0][1]. T[0] is exactly equivalent to 'a', so you can use
the same operations, you don't have to assign to 'a' first.

Johannes

 

[Daniel Klein]

I have a list that consists of lists.
E.g. T=[[1, 2, 3], [4, 5], [6]]
Is there a way to address the a specific component in the "inner" list
directly?
E.g. right now I want to get the second value of the first list.
Unfortunately I have to save it to a variable first and then read it.
a = T[0]
print a[1]

That kind of sucks, becaus I have to read a lot of values from a lot of
lists! :-(
Is there a faster way than my saving it to a "help variable" first?

T=[[1, 2, 3], [4, 5], [6]]
print t[0][1]

2

Daniel Klein

 

[Lukasz Pankowski]

Do you mean this:

T=[[1, 2, 3], [4, 5], [6]]
print T[0][1]

2

 

[Peter Otten]

Hi,

I have a list that consists of lists.
E.g. T=[[1, 2, 3], [4, 5], [6]]
Is there a way to address the a specific component in the "inner" list
directly?
E.g. right now I want to get the second value of the first list.
Unfortunately I have to save it to a variable first and then read it.
a = T[0]
print a[1]

That kind of sucks, becaus I have to read a lot of values from a lot of
lists! :-(
Is there a faster way than my saving it to a "help variable" first?

Thanks folks!!

Regards, Tom

Your example rather than your problem specification suggests that you want
them all. If I'm guessing right:

def flatten(lol):
for lst in lol:
for item in lst:
yield item

T=[[1, 2, 3], [4, 5], [6]]

for item in flatten(T):
print item

Indices seem to be a dying breed

Peter

 

[Tom]

Hi guys,

thanks to everyone.
My mistake was that I had no idea that writing [][] NEXT to each other
goes into depth. I always tried different varieties of [[]] to get into
the deeper lists!
Thanks again.

CU Tom

 

[Dave Kuhlman]

Hi guys,

thanks to everyone.
My mistake was that I had no idea that writing [][] NEXT to each
other goes into depth. I always tried different varieties of [[]]
to get into the deeper lists!
Thanks again.

It's a simple concept, once you grasp it, but for those new to
Python, it may be worth emphasizing -- You can concatenate
operators (to the right, at least) and these operators will
operate on the run-time value produced by the expression
to which they are applied. For example (read from bottom up):


getArray()[3].formatter()
^ ^ ^ ^ ^
| | | | |
| | | | +--- (5) call function retrieved from
| | | | attribute
| | | +-------------- (4) access attribute of object indexed
| | | from array
| | +---------------- (3) index element of array returned by
| | function call
| +------------------- (2) call function retrieved from name
| binding
+------------------------ (1) retrieve value bound to variable


It is also worth thinking about what is meant by saying that this
evaluation is *dynamic*. For example, if the object returned by
the function call to getArray (above) is not indexable, then the []
operator will fail.

And, the only limiting factor is confusion.

Dave

 

[Peter Otten]

It's a simple concept, once you grasp it, but for those new to
Python, it may be worth emphasizing -- You can concatenate
operators (to the right, at least) and these operators will
operate on the run-time value produced by the expression
to which they are applied. For example (read from bottom up):


getArray()[3].formatter()
^ ^ ^ ^ ^
| | | | |
| | | | +--- (5) call function retrieved from
| | | | attribute
| | | +-------------- (4) access attribute of object indexed
| | | from array
| | +---------------- (3) index element of array returned by
| | function call
| +------------------- (2) call function retrieved from name
| binding
+------------------------ (1) retrieve value bound to variable


It is also worth thinking about what is meant by saying that this
evaluation is *dynamic*. For example, if the object returned by
the function call to getArray (above) is not indexable, then the []
operator will fail.

And, the only limiting factor is confusion.

Nice explanation. I take the occasion to warn newbies that the sort() method
is a showstopper in this scheme:

getArray().sort()[3].formatter() #BAD CODE, DON'T USE
^
|
+ -- sort() returns None

By the way, is there any Python programmer who has not made this error at
least once?

Peter

 

[Max M]

Nice explanation. I take the occasion to warn newbies that the sort() method
is a showstopper in this scheme:

getArray().sort()[3].formatter() #BAD CODE, DON'T USE
^
|
+ -- sort() returns None

By the way, is there any Python programmer who has not made this error at
least once?

Also it is a slower approach if you want to look up more than one item
in the list. In that case it is better to bind the sorted result of
getArray to a variable.

arr = getArray()
arr.sort()
arr[3].formatter()
arr[4].formatter()
arr[5].formatter()


So I find that I rarely use the short form of the expression.

regards Max M