modifying a list while iterating through

[dustin.getz]

consider the following working loop where Packet is a subclass of
list, with Packet.insert(i ndex, iterable) inserting each item in
iterable into Packet at consecutive indexes starting at index.

i=0
while(i<len(pac ket)-4):
if packet[i:i+5]==Packet("01110 "):
packet.insert(i , "01111")
i+=10 #skip the 5 bits inserted, and skip the 5 bits just
checked bc overlap should not trigger insertion
else: i+=1

is there a way to do this more elegantly? seems like a big kludge.

[George Sakkis]

On Feb 25, 8:12 pm, dustin.g...@gma il.com wrote:

consider the following working loop where Packet is a subclass of
list, with Packet.insert(i ndex, iterable) inserting each item in
iterable into Packet at consecutive indexes starting at index.

i=0
while(i<len(pac ket)-4):
if packet[i:i+5]==Packet("01110 "):
packet.insert(i , "01111")
i+=10 #skip the 5 bits inserted, and skip the 5 bits just
checked bc overlap should not trigger insertion
else: i+=1

is there a way to do this more elegantly? seems like a big kludge.

Unless I missed something, this is a simple string replacement:

''.join(packet) .replace('01110 ', '0111001111')
George

[attn.steven.kuo]

On Feb 25, 5:12 pm, dustin.g...@gma il.com wrote:

consider the following working loop where Packet is a subclass of
list, with Packet.insert(i ndex, iterable) inserting each item in
iterable into Packet at consecutive indexes starting at index.

i=0
while(i<len(pac ket)-4):
if packet[i:i+5]==Packet("01110 "):
packet.insert(i , "01111")
i+=10 #skip the 5 bits inserted, and skip the 5 bits just
checked bc overlap should not trigger insertion
else: i+=1

is there a way to do this more elegantly? seems like a big kludge.

If Packet consists of '0's and '1's, then it may be
easier to convert to, or base the class on str (strings):

packet = "10101011110111 00111010001"
print "BEFORE ", packet
li = packet.split("0 1110")
packet = "0111001111".jo in(li)
print "AFTER ", packet

--
Hope this helps,
Steven

[dustin.getz]

On Feb 25, 9:15 pm, attn.steven.... @gmail.com wrote:

On Feb 25, 5:12 pm, dustin.g...@gma il.com wrote:

consider the following working loop where Packet is a subclass of
list, with Packet.insert(i ndex, iterable) inserting each item in
iterable into Packet at consecutive indexes starting at index.

i=0
while(i<len(pac ket)-4):
if packet[i:i+5]==Packet("01110 "):
packet.insert(i , "01111")
i+=10 #skip the 5 bits inserted, and skip the 5 bits just
checked bc overlap should not trigger insertion
else: i+=1

is there a way to do this more elegantly? seems like a big kludge.

If Packet consists of '0's and '1's, then it may be
easier to convert to, or base the class on str (strings):

packet = "10101011110111 00111010001"
print "BEFORE ", packet
li = packet.split("0 1110")
packet = "0111001111".jo in(li)
print "AFTER ", packet

--
Hope this helps,
Steven

Steven, George,

Thanks for your responses. Yea, that would work.

My original question still stands, though, in situations where a
simple string replacement might not be sufficient. Is there a way to
insert into a list whilst iterating through it?

for example, consider a list of binary values.

for index in range(len(itera ble)):
item=iterable[index]
if item==1:
iterable.insert (index,0)

obv this wouldn't work because now all future indexes will be off by
the number of previously inserted items.

using a while loop to fix this ugly and counterintuitiv e.

[Steven D'Aprano]

On Mon, 26 Feb 2007 13:45:36 -0800, dustin.getz wrote:

My original question still stands, though, in situations where a
simple string replacement might not be sufficient. Is there a way to
insert into a list whilst iterating through it?

Inserting/deleting from a list while you're walking through it is *always*
tricky, by its very nature.

Deletions are easy to deal with: iterate over the list backwards. When
you delete the current item, the only items that are re-numbered are items
you've already looked at.

Similarly, if you iterate backwards over the list and make sure you only
insert after the current item, never before, you can avoid re-numbering
items you haven't looked at yet.

Another solution is to iterate over the list, creating a new list as you
go:

new = []
for item in some_list:
if condition:
# delete the item
pass
elif other_condition :
# insert something
new.extend(['something', item])
else:
new.append(item )

for example, consider a list of binary values.

for index in range(len(itera ble)):
item=iterable[index]

The Pythonic way to write that is

for index,item in enumerate(itera ble):
pass

if item==1:
iterable.insert (index,0)

"Iterables" are sequences and iterators -- anything you can iterate over.
In general, only sequences can be inserted into (and not even all
sequences).

obv this wouldn't work because now all future indexes will be off by the
number of previously inserted items.

using a while loop to fix this ugly and counterintuitiv e.

Well, if you insist on doing a tricky job, you're always going to have
tricky code. Here's one solution:

# inserting into a mutable sequence
sequence.revers e()
for index in range(len(seque nce)-1, -1, -1):
item = sequence[index]
if item == 1:
sequence.insert (index+1, 0)
sequence.revers e()
Here's a solution that should work for any iterable, provided you have
sufficient memory:

# inserting into a copy of iterable
copy = []
for item in iterable:
if item == 1:
copy.append(0)
copy.append(ite m)
Hope this helps.
--
Steven.