des combinaisons entre les deux listes?

Ça fait un moment et j'ai du mal à enveloppant ma tête autour d'un algorithme que je vais essayer de le faire. En gros, j'ai deux listes et que vous souhaitez obtenir toutes les combinaisons de ces deux listes.

Je ne pourrais pas l'expliquer, corriger alors, voici un exemple.

name = 'a', 'b'
number = 1, 2

la sortie serait dans ce cas:

1.  A1 B2
2.  B1 A2

La partie délicate est que je pourrais avoir plus d'éléments dans le “nom de variable” que les articles dans le “nombre” de la variable(nombre sera toujours égale ou inférieure à la variable de nom).

Je suis confus comment faire toutes les combinaisons (nested loop?) et encore plus confus sur la logique de déplacer les éléments dans le nom de la variable dans le cas où il y a plus d'éléments que le nom, ils sont dans la liste nombre de.

Je ne suis pas le meilleur programmeur mais je pense que je peux lui donner un coup si quelqu'un peut m'aider à clarifier la logique/algoriythm pour atteindre cet objectif. J'ai été coincé sur des boucles for imbriquées.

Mise à jour:

Voici la sortie avec 3 variables et 2 numéros:

name = 'a', 'b', 'c'
number = 1, 2

de sortie:

1.  A1 B2
2.  B1 A2
3.  A1 C2
4.  C1 A2
5.  B1 C2
6.  C1 B2

docs.python.org/library/itertools.html
J'ai vu, et a trouvé des exemples un peu similaire objectifs à l'aide d'itertools mais je suis prototypage en python, mais va écrire le code final dans une autre langue, donc je ne veux pas utiliser des outils qui ne sont pas bénéficier elseway.
Ce que vous demandez n'a pas vraiment de sens. Si la première liste contient A,B,C et le deuxième contient du 1,2, quel résultat attendez-vous? Il pourrait être fait si l'exemple que vous avez donné a 4 résultats d'une lettre et d'un numéro de chacun (A1, A2, B1, B2), ou si les deux listes devaient avoir la même taille.
Je suis d'accord avec interjay. Veuillez indiquer le résultat de la non-taille égale cas, sinon il n'est pas possible de fournir une solution générale.
Salut tout le monde, j'ai mis à jour la réponse à montrer la sortie avec 3 noms et les 2 numéros..j'ai pensé que je vous l'explique bien, ne sais pas pourquoi le downvote.
Comment la sortie de l'air pour name = 'a', 'b', 'c' et number = 1, 2, 3?
La commande est vraiment important ou est-ce suffisant pour générer toutes les "combinaisons" que voulez-vous? Aussi A1 B2 == B2 A1?
il devrait ressembler à l'exemple que j'avais au-dessus avec les 2 noms et 2 chiffres, mais au lieu de 4 résultats il n'y aurait plus parce qu'il y a 3 éléments dans la liste nombre de. bakuriu L'ordre n'a pas vraiment d'importance, en essayant de capturer les combinaisons.
Note pour les futurs gens de dup-ing questions à ceci: Il ya une bonne chance que Obtenir le produit cartésien d'une série de listes? c'est mieux en double cible (beaucoup de trucs qui doivent utiliser product est dupliqué ici, même si cette question n'est pas correctement résolu de cette façon). Dans des cas plus rares, Tous les substituts possibles des deux listes? peut-être mieux (lors de la sélection d'une valeur d'une des deux listes à chaque indice, qui est un product solution à nouveau, avec un zip prepass).

InformationsquelleAutor user1735075 | 2012-10-17

55

Supposons que len(list1) >= len(list2). Ensuite, ce que vous semblez vouloir, c'est de prendre toutes les permutations de longueur len(list2) de list1 et de les associer à des éléments de la liste 2. En python:
```
import itertools
list1=['a','b','c']
list2=[1,2]

[zip(x,list2) for x in itertools.permutations(list1,len(list2))]
```
Retourne
```
[[('a', 1), ('b', 2)], [('a', 1), ('c', 2)], [('b', 1), ('a', 2)], [('b', 1), ('c', 2)], [('c', 1), ('a', 2)], [('c', 1), ('b', 2)]]
```
- Le résultat est exactement ce que je veux, mais est-il possible de partager la logique derrière comment le faire? Si je convertir mon code pour le C ou le Java, je n'aurai pas accès à zip ou itertools(bien qu'ils rendent la vie très très facile)
- Jetez un oeil à la documentation
- savez-vous que python est-il open source? Ainsi, vous pouvez simplement télécharger les sources et voir ce qu'ils font. +1 pour M. Steak de remarquer que la documentation a fait un exemple de mise en œuvre qui n'utilise pas zip et similaires.
- génial..ils documentent leur algorithme. très utile merci interjay et monsieur. steak!
- j'ai littéralement ne peut pas obtenir que cela fonctionne, même avec votre exemple... tout ce que j'obtiens une liste de zip objet.. 😐
- quelle devrait être la solution retenue.
InformationsquelleAutor interjay
379

La façon la plus simple est d'utiliser itertools.product:
```
a = ["foo", "melon"]
b = [True, False]
c = list(itertools.product(a, b))
>> [("foo", True), ("foo", False), ("melon", True), ("melon", False)]
```
- L'OP n'a pas été demandé pour un produit Cartésien, et cette réponse (ainsi que la plupart des autres) ne donne pas le résultat attendu est précisé dans la question.
- vous êtes très à droite, mais comme trop de gens semblent trouver que cette réponse est correcte, alors je ne peux que supposer que le titre de la question est le manque de contexte.
- Le titre est trop court pour tout expliquer. C'est pourquoi vous avez besoin de lire la question.
- L'OP voulait permuations, mais Google envoie quelqu'un à la recherche pour les combinaisons (comme moi) de cette réponse - heureux de voir qu'il a 8 fois la voix!
InformationsquelleAutor DrIDK
107

Peut être plus simple que le plus simple ci-dessus:
```
>>> a = ["foo", "bar"]
>>> b = [1, 2, 3]
>>> [(x,y) for x in a for y in b]
[('foo', 1), ('foo', 2), ('foo', 3), ('bar', 1), ('bar', 2), ('bar', 3)]
```
sans aucune importation
- La meilleure solution! Merci!!!! D'autres solutions sont simplement faux ou ne fonctionnent que dans des cas spécifiques tels que a > b etc.
- La plupart des Pythonic solution! (et évite les importations)
- Le temps de la complexité est O(n^2)
- Paris de solution!! Nu basics est la meilleure façon toujours
InformationsquelleAutor logic

Je cherchais une liste multiplié par lui-même avec uniquement des combinaisons uniques, qui est fournie dans cette fonction.

import itertools
itertools.combinations(list, n_times)

Ici qu'un extrait de le Python docs sur itertools Qui peut vous aider à trouver ce que vous cherchez.

Combinatoric generators:

Iterator                                 | Results
-----------------------------------------+----------------------------------------
product(p, q, ... [repeat=1])            | cartesian product, equivalent to a 
                                         |   nested for-loop
-----------------------------------------+----------------------------------------
permutations(p[, r])                     | r-length tuples, all possible 
                                         |   orderings, no repeated elements
-----------------------------------------+----------------------------------------
combinations(p, r)                       | r-length tuples, in sorted order, no 
                                         |   repeated elements
-----------------------------------------+----------------------------------------
combinations_with_replacement(p, r)      | r-length tuples, in sorted order, 
                                         | with repeated elements
-----------------------------------------+----------------------------------------
product('ABCD', repeat=2)                | AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
permutations('ABCD', 2)                  | AB AC AD BA BC BD CA CB CD DA DB DC
combinations('ABCD', 2)                  | AB AC AD BC BD CD
combinations_with_replacement('ABCD', 2) | AA AB AC AD BB BC BD CC CD DD

InformationsquelleAutor ThorSummoner

Vous pourriez vouloir essayer une une ligne de la liste de compréhension:

>>> [name+number for name in 'ab' for number in '12']
['a1', 'a2', 'b1', 'b2']
>>> [name+number for name in 'abc' for number in '12']
['a1', 'a2', 'b1', 'b2', 'c1', 'c2']

InformationsquelleAutor Idanmel

une petite amélioration pour la réponse de interjay, pour rendre le résultat comme un aplatir liste.

>>> list3 = [zip(x,list2) for x in itertools.permutations(list1,len(list2))]
>>> import itertools
>>> chain = itertools.chain(*list3)
>>> list4 = list(chain)
[('a', 1), ('b', 2), ('a', 1), ('c', 2), ('b', 1), ('a', 2), ('b', 1), ('c', 2), ('c', 1), ('a', 2), ('c', 1), ('b', 2)]

de référence à partir de ce lien

InformationsquelleAutor Mass Zhou

Sans itertools

[(list1[i], list2[j]) for i in xrange(len(list1)) for j in xrange(len(list2))]

InformationsquelleAutor user3684792

De répondre à la question "étant donné deux listes, retrouvez toutes les permutations possibles de paires d'un élément de chaque liste" et l'utilisation de base de la fonctionnalité Python (c'est à dire, sans itertools) et, par conséquent, le rendant facile à reproduire pour d'autres langages de programmation:

def rec(a, b, ll, size):
    ret = []
    for i,e in enumerate(a):
        for j,f in enumerate(b):
            l = [e+f]
            new_l = rec(a[i+1:], b[:j]+b[j+1:], ll, size)
            if not new_l:
                ret.append(l)
            for k in new_l:
                l_k = l + k
                ret.append(l_k)
                if len(l_k) == size:
                    ll.append(l_k)
    return ret

a = ['a','b','c']
b = ['1','2']
ll = []
rec(a,b,ll, min(len(a),len(b)))
print(ll)

Retourne

[['a1', 'b2'], ['a1', 'c2'], ['a2', 'b1'], ['a2', 'c1'], ['b1', 'c2'], ['b2', 'c1']]

InformationsquelleAutor computerist

Vous devez vous connecter pour publier un commentaire.