W tym artykule pokażę Ci, **jak używać Rusta z Pythonem**, korzystając z narzędzi takich jak PyO3 i Maturin. PyO3 to biblioteka, która umożliwia tworzenie natywnych modułów Pythona w Rust. Maturin to narzędzie, które ułatwia budowanie, pakowanie i dystrybuowanie projektów mieszanych Python-Rust. Pokażemy ci, jak napisać prostą funkcję w Rust, która przyjmuje argumenty z Pythona i zwraca wynik do Pythona. Pokażę Ci też, jak zbudować i zainstalować swój moduł Rust jako pakiet Pythona, który możesz zaimportować i użyć w swoim kodzie Pythona.
## Jak napisać funkcję w Rust, która przyjmuje argumenty z Pythona i zwraca wynik do Pythona
Aby napisać funkcję w Rust, która może być wywoływana z Pythona, musimy użyć makra `#[pyfunction]` z biblioteki PyO3. To makro automatycznie konwertuje argumenty i wartości zwracane między typami Rusta i Pythona. Na przykład, jeżeli chcemy napisać funkcję, która dodaje dwie liczby całkowite i zwraca ich sumę, możemy to zrobić tak:
```
use pyo3::prelude::*;
#[pyfunction]
fn add(a: i32, b: i32) -> PyResult {
Ok(a + b)
}
```
Jak widać, funkcja przyjmuje dwa argumenty typu `i32`, który jest typem całkowitym w Rust, i zwraca wynik typu `PyResult`, który jest typem wyniku z biblioteki PyO3. Typ `PyResult` jest używany do obsługi błędów, które mogą wystąpić podczas konwersji typów lub wykonywania operacji. jeżeli wszystko pójdzie dobrze, funkcja zwraca wartość Ok(T), gdzie T jest wartością zwracaną. jeżeli coś pójdzie nie tak, funkcja zwraca wartość `Err(E)`, gdzie E jest błędem.
Aby udostępnić naszą funkcję Pythonowi, musimy zarejestrować ją w module Rust, który będzie naszym natywnym modułem Pythona. Aby to zrobić, musimy użyć makra `#[pymodule]` z biblioteki PyO3. To makro tworzy moduł Rust, który może być importowany i używany w Pythonie. Na przykład, jeżeli chcemy nazwać nasz moduł `rusty`, możemy to zrobić tak:
```
use pyo3::prelude::*;
#[pymodule]
fn rusty(py: Python, m: &PyModule) -> PyResult {
m.add_function(wrap_pyfunction!(add, m)?)?;
Ok(())
}
```
Jak widać, funkcja przyjmuje dwa argumenty: `py`, który jest referencją do interpretera Pythona, i m, który jest referencją do modułu Rust. Następnie używamy funkcji `add_function`, która dodaje naszą funkcję add do modułu Rust, używając makra `wrap_pyfunction`, które opakowuje naszą funkcję w obiekt Pythona. Na koniec zwracamy wartość Ok(()), która oznacza, iż wszystko poszło dobrze.
Teraz mamy gotową funkcję w Rust, która może być wywoływana z Pythona. Aby to sprawdzić, musimy zbudować i zainstalować nasz moduł Rust jako pakiet Pythona. Pokażę Ci, jak to zrobić w następnej części artykułu.
## Jak zbudować i zainstalować moduł Rust jako pakiet Pythona
Aby zbudować i zainstalować nasz moduł Rust jako pakiet Pythona, będziemy potrzebować narzędzia o nazwie Maturin. **Maturin to narzędzie, które ułatwia budowanie, pakowanie i dystrybuowanie projektów mieszanych Python-Rust**. Maturin obsługuje zarówno systemy operacyjne Windows, Linux, jak i MacOS, a także różne wersje Pythona.
Aby zainstalować Maturin, możemy użyć menedżera pakietów Pythona, pip. Wystarczy wpisać następujące polecenie w terminalu:
```
pip install maturin
```
Aby zbudować nasz moduł Rust jako pakiet Pythona, musimy utworzyć plik o nazwie `Cargo.toml` w katalogu naszego projektu. Plik `Cargo.toml` jest plikiem konfiguracyjnym dla narzędzia Cargo, które jest menedżerem zależności i budowania dla projektów Rust. W pliku `Cargo.toml` musimy podać podstawowe informacje o naszym projekcie, takie jak nazwa, wersja, autorzy, licencja, itp. Musimy także dodać zależność do biblioteki PyO3, która umożliwia tworzenie natywnych modułów Pythona w Rust. Na przykład, nasz plik `Cargo.toml` może wyglądać tak:
```
[package]
name = "rusty"
version = "0.1.0"
authors = ["Bing "]
edition = "2018"
license = "MIT"
[dependencies]
pyo3 = { version = "0.14", features = ["extension-module"] }
```
Aby zbudować nasz moduł Rust jako pakiet Pythona, musimy użyć polecenia `maturin build` w terminalu. To polecenie automatycznie skompiluje nasz kod Rust i utworzy plik końcowy o nazwie `rusty-0.1.0-cp39-cp39-win_amd64.whl` (nazwa może się różnić w zależności od wersji Pythona i systemu operacyjnego). Plik `.whljest` plikiem binarnym, który zawiera nasz moduł Rust i wszystkie niezbędne metadane.
Aby zainstalować nasz moduł Rust jako pakiet Pythona, musimy użyć polecenia `pip install` w terminalu. To polecenie automatycznie skopiuje nasz plik `.whl` do odpowiedniego katalogu i zarejestruje go w systemie Pythona. Na przykład, możemy zainstalować nasz moduł Rust tak:
```
pip install rusty-0.1.0-cp39-cp39-win_amd64.whl
```
Teraz mamy **gotowy pakiet Pythona**, który zawiera nasz moduł Rust. Aby go użyć, wystarczy zaimportować go w naszym kodzie Pythona i wywołać naszą funkcję add. Na przykład, możemy to zrobić tak:
```
import rusty
result = rusty.add(2, 3)
print(result)
```
To powinno wypisać 5 na ekranie.
W ten sposób możemy używać Rusta z Pythonem, korzystając z PyO3 i Maturin. Możemy także tworzyć **bardziej złożone funkcje i klasy w Rust**, które mogą wchodzić w interakcje z typami i obiektami Pythona. Możemy także eksportować nasz pakiet Pythona do PyPI, aby udostępnić go innym użytkownikom Pythona.
## Zostań ekspertem w języku Rust: Zapisz się na kompleksowe Szkolenie Rust
Mam nadzieję, iż ten artykuł był dla Ciebie pomocny i interesujący. jeżeli chcesz dowiedzieć się więcej o programowaniu w Rust lub potrzebujesz poznać najpierw podstawy tego języka, zapraszam na moje [szkolenie Rust w formule otwartej lub zamkniętej](https://www.sages.pl/szkolenia/programowanie-w-jezyku-rust) - dostosowane do potrzeb Twoich projektów.
