向 tk.Tk 和 tk.Toplevel 添加方法

Question

I would like to add 2 methods to instances of tk.Tk and tk.Toplevel . The former exists as the applications root window, where the latter is created any number of times by the user. Each tk.Toplevel represents a different functionality of the application and current 13 variations exist. The application is configured so that only 1 instance of each variation may be created at any time.

One approach to solving this may be to subclass both classes:

class RootWindow(tk.Tk):
    def method_1(self):
        ...
    def method_2(self):
        ...

class TopWindow(tk.Toplevel):
    def method_1(self):
        ...
    def method_2(self):
        ...

Since I only wish to add 2 methods for functionality (that are identical as they use methods of these classes such as winfo_height() ), subclassing seems overkill as well as redundant as the same code is written twice. Therefore, another method may be to use setattr() , but I feel like that violates the open/close principle of class design:

def method_1(self):
    ...
def method_2(self):
    ...

class RootWindow(tk.Tk):
    def __init__(self):
        setattr(self, 'method_1', method_1)
        setattr(self, 'method_2', method_2)

class TopWindow(tk.Toplevel):
    def __init__(self):
        setattr(self, 'method_1', method_1)
        setattr(self, 'method_2', method_2)

Now I've only written the methods once and modified the classes; in essence, this condenses the first method and is effectively the same.

Given that tk.Tk is a window, and tk.Toplevel is a window, is there not a way through tkinter where I can define a method that all "window" based widgets will have access to? This wouldn't be an issue if all windows came from a single tkinter class, but the root window of tk.Tk is different than that of tk.Toplevel (such as for event bindings, not necessarily visual behavior).

Edit:

Taking a look at @BryanOakleys solution, I find that linters really dont like this; they point at unresolved references to attributes that I know the subclasses will have access to but not the mix-in class. Consider the following:

class Mixin:
    def method(self):
        width = self.winfo_width()
        height = self.winfo_height()
        print(f'The window is {width} x {height}')

IDE linters throw the caution because self cannot find winfo_width defined. I, however, know that its going to be called by instances of classes that subclass from tk.Tk and tk.Toplevel , but misuse would lead to undefined behavior, say for example:

class OtherWindow(Window):
    pass

o = OtherWindow()
o.method()
# Attribute error

Is this problematic? The proposed solution works, but feels like its being forced to work because "I know how it will be used". An obvious solution is to type hint:

class Mixin:
    def method(self: Union[tk.Tk, tk.Toplevel]):
        width = self.winfo_width()
        height = self.winfo_height()
        print(f'The window is {width} x {height}')

Thus the linters are satisfied and the code is readable to anybody (assuming they dont need to look up Union ). Again, is this expected behavior when using mix-in classes (never tried them)?

Answer 1

I would use a mixin class. Keeping custom classes for TopWindow and RootWindow is the right solution for creating a specialization of the base Toplevel and Tk classes, and the mixin solves the problem of not wanting to repeat code.

For example:

class CustomMixin():
    def method_1(self):
        ...
    def method_2(self):
        ...

class TopWindow(CustomMixin, tk.Toplevel):
    pass

class RootWindow(CustomMixin, tk.Tk):
    pass

Answer 2

Write one class that has your methods then create a class attribute in your other classes that keep an instance of your extra methods class.

Try this and let me know if you have any questions:

import tkinter as tk


class SomeExtraMethods:
    def __init__(self, window):
        self.window = window

    def size(self):
        return [self.window.winfo_width(), self.window.winfo_height()]


class RootWindow(tk.Tk):
    def __init__(self):
        super().__init__()
        self.extra = SomeExtraMethods(self)
        tk.Button(self, text='Print root window size', command=self.print_size).pack()
        tk.Button(self, text='Open top window', command=self.open_top).pack()

    def print_size(self):
        print(self.extra.size())

    def open_top(self):
        top = TopWindow()


class TopWindow(tk.Toplevel):
    def __init__(self):
        super().__init__()
        self.extra = SomeExtraMethods(self)
        tk.Button(self, text='Print top window size', command=self.print_size).pack()

    def print_size(self):
        print(self.extra.size())


if __name__ == '__main__':
    RootWindow().mainloop()

Results: