TKinter-appel au constructeur

Version imprimable

Je découvre un peu chaque jour Python3

Voicion problème à la lecture d'explication en ligne sur Tkinter j'ai creer le petit test
Code:

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 # coding: utf-8 import tkinter as tk from distutils import command class lafenetre(tk.Tk): #curieusement sans héritage cela fonctionne def __init__(self): tk.Tk.__init__(self) # appel du constructeur de la class mere TK mafenete = tk.Tk() mafenete.geometry("800x400+100+50") # taille de la fenetre et position h100 - l50 mafenete.grid() mafenete.title("Ma fenetre") # titre de la fenetre mafenete.premierBouton = tk.Button(mafenete, text ='Bonjour', command = execpremierBouton ) # definie une bouton simple mafenete.secondBouton = tk.Button(mafenete, text ='OK',command = execsecondBouton ) mafenete.premierBouton.grid() mafenete.secondBouton.grid() mafenete.mainloop() # surveille les interaction de la fenetre def execpremierBouton(mafenete): print("premier Bouton") mafenete.quit() def execsecondBouton(mafenete): print("OK") lancer = lafenetre()
on me dit que ma class qui appel tkinter doit faire référence au constructeur .
ceci étant même sans on obtient l'affichage de l'écran

class lafenetre(): #curieusement sans héritage cela fonctionne
def __init__(self):

on me dit que l'on doit déclarer l'appel au constructeur

Code:

tk.Tk.__init__(self) # appel du constructeur de la class mere TK

si je mets cette ligne de code 2 fenêtres "tkinter" s'ouvre l'une vide l'autre correpond à ma fenetre :aie:

Pourquoi ?

peut être que le code logiquement devraitêtre ceci?

Code:

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
# coding: utf-8  
import tkinter as tk 
 
 
 
 
 
class lafenetre(tk.Tk): #curieusement sans héritage cela fonctionne
    def __init__(self):
        #tk.Tk.__init__(self) # appel du constructeur de la class mere TK
        self  = tk.Tk()
        self.geometry("800x400+100+50") # taille de la fenetre et position h100 - l50
        self.grid()
        self.title("Ma fenetre")  # titre de la fenetre
        premierBouton = tk.Button(self, text ='Bonjour', command = execpremierBouton  ) # definie une bouton simple 
        secondBouton = tk.Button(self, text ='OK',command = execsecondBouton  ) 
        premierBouton.grid(column = 0 ,row = 0)
        secondBouton.grid(column = 1 ,row = 0)
        self.mainloop() # surveille les interaction de la fenetre
 
 
 
def execpremierBouton() :
    print("premier Bouton")
 
 
def execsecondBouton():    
    print("OK")
 
 
lancer = lafenetre()

09/02/2018, 14h20
wiztricks
Salut,

Si on écrit simplement:
Code:

1 2 3 4 import tkinter as tk root = tk.Tk() tk.mainloop()
côté visible, çà ouvre une fenêtre et si on ecrit:
Code:

1 2 3 4 5 import tkinter as tk root = tk.Tk() root = tk.Tk() tk.mainloop()
çà ouvrira 2 fenêtres (et çà ne sera pas facile à gérer).

Après, avec les "class", on va pouvoir distribuer ces instructions différemment:
Code:

1 2 3 4 class A(tk.Tk): def __init__(self): super().__init__(self) root = tk.Tk()
le premier tk.Tk() étant enfoui dans l'appel au constructeur qui appelle le constructeur de la classe mère et le deuxième effectué un peu après.
Puis on peut faire varier l'écriture et remplacer super().__init__(self) par tk.Tk.__init__(self).

Finalement, on a multiplié le nombre de lignes rendant plus difficile la compréhension des opérations élémentaires qui se déroulent derrière et on n'y comprend plus rien.

Pourtant, vous avez la chance d'utiliser tkinter, une des rares bibliothèques graphiques qui ne vous oblige pas à écrire le mot clef "class" pour vos premiers codes... Ce qui est sympa. car une bibliothèque graphique, c'est bien assez compliqué sans çà.

- W

Citation:
Envoyé par dedalios
Je découvre un peu chaque jour Python3
Code:

1 2 3 4 class lafenetre(tk.Tk): #curieusement sans héritage cela fonctionne def __init__(self): tk.Tk.__init__(self) # appel du constructeur de la class mere TK mafenete = tk.Tk()
Salut et bienvenue dans la programmation object.

Comme tu l'indiques dans tes commentaires, ta classe "hérite" d'une autre classe.
Tu sais que c'est comme ça, que ça porte ce nom là mais tu n'en mesures ni les effets ni les conséquences.

Lorsque tu écris class lafenetre(tk.Tk): tu déclares que "lafenetre" EST "tk.Tk" et donc que toutes les propriétés (attributs, méthodes, goûts culinaires, etc.) de cette classe "Tk" sont maintenant propriétés de ta classe "lafenetre".

Enfin il faut encore initialiser l'objet "Tk" pour que ça marche.
La pratique courante pour cela sera d'utiliser:
Code:

1 2 3 def __init__(self): super().__init__()
Pour Python 2 il faut indiquer le nom de la classe héritée à super, mais qui utilise encore Python 2 de nos jours?

Donc, maintenant que "lafenetre" EST "tk.Tk", ta ligne de code mafenete = tk.Tk() n'as plus de raison d'être.

D'autant plus que cette "mafenete" n'aura de durée de vie que dans l'espace de nom de la méthode __init__() c'est-à-dire aucune.

Au contraire, maintenant tu peux peupler ta fenêtre avec
Code:

1 2 3 4 5 6 7 8 9 self.title("Ma fenetre") # titre de la fenetre self.premierBouton = tk.Button(self, text='Bonjour', command=self.execpremierBouton ) self.secondBouton = tk.Button(self, text='OK', command=self.execsecondBouton ) self.premierBouton.grid() self.secondBouton.grid() self.mainloop()
Toute la magie se trouve dans self qui à l'intérieur de cette classe en représente l'instance.

Bonnes découvertes.