Grundlegende Chunking-Techniken zum Erstellen besserer LLM-Anwendungen
Bild vom Autor

Einführung

Jede LLM-Anwendung (Massive Language Mannequin), die Informationen abruft, steht vor einem einfachen Downside: Wie zerlegt man ein 50-seitiges Dokument in Teile, die ein Modell tatsächlich verwenden kann? Wenn Sie additionally eine RAG-App (Retrieval-Augmented Era) erstellen, müssen Ihre Dokumente in Blöcke aufgeteilt werden, bevor Ihre Vektordatenbank etwas abruft und Ihr LLM Antworten generiert.

Die Artwork und Weise, wie Sie Dokumente in Abschnitte aufteilen, bestimmt Was Informationen, die Ihr System abrufen kann und Wie Genau kann es Fragen beantworten. Dieser Vorverarbeitungsschritt, der oft als untergeordnetes Implementierungsdetail betrachtet wird, bestimmt tatsächlich, ob Ihr RAG-System erfolgreich ist oder nicht.

Der Grund ist einfach: Der Abruf erfolgt auf Chunk-Ebene, nicht auf Dokumentebene. Richtiges Chunking verbessert die Abrufgenauigkeit, reduziert Halluzinationen und stellt sicher, dass das LLM fokussierten, relevanten Kontext erhält. Schlechtes Chunking breitet sich durch Ihr gesamtes System aus und führt zu Fehlern, die durch Abrufmechanismen nicht behoben werden können.

Dieser Artikel behandelt wesentliche Chunking-Strategien und erklärt, wann die einzelnen Methoden anzuwenden sind.

Warum Chunking wichtig ist

Einbettungsmodelle und LLMs verfügen über endliche Kontextfenster. Dokumente überschreiten normalerweise diese Grenzwerte. Chunking löst dieses Downside, indem es lange Dokumente in kleinere Segmente aufteilt, bringt jedoch einen wichtigen Kompromiss mit sich: Chunks müssen klein genug sein, um einen effizienten Abruf zu ermöglichen, und gleichzeitig groß genug bleiben, um die semantische Kohärenz zu wahren.

Die Vektorsuche arbeitet mit Einbettungen auf Chunk-Ebene. Wenn Chunks mehrere Themen vermischen, stellen ihre Einbettungen einen Durchschnitt dieser Konzepte dar, was einen präzisen Abruf erschwert. Wenn Blöcke zu klein sind, fehlt ihnen ausreichend Kontext, damit das LLM nützliche Antworten generieren kann.

Die Herausforderung besteht darin, den Mittelweg zu finden, bei dem die Blöcke semantisch fokussiert und dennoch kontextuell vollständig sind. Kommen wir nun zu den eigentlichen Chunking-Techniken, mit denen Sie experimentieren können.

1. Chunking mit fester Größe

Chunking mit fester Größe Teilt Textual content basierend auf einer vorgegebenen Anzahl von Token oder Zeichen auf. Die Umsetzung ist unkompliziert:

• Wählen Sie eine Blockgröße (normalerweise 512 oder 1024 Token).
• Überlappung hinzufügen (normalerweise 10–20 %)
• Teilen Sie das Dokument

Die Methode ignoriert die Dokumentstruktur vollständig. Textual content wird unabhängig von semantischen Grenzen an beliebigen Stellen geteilt, oft mitten im Satz oder in der Mitte des Absatzes. Überlappung trägt dazu bei, den Kontext an Grenzen zu bewahren, geht aber nicht auf das Kernproblem der strukturblinden Aufteilung ein.

Trotz seiner Einschränkungen bietet das Chunking mit fester Größe eine solide Grundlage. Es ist schnell, deterministisch und eignet sich intestine für Dokumente ohne starke Strukturelemente.

Wann zu verwenden: Basisimplementierungen, einfache Dokumente, schnelles Prototyping.

2. Rekursives Chunking

Rekursives Chunking verbessert Ansätze mit fester Größe, indem es natürliche Textgrenzen berücksichtigt. Es versucht, an immer feineren Separatoren zu spalten – zuerst bei Absatzumbrüchen, dann bei Sätzen, dann bei Wörtern – bis die Abschnitte in die Zielgröße passen.

Rekursives Chunking
Bild vom Autor

Der Algorithmus versucht, semantisch verwandte Inhalte zusammenzuhalten. Wenn beim Teilen an Absatzgrenzen Abschnitte entstehen, die innerhalb der Größenbeschränkung liegen, wird der Vorgang dort beendet. Wenn Absätze zu groß sind, wird die Aufteilung auf Satzebene rekursiv nur auf übergroße Abschnitte angewendet.

Dadurch bleibt mehr von der ursprünglichen Struktur des Dokuments erhalten als durch die willkürliche Zeichenaufteilung. Chunks neigen dazu, sich an natürlichen Denkgrenzen auszurichten, was sowohl die Relevanz des Abrufs als auch die Qualität der Generierung verbessert.

Wann zu verwenden: Allzweckanwendungen, unstrukturierter Textual content wie Artikel und Berichte.

3. Semantisches Chunking

Anstatt sich auf Charaktere oder Strukturen zu verlassen, Semantisches Chunking nutzt Bedeutung, um Grenzen zu bestimmen. Der Prozess bettet einzelne Sätze ein, vergleicht ihre semantische Ähnlichkeit und identifiziert Punkte, an denen es zu Themenverschiebungen kommt.

Semantisches Chunking
Bild vom Autor

Die Implementierung umfasst die Berechnung der Einbettungen für jeden Satz, das Messen der Abstände zwischen aufeinanderfolgenden Satzeinbettungen und die Aufteilung, wenn die Distanz einen Schwellenwert überschreitet. Dadurch entstehen Blöcke, in denen der Inhalt um ein einzelnes Thema oder Konzept herum zusammenhängt.

Der Rechenaufwand ist höher. Das Ergebnis sind jedoch semantisch kohärente Blöcke, die häufig die Abrufqualität komplexer Dokumente verbessern.

Wann zu verwenden: Dichte wissenschaftliche Arbeiten, technische Dokumentation, bei der sich die Themen unvorhersehbar ändern.

4. Dokumentbasiertes Chunking

Dokumente mit expliziter Struktur – Markdown-Header, HTML-Tags, Codefunktionsdefinitionen – enthalten natürliche Aufteilungspunkte. Das dokumentenbasierte Chunking nutzt diese Strukturelemente.

Für Markdown auf Header-Ebene aufteilen. Teilen Sie für HTML semantische Tags wie auf <part> oder <article>. Teilen Sie Code nach Funktions- oder Klassengrenzen auf. Die resultierenden Blöcke richten sich nach der logischen Organisation des Dokuments, die normalerweise mit der semantischen Organisation korreliert. Hier ist ein Beispiel für dokumentbasiertes Chunking:

Dokumentenbasiertes Chunking
Bild vom Autor

Bibliotheken mögen LangChain Und LamaIndex stellen spezielle Splitter für verschiedene Formate bereit, die die Parsing-Komplexität bewältigen und es Ihnen ermöglichen, sich auf die Parameter der Blockgröße zu konzentrieren.

Wann zu verwenden: Strukturierte Dokumente mit klaren hierarchischen Elementen.

5. Spätes Chunking

Spätes Chunking kehrt die typische Einbettungs- und dann Chunking-Sequenz um. Betten Sie zunächst das gesamte Dokument mithilfe eines Lengthy-Context-Modells ein. Teilen Sie dann das Dokument auf und leiten Sie Chunk-Einbettungen ab, indem Sie die relevanten Einbettungen auf Token-Ebene aus der vollständigen Dokumenteinbettung mitteln.

Dadurch bleibt der globale Kontext erhalten. Die Einbettung jedes Blocks spiegelt nicht nur seinen eigenen Inhalt wider, sondern auch seine Beziehung zum umfassenderen Dokument. Verweise auf frühere Konzepte, gemeinsame Terminologie und dokumentweite Themen bleiben in den Einbettungen kodiert.

Der Ansatz erfordert Einbettungsmodelle mit langem Kontext, die in der Lage sind, ganze Dokumente zu verarbeiten, was seine Anwendbarkeit auf Dokumente angemessener Größe beschränkt.

Wann zu verwenden: Technische Dokumente mit erheblichen Querverweisen, Gesetzestexte mit internen Abhängigkeiten.

6. Adaptives Chunking

Adaptives Chunking Passt Chunk-Parameter dynamisch basierend auf Inhaltsmerkmalen an. Dichte, informationsreiche Abschnitte erhalten kleinere Teile, um die Granularität beizubehalten. Spärliche, kontextbezogene Abschnitte erhalten größere Teile, um die Kohärenz zu wahren.

Adaptives Chunking
Bild vom Autor

Die Implementierung verwendet in der Regel Heuristiken oder leichtgewichtige Modelle, um die Inhaltsdichte zu bewerten und die Blockgröße entsprechend anzupassen.

Wann zu verwenden: Dokumente mit stark schwankender Informationsdichte.

7. Hierarchisches Chunking

Durch hierarchisches Chunking entstehen mehrere Granularitätsebenen. Große übergeordnete Blöcke erfassen umfassende Themen, während kleinere untergeordnete Blöcke spezifische Particulars enthalten. Rufen Sie zum Zeitpunkt der Abfrage zuerst grobe Blöcke ab und führen Sie dann einen Drilldown in feinkörnige Blöcke innerhalb relevanter übergeordneter Elemente durch.

Dies ermöglicht sowohl übergeordnete Abfragen („Was deckt dieses Dokument ab?“) als auch spezifische Abfragen („Wie lautet die genaue Konfigurationssyntax?“) unter Verwendung desselben Chunked-Korpus. Die Implementierung erfordert die Aufrechterhaltung der Beziehungen zwischen Chunk-Ebenen und deren Durchquerung während des Abrufs.

Wann zu verwenden: Große technische Handbücher, Lehrbücher, umfassende Dokumentation.

8. LLM-basiertes Chunking

Beim LLM-basierten Chunking haben wir Verwenden Sie ein LLM, um Chunk-Grenzen zu bestimmen und das Chunking in intelligentes Terrain treiben. Anstelle von Regeln oder Einbettungen analysiert das LLM das Dokument und entscheidet basierend auf semantischem Verständnis, wie es aufgeteilt wird.

LLM-basiertes Chunking
Bild vom Autor

Zu den Ansätzen gehören das Aufteilen von Textual content in atomare Sätze, das Erstellen von Zusammenfassungen für Abschnitte oder das Identifizieren logischer Haltepunkte. Das LLM kann Blöcke auch mit Metadaten oder kontextbezogenen Beschreibungen anreichern, die den Abruf verbessern.

Dieser Ansatz ist teuer – er erfordert LLM-Aufrufe für jedes Dokument –, erzeugt aber hochkohärente Blöcke. Bei anspruchsvollen Anwendungen, bei denen die Abrufqualität die Kosten rechtfertigt, übertrifft LLM-basiertes Chunking häufig einfachere Methoden.

Wann zu verwenden: Anwendungen, bei denen die Abrufqualität wichtiger ist als die Verarbeitungskosten.

9. Agentisches Chunking

Agentic Chunking erweitert LLM-basierte Ansätze um Lassen Sie einen Agenten jedes Dokument analysieren und dynamisch die entsprechende Chunking-Strategie auswählen. Der Agent berücksichtigt die Dokumentstruktur, die Inhaltsdichte und das Format, um professional Dokument zwischen festen, rekursiven, semantischen oder anderen Ansätzen zu wählen.

Agentisches Chunking
Bild vom Autor

Dies behandelt heterogene Dokumentensammlungen, bei denen eine einzelne Strategie schlecht funktioniert. Der Agent könnte dokumentbasiertes Chunking für strukturierte Berichte und semantisches Chunking für narrative Inhalte innerhalb desselben Korpus verwenden.

Der Kompromiss besteht zwischen Komplexität und Kosten. Jedes Dokument erfordert eine Agentenanalyse, bevor mit dem Chunking begonnen werden kann.

Wann zu verwenden: Vielfältige Dokumentensammlungen, bei denen die optimale Strategie erheblich variiert.

Abschluss

Chunking bestimmt, welche Informationen Ihr Abrufsystem finden kann und welchen Kontext Ihr LLM zur Generierung erhält. Nachdem Sie nun die verschiedenen Chunking-Techniken verstanden haben, Wie wählen Sie eine Chunking-Strategie für Ihre Anwendung aus?? Sie können dies basierend auf Ihren Dokumentmerkmalen tun:

• Kurze, eigenständige Dokumente (FAQs, Produktbeschreibungen): Keine Aufteilung erforderlich
• Strukturierte Dokumente (Markdown, HTML, Code): Dokumentbasiertes Chunking
• Unstrukturierter Textual content (Artikel, Berichte): Versuchen Sie es mit rekursivem oder hierarchischem Chunking, wenn das Chunking mit fester Größe keine guten Ergebnisse liefert
• Komplexe, hochwertige Dokumente: Semantisches oder adaptives oder LLM-basiertes Chunking
• Heterogene Sammlungen: Agentisches Chunking

Berücksichtigen Sie auch das Kontextfenster Ihres Einbettungsmodells und typische Abfragemuster. Wenn Benutzer spezifische sachliche Fragen stellen, bevorzugen Sie aus Gründen der Präzision kleinere Abschnitte. Wenn Abfragen das Verständnis eines breiteren Kontexts erfordern, verwenden Sie größere Abschnitte.

Noch wichtiger ist, dass Sie Metriken festlegen und testen. Verfolgen Sie die Abrufgenauigkeit, Antwortgenauigkeit und Benutzerzufriedenheit über verschiedene Chunking-Strategien hinweg. Verwenden Sie repräsentative Abfragen mit bekanntermaßen richtigen Antworten. Messen Sie, ob die richtigen Blöcke abgerufen werden und ob das LLM aus diesen Blöcken genaue Antworten generiert.

Frameworks wie LangChain Und LamaIndex bieten vorgefertigte Splitter für die meisten Strategien an. Implementieren Sie bei benutzerdefinierten Ansätzen die Logik direkt, um die Kontrolle zu behalten und Abhängigkeiten zu minimieren. Viel Spaß beim Chunken!

Referenzen und weiteres Lernen

Open-Supply-CLI-Instruments haben im Entwickler und in der KI-Gemeinschaften viel Aufregung geschaffen. Mit der Veröffentlichung von Claude’s Codex CLI, OpenAIs Codex CLI und in jüngerer Zeit von Googles Gemini CLI gibt es einen plötzlichen Anstieg des Interesses an CLIs im Allgemeinen. Durch die Einbeziehung der KI -Unterstützung in Routineaufgaben verändern diese Instruments die Artwork und Weise, wie Entwickler ihre Terminals nutzen.

Entwickler können das Codeverständnis verbessern, das Debuggen beschleunigen und schwierige Codierungsaufgaben durch die Verwendung dieser CLIs automatisieren. Instruments wie Codex CLI helfen Benutzern dabei, den Code effizienter zu schreiben, zu analysieren und zu verbessern, indem sie starke KI-gesteuerte Funktionen wie Codegenerierung, Refactoring und Inline-Dokumentation direkt in die Befehlszeile bringen. Der Markt ist mit der Einführung von Gemini Cli, einem leichten Open-Supply-Ersatz von Google, der schnell an Popularität gewinnt, noch spannender geworden.

Schauen wir uns nun genauer an, wie Gemini CLI und Codex Cli bei der Prüfung abschneiden.

Was sind Gemini CLI und Codex CLI?

Gemini Cli: Ein Open-Supply-AI-Agent von Google, der Gemini-Modelle (wie Gemini 2.5 Professional) in das Terminal für Entwickler integriert.

Codex CLI: Ein Open-Supply-Befehlszeilen-Software, das aus OpenAIs ursprünglichem Codex CLI entnommen wurde und jetzt mehrere KI-Anbieter unterstützt, darunter Gemini 2.5 Professional. Es ermöglicht Entwicklern, mit großen Sprachmodellen im Terminal für Aufgaben wie Codegenerierung, Refactoring und Skript -Erklärung zu interagieren.

Wenn Sie nach detaillierten Vorgehensweise suchen, lesen Sie unsere Führer in jedem CLI -Software:

Set up

Stellen Sie vor der Set up sicher, dass die Systemanforderungen erfüllt sind.

Systemanforderungen

NodeJS ist eine häufige Voraussetzung für beide CLIs. Sie können node.js installieren, indem Sie den Anweisungen auf seiner offiziellen Seite folgen: https://nodejs.org/

Installationsschritte für Codex CLI

1. Überprüfen Sie die Model von Node.js:

node --version

2. Stellen Sie sicher, dass es sich um NodeJS Model 22 oder höher handelt.
3. Installieren Sie die Codex CLI weltweit:

npm set up -g @openai/codex

4. Oder mit PNPM:

pnpm add -g @openai/codex

5. Setzen Sie Ihre OpenAI -API -Style (wenn die Datei.

export OPENAI_API_KEY="your-openai-api-key"

6. Fügen Sie diese Zeile Ihrer Shell -Konfigurationsdatei (z. B. ~/.bashrc, ~/.zshrc) für die Persistenz hinzu.
7. Ausführen von Codex CLI:

codex

8. Oder übergeben Sie eine Eingabeaufforderung direkt:

codex "clarify this codebase to me"

Installationsschritte für Gemini CLI

1. Überprüfen Sie die Model von Node.js:

node --version

Stellen Sie sicher, dass es 18 oder höher ist.

2. Installieren Sie Gemini CLI weltweit (empfohlen):

npm set up -g @google/gemini-cli

3. Alternativ direkt ohne Set up ausführen:

npx https://github.com/google-gemini/gemini-cli

4. Authentifizieren:
   1. Standardeinstellung: Melden Sie sich bei der Aufgabe mit Ihrem Google -Konto an (Browserfenster wird geöffnet).
   2. API -Schlüssel (für die erweiterte Verwendung):
      1. Holen Sie sich Ihren API -Schlüssel von Google AI Studio.
      2. Stellen Sie es mit dem folgenden Eintrag in Ihre Umgebung ein:
         exportieren gemini_api_key = „your-api-key“
5. Run Gemini Cli:

gemini

6. Oder übergeben Sie eine Eingabeaufforderung direkt:

gemini "Howdy, are you able to assist me with coding?"

Dinge zu beachten

• Für beide Instruments müssen Node.js und NPM (Node Bundle Supervisor) in Ihrem Systempfad installiert und verfügbar sein.
• Für Codex CLI ist Node.js 22+ erforderlich, während Gemini CLI mit Node.js 18+ funktioniert.
• Beide erfordern eine Authentifizierung über API -Schlüssel oder Kontoanmeldung für die volle Funktionalität.
• Unter Home windows wird Codex CLI am besten über WSL2 ausgeführt, um die vollständige Kompatibilität zu erhalten.
• Denken Sie daran, wenn Sie Ihre CLI für ein bestimmtes Projekt verwenden möchten, stellen Sie sicher, dass das aktuelle Arbeitsverzeichnis auf dem Ordnerpfad festgelegt ist, in dem Ihr Projekt existiert.

Führen Sie unsere CLI -Instanzen aus

Lassen Sie uns die Leistung zwischen den 2 Modellen mit 3 Aufgaben vergleichen

• Erstellen eines Arbeitsmodells auf einem lokalen Gastgeber
• Lesen einer komplexen Codebasis und Erläuterung des Codes
• Fehlerdebuggen

Probieren wir es zuerst mit Codex CLI aus:

Codex Cli

Wenn alle Anforderungen erfüllt sind, können wir mit den Checks beginnen.

Aufgabe 1 – Erklären Sie unsere Codebasis

Wir können sehen, dass Codex eine detaillierte Zusammenfassung unserer Codebasis bereitstellen kann, die ehrlich und überraschend intestine warfare. Darüber hinaus fordert Codex CLI uns vorübergehend auf, Zugriff auf bestimmte Codesegmente zu gewähren, die wir auf der Grundlage unseres Urteils gewähren oder ablehnen können. Es enthält einen respektablen Bericht, nachdem es eine angemessene Zeit zum Nachdenken benötigt hat.

Der hochrangige Zweck, das Repository-Format, die Schlüsselkomponenten, die Entrance-Finish-Web sites und die Vermögenswerte sind zusammen mit einer Zusammenfassung enthalten. Obwohl ich die Hauptdateien ziemlich mehrdeutige Namen gegeben hatte, warfare ich immer noch schockiert, als ich feststellte, dass sie alle vorherigen Iterationen der Codedateien in chronologischer Reihenfolge dekodieren konnte.

Aufgabe 2 – Fehlerdebuggen

Da wir den CODEX -CLI -Zugriff auf unsere gesamte Datenbank zulassen, sei es privat oder geschützt, wird unsere Autorisierung gefragt, bevor sie Code -Snippets lesen. Wenn wir es zulassen, wird es angemessen auf unser Snippet zugreifen.

Insgesamt warfare es in der Lage, jeden winzigen Fehler zu erkennen, und bot gelegentlich Korrekturen für einige unachtsame Fehler im Code an, wobei unnötige Teile entfernt wurden, die einen Einfluss auf einen Teil der Latenz leicht hatten.

Aufgabe 3 – Ergänzungen zu Codebasis

Dies umfasste das Verständnis, wie jedes Modul in verschiedenen Verzeichnissen definiert wurde und das Wissen zwischen jeder Abhängigkeit überbrückt, um sicherzustellen, dass ein neues Verzeichnis erstellt wurde, um die zu erstellen new.py Dateien für die Ergänzungen, die wir beim Anfordern von Zugriff angefordert hatten.

Versuchen wir nun zu untersuchen, wie die Gemini CLI funktioniert.

Gemini Cli

Ich mochte das Dracula -Thema.

Im Gegensatz zu Codex CLI, bei dem wir nur unseren OpenAI_API_Key exportieren müssen, haben wir drei verschiedene Möglichkeiten, sich hier anzumelden: Verwenden unseres Google Mail -Kontos, Kopieren des Gemini_API_Key von AISTUDIO oder Verwendung von Vertex -AI -Anmeldeinformationen.

Aufgabe 1 – Erklären Sie unsere Codebasis

Der Hauptunterschied, den ich beobachtete, warfare, dass Gemini im Gegensatz zu Codex CLI, der nach dem Zugriff auf bestimmte Verzeichnisse fragt, diesen Schritt überspringt und stattdessen unsere gesamte Datenbank scannt. Trotzdem bietet es meiner Erfahrung nach einen anständigen Überblick, aber es ist keineswegs so intestine wie Codex in Bezug auf die Ausgabe.

Aufgabe 2 – Fehlerdebuggen

Meiner Meinung nach wurde die Reaktion von Gemini deutlich besser erklärt als die von Codex, da es in der Lage warfare, die Arten von Sicherheitsrisiken zu identifizieren, sie zu erklären und Dateinamen als Referenzen für weitere Untersuchungen und vorgeschlagene Änderungen anzugeben. Darüber hinaus würde das Anbieten einer gründlichen Strategie zur Bekämpfung jeder dieser Fehler ermöglichen, dass der Code geändert werden kann, ohne seine Funktionalität zu beeinträchtigen, wenn die erforderlichen Anweisungen eingehalten würden.

Aufgabe 3 – Ergänzungen zu Codebasis

Gemini Cli arbeitete nicht für diese Arbeitsbelastung, so dass keine Ausgabe erzeugt wurde.

Gemini Cli vs Codex Cli: Endes Urteil

Lesen Sie auch: 10 Möglichkeiten, wie Schüler Cursor AI kostenlos verwenden können

In Kombination mit intelligenteren VIBE -Codierungs -IDes wie CursorAnwesend WindsurfUnd andere, solche CLIs würden zweifellos neue Möglichkeiten für den Stimmmodus -Codierungs -Workflow und die Anwendungsoperation eröffnen. Es kann jedoch noch Sicherheits- und Datenschutzschwachstellen bestehen. Daher würde ich empfehlen, vorsichtig zu sein, was und wo in unserer Codebasis wir diesen CLIS -Zugriff gewähren.

Häufig gestellte Fragen

Genai Praktikant @ Analytics Vidhya | Letzte Jahr @ Vit Chennai
Leidenschaftlich für KI und maschinelles Lernen, ich bin bestrebt, als KI/ML -Ingenieur oder Datenwissenschaftler in Rollen einzutauchen, wo ich einen echten Einfluss haben kann. Ich freue mich sehr, modern Lösungen und hochmoderne Fortschritte auf den Tisch zu bringen. Meine Neugier treibt mich an, KI über verschiedene Bereiche hinweg zu erkunden und die Initiative zu ergreifen, um sich mit Knowledge Engineering zu befassen, um sicherzustellen, dass ich vorne bleibe und wirksame Projekte liefere.

Rückblick auf meine sechsjährige Karriere als Datenwissenschaftler

Ich habe meinen ersten Vollzeitjob als Information Scientist im Januar 2018 als Affiliate Product Analyst angetreten. Dies ist das 7. Jahr meiner Karriere bei Information Scientist, jetzt als Senior Information Scientist. Sechs Jahre sind wie im Flug vergangen (vor allem wegen der Pandemie). Ich habe für zwei Unternehmen gearbeitet, mindestens 10 verschiedene Groups unterstützt, mit Partnern in den Bereichen Produkt, Entwicklung, Design, Finanzen und Betrieb zusammengearbeitet und bin in verschiedene Bereiche der Information Science eingestiegen, darunter Information Pipelining, Dashboarding, Metriküberprüfung …

Bild vom Autor

Wir alle schreiben Funktionen, wenn wir in Python programmieren. Aber schreiben wir unbedingt Intestine Funktionen? Nun, lasst es uns herausfinden.

Mit Funktionen in Python können Sie modularen Code schreiben. Wenn Sie eine Aufgabe haben, die Sie an mehreren Stellen ausführen müssen, können Sie die Logik der Aufgabe in eine Python-Funktion packen. Und Sie können die Funktion jedes Mal aufrufen, wenn Sie diese bestimmte Aufgabe ausführen müssen. So einfach der Einstieg in Python-Funktionen auch scheint, das Schreiben wartbarer und leistungsfähiger Funktionen ist nicht so einfach.

Aus diesem Grund werden wir einige Vorgehensweisen untersuchen, die Ihnen dabei helfen, sauberere und leicht zu wartende Python-Funktionen zu schreiben. Lassen Sie uns beginnen …

1. Schreiben Sie Funktionen, die nur eine Sache tun

Beim Schreiben von Funktionen in Python ist es oft verlockend, alle zugehörigen Aufgaben in einer einzigen Funktion zusammenzufassen. Dies kann Ihnen zwar dabei helfen, Dinge schnell zu programmieren, wird jedoch in naher Zukunft die Wartung Ihres Codes nur mühsam machen. Dies erschwert nicht nur das Verständnis dessen, was eine Funktion tut, sondern führt auch zu anderen Problemen, wie z. B. zu vielen Parametern (mehr dazu später!).

Als bewährte Vorgehensweise sollten Sie immer versuchen, Ihre Funktion nur eine Sache – eine Aufgabe – ausführen zu lassen und diese intestine zu machen. Aber manchmal müssen Sie für eine einzelne Aufgabe möglicherweise eine Reihe von Unteraufgaben abarbeiten. Wie entscheiden Sie additionally, ob und wie die Funktion umgestaltet werden soll?

Es hängt davon ab Was Anhand der Aufgaben, die die Funktion ausführen soll, und der Komplexität der Aufgabe können Sie die Trennung der Belange zwischen den Unteraufgaben erarbeiten. Und dann ermitteln Sie eine geeignete Ebene, auf der Sie die Funktion in mehrere Funktionen umgestalten können – wobei sich jede auf eine bestimmte Unteraufgabe konzentriert.

Refactoring-Funktionen | Bild vom Autor

Hier ist ein Beispiel. Schauen Sie sich die Funktion an analyze_and_report_sales:

# fn. to investigate gross sales knowledge, calculate gross sales metrics, and write it to a file
def analyze_and_report_sales(knowledge, report_filename):
	total_sales = sum(merchandise('value') * merchandise('amount') for merchandise in knowledge)
	average_sales = total_sales / len(knowledge)
    
	with open(report_filename, 'w') as report_file:
    	    report_file.write(f"Whole Gross sales: {total_sales}n")
    	    report_file.write(f"Common Gross sales: {average_sales}n")
    
	return total_sales, average_sales

Es ist ganz einfach zu erkennen, dass es in zwei Funktionen umgestaltet werden kann: eine zum Berechnen der Verkaufskennzahlen und eine andere zum Schreiben der Verkaufskennzahlen in eine Datei wie folgt:

# refactored into two funcs: one to calculate metrics and one other to put in writing gross sales report
def calculate_sales_metrics(knowledge):
	total_sales = sum(merchandise('value') * merchandise('amount') for merchandise in knowledge)
	average_sales = total_sales / len(knowledge)
	return total_sales, average_sales

def write_sales_report(report_filename, total_sales, average_sales):
	with open(report_filename, 'w') as report_file:
    	    report_file.write(f"Whole Gross sales: {total_sales}n")
    	    report_file.write(f"Common Gross sales: {average_sales}n")

Jetzt ist es einfacher, Probleme mit der separaten Berechnung von Verkaufsmetriken und Dateivorgängen zu beheben. Und hier ist ein Beispiel für einen Funktionsaufruf:

knowledge = ({'value': 100, 'amount': 2}, {'value': 200, 'amount': 1})
total_sales, average_sales = calculate_sales_metrics(knowledge)
write_sales_report('sales_report.txt', total_sales, average_sales)

Sie sollten die Datei „sales_report.txt“ mit den Verkaufsmetriken in Ihrem Arbeitsverzeichnis sehen können. Dies ist ein einfaches Beispiel für den Einstieg, aber es ist besonders hilfreich, wenn Sie an komplexeren Funktionen arbeiten.

2. Fügen Sie Typhinweise hinzu, um die Wartbarkeit zu verbessern

Python ist eine dynamisch typisierte Sprache. Sie müssen additionally für die Variablen, die Sie erstellen, keine Typen deklarieren. Sie können jedoch Typhinweise hinzufügen, um den erwarteten Datentyp für Variablen anzugeben. Wenn Sie die Funktion definieren, können Sie die erwarteten Datentypen für die Parameter und die Rückgabewerte hinzufügen.

Da Python zur Laufzeit keine Typen erzwingt, hat das Hinzufügen von Typhinweisen zur Laufzeit keine Auswirkungen. Die Verwendung von Typhinweisen hat jedoch dennoch Vorteile, insbesondere im Hinblick auf die Wartbarkeit:

• Das Hinzufügen von Typhinweisen zu Python-Funktionen dient als Inline-Dokumentation und vermittelt eine bessere Vorstellung davon, was die Funktion macht und welche Werte sie verbraucht und zurückgibt.
• Wenn Sie Ihren Funktionen Typhinweise hinzufügen, können Sie Ihre IDE so konfigurieren, dass diese Typhinweise genutzt werden. So erhalten Sie hilfreiche Warnungen, wenn Sie versuchen, in einem oder mehreren Funktionsaufrufen ein Argument ungültigen Typs zu übergeben, Funktionen zu implementieren, deren Rückgabewerte nicht dem erwarteten Typ entsprechen, und dergleichen. So können Sie Fehler im Vorfeld minimieren.
• Sie können non-compulsory statische Typprüfer verwenden wie meinPy um Fehler früher zu erkennen, anstatt zuzulassen, dass durch Typ-Inkonsistenzen subtile Bugs entstehen, die schwer zu debuggen sind.

Hier ist eine Funktion, die Bestelldetails verarbeitet:

# fn. to course of orders
def process_orders(orders):
	total_quantity = sum(order('amount') for order in orders)
	total_value = sum(order('amount') * order('value') for order in orders)
	return {
    	'total_quantity': total_quantity,
    	'total_value': total_value
	}

Fügen wir der Funktion nun Typhinweise wie folgt hinzu:

# modified with sort hints
from typing import Checklist, Dict

def process_orders(orders: Checklist(Dict(str, float | int))) -> Dict(str, float | int):
	total_quantity = sum(order('amount') for order in orders)
	total_value = sum(order('amount') * order('value') for order in orders)
	return {
    	'total_quantity': total_quantity,
    	'total_value': total_value
	}

Mit der modifizierten Model erfahren Sie, dass die Funktion eine Liste von Wörterbüchern aufnimmt. Die Schlüssel des Wörterbuchs sollten alle Zeichenfolgen sein und die Werte können entweder Ganzzahlen oder Gleitkommawerte sein. Die Funktion gibt auch ein Wörterbuch zurück. Sehen wir uns einen Beispielfunktionsaufruf an:

# Pattern knowledge
orders = (
	{'value': 100.0, 'amount': 2},
	{'value': 50.0, 'amount': 5},
	{'value': 150.0, 'amount': 1}
)

# Pattern perform name
consequence = process_orders(orders)
print(consequence)

Hier ist die Ausgabe:

{'total_quantity': 8, 'total_value': 600.0}

In diesem Beispiel helfen uns Typhinweise, eine bessere Vorstellung davon zu bekommen, wie die Funktion funktioniert. In Zukunft werden wir Typhinweise für alle besseren Versionen von Python-Funktionen hinzufügen, die wir schreiben.

3. Akzeptieren Sie nur die Argumente, die Sie wirklich brauchen

Wenn Sie Anfänger sind oder gerade Ihre erste Entwicklerrolle übernommen haben, ist es wichtig, beim Definieren der Funktionssignatur an die verschiedenen Parameter zu denken. Es ist durchaus üblich, zusätzliche Parameter in die Funktionssignatur einzuführen, die die Funktion nie wirklich verarbeitet.

Wenn sichergestellt wird, dass die Funktion nur die tatsächlich erforderlichen Argumente annimmt, bleiben Funktionsaufrufe insgesamt sauberer und wartungsfreundlicher. In einem ähnlichen Zusammenhang ist zu beachten, dass zu viele Parameter in der Funktionssignatur die Wartung ebenfalls erschweren. Wie additionally definieren Sie einfach zu wartende Funktionen mit der richtigen Anzahl von Parametern?

Wenn Sie eine Funktionssignatur mit einer wachsenden Anzahl von Parametern schreiben, besteht der erste Schritt darin, alle nicht verwendeten Parameter aus der Signatur zu entfernen. Wenn auch nach diesem Schritt zu viele Parameter vorhanden sind, gehen Sie zurück zu Tipp Nr. 1: Teilen Sie die Aufgabe in mehrere Unteraufgaben auf und refaktorisieren Sie die Funktion in mehrere kleinere Funktionen. Dies hilft dabei, die Anzahl der Parameter unter Kontrolle zu halten.

Behalten Sie num_params unter Kontrolle | Bild vom Autor

Es ist Zeit für ein einfaches Beispiel. Hier enthält die Funktionsdefinition zur Berechnung der Schülernoten die teacher Parameter, der nie verwendet wird:

# takes in an arg that is by no means used!
def process_student_grades(student_id, grades, course_name, teacher'):
	average_grade = sum(grades) / len(grades)
	return f"Scholar {student_id} achieved a mean grade of {average_grade:.2f} in {course_name}."

Sie können die Funktion neu schreiben, ohne teacher Parameter wie folgt:

# higher model!
def process_student_grades(student_id: int, grades: record, course_name: str) -> str:
	average_grade = sum(grades) / len(grades)
	return f"Scholar {student_id} achieved a mean grade of {average_grade:.2f} in {course_name}."

# Utilization
student_id = 12345
grades = (85, 90, 75, 88, 92)
course_name = "Arithmetic"
consequence = process_student_grades(student_id, grades, course_name)
print(consequence)

Hier ist die Ausgabe des Funktionsaufrufs:

Scholar 12345 achieved a mean grade of 86.00 in Arithmetic.

4. Erzwingen Sie Nur-Schlüsselwort-Argumente, um Fehler zu minimieren

In der Praxis akzeptieren die meisten Python-Funktionen mehrere Argumente. Sie können Argumente an Python-Funktionen als Positionsargumente, Schlüsselwortargumente oder eine Mischung aus beidem übergeben. Lesen Sie Python-Funktionsargumente: Ein definitiver Leitfaden für eine schnelle Überprüfung der Funktionsargumente.

Einige Argumente sind von Natur aus positionell. Manchmal können Funktionsaufrufe, die nur positionelle Argumente enthalten, jedoch verwirrend sein. Dies gilt insbesondere dann, wenn die Funktion mehrere Argumente desselben Datentyps annimmt, von denen einige erforderlich und einige non-compulsory sind.

Wie Sie sich erinnern, werden bei Positionsargumenten die Argumente an die Parameter in der Funktionssignatur in der Dasselbe Reihenfolge, in der sie im Funktionsaufruf erscheinen. Änderungen in der Reihenfolge der Argumente können additionally zu subtilen Fehlern führen.

Es ist oft hilfreich, Non-compulsory Argumente Nur Schlüsselwort. Dadurch wird auch das Hinzufügen optionaler Parameter viel einfacher – ohne bestehende Aufrufe zu unterbrechen.

Hier ist ein Beispiel. Die process_payment Funktion nimmt eine optionale description Zeichenfolge:

# instance fn. for processing transaction
def process_payment(transaction_id: int, quantity: float, forex: str, description: str = None):
	print(f"Processing transaction {transaction_id}...")
	print(f"Quantity: {quantity} {forex}")
	if description:
    		print(f"Description: {description}")

Angenommen, Sie möchten die optionale description ein reines Schlüsselwortargument. So können Sie es machen:

# implement keyword-only arguments to reduce errors
# make the non-compulsory `description` arg keyword-only
def process_payment(transaction_id: int, quantity: float, forex: str, *, description: str = None):
	print(f"Processing transaction {transaction_id}:")
	print(f"Quantity: {quantity} {forex}")
	if description:
    		print(f"Description: {description}")

Betrachten wir einen Beispielfunktionsaufruf:

process_payment(1234, 100.0, 'USD', description='Cost for companies')

Dies gibt aus:

Processing transaction 1234...
Quantity: 100.0 USD
Description: Cost for companies

Versuchen Sie nun, alle Argumente als Positionsargumente zu übergeben:

# throws error as we attempt to go in additional positional args than allowed!
process_payment(5678, 150.0, 'EUR', 'Bill cost') 

Sie erhalten die folgende Fehlermeldung:

Traceback (most up-to-date name final):
  File "/house/balapriya/better-fns/tip4.py", line 9, in 
	process_payment(1234, 150.0, 'EUR', 'Bill cost')
TypeError: process_payment() takes 3 positional arguments however 4 got

5. Geben Sie keine Hear aus Funktionen zurück; verwenden Sie stattdessen Generatoren

Es ist durchaus üblich, Python-Funktionen zu schreiben, die Sequenzen wie z. B. eine Liste von Werten generieren. Sie sollten jedoch möglichst vermeiden, Hear von Python-Funktionen zurückzugeben. Stattdessen können Sie sie als Generatorfunktionen neu schreiben. Generatoren verwenden eine verzögerte Auswertung; sie liefern additionally Elemente der Sequenz bei Bedarf, anstatt alle Werte im Voraus zu berechnen. Lesen Sie Erste Schritte mit Python-Generatoren für eine Einführung in die Funktionsweise von Generatoren in Python.

Nehmen wir als Beispiel die folgende Funktion, die die Fibonacci-Folge bis zu einer bestimmten Obergrenze generiert:

# returns a listing of Fibonacci numbers
def generate_fibonacci_numbers_list(restrict):
	fibonacci_numbers = (0, 1)
	whereas fibonacci_numbers(-1) + fibonacci_numbers(-2) <= restrict:
    		fibonacci_numbers.append(fibonacci_numbers(-1) + fibonacci_numbers(-2))
	return fibonacci_numbers

Es handelt sich um eine rekursive Implementierung, die rechenintensiv ist und das Auffüllen und Zurückgeben der Liste erscheint ausführlicher als nötig. Hier ist eine verbesserte Model der Funktion, die Generatoren verwendet:

# use mills as an alternative
from typing import Generator

def generate_fibonacci_numbers(restrict: int) -> Generator(int, None, None):
	a, b = 0, 1
	whereas a <= restrict:
    		yield a
    	a, b = b, a + b

In diesem Fall gibt die Funktion ein Generatorobjekt zurück, das Sie dann durchlaufen können, um die Elemente der Sequenz zu erhalten:

restrict = 100
fibonacci_numbers_generator = generate_fibonacci_numbers(restrict)
for num in fibonacci_numbers_generator:
	print(num)

Hier ist die Ausgabe:

0
1
1
2
3
5
8
13
21
34
55
89

Wie Sie sehen, kann die Verwendung von Generatoren insbesondere bei großen Eingabegrößen viel effizienter sein. Außerdem können Sie mehrere Generatoren miteinander verketten, sodass Sie mit Generatoren effiziente Datenverarbeitungspipelines erstellen können.

Einpacken

Und das struggle’s. Den gesamten Code finden Sie auf GitHub. Hier ist eine Übersicht über die verschiedenen Tipps, die wir besprochen haben:

• Schreiben Sie Funktionen, die nur eine Sache tun
• Fügen Sie Typhinweise hinzu, um die Wartbarkeit zu verbessern
• Akzeptieren Sie nur die Argumente, die Sie wirklich brauchen
• Erzwingen Sie Argumente, die nur aus Schlüsselwörtern bestehen, um Fehler zu minimieren
• Geben Sie keine Hear von Funktionen zurück; verwenden Sie stattdessen Generatoren

Ich hoffe, Sie fanden sie hilfreich! Wenn Sie diese Vorgehensweisen beim Schreiben von Python-Funktionen nicht bereits ausprobieren, sollten Sie sie ausprobieren. Viel Spaß beim Programmieren!

Bala Priya C ist Entwicklerin und technische Redakteurin aus Indien. Sie arbeitet gerne an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessens- und Fachgebiete umfassen DevOps, Datenwissenschaft und natürliche Sprachverarbeitung. Sie liest, schreibt, programmiert und trinkt gerne Kaffee! Derzeit arbeitet sie daran, ihr Wissen zu lernen und mit der Entwickler-Group zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt auch ansprechende Ressourcenübersichten und Programmier-Tutorials.