3

For a homework assignment, we were required to create a function that took in two inputs (list and a string) and that returned a list. I would like to write this function using list comprehension, but have been running into an annoying issue. Here is he original function I would like to re-write:

index = [['keyword1', ['url1', 'url2', 'url3']], ['keyword2', ['url4', 'url5']]...]

def lookup(index, keyword):
    result = []
    for entry in index:
        if entry[0] == keyword:
            result += entry[1]
    return result

These were my attempts at using list comprehension:

def lookup(index, keyword):
    return [entry[1] for entry in index if entry[0] == keyword]

def lookup(index, keyword):
    return [ulist for key, ulist in index if i == keyword]

and finally...

def lookup(index, keyword):
    return [j for j in (entry[1] for entry in index if entry[0] == keyword)]

The problem here is that it returns the desired urls in a list inside of a list, like so:

[['url1', 'url2', 'url3']]

instead of the desired format of:

['url1', 'url2', 'url3']

I thought of just doing something like this (adding [0] to the end of the return statement so it gives me the inner list):

def lookup(index, keyword):
        return [j for j in (entry[1] for entry in index if entry[0] == keyword)][0]

But it just doesn't seem like the right way. Am I trying to use list comprehension unnecessarily (my understanding was that this situation was well suited for list comprehension)? Any suggestions?

Improve this question

6 Answers 6

Reset to default
7

This would be the most straightforward way:

def lookup(index,keyword):
    return [x for entry in index if entry[0]==keyword for x in entry[1]]

The nested list comprehension syntax isn't what you might initially expect. The key is to realize that the use of the two for loops is not two separate list comprehensions, but a single list comprehension with nested loops. That is actually why it works. It is like you were writing

for entry in index:
  if entry[0]==keyword:
    for x in entry[1]:
      yield x

The order in list comprehensions is the same as in regular loops, except for the yielded value, which comes first.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

When I first read this I thought it would have generated: "UnboundLocalError: local variable 'x' referenced before assignment". When I tried this: [j for j in entry[1] for entry in index if entry[0] == keyword], that is the error I got. Are assignments assessed differently in these types of expressions?
Very helpful! When you illustrate it that way it seems obvious that the first variable is building the list the same way the yielded value would have. The difference is simply presenting it as the first value as the list comprehension syntax requires. Awesome!
3

You should use a dictionary instead, because its API is more naturally suited to talking (and quickly processing) things related to maps.

keywordToUrl = {keyword1:(url1,url2,url3), keyword2:(url4,url5), ...}
keywordToUrl[keyword]
Improve this answer

2 Comments

I should have specified that this assignment specifies using lists only. Sorry for confusion...
I will never understand why teachers and professors construct stupid assignments like this.
1 
def lookup(index, keyword):
    return sum((entry[1] for entry in index if entry[0] == keyword), [])

Example:

>>> index = [['keyword1', ['url1', 'url2', 'url3']], ['keyword2', ['url4', 'url5']]]
>>> lookup(index, 'keyword1')
['url1', 'url2', 'url3']
Improve this answer

Comments

0 
def lookup(index,keyword):
    return [j for j in (entry[1] for entry in index if entry[0] == keyword)]

The problem is that you're returning something inside brackets, hence your value is being returned inside a list, remove the brackets and problem solved.

This would be the correct code:

def lookup(index,keyword):
    return j for j in (entry[1] for entry in index if entry[0] == keyword)
Improve this answer

3 Comments

That's just plain incorrect, and, in fact, the code you posted is a syntax error. The brackets are what allow it to be a list comprehension.
I think it's correct if you add square brackets appropriately - but I prefer the suggestion at the end of the original post.
If you put parens around the return is can return a generator object (brackets would make it exactly the same as the original), but the generator still contains one object, which is a list containing the strings, so no progress is made.
0

I apologize for the previous inconvenience. I already tested your code, if you take a look at the index list your values are not uniform:

index = [['keyword1', ('url1', 'url2', 'url3')], ['keyword2', ['url4', 'url5']]...]

here index[0][1] has a tuple and index[1][1] has a list.

If you make all the second values of the lists inside index, a tuple here's what happens:

Here's the same code as yours:

index = [["keyword1", ("url1", "url2", "url3")], ["keyword2", ("url4", "url5")]]
def lookup(index, keyword):
    return [entry[1] for entry in index if entry[0] == keyword]

print lookup(index,"keyword1")

And this is the output:

[('url1', 'url2', 'url3')]

You can notice that this isn't a list inside a list, cause all the values in index[i][1] are tuples now.

if you want this output:

['url1', 'url2', 'url3']

You'll need to convert that tuple into a list, which Python does not automatically for you. As described in the official documentation, a list comprehension always returns a list, thats why the tuple is inside a list.

http://www.python.org/dev/peps/pep-0202/

Improve this answer

3 Comments

There was a typo in the original post where the first list of urls was unintentionally encapsulated in () instead of [], this has been corrected. The variable index should be a list of lists: index = [[keyword, [url1, url2]], [keyword2, [url3, url4]],...]
Then regarding your original question, there's nothing you can do about it. A lot of python primitives return lists as a design choice. Given that a list comprehension always return lists as mentioned in the official documentation I linked before, and also given the fact that your list index contains lists that at the same time have one if it's values that is also a list, then the output of the list comprehension is a list inside a list. If you do not wish that output, then you'll need to take the first element of the list and return it as you mentioned before in your original post.
Vaughn-Cato has already solved this in one statement which returns a list meeting my criteria.
0

Let's take this example: when I give a letter and a list the return function will give the names that are there in the list starting with that letter.

def abc(letter , nameslist):
    return [name for name in nameslist if name[0].lower() == letter.lower() ]


nameslist = ["Sou", "Soudipta", "Gini", "Protijayi", "Gina"]

print( abc("P",nameslist) )
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.