Bonjour,

J'aimerais savoir comment représenter le temps sous le format MM:SS sur l'axe des ordonnées avec matplotlib.

Ci-dessous le code:

# Script graphique_code_couleurs.py
# Importation des modules
from datetime import datetime
import matplotlib.pyplot as plt
import operator
import pickle
from tkinter import *
from app.graphical.graphique import Graphique
from app.settings import options
from app.text.code_couleurs_text import *
from app.text.common_text import *


CHECKBOX_SCORE_X = 250
CHECKBOX_SCORE_Y = 65


class GraphiqueCodeCouleurs(Graphique):
    def __init__(self, username: str):
        Graphique.__init__(self, username)

        self.var_score = None
        self.check_button_score = None

        self.init_checkboxes()

    def init_checkboxes(self):
        """
            Définition des checkboxes
        """
        self.var_score = IntVar()
        self.check_button_score = Checkbutton(self.window, text=score_text[options.language], variable=self.var_score,
                                              onvalue=1, offvalue=0, command=self.switch_var_score)
        self.check_button_score.pack()
        self.check_button_score['bg'] = '#DDDDDD'
        self.check_button_score.select()
        self.var_score.set(1)

        self.main_canevas.create_window(CHECKBOX_SCORE_X, CHECKBOX_SCORE_Y, window=self.check_button_score)

    def switch_var_score(self):
        """
            Changement d'état de la checkbox "Score"
        """
        if self.var_score.get() == 0:
            self.var_score.set(1)
        else:
            self.var_score.set(0)

        self.update_graphe()

    def switch_var_legende(self):
        """
            Changement d'état de la checkbox "legende"
        """
        if self.var_legende.get() == 0:
            self.var_legende.set(1)
        else:
            self.var_legende.set(0)

        self.update_graphe()

    def update_graphe(self):
        """
            Effacement du graphe pour le mettre à jour
        """
        self.plot1.remove()
        self.plot1 = self.fig.add_subplot(6, 1, (1, 5))
        self.canvas.get_tk_widget().pack()
        self.plot()

    def plot(self):
        """
            Affichage des courbes
        """
        # Lecture du fichier des meilleurs scores
        with open('records', 'rb') as fichier:
            mon_depickler = pickle.Unpickler(fichier)
            self._scores_recuperes_username = mon_depickler.load()

        scores_recuperes = self._scores_recuperes_username[self._username]

        dico_graphe_code = scores_recuperes["Graphique"]["Code Couleurs"]
        worst_time = 0

        year = int(self.mois_annee_text.split(" ")[1])
        month = int(self.month_in_number(self.mois_annee_text.split(" ")[0]))

        x_graph_code = []
        y_graph_code = []

        if self.var_score.get() == 1:
            for elts, score in dico_graphe_code.items():
                if datetime.strptime(elts, "%d/%m/%Y").month == month and datetime.strptime(elts, "%d/%m/%Y").year == year:
                    elts_day = str("%02d" % datetime.strptime(elts, "%d/%m/%Y").day)
                    elts_month = str("%02d" % datetime.strptime(elts, "%d/%m/%Y").month)
                    elts_year = datetime.strptime(elts, "%d/%m/%Y").year
                    elts_date = "/".join([str(elts_day), str(elts_month), str(elts_year)])
                    x_graph_code.append(elts_date)
                    minutes = int(score.split(':')[0])
                    seconds = int(score.split(':')[1])
                    time_score = float(minutes)*60 + float(seconds) % 60
                    y_graph_code.append(time_score)

                    if time_score > worst_time:
                        worst_time = time_score

        plt.ylim(0, worst_time + 10)

        self.fig.set_facecolor('#DDDDDD')
        self.plot1.set_title(code_couleurs_text[options.language])

        list_dates = []

        for elt in x_graph_code:
            list_dates.append(elt)

        list_dates = self.tri_dates(list_dates)
        dico_dates = {}

        index = 1

        for elt in list_dates:
            dico_dates[elt] = index
            index += 1

        list_scores = []

        for elt in y_graph_code:
            if elt not in list_scores:
                list_scores.append(elt)

        list_scores_sorted = [ts for ts in list_scores]
        list_scores_sorted.sort()

        list_to_diplay = []

        if len(list_scores_sorted) > 0:
            max_in_new_list = list_scores_sorted[-1]
        else:
            max_in_new_list = 0

        temps_max = int(max_in_new_list)

        for index in range(temps_max + 1):
            minutes = index // 60
            seconds = index % 60
            score_to_add = str("%02d" % minutes) + ":" + str("%02d" % seconds)
            list_to_diplay.append(score_to_add)

        x_graph_code_int = []

        for elt in x_graph_code:
            x_graph_code_int.append(dico_dates[elt])

        self.plot1.plot(x_graph_code, y_graph_code, marker="o", color="#804040", label=score_text[options.language])

        if self.var_legende.get() == 1:
            handles, labels = self.plot1.get_legend_handles_labels()

            list_courbes = sorted(zip(handles, labels), key=operator.itemgetter(1))
            if len(list_courbes) > 0:
                handles2, labels2 = zip(*list_courbes)
                self.plot1.legend(handles2, labels2)

        plt.gca().get_xaxis().set_ticklabels(list_dates, fontsize=8, rotation=90)
        # plt.gca().set_xticks(range(1, len(list_dates) + 1, 1))
        # plt.gca().get_yaxis().set_ticklabels(list_to_diplay, fontsize=8)
        # plt.gca().set_yticks(range(0, len(list_to_diplay), 1))
        self.plot1.patch.set_facecolor('#000000')
        self.plot1.grid(which='major', axis='x', color='w', linestyle='dashed')
        self.plot1.grid(which='major', axis='y', color='w', linestyle='dashed')

        self.canvas.draw()

        self.canvas.get_tk_widget().pack()

Résultat ci-dessous:

Merci d'avance,

-
Edité par HabibKASSIS 4 décembre 2022 à 20:51:06

que mets tu en y_graph_code, des valeurs (minutes*60+secondes) (ligne 100 à 102),  calculées depuis score; pourquoi ne pas utiliser directement score du coup ?

En fait, dans mon fichier de score, les temps sont représentés de la forme MM:SS. Ensuite, je les convertis en nombre total de secondes en int. Si je n'utilise pas directement les scores tels qu'ils sont c'est parce que dans mon graphique, les temps ne sont pas affichés dans le bon ordre sur l'axe des ordonnées.

il faudrait les utiliser yticks label  ou quelque chose comme ça (peut-être)

ça donne quoi par exemple sur le graphe ?

avec les yticks label:

# Script graphique_calcul_mental.py
# Importation des modules
from datetime import datetime
import matplotlib.pyplot as plt
import operator
import pickle
from tkinter import *
from app.graphical.graphique import Graphique
from app.settings import options
from app.text.casse_tete_text import *


CHECKBOX_2_2_X = 100
CHECKBOX_2_2_Y = 65

CHECKBOX_3_3_X = 200
CHECKBOX_3_3_Y = 65

CHECKBOX_4_4_X = 300
CHECKBOX_4_4_Y = 65

CHECKBOX_5_5_X = 400
CHECKBOX_5_5_Y = 65


class GraphiqueCasseTete(Graphique):
    def __init__(self, username: str):
        Graphique.__init__(self, username)

        self.var_2x2 = None
        self.var_3x3 = None
        self.var_4x4 = None
        self.var_5x5 = None
        self.check_button_2x2 = None
        self.check_button_3x3 = None
        self.check_button_4x4 = None
        self.check_button_5x5 = None

        self.init_checkboxes()

    def init_checkboxes(self):
        """
            Définition des checkboxes
        """
        self.var_2x2 = IntVar()
        self.check_button_2x2 = Checkbutton(self.window, text="2x2", variable=self.var_2x2, 
                                            onvalue=1, offvalue=0, command=self.switch_var_2x2)
        self.check_button_2x2.pack()
        self.check_button_2x2['bg'] = '#DDDDDD'
        self.check_button_2x2.select()
        self.var_2x2.set(1)

        self.main_canevas.create_window(CHECKBOX_2_2_X, CHECKBOX_2_2_Y, window=self.check_button_2x2)

        self.var_3x3 = IntVar()
        self.check_button_3x3 = Checkbutton(self.window, text="3x3", variable=self.var_3x3,
                                            onvalue=1, offvalue=0, command=self.switch_var_3x3)
        self.check_button_3x3.pack()
        self.check_button_3x3['bg'] = '#DDDDDD'
        self.check_button_3x3.select()
        self.var_3x3.set(1)

        self.main_canevas.create_window(CHECKBOX_3_3_X, CHECKBOX_3_3_Y, window=self.check_button_3x3)

        self.var_4x4 = IntVar()
        self.check_button_4x4 = Checkbutton(self.window, text="4x4", variable=self.var_4x4,
                                            onvalue=1, offvalue=0, command=self.switch_var_4x4)
        self.check_button_4x4.pack()
        self.check_button_4x4['bg'] = '#DDDDDD'
        self.check_button_4x4.select()
        self.var_4x4.set(1)

        self.main_canevas.create_window(CHECKBOX_4_4_X, CHECKBOX_4_4_Y, window=self.check_button_4x4)

        self.var_5x5 = IntVar()
        self.check_button_5x5 = Checkbutton(self.window, text="5x5", variable=self.var_5x5,
                                            onvalue=1, offvalue=0, command=self.switch_var_5x5)
        self.check_button_5x5.pack()
        self.check_button_5x5['bg'] = '#DDDDDD'
        self.check_button_5x5.select()
        self.var_5x5.set(1)

        self.main_canevas.create_window(CHECKBOX_5_5_X, CHECKBOX_5_5_Y, window=self.check_button_5x5)

    def switch_var_2x2(self):
        """
            Changement d'état de la checkbox "2x2"
        """
        if self.var_2x2.get() == 0:
            self.var_2x2.set(1)
        else:
            self.var_2x2.set(0)

        self.update_graphe()

    def switch_var_3x3(self):
        """
            Changement d'état de la checkbox "3x3"
        """
        if self.var_3x3.get() == 0:
            self.var_3x3.set(1)
        else:
            self.var_3x3.set(0)

        self.update_graphe()

    def switch_var_4x4(self):
        """
            Changement d'état de la checkbox "4x4"
        """
        if self.var_4x4.get() == 0:
            self.var_4x4.set(1)
        else:
            self.var_4x4.set(0)

        self.update_graphe()

    def switch_var_5x5(self):
        """
            Changement d'état de la checkbox "5x5"
        """
        if self.var_5x5.get() == 0:
            self.var_5x5.set(1)
        else:
            self.var_5x5.set(0)

        self.update_graphe()

    def switch_var_legende(self):
        """
            Changement d'état de la checkbox "legende"
        """
        if self.var_legende.get() == 0:
            self.var_legende.set(1)
        else:
            self.var_legende.set(0)

        self.update_graphe()
        
    def update_graphe(self):
        """
            Effacement du graphe pour le mettre à jour
        """
        self.plot1.remove()
        self.plot1 = self.fig.add_subplot(6, 1, (1, 5))
        self.canvas.get_tk_widget().pack()
        self.plot()

    def plot(self):
        """
            Affichage des courbes
        """
        # Lecture du fichier des meilleurs scores
        with open('records', 'rb') as fichier:
            mon_depickler = pickle.Unpickler(fichier)
            self._scores_recuperes_username = mon_depickler.load()

        scores_recuperes = self._scores_recuperes_username[self._username]

        dico_graphe_2_by_2 = scores_recuperes["Graphique"]["Casse Tête"]["2x2"]
        dico_graphe_3_by_3 = scores_recuperes["Graphique"]["Casse Tête"]["3x3"]
        dico_graphe_4_by_4 = scores_recuperes["Graphique"]["Casse Tête"]["4x4"]
        dico_graphe_5_by_5 = scores_recuperes["Graphique"]["Casse Tête"]["5x5"]

        year = int(self.mois_annee_text.split(" ")[1])
        month = int(self.month_in_number(self.mois_annee_text.split(" ")[0]))

        x_graph_2_2 = []
        y_graph_2_2 = []

        if self.var_2x2.get() == 1:
            for elts, score in dico_graphe_2_by_2.items():
                if datetime.strptime(elts, "%d/%m/%Y").month == month and datetime.strptime(elts, "%d/%m/%Y").year == year:
                    elts_day = str("%02d" % datetime.strptime(elts, "%d/%m/%Y").day)
                    elts_month = str("%02d" % datetime.strptime(elts, "%d/%m/%Y").month)
                    elts_year = datetime.strptime(elts, "%d/%m/%Y").year
                    elts_date = "/".join([str(elts_day), str(elts_month), str(elts_year)])
                    x_graph_2_2.append(elts_date)
                    minutes = int(score.split(':')[0])
                    seconds = int(score.split(':')[1])
                    time_score = float(minutes)*60 + float(seconds) % 60
                    y_graph_2_2.append(time_score)

        x_graph_3_3 = []
        y_graph_3_3 = []

        if self.var_3x3.get() == 1:
            for elts, score in dico_graphe_3_by_3.items():
                if datetime.strptime(elts, "%d/%m/%Y").month == month and datetime.strptime(elts, "%d/%m/%Y").year == year:
                    elts_day = str("%02d" % datetime.strptime(elts, "%d/%m/%Y").day)
                    elts_month = str("%02d" % datetime.strptime(elts, "%d/%m/%Y").month)
                    elts_year = datetime.strptime(elts, "%d/%m/%Y").year
                    elts_date = "/".join([str(elts_day), str(elts_month), str(elts_year)])
                    x_graph_3_3.append(elts_date)
                    minutes = int(score.split(':')[0])
                    seconds = int(score.split(':')[1])
                    time_score = float(minutes)*60 + float(seconds) % 60
                    y_graph_3_3.append(time_score)

        x_graph_4_4 = []
        y_graph_4_4 = []

        if self.var_4x4.get() == 1:
            for elts, score in dico_graphe_4_by_4.items():
                if datetime.strptime(elts, "%d/%m/%Y").month == month and datetime.strptime(elts, "%d/%m/%Y").year == year:
                    elts_day = str("%02d" % datetime.strptime(elts, "%d/%m/%Y").day)
                    elts_month = str("%02d" % datetime.strptime(elts, "%d/%m/%Y").month)
                    elts_year = datetime.strptime(elts, "%d/%m/%Y").year
                    elts_date = "/".join([str(elts_day), str(elts_month), str(elts_year)])
                    x_graph_4_4.append(elts_date)
                    minutes = int(score.split(':')[0])
                    seconds = int(score.split(':')[1])
                    time_score = float(minutes)*60 + float(seconds) % 60
                    y_graph_4_4.append(time_score)

        x_graph_5_5 = []
        y_graph_5_5 = []

        if self.var_5x5.get() == 1:
            for elts, score in dico_graphe_5_by_5.items():
                if datetime.strptime(elts, "%d/%m/%Y").month == month and datetime.strptime(elts, "%d/%m/%Y").year == year:
                    elts_day = str("%02d" % datetime.strptime(elts, "%d/%m/%Y").day)
                    elts_month = str("%02d" % datetime.strptime(elts, "%d/%m/%Y").month)
                    elts_year = datetime.strptime(elts, "%d/%m/%Y").year
                    elts_date = "/".join([str(elts_day), str(elts_month), str(elts_year)])
                    x_graph_5_5.append(elts_date)
                    minutes = int(score.split(':')[0])
                    seconds = int(score.split(':')[1])
                    time_score = float(minutes)*60 + float(seconds) % 60
                    y_graph_5_5.append(time_score)

        self.fig.set_facecolor('#DDDDDD')
        self.plot1.set_title(casse_tete_text[options.language])

        list_dates = []

        for elt in x_graph_2_2:
            list_dates.append(elt)

        for elt in x_graph_3_3:
            if elt not in list_dates:
                list_dates.append(elt)

        for elt in x_graph_4_4:
            if elt not in list_dates:
                list_dates.append(elt)

        for elt in x_graph_5_5:
            if elt not in list_dates:
                list_dates.append(elt)

        list_dates = self.tri_dates(list_dates)
        dico_dates = {}

        index = 1

        for elt in list_dates:
            dico_dates[elt] = index
            index += 1

        list_scores = []

        for elt in y_graph_2_2:
            if elt not in list_scores:
                list_scores.append(elt)

        for elt in y_graph_3_3:
            if elt not in list_scores:
                list_scores.append(elt)

        for elt in y_graph_4_4:
            if elt not in list_scores:
                list_scores.append(elt)

        for elt in y_graph_5_5:
            if elt not in list_scores:
                list_scores.append(elt)

        list_scores_sorted = [ts for ts in list_scores]
        list_scores_sorted.sort()

        list_to_diplay = []

        if len(list_scores_sorted) > 0:
            max_in_new_list = list_scores_sorted[-1]
        else:
            max_in_new_list = 0

        temps_max = int(max_in_new_list)

        for index in range(temps_max+1):
            minutes = index // 60
            seconds = index % 60
            score_to_add = str("%02d" % minutes) + ":" + str("%02d" % seconds)
            list_to_diplay.append(score_to_add)

        x_graph_2_2_int = []

        for elt in x_graph_2_2:
            x_graph_2_2_int.append(dico_dates[elt])

        self.plot1.plot(x_graph_2_2_int, y_graph_2_2, marker="o", color="#00FF00", label='2x2')

        x_graph_3_3_int = []

        for elt in x_graph_3_3:
            x_graph_3_3_int.append(dico_dates[elt])

        self.plot1.plot(x_graph_3_3_int, y_graph_3_3, marker="o", color="#0000FF", label='3x3')

        x_graph_4_4_int = []

        for elt in x_graph_4_4:
            x_graph_4_4_int.append(dico_dates[elt])

        self.plot1.plot(x_graph_4_4_int, y_graph_4_4, marker="o", color="#FFFF00", label='4x4')

        x_graph_5_5_int = []

        for elt in x_graph_5_5:
            x_graph_5_5_int.append(dico_dates[elt])

        self.plot1.plot(x_graph_5_5_int, y_graph_5_5, marker="o", color="#FF0000", label='5x5')

        if self.var_legende.get() == 1:
            handles, labels = self.plot1.get_legend_handles_labels()

            list_courbes = sorted(zip(handles, labels), key=operator.itemgetter(1))
            if len(list_courbes) > 0:
                handles2, labels2 = zip(*list_courbes)
                self.plot1.legend(handles2, labels2)

        plt.gca().get_xaxis().set_ticklabels(list_dates, fontsize=8, rotation=90)
        plt.gca().set_xticks(range(1, len(list_dates) + 1, 1))
        plt.gca().get_yaxis().set_ticklabels(list_to_diplay, fontsize=8)
        plt.gca().set_yticks(range(0, len(list_to_diplay), 1))
        self.plot1.patch.set_facecolor('#000000')
        self.plot1.grid(which='major', axis='x', color='w', linestyle='dashed')
        self.plot1.grid(which='major', axis='y', color='w', linestyle='dashed')

        self.canvas.draw()

        self.canvas.get_tk_widget().pack()

Graphiquement ça donne ça:

Mais imaginons que le temps maximum est de 1 minute (01:00), si on mettait toutes les secondes jusqu'à une minute, cela donnerait quelque chose d'illisible.

HabibKASSIS a écrit:

Mais imaginons que le temps maximum est de 1 minute (01:00), si on mettait toutes les secondes jusqu'à une minute, cela donnerait quelque chose d'illisible.

C'est ce à quoi servent formatters et locators dont on trouve des exemples comme celui-ci

C'est bon j'ai trouvé la solution.

Exemple: Affichage toutes les 5 secondes.

édite ton post pour remettre ton code propre en utilisant le bouton </> stp, on ne vois pas les indentations (même si d'expérience, on devine)

-
Edité par umfred 24 janvier 2023 à 12:56:56