Python - перетасовать только некоторые элементы списка

Question

Я пытаюсь перетасовать только элементы списка с 3-й до последней позиции, поэтому первые две всегда будут оставаться на месте, например,

list = ['a?','b','c','d','e']

в

list = ['a?','b','d','e','c']

и дляпо какой-то причине это не работает:

list = ['a?','b','c','d','e']
import random
random.shuffle(list[2:])    
print list

Кто-нибудь знает, что я делаю не так?

Единственное, что работает для меня, это пока что (РЕДАКТИРОВАНИЕ):

lists = [['a?','b','c','d','e'],['1?','2','3','4','5','6','7']]
import random

for list in lists:
    copy = list[2:]
    random.shuffle(copy)
    list[2:] = copy

print lists

Думаю, это именно то, что мне нужно.

Answer 1

Если вы хотите перемешать без копирования, вы можете попытаться написать свой собственный класс изменяемых фрагментов, как показано ниже (это грубый эскиз реализации, без проверки границ и т. Д.):

class MutableSlice(object):
    def __init__(self, baselist, begin, end=None):
        self._base = baselist
        self._begin = begin
        self._end = len(baselist) if end is None else end

    def __len__(self):
        return self._end - self._begin

    def __getitem__(self, i):
        return self._base[self._begin + i]

    def __setitem__(self, i, val):
        self._base[i + self._begin] = val

Затем оберните исходный список в него и подайте в стандартном порядке:

>>> mylist = [1,2,3,4,5,6]
>>> slice = MutableSlice(mylist, 2)
>>> import random
>>> random.shuffle(slice)
>>> mylist
[1, 2, 4, 3, 5, 6]

Answer 2

Что вы делаете это:

copy = list[2:]
random.shuffle(copy)    

, что не имеет большого значения для первоначального списка. Попробуйте это:

copy = list[2:]
random.shuffle(copy)
list[2:] = copy # overwrite the original

Answer 3

Вы можете создать свою собственную функцию перемешивания, которая позволит вам перемешивать фрагмент в изменяемой последовательности.Он обрабатывает выборку копии среза и переназначение обратно на срез.Вы должны передать slice() аргументы вместо более привычных [2:] обозначений.

from random import sample
def myShuffle(x, *s):
    x[slice(*s)] = sample(x[slice(*s)], len(x[slice(*s)]))

использование:

>>> lst = ['a?','b','c','d','e']   #don't use list as a name
>>> myShuffle(lst, 2)              #shuffles lst[:2]
>>> lst
['b', 'a?', 'c', 'd', 'e']
>>> myShuffle(lst, 2, None)        #shuffles lst[2:]
>>> lst
['b', 'a?', 'd', 'e', 'c']

Answer 4

Чтобы перемешать фрагмент списка на месте, без копий, мы можем использовать Knuth shuffle :

import random
def shuffle_slice(a, start, stop):
    i = start
    while (i < stop-1):
        idx = random.randrange(i, stop)
        a[i], a[idx] = a[idx], a[i]
        i += 1

Он делает то же самое, что и random.shuffle, за исключением фрагмента:

>>> a = [0, 1, 2, 3, 4, 5]
>>> shuffle_slice(a, 0, 3)
>>> a
[2, 0, 1, 3, 4, 5]

Answer 5

l[2:] создает новый список, а random.shuffle пытается изменить список «на месте», что никак не влияет на сам l.

Вы можете использовать random.sample для этого:

l[2:] = random.sample(l[2:], len(l)-2)

Answer 6

Я скопировал функцию shuffle из random.shuffle и адаптировал ее так, что она будет перетасовывать список только в определенном диапазоне:

import random
a = range(0,20)
b = range(0,20)

def shuffle_slice(x, startIdx, endIdx):
    for i in reversed(xrange(startIdx+1, endIdx)):
       # pick an element in x[:i+1] with which to exchange x[i]
       j = random.randint(startIdx, i)
       x[i], x[j] = x[j], x[i]

#Shuffle from 5 until the end of a
shuffle_slice(a, 5, len(a))    
print a

#Shuffle b from 5 ... 15
shuffle_slice(b, 5, 15)
print b

Приведенный выше код перетасовывает элементы только в указанном диапазоне. Перестановка выполняется на месте, т. Е. Копия списка не создается.

Answer 7

Используя тот факт, что список быстро удаляется, вставляется и расширяется предыдущее решение (https://stackoverflow.com/a/25229111/3449962):

Элемент списка

• перечисляет фиксированные элементы и копирует их и их индекс
• удалить фиксированные элементы из списка
• перемешать оставшийся поднабор
• поместить фиксированные элементы обратно в

Это будет использовать операции с памятью на местеиздержки, которые зависят от количества фиксированных элементов в списке. Линейные по времени. Возможная более общая реализация shuffle_subset:

#!/usr/bin/env python
"""Shuffle elements in a list, except for a sub-set of the elments.

The sub-set are those elements that should retain their position in
the list.  Some example usage:

>>> from collections import namedtuple
>>> class CAnswer(namedtuple("CAnswer","x fixed")):
...             def __bool__(self):
...                     return self.fixed is True
...             __nonzero__ = __bool__  # For Python 2. Called by bool in Py2.
...             def __repr__(self):
...                     return "<CA: {}>".format(self.x)
...
>>> val = [3, 2, 0, 1, 5, 9, 4]
>>> fix = [2, 5]
>>> lst = [CAnswer(v, i in fix) for i, v in enumerate(val)]

>>> print("Start   ", 0, ": ", lst)
Start    0 :  [<CA: 3>, <CA: 2>, <CA: 0>, <CA: 1>, <CA: 5>, <CA: 9>, <CA: 4>]

Using a predicate to filter.

>>> for i in range(4):  # doctest: +NORMALIZE_WHITESPACE
...     shuffle_subset(lst, lambda x : x.fixed)
...     print([lst[i] for i in fix], end=" ")
...
[<CA: 0>, <CA: 9>] [<CA: 0>, <CA: 9>] [<CA: 0>, <CA: 9>] [<CA: 0>, <CA: 9>]

>>> for i in range(4):                # doctest: +NORMALIZE_WHITESPACE
...     shuffle_subset(lst)           # predicate = bool()
...     print([lst[i] for i in fix], end=" ")
...
[<CA: 0>, <CA: 9>] [<CA: 0>, <CA: 9>] [<CA: 0>, <CA: 9>] [<CA: 0>, <CA: 9>]

Exclude certain postions from the shuffle.  For example, exclude the
first two elements:

>>> fix = [0, 1]
>>> lst = [CAnswer(v, i in fix) for i, v in enumerate(val)]
>>> print("Start   ", 0, ": ", lst)
Start    0 :  [<CA: 3>, <CA: 2>, <CA: 0>, <CA: 1>, <CA: 5>, <CA: 9>, <CA: 4>]
>>> for i in range(4):                # doctest: +NORMALIZE_WHITESPACE
...     shuffle_subset(lst, fix)
...     print([lst[i] for i in fix], end=" ")
...
[<CA: 3>, <CA: 2>] [<CA: 3>, <CA: 2>] [<CA: 3>, <CA: 2>] [<CA: 3>, <CA: 2>]

Using a selector with the same number of elements as lst:

>>> fix = [0, 1]
>>> lst = [CAnswer(v, i in fix) for i, v in enumerate(val)]
>>> sel = [(i in fix) for i, _ in enumerate(val)]
>>> print("Start   ", 0, ": ", lst)
Start    0 :  [<CA: 3>, <CA: 2>, <CA: 0>, <CA: 1>, <CA: 5>, <CA: 9>, <CA: 4>]
>>> for i in range(4):                # doctest: +NORMALIZE_WHITESPACE
...     shuffle_subset(lst, sel)
...     print([lst[i] for i in fix], end=" ")
...
[<CA: 3>, <CA: 2>] [<CA: 3>, <CA: 2>] [<CA: 3>, <CA: 2>] [<CA: 3>, <CA: 2>]

A generator as selector works fine too:

>>> fix = [0, 1]
>>> lst = [CAnswer(v, i in fix) for i, v in enumerate(val)]
>>> print("Start   ", 0, ": ", lst)
Start    0 :  [<CA: 3>, <CA: 2>, <CA: 0>, <CA: 1>, <CA: 5>, <CA: 9>, <CA: 4>]
>>> for i in range(4):                # doctest: +NORMALIZE_WHITESPACE
...     sel = ((i in fix) for i, _ in enumerate(val))
...     shuffle_subset(lst, sel)
...     print([lst[i] for i in fix], end=" ")
...
[<CA: 3>, <CA: 2>] [<CA: 3>, <CA: 2>] [<CA: 3>, <CA: 2>] [<CA: 3>, <CA: 2>]

"""
from __future__ import print_function
import random


def shuffle_subset(lst, predicate=None):
    """All elements in lst, except a sub-set, are shuffled.

    The predicate defines the sub-set of elements in lst that should
    not be shuffled:

      + The predicate is a callable that returns True for fixed
      elements, predicate(element) --> True or False.

      + If the predicate is None extract those elements where
      bool(element) == True.

      + The predicate is an iterable that is True for fixed elements
      or len(predicate) == len(lst).

      + The predicate is a list of indices of fixed elements in lst
      with len(predicate) < len(lst).

    """
    def extract_fixed_elements(pred, lst):
        try:
            if callable(pred) or pred is None:
                pred = bool if pred is None else pred
                fixed_subset = [(i, e) for i, e in enumerate(lst) if pred(e)]
            elif (hasattr(pred, '__next__') or len(pred) == len(lst)):
                fixed_subset = [(i, lst[i]) for i, p in enumerate(pred) if p]
            elif len(pred) < len(lst):
                fixed_subset = [(i, lst[i]) for i in pred]
            else:
                raise TypeError("Predicate {} not supported.".format(pred))
        except TypeError as err:
            raise TypeError("Predicate {} not supported. {}".format(pred, err))
        return fixed_subset
    #
    fixed_subset = extract_fixed_elements(predicate, lst)
    fixed_subset.reverse()      # Delete fixed elements from high index to low.
    for i, _ in fixed_subset:
        del lst[i]
    random.shuffle(lst)
    fixed_subset.reverse()      # Insert fixed elements from low index to high.
    for i, e in fixed_subset:
        lst.insert(i, e)


if __name__ == "__main__":
    import doctest
    doctest.testmod()

Answer 8

Попробуйте это .. это намного проще и не делает никаких копий списка.
Вы можете сохранить любой из элементов фиксированным, просто поиграв с индексами списка.

работает:

1. создать новый список только тех элементов, которые вы хотите перемешать.

2. перемешать новый список.

3. удалите те элементы, которые вы хотели перетасовать из исходного списка.

4. вставьте вновь созданный список в старый список с соответствующим индексом

    import random
    list = ['a?', 'b', 'c', 'd', 'e']

    v = []
    p = [v.append(list[c]) for c in range(2,len(list))] #step 1
    random.shuffle(v)  #step 2
    for c in range(2,len(list)):
        list.remove(list[c])  #step 3
        list.insert(c,v[c-2]) #step 4    #c-2 since the part to be shuffled begins from this index of list

    print(list)