04.02.2025
Rust und Python: Das Beste aus beiden Welten vereinen
Python Fuzzy Search mit Rust & PyO3
Fuzzy Search findet unscharfe Übereinstimmungen in Strings, stößt in Python aber bei großen Datenmengen an Grenzen. Rust löst dieses Problem effizient. Mit PyO3 lässt sich Rust als Python-Erweiterung nutzen, um rechenintensive Prozesse zu beschleunigen. Dieser Artikel zeigt, wie Fuzzy Search in Python mit Rust umgesetzt wird und welche Werkzeuge – insbesondere PyO3, Maturin und die Nucleo-Bibliothek – dabei helfen.
Inhaltsverzeichnis
Pfuzzer: Ein Python Fuzzy Searcher mit Rust
Die Kombination von Rust und Python wird immer beliebter, insbesondere für performance-sensitive Anwendungen. Mit PyO3 lassen sich Rust-Module als Python-Erweiterung nutzen, wodurch sich die Geschwindigkeit und Effizienz von Rust mit der Flexibilität von Python verbinden lassen.
Ein herausragendes Beispiel für diese Integration ist Pfuzzer – eine Python-Bibliothek für Fuzzy Search, die auf der leistungsstarken Rust-Bibliothek Nucleo basiert. Doch Pfuzzer ist mehr als nur eine praktische Lösung für unscharfe Suchanfragen: Es zeigt, wie PyO3 genutzt werden kann, um Rust-Code nahtlos in Python einzubinden und rechenintensive Prozesse zu optimieren.
In diesem Artikel erfährst du, wie Pfuzzer funktioniert, wie PyO3 die Entwicklung von Rust-Erweiterungen für Python erleichtert und wie du eine Fuzzy Search in Python mit Rust umsetzen kannst.
Erfahre mehr über unsere Python-EntwicklungsdiensteWas ist PyO3?
PyO3 ist ein Framework, das Rust-Code als native Python-Module verfügbar macht. Damit lassen sich Rust-Programme in Python integrieren, ohne auf Leistung oder Speichersicherheit verzichten zu müssen. Mit PyO3 kannst du:
- Python-APIs mit Rust entwickeln
- Bestehende Rust-Bibliotheken in Python einbinden
- Python-Funktionen aus Rust heraus aufrufen
Das Framework übernimmt technische Details wie Speicherverwaltung, Datenstrukturen und die Interaktion zwischen Python- und Rust-Laufzeit.
Dank der hohen Performance von Rust und der Flexibilität von Python ist PyO3 ideal für rechenintensive Anwendungen, darunter Datenverarbeitung, maschinelles Lernen und performante Fuzzy-Suchfunktionen – wie es Pfuzzer demonstriert.
Pfuzzer: Ein Python-Modul für Fuzzy Search mit Rust
Pfuzzer ist eine Python-Bibliothek für Fuzzy Search, die auf der Rust-Bibliothek Nucleo basiert. Sie ermöglicht eine schnelle und effiziente unscharfe Suche – ideal für Anwendungen mit großen Datenmengen.
Warum Rust für Fuzzy Search?
- Performance: Rust ist deutlich schneller als reines Python
- Speichersicherheit: Kein Garbage Collector, kein Memory Leak
- Einfache Integration: Mit PyO3 als Python-Erweiterung in Rust nutzbar
Pfuzzer installieren und einrichten
Um ein Rust-Projekt mit PyO3 in Python zu nutzen, eignet sich Maturin. Maturin erleichtert den Build-Prozess, indem es Rust-Code als Python-Wheel kompiliert. So kann das Modul wie jede andere Python-Bibliothek installiert und verwendet werden.
Einrichtung eines PyO3-Projekts
1. Projekt erstellen
Für die Projektstruktur nutzen wir den uv Package Manager::
$ mkdir pfuzzer
$ cd pfuzzer
$ uv venv
$ uv add maturin
$ . .env/bin/activate
2. Maturin initialisieren
Führe Maturin aus und lasse dir alle benötigten Dateien erstellen:
$ maturin init
✔ 🤷 What kind of bindings to use? · pyo3
✨ Done! New project created pfuzzer
Dieser Befehl erzeugt die Dateien Cargo.toml (Rust-Dependency-Management) und lib.rs (Rust-Code, der aus Python aufgerufen wird).
Der Befehl maturin develop installiert dann dein frisch erstelltes Rust Package in dem vorher erstellten virtualenv. Da wir uv benutzen muss die --uv flag ergänzt werden. Mit maturin build –release kann das Package für den Roll-Out gebuildet werden.
Pfuzzer: Implementierung und Funktionsweise
Das Pfuzzer Python Package ist ein Wrapper für die Rust Library nucleo. Wie bereits gezeigt ist ein Wrapper einer bestehenden Library leicht mit PyO3 umzusetzen. Trotzdem will ich kurz auf die Implementierung eingehen und die Funktionsweise erklären. Der gesamte Code kann hier eingesehen werden.
Dank PyO3 ist die Implementierung recht einfach. So stellt es mehrere Rust Attributes bereit, um Rust Code in Python aufrufbar zu machen. Hier z. B. die Implementierung des grundsätzlichen Python Moduls:
mod python_classes;
use pyo3::prelude::*;
/// A Python fuzzy searcher module implemented in Rust.
#[pymodule]
fn pfuzzer(m: &Bound<'_, PyModule>) -> PyResult<()> {
m.add_class::<python_classes::pfuzzer::Pfuzzer>()?;
Ok(())
}
Das ist so wenig Code, man könnte fast meinen, es ist bereits in Python geschrieben. Aber kurz die wichtigsten Abschnitte erklärt:
#[pymodule]--> teilt dem compiler mit, dass es sich hier um ein Python Modul handelt. Dadurch wird in die Funktion PyModule als Variable injected, welche dann als Eingangspunkt für unser Python Modul benutzt werden kann.m.add_class::<...>--> weist unserem Modul eine Klasse zu, in diesem Fall die noch nicht spezifizierte Pfuzzer Klasse.
Wir können auch deine Python Anwendung mit Rust und PyO3 beschleunigen.
Es gibt noch andere Möglichkeiten Rust Code dem Modul zuzuweisen. Darunter m.add_function. Anders als bei add_class wird hier allerdings nicht die Turbofish syntax verwendet sondern man muss die Rust Function mit einem Makro aufrufen. Mehr dazu in den PyO3 docs.
Pfuzzer-Klasse in Rust umsetzen
Da Rust keine Klassen kennt, verwenden wir stattdessen Structs, um das Verhalten der Pfuzzer-Klasse zu definieren:
#[pyclass]
pub struct Pfuzzer {
pub matcher: Matcher,
}
Als Attribut wird hier pyclass vergeben. Dadurch wird das Struct als Python Klasse markiert und kann dann, wie vorher gezeigt, dem Modul zugewiesen werden.
Konstruktor für Pfuzzer
Jede gute Klasse braucht natürlich auch einen Konstruktor:
use nucleo::{Config, Matcher, Utf32Str};
#[pymethods]
impl Pfuzzer {
#[new]
pub fn new() -> PyResult<Self> {
Ok(Pfuzzer {
matcher: Matcher::new(Config::DEFAULT),
})
}
...
Durch #[pymethods] deklarieren wir den gesamten Implementation Block als Python Methoden der Pfuzzer Klasse. Der Konstruktor selbst wird mit #[new] markiert. Aktuell unterstützt PyO3 nämlich nur die __new__ Magic Method und nicht __init__.
Fuzzy Search in Rust: compare_strings Methode
Zu guter Letzt noch die eigentliche “Logik” unseres Wrappers. Ich darf präsentieren, die compare_strings Methode:
pub fn compare_strings(&self, targets: Vec<String>, query: String) -> Vec<Option<u16>> {
let mut res = Vec::<Option<u16>>::new();
for target in targets {
res.push(self.matcher.to_owned().fuzzy_match(
Utf32Str::Ascii(target.as_bytes()),
Utf32Str::Ascii(query.as_bytes()),
))
}
return res;
}
Wie man schnell erkennen kann, benutzt sie den nucleo Matcher und führt für jeden Ziel String das fuzzy matching anhand des angegebenen Query Strings aus.
Ergebnis der Methode ist dann ein optionaler Integer pro Ziel String, welcher aussagt, wie gut der Query String mit dem Ziel String übereinstimmt. Je höher das Ergebnis, desto besser die Übereinstimmung. Ein Null / None Wert sagt aus, dass Ziel und Query überhaupt nicht (oder zumindest nicht messbar) übereinstimmen.
Pfuzzer in Python verwenden
Und wie sieht das Ganze nun in Python aus? Bitteschön:
from pfuzzer import Pfuzzer
pf = Pfuzzer()
print(pf.compare_strings(["hello world", "hello blueshoe"], "helo world"))
>>> [257, None]
Laut Ergebnis Matrix, ist also der erste String der String, welcher am besten mit der Query übereinstimmt.
Wenn du noch Ideen für neue Features für Pfuzzer, oder gar Optimierungsgedanken, hast dann lass gerne einen Kommentar da. Oder mach ein Issue auf Github auf!
Fazit: Rust und Python effizient kombiniert
In diesem Artikel haben wir gezeigt, wie Rust und Python mit PyO3 zusammenarbeiten, um performante Lösungen für Fuzzy Search zu ermöglichen. Pfuzzer ist ein Beispiel dafür, wie sich die Geschwindigkeit und Sicherheit von Rust mit der Flexibilität von Python verbinden lassen. Die nahtlose Integration über PyO3 und Maturin eröffnet neue Möglichkeiten – besonders für rechenintensive Anwendungen wie Datenverarbeitung und maschinelles Lernen.
Wenn auch du Lust auf richtig schnelles Python hast, dann schreib uns gerne in den Kommentaren und wir erörtern die Einsatzmöglichkeiten von Rust in deinem Python Projekt! Auch über Kommentare zu deinem Einsatz von PyO3 freuen wir uns!
Häufige Fragen
1. Wie kann ich ein Python-Modul mit Rust und PyO3 erstellen?
Um ein Rust-Modul für Python zu schreiben, brauchst du PyO3 und Maturin. Die grundlegenden Schritte:
- Rust-Umgebung einrichten: Folgende Kommandos:
cargo new --lib my_project,cd my_project. - PyO3 hinzufügen: Füge in der
Cargo.tomldie Dependencypyo3 = { version = "0.18", features = ["extension-module"] }hinzu. - Modul implementieren:
use pyo3::prelude::*;und#[pymodule] - Mit Maturin bauen:
maturin build
2. Wie funktioniert Fuzzy Search in Rust mit der Nucleo-Bibliothek?
Die Nucleo-Bibliothek bietet einen leistungsstarken Fuzzy Matching Algorithmus, um die Ähnlichkeit zwischen Strings zu berechnen. Pfuzzer nutzt diese Bibliothek für schnelle unscharfe Suchen in Python.
3. Kann ich Rust-Module in bestehenden Python-Projekten verwenden?
Ja! Rust-Module lassen sich problemlos in bestehende Python-Projekte integrieren. Dank PyO3 kannst du Rust-Funktionen direkt als Python-Module importieren und nutzen.
Hast du noch Fragen oder eine Meinung? Mit deinem GitHub Account kannst Du es uns wissen lassen...
Hier sind ein paar Artikel, die du auch interessant finden könntest:
Analyse der Import-Zeit von Python Apps
Der schnelle Start von Python-Applikationen in Cloud-Umgebungen kann essentiell für dynamische Skalierung sein, wie beispielsweise das horizontale Pod-Autoscaling. In diesem Blogpost teilen wir unsere Methode, um die Importzeiten – und damit die Startzeit von Python-Apps – zu analysieren und zu optimieren.
Django-CORS: Sicherheit & Best Practices
CORS (Cross-Origin Resource Sharing) richtig zu konfigurieren, ist entscheidend für die Sicherheit und Funktionalität deiner Django-Anwendung. Erfahre, wie du Django-CORS effektiv einsetzt, um externe Anfragen sicher und zuverlässig zu handhaben.
FastAPI in Produktion: So klappt's!
Mit FastAPI kannst du von einer Vielzahl von Vorteilen profitieren, darunter Geschwindigkeit, Modernität und Flexibilität. Doch um sicherzustellen, dass deine FastAPI-Anwendung in der Produktion erfolgreich läuft, benötigst du die richtigen Strategien und Werkzeuge. Hier findest du die wichtigsten Best Practices und Tools, um deine Anwendung effizient und sicher zu betreiben.
FastAPI Dokumentation mit Programmierbeispielen
Es gibt eine Sache, die uns immer wieder umtreibt, wenn wir eine gute API bauen wollen - die Dokumentation. Insbesondere für öffentlich konsumierbare APIs weiß man nie, wer diese einsetzt und wie die Voraussetzungen des jeweiligen Entwicklers sind. Für eine besonders gute DX (= Developer Experience) statten wir unsere OpenAPI Dokumentationen mit Code-Beispielen in vielen Sprachen aus.
Django Entwicklung für Kubernetes
Wir haben uns erneut Gedanken gemacht, wie wir das Ausführen von Django-Anwendungen mehr Cloud Native und "ready for kubernetes" gestalten können. Als Resultat ist Django-Hurricane herausgekommen, welches wir in diesem Blogpost vorstellen und als Open Source-Projekt zur Verfügung stellen.
Weitere Blog Artikel
Entdecke spannende Einblicke und praktische Tipps in unseren neuesten Blogbeiträgen. Von Python und Rust über Kubernetes bis hin zu Django-Sicherheit und Frontend-Themen – hier findest du wertvolles Wissen für deine Projekte. Klicke hier, um alle Artikel zu erkunden!
Was unsere Kunden über uns sagen
- Ofa Bamberg GmbHB2B Online-Shop | B2C Website | Hosting | Betreuung | Security© Ofa Bamberg GmbH
- Ludwig-Maximilians-Universität MünchenPlattformentwicklung | Hosting | Betreuung | APIs | Website
Blueshoe hat unsere Forschungsdatenplattform Munich Media Monitoring (M3) entwickelt und uns hervorragend dabei beraten. Das Team hat unsere Anforderungen genau verstanden und sich aktiv in die Ausgestaltung der Software und der Betriebsumgebung eingebracht. Wir sind froh, dass auch Wartung und weiterführender Support in Blueshoes Händen liegen.
- Deutsches MuseumDigitalisierung | Beratung | Datenbank-Optimierung | GraphQL | CMSFoto: Anne Göttlicher
Im Rahmen eines komplexen Digitalisierungsprojekts für unsere Exponate-Datenbank war Blueshoe ein äußerst verlässlicher Partner. Sie haben uns nicht nur während des gesamten Projekts hervorragend beraten, sondern unsere Anforderungen perfekt umgesetzt. Dank ihrer Arbeit ist unsere Datenbank nun ein bedeutender Mehrwert für die weltweite wissenschaftliche Forschung.
- Fonds Finanz Maklerservice GmbHPlattformentwicklung | Prozess-Systeme | Hosting | Betreuung | Zertifikate | Website© Fonds Finanz Maklerservice GmbH
Blueshoe ist unsere verlängerte Werkbank für Entwicklung, Wartung und Support unserer Weiterbildungs- und Zertifizierungsplattformen. Das Team hat sich gründlich in unsere Abläufe eingearbeitet, und wir freuen uns, Blueshoe als zuverlässigen Partner an unserer Seite zu haben.
- Technische Universität HamburgPlattformentwicklung | Beratung | Prozess-Systeme | Hosting | Website
Seit 2019 unterstützt uns die Blueshoe GmbH tatkräftig bei der Entwicklung und Weiterentwicklung des "Digital Learning Lab" und der "Digital Learning Tools". Dank ihrer Beratung konnten wir von Anfang an auf eine zukunftssichere, moderne technische Struktur setzen. Die Zusammenarbeit ist reibungslos, und wir fühlen uns rundum gut betreut. Und davon profitieren dann auch die Lehrkräfte in Hamburg.
