Applications pratiques des combinaisons
Maintenant, explorons quelques applications pratiques de la fonction itertools.combinations(). Nous allons implémenter quelques exemples du monde réel pour démontrer comment cette fonction peut être utilisée pour résoudre des problèmes courants.
Imaginez que vous deviez former des équipes d'une certaine taille à partir d'un groupe de personnes. Créons un programme qui aide à former toutes les équipes possibles.
-
Créez un nouveau fichier nommé team_formation.py dans le répertoire /home/labex/project.
-
Ajoutez le code suivant :
import itertools
def form_teams(members, team_size):
"""Generate all possible teams of the specified size from the list of members."""
teams = list(itertools.combinations(members, team_size))
return teams
## List of team members
team_members = ["Alice", "Bob", "Charlie", "David", "Eva", "Frank"]
## Form teams of different sizes
pairs = form_teams(team_members, 2)
trios = form_teams(team_members, 3)
## Display the results
print(f"Total members: {len(team_members)}")
print(f"Members: {team_members}\n")
print(f"Possible pairs (teams of 2): {len(pairs)}")
for i, pair in enumerate(pairs, 1):
print(f"Team {i}: {' and '.join(pair)}")
print(f"\nPossible trios (teams of 3): {len(trios)}")
for i, trio in enumerate(trios, 1):
print(f"Team {i}: {', '.join(trio)}")
- Exécutez le script :
python3 team_formation.py
Vous devriez voir une sortie qui liste toutes les paires et tous les trios possibles qui peuvent être formés à partir des six membres de l'équipe.
Exemple 2 : Recherche de tous les sous-ensembles
Une autre application courante consiste à générer tous les sous-ensembles possibles d'un ensemble donné (également connu sous le nom d'ensemble des parties). Implémentons cela :
-
Créez un nouveau fichier nommé generate_subsets.py dans le répertoire /home/labex/project.
-
Ajoutez le code suivant :
import itertools
def generate_all_subsets(items):
"""Generate all possible subsets of the given items."""
all_subsets = []
## Empty set is always a subset
all_subsets.append(())
## Generate subsets of all possible lengths
for r in range(1, len(items) + 1):
subsets_of_length_r = list(itertools.combinations(items, r))
all_subsets.extend(subsets_of_length_r)
return all_subsets
## Sample set of items
items = ['A', 'B', 'C']
## Generate all subsets
subsets = generate_all_subsets(items)
## Display the results
print(f"Original set: {items}")
print(f"Total number of subsets: {len(subsets)}")
print("All subsets (including the empty set):")
for i, subset in enumerate(subsets):
if len(subset) == 0:
print(f"{i+1}. Empty set {{}}")
else:
print(f"{i+1}. {set(subset)}")
- Exécutez le script :
python3 generate_subsets.py
La sortie montrera tous les sous-ensembles possibles de l'ensemble {A, B, C}, y compris l'ensemble vide.
Créons une application pratique qui aide un restaurant à générer toutes les combinaisons de repas possibles à partir de ses éléments de menu :
-
Créez un nouveau fichier nommé menu_combinations.py dans le répertoire /home/labex/project.
-
Ajoutez le code suivant :
import itertools
def generate_meal_combinations(appetizers, main_courses, desserts):
"""Generate all possible meal combinations with one item from each category."""
meal_combinations = []
for app in appetizers:
for main in main_courses:
for dessert in desserts:
meal_combinations.append((app, main, dessert))
return meal_combinations
def generate_combo_deals(menu_items, combo_size):
"""Generate all possible combo deals of the specified size."""
return list(itertools.combinations(menu_items, combo_size))
## Menu categories
appetizers = ["Salad", "Soup", "Bruschetta"]
main_courses = ["Pasta", "Steak", "Fish"]
desserts = ["Ice Cream", "Cake", "Fruit"]
## All menu items
all_items = appetizers + main_courses + desserts
## Generate all possible three-course meals
meals = generate_meal_combinations(appetizers, main_courses, desserts)
## Generate all possible 2-item combo deals from the entire menu
combos = generate_combo_deals(all_items, 2)
## Display the results
print("Restaurant Menu Planner\n")
print("Menu Items:")
print(f"Appetizers: {appetizers}")
print(f"Main Courses: {main_courses}")
print(f"Desserts: {desserts}\n")
print(f"Total possible three-course meals: {len(meals)}")
print("Sample meals:")
for i in range(min(5, len(meals))):
app, main, dessert = meals[i]
print(f"Meal option {i+1}: {app} + {main} + {dessert}")
print(f"\nTotal possible 2-item combo deals: {len(combos)}")
print("Sample combo deals:")
for i in range(min(5, len(combos))):
print(f"Combo {i+1}: {' + '.join(combos[i])}")
- Exécutez le script :
python3 menu_combinations.py
La sortie montrera diverses combinaisons de repas et offres d'assortiment qui peuvent être créées à partir des éléments du menu.
Ces exemples démontrent comment la fonction itertools.combinations() peut être appliquée pour résoudre des problèmes du monde réel impliquant des combinaisons d'éléments. En comprenant comment utiliser efficacement cette fonction, vous pouvez développer des solutions plus efficaces pour les problèmes qui impliquent la sélection de groupes d'éléments à partir d'un ensemble plus large.
