Elementen van een lijst n keer herhalen

Hoe herhaal ik elk element van een lijst nkeer en maak ik een nieuwe lijst? Bijvoorbeeld:

x = [1,2,3,4]
n = 3
x1 = [1,1,1,2,2,2,3,3,3,4,4,4]

x * nwerkt niet

for i in x[i]:
    x1 = n * x[i]

Er moet een eenvoudige en slimme manier zijn.

Antwoord 1, autoriteit 100%

De ideale manier is waarschijnlijk numpy.repeat:

In [16]:
x1=[1,2,3,4]
In [17]:
np.repeat(x1,3)
Out[17]:
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])

Antwoord 2, autoriteit 47%

In het geval je echt resultaat als lijst wilt, en generator niet voldoende is:

import itertools
lst = range(1,5)
list(itertools.chain.from_iterable(itertools.repeat(x, 3) for x in lst))
Out[8]: [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]

Antwoord 3, autoriteit 42%

U kunt lijstbegrip gebruiken:

[item for item in x for i in range(n)]

>>> x = [1, 2, 3, 4]
>>> n = 3
>>> new = [item for item in x for i in range(n)]
#[1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]

Antwoord 4, autoriteit 12%

Een eenvoudigere manier om dit te bereiken is door de lijst xte vermenigvuldigen met nen de resulterende lijst te sorteren. bijv.

>>> x = [1,2,3,4]
>>> n = 3
>>> a = sorted(x*n)
>>> a
>>> [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]

Antwoord 5, autoriteit 6%

Een geneste lijst-comp werkt hier:

>>> [i for i in range(10) for _ in xrange(3)]
[0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9]

Of om uw voorbeeld te gebruiken:

>>> x = [1, 2, 3, 4]
>>> n = 3
>>> [i for i in x for _ in xrange(n)]
[1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]

Antwoord 6, autoriteit 3%

Dit lost je probleem op:

x=[1,2,3,4]
n = 3
x = sorted(x * n)

Antwoord 7, autoriteit 2%

[myList[i//n] for i in range(n*len(myList))]

Antwoord 8

import itertools
def expand(lst, n):
    lst = [[i]*n for i in lst]
    lst = list(itertools.chain.from_iterable(lst))
    return lst
x=[1,2,3,4]
n=3
x1 = expand(x,3)
print(x1)

Geeft:

[1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]

Uitleg:

Doen, [3]*3geeft het resultaat van [3,3,3], dit vervangen door nwe krijgen [3,3,3,...3] (n times)Met behulp van een lijstbegrip kunnen we door elk element van de lijst gaan en deze bewerking uitvoeren, ten slotte moeten we de lijst afvlakken, die we kan doen door list(itertools.chain.from_iterable(lst))

Antwoord 9

zAxe=[]
for i in range(5):
    zAxe0 =[i] * 3
    zAxe +=(zAxe0) # append allows accimulation of data 

Antwoord 10

manier 1:

def foo():
    for j in [1, 3, 2]:
        yield from [j]*5

manier 2:

from itertools import chain
l= [3, 1, 2]
chain(*zip(*[l]*3))

manier 3:

sum(([i]*5 for i in [2, 1, 3]), [])

Antwoord 11

Als u de lijst ter plekke wilt wijzigen, kunt u het beste vanaf de achterkant herhalen en een deel van wat voorheen één item was, toewijzen aan een lijst van dat item nkeer.

Dit werkt vanwege de slice-toewijzing:

>>> ls = [1, 2, 3]
>>> ls[0: 0+1]
[1]
>>> ls[0: 0+1] = [4, 5, 6]
>>> ls
>>> [4, 5, 6, 2, 3]

def repeat_elements(ls, times):
    for i in range(len(ls) - 1, -1, -1):
        ls[i: i+1] = [ls[i]] * times

Demogebruik:

>>> a = [1, 2, 3]
>>> b = a
>>> b
[1, 2, 3]
>>> repeat_elements(b, 3)
>>> b
[1, 1, 1, 2, 2, 2, 3, 3, 3]
>>> a
[1, 1, 1, 2, 2, 2, 3, 3, 3]

(Als u het niet ter plaatse wilt wijzigen, kunt u de lijst kopiëren en de kopie retourneren, waardoor het origineel niet wordt gewijzigd. Dit zou ook werken voor andere reeksen, zoals tuples, maar is niet lui zoals de itertools.chain.from_iterableen itertools.repeatmethode)

def repeat_elements(ls, times):
    ls = list(ls)  # Makes a copy
    for i in range(len(ls) - 1, -1, -1):
        ls[i: i+1] = [ls[i]] * times
    return ls

Antwoord 12

Voor basis Python 2.7:

   from itertools import repeat
    def expandGrid(**kwargs):
        # Input is a series of lists as named arguments
        # output is a dictionary defining each combination, preserving names
        #
        # lengths of each input list
        listLens = [len(e) for e in kwargs.itervalues()] 
        # multiply all list lengths together to get total number of combinations
        nCombos = reduce((lambda x, y: x * y), listLens) 
        iDict = {}
        nTimesRepEachValue=1 #initialize as repeating only once
        for key in kwargs.keys():
            nTimesRepList=nCombos/(len(kwargs[key])*nTimesRepEachValue)
            tempVals=[] #temporary list to store repeated
            for v in range(nTimesRepList):
                indicesToAdd=reduce((lambda x,y: list(x)+list(y)),[repeat(x, nTimesRepEachValue) for x in kwargs[key]])
                tempVals=tempVals+indicesToAdd
            iDict[key] = tempVals
            # Accumulating the number of times needed to repeat each value
            nTimesRepEachValue=len(kwargs[key])*nTimesRepEachValue
        return iDict
    #Example usage:
    expandedDict=expandGrid(letters=["a","b","c","d"],nums=[1,2,3],both=["v",3])