Discussion :

[nina29000]

bonjour,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[wiztricks]

Salut,

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

[fred1599]

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.

[BamBi25]

Hello,

je te propose une solution un peux plus flexible:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[fred1599]

Bonjour,

une solution un peux plus flexible

Que veux-tu dire par plus flexible ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[BamBi25]

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

[Sve@r]

Bonjour

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 python :

Sélectionner tout - Visualiser dans une fenêtre à part

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 python :

Sélectionner tout - Visualiser dans une fenêtre à part

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'})

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 !!!

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

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 python :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

...

[fred1599]

Moi j'ai ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Sve@r]

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.
Maintenant si c'est le cas alors oui c'est "plus flexible" que la mienne

[fred1599]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[Sve@r]

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)))]