Command do klasy dziedziczonej z Button

Mam problem z przypisaniem command method do class dziedziczonej z Button

class Tail(tk.Button):
    def __init__(self, master, image, x,y, **kwargs):
        super().__init__(master, image=image, command=clickT(self))
        self.x = x
        self.y = y
    x: int
    y: int

    def setPos(self,x,y):
        self.x = x
        self.y = y

    def setImage(self,image):
        self.config(image=image)

def clickT():
    Tail.config(image=imgW)

Po kliknieciu na Tail dostaje error:

TypeError: Misc.configure() missing 1 required positional argument: 'self'

Problem pewnie banalny, ale utknalem na amen.

Pozdrawiam Usjwo

a co ma robic ta funcja clickT() ? przerobiłem swój kod żeby sie kompilował i zadziałał moze z tego kodu cos Ci sie przyda wystarczy dodac sciezke do pliku obrazka..

import tkinter as tk

class Tail(tk.Button):
    def __init__(self, master, image=None, x=0, y=0, **kwargs):
        # Provide default values for image, x, and y
        super().__init__(master, image=image, command=lambda: clickT(self), **kwargs)
        self.x = x
        self.y = y

        # Load the image (replace 'path/to/your/image.gif' with your actual image path)
        self.image = tk.PhotoImage(file='images/apple-touch-icon.png')  

    def setPos(self, x, y):
        self.x = x
        self.y = y

    def setImage(self, image):
        self.config(image=image)

def clickT(self):
    # Assuming you want to swap to a different image on click (optional)
    self.config(image=self.image)

root = tk.Tk()
# Initial state without image
button = Tail(root, image=None, x=100, y=50)  

# diffrent image
# another_image = tk.PhotoImage(file='path/to/another/image.png')
# button.setImage(another_image)

button.pack()
root.mainloop()

jesli jest ona poza classa to juz nie odnosimy sie do classy tylko musimy przekazac reference do tej funkcji z uzyciem lambdy, jesli planujesz dodatkowe arg. cos jak tu. no i funkcja musi miec przekazane instacje obiektu jesli chcesz operowac na tym samym obiekcie. (czyli wystarczylo dodac lambde jesli chcesz operowac na dodatkowych zmiennych )

import tkinter as tk

class MyButton(tk.Button):
  def __init__(self, master, text, function_to_call, additional_arg):
    super().__init__(master, text=text, command=lambda: function_to_call(self, additional_arg))

  def setPos(self,x,y):
        self.x = x
        self.y = y

  def setImage(self,image):
        self.config(image=image)


def print_message(button_instance, message):
  print(f"Message from button: {message}")
root = tk.Tk()
button = MyButton(root, text="Click me", function_to_call=print_message, additional_arg="Hello")
button.pack()
root.mainloop()

czyli wystarczylo dodac lambde jesli chcesz operowac na dodatkowych zmiennych

Dzieki!! Dziala.

Nie używaj dziedziczenia.

Riddle napisał(a):

Nie używaj dziedziczenia.

A dlaczego?

Usjwo napisał(a):

Riddle napisał(a):

Nie używaj dziedziczenia.

A dlaczego?

Bo gdzies w okolicach roku 2000 okazało się iż lepiej używać kompozycji niż dziedziczenia

https://en.wikipedia.org/wiki/Composition_over_inheritance

Usjwo napisał(a):

Riddle napisał(a):

Nie używaj dziedziczenia.

A dlaczego?

Z wielu powodów:

1. Po pierwsze dlatego, że jest to najciaśniejsza relacja między elementami w języku programowania (tight-coupling).
2. Po drugie, dlatego że skłania to do robienia niepotrzebnych klas, bo np. w przypadku tego przycisku - możesz po prostu stworzyć instancję tego przycisku i tyle - nie potrzebujesz nowej klasy.
3. Po trzecie, dlatego że nawet jak chcesz reużyć kod, to najlepszym sposobem na to jest albo wynieść kod do funkcji; albo jeśli już koniecznie chcesz klasę, to możesz stworzyć nową klasę, ale taką która po prostu korzysta z innej (a nie dziedziczy z niej). O tym mówi @KamilAdam w poście wyżej.
4. To buduje niezdrowe wyobrażenie tego czym OOP jest, to skłania do myślenia o programowaniu w kontekście "relacji między klasami", co jest całkowitym non-sensem. (Bo relacje między klasami oczywiście są, tylko że nie takie :D)
5. Utrudnia pracę z takimi klasami (nie da się zrobić łatwo Dependency Injection, O/C, dependency inversion), praktycznie nic się z czymś takim nie da bez usunięcia dziedziczenia.
6. Miejsce na dziedziczenie w programowaniu jest, ale to jest tak ogromnie mały procent, że nie warto na to poświęcać uwagi. Myślę że może w 1 przypadku na 1000 użyję dziedziczenia jeśli "pasuje" (bo klasa jest mała, i ma dużą kohizję z parentem), ale w 999 na 1000 przypadków lepiej jest użyć kompozycji bez dwóch zdań. Często w ogóle nie potrzebujesz dwóch klas, bo wystarczy użyć jednej.

Powody można mnożyć.

KamilAdam napisał(a):

Bo gdzies w okolicach roku 2000 okazało się iż lepiej używać kompozycji niż dziedziczenia

https://en.wikipedia.org/wiki/Composition_over_inheritance

To wiele wyjasnia. W okolicach roku 2000 ja juz bylem w okolicach 30+ Kiedy nauki pobieralem inheritance bylo swietym gralem
Dzieki!