[].index

[Mike Edey]

Good day.
Recently I'd run into wishing a list's index method would match
substrings. Being fairly new to this game I can't help but think that my
solution is a little, well, clumsy. In the following trivial example I'm
only interested in finding the first matching list item:

data = ['aaa','bbb','ccc','ddd','eee','fff','ggg','hhh'] foo =
['b','e','e']
[data[[data.index(iy) for iy in data if iy.find(foo[ix]) > -1][0]] for
ix in range(len(foo))]

['bbb', 'eee', 'eee']
So I guess this question is - have I missed a cleaner method then this
nested list comprehension?

[Calvin Spealman]

Mike Edey wrote:

Good day.
Recently I'd run into wishing a list's index method would match
substrings. Being fairly new to this game I can't help but think that my
solution is a little, well, clumsy. In the following trivial example I'm
only interested in finding the first matching list item:

data = ['aaa','bbb','ccc','ddd','eee','fff','ggg','hhh'] foo =
['b','e','e']
[data[[data.index(iy) for iy in data if iy.find(foo[ix]) > -1][0]] for
ix in range(len(foo))]

['bbb', 'eee', 'eee']
So I guess this question is - have I missed a cleaner method then this
nested list comprehension?

This depends on what you need this for exactly. Will you always be matching
a single character to the beginning of a string or will they sometimes be
more than one character? if only one, then how about storing the strings as
a dict with the characters as keys?

[Jeff Epler]

Using your test case:

data = ['aaa','bbb','ccc','ddd','eee','fff','ggg','hhh']
foo = ['b', 'e', 'e']
I'd define a function to do the difficult part:
(note that in Python 2.3, "s in t" returns True if s is a substring of t.
In earlier versions, "s in t" worked only when s was a length-1 string) def match(substring, candidates): ... """Return the candidate which contains substring"""
... for c in candidates:
... if substring in c: return c

Then, the list comprehension becomes simple: [match(c, data) for c in foo] ['bbb', 'eee', 'eee']

Even if you want to write this as a single list comprehension, why not [iy for ix in foo for iy in data if ix in iy] ['bbb', 'eee', 'eee']
... though if some item in foo doesn't correspond to any items in data,
you just get a different-length output than input, not an exception (as
for your code) or a None in the resulting list (in my first example)

Personally, I'll take the approach that uses a function. The
pure-listocmp version I wrote might as well say [fee fie foe fum i smell the blood of an englishman]

as far as my eyes are concerned.

Jeff

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (GNU/Linux)

iD8DBQFAu0XIJd01MZaTXX0RAlZsAJ0ZCAxaOdcgnYv6o/NgSyAhYN/cKQCeONd7
cvbvdpQ+Fjdm7KJgI4nHD/I=
=hWv7
-----END PGP SIGNATURE-----

[Shalabh Chaturvedi]

Mike Edey wrote:

Good day.
Recently I'd run into wishing a list's index method would match
substrings. Being fairly new to this game I can't help but think that my
solution is a little, well, clumsy. In the following trivial example I'm
only interested in finding the first matching list item:

data = ['aaa','bbb','ccc','ddd','eee','fff','ggg','hhh'] foo =
['b','e','e']
[data[[data.index(iy) for iy in data if iy.find(foo[ix]) > -1][0]] for
ix in range(len(foo))]

['bbb', 'eee', 'eee']
So I guess this question is - have I missed a cleaner method then this
nested list comprehension?

Here's an option:

[s for s in data for prefix in foo if s.startswith(prefix)]

Clearer to read and understand. I like to keep away from indexes and
counters as much as possible.

HTH,
Shalabh

[Piet van Oostrum]

>>>>> Mike Edey <mi**@edey.mine.nu> (ME) wrote:

ME> Good day.
ME> Recently I'd run into wishing a list's index method would match
ME> substrings. Being fairly new to this game I can't help but think that my
ME> solution is a little, well, clumsy. In the following trivial example I'm
ME> only interested in finding the first matching list item:

data = ['aaa','bbb','ccc','ddd','eee','fff','ggg','hhh'] foo =
['b','e','e']
[data[[data.index(iy) for iy in data if iy.find(foo[ix]) > -1][0]] for
ix in range(len(foo))]

ME> ['bbb', 'eee', 'eee']
ME> So I guess this question is - have I missed a cleaner method then this
ME> nested list comprehension?

It can be cleaned up:

[d for d in data for x in foo if d.find(x) > -1]
--
Piet van Oostrum <pi**@cs.uu.nl>
URL: http://www.cs.uu.nl/~piet [PGP]
Private email: P.***********@hccnet.nl