Pour commencer un nouveau Projet utilisant Tkinter (w\ Python 3.x), j'utilise ce modèle générique que j'ai conçue grâce a mon ancien projet 'ProjetBrassard'.

Infos_Hardware-3_7.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#PYTHON 3.x EDITION
#AIDES: https://pythonconverter.com/

#AIDES: https://stackoverflow.com/questions/9229333/how-to-get-overall-cpu-sage-e-g-57-on-linux
#AIDES: https://stackoverflow.com/questions/10585978/linux-command-for-percentage-of-memory-that-is-free
#AIDES: https://docs.python.org/2/library/commands.html


import os
import sys
import datetime
import time
from nettoyage_du_cache import clear_cache


import io
import subprocess


def CPU_usage():
    #Charge CPU
    global UtilisationCPU

    LectureCommande0=subprocess.getoutput("top -bn 1 | awk 'NR>7{s+=$9} END {print s/4}'")    #On execute cette commande pour Obtenir le resultat depuis le sysytem sans passer par un programme tièrce
    UtilisationCPU = "Utilisation du Processeur: " + LectureCommande0 + " %"                #Enregistrement de la Variable reçu et Mise en forme
    print(UtilisationCPU)                                                                   #Affichage des nouvelles données reçu dans la console

    return UtilisationCPU                                                       #Retourne les valeurs pour une prochaine utilisation.

def CPU_temp():
    #Temperature du CPU/SoC
    global tk_cputemp
        #f = open("/sys/class/thermal/thermal_zone0/temp")
        #t = f.readline ()
        #cputemp = "CPU temp: "+t
    cputemp = subprocess.getoutput("vcgencmd measure_temp")
    print(("Temperature du Processeur: "+ cputemp))

    #--
    tk_cputemp        = "Temperature du Processeur: " + cputemp                             #Mise en forme pour l'affichage sous Tkinter
    #--

    return tk_cputemp 

def SoC_info():
    global mesure_voltage
    global memoire_processeur
    global memoire_gpu

    #Voltage utilisé par le Socket CPU/GPU
    LectureCommande1=subprocess.getoutput("vcgencmd measure_volts core")
    mesure_voltage = "Tension utilisé par l'ensemble CPU/GPU: " + LectureCommande1 
    print(mesure_voltage)

    #Indication de la Mémoire Vive alouée pour le Processeur
    LectureCommande2=subprocess.getoutput("vcgencmd get_mem arm")
    memoire_processeur = "Mémoire Vive alouée pour le Processeur: " + LectureCommande2 
    print(memoire_processeur)

    #Indication de la Mémoire Vive alouée pour le Processeur Graphique
    LectureCommande3=subprocess.getoutput("vcgencmd get_mem gpu")
    memoire_gpu = "Mémoire Vive alouée pour le Processeur Graphique: " + LectureCommande3 
    print(memoire_gpu)

    return mesure_voltage,memoire_processeur,memoire_gpu   

def MEM_info():
    #Charge Memoire Vive
    global MemoireUtilise
    LectureCommande4=subprocess.getoutput("free | grep Mem | awk '{print $3/$2 * 100.0}'")
    MemoireUtilise = "Memoire Vive Utilise: " + LectureCommande4 + " %"
    print(MemoireUtilise)

    return MemoireUtilise


if __name__ == "__main__":
    clear_cache()           #Nettoyage du Cache Python.
    CPU_usage()             #Obtention du Niveau d'utilisation du Processeur.
    CPU_temp()              #Obtention de la Temperature du Processeur.
    SoC_info()              #Obtention d'information par rapport au Couple CPU/GPU.
    MEM_info()              #Obtention d'information par rapport à la Memoire Vive.

Interface_CryptoView-3_7.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#PYTHON 3.x EDITION
#AIDES: https://pythonconverter.com/

#AIDES: https://github.com/Franck1333/ProjetBrassard
#AIDES: https://gist.github.com/Franck1333/f80936044088cb50aec1c1aad9de1803
#AIDES: http://apprendre-python.com/page-tkinter-interface-graphique-python-tutoriel


#---------------------------------------Importante LIB---------------------------------------
import os                                                   #Blibliotheque permettant l'interaction avec le systeme
import sys                                                  #Blibliotheque permettant l'interaction avec le systeme
import datetime                                             #Blibliotheque permettant d'obtenir la date
import time                                                 #Blibliotheque permettant d'obtenir la date

import getpass                                              #On importe la blibliotheque "getpass"
USERNAME = getpass.getuser()                                #On enregistre le Nom de l'Utilisateur

from tkinter import * #Python Version 2                     #Blibliotheque permettant d'obtenir Tkinter(G.U.I)
import tkinter.ttk                                                  #Blibliotheque permettant de charger un composant Tkinter(G.U.I)
#---------------------------------------Importante LIB---------------------------------------

#-----------------------------------------------------Localisation de l'emplacement des fichiers necessaires-----------------------------------------------------
print("\n Bonjour/Bonsoir, ne pas faire fonctionner ce programme en utilisant les droits/commandes administrateur si l'utilisateur n'est pas l'Admin au quel cas le programme ne fonctionnera pas correctement. \n") #Information a lire dans la console
sys.path.append('/home/'+USERNAME+'/CrytpoView_Projet/Services')              #On indique au systeme ou ce situe le repertoire "Services" dans l'Appareil
#print(USERNAME)                                                              #Test debug

from nettoyage_du_cache import clear_cache                  #Bibliotheque permettant de nettoyer les fichiers cache PYTHON

from Infos_Hardware import CPU_usage                        #Obtention de l'utilisation du Processeur par le Systeme d'exploitation et ses programmes autour
from Infos_Hardware import CPU_temp                         #Obtention de la Temperature du Processeur sur la carte mere
from Infos_Hardware import SoC_info                         #Obtention des informations concernant le package CPU+GPU
from Infos_Hardware import MEM_info                         #Obtention de l'utilisation de la Memoire Vive du Systeme
#-----------------------------------------------------Localisation de l'emplacement des fichiers necessaires-----------------------------------------------------

#-------------Fenetre Maitre-------------
fenetre = Tk()              #Creation d'une Fenetre Maîtresse TK appeler "fenetre"
#-------------Fenetre Maitre-------------

#-------------------------------------------------------------------Contenue Fenetre Principale-------------------------------------------------------------------
#------------------------------------------------------------------------------     #Affichage du Temps HEURES/MINUTES/SECONDES
def temps_actuel():   
    #OBTENTION DE L'HEURE ACTUEL sous format HEURE,MINUTE,SECONDE
    #-- DEBUT -- Heure,Minute,Seconde
    tt = time.time()
    system_time = datetime.datetime.fromtimestamp(tt).strftime('%H:%M:%S')
    print(("Voici l'heure:",system_time))
    return system_time
    #-- FIN -- Heure,Minute,Seconde
#---------------------------------------------
status_temps_actuel = Label(fenetre, text=temps_actuel())                   #Affichage du Temps (Label)
status_temps_actuel.pack()                                                  #Pour obtenir un affichage dynamique , Il faut utiliser pack/grid de cette façon
#---------------------------------------------
def update_temps_actuel():                                                  #Fonctionnalité permettant de mettre à jour l'Heure en fonction du Temps Réel
    # On met à jour le temps actuel dans le champs text du Widget LABEL pour afficher l'heure
    status_temps_actuel["text"] = temps_actuel()

    # Après une seconde , on met à jour le contenue text du LABEL
    fenetre.after(1000, update_temps_actuel)    
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
def information_Materiel():
    #Obtention des Informations Materiel de l'Ordinateur
    global tk_UtilisationCPU
    global tk_tk_cputemp
    global tk_MemoireUtilise

    #--        
    UtilisationCPU = CPU_usage()                                                #Obtention du Niveau d'utilisation du Processeur.
    MemoireUtilise = MEM_info()                                                 #Obtention d'information par rapport à la Memoire Vive.
    tk_cputemp = CPU_temp()                                                     #Obtention de la Temperature du Package Processeur/GPU.
    mesure_voltage,memoire_processeur,memoire_gpu  = SoC_info()                 #Obtention d'information par rapport au Couple CPU/GPU.
    
    #--

    #--Affichage--
    EnveloppeInfoMateriel = LabelFrame(fenetre, text="Informations Relatives aux Matériels", padx=5, pady=5)    #Création d'une "Zone Frame" à Label
    EnveloppeInfoMateriel.pack(fill="both", expand="no")                                                        #Position de la "Zone Frame" à Label dans la fenêtre

    tk_UtilisationCPU = Label(EnveloppeInfoMateriel, text=UtilisationCPU)
    tk_MemoireUtilise = Label(EnveloppeInfoMateriel, text=MemoireUtilise)
    tk_tk_cputemp = Label(EnveloppeInfoMateriel, text=tk_cputemp)
    
    tk_UtilisationCPU.pack()
    tk_MemoireUtilise.pack()
    tk_tk_cputemp.pack()    
    #--Affichage--

def update_information_Materiel():
    #Mise a Jour des Informations a Propos du Materiel
    tk_UtilisationCPU["text"] = CPU_usage()
    tk_MemoireUtilise["text"] = MEM_info()
    tk_tk_cputemp["text"] = CPU_temp()    

    # Après une seconde , on met à jour le contenue text du LABEL
    fenetre.after(1000, update_information_Materiel)
#---
information_Materiel() #Lancement de la Fonctionnalitée.
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
def information_Complementaire():
    #Recuperation des Informations

    INFOS = "Aucune Informations Supp. à affichée pour le moment."
    
    #--Affichage--
    EnveloppeInfoComplementaire = LabelFrame(fenetre, text="Informations Complémentaires", padx=5, pady=5)    #Création d'une "Zone Frame" à Label
    EnveloppeInfoComplementaire.pack(fill="both", expand="no")


    #---Affichage Numero d'Urgence---
    tk_info_supp = Label(EnveloppeInfoComplementaire, text=INFOS)
    tk_info_supp.pack()
    #---Affichage Numero d'Urgence---

    
    #--Affichage--

#def update_information_Complementaire():
#    #Mise à Jour des Informations reçues
#    tk_tk_tel_urgence["text"] = numero_urgence()
#
#    # Après X seconde , on met à jour le contenue text du LABEL
#    fenetre.after(500013, update_information_Complementaire)
#---
information_Complementaire() #Lancement de la Fonctionnalitée.
#------------------------------------------------------------------------------

#-------------------------------------------------------------------Contenue Fenetre Principale-------------------------------------------------------------------



if __name__ == "__main__":
    try:
        clear_cache()
        #-------------------------------------------------------------------Demarrage des fonctions operant sur la Fenetre Principale-------------------------------------------------------------------
        #Récupération des informations pour la Mise à jour du LABEL toute les 1 milliseconde quand la fenêtre Maitre est lancée
        fenetre.after(1, update_temps_actuel)               #update_temps_actuel()
        fenetre.after(1, update_information_Materiel)       #update_information_Materiel()
        #fenetre.after(1, update_information_Complementaire) #update_information_Complementaire()
        #-------------------------------------------------------------------Demarrage des fonctions operant sur la Fenetre Principale-------------------------------------------------------------------
        fenetre.mainloop()                                  #Boucle de Lancement de la Fenêtre PRINCIPAL
        pass
    #---!!!GESTION DES ERREURS!!!---
    except TypeError:
     #print("Le signal GPS est degradé , veuillez-vous deplacez!")                   #On affiche ce message dans la console                              
     print("Code Erreur: TypeError")
     clear_cache()
    except KeyError:
     #print("API Geocoder a planté, il faut recommencer une nouvelle fois ;=)")      #On affiche ce message dans la console                              
     print("Code Erreur: KeyError")
     clear_cache()      
    except ValueError:
     #print("Le signal GPS est degradé , veuillez-vous deplacez!")                   #On affiche ce message dans la console
     print("Code Erreur: ValueError")
     clear_cache()
    except AssertionError:
     #print("Le Signal GPS est degradé , veuillez-vous deplacez!")                   #On affiche ce message dans la console
     print("Code Erreur: AssertionError")
     clear_cache()
    except NameError:
     print("Il est necessaire de Redemarrez le Programme!")                          #On affiche ce message dans la console
     print("Code Erreur: NameError")
     clear_cache()
    except:
     print("Il est necessaire de Redemarrez le Logiciel!")                           #On affiche ce message dans la console
     print("Code Erreur: Aucun")
     clear_cache()
    #---!!!GESTION DES ERREURS!!!---

nettoyage_du_cache-3_7.py

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

#PYTHON 3.x EDITION
#AIDES: https://pythonconverter.com/
#Aides : https://blog.mozilla.org/webdev/2015/10/27/eradicating-those-nasty-pyc-files/

import serial
import time
import os
import sys

#Supprime les fichiers CACHE du language PYTHON
def clear_cache():
    print("Les Fichiers CACHES python perimees ont ete supprimer!")
    #print("\n")
    #print("Execution de la commande")
    os.system("sudo find . -name '*.pyc' -delete")
    #"Obviously, this can be used for any file type that you wish to eradicate, not just .pyc files."

if __name__ == '__main__':
    clear_cache() #Fonctionnalité qui permet de supprimer les fichiers CACHE produit par l'utilisation du langage PYTHON