考虑到你的标签包含numpy，在大型数组上有一个更快的解决方案：

def combinations_with_replacement_(m, n, dtype=int):
    if n < 0:
        raise ValueError('n must be non-negative')
    if m < 0:
        raise ValueError('m must be non-negative')

    if n == 0:
        return np.empty((1, 0), dtype)

    shape = (math.comb(m + n - 1, n), n)
    out = np.zeros(shape, dtype)
    out[:m, -1] = np.arange(m, dtype=dtype)

    lengths = np.arange(1, m, dtype=np.intp)
    start = m
    for col in reversed(range(1, n)):
        block = out[:start, col:]
        for i, length in enumerate(reversed(lengths), 1):
            stop = start + length
            out[start:stop, col:] = block[-length:]
            out[start:stop, col - 1] = i
            start = stop
        lengths = lengths.cumsum()

    return out

字符串
对于小型数组，有一些棘手的加速方法，但它们会损失一些可读性：

from itertools import combinations_with_replacement, chain

def comb_with_rep_faster_on_small(m, n, dtype=int):
    it = combinations_with_replacement(range(m), n)
    flatten = chain.from_iterable(it)
    buffer = bytes(flatten)
    return np.frombuffer(buffer, np.uint8).astype(dtype).reshape(-1, n)

型
一个简单的比较方法：

from itertools import combinations_with_replacement

def comb_with_rep(m, n, dtype=int):
    return np.array(list(combinations_with_replacement(range(m), n)), dtype)

型
基准：

import perfplot

funcs = [
    comb_with_rep,
    comb_with_rep_faster_on_small,
    combinations_with_replacement_
]

perfplot.bench(
    kernels=funcs,
    n_range=list(range(1, 20)),
    setup=lambda n: (7, n),
    equality_check=np.array_equal
).show()

型

的数据

为了回答我自己的问题：一种方法是选择所有索引(i_1, i_2, ..., i_n)与i_1 <= i_2 <= ... <= i_n。伪代码是：

def perm_unique(m):

  index_list = []
  
  for i_1 in range(m):
    for i_2 in range(i_1, m):
      ...
        for i_n in range(i_{n-1}, m):
  
          index_list.append([i_1, i_2, ..., i_n])

  return index_list

字符串
注意事项：上面的伪代码需要预先知道n。一个更好的解决方案是将n作为perm_unique()的参数，但这需要递归，我不确定什么是最好的方法。
事实证明，解决方案非常简单。下面的代码就是这样做的：

index_list = list(itertools.combinations_with_replacement(range(m), n))

型