通过 itertools.permutations() 函数生成条件

注意：这个想法已经在评论中描述过。在我看来，我只想给出正确的实现。

我们将“第一个值”从列表中排除（如果存在）。我们生成没有它的排列，将其添加到每个排列的开头：

def limited_permutations(iterable, first_value, r=None):
    values = list(iterable)
    if first_value in values:
        i = values.index(first_value)
        values = values[:i] + values[i + 1:]
        if r is not None:
            r -= 1
    return (
        (first_value, ) + p
        for p in itertools.permutations(values, r=r)
    )

答案是根据@aleksandrbarakin的评论给出的。它由“General”标志表示。

# Суть алга - убирать первый элемент,  
# Генерировать без него, 
# А затем результаты добовлять этот элемент ко всем сгенерированным результатам 

def permutations(variants: list, v_len: int, first_element) -> list:
    variants.remove(first_element) # Удаляем "first_element"

    combinations = list(itertools.permutations(variants, v_len-1)) # Вычисляем
    combinations = [[first_element] + list(x) for x in combinations]

    return combinations

由于 itertools 不允许您进入生成器并添加检查，因此您需要自己制作。

以下是如何使用部分排列测试来制作排列生成器。

生成器递归地构建排列：

• 首先前缀为空
• 如果前缀的长度等于元素集合的长度，则返回前缀——排列构造完成
• 如果前缀小于元素集合，则返回以给定前缀开始的所有排列，将剩余元素一一添加到前缀中，并使用扩展前缀调用生成器。

谓词接收排列前缀并返回三个值之一：

• OH_SHIT：前缀违反了约束，无需构造以此前缀开头的其他排列。
• SHOOT_IT_BABY：已知以此前缀开头的所有排列都是正确的。无需检查子前缀。
• SO_FAR_SO_GOOD：前缀正确，但子前缀也需要检查。

我将从示例开始：

• 四个元素的所有排列：

  p_gen = permute(list("ABCD"))
  print(list(p_gen))
  

  [('A', 'B', 'C', 'D'), ('A', 'B', 'D', 'C'), ('A', 'C', 'B', 'D'), ('A', 'C', 'D', 'B'), ('A', 'D', 'B', 'C'), ('A', 'D', 'C', 'B'), ('B', 'A', 'C', 'D'), ('B', 'A', 'D', 'C'), ('B', 'C', 'A', 'D'), ('B', 'C', 'D', 'A'), ('B', 'D', 'A', 'C'), ('B', 'D', 'C', 'A'), ('C', 'A', 'B', 'D'), ('C', 'A', 'D', 'B'), ('C', 'B', 'A', 'D'), ('C', 'B', 'D', 'A'), ('C', 'D', 'A', 'B'), ('C', 'D', 'B', 'A'), ('D', 'A', 'B', 'C'), ('D', 'A', 'C', 'B'), ('D', 'B', 'A', 'C'), ('D', 'B', 'C', 'A'), ('D', 'C', 'A', 'B'), ('D', 'C', 'B', 'A')]
  

• 所有不以“A”开头的排列

  p_gen = permute(list("ABCD"), lambda lst: OH_SHIT if lst[0] == "A" else SHOOT_IT_BABY)
  print(list(p_gen))
  

  [('B', 'A', 'C', 'D'), ('B', 'A', 'D', 'C'), ('B', 'C', 'A', 'D'), ('B', 'C', 'D', 'A'), ('B', 'D', 'A', 'C'), ('B', 'D', 'C', 'A'), ('C', 'A', 'B', 'D'), ('C', 'A', 'D', 'B'), ('C', 'B', 'A', 'D'), ('C', 'B', 'D', 'A'), ('C', 'D', 'A', 'B'), ('C', 'D', 'B', 'A'), ('D', 'A', 'B', 'C'), ('D', 'A', 'C', 'B'), ('D', 'B', 'A', 'C'), ('D', 'B', 'C', 'A'), ('D', 'C', 'A', 'B'), ('D', 'C', 'B', 'A')]
  

• “B”在“C”之前的所有排列。

  p_gen = permute(
      list("ABCD"),
      lambda lst: OH_SHIT if 'C' in lst else SHOOT_IT_BABY if 'B' in lst else SO_FAR_SO_GOOD
  )
  print(list(p_gen))
  

  [('A', 'B', 'C', 'D'), ('A', 'B', 'D', 'C'), ('A', 'D', 'B', 'C'), ('B', 'A', 'C', 'D'), ('B', 'A', 'D', 'C'), ('B', 'C', 'A', 'D'), ('B', 'C', 'D', 'A'), ('B', 'D', 'A', 'C'), ('B', 'D', 'C', 'A'), ('D', 'A', 'B', 'C'), ('D', 'B', 'A', 'C'), ('D', 'B', 'C', 'A')]
  

• 以“C”结尾的排列除外

  p_gen = permute(
      list("ABCD"),
      lambda lst: OH_SHIT if (len(lst) == 4 and 'C' == lst[-1]) else SO_FAR_SO_GOOD
  )
  print(list(p_gen))
  

  [('A', 'B', 'C', 'D'), ('A', 'C', 'B', 'D'), ('A', 'C', 'D', 'B'), ('A', 'D', 'C', 'B'), ('B', 'A', 'C', 'D'), ('B', 'C', 'A', 'D'), ('B', 'C', 'D', 'A'), ('B', 'D', 'C', 'A'), ('C', 'A', 'B', 'D'), ('C', 'A', 'D', 'B'), ('C', 'B', 'A', 'D'), ('C', 'B', 'D', 'A'), ('C', 'D', 'A', 'B'), ('C', 'D', 'B', 'A'), ('D', 'A', 'C', 'B'), ('D', 'B', 'C', 'A'), ('D', 'C', 'A', 'B'), ('D', 'C', 'B', 'A')]
  

重新排列者

OH_SHIT = 0
SO_FAR_SO_GOOD = 1
SHOOT_IT_BABY = 2

def _assert_verdict(v: int) -> None:
    if v == OH_SHIT or v == SO_FAR_SO_GOOD or v == SHOOT_IT_BABY:
        return
    raise ValueError(f"Invalid verdict: {v}")

def _all_is_good(_):
    return SO_FAR_SO_GOOD

class _Permutator[T]:
    """Строит перестановки заданных элементов в соответствии с предикатом.
    
    Предикат получает префикс перестановки и возвращает одно из трёх значений:
    - OH_SHIT: префикс нарушает ограничение, не нужно строить остальные перестановки,
      которые начинаются с данного префикса.
    - SHOOT_IT_BABY: все перестановки, начинающиеся с  данного префикса, заведомо корректны.
      Дочерние префиксы проверять не нужно.
    - SO_FAR_SO_GOOD: префикс корректен, но дочерние префиксы тоже нужно проверять.
    
    Объект типа `_Permutator` является итерируемым. Обратный итератор не определён.
    """
    def __init__(self, lst: list[T], predicate: callable = _all_is_good):
        self.lst = lst
        self.predicate = predicate
        # Состояние перестановщика:
        # - текущий префикс перестановки
        self.prefix: List[T] = []
        # - индексы элементов, включенных в префикс
        self.idx_set : set[int] = set()
        # - состояние предиката
        self.check_state = SO_FAR_SO_GOOD

    def _mk_permut_recursive(self) -> Iterator[Tuple[T]]:
        """Рекурсивно строит все перестановки, удовлетворяющие предикату."""
        if len(self.prefix) == len(self.lst):
            # все элементы уже в префиксе, перестановка построена. Префикс проверен выше по стеку,
            # можно возвращать кортеж элементов без проверки предиката
            yield tuple(self.prefix)
            return
        
        for i in range(len(self.lst)):
            # Оптимизация проверки, что элемент `lst[i]` уже включен в префикс
            if i in self.idx_set:
                continue

            old_state = self.check_state
            try:
                # строим дочерний префикс
                self.prefix.append(self.lst[i])
                if self.check_state != SHOOT_IT_BABY:
                    # нужно проверить префикс
                    v = self.predicate(self.prefix)
                    _assert_verdict(v)
                    if v == OH_SHIT:
                        # префикс нарушает предикат,
                        # дальше перестановки с этим префиксом не строим.
                        continue
                    self.check_state = v
                # префикс корректен (либо состояние SHOOT_IT_BABY, либо вердикт != OH_SHIT)
                # Заносим индекс добавленного элемента в множество индексов перестановки
                self.idx_set.add(i)
                # возвращаем все перестановки с дочерним префиксом
                yield from self._mk_permut_recursive()
            finally:
                # Восстанавливаем состояние перестановщика
                self.prefix.pop()
                self.check_state = old_state
                self.idx_set.discard(i)

    def __iter__(self):
        return self._mk_permut_recursive()
    
    def __call__(self):
        return iter(self)

和一个包装函数

def permute[T](elems: list[T]|tuple[T], predicate: callable = _all_is_good) -> Iterator[Tuple[T]]:
    """Возвращает генератор перестановок, удовлетворяющих предикату.
    
    Предикат получает префикс перестановки и возвращает одно из трёх значений:
    - OH_SHIT: префикс нарушает ограничение, не нужно строить остальные перестановки,
      которые начинаются с данного префикса.
    - SHOOT_IT_BABY: все перестановки, начинающиеся с  данного префикса, заведомо корректны.
      Дочерние префиксы проверять не нужно.
    - SO_FAR_SO_GOOD: префикс корректен, но дочерние префиксы тоже нужно проверять.
    """
    return _Permutator(elems, predicate=predicate)

亚历山大·巴拉金（aleksandr barakin）评论中同一主题的变体，纯粹是出于itertools美观的目的，没有检查，我们假设该函数已经通过提前将数字与列表分开来以所需的方式调用，并且生成器获得生成器，以节省内存并在必要时保存提前终止：

from itertools import permutations, cycle, chain

def combinations(first, lst):
    for prefix, body in zip(cycle([first]), permutations(lst, len(lst))):
        yield chain([prefix], body)

for item in combinations(1, [2, 3]):
    print(list(item))

结论：

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

更新：我已经做了额外的事情，它更简单：

from itertools import permutations, chain

def combinations(first, lst):
    return (chain([first], body) for body in permutations(lst, len(lst)))

这实际上可以归结为斯坦尼斯拉夫·沃洛达尔斯基的回答，只是没有检查。好吧，我将把它作为一个应用示例cycle，chain以防它对某人派上用场。