A Comprehensive Guide to Python's `random.choices()` Method

random.choices(population, weights=None, *, cum_weights=None, k=1)

import random
 
# Basic selection from a list
fruits = ['apple', 'banana', 'orange', 'grape']
selected = random.choices(fruits, k=2)
print(selected)  # Example output: ['banana', 'apple']
 
# Selecting from a string
letters = 'ABCDE'
selected_letters = random.choices(letters, k=3)
print(selected_letters)  # Example output: ['C', 'A', 'D']
 
# Multiple selections (note: same element can appear multiple times)
multiple_selections = random.choices(fruits, k=5)
print(multiple_selections)  # Example output: ['orange', 'banana', 'orange', 'grape', 'apple']

# This ensures no duplicates (without replacement)
unique_selection = random.sample(fruits, k=2)
print(unique_selection)  # Will always have 2 different fruits

import random
 
# Population with weights
colors = ['red', 'green', 'blue']
weights = [10, 3, 1]  # red is 10x more likely than blue
 
# Select with weighted probabilities
selected_color = random.choices(colors, weights=weights, k=1)[0]
print(f"Selected color: {selected_color}")
 
# Multiple selections with weights
multiple_colors = random.choices(colors, weights=weights, k=10)
print(f"10 selections: {multiple_colors}")

# Simulating a dice with biased probabilities
dice_faces = [1, 2, 3, 4, 5, 6]
# Weights favoring higher numbers
dice_weights = [1, 1, 2, 2, 3, 3]
 
# Roll the biased dice 20 times
rolls = random.choices(dice_faces, weights=dice_weights, k=20)
print(f"Biased dice rolls: {rolls}")
 
# Calculate distribution
from collections import Counter
distribution = Counter(rolls)
print(f"Distribution: {distribution}")

# Weights don't need to sum to 1 - they're automatically normalized
population = ['A', 'B', 'C']
weights = [100, 50, 25]  # These will be normalized to probabilities
 
# The actual probabilities become:
# A: 100/(100+50+25) = ~0.57
# B: 50/(100+50+25) = ~0.29  
# C: 25/(100+50+25) = ~0.14
 
selections = random.choices(population, weights=weights, k=1000)
count = Counter(selections)
print(f"Empirical probabilities: {count}")

import random
 
population = ['A', 'B', 'C', 'D']
 
# Regular weights
weights = [2, 1, 3, 1]
 
# Equivalent cumulative weights
cum_weights = [2, 3, 6, 7]  # Cumulative sum: 2, 2+1=3, 3+3=6, 6+1=7
 
# Both methods produce the same distribution
result1 = random.choices(population, weights=weights, k=1000)
result2 = random.choices(population, cum_weights=cum_weights, k=1000)
 
# Verify they're equivalent
from collections import Counter
print("Weights method:", Counter(result1))
print("Cum_weights method:", Counter(result2))

# Cumulative weights are more efficient for large populations
large_population = list(range(1000))
 
# Regular weights (less efficient for large n)
weights = [i+1 for i in range(1000)]  # Linear weights
 
# Cumulative weights (more efficient)
import itertools
cum_weights = list(itertools.accumulate(range(1, 1001)))
 
# For large k, cum_weights can be faster
selected = random.choices(large_population, cum_weights=cum_weights, k=10000)

def recommend_items(user_preferences, items, preference_weights, k=5):
    """
    Simple recommendation system using weighted random selection
    """
    # Combine user preferences with base weights
    combined_weights = [preference_weights.get(item, 1) for item in items]
    
    # Select recommendations
    recommendations = random.choices(items, weights=combined_weights, k=k)
    return list(dict.fromkeys(recommendations))  # Remove duplicates while preserving order
 
# Example usage
items = ['movie_A', 'movie_B', 'movie_C', 'movie_D', 'movie_E']
user_weights = {'movie_A': 5, 'movie_C': 3, 'movie_E': 2}
 
recommendations = recommend_items(user_weights, items, user_weights, k=3)
print(f"Recommended: {recommendations}")

class LootSystem:
    def __init__(self):
        self.loot_table = {
            'common': ['Health Potion', 'Mana Potion', 'Gold Coin'],
            'rare': ['Magic Sword', 'Enchanted Shield', 'Dragon Scale'],
            'epic': ['Legendary Artifact', 'Ancient Relic', 'Dragon Egg']
        }
        self.rarity_weights = {
            'common': 70,
            'rare': 25, 
            'epic': 5
        }
    
    def generate_loot(self, k=3):
        # First select rarity
        rarities = list(self.rarity_weights.keys())
        weights = list(self.rarity_weights.values())
        selected_rarities = random.choices(rarities, weights=weights, k=k)
        
        # Then select specific items from each rarity
        loot = []
        for rarity in selected_rarities:
            item = random.choice(self.loot_table[rarity])
            loot.append(f"{rarity.title()}: {item}")
        
        return loot
 
# Usage
loot_system = LootSystem()
print("Loot dropped:", loot_system.generate_loot())

def assign_variant(user_id, variants, weights):
    """Assign users to A/B test variants using weighted random selection"""
    # Use user_id as seed for consistent assignment
    random.seed(user_id)
    variant = random.choices(variants, weights=weights, k=1)[0]
    random.seed()  # Reset seed
    return variant
 
# A/B test configuration
variants = ['control', 'variant_a', 'variant_b']
weights = [40, 30, 30]  # 40% control, 30% each variant
 
# Assign users
users = ['user_001', 'user_002', 'user_003']
for user in users:
    variant = assign_variant(user, variants, weights)
    print(f"{user} assigned to: {variant}")

import pandas as pd
import numpy as np
 
def stratified_weighted_sample(df, strata_column, weight_column, sample_size):
    """
    Create a stratified weighted sample from a DataFrame
    """
    samples = []
    
    for stratum in df[strata_column].unique():
        stratum_data = df[df[strata_column] == stratum]
        indices = list(stratum_data.index)
        
        if len(indices) > 0:
            weights = stratum_data[weight_column].values
            sampled_indices = random.choices(indices, weights=weights, 
                                           k=min(sample_size, len(indices)))
            samples.extend(sampled_indices)
    
    return df.loc[samples]
 
# Example usage with sample data
data = {
    'category': ['A'] * 50 + ['B'] * 30 + ['C'] * 20,
    'value': np.random.rand(100),
    'weight': np.random.randint(1, 10, 100)
}
df = pd.DataFrame(data)
 
sampled_df = stratified_weighted_sample(df, 'category', 'weight', 5)
print(f"Sampled data shape: {sampled_df.shape}")

import time
import random
 
def benchmark_choices(population_size, k_values):
    population = list(range(population_size))
    weights = [random.random() for _ in range(population_size)]
    
    results = {}
    for k in k_values:
        start_time = time.time()
        random.choices(population, weights=weights, k=k)
        end_time = time.time()
        results[k] = end_time - start_time
    
    return results
 
# Benchmark different scenarios
population_sizes = [100, 1000, 10000]
k_values = [10, 100, 1000]
 
for size in population_sizes:
    print(f"\nPopulation size: {size}")
    timings = benchmark_choices(size, k_values)
    for k, time_taken in timings.items():
        print(f"  k={k}: {time_taken:.6f} seconds")

# For very large populations, consider memory-efficient approaches
 
# Memory-efficient weighted selection for large populations
def memory_efficient_choices(population, weight_func, k=1):
    """
    For populations too large to fit weights in memory
    """
    selections = []
    for _ in range(k):
        # This is simplified - in practice, you'd need a more sophisticated approach
        max_weight = max(weight_func(x) for x in population)
        while True:
            candidate = random.choice(population)
            if random.random() < weight_func(candidate) / max_weight:
                selections.append(candidate)
                break
    return selections

def safe_choices(population, weights=None, cum_weights=None, k=1):
    """
    Safe wrapper around random.choices with validation
    """
    # Validate population
    if not population:
        raise ValueError("Population cannot be empty")
    
    # Validate k
    if k < 0:
        raise ValueError("k must be non-negative")
    
    # Validate weights
    if weights is not None:
        if len(weights) != len(population):
            raise ValueError("Weights and population must have same length")
        if any(w < 0 for w in weights):
            raise ValueError("Weights cannot be negative")
        if all(w == 0 for w in weights):
            raise ValueError("At least one weight must be positive")
    
    return random.choices(population, weights=weights, 
                         cum_weights=cum_weights, k=k)
 
# Usage with error handling
try:
    result = safe_choices([], k=1)
except ValueError as e:
    print(f"Error: {e}")

# For reproducible results, always set the seed
random.seed(42)  # Any fixed number
result1 = random.choices(['A', 'B', 'C'], k=5)
 
random.seed(42)  # Reset to same seed
result2 = random.choices(['A', 'B', 'C'], k=5)
 
print(f"Result 1: {result1}")
print(f"Result 2: {result2}")
print(f"Results are identical: {result1 == result2}")

# Edge case: Single element population
single_element = random.choices(['only_choice'], k=3)
print(f"Single element: {single_element}")
 
# Edge case: k=0
empty_selection = random.choices(['A', 'B', 'C'], k=0)
print(f"k=0: {empty_selection}")
 
# Edge case: All weights zero (should be handled)
try:
    problematic = random.choices(['A', 'B'], weights=[0, 0], k=1)
except ValueError as e:
    print(f"Handled error: {e}")

import random
 
population = ['A', 'B', 'C', 'D', 'E']
 
# random.choices() - with replacement
choices_result = random.choices(population, k=10)
print(f"choices() - can have duplicates: {choices_result}")
 
# random.sample() - without replacement
sample_result = random.sample(population, k=3)  # k cannot exceed population size
print(f"sample() - no duplicates: {sample_result}")
 
# random.choice() - single selection
single_result = random.choice(population)
print(f"choice() - single element: {single_result}")

import timeit
 
population = list(range(1000))
 
# Benchmark choices vs sample for different k values
k_values = [10, 100, 500]
 
for k in k_values:
    choices_time = timeit.timeit(
        lambda: random.choices(population, k=k), number=1000
    )
    
    if k <= len(population):
        sample_time = timeit.timeit(
            lambda: random.sample(population, k=k), number=1000
        )
    else:
        sample_time = float('inf')
    
    print(f"k={k}: choices={choices_time:.4f}s, sample={sample_time:.4f}s")

# Incorrect - will raise ValueError
try:
    population = ['A', 'B', 'C']
    weights = [1, 2]  # Missing weight for 'C'
    result = random.choices(population, weights=weights)
except ValueError as e:
    print(f"Error: {e}")
 
# Correct
population = ['A', 'B', 'C']
weights = [1, 2, 1]  # Correct number of weights
result = random.choices(population, weights=weights)
print(f"Correct usage: {result}")

# Incorrect - negative weights
try:
    result = random.choices(['A', 'B'], weights=[1, -1])
except ValueError as e:
    print(f"Error: {e}")
 
# Correct - all weights non-negative
result = random.choices(['A', 'B'], weights=[1, 0])  # Zero is allowed
print(f"Non-negative weights: {result}")

# For very large k, consider memory usage
large_k = 1000000
population = ['A', 'B', 'C']
 
# This creates a list with 1 million elements
result = random.choices(population, k=large_k)
 
# For memory-constrained environments, generate on-the-fly
def stream_choices(population, weights=None, k=1):
    """Generator version for large k"""
    for _ in range(k):
        yield random.choices(population, weights=weights, k=1)[0]
 
# Usage
for i, choice in enumerate(stream_choices(population, k=large_k)):
    if i % 100000 == 0:
        print(f"Processed {i} items")