CommunityCodierung & Entwicklunggithub.com

python-reduce-complexity

Misst und reduziert die Komplexität von Python-Code, gezählt als imperative lexikalische Tokens durch ein gebündeltes Skript. Schlägt Vereinfachungen vor, verifiziert die funktionale Äquivalenz und misst erneut, um die Reduzierung zu bestätigen.

Was ist python-reduce-complexity?

Diese Fähigkeit für KI-Agenten (wie Claude Code) analysiert und reduziert die Komplexität von Python-Code, gemessen an der Anzahl imperativer lexikalischer Tokens. Sie unterstützt Python-Dateien (.py) und Jupyter-Notebooks (.ipynb) und führt einen mehrstufigen Prozess durch: Basislinienmessung, Vorschlagen von Vereinfachungen (z. B. Ersetzen von manuellen Schleifen durch Comprehensions, Verwenden von Standardbibliotheksfunktionen, Entfernen von totem Code), Anwenden und Verifizieren der Äquivalenz (durch Tests und direkten Vergleich) sowie erneute Messung. Die Fähigkeit erlaubt signifikante Refactorings, solange die Gesamttokenzahl sinkt, und bietet detaillierte Argumente für nicht streng äquivalente Änderungen. Sie ist nützlich, wenn ein Benutzer bittet, Python-Code zu vereinfachen, zu verkleinern, zu messen oder zu prüfen, und folgt den projektspezifischen Regeln (CLAUDE.md).

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/jachymb/skills/tree/main/python-reduce-complexity

Installed? Explore more Codierung & Entwicklung skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Python-Komplexität reduzieren

Dateien: $ARGUMENTS

Code-Komplexität sollte möglichst niedrig gehalten werden. Komplexität wird gemessen als die Anzahl der Python-Lexikalischen Tokens, die Teil von imperativem Code sind: Syntax, die etwas ausführt. Deklarationen organisieren den Code, ohne Logik hinzuzufügen, daher sind sie kostenlos.

Was zählt

imperative_tokens.py, neben dieser Datei, ist die Definition.

Nicht gezählt:

  • def- und class-Köpfe, vom ersten Dekorator bis zum Doppelpunkt, der den Rumpf öffnet: Dekorateure, Parameter, Standardwerte, Basisklassen, Rückgabeannotation. All das wird einmal ausgewertet, mit der Definition, und deklariert eine Schnittstelle.
  • Typannotationen (x: int = 1 zählt als x = 1, ein bloßes x: int als nichts) und type-Aliase.
  • Importe, Kommentare, Docstrings, Zeilenumbrüche und Einrückungen.
  • Der Name eines Schlüsselwortarguments in einem Aufruf: f(key=value) wiegt genauso viel wie f(value). Die Übergabe eines Arguments per Schlüsselwort wird in den meisten Situationen bevorzugt, daher kostet es nichts.
  • Attributqualifikation: a.b.c.d wiegt genauso viel wie d. Ein Punktpfad benennt ein Objekt. Es zu zählen würde from numpy import log gegenüber np.log oder einen lokalen Alias für self.x belohnen, und keines ändert irgendeine Logik.

Gezählt: jedes andere Token. Anweisungen (if, for, while, try, with, return, raise, …), Zuweisungen, Operatoren, Aufrufe, Literale, Comprehensions und Lambdas, mit ihren Kommas, Doppelpunkten und beiden Klammern eines Paares. Ein Aufruf wiegt daher einen mehr als der Operator, der dasselbe tut: a.update(b) sind 4 Tokens, a |= b sind 3.

Für ein Notebook (.ipynb) zählen die Codezellen. Eine Magie- oder Shell-Zeile (%config …, !pip …) zählt als der Aufruf, in den IPython sie umwandelt. Eine Zelle unter einer Zellenmagie (%%bash, %%html) zählt 0. Die Ausnahme ist eine Zellenmagie, die den Rumpf als Python ausführt (IPythons ExecutionMagics, wie %%time und %%capture): die Magie zählt als eine Zeilenmagie und der Rumpf als Code. Eine Magie, die nicht in der installierten IPython eingebaut ist, wie eine von einer Erweiterung, zählt 0 und das Skript gibt eine Warnung aus: geben Sie diese Warnung im Bericht weiter. Ein Notebook, dessen Kernel nicht Python ist, zählt 0. Das Skript importiert IPython nur, wenn ihm ein Python-Notebook übergeben wird, und fragt es, welche Magies eingebaut sind.

Die Zählung ist ein Indikator

Eine niedrigere Zählung ist der Beleg einer Vereinfachung, nicht die Vereinfachung selbst.

  • Signifikante Refactorings sind erlaubt: eine neue Hilfsfunktion, eine neue Basisklasse, eine neue Datei. Die Zählung wird dann über alle betroffenen Dateien kombiniert verglichen (Schritt 4), sodass zwischen Dateien verschobene Logik auf Null herauskommt.
  • Erfordert eine eigene Begründung: Logik verschieben, wo das Skript nicht hinsieht, also ein Standardwert, ein Dekoratorargument, ein Basisklassenausdruck oder eine neue Abhängigkeit. Der Vorschlag gibt an, warum die Änderung gut ist, abgesehen von der niedrigeren Zählung.
  • Verboten: Code in einem String für eval oder exec oder ähnliche externe Ausführung.
  • Das Inlinen einer Variable, die nur einmal verwendet wird, ist nur akzeptabel, wenn es die Lesbarkeit nicht beeinträchtigt. Ein guter Name für eine Zwischenvariable hilft dem Leser, die Absicht zu verstehen.
  • Keine Reduktionen: Entfernen von Verhalten (Validierung an einer Grenze, Fehlerbehandlung, ein unterstützter Fall) und das Opfern von Lesbarkeit für ein paar Tokens (ein dichtes Einzeiler, ein weggelassenes abschließendes Komma).

Die eigenen Regeln des Projekts (CLAUDE.md, Codierungsrichtlinien) haben Vorrang vor der Zählung.

Änderungen, die nicht streng äquivalent sind

Eine Änderung kann das Verhalten zugunsten der Einfachheit verändern, wenn eine Argumentation zeigt, dass das Programm korrekt bleibt. Der Vorschlag gibt an, was sich unterscheidet, für welche Eingaben, und die Argumentation mit ihrem Beleg im Code:

  • Die unterschiedliche Eingabe kann nicht auftreten. Beleg: der Code, der den Wert erstellt oder validiert.
  • Nichts beobachtet den Unterschied. Beleg: jeder Verbraucher des Werts, aufgelistet.
  • Der Unterschied ist beobachtbar, aber harmlos: andere Ziehungen aus einem gesetzten Generator, ein langsamerer Algorithmus, ein früher ausgelöster Fehler. Dies erfordert die ausdrückliche Zustimmung des Benutzers. Das gilt auch für jeden Unterschied, den ein öffentlicher Rückgabewert, eine geschriebene Ausgabe oder ein Test sehen kann.

Einige Beispiele, um die Form der Argumentation zu zeigen. Jede andere Änderung, die das Verhalten verändert, wird auf die gleiche Weise argumentiert, unabhängig davon, ob sie einem dieser ähnelt:

Einfachere FormErsetztWas sich unterscheidet
x or standardx if x is not None else standardein falsy x (0, "", []) wird auch ersetzt
zip(a, b)Indizierung beider mit range(len(a))ein kürzeres b schneidet stillschweigend ab; strict=True behält die Prüfung
a // bint(a / b)negative Operanden runden anders herum
max(xs, key=f)sorted(xs, key=f)[-1]bei Gleichstand gewinnt das erste der gleichen Elemente, nicht das letzte
xs.sort()xs = sorted(xs)die vom Aufrufer übergebene Liste wird mutiert
Counter(xs)eine Zählschleifeein fehlender Schlüssel liest 0 statt zu erheben
ein @dataclass, gelesen als row.nameein Dict-Eintrag, gelesen als row["name"]Indizierung, .get, **-Entpacken und JSON-Serialisierung des Eintrags funktionieren nicht mehr

Die Argumentation stützt sich auf den Code, nicht auf heutige Daten: „Die Datei hat keine Duplikate" ist keine, und auch nicht „wahrscheinlich eindeutig". Das Entfernen von Verhalten bleibt ausgeschlossen: Validierung an einer Grenze wird nicht wegargumentiert.

Im Zweifelsfall entscheidet der Benutzer. Wenn die Beweislage unvollständig ist (ein Verbraucher außerhalb des Repositorys, ein von nicht lesbarem Code erstellter Wert) oder unklar ist, ob ein Unterschied harmlos ist, entscheiden Sie nicht darüber. Bieten Sie die Änderung mit dem, was sich unterscheidet und was unbekannt ist, fahren Sie mit den anderen Vorschlägen fort, und wenden Sie sie nur mit Zustimmung des Benutzers an.

Standardbibliotheksformen

Eine Stichprobe häufiger Fälle, um zu zeigen, wie eine solche Ersetzung aussieht. Es ist kein Katalog: die eingebauten Funktionen, die Standardbibliothek und die installierten Abhängigkeiten des Projekts bieten viele weitere, und eine Ersetzung, die in der Tabelle fehlt, ist genauso gültig wie eine, die darin enthalten ist.

StandardformErsetztWas sich unterscheidet
@dataclass, mit field(default_factory=list), order=True, frozen=Trueein __init__, das nur seine Parameter speichert; ein selbstgeschriebener __eq__, __repr__, __lt__, __hash__eine Klasse, die keinen __eq__ hatte, vergleicht jetzt nach Wert und ist unhashbar (eq=False behält Identität); __eq__ vergleicht auch die Klasse; ein explizites None wird nicht mehr zum Standardwert
any(p(x) for x in xs), all(…), next(filter(p, xs), None)eine Flag- oder Suchschleife mit breaknichts
defaultdict(list)if key not in groups: groups[key] = []Lesen eines fehlenden Schlüssels fügt ihn ein
@cache, @cached_propertyein Memo-Dict; ein if self._x is None-Lazy-Attribut@cache auf einer Methode behält jede Instanz am Leben, auf der sie aufgerufen wurde; die Eigenschaft wird mit del zurückgesetzt, nicht durch Zuweisen von None
itemgetter("foo"), str.strip, operator.mulein Lambda, das nur indiziert, eine Methode aufruft oder einen Operator anwendetstr.strip erhebt einen Fehler bei einem Wert, der kein str ist
Path(path).read_text()with open(path) as file: und file.read()nichts
name.removeprefix(prefix), line.partition("=")startswith und ein Slice; split und eine Längenprüfungnichts
chain.from_iterable(xss)[x for xs in xss for x in xs]ein Iterator: in list einwickeln, wenn das Ergebnis indiziert oder zweimal gelesen wird
batched(xs, n)xs[i:i + n] über range(0, len(xs), n)ein Iterator von Tupeln, keine Liste von Slices
@singledispatcheine isinstance-Kettedie spezifischste registrierte Klasse gewinnt, nicht der erste Test, der passt; das dispatchierte Argument ist das erste, das positionell übergeben wird

@singledispatch und die Argumente von @dataclass verschieben Logik in einen Kopf, wo das Skript nicht hinsieht. Ihr Grund abgesehen von der Zählung: die generierten Methoden folgen der Feldliste und können nicht davon abweichen, und jeder Typ bekommt eine eigene Funktion, die ein neuer Typ nicht berührt.

Andere Formen helfen nur abhängig vom Kontext, daher brauchen sie zusätzliche Überlegung:

  • itertools.product oder itertools.combinations können eine verschachtelte Schleife ersetzen.
  • functools.reduce kann eine Faltung ersetzen, die keinen eingebauten Befehl hat.

Schritte

  1. Basislinie. Führen Sie das Skript auf den Dateien des Arguments mit dem Interpreter des Projekts (Python 3.12 oder neuer) aus und behalten Sie die Ausgabe:

    python "${CLAUDE_SKILL_DIR}/imperative_tokens.py" <datei.py | notebook.ipynb> [...]
    

    Führen Sie jetzt die Tests aus: eine Testsuite, die vor der Änderung fehlschlägt, kann danach nichts verifizieren. Wenn der Benutzer nur nach einer Messung gefragt hat, melden Sie diese und stoppen Sie.

  2. Vorschlagen. Lesen Sie den Code dafür, was er berechnet, nicht nach Mustern, die passen, und fragen Sie bei jeder Funktion, Schleife und Verzweigung, ob dasselbe Ergebnis mit weniger ausgedrückt werden kann. Die Listen und Tabellen in dieser Fähigkeit zeigen, wie eine Vereinfachung aussieht. Sie sind nicht der Suchraum: das meiste, was entfernt werden kann, ist spezifisch für den vorliegenden Code, und keine Liste antizipiert es. Ein Durchgang, der nur die aufgeführten Muster prüft, ist unvollständig.

    Die üblichen Funde, ungefähr in der Reihenfolge des Ertrags:

    • toter Code: ungenutzte Funktionen, Parameter und Verzweigungen, die nicht genommen werden können;
    • dieselbe Logik zweimal geschrieben, hier oder in einer anderen Datei, die ein gemeinsamer Helfer oder eine Basisklasse einmal halten würde;
    • handgeschriebener Code, den die Standardbibliothek, ein eingebauter Befehl oder eine installierte Abhängigkeit bereits bereitstellt; Standardbibliothekswerkzeuge wie itertools, functools, operator, collections oder dataclasses können helfen, und „Standardbibliotheksformen" oben listet die häufigen Fälle auf;
    • Schleifen, die einen Wert aufbauen: eine Comprehension ist normalerweise besser als eine Schleife, und gelegentlich ist das eingebaute filter oder map einfacher als eine Comprehension;
    • Methodenaufrufe, die ein überladener Operator ersetzt: a | b für a.union(b), a |= b für a.update(b), a @ b für a.dot(b). Überprüfen Sie zuerst die Operandentypen: |= auf einem Set benötigt ein Set, während .update() jedes Iterable nimmt;
    • Verzweigungen, die in Daten (eine Map) oder in den allgemeinen Pfad kollabieren;
    • Zustand und Konvertierungen, die nur existieren, um rückgängig gemacht zu werden;
    • defensive Prüfungen weg von einer Programm-Grenze;
    • Code strenger als seine Eingaben es erfordern, wo eine einfachere Form sich nur auf Eingaben unterscheidet, die nicht auftreten können oder in Weisen, die nichts beobachtet (Tabelle oben).

    Gehen Sie dann noch einmal durch den Code, zuerst die längsten Funktionen, nach dem, was in keine dieser Kategorien passt: ein anderer Algorithmus oder eine andere Datenstruktur, die die Buchhaltung überflüssig macht; eine Neuordnung einer Berechnung, sodass ein Spezialfall verschwindet; eine Funktion einer Abhängigkeit, die das Projekt bereits verwendet und die die gesamte Arbeit erledigt; zwei Funktionen, die sich in einem Wert unterscheiden. Ein solcher Vorschlag unterliegt denselben Regeln wie jeder aufgeführte.

    Um einen Schnipsel, wie die Zeilen eines Vorschlags vorher und nachher, abzuwägen, pipen Sie ihn an das Skript ohne ein Dateiargument. Es gibt nur die Zählung aus. Der Schnipsel muss für sich allein parsen, also entrücken Sie ihn:

    python "${CLAUDE_SKILL_DIR}/imperative_tokens.py" <<'EOF'
    uncounted |= set(range(first, last))
    EOF
    

    Zeigen Sie jeden Vorschlag als Codeform, die Schlüsselzeilen vorher und nachher, mit der erwarteten Einsparung bei Tokens, den anderen Dateien, die er berührt, und jeder Begründung oder Argumentation, die die obigen Abschnitte fordern. Wenden Sie auf Zustimmung des Benutzers an, oder direkt, wenn er bereits darum gebeten hat, die Änderungen vorzunehmen.

  3. Anwenden und verifizieren, einen Vorschlag nach dem anderen, sodass ein Fehler auf seine Ursache zeigt.

    • Vor der ersten Bearbeitung einer Datei außerhalb der Basislinie messen Sie sie und fügen Sie sie zur Basislinie hinzu. Eine neue Datei beginnt bei 0.
    • Die Tests bestehen, unverändert. Ein Test, der zusammen mit dem von ihm geprüften Code bearbeitet wird, prüft ihn nicht mehr; wenn einer geändert werden muss (er ruft einen entfernten Helfer auf), sagen Sie dies.
    • Tests, die die geänderten Zeilen nie ausführen, beweisen nichts. Führen Sie für diese Zeilen die alte Version (git stash, oder git show HEAD:<pfad> in eine temporäre Datei) und die neue Version auf denselben Eingaben, einschließlich Randfällen, aus und vergleichen Sie die Ausgaben. Gleitkommaergebnisse sind identisch, oder der Bericht gibt die Größe des Unterschieds an.
    • Eine Änderung, die nicht streng äquivalent ist, wird auf den Eingaben verglichen, die ihre Argumentation zulässt. Überprüfen Sie dann die Argumentation selbst: lesen Sie den Code, der den Wert erstellt, oder suchen Sie nach jedem Verbraucher. Belege, die nicht halten, lassen den Vorschlag fallen.
    • Eine Änderung im öffentlichen Verhalten (eine Signatur, ein Ausnahmetyp, die Reihenfolge einer Ausgabe) ist keine äquivalente Änderung. Sie benötigt die ausdrückliche Zustimmung des Benutzers.
  4. Erneute Messung. Führen Sie das Skript auf allen betroffenen Dateien aus: denen des Arguments und jeder anderen Datei, die die Änderung bearbeitet oder erstellt hat. Eine gelöschte Datei endet bei 0. Die kombinierte Summe ist niedriger als die kombinierte Basislinie, oder die Änderung wird rückgängig gemacht. Das gilt auch für eine, die Schritt 3 nicht bestanden hat.

  5. Bericht. Pro betroffener Datei und kombiniert: Tokens vorher, nachher und der Unterschied. Dann, was die Äquivalenz verifiziert hat (welche Tests, welche direkten Vergleiche), jede Änderung, die nicht streng äquivalent ist, mit dem, was sich unterscheidet und ihrer Argumentation, jede Änderung, die auf die Entscheidung des Benutzers wartet, und jeder Vorschlag, der fallengelassen wurde, mit dem Grund.

Verwandte Skills