Szeretjük a Pythont. Ez az adatfeldolgozás közös nyelve, amivel bármit megoldunk öt sorból. De legyünk őszinték, amikor több millió sort kell ciklusban feldolgozni, a Python csúnyán elvérzik. A megoldás eddig a C++ volt, de az olyan, mintha láncfűrésszel akarnál vajat kenni. Itt jön a képbe a Rust.
A Python legnagyobb előnye egyben a hátránya is, a dinamikus, interpretált nyelv. A „Global Interpreter Lock” (GIL) néven ismert mechanizmus sokszor megfogja a többszálú teljesítményt, és a memóriakezelés sem éppen a hatékonyság csúcsa. Ezzel szemben a Rust egy modern, rendszerközeli nyelv, ami memóriabiztos, nincsenek váratlan összeomlások, és elképesztően gyors.
De nem kell választanod a kettő között! A mai cikkben megmutatom, hogyan házasítsd össze őket. A lassú, számításigényes feladatokat kiszervezzük Rustba, miközben a kényelmes vezérlést megtartjuk Pythonban. Ez a PyO3 és a Maturin ereje.
Miért pont Rust?
Miért nem C++ vagy Python? Mert a Rust fordítóprogramja olyan, mint egy nagyon szigorú, de profi mentor. Nem engedi, hogy memóriaszivárgást okozz, vagy véletlenül felülírj adatokat, amiket nem kéne. A Python fejlesztőknek a Rust tanulási görbéje meredek, de a PyO3 könyvtár segítségével szinte észrevétlenül tudunk Python modulokat írni Rust nyelven.
Lássuk a gyakorlatot. Építsünk egy modult, ami nagyságrendekkel gyorsabban számol, mint a tiszta Python.
1. lépés: A környezet előkészítése
Szükséged lesz a Rust telepítésére, ez a cargo parancsot is hozza magával, valamint egy Python környezetre.
A terminálban hozzunk létre egy új projektet. A maturin lesz az az eszköz, az „építőrendszer”, ami lefordítja a Rust kódot és Python csomaggá csomagolja.
# Telepítsük a Maturin-t (ez a hídépítő)
pip install maturin
# Hozzunk létre egy új Rust könyvtárat
maturin new --lib rust_gyorsitoVálaszd a pyo3 lehetőséget, amikor a rendszer rákérdez a típusra.
2. lépés: A konfiguráció
Nyisd meg a keletkezett mappában a Cargo.toml fájlt. Ez a Rust projekt konfigurációja, hasonló a Python pyproject.toml-jéhez. Így kell kinéznie:
[package]
name = "rust_gyorsito"
version = "0.1.0"
edition = "2021"
[lib]
name = "rust_gyorsito"
# A cdylib típus kritikus, ez teszi lehetővé, hogy a Python betöltse
crate-type = ["cdylib"]
[dependencies]
# A PyO3 a varázslat, ami összeköti a két nyelvet
pyo3 = { version = "0.20.0", features = ["extension-module"] }3. lépés: Írjuk meg a nehéz kódot Rustban
A feladat legyen egy klasszikus CPU-gyilkos művelet. Számoljuk ki, hány prímszám van egy adott tartományban. Pythonban ez lassú, mert minden egyes számot egyesével kell vizsgálni.
Nyisd meg a src/lib.rs fájlt, és cseréld le a tartalmát erre:
use pyo3::prelude::*;
// Ez a segédfüggvény ellenőrzi, hogy egy szám prím-e
// Figyeld meg: nincs Python hívás, tiszta Rust (villámgyors)
fn is_prime(n: u64) -> bool {
if n <= 1 {
return false;
}
for i in 2..=(n as f64).sqrt() as u64 {
if n % i == 0 {
return false;
}
}
true
}
// Ez a függvény lesz meghívható Pythonból
// A #[pyfunction] dekorátor jelzi a PyO3-nak a szándékunkat
#[pyfunction]
fn count_primes(limit: u64) -> u64 {
let mut count = 0;
for i in 0..limit {
if is_prime(i) {
count += 1;
}
}
count
}
// Itt "regisztráljuk" a modult, hogy a Python lássa
#[pymodule]
fn rust_gyorsito(_py: Python, m: &PyModule) -> PyResult<()> {
m.add_function(wrap_pyfunction!(count_primes, m)?)?;
Ok(())
}4. lépés: Fordítás és telepítés
Itt történik a varázslat. A Maturin lefordítja a Rust kódot gépi kódra, és telepíti az aktuális Python környezetedbe, mintha csak egy pip install történt volna.
maturin develop
Ha a parancs lefutott, a rust_gyorsito modul már ott is van a Pythonodban!
5. lépés: A nagy verseny
Most nézzük meg, mekkora a különbség. Írjunk egy Python szkriptet test_speed.py, ami összehasonlítja a natív Python megoldást a Rust implementációval.
import time
from rust_gyorsito import count_primes as rust_count_primes
# 1. A lassú Python implementáció
def python_count_primes(limit):
count = 0
for n in range(limit):
if n <= 1:
continue
is_prime = True
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
is_prime = False
break
if is_prime:
count += 1
return count
LIMIT = 10_000_000 # Tízmillió szám vizsgálata
print(f"Számítás indítása {LIMIT} számig...")
# Rust mérése
start = time.time()
rust_result = rust_count_primes(LIMIT)
rust_time = time.time() - start
print(f"Rust eredmény: {rust_result} | Idő: {rust_time:.4f} másodperc")
# Python mérése
start = time.time()
py_result = python_count_primes(LIMIT)
py_time = time.time() - start
print(f"Python eredmény: {py_result} | Idő: {py_time:.4f} másodperc")
# Gyorsulás kiszámítása
speedup = py_time / rust_time
print(f"🚀 Gyorsulás: {speedup:.2f}x")Az eredmény sokkoló
Ha lefuttatod a fenti kódot egy átlagos gépen, valami ilyesmit fogsz látni:
- Python: kb. 15-20 másodperc.
- Rust: kb. 0.5 – 1 másodperc.
- Gyorsulás: 20-40x szorzó!
Hibrid rendszereké a jövő
A tanulság nem az, hogy dobd ki a Pythont. A Python tökéletes a „ragasztónak”, az adatvizualizációra, a modell betanításának vezérlésére. De azokban a kritikus másodpercekben, amikor nyers matematikai erőt kell kifejteni, érdemes kiszervezni a munkát Rustba.
A mivagyunk.hu tippje: Kezdd kicsiben. Keress egy függvényt a kódodban, ami a profilozás szerint a legtöbb időt viszi el, és írd át Rustra. A felhasználóid hálásak lesznek érte.
