... sind nicht gut, weil in ”Funktionen” auf globale Werte zugegriffen wird.

#!/usr/bin/env python3
import tkinter as tk
from functools import partial


def on_button_click(label):
label.config(text="Button wurde geklickt!")


def on_entry_change(label, event):
label.config(text=f"Eingabe ...

... ich habe das über Python gelöst, und bekomme auch 29 Ergebnisse:
#!/usr/bin/env python3
from collections import defaultdict
from functools import partial
from pathlib import Path

import iconv

MODULES_FILE_PATH = Path("/usr/lib/x86_64-linux-gnu/gconv/gconv-modules")


def parse_gconf_modules(lines ...

... Idee. Ich hatte die EBCDIC-Kodierung(en) mit Python selbst gefunden:
#!/usr/bin/env python3
import codecs
import encodings
from functools import partial
from pathlib import Path


def is_text_encoding(name):
try:
codecs.lookup(name)
#
# Try encoding a string to filter out non text encodings ...

... mal etwas mit dem Designer gebastelt, was absichtlich größere Texte hat:
https://i.imgur.com/70ygL9Q.png

buttons.py:
from functools import partial
from pathlib import Path
import sys

from PyQt5 import QtCore
from PyQt5.QtWidgets import QApplication, QMainWindow
from PyQt5.uic import loadUi ...

... Wahl ja einen Grund. Ich würde die relativ zur normalen Grösse machen.

Den Hack bei ``lambda`` Defaultwerte zu binden macht man seit `functools.partial()` nicht mehr. Das wurde genau für so etwas eingeführt.

Ohne Not ``pop(0)`` ist unschön. Die Liste ist ja gemischt worden, also macht es ...

... 588
super().__init__(
pin, pull_up=pull_up, active_state=active_state,
threshold=threshold, queue_len=queue_len, sample_wait=1 /
sample_rate, partial=partial, pin_factory=pin_factory, average=mean)
self._queue.start()

line 257
super().__init__(
pin, pull_up=pull_up, active_state=active ...

... übernimmt und dann die Berechnung startet.
Beispielhaft würde das so aussehen:
#!/usr/bin/env python3
import tkinter as tk
from functools import partial


def process_user_entry(user_entry, temperature):
temperature.set(user_entry.get())
calculate_something(user_entry.get())


def calculate ...

... was Du eigentlich machst.
Alles was Funktionen brauchen, muß man über die Argumente übergeben. Bei GUIs kann man noch mit functools.partial arbeiten, aber irgendwann kommt man um Klassen nicht herum.
place sollte man nicht benutzen, auch läßt man am besten die Defaulteinstellungen, was ...

Hallo


Wobei man hier statt `partial()` auch zusätzliche Argumente an `after()` übergeben kann, die Tk dann beim Aufruf an die Rückruffunktion übergibt.


ja danke... , jetzt habe ich das. Übergabe mit .after war falsch. Manchmal braucht man nur einen kleinen Tip :D


from tkinter import *

def ...

Wobei man hier statt `partial()` auch zusätzliche Argumente an `after()` übergeben kann, die Tk dann beim Aufruf an die Rückruffunktion übergibt.

... zweites Beispiel übergibt statt der Funktion None an after, weil das der Rückgabewerte der Funktion ist. (Bzw. würde das übergeben, wenn er nicht in der Rekursion stecken bleiben würde und so nie das Ende der Funktion erreicht.

Such mal nach "functools.partial". Das wurde hier sehr häufig diskutiert.

Du willst ja nur sortieren: oder falls der Import nicht zählt, noch kürzer: Da war halt Python2 ohne keyword-only-Argumenten noch besser:

... man für Eingaben mit Var-Objekten, dann ist man unabhängig von der eigentlichen Darstellung.

Hier ein Beispiel, wie man noch mit `functools.partial` an die Daten kommt.
import tkinter as tk
from tkinter.ttk import Combobox
from functools import partial

SPELLING_ALPHABET = [
"wählen ...

... vars = []
for value, text in aMaske:
variable = tk.IntVar(einzelmarken_label, value=value)
checkbox_vars.append(variable)
variable.trace("w", partial(on_intvar_change, text=text, variable=variable))
checkbox = tk.Checkbutton(einzelmarken_label, text=text, variable=variable)
checkbox.pack(side ...

... Beispiel, das das Problem zeigt, wäre hilfreich, denn mein Versuch funktioniert einwandfrei:
import tkinter as tk
from functools import partial

def on_intvar_change(name, index, mode, text, variable):
print(text, variable.get())

def main():
atemschutzmasken = [
(0, "keine"),
(1 ...

... heisst.

Funktionen und Methoden bekommen alles was sie ausser Konstanten benötigen, als Argument(e) übergeben. Hier kommt man noch mit `functools.partial()` aus, aber bei jeder nicht-trivialen GUI braucht man objektorientierte Programmierung (OOP), also muss eigene Klassen schreiben können.

Namen ...

... key!r}")
record[key] = KEY_TO_VALUE[key](value)
if len(record) == len(KEY_TO_VALUE):
yield record
record = {}
if record:
raise ValueError("partial record")

def main():
with open("test.txt", "r", encoding="ascii") as lines:
for record in parse_records(lines):
print(record)


if __name ...

... Programmierung voraus. Also eigene Klassen schreiben zu können, weil man sich Zustand über Aufrufe hinweg merken muss. In einfachen Fällen kann man den noch bei den Aufrufen an die Rückruffunktionen durchreichen — da ist `functools.partial()` oft hilfreich — aber dieses Vorgehen hat Grenzen.

Um wirklich eine Liste zu erhalten muss da noch ein `list(…)` drum herum und bei ``list(map(partial(…`` ist die Frage ob eine „list comprehension“ nicht die einfachere/lesbarere Wahl wäre.

Was die doppelte Codezeile angeht: keine kopfgesteuerte Schleife, sondern ``while True:`` und dann in der ...

... die herumgereicht wird....

Ob sich das dann so einfach wie in diesem Pseudocode lösen lässt, ist dann die Frage...
from functools import partial

def berechne_gasstrom_für_einen_zylinder(ein_zylinder, druck):
return ein_zylinder.berechne_gasstrom(druck)

def berechne_irgendwie_neuen_druck ...