Welcome to our latest exploration, where we dive into the thrilling world of combining the raw power of Rust with the versatility of Python to elevate your programming projects to unprecedented levels of efficiency and performance. In "Supercharge Your Python Apps with Rust," we embark on a journey designed to transform beginners into adept users of these two formidable languages.
Whether you're looking to boost your Python application's speed, ensure memory safety, or simply be curious about integrating Rust into your workflow, this blog is your first step towards mastering the art of leveraging Rust's capabilities within your Python projects. Dive in now to discover a step-by-step guide that demystifies the process, making it accessible and straightforward for developers of all skill levels. Don't miss out on unlocking the full potential of your applications; join us in this exciting adventure!
Creating a dynamic library in Rust and calling it from Python using Foreign Function Interface (FFI) is an exciting way to leverage Rust's performance and safety in Python applications. This tutorial will guide you through the process step-by-step, with clear examples and explanations tailored for developers.
Creating a Rust Dynamic Library
Step 1: Setting Up Your Rust Project
First, you'll need to create a new Rust library project. Open a terminal and run the following command:
cargo new --lib rust_library
cd rust_library
This command creates a new Rust library project called rust_library and moves it into the project directory.
Step 2: Writing Your Rust Function
Open the src/lib.rs file and replace its contents with the following code, which defines a simple function to add two numbers:
#[no_mangle]
pub extern "C" fn add_numbers(a: i32, b: i32) -> i32 {
a + b
}
#[no_mangle] prevents Rust from changing the name of the function during compilation, making it easier to link from Python.
pub extern "C" makes this function adhere to the C calling convention, a requirement for FFI.
Step 3: Configuring Cargo.toml
Open the Cargo.toml file and add the following lines to create a dynamic library:
[lib]
crate-type = ["cdylib"]
This configuration tells Rust to compile the library as a C-compatible dynamic library (cdylib).
Step 4: Building the Dynamic Library
Run the following command in your terminal:
cargo build --release
After the build completes, you'll find the dynamic library in target/release (e.g., librust_library.so on Linux, rust_library.dll on Windows, or librust_library.dylib on macOS).
Calling Rust from Python
Step 1: Installing ctypes in Python
Ensure you have ctypes available in your Python environment. It's included in the standard library, so you should be all set.
Step 2: Writing Python Code to Call Rust Function
Create a new Python file (e.g., call_rust.py) and write the following code:
from ctypes import cdll, c_int
lib = cdll.LoadLibrary("target/release/librust_library.so")
lib.add_numbers.argtypes = (c_int, c_int)
lib.add_numbers.restype = c_int
result = lib.add_numbers(5, 7)
print(f"The result is: {result}")
Step 3: Running Your Python Code
Run your Python script:
python call_rust.py
You should see the output:
The result is: 12
Conclusion
You've now successfully created a Rust dynamic library and called it from Python using FFI! This approach enables you to combine Rust's performance and reliability with Python's ease of use, creating powerful and efficient applications.
This tutorial serves as a basic introduction to FFI and inter-language communication. As you dive deeper, you'll encounter more complex scenarios, such as passing strings or complex data structures between Rust and Python. Each step has been designed to be as developer-friendly as possible, providing you with a solid foundation for integrating Rust and Python in your projects.
The examples for the above tutorial is referenced from : https://github.com/theArjun/learning-rust/tree/main/rust_adder
