Idiomatic way of repeating items in a sequence.

[alr]

I need to repeat each item in a list n times, like this function does:

def repeatitems(seq uence, repetitions):
newlist = []
for item in sequence:
for i in range(repetitio ns):
newlist.append( item)
return newlist

Output:

repeatitems(['a', 'b', 'c'], 3)

['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']

Clear and simple. But i wonder if there is a more idiomatic way. Surely not this:

def repeatitems(seq uence, repetitions):
return reduce(lambda l, i: l + i, [[item] * repetitions for item in sequence])

?

[Max M]

alr wrote:

I need to repeat each item in a list n times, like this function does:

def repeatitems(seq uence, repetitions):
newlist = []
for item in sequence:
for i in range(repetitio ns):
newlist.append( item)
return newlist

I would make just a minor change:

def repeatitems(seq uence, repetitions):
newlist = []
for item in sequence:
newlist += repetitions*[item]
return newlist
regards Max M

[Duncan Booth]

an***@wmdata.co m (alr) wrote in
news:f5******** *************** **@posting.goog le.com:

I need to repeat each item in a list n times, like this function does:

def repeatitems(seq uence, repetitions):
newlist = []
for item in sequence:
for i in range(repetitio ns):
newlist.append( item)
return newlist

Output:

>>> repeatitems(['a', 'b', 'c'], 3)

['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']

Clear and simple. But i wonder if there is a more idiomatic way.

The most obvious one that springs to mind is just a slight simplification
of your version:

def repeatitems(seq uence, repetitions):
newlist = []
for item in sequence:
newlist.extend([item] * repetitions)
return newlist
--
Duncan Booth du****@rcp.co.u k
int month(char *p){return(1248 64/((p[0]+p[1]-p[2]&0x1f)+1)%12 )["\5\x8\3"
"\6\7\xb\1\x9\x a\2\0\4"];} // Who said my code was obscure?

[Peter Otten]

alr wrote:

I need to repeat each item in a list n times, like this function does:

def repeatitems(seq uence, repetitions):
newlist = []
for item in sequence:
for i in range(repetitio ns):
newlist.append( item)
return newlist
.... But i wonder if there is a more idiomatic way.

How about this?

def repeatItems(seq uence, repetitions):
return [[item]*repetitions for item in sequence]

[Richard Brodie]

"Peter Otten" <__*******@web. de> wrote in message news:bd******** *****@news.t-online.com...

How about this?

def repeatItems(seq uence, repetitions):
return [[item]*repetitions for item in sequence]

Unfortunately that is equivalent to:

def repeatitems(seq uence, repetitions):
newlist = []
for item in sequence:
newlist.append([item] * repetitions)
return newlist

and not:

def repeatitems(seq uence, repetitions):
newlist = []
for item in sequence:
newlist.extend([item] * repetitions)
return newlist

[Duncan Booth]

Duncan Booth <du****@NOSPAMr cp.co.uk> wrote in
news:Xn******** *************** ****@127.0.0.1:

The most obvious one that springs to mind is just a slight
simplification of your version:

def repeatitems(seq uence, repetitions):
newlist = []
for item in sequence:
newlist.extend([item] * repetitions)
return newlist

Or, if you are in a "I've got a new toy to play with" mood you could use
itertools from Python 2.3 to obfuscate it somewhat:

from itertools import chain, izip, repeat
def repeatiterate(s equence, repetitions):
return chain(*izip(*re peat(sequence, repetitions)))

This version returns an iterator, so you might want to throw in a call to
'list' if you want to do anything other than iterating over the result.

--
Duncan Booth du****@rcp.co.u k
int month(char *p){return(1248 64/((p[0]+p[1]-p[2]&0x1f)+1)%12 )["\5\x8\3"
"\6\7\xb\1\x9\x a\2\0\4"];} // Who said my code was obscure?

[Peter Otten]

Richard Brodie wrote:

Unfortunately that is equivalent to:

def repeatitems(seq uence, repetitions):
newlist = []
for item in sequence:
newlist.append([item] * repetitions)
return newlist

.... but it looked so good. I should have tested it, though.
Je suis desole :-(

[Terry Reedy]

"alr" <an***@wmdata.c om> wrote in message
news:f5******** *************** **@posting.goog le.com...

I need to repeat each item in a list n times, like this function

does:

Is this really the right question? Any code that requires such an
n-repeat list *could* be rewritten (if you own it) to use the replist
in condensed form: (items, n). If this is not possible, one could
also define a replist class with a __getitem__(sel f, index) that
divides index by self.n and an __iter__() that returns an appropriate
generator.

Terry J. Reedy

[John Hunter]

>>>>> "alr" == alr <an***@wmdata.c om> writes:

alr> reduce(lambda l, i: l + i, [[item] * repetitions for item in

This doesn't look too bad to me, but perhaps list comprehensions are
clearer?

seq = ['a', 'b', 'c']
print [x for x in seq for x in seq]

[John Hunter]

>>>>> "alr" == alr <an***@wmdata.c om> writes:

alr> reduce(lambda l, i: l + i, [[item] * repetitions for item in
alr> sequence])
Oops, premature hit of send key. What I meant to say was

seq = ['a', 'b', 'c']
print [x for x in seq for i in range(len(seq))]

JDH