CODEWITHSUNDEEP
pythonfor-loopconditional-statements
techhighlands
techhighlands

Reputation: 972

for loop based on dynamic list python

Edit: The desired behaviour of the program is to find the number sequences that have an increasing trend, so I want to generate from ks list a list like this: desiredList=[[97,122],[98,111],[98,101,103,103,104]]

I have the following, my goal is to run the for loop based on the length of the list, the list length gets changed inside the for loop itself. Python takes into account only the length before the for loop, when the length of the list is changed in the loop it still takes the older value before the loop. Here is the code:

ks=[97,122,111,98,111,98,101,103,103,104,97]
splitLine=2
counter=[]
for i in range(0,len(ks)):
   a=ks[i:splitLine]
   while len(a)>1:
        for j in range(0,len(a)):
            m=j
            n=j+1
            if(a[m]-a[n]<=0):
                c=c+1
                k=splitLine+c-1
                a.append(ks[k]) #When append happens, the for loop still takes the older value of len(a) instead of new value
            else:
                a.pop(-1)
                counter.append(a)
                splitLine=splitLine+1
                a=[]
                break

Upvotes: 2

Views: 9775

Answers (3)

daragua
daragua

Reputation: 1183

Your implementation is probably nesting too many loops for the problem it is trying to solve.

This first implementation contains an error. See below for the fix.

Try something along these lines perhaps:

l = [97,122,111,98,111,98,101,103,103,104,97]
out = []
acc = []
for v in l:
    if len(acc)==0 or v >= acc[-1]:
        acc.append(v)
    else:
        if len(acc) > 1:
            out.append(acc)
        acc = [v]

print(out)
>>>[[97, 122], [98, 111], [98, 101, 103, 103, 104]]

That previous code is slow and can drop the last found fragment. I found that error while running random tests on it to try an optimized version. The following code shows the original code with the correction and the optimized version which can be 30% faster.

def original(l):
    out = []
    acc = []
    added = False
    for v in l:
        if len(acc)==0 or v >= acc[-1]:
            acc.append(v)
        else:
            added = False
            acc = [v]

        if acc is not None and len(acc)>1 and not added:
            added = True
            out.append(acc)
    return out


def optimized(l):
    out = []

    acc = None
    tmp = None
    deb_v = False
    for v in l:
        prev =  acc[-1] if (acc is not None and len(acc)) else tmp
        if prev is not None and v >= prev:
            if tmp is not None:
                acc = []
                acc.append(tmp)
                out.append(acc)
                tmp = None
            acc.append(v)
        else:
            acc = None
            tmp = v
    return out


# The original test data
l = [97,122,111,98,111,98,101,103,103,104,97]
assert original(l) == optimized(l) == [[97,122],[98,111],[98,101,103,103,104]]

# A list that triggered last-fragment-dropped error
l = [57, 16, 6, 19, 40, 3, 4, 13, 2, 70, 85, 65, 32, 69, 54, 51, 95, 74, 92, 46, 45, 26, 0, 61, 99, 43, 67, 71, 97, 10, 18, 73, 88, 47, 33, 82, 25, 75, 93, 80, 23, 37, 87, 90, 49, 15, 35, 63, 17, 64, 5, 72, 89, 21, 50, 8, 41, 86, 31, 78, 52, 76, 56, 42, 77, 36, 11, 60, 39, 22, 68, 27, 24, 28, 59, 96, 29, 38, 12, 79, 53, 9, 83, 94, 34, 14, 7, 48, 30, 20, 66, 62, 91, 58, 81, 1, 98, 44, 55, 84]
assert original(l) == optimized(l)

# Random testing
import random
l = list(range(100))
random.shuffle(l)
assert original(l) == optimized(l)

# Timing!
import timeit

print(timeit.timeit("original(l)", globals={"l":l, "original": original}))
# 43.95869998800117

print(timeit.timeit("optimized(l)", globals={"l":l, "optimized": optimized}))
# 34.82134292599949

Upvotes: 1

Tagc
Tagc

Reputation: 9076

As Moinuddin says, the root of your problem isn't clear to us. However, the code below shows how you can keep iterating over a list as its length changes:

def iterate_for_static_list_length(l):
    for i in range(len(l)):
        yield i
        l.append(object())


def iterate_for_dynamic_list_length(l):
    for i, _ in enumerate(l):
        yield i
        l.append(object())


if __name__ == '__main__':
    l = [object()] * 3

    print('Static implementation')
    for value in iterate_for_static_list_length(l):
        input(value)

    print('\nDynamic implementation')
    for value in iterate_for_dynamic_list_length(l):
        input(value)

Output

Static implementation
0
1
2

Dynamic implementation
0
1
2
3
4
5
6
7
8

This program will keep going forever. In your code I can see that you conditionally append to the list within the loop, so it seems like it should terminate eventually.

Upvotes: 0

wildwilhelm
wildwilhelm

Reputation: 5019

A quick fix for your looping problem would be to swap out your for loop for a while loop. Change this:

for j in range(0,len(a)):
    # <loop contents>

to this:

j = 0
while j < len(a):
    # <loop contents>
    j += 1

The for loop is grabbing values of j out of a range (a list in Python 2, and a generator object in Python 3). This range is calculated when the for loop is run the first time; it will not update after that, no matter what you do to a.

The while loop gives you more control in this situation, because you can specify the condition under which you want to exit the loop.

Upvotes: 3

Related Questions