J'ai une liste L = [A, B, C] et je veux générer une liste de tuples:
[(a,a), (a,b), (a,c), (b,a), (b,b), (b,c)...]
7 Réponses :
Jetez un coup d'œil au module donne: p> iTertools code>, qui fournit un membre produit code>. [(1,1),(1,2),(1,3),(2,1), .... and so on]
the itTools code> module contient un certain nombre de fonctions utiles Pour ce genre de chose. On dirait que vous recherchez peut-être produit code> a >: >>> import itertools
>>> L = [1,2,3]
>>> itertools.product(L,L)
<itertools.product object at 0x83788>
>>> list(_)
[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]
Vous pouvez le faire avec une compréhension de liste: Vous pouvez également utiliser itheroTools.Product comme d'autres ont suggéré, Mais seulement si vous utilisez 2.6 à partir de 2.6. La compréhension de la liste fonctionnera toutes les versions de Python à partir de 2.0. Si vous utilisez itheroTools.Produité, gardez à l'esprit qu'il renvoie un générateur au lieu d'une liste, vous devrez peut-être le convertir (en fonction de ce que vous voulez faire avec elle).
x = [a, b, c] y = [] Pour l'article dans x: Pour l'élément2 dans x: y.append ((élément, élément2))
Peut-être pas la voie pythonique mais travaillant
OK j'ai essayé:
l2 = [(x, y) pour x dans L pour x dans l] et ceci got l carré.
Est-ce la meilleure façon pythononique de faire cela? Je m'attendrais à ce que je travaille à Python.
Mauvaise attente - Séquence * Séquence est NOT Défini (seulement Séquence * int , qui fait quelque chose très différent! -).
Oups, a écrit cela avant de voir les réponses. Merci d'ignorer
Deux alternatives principales:
>>> L = ['a', 'b', 'c']
>>> import itertools
>>> list(itertools.product(L, L))
[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'b'), ('b', 'c'), ('c', 'a'), ('c', 'b'), ('c', 'c')]
>>> [(one, two) for one in L for two in L]
[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'b'), ('b', 'c'), ('c', 'a'), ('c', 'b'), ('c', 'c')]
>>>
L'utilisation d'itheroTools vous semble étrange pour moi si vous allez simplement convertir directement à une liste de toute façon. La compréhension de la liste est probablement plus efficace, tout aussi lisible et probablement plus maintenue en ce sens que vous pouvez faire directement à l'expression. Plus d'abstraction peut signifier plus d'inflexibilité et tout le point est de masquer les détails que vous espoir (mais je ne peux pas être sûr), vous n'avez jamais besoin de vous inquiéter.
La manière la plus ancienne pour le faire serait:
def perm(L):
result = []
for i in L:
for j in L:
result.append((i,j))
return result
Toutes les approches de cela ont au mieux O (N ^ 2), la raison pour laquelle ils doivent tous générer des tuples O (n ^ 2). L'utilisation d'un itérateur tel que itertools vous permet de différer une partie de ce travail, mais vous ne pouvez pas l'éviter complètement. Votre approche peut même être O (n ^ 3) - Ajout à des listes pourrait bien être O (n) plutôt que O (1) en raison de problèmes de réaffectation de la mémoire, même si je ne me souviens pas avec certitude. Je pense la liste Python utilise une matrice redimensionnable - pas une liste liée. Il pourrait y avoir une sorte d'optimisation des appends, cependant. Une compréhension de la liste probablement préallocate l'ensemble du tableau au début.
Ce type de "produit" s'appelle également un "produit cartésien" ou "produit direct" (je ne suis pas sûr si un mandat ou l'autre est plus approprié ici, mais le DOC Python lui-même utilise "le produit cartésien")