CODEWITHSUNDEEP
pythonpython-3.xlistslice
Alison LT
Alison LT

Reputation: 405

Python list slicing for n-2 every n

If I have a list test

test = [i for i in range(20)]
print(test)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

and I want to get the last 3 numbers every 5 numbers such that I get a list that looks like:

[2, 3, 4, 7, 8, 9, 12, 13, 14, 17, 18, 19]

Is there a way to do this with list slicing? I can do it with a modulo function like

[i for i in test if i % 5 > 1]

But I'm wondering if there is a way to do this with list slicing? Thanks

Upvotes: 2

Views: 283

Answers (4)

PieCot
PieCot

Reputation: 3639

I propose this solution:

from functools import reduce
reduce(lambda x, y: x + y, zip(test[2::5], test[3::5], test[4::5]))

Testing with timeit, it is faster than filter and comprehension list (at least on my pc).

Here the code to carry out an execution time comparison:

import numpy as np
import timeit

a = timeit.repeat('list(filter(lambda x: x % 5 > 1, test))',
                  setup='from functools import reduce; test = list(range(20))',
                  repeat=20,
                  number=100000)

b = timeit.repeat('[i for i in test if i % 5 > 1]',
                  repeat=20,
                  setup='test = list(range(20))',
                  number=100000)

c = timeit.repeat('reduce(lambda x, y: x + y, zip(test[2::5], test[3::5], test[4::5]))',
                  repeat=20,
                  setup='from functools import reduce;test = list(range(20))',
                  number=100000)

list(map(lambda x: print("{}:\t\t {} ({})".format(x[0], np.mean(x[1]), np.std(x[1]))),
         [("filter list", a),
          ('comprehension', b),
          ('reduce + zip', c)]))

The previous code produce the following results:

filter list:         0.2983790061000036 (0.007463432805174629)
comprehension:       0.15115660065002884 (0.004455055805853705)
reduce + zip:        0.11976779574997636 (0.002553487341208172)

I hope this can help :)

Upvotes: 0

Patrick Haugh
Patrick Haugh

Reputation: 61063

Yes, but I very much doubt it will be faster than a simple list comprehension:

from itertools import chain, zip_longest as zipl

def offset_modulo(l, x, n):
    sentinel = object()
    slices = (l[i::n] for i in range(x, n))
    iterable = chain.from_iterable(zipl(*slices, fillvalue=sentinel))
    return list(filter(lambda x: x is not sentinel, iterable))

print(offset_modulo(range(20), 2, 5))
# [2, 3, 4, 7, 8, 9, 12, 13, 14, 17, 18, 19]
print(offset_modulo(range(24), 2, 5))
# [2, 3, 4, 7, 8, 9, 12, 13, 14, 17, 18, 19, 22, 23]

Basically, this approach gets the list slices that represents each the index i such that i % n >= x. It then uses zip and chain to flatten those into the output.

Edit:

A simpler way

def offset(l, x, n):
    diff = n-x
    slices = (l[i:i+diff] for i in range(x, len(l), n))
    return list(chain.from_iterable(slices))

offset(range(20), 2, 5)
# [2, 3, 4, 7, 8, 9, 12, 13, 14, 17, 18, 19]
offset(range(24), 2, 5)
# [2, 3, 4, 7, 8, 9, 12, 13, 14, 17, 18, 19, 22, 23]

Where we get the slices of the adjacent elements we want, then chain those together.

Upvotes: 0

rneeja
rneeja

Reputation: 96

If ordering does not matter, you can try the following:

test[2::5] + test[3::5] + test[4::5]

Or more generally speaking

 start = 2 #Number of indices to skip
 n = 5
 new_test = []
 while start < 5:
     b.extend(test[start::n])
     start += 1

Upvotes: 1

Bubble Bubble Bubble Gut
Bubble Bubble Bubble Gut

Reputation: 3358

Use the filter function:

list(filter(lambda x: x % 5 > 1, test))  # [2, 3, 4, 7, 8, 9, 12, 13, 14, 17, 18, 19]

Upvotes: 3

Related Questions