limiting the number of combinations /permutations in python

You need to use itertools.islice, like this

itertools.islice(itertools.product( * big_list), 5000)

It doesn't create the entire list in memory, but it returns an iterator which consumes the actual iterable lazily. You can convert that to a list like this

list(itertools.islice(itertools.product( * big_list), 5000))

You could create a tiny wrapper around itertools.product

it = itertools.product( * big_list)
pg = (next(it) for _ in range(5000)) # generator expression

(next(it) for _ in range(5000)) returns a generator not capable of producing more than 5000 values. Convert it to list by using the list constructor

pl = list(pg)

or by wrapping the generator expression with square brackets (instead of round ones)

pl = [next(it) for _ in range(5000)] # list comprehension

Use any temporary variable and limit it

    from itertools
    import permutations
    m = ['a', 'b', 'c', 'd']
    per = permutations(m)
    temp = 1
    for i in list(per):
       if temp <= 2: #2 is the limit set
           print (i)
           temp= temp + 1
    else:
       break

Suggestion : 2

For what you are trying to do, what qualifies as a combination? Does a combination consist of 33 ones, 33 twos and 66 zeros, but in any order?,Letters are like there are 33 ones, 33 twos and 66 zeros amounting to total letters 132. If I do it manually, there will be a lot of combinations. To make it easy for computer I want to limit combinations no to 1000. Plz help. my_letters=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2],… there will be a lot of combinations.,Technically, the different orders of the same numbers of each kind of object are known as permutations. Is this what is needed here?

Sorry Ali123, I have no idea what you are talking about here. Your
variable letters doesn’t have any letters in it, it is a list with a
single large number:

11111111111111111111111111

Let’s create 1000 combinations of letters, but to save space, we will display only 10 of those combinations.

import random
combos = []
for k in range(1000):
   letters = [random.randint(0, 1) for i in range(26)]
combo = "".join([chr(i + ord("A")) for i in range(26) if letters[i] == 1])
combos.append(combo)
for i in range(10):
   print(combos[i])

Output:

BEFHJNXZ
ABCFGHIORUVW
BDEFKNQRSTYZ
ABCHKLMORSTUVWXY
ADFHKMNOPQRSTUZ
EFKLMNOSUVWZ
CDEGHIJLMQVW
CDGHIKLMNOPRSTUVXZ
ABIJKOPQRSVXYZ
BCDEGIKMPTVWXY

Suggestion : 3

In the above techniques to calculate permutations, we are including all the numbers or letters. There is a possibility to restrict the number of elements in the permutations.,Permutation mathematically refers to “the arrangement of certain numbers or letters”. The permutations() function in the itertools library does exactly that.,The permuatations() function takes an iterable argument, therefore in order to find out permutations of numbers, we need to pass the numbers as a list, set, or tuple.,In the above code snippet, the permutations() function is asked to arrange only 2 elements at a time from the list of numbers provided.

import itertools

import itertools

st = "ABC"

per = itertools.permutations(st)

for val in per:
   print( * val)

A B C
A C B
B A C
B C A
C A B
C B A

<itertools.permutations object at 0x7fc9abdd8308>

import itertools

values = [1, 2, 3]

per = itertools.permutations(values)

for val in per:
   print( * val)

Suggestion : 4

Last Updated : 19 Jul, 2022

Output:

(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)

Output:

(1, 2)
(1, 3)
(2, 1)
(2, 3)
(3, 1)
(3, 2)

Output:

(1, 1)
(1, 2)
(1, 3)
(2, 2)
(2, 3)
(3, 3)

Suggestion : 5

Permutation is the method of selecting elements from a set in different ways.,For example: the number of ways in which characters from yup can be selected are yup, ypu, uyp, upy, puy, pyu, and not selecting any.,The elements of words are swapped. In this way, we achieve all different combinations of characters.,In this example, recursion is used to find the permutations of a string yup.

Example 1: Using recursion

def get_permutation(string, i = 0):

   if i == len(string):
   print("".join(string))

for j in range(i, len(string)):

   words = [c
      for c in string
   ]

# swap
words[i], words[j] = words[j], words[i]

get_permutation(words, i + 1)

print(get_permutation('yup'))

Output

yup
ypu
uyp
upy
puy
pyu
None

Example 2: Using itertools

from itertools
import permutations

words = [''.join(p) for p in permutations('pro')]

print(words)