[Python 3.X] Deux list en dict

Deux list en dict

bonjour,

Est il possible de transformer deux listes de longueur différentes ?
genre :
Code:

1 2 3 4 5 6 7 8 v = ['un', 'deux', 'trois', 'quatre', 'cinq', 'six'] k = ['s1', 's2', 's3'] array = [] for n in v: dictionary = dict(zip(k, v)) array.append(dictionary)
résultat obtenu : [{'s1': 'un', 's2': 'deux', 's3': 'trois'}, {'s1': 'un', 's2': 'deux', 's3': 'trois'}, {'s1': 'un', 's2': 'deux', 's3': 'trois'}, {'s1': 'un', 's2': 'deux', 's3': 'trois'}, {'s1': 'un', 's2': 'deux', 's3': 'trois'}, {'s1': 'un', 's2': 'deux', 's3': 'trois'}]
resultat esperé : [{'s1': 'un', 's2': 'deux', 's3': 'trois'}, {'s1': 'quatre', 's2': 'cinq', 's3': 'six'}]

où est ce que je me trompe ...???
Merci

Salut,

Citation:

Envoyé par nina29000

où est ce que je me trompe ...???

Si votre boucle crée un dictionnaire à chaque itération, avec for n in v vous allez créer 6 dictionnaires.
Si vous n'en vouliez que 2, c'est mal parti...

Si vous découpiez v en morceaux de longueur 3 (la taille de k), çà marcherait mieux puisque 2 = 6 / 3.

- W

Pour faire ce découpage qu'indique @wiztricks, le slicing est une méthode possible,

C'est déjà très bien d'avoir eu l'idée d'utiliser dict(zip(...)) pour faire cet exercice.

resultat

Hello,

je te propose une solution un peux plus flexible:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
def lePlusPetit(a, b):
    if len(a) < len(b):
        return a
    else:
        return b
 
 
def lePlusGrand(a, b):
    if len(a) > len(b):
        return a
    else:
        return b
 
loop = itertools.cycle(lePlusPetit(v, k))
c = [(next(loop), x) for x in lePlusGrand(v, k)]
print(c)

Bonjour,

Citation:

une solution un peux plus flexible

Que veux-tu dire par plus flexible ?
Citation:
Code:

1 2 3 4 5 def lePlusPetit(a, b): if len(a) < len(b): return a else: return b
Pour ton code, il ne répond pas au besoin du PO, pas sous la forme voulue...

Je vois des else inutiles dans ton code.

Fred, j’entend par flexible qu'il accepte deux listes peut importe qui est la plus grande et peux importe leur taille.

Effectivement les else sont inutile merci. :p

Bonjour
Citation:
Envoyé par nina29000
Est il possible de transformer deux listes de longueur différentes ?
genre :
Code:

1 2 v = ['un', 'deux', 'trois', 'quatre', 'cinq', 'six'] k = ['s1', 's2', 's3']
resultat esperé : [{'s1': 'un', 's2': 'deux', 's3': 'trois'}, {'s1': 'quatre', 's2': 'cinq', 's3': 'six'}]
Oui c'est possible. Mais attention aux détails car certes les deux listes sont de longueur différente mais la longueur de la seconde est un multiple parfait de la longueur de la première. Alors sera-ce toujours le cas ou est-ce juste un hasard ? La réponse à cette question conditionnera beaucoup l'algorithme.

Voici l'algorithme pour le cas le plus général (donc qui fonctionnera aussi ici)
Code:

1 2 3 4 5 6 7 8 v=("un", "deux", "trois", "quatre", "cinq", "six", "sept") k=("s1", "s2", "s3") d=tuple( (dict(zip(k, v[i*len(k):(i+1)*len(k)]))) for i in range((len(v) - 1) // len(k) + 1) ) print(d)
résultat: ({'s1': 'un', 's2': 'deux', 's3': 'trois'}, {'s1': 'quatre', 's2': 'cinq', 's3': 'six'}, {'s1': 'sept'})

Et pour le cas particulier où v est toujours multiple de k
Code:

1 2 3 4 5 6 7 8 v=("un", "deux", "trois", "quatre", "cinq", "six") k=("s1", "s2", "s3") d=tuple( (dict(zip(k, v[i*len(k):(i+1)*len(k)]))) for i in range(len(v) // len(k)) ) print(d)
résultat: ({'s1': 'un', 's2': 'deux', 's3': 'trois'}, {'s1': 'quatre', 's2': 'cinq', 's3': 'six'})

Citation:

Envoyé par BamBi25

je te propose une solution un peux plus flexible

plus flexible que quoi ? un comparatif "plus" implique une comparaison sinon ta phrase ne veut rien dire !!!
Citation:
Envoyé par BamBi25
Code:

1 2 3 4 5 6 7 8 9 10 11 def lePlusPetit(a, b): if len(a) < len(b): return a else: return b def lePlusGrand(a, b): if len(a) > len(b): return a else: return b
Voici une solution un peu (sans "x" à "peu" car ce n'est pas un verbe conjuqué mais un adverbe) plus flexible que la tienne (là il y a comparaison)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 def compar(a, o, b) import operator as op return a if { "<" : op.lt, ">" : op.gt, "<=" : op.le, ">=" : op.ge, }[o](len(a), len(b)) else b # compar() compar(x, "<", y) compar(x, ">", y)
...

Moi j'ai ça
Code:

1 2 3 4 5 v = ['un', 'deux', 'trois', 'quatre', 'cinq', 'six'] k = ['s1', 's2', 's3'] res = [dict(zip(k, n)) for n in (v[:len(k)], v[len(k):])] print(res)
EDIT: Après si la taille de k est modifié, il faudra adapter, et vérifier aussi si la taille de v est plus grande que k.

Citation:

Envoyé par fred1599

EDIT: Après si la taille de k est modifié, il faudra adapter, et vérifier aussi si la taille de v est plus grande que k.

Hé oui. Ta solution (bien que très élégante), part du principe que v sera toujours deux fois la taille de k. :P
Maintenant si c'est le cas alors oui c'est "plus flexible" que la mienne 8-)

Voilà plus flexible, j'ai pas le temps de faire tous les tests,
Code:

1 2 3 v_trim = [v[i:i+len(k)] for i in range(0, len(v), len(k))] res = [dict(zip(k, n)) for n in v_trim] print(res)

Citation:

Envoyé par fred1599

j'ai pas le temps de faire tous les tests

Je les ai faits pour toi. Ok, t'as gagné, ça fonctionne dans tous les cas (y compris mon premier exemple).
Mais... on peut éviter v_trim => res=[dict(zip(k, n)) for n in (v[i:i+len(k)] for i in range(0, len(v), len(k)))] :lahola:

Citation:

Envoyé par Sve@r

Je les ai faits pour toi. Ok, t'as gagné, ça fonctionne dans tous les cas (y compris mon premier exemple).
Mais... on peut éviter v_trim => res=[dict(zip(k, n)) for n in (v[i:i+len(k)] for i in range(0, len(v), len(k)))] :lahola:

On perd en lisibilité, et merci pour les tests ;)