How to pick random non-duplicating samples containing one element from each group?

Below is the list say my_list. Max items or max length of my_list could be 1 million.

[
	['N1', 'C1'], 
	['N2', 'C2'], 
	['N3', 'C1'], 
	['N4', 'C1'], 
	['N5', 'C1'], 
	['N6', 'C2'], 
	['N7', 'C1']
]

I want to pick two samples from this list where the first one has C1 and the second has C2. I will be picking the 2 samples 80 million times. In the given my_list the first item i.e the ones starting with N* will always be unique. Whereas, the final output pair I'm looking should not have same or duplicate pair repeating. I will always want a unique pair.

The output could be:

N1 and N2

OR

N2 and N1

OR

N6 and N7

I've used random.sample() with list previously, but in this case I'm not sure how to apply condition as the list element are separated by ,.

If you need to do this multiple times for the same list, you could separate the list into groups and then select one from each group:

# This needs to be done once per my_list
groups = {}

for n, c in my_list:
    if c not in groups:
        groups[c] = []
    groups[c].append(n)

# this selects random elements from each group
result = tuple(random.choice(grp) for grp in groups.values())

For example, running the selection code 10 times gives:

for _ in range(10):
    # this selects random elements from each group
    result = tuple(random.choice(grp) for grp in groups.values())

    print(result)

('N5', 'N2')
('N7', 'N6')
('N5', 'N6')
('N7', 'N6')
('N4', 'N2')
('N5', 'N2')
('N1', 'N2')
('N7', 'N2')
('N1', 'N2')
('N1', 'N6')

This code can be put in a class to make it easier to use:

class GroupedSelect:
    def __init__(self, my_list):
        self.groups = {}
        for n, c in my_list:
            if c not in self.groups:
                self.groups[c] = []
            self.groups[c].append(n)

    def select(self):
        return tuple(random.choice(grp) for grp in self.groups.values())


my_selector = GroupedSelect(my_list)
for _ in range(10):
    print(my_selector.select())

To prevent duplicates, you're going to have to keep track of which elements have already been selected. One way to do this would be to figure out how many elements the product of all groups contains, and return one of those in random order.

Upon creating the GroupedSelect object, we

• Figure out how many combinations we will have. This is simply the product of the lengths of all groups.
• Create a list of indices of that length. For example, if we have 5 objects in group 1 and 2 in group 2, we have 10 combinations, so self._sel_indices is list(range(10)). Then shuffle this list
• Every time select() is called, we pop the last element of this list. Since popping the last element of a list is O(1), this is not an expensive operation.
  • If no more indices exist, then we can either reshuffle or raise an error.
• The popped index is converted to the individual coordinates in the groups. The logic for this is identical to that of numpy.unravel_index.
• Return the element at these coordinates.

import random
from functools import reduce

class GroupedSelect:
    def __init__(self, my_list, raise_error=False):
        self.groups = {}
        self._raise_error = raise_error
        for n, c in my_list:
            if c not in self.groups:
                self.groups[c] = []
            self.groups[c].append(n)

        self._shape = tuple(len(grp) for grp in self.groups.values())
        self._reshuffle()

    def _reshuffle(self):
        n_indices = reduce(lambda x, y: x*y, self._shape)
        
        # Create a list of all possible indices and shuffle it
        self._sel_indices = list(range(n_indices))
        random.shuffle(self._sel_indices)
        

    def select(self):
        try:
            # Get the next index to select
            index = self._sel_indices.pop()
        except IndexError as ex: 
            # If we've selected all possible indices, reshuffle everything and start over
            # or raise an error if needed
            if self._raise_error:
                raise RuntimeError("No more combinations to select") from ex
            self._reshuffle()
            index = self._sel_indices.pop()

        # Convert index to coordinates in each group
        coords = self._index_to_coords(index)
        
        # Select the correct value from each group and return it
        return tuple(grp[coord] for grp, coord in zip(self.groups.values(), coords))
     
    def _index_to_coords(self, index):
        # This function is a pure-python implementation of numpy.unravel_index
        coords = []
        for ss in reversed(self._shape):
            index, cc = divmod(index, ss)
            coords.append(cc)
        return coords[::-1]

To use this class such that it will throw an error after it runs out of combinations, do:

my_selector = GroupedSelect(my_list, True)
for _ in range(12):
    print(my_selector.select())

which gives:

('N3', 'N2')
('N5', 'N6')
('N4', 'N6')
('N1', 'N2')
('N4', 'N2')
('N5', 'N2')
('N7', 'N6')
('N3', 'N6')
('N7', 'N2')
('N1', 'N6')
Traceback (most recent call last):

  File "<file>", line 35, in select
    index = self._sel_indices.pop()

IndexError: pop from empty list

The above exception was the direct cause of the following exception:

Traceback (most recent call last):

  File "<file>", line 70, in <module>
    print(my_selector.select())

  File "<file>", line 40, in select
    raise RuntimeError("No more combinations to select") from ex
RuntimeError: No more combinations to select

You can catch a RuntimeError to prevent this traceback, or initialize the object with raise_error=False to re-shuffle and keep returning combinations, although these will be duplicates (but not in the same order as before):

my_selector = GroupedSelect(my_list, False)
for _ in range(12):
    print(my_selector.select())

outputs:

('N3', 'N2')
('N5', 'N6')
('N7', 'N2')
('N7', 'N6')
('N5', 'N2')
('N1', 'N2')
('N4', 'N6')
('N3', 'N6')
('N1', 'N6')
('N4', 'N2')
('N7', 'N6')
('N3', 'N6')

Use random.choice:

def pick_samples(all_choices):
    a = random.choice(all_choices)
    while True:
        b = random.choice(all_choices)
        if b[1] != a[1]:
            break
    return a[0], b[0]

If you're able, you can simplify by breaking the choices into two groups and choosing one from each:

c1_list = [c[0] for c in all_choices if c[1] == 'C1']
c2_list = [c[0] for c in all_choices if c[1] == 'C2']

def pick_samples(c1_list, c2_list):
    return random.choice(c1_list), random.choice(c2_list)