Change one list item in place

[Gnarlodious]

This works for me:

def sendList():
return ["item0", "item1"]

def query():
l=sendList()
return ["Formatting only {0} into a string".format(l[0]), l[1]]

query()


However, is there a way to bypass the

l=sendList()

and change one list item in-place? Possibly a list comprehension
operating on a numbered item?

-- Gnarlie

 

[MRAB]

This works for me:

def sendList():
return ["item0", "item1"]

def query():
l=sendList()
return ["Formatting only {0} into a string".format(l[0]), l[1]]

query()


However, is there a way to bypass the

l=sendList()

and change one list item in-place? Possibly a list comprehension
operating on a numbered item?

There's this:

return ["Formatting only {0} into a string".format(x) if i == 0
else x for i, x in enumerate(sendList())]

but that's too clever for its own good. Keep it simple.

 

[Gnarlodious]

Thanks.
Unless someone has a simpler solution, I'll stick with 2 lines.

-- Gnarlie

 

[Steve Holden]

This works for me:

def sendList():
return ["item0", "item1"]

def query():
l=sendList()
return ["Formatting only {0} into a string".format(l[0]), l[1]]

query()


However, is there a way to bypass the

l=sendList()

and change one list item in-place? Possibly a list comprehension
operating on a numbered item?

There's this:

return ["Formatting only {0} into a string".format(x) if i == 0 else
x for i, x in enumerate(sendList())]

but that's too clever for its own good. Keep it simple.

I quite agree. That solution is so clever it would be asking for a fight
walking into a bar in Glasgow.

However, an unpacking assignment can make everything much more
comprehensible [pun intended] by removing the index operations. The
canonical solution would be something like:

def query():
x, y = sendList()
return ["Formatting only {0} into a string".format(x), y]

regards
Steve

 

[Steven D'Aprano]

This works for me:

def sendList():
return ["item0", "item1"]

def query():
l=sendList()
return ["Formatting only {0} into a string".format(l[0]), l[1]]

For the record, you're not actually changing a list in place, you're
creating a new list.

I would prefer:

def query():
l = sendList()
l[0] = "Formatting only {0} into a string".format(l[0])
return l


which will continue to work even if sendlist() gets changed to return 47
items instead of 2.

An alternative would be:

 

[Steven D'Aprano]

An alternative would be:

Please ignore. That was an accidental Send mid-edit.

 

[Jean-Michel Pichavant]

This works for me:

def sendList():
return ["item0", "item1"]

def query():
l=sendList()
return ["Formatting only {0} into a string".format(l[0]), l[1]]

query()


However, is there a way to bypass the

l=sendList()

and change one list item in-place? Possibly a list comprehension
operating on a numbered item?

-- Gnarlie

what about

def query():
return ["Formating only {0} into a string".format(sendList()[0])] +
sendList()[1:]


JM

 

[Gnarlodious]

what about

def query():
    return ["Formating only {0} into a string".format(sendList()[0])] +
sendList()[1:]

However this solution calls sendList() twice, which is too processor
intensive.

Thanks for all the ideas, I've resigned myself to unpacking a tuple
and reassembling it.

-- Gnarlie
http://Sectrum.com

 

[Jean-Michel Pichavant]

what about

def query():
return ["Formating only {0} into a string".format(sendList()[0])] +
sendList()[1:]

However this solution calls sendList() twice, which is too processor
intensive.

You got to get rid of those nerd habits of unecessary optimization. To
put it simple, you just don't give a [put whatever suitable word] to the
overhead of 2 calls of sendList instead of one.
Until query is called a million time a second, there's no need to
sacrifice anything on the optimization altar, because no one will never
ever see the difference.

You can find my solution not that readable, that would be a proper
reason for not using it. It's up to you.

JM

 

[Steven D'Aprano]

Thanks for all the ideas, I've resigned myself to unpacking a tuple and
reassembling it.

You make it sound like that's an onerous task.