Discussion :

[hugocallens]

Bonjour,

Je ne sais pas si ma question est simple ou compliquée... En fait j'aimerai "simplement" convertir cette liste de tuples :

s = [(0, 3), (2, 0), (2, 1), (2, 4), (3, 0), (3, 1), (3, 2), (4, 3)]

En une liste de sous listes qui se présenterait comme ceci :

s = [[(0, 3)], [(2, 0), (2, 1), (2, 4)], [(3, 0), (3, 1), (3, 2)], [(4, 3)]]

(pour plus de clarté)
s = [[(0, 3)],
[(2, 0), (2, 1), (2, 4)],
[(3, 0), (3, 1), (3, 2)],
[(4, 3)]]

Donc en fait créer une liste de sous listes basée sur le chiffre présent dans le premier élément du tuple. Regrouper tous les éléments ayant le même élément dans une liste et faire de suite pour les autres.

Cela fait bientôt une heure que j'essaie mais je n'arrive pas au résultat voulu...

Merci d'avance pour votre aide !

[wiztricks]

Salut,

Cela fait bientôt une heure que j'essaie mais je n'arrive pas au résultat voulu...

Si la liste est triée suivant le premier item de chaque tuple, il faut faire une boucle qui détecte le changement de sa valeur. Pour détecter ce changement, il va falloir mémoriser dans une variable la valeur précédente.

Après cette première étape, il va falloir saupoudrer le code avec une liste à construire, la liste courante qu'on remplit avec les tuples qui commencent avec le même tuple, l'ajout dans la liste à construire, la création d'une nouvelle liste courante lorsqu'on détecte un changement et probablement une action en sortie de boucle pour gérer la liste courante qui traîne.

Rien de bien compliqué mais çà prend du temps pour comprendre cette logique... passez à autre chose, et remettez vous y plus tard, vous verrez c'est bien plus efficace pour apprendre.

- W

[Invité]

Salut !

Si tu n'as pas le temps de niaiser, je te propose quelques solutions, je t'invite fortement à comprendre comment ça fonctionne et nous poser des questions si tu n'y arrives pas. Sur une échelle de difficulté je classerais mes solutions comme "intermédiaires". A vrai dire je ne peux pas beaucoup mieux à mon niveau.

J'utilise en autres la compréhension de liste et le dictionnaire :
• Dictionnaire : https://docs.python.org/3/tutorial/d...l#dictionaries
• Compréhension de liste : https://data-flair.training/blogs/py...comprehension/

Tu peux remplacer la compréhension de liste par une simple boucle for element in iterable si tu n'as pas encore appris à t'en servir .

Code :

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

1
2
>>> [x for x in 'abc']
['a', 'b', 'c']

Code :

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

1
2
3
4
5
>>> liste = []
>>> for x in 'abc':
	liste.append(x)	
>>> liste
['a', 'b', 'c']

Deux solutions (bouton "Montrer" à droite pour afficher) :

Je te propose deux solutions :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
>>> def test(liste):
	LST = [[] for i in range(len(liste))] #Je crée une liste remplie d'autant de sous-listes (vides) que de tuples
	for tpl in liste:
		LST[tpl[0]].append(tpl) #Je rajoute dans la sous-liste présent à l'index tpl[0]=2 par exemple, le tuple.
	LST = list(filter(([]).__ne__, LST)) #Je supprimer toutes les sous-listes vide, tuto : https://www.delftstack.com/fr/howto/python/python-list-remove-all/
 
 
>>> def test2(liste):
	IDS = dict([(tpl[0],[]) for tpl in liste]) #IDS = {0: [], 2: [], 3: [], 4: []}
	for tpl in liste:
		IDS[tpl[0]].append(tpl) #J'ajoute dans la liste présent dans le dictionnaire à la clé tpl[0]=2 par exemple, le tuple.
	LST = [value for value in IDS.values()] #Je créé une liste composé uniquement des valeurs (values) du dictionnaire.

Code :

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

1
2
3
4
5
6
7
>>> s = [(0, 3), (2, 0), (2, 1), (2, 4), (3, 0), (3, 1), (3, 2), (4, 3)]
 
>>> test2(s)
[[(0, 3)], [(2, 0), (2, 1), (2, 4)], [(3, 0), (3, 1), (3, 2)], [(4, 3)]]
 
>>> test(s)
[[(0, 3)], [(2, 0), (2, 1), (2, 4)], [(3, 0), (3, 1), (3, 2)], [(4, 3)]]

Il existe très probablement des modules capables de faire ce que tu souhaites, je pense à collections mais pour ma part j'aime bien bidouiller moi même les données même si c'est 100 fois moins performants.

[hugocallens]

Re,

Tout d'abord, merci à vous deux pour vos réponses ! J'ai conscience que mon cas est très spécifique et difficilement généralisable mais au cas où quelqu'un cherche un jour une solution à ce problème, j'ai trouvé une solution :

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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
s = [(0, 3), (2, 0), (2, 1), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3)]
 
# Initialisation de la liste finale et de la liste temporaire qui changera
# à chaque fois que le premier nombre d'un couple change
ls_f = []
ls_tmp = []
 
i = 0
 
# Traitement jusqu'à l'avant dernier élément
 
while i < len(s) - 1:
    val = s[i][0]
    ls_tmp.append(s[i])
    # Tant que le premier chiffre est pareil
    while val == s[i + 1][0]:
        # Tant qu'on arrive pas à un i trop élevé,
        # pour éviter un index out of range, on arrête la boucle à i = 6
        # car autrement, avec i = 7 on traitera s[8][0] qui n'existe pas
        if i != len(s) - 2:
            ls_tmp.append(s[i + 1])
            i += 1
        # Si i = 6 on sort de la boucle car on a traité jusqu'à l'avant dernier couple
        else:
            break
    ls_f.append(ls_tmp)
    ls_tmp = []
    i += 1
 
# Traitement pour le dernier élément
 
# Si le premier chiffre du dernier couple de s est égal au premier chiffre
# du dernier couple de ls_f
if s[-1][0] == ls_f[-1][0][0]:
    ls_f[-1].append(s[-1])
# Autrement
else:
    ls_f.append([s[-1]])
 
print(ls_f)
# affiche ls_f = [[(0, 3)], [(2, 0), (2, 1), (2, 4)], [(3, 0), (3, 1), (3, 2), (3, 3)]]

(Ici, je donne des exemples de i qui fonctionnent car la longueur de ma liste s est définie mais bien sûr il varie en fonction de la longueur de votre liste)

J'ai bien conscience que le code n'est clairement pas optimisé au maximum mais il fonctionne comme moi je l'ai besoin.
Bien à vous.

[Sve@r]

Bonjour

j'ai trouvé une solution

Une solution bien bien compliquée. Pourquoi tu gères le dernier élément à part ???

Code python :

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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#!/usr/bin/env python3
# coding: utf-8
 
def liste2liste(base):
	# Initialisation liste finale
	final=list()
 
	# Initialisation mémorisation élément
	mem=None
 
	# Traitement de la liste
	for s in base:
		# Si le premier élément de la liste a changé
		if s[0] != mem:
			# On crée une nouvelle sous-liste
			final.append(list())
 
			# On mémorise l'élement
			mem=s[0]
		# if
 
		# La liste en cours est ajoutée à la dernière sous-liste créée
		final[-1].append(s)
	# for
 
	return final
# liste2liste()
 
s = [(0, 3), (2, 0), (2, 1), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3)]
s2=liste2liste(s)
print(s2)

Voilà. Une application littérale de ce qu'avait dit wiztricks (mais qui impose, comme il l'a dit, que la liste initiale soit triée).
Ensuite il y a des solutions plus "full python" telles que montrées par Le Narvalo

J'ai bien conscience que le code n'est clairement pas optimisé au maximum mais il fonctionne comme moi je l'ai besoin.

Bien souvent cela ne suffit pas (tu comprendras lorsque tu y reviendras après quelques mois)...

[hugocallens]

Merci pour ta réponse cela semble bien mieux ! J'avais tellement le nez dedans que je ne pouvais rien faire de bien !