πβοΈ Python ΠΈΠ»ΠΈ Rust: ΡΡΠΎ Π²ΡΠ±ΡΠ°ΡΡ Π΄Π»Ρ Π°Π½Π°Π»ΠΈΠ·Π° Π΄Π°Π½Π½ΡΡ ΠΈ ΠΌΠ°ΡΠΈΠ½Π½ΠΎΠ³ΠΎ ΠΎΠ±ΡΡΠ΅Π½ΠΈΡ
ΠΠΎΠΏΡΠ»ΡΡΠ½ΠΎΡΡΡ Python Π² Π°Π½Π°Π»ΠΈΠ·Π΅ Π΄Π°Π½Π½ΡΡ ΠΈ ML ΡΠΆΠ΅ Π½Π΅ΠΎΡΠΏΠΎΡΠΈΠΌΠ°, ΠΎΠ΄Π½Π°ΠΊΠΎ Π±ΡΡΡΡΠΎΡΠ°ΡΡΡΡΠ°Ρ Π·Π²Π΅Π·Π΄Π° Rust Π³ΠΎΡΠΎΠ²Π° Π±ΡΠΎΡΠΈΡΡ Π΅ΠΌΡ Π²ΡΠ·ΠΎΠ².
Python ΡΡΠ°Π» ΠΎΡΠ½ΠΎΠ²Π½ΡΠΌ ΡΠ·ΡΠΊΠΎΠΌ ΠΌΠ°ΡΠΈΠ½Π½ΠΎΠ³ΠΎ ΠΎΠ±ΡΡΠ΅Π½ΠΈΡ ΠΈ Π°Π½Π°Π»ΠΈΠ·Π° Π΄Π°Π½Π½ΡΡ Π±Π»Π°Π³ΠΎΠ΄Π°ΡΡ ΡΠ²ΠΎΠ΅ΠΉ ΠΏΡΠΎΡΡΠΎΡΠ΅, Π³ΠΈΠ±ΠΊΠΎΡΡΠΈ ΠΈ ΠΎΠ³ΡΠΎΠΌΠ½ΠΎΠΌΡ Π²ΡΠ±ΠΎΡΡ Π²ΡΠΏΠΎΠΌΠΎΠ³Π°ΡΠ΅Π»ΡΠ½ΡΡ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊ. ΠΡΠΎΡΠ΅ΡΡ ΡΠ°Π·ΡΠ°Π±ΠΎΡΠΊΠΈ Π½Π° Python ΠΈΠ΄Π΅Ρ Π³ΠΎΡΠ°Π·Π΄ΠΎ Π±ΡΡΡΡΠ΅Π΅, ΡΠ΅ΠΌ Π½Π° Π»ΡΠ±ΠΎΠΌ Π΄ΡΡΠ³ΠΎΠΌ ΡΠ·ΡΠΊΠ΅, ΠΈ Ρ ΠΎΡΡ Python Π΄ΠΎΠ²ΠΎΠ»ΡΠ½ΠΎ ΡΠ°ΡΡΠΎ ΠΊΠΎΠΌΠ±ΠΈΠ½ΠΈΡΡΡΡ Ρ R ΠΈ Julia, Π½ΠΈ ΡΠΎΡ, Π½ΠΈ Π΄ΡΡΠ³ΠΎΠΉ ΡΠ·ΡΠΊ Π½Π΅ ΠΌΠΎΠΆΠ΅Ρ ΠΏΠΎΠ»Π½ΠΎΡΡΡΡ Π΅Π³ΠΎ Π·Π°ΠΌΠ΅Π½ΠΈΡΡ. ΠΠ΅Π΄Π°Π²Π½ΠΎ Ρ Python ΠΏΠΎΡΠ²ΠΈΠ»ΡΡ Π½ΠΎΠ²ΡΠΉ ΠΊΠΎΠ½ΠΊΡΡΠ΅Π½Ρ β Rust. ΠΠ½ Π³ΠΎΡΠ°Π·Π΄ΠΎ ΡΠ»ΠΎΠΆΠ½Π΅Π΅ Python, Π½ΠΎ Ρ Π½Π΅Π³ΠΎ Π΅ΡΡΡ Π΄Π²Π° Π²Π°ΠΆΠ½ΡΡ ΠΏΡΠ΅ΠΈΠΌΡΡΠ΅ΡΡΠ²Π° β Π²ΡΡΠΎΠΊΠ°Ρ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΠ΅Π»ΡΠ½ΠΎΡΡΡ, ΡΠΎΠΏΠΎΡΡΠ°Π²ΠΈΠΌΠ°Ρ Ρ C/C++, ΠΈ ΠΌΠ°ΠΊΡΠΈΠΌΠ°Π»ΡΠ½ΠΎ Π½Π°Π΄Π΅ΠΆΠ½ΡΠΉ ΠΌΠ΅Ρ Π°Π½ΠΈΠ·ΠΌ ΠΎΠ±Π΅ΡΠΏΠ΅ΡΠ΅Π½ΠΈΡ Π±Π΅Π·ΠΎΠΏΠ°ΡΠ½ΠΎΡΡΠΈ. Π’Π΅ΠΏΠ΅ΡΡ ΠΊΠ°ΠΆΠ΄ΡΠΉ ML-ΡΠ°Π·ΡΠ°Π±ΠΎΡΡΠΈΠΊ ΠΈ Π°Π½Π°Π»ΠΈΡΠΈΠΊ Π΄Π°Π½Π½ΡΡ Π΄ΠΎΠ»ΠΆΠ΅Π½ ΡΠ΅ΡΠΈΡΡ Π΄Π»Ρ ΡΠ΅Π±Ρ Π΄ΠΈΠ»Π΅ΠΌΠΌΡ β ΠΊΠ°ΠΊΠΎΠΉ ΠΈΠ· ΡΡΠΈΡ ΡΠ·ΡΠΊΠΎΠ² Π²ΡΠ±ΡΠ°ΡΡ. ΠΠΎΠΏΡΠΎΠ±ΡΠ΅ΠΌ ΡΡΠ°Π²Π½ΠΈΡΡ ΠΎΡΠΎΠ±Π΅Π½Π½ΠΎΡΡΠΈ Python, ΠΊΠΎΡΠΎΡΡΠ΅ ΡΠ΄Π΅Π»Π°Π»ΠΈ Π΅Π³ΠΎ ΡΠ°ΠΊΡΠΈΡΠ΅ΡΠΊΠΈΠΌ ΡΡΠ°Π½Π΄Π°ΡΡΠΎΠΌ Π² AI/ML ΠΈ Π°Π½Π°Π»ΠΈΠ·Π΅ Π΄Π°Π½Π½ΡΡ , Ρ Π²Π΅ΡΠΊΠΈΠΌΠΈ ΠΏΡΠ΅ΠΈΠΌΡΡΠ΅ΡΡΠ²Π°ΠΌΠΈ Π²ΠΎΡΡ ΠΎΠ΄ΡΡΠ΅ΠΉ Π·Π²Π΅Π·Π΄Ρ Rust.
ΠΠ°ΡΠ»Π΅Π΄ΠΈΠ΅ Python
Python ΠΈΠΌΠ΅Π΅Ρ ΠΏΡΠΎΡΡΠΎΠΉ ΠΈ ΠΈΠ½ΡΡΠΈΡΠΈΠ²Π½ΠΎ ΠΏΠΎΠ½ΡΡΠ½ΡΠΉ ΡΠΈΠ½ΡΠ°ΠΊΡΠΈΡ, ΠΊΠΎΡΠΎΡΡΠΉ ΠΈΠ½ΠΎΠ³Π΄Π° Π² ΡΡΡΠΊΡ Π½Π°Π·ΡΠ²Π°ΡΡ ΠΈΡΠΏΠΎΠ»Π½ΡΠ΅ΠΌΡΠΌ ΠΏΡΠ΅Π²Π΄ΠΎΠΊΠΎΠ΄ΠΎΠΌ. ΠΡΠ° ΠΏΡΠΎΡΡΠΎΡΠ° ΠΈ Π΄ΠΎΡΡΡΠΏΠ½ΠΎΡΡΡ ΠΏΡΠΈΠ³Π»ΡΠ½ΡΠ»ΠΈΡΡ ΠΌΠ½ΠΎΠ³ΠΈΠΌ ΡΠ°Π»Π°Π½ΡΠ»ΠΈΠ²ΡΠΌ ΡΠ°Π·ΡΠ°Π±ΠΎΡΡΠΈΠΊΠ°ΠΌ: ΠΎΠ½ΠΈ Π½Π°ΡΠ°Π»ΠΈ ΡΠΎΠ·Π΄Π°Π²Π°ΡΡ Π²ΡΠ΅Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΡΠ΅ Π΄ΠΎΠΏΠΎΠ»Π½ΠΈΡΠ΅Π»ΡΠ½ΡΠ΅ ΠΌΠΎΠ΄ΡΠ»ΠΈ, Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠΈ ΠΈ ΡΡΠ΅ΠΉΠΌΠ²ΠΎΡΠΊΠΈ. Π ΡΠ΅Π·ΡΠ»ΡΡΠ°ΡΠ΅ Python ΠΎΡΠ΅Π½Ρ Π±ΡΡΡΡΠΎ ΠΎΠ±Π·Π°Π²Π΅Π»ΡΡ Π½Π΅ΠΎΠ±ΡΡΡΠ½ΠΎΠΉ ΡΠΊΠΎΡΠΈΡΡΠ΅ΠΌΠΎΠΉ, Π² ΠΊΠΎΡΠΎΡΠΎΠΉ Π΅ΡΡΡ ΠΈΠ½ΡΡΡΡΠΌΠ΅Π½ΡΡ Π΄Π»Ρ ΡΠ΅ΡΠ΅Π½ΠΈΡ Π»ΡΠ±ΡΡ Π·Π°Π΄Π°Ρ. ΠΠ΅ Π²ΡΠ΅ ΡΡΠΈ Π·Π°Π΄Π°ΡΠΈ ΡΠ΅ΡΠ°ΡΡΡΡ ΠΌΠ°ΠΊΡΠΈΠΌΠ°Π»ΡΠ½ΠΎ ΡΡΡΠ΅ΠΊΡΠΈΠ²Π½ΠΎ β ΠΈΠ·-Π·Π° Π½Π΅Π²ΡΡΠΎΠΊΠΎΠΉ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΠ΅Π»ΡΠ½ΠΎΡΡΠΈ Python Π½Π΅ ΠΏΠΎΠ΄Ρ ΠΎΠ΄ΠΈΡ Π΄Π»Ρ ΡΠ°Π·ΡΠ°Π±ΠΎΡΠΊΠΈ ΡΠ΅ΡΡΠ΅Π·Π½ΡΡ 3D-ΠΈΠ³Ρ, Π½Π°ΠΏΡΠΈΠΌΠ΅Ρ β Π½ΠΎ Π΄Π»Ρ Π°Π½Π°Π»ΠΈΠ·Π° Π΄Π°Π½Π½ΡΡ , ΠΌΠ°ΡΠΈΠ½Π½ΠΎΠ³ΠΎ ΠΎΠ±ΡΡΠ΅Π½ΠΈΡ ΠΈ ΠΌΠ½ΠΎΠ³ΠΈΡ Π΄ΡΡΠ³ΠΈΡ Π²Π΅ΡΠ΅ΠΉ ΡΠΊΠΎΡΠΎΡΡΠΈ ΡΠ·ΡΠΊΠ° Π²ΠΏΠΎΠ»Π½Π΅ Ρ Π²Π°ΡΠ°Π΅Ρ. Π ΡΠΎΠΌΡ ΠΆΠ΅ ΠΌΠ½ΠΎΠ³ΠΈΠ΅ ΠΊΡΠΈΡΠΈΡΠ΅ΡΠΊΠΈ Π²Π°ΠΆΠ½ΡΠ΅ ΠΌΠΎΠ΄ΡΠ»ΠΈ ΠΈ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠΈ Python ΡΠ΅Π°Π»ΠΈΠ·ΠΎΠ²Π°Π½Ρ Π½Π° ΡΡΠΎΠ²Π½Π΅ Π‘ ΠΈ ΡΠ°Π±ΠΎΡΠ°ΡΡ Ρ ΡΠΎΠΎΡΠ²Π΅ΡΡΡΠ²ΡΡΡΠ΅ΠΉ ΡΠΊΠΎΡΠΎΡΡΡΡ. ΠΠΎΡ ΡΠ°ΠΊ ΠΏΡΠΎΡΡΠΎ Π²ΡΠ³Π»ΡΠ΄ΠΈΡ ΡΡΠ΅Π½ΠΈΠ΅ Π΄Π°Π½Π½ΡΡ ΠΈΠ· CSV-ΡΠ°ΠΉΠ»Π° Π² Python Ρ ΠΏΠΎΠΌΠΎΡΡΡ Pandas:
import pandas as pd data = pd.read_csv("mydataset.csv") print(data.head())
ΠΠΎΠ²ΡΠΉ ΠΊΠΎΠ½ΠΊΡΡΠ΅Π½Ρ β Rust
ΠΡΠ½ΠΎΠ²Π½ΡΠ΅ ΠΏΠ»ΡΡΡ Rust β Π²ΡΡΠΎΠΊΠ°Ρ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΠ΅Π»ΡΠ½ΠΎΡΡΡ, Π±Π΅Π·ΠΎΠΏΠ°ΡΠ½ΠΎΡΡΡ ΠΈ ΠΌΠ½ΠΎΠ³ΠΎΠΏΠΎΡΠΎΡΠ½ΠΎΡΡΡ. ΠΠ½ ΠΎΡΠ»ΠΈΡΠ½ΠΎ ΠΏΠΎΠ΄Ρ ΠΎΠ΄ΠΈΡ Π΄Π»Ρ ΡΠΈΡΡΠ΅ΠΌΠ½ΠΎΠ³ΠΎ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΠΈΡΠΎΠ²Π°Π½ΠΈΡ, ΡΡΡΠ΅ΠΌΠΈΡΠ΅Π»ΡΠ½ΠΎ Π½Π°Π±ΠΈΡΠ°Π΅Ρ ΠΏΠΎΠΏΡΠ»ΡΡΠ½ΠΎΡΡΡ Π² ΡΠ΅ΡΠ²Π΅ΡΠ½ΠΎΠΉ ΡΠ°Π·ΡΠ°Π±ΠΎΡΠΊΠ΅ ΠΈ Π³Π΅ΠΉΠΌΠ΄Π΅Π²Π΅. Rust β Π½Π΅ ΡΠ°ΠΌΡΠΉ ΠΎΡΠ΅Π²ΠΈΠ΄Π½ΡΠΉ Π²ΡΠ±ΠΎΡ Π΄Π»Ρ Π°Π½Π°Π»ΠΈΠ·Π° Π΄Π°Π½Π½ΡΡ ΠΈ ΠΌΠ°ΡΠΈΠ½Π½ΠΎΠ³ΠΎ ΠΎΠ±ΡΡΠ΅Π½ΠΈΡ. ΠΠ΄Π½Π°ΠΊΠΎ Π² ΠΏΠΎΡΠ»Π΅Π΄Π½ΠΈΠ΅ Π½Π΅ΡΠΊΠΎΠ»ΡΠΊΠΎ Π»Π΅Ρ, Π±Π»Π°Π³ΠΎΠ΄Π°ΡΡ ΡΠ²ΠΎΠΈΠΌ Π²Π΅ΡΠΊΠΈΠΌ ΠΏΡΠ΅ΠΈΠΌΡΡΠ΅ΡΡΠ²Π°ΠΌ, ΠΎΠ½ Π²ΡΠ΅ ΡΠ°ΡΠ΅ ΠΏΡΠΈΠΌΠ΅Π½ΡΠ΅ΡΡΡ ΠΈ Π² ΡΡΠΈΡ ΠΎΠ±Π»Π°ΡΡΡΡ β Ρ ΠΎΡΡ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡ Π΅Π³ΠΎ Π·Π°ΠΌΠ΅ΡΠ½ΠΎ ΡΠ»ΠΎΠΆΠ½Π΅Π΅. Π§ΡΠ΅Π½ΠΈΠ΅ ΡΠΎΠ³ΠΎ ΠΆΠ΅ ΡΠ°ΠΌΠΎΠ³ΠΎ CSV-ΡΠ°ΠΉΠ»Π° Π² Rust Π²ΡΠ³Π»ΡΠ΄ΠΈΡ ΡΠ°ΠΊ:
use std::error::Error; use csv::ReaderBuilder; fn main() -> Result<(), Box<dyn Error>> { let file = std::fs::File::open("mydataset.csv")?; let mut rdr = ReaderBuilder::new().has_headers(true).from_reader(file); for result in rdr.records() { let record = result?; println!("{:?}", record); } Ok(()) }
Python ΠΈΠ»ΠΈ Rust: ΡΡΠΎ ΠΏΡΠΎΡΠ΅
Python ΠΈΠ·Π²Π΅ΡΡΠ΅Π½ ΠΏΠ»Π°Π²Π½ΠΎΠΉ ΠΊΡΠΈΠ²ΠΎΠΉ ΠΎΠ±ΡΡΠ΅Π½ΠΈΡ: Ρ ΠΌΠΈΠ½ΠΈΠΌΠ°Π»ΡΠ½ΡΠΌΠΈ Π·Π½Π°Π½ΠΈΡΠΌΠΈ ΡΠ·ΡΠΊΠ° ΡΠΆΠ΅ ΠΌΠΎΠΆΠ½ΠΎ ΠΏΠΈΡΠ°ΡΡ ΠΏΠΎΠ»Π΅Π·Π½ΡΠ΅ ΡΠΊΡΠΈΠΏΡΡ, Π° ΠΈΠ·ΡΡΠ΅Π½ΠΈΠ΅ Π±ΠΎΠ»Π΅Π΅ ΡΠ»ΠΎΠΆΠ½ΡΡ ΠΊΠΎΠ½ΡΠ΅ΠΏΡΠΈΠΉ ΠΎΡΠ»ΠΎΠΆΠΈΡΡ Π½Π° ΠΏΠΎΡΠΎΠΌ. ΠΠΎ ΡΡΠΎΠΉ ΠΏΡΠΈΡΠΈΠ½Π΅ Pyhton ΠΈΠ΄Π΅Π°Π»ΡΠ½ΠΎ ΠΏΠΎΠ΄Ρ ΠΎΠ΄ΠΈΡ:
- Π‘ΠΏΠ΅ΡΠΈΠ°Π»ΠΈΡΡΠ°ΠΌ, ΠΊΠΎΡΠΎΡΡΠΌ Π½ΡΠΆΠ½ΠΎ Ρ ΠΏΠΎΠΌΠΎΡΡΡ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΠΈΡΠΎΠ²Π°Π½ΠΈΡ ΡΠ΅ΡΠ°ΡΡ ΠΏΡΠΎΡΠ΅ΡΡΠΈΠΎΠ½Π°Π»ΡΠ½ΡΠ΅ Π·Π°Π΄Π°ΡΠΈ β Π½Π°ΡΡΠ½ΡΠ΅ ΠΈ ΠΈΠ½ΠΆΠ΅Π½Π΅ΡΠ½ΡΠ΅.
- ΠΠΎΠ²ΠΈΡΠΊΠ°ΠΌ, Π½Π΅ ΠΈΠΌΠ΅ΡΡΠΈΠΌ Π½ΠΈΠΊΠ°ΠΊΠΎΠ³ΠΎ ΠΎΠΏΡΡΠ° Π² ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΠΈΡΠΎΠ²Π°Π½ΠΈΠΈ.
# ΠΡΠΈΠΌΠ΅Ρ ΠΊΠΎΠ΄Π° Π½Π° Python print("Hello, World!")
Rust, Π½Π°ΠΏΡΠΎΡΠΈΠ², ΠΌΠΎΠΆΠ΅Ρ ΠΏΠΎΠΊΠ°Π·Π°ΡΡΡΡ ΡΠ»ΠΈΡΠΊΠΎΠΌ ΡΠ»ΠΎΠΆΠ½ΡΠΌ Π΄Π»Ρ Π½Π°ΡΠΈΠ½Π°ΡΡΠΈΡ : Π² Π½Π΅ΠΌ Π΅ΡΡΡ Π½Π΅ΠΏΡΠΎΡΡΡΠ΅ ΠΊΠΎΠ½ΡΠ΅ΠΏΡΠΈΠΈ, ΠΊΠΎΡΠΎΡΡΠ΅ Π½Π°Π΄ΠΎ ΠΎΡΠΌΡΡΠ»ΠΈΡΡ ΡΡΠ°Π·Ρ, Π½Π°ΠΏΡΠΈΠΌΠ΅Ρ, ΡΠΈΡΡΠ΅ΠΌΡ Π²Π»Π°Π΄Π΅Π½ΠΈΡ ΠΈ Π·Π°ΠΈΠΌΡΡΠ²ΠΎΠ²Π°Π½ΠΈΡ:
- Π‘ΠΈΡΡΠ΅ΠΌΠ° Π²Π»Π°Π΄Π΅Π½ΠΈΡ Π² Rust ΠΎΠ·Π½Π°ΡΠ°Π΅Ρ, ΡΡΠΎ ΠΊΠ°ΠΆΠ΄ΡΠΉ ΠΎΠ±ΡΠ΅ΠΊΡ ΠΈΠΌΠ΅Π΅Ρ ΡΠΎΠ»ΡΠΊΠΎ ΠΎΠ΄Π½ΠΎΠ³ΠΎ Π²Π»Π°Π΄Π΅Π»ΡΡΠ°, ΠΊΠΎΡΠΎΡΡΠΉ ΠΎΡΠ²Π΅ΡΠ°Π΅Ρ Π·Π° Π΅Π³ΠΎ ΡΠ½ΠΈΡΡΠΎΠΆΠ΅Π½ΠΈΠ΅. ΠΡΠΎ ΠΏΡΠ΅Π΄ΠΎΡΠ²ΡΠ°ΡΠ°Π΅Ρ ΠΌΠ½ΠΎΠ³ΠΈΠ΅ ΠΎΡΠΈΠ±ΠΊΠΈ, ΡΠ²ΡΠ·Π°Π½Π½ΡΠ΅ Ρ ΡΡΠ΅ΡΠΊΠΎΠΉ ΠΏΠ°ΠΌΡΡΠΈ ΠΈΠ»ΠΈ Π΄Π²ΠΎΠΉΠ½ΡΠΌ ΠΎΡΠ²ΠΎΠ±ΠΎΠΆΠ΄Π΅Π½ΠΈΠ΅ΠΌ ΡΠ΅ΡΡΡΡΠΎΠ².
- Π‘ΠΈΡΡΠ΅ΠΌΠ° Π·Π°ΠΈΠΌΡΡΠ²ΠΎΠ²Π°Π½ΠΈΡ ΠΏΠΎΠ·Π²ΠΎΠ»ΡΠ΅Ρ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡ ΠΎΠ΄ΠΈΠ½ ΠΈ ΡΠΎΡ ΠΆΠ΅ ΡΠ΅ΡΡΡΡ Π² Π½Π΅ΡΠΊΠΎΠ»ΡΠΊΠΈΡ
ΠΌΠ΅ΡΡΠ°Ρ
ΠΊΠΎΠ΄Π° Π±Π΅Π· Π½Π΅ΠΎΠ±Ρ
ΠΎΠ΄ΠΈΠΌΠΎΡΡΠΈ Π΅Π³ΠΎ ΠΊΠΎΠΏΠΈΡΠΎΠ²Π°Π½ΠΈΡ. ΠΡΠΎ ΠΌΠΎΠΆΠ΅Ρ Π·Π½Π°ΡΠΈΡΠ΅Π»ΡΠ½ΠΎ ΠΏΠΎΠ²ΡΡΠΈΡΡ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΠ΅Π»ΡΠ½ΠΎΡΡΡ, ΡΠ°ΠΊ ΠΊΠ°ΠΊ Π½Π΅ ΡΡΠ°ΡΡΡΡΡ ΡΠ΅ΡΡΡΡΡ Π½Π° ΡΠΎΠ·Π΄Π°Π½ΠΈΠ΅ Π»ΠΈΡΠ½ΠΈΡ
ΠΊΠΎΠΏΠΈΠΉ ΠΎΠ±ΡΠ΅ΠΊΡΠΎΠ².
ΠΠ΄Π½Π°ΠΊΠΎ ΡΡΠΈ ΠΊΠΎΠ½ΡΠ΅ΠΏΡΠΈΠΈ, ΡΡΠ΅Π΄ΠΈ ΠΏΡΠΎΡΠΈΡ ΡΠ½ΠΈΠΊΠ°Π»ΡΠ½ΡΡ ΠΎΡΠΎΠ±Π΅Π½Π½ΠΎΡΡΠ΅ΠΉ Rust, ΠΈ Π΄Π΅Π»Π°ΡΡ Π΅Π³ΠΎ ΡΠ°ΠΊΠΈΠΌ Π±ΡΡΡΡΡΠΌ, Π±Π΅Π·ΠΎΠΏΠ°ΡΠ½ΡΠΌ ΠΈ Π½Π°Π΄Π΅ΠΆΠ½ΡΠΌ. ΠΡΠΎ ΠΊΠ°ΠΊ ΡΠ°Π· ΡΠΎΡ ΡΠ»ΡΡΠ°ΠΉ, ΠΊΠΎΠ³Π΄Π° ΡΡΠΈΠ»ΠΈΡ, Π·Π°ΡΡΠ°ΡΠ΅Π½Π½ΡΠ΅ Π½Π° ΠΈΠ·ΡΡΠ΅Π½ΠΈΠ΅ ΡΠ·ΡΠΊΠ°, Π±ΡΠ΄ΡΡ ΠΌΠ½ΠΎΠ³ΠΎΠΊΡΠ°ΡΠ½ΠΎ ΠΊΠΎΠΌΠΏΠ΅Π½ΡΠΈΡΠΎΠ²Π°Π½Ρ ΠΊΠ°ΡΠ΅ΡΡΠ²ΠΎΠΌ ΠΈ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΠ΅Π»ΡΠ½ΠΎΡΡΡΡ Π³ΠΎΡΠΎΠ²ΡΡ ΠΏΡΠΈΠ»ΠΎΠΆΠ΅Π½ΠΈΠΉ.
// ΠΡΠΈΠΌΠ΅Ρ ΠΊΠΎΠ΄Π° Π½Π° Rust fn main() { println!("Hello, World!"); }
Rust ΠΈΠ»ΠΈ Python: ΡΡΠΎ Π±ΡΡΡΡΠ΅Π΅
Π‘ΡΠ°Π²Π½ΠΈΠΌ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΠ΅Π»ΡΠ½ΠΎΡΡΡ Rust ΠΈ Python Π½Π° ΡΠ΅ΡΠ΅Π½ΠΈΠΈ ΠΎΠ΄Π½ΠΎΠΉ ΠΈ ΡΠΎΠΉ ΠΆΠ΅ Π·Π°Π΄Π°ΡΠΈ. ΠΠ°ΠΏΠΈΡΠ΅ΠΌ ΡΠ΅ΠΊΡΡΡΠΈΠ²Π½ΡΠΉ ΠΊΠΎΠ΄, ΠΊΠΎΡΠΎΡΡΠΉ Π²ΡΡΠΈΡΠ»ΡΠ΅Ρ ΠΏΠ΅ΡΠ²ΡΠ΅ 35 ΡΠΈΡΠ΅Π» Π² ΠΏΠΎΡΠ»Π΅Π΄ΠΎΠ²Π°ΡΠ΅Π»ΡΠ½ΠΎΡΡΠΈ Π€ΠΈΠ±ΠΎΠ½Π°ΡΡΠΈ ΠΈ Π²ΡΠ²ΠΎΠ΄ΠΈΡ Π²ΡΠ΅ΠΌΡ, Π·Π°ΡΡΠ°ΡΠ΅Π½Π½ΠΎΠ΅ Π½Π° ΡΡΠΎ Π²ΡΡΠΈΡΠ»Π΅Π½ΠΈΠ΅.
ΠΡΡΠΈΡΠ»Π΅Π½ΠΈΠ΅ ΠΏΠΎΡΠ»Π΅Π΄ΠΎΠ²Π°ΡΠ΅Π»ΡΠ½ΠΎΡΡΠΈ Π€ΠΈΠ±ΠΎΠ½Π°ΡΡΠΈ Π½Π° Rust:
use std::time::Instant; fn fibonacci(n: u32) -> u32 { match n { 0 => 0, 1 => 1, _ => fibonacci(n - 1) + fibonacci(n - 2), } } fn main() { let start_time = Instant::now(); for i in 0..35 { println!("{}", fibonacci(i)); } let duration = start_time.elapsed(); println!("ΠΡΠ΅ΠΌΡ Π²ΡΠΏΠΎΠ»Π½Π΅Π½ΠΈΡ: {:.2} ΡΠ΅ΠΊΡΠ½Π΄", duration.as_secs_f64()); }
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 ΠΡΠ΅ΠΌΡ Π²ΡΠΏΠΎΠ»Π½Π΅Π½ΠΈΡ: 0.05 ΡΠ΅ΠΊΡΠ½Π΄
ΠΠ°ΡΠΈΠ°Π½Ρ Π½Π° Python:
import time def fibonacci(n): if n <= 0: return 0 elif n == 1: return 1 else: return fibonacci(n-1) + fibonacci(n-2) start_time = time.time() for i in range(35): print(fibonacci(i)) end_time = time.time() print(f"ΠΡΠ΅ΠΌΡ Π²ΡΠΏΠΎΠ»Π½Π΅Π½ΠΈΡ : {end_time - start_time} ΡΠ΅ΠΊΡΠ½Π΄")
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 ΠΡΠ΅ΠΌΡ Π²ΡΠΏΠΎΠ»Π½Π΅Π½ΠΈΡ : 7.8505754470825195 ΡΠ΅ΠΊΡΠ½Π΄
ΠΡΠ΅Π²ΠΈΠ΄Π½ΠΎ, ΡΡΠΎ Rust ΡΠΏΡΠ°Π²ΠΈΠ»ΡΡ Ρ Π·Π°Π΄Π°ΡΠ΅ΠΉ Π±ΡΡΡΡΠ΅Π΅:).
ΠΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠΈ ΠΈ ΡΡΠ΅ΠΉΠΌΠ²ΠΎΡΠΊΠΈ
Π‘ ΡΠΊΠΎΡΠΈΡΡΠ΅ΠΌΠΎΠΉ Python ΡΠ»ΠΎΠΆΠ½ΠΎ ΡΠΎΠΏΠ΅ΡΠ½ΠΈΡΠ°ΡΡ: Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠΈ Π΄Π»Ρ ΠΌΠ°ΡΠ΅ΠΌΠ°ΡΠΈΡΠ΅ΡΠΊΠΈΡ Π²ΡΡΠΈΡΠ»Π΅Π½ΠΈΠΉ, Π°Π½Π°Π»ΠΈΠ·Π° Π΄Π°Π½Π½ΡΡ ΠΈ ΡΠ°Π±ΠΎΡΡ Ρ Π½Π΅ΠΉΡΠΎΠ½Π½ΡΠΌΠΈ ΡΠ΅ΡΡΠΌΠΈ (Numpy, Pandas, TensorFlow, PyTorch, Scikit-Learn ΠΈ Ρ. Π΄.) ΡΡΠ°Π»ΠΈ ΡΡΠ°Π½Π΄Π°ΡΡΠΎΠΌ Π΄Π΅-ΡΠ°ΠΊΡΠΎ Π² ΠΈΠ½Π΄ΡΡΡΡΠΈΠΈ Π°Π½Π°Π»ΠΈΠ·Π° Π΄Π°Π½Π½ΡΡ , Data Science ΠΈ ML/AI.
ΠΠ΄Π½Π°ΠΊΠΎ Rust ΠΈ Π΅Π³ΠΎ ΡΠΊΠΎΡΠΈΡΡΠ΅ΠΌΠ° Π±ΡΡΡΡΠΎ ΡΠ°Π·Π²ΠΈΠ²Π°ΡΡΡΡ:
- Π ΡΠ°ΡΠΏΠΎΡΡΠΆΠ΅Π½ΠΈΠΈ ΡΠ°Π·ΡΠ°Π±ΠΎΡΡΠΈΠΊΠΎΠ² Π΅ΡΡΡ ΠΌΠΎΠ΄ΡΠ»Ρ ndarray Ρ Π°Π½Π°Π»ΠΎΠ³ΠΈΡΠ½ΠΎΠΉ NumPy ΡΡΠ½ΠΊΡΠΈΠΎΠ½Π°Π»ΡΠ½ΠΎΡΡΡΡ.
- ΠΠΌΠ΅Π΅ΡΡΡ Π°Π½Π°Π»ΠΎΠ³ Pandas Π΄Π»Ρ Π°Π½Π°Π»ΠΈΠ·Π° Π΄Π°Π½Π½ΡΡ
β Polars.
- ΠΡΡΡ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠ° statrs Π΄Π»Ρ ΡΡΠ°ΡΠΈΡΡΠΈΡΠ΅ΡΠΊΠΈΡ
ΡΠ°ΡΡΠ΅ΡΠΎΠ² ΠΈ Π°Π½Π°Π»ΠΈΠ·Π°.
- ΠΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠ° Tangram ΠΈΡΠΏΠΎΠ»ΡΠ·ΡΠ΅ΡΡΡ Π΄Π»Ρ ΠΌΠ°ΡΠΈΠ½Π½ΠΎΠ³ΠΎ ΠΎΠ±ΡΡΠ΅Π½ΠΈΡ ΠΈ ΠΏΡΠΎΠ³Π½ΠΎΠ·ΠΈΡΠΎΠ²Π°Π½ΠΈΡ.
- Linfa, Autograd ΠΈ SmartCore ΠΏΡΠ΅Π΄ΠΎΡΡΠ°Π²Π»ΡΡΡ ΡΡΠ½ΠΊΡΠΈΠΎΠ½Π°Π»ΡΠ½ΠΎΡΡΡ, ΡΡ
ΠΎΠ΄Π½ΡΡ Ρ PyTorch ΠΈ TensorFlow.
ΠΡΠΎΠΌΠ΅ ΡΠΎΠ³ΠΎ, PyTorch ΠΈ TensorFlow ΡΠΎΠΆΠ΅ ΠΌΠΎΠΆΠ½ΠΎ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡ Π² Rust, Π° ΡΠΏΠΈΡΠΎΠΊ DS/ML/AI Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊ, ΡΠ°Π·ΡΠ°Π±ΠΎΡΠ°Π½Π½ΡΡ ΡΠΏΠ΅ΡΠΈΠ°Π»ΡΠ½ΠΎ Π΄Π»Ρ Rust, ΡΠ΅Π³ΡΠ»ΡΡΠ½ΠΎ ΠΏΠΎΠΏΠΎΠ»Π½ΡΠ΅ΡΡΡ.
ΠΠ΅Π·ΠΎΠΏΠ°ΡΠ½ΠΎΡΡΡ ΠΈ ΠΊΠΎΠ½ΠΊΡΡΠ΅Π½ΡΠΎΡΡΡ
Π ΠΎΡΠ»ΠΈΡΠΈΠ΅ ΠΎΡ Python, Rust ΠΎΠ±Π΅ΡΠΏΠ΅ΡΠΈΠ²Π°Π΅Ρ Π±Π΅Π·ΠΎΠΏΠ°ΡΠ½ΠΎΡΡΡ ΠΏΠ°ΠΌΡΡΠΈ: ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΠ° Π½Π° Rust Π½Π΅ ΠΌΠΎΠΆΠ΅Ρ ΡΠ»ΡΡΠ°ΠΉΠ½ΠΎ ΠΎΠ±ΡΠ°ΡΠΈΡΡΡΡ ΠΊ Π½Π΅Π²Π΅ΡΠ½ΠΎΠΌΡ Π°Π΄ΡΠ΅ΡΡ Π² ΠΏΠ°ΠΌΡΡΠΈ ΠΈ Π²ΡΠ·Π²Π°ΡΡ ΠΎΡΠΈΠ±ΠΊΡ. ΠΡΠΎ Π΄Π΅Π»Π°Π΅Ρ Rust Π±ΠΎΠ»Π΅Π΅ Π½Π°Π΄Π΅ΠΆΠ½ΡΠΌ ΠΈ Π±Π΅Π·ΠΎΠΏΠ°ΡΠ½ΡΠΌ Π΄Π»Ρ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°Π½ΠΈΡ Π² ΠΊΡΠΈΡΠΈΡΠ΅ΡΠΊΠΈΡ ΠΏΡΠΈΠ»ΠΎΠΆΠ΅Π½ΠΈΡΡ .
ΠΡΠΎΠΌΠ΅ ΡΠΎΠ³ΠΎ, Rust ΡΠ²Π»ΡΠ΅ΡΡΡ ΡΠ·ΡΠΊΠΎΠΌ Ρ ΠΊΠΎΠ½ΠΊΡΡΠ΅Π½ΡΠ½ΠΎΠΉ ΠΌΠΎΠ΄Π΅Π»ΡΡ Π²ΡΠΏΠΎΠ»Π½Π΅Π½ΠΈΡ: Π½Π΅ΡΠΊΠΎΠ»ΡΠΊΠΎ ΠΎΠΏΠ΅ΡΠ°ΡΠΈΠΉ ΠΌΠΎΠ³ΡΡ Π²ΡΠΏΠΎΠ»Π½ΡΡΡΡΡ ΠΏΠ°ΡΠ°Π»Π»Π΅Π»ΡΠ½ΠΎ Π±Π΅Π· Π½Π΅ΠΎΠ±Ρ ΠΎΠ΄ΠΈΠΌΠΎΡΡΠΈ Π±Π»ΠΎΠΊΠΈΡΠΎΠ²ΠΊΠΈ ΠΈΠ»ΠΈ ΡΠΈΠ½Ρ ΡΠΎΠ½ΠΈΠ·Π°ΡΠΈΠΈ. ΠΡΠΎ ΠΏΠΎΠ·Π²ΠΎΠ»ΡΠ΅Ρ Rust Π΄ΠΎΡΡΠΈΠ³Π°ΡΡ Π±ΠΎΠ»Π΅Π΅ Π²ΡΡΠΎΠΊΠΎΠΉ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΠ΅Π»ΡΠ½ΠΎΡΡΠΈ, ΡΠ΅ΠΌ Python, ΠΎΡΠΎΠ±Π΅Π½Π½ΠΎ ΠΏΡΠΈ ΡΠ°Π±ΠΎΡΠ΅ Ρ Π±ΠΎΠ»ΡΡΠΈΠΌΠΈ ΠΎΠ±ΡΠ΅ΠΌΠ°ΠΌΠΈ Π΄Π°Π½Π½ΡΡ .
ΠΠ»Ρ ΡΠΎΠ·Π΄Π°Π½ΠΈΡ ΠΏΡΠ»Π° ΠΏΠΎΡΠΎΠΊΠΎΠ² ΠΈ Π²ΡΠΏΠΎΠ»Π½Π΅Π½ΠΈΡ Π·Π°Π΄Π°Ρ ΠΏΠ°ΡΠ°Π»Π»Π΅Π»ΡΠ½ΠΎ Π² Python ΠΌΠΎΠΆΠ½ΠΎ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡ ΠΌΠΎΠ΄ΡΠ»Ρ concurrent.futures ΠΈΠ· ΡΡΠ°Π½Π΄Π°ΡΡΠ½ΠΎΠΉ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠΈ:
import concurrent.futures def process_data(data_chunk): return data_chunk * 2 data_chunks = [1, 2, 3, 4, 5] with concurrent.futures.ThreadPoolExecutor() as executor: future_to_data = {executor.submit(process_data, data_chunk): data_chunk for data_chunk in data_chunks} for future in concurrent.futures.as_completed(future_to_data): data_chunk = future_to_data[future] try: data = future.result() except Exception as exc: print(f'{data_chunk} ΠΈΡΠΊΠ»ΡΡΠ΅Π½ΠΈΠ΅: {exc}') else: print(f'{data_chunk} ΠΎΠ±ΡΠ°Π±ΠΎΡΠ°Π½ΠΎ: {data}')
ΠΠ»Ρ ΠΏΠ°ΡΠ°Π»Π»Π΅Π»ΡΠ½ΡΡ ΠΎΠΏΠ΅ΡΠ°ΡΠΈΠΉ Π² Rust ΠΈΡΠΏΠΎΠ»ΡΠ·ΡΠ΅ΡΡΡ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠ° Rayon:
use rayon::prelude::*; fn process_data(data_chunk: &mut Vec<i32>) { *data_chunk = data_chunk.iter().map(|&x| x * 2).collect(); } fn main() { let mut data_chunks: Vec<Vec<i32>> = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]; data_chunks.par_iter_mut().for_each(|chunk| { process_data(chunk); }); println!("{:?}", data_chunks); }
Π£ΠΏΡΠ°Π²Π»Π΅Π½ΠΈΠ΅ ΠΏΠ°ΠΌΡΡΡΡ ΠΏΡΠΈ ΠΎΠ±ΡΠ°Π±ΠΎΡΠΊΠ΅ Π΄Π°Π½Π½ΡΡ
Π Python ΡΠΏΡΠ°Π²Π»Π΅Π½ΠΈΠ΅ ΠΏΠ°ΠΌΡΡΡΡ Π°Π±ΡΡΡΠ°Π³ΠΈΡΠΎΠ²Π°Π½ΠΎ, ΡΡΠΎ Π΄Π΅Π»Π°Π΅Ρ Π΅Π³ΠΎ Π±ΠΎΠ»Π΅Π΅ ΠΏΡΠΎΡΡΡΠΌ Π΄Π»Ρ ΡΠ°Π·ΡΠ°Π±ΠΎΡΡΠΈΠΊΠΎΠ² ΠΈ ΡΠΏΠ΅ΡΠΈΠ°Π»ΠΈΡΡΠΎΠ² ΠΏΠΎ Π°Π½Π°Π»ΠΈΠ·Ρ Π΄Π°Π½Π½ΡΡ , ΠΏΠΎΡΠΊΠΎΠ»ΡΠΊΡ ΠΎΠ½ΠΈ ΠΌΠΎΠ³ΡΡ ΡΠΎΡΡΠ΅Π΄ΠΎΡΠΎΡΠΈΡΡΡΡ Π½Π° Π°Π»Π³ΠΎΡΠΈΡΠΌΠ°Ρ , Π° Π½Π΅ Π½Π° ΡΠΎΠ½ΠΊΠΎΡΡΡΡ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°Π½ΠΈΡ ΠΏΠ°ΠΌΡΡΠΈ. ΠΠ΄Π½Π°ΠΊΠΎ ΡΡΠΎ ΠΌΠΎΠΆΠ΅Ρ ΠΏΡΠΈΠ²Π΅ΡΡΠΈ ΠΊ ΠΏΡΠΎΠ±Π»Π΅ΠΌΠ°ΠΌ ΠΏΡΠΈ ΡΠ°Π±ΠΎΡΠ΅ Ρ Π±ΠΎΠ»ΡΡΠΈΠΌΠΈ ΠΎΠ±ΡΠ΅ΠΌΠ°ΠΌΠΈ ΠΈΠ½ΡΠΎΡΠΌΠ°ΡΠΈΠΈ: Python ΠΈΡΠΏΠΎΠ»ΡΠ·ΡΠ΅Ρ Π°Π²ΡΠΎΠΌΠ°ΡΠΈΡΠ΅ΡΠΊΡΡ ΡΠ±ΠΎΡΠΊΡ ΠΌΡΡΠΎΡΠ°, ΠΊΠΎΡΠΎΡΠ°Ρ ΠΌΠΎΠΆΠ΅Ρ Π±ΡΡΡ Π½Π΅ΡΡΡΠ΅ΠΊΡΠΈΠ²Π½ΠΎΠΉ Π΄Π»Ρ ΠΎΠ±ΡΠ΅ΠΌΠ½ΡΡ Π½Π°Π±ΠΎΡΠΎΠ² Π΄Π°Π½Π½ΡΡ .
Π Rust Π΅ΡΡΡ Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΠΎΡΡΡ ΡΠΏΡΠ°Π²Π»ΡΡΡ ΠΏΠ°ΠΌΡΡΡΡ Π½Π° Π±ΠΎΠ»Π΅Π΅ Π½ΠΈΠ·ΠΊΠΎΠΌ ΡΡΠΎΠ²Π½Π΅, ΠΎΠ±Π΅ΡΠΏΠ΅ΡΠΈΠ²Π°Ρ ΡΡΡΠ΅ΠΊΡΠΈΠ²Π½ΠΎΠ΅ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°Π½ΠΈΠ΅ ΡΠ΅ΡΡΡΡΠΎΠ². ΠΡΠΎ ΠΏΠΎΠ·Π²ΠΎΠ»ΡΠ΅Ρ ΡΠΎΡΠ½ΠΎ ΠΊΠΎΠ½ΡΡΠΎΠ»ΠΈΡΠΎΠ²Π°ΡΡ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°Π½ΠΈΠ΅ ΠΏΠ°ΠΌΡΡΠΈ ΠΈ ΠΌΠΎΠΆΠ΅Ρ Π±ΡΡΡ ΠΎΡΠ΅Π½Ρ ΠΏΠΎΠ»Π΅Π·Π½ΠΎ ΠΏΡΠΈ ΡΠ°Π±ΠΎΡΠ΅ Ρ Π±ΠΎΠ»ΡΡΠΈΠΌΠΈ Π½Π°Π±ΠΎΡΠ°ΠΌΠΈ Π΄Π°Π½Π½ΡΡ . Π ΠΏΡΠΈΠ²Π΅Π΄Π΅Π½Π½ΠΎΠΌ Π½ΠΈΠΆΠ΅ ΠΏΡΠΈΠΌΠ΅ΡΠ΅ ΠΏΡΠΎΠΈΡΡ ΠΎΠ΄ΠΈΡ ΡΠ»Π΅Π΄ΡΡΡΠ΅Π΅:
- large_array ΡΠΎΠ·Π΄Π°Π΅ΡΡΡ Π²Π½ΡΡΡΠΈ ΡΡΠ½ΠΊΡΠΈΠΈ main ΠΈ ΡΡΠ°Π½ΠΎΠ²ΠΈΡΡΡ Π²Π»Π°Π΄Π΅Π»ΡΡΠ΅ΠΌ Vec. ΠΡΠΎ ΠΎΠ·Π½Π°ΡΠ°Π΅Ρ, ΡΡΠΎ large_array ΠΎΡΠ²Π΅ΡΠ°Π΅Ρ Π·Π° ΠΎΡΠ²ΠΎΠ±ΠΎΠΆΠ΄Π΅Π½ΠΈΠ΅ ΠΏΠ°ΠΌΡΡΠΈ, Π²ΡΠ΄Π΅Π»Π΅Π½Π½ΠΎΠΉ Π΄Π»Ρ Vec, ΠΊΠΎΠ³Π΄Π° ΠΎΠ½ Π²ΡΡ ΠΎΠ΄ΠΈΡ ΠΈΠ· ΠΎΠ±Π»Π°ΡΡΠΈ Π²ΠΈΠ΄ΠΈΠΌΠΎΡΡΠΈ.
- sum ΡΠΎΠ·Π΄Π°Π΅ΡΡΡ ΠΊΠ°ΠΊ ΡΡΡΠ»ΠΊΠ° Π½Π° ΡΠ΅Π·ΡΠ»ΡΡΠ°Ρ Π²ΡΠ·ΠΎΠ²Π° large_array.iter().sum(). Π’Π°ΠΊΠΈΠΌ ΠΎΠ±ΡΠ°Π·ΠΎΠΌ, sum Π½Π΅ Π²Π»Π°Π΄Π΅Π΅Ρ Π΄Π°Π½Π½ΡΠΌΠΈ, Π° ΠΏΡΠΎΡΡΠΎ ΡΡΡΠ»Π°Π΅ΡΡΡ Π½Π° Π½ΠΈΡ
.
- Π ΠΊΠΎΠ½ΡΠ΅ ΡΡΠ½ΠΊΡΠΈΠΈ main, ΠΊΠΎΠ³Π΄Π° large_array Π²ΡΡ
ΠΎΠ΄ΠΈΡ ΠΈΠ· ΠΎΠ±Π»Π°ΡΡΠΈ Π²ΠΈΠ΄ΠΈΠΌΠΎΡΡΠΈ, ΠΏΠ°ΠΌΡΡΡ, Π²ΡΠ΄Π΅Π»Π΅Π½Π½Π°Ρ Π΄Π»Ρ Vec, Π°Π²ΡΠΎΠΌΠ°ΡΠΈΡΠ΅ΡΠΊΠΈ ΠΎΡΠ²ΠΎΠ±ΠΎΠΆΠ΄Π°Π΅ΡΡΡ. ΠΡΠΎ Π³Π°ΡΠ°Π½ΡΠΈΡΡΠ΅ΡΡΡ ΡΠΈΡΡΠ΅ΠΌΠΎΠΉ ΡΠΏΡΠ°Π²Π»Π΅Π½ΠΈΡ ΠΏΠ°ΠΌΡΡΡΡ Rust, ΠΊΠΎΡΠΎΡΠ°Ρ Π°Π²ΡΠΎΠΌΠ°ΡΠΈΡΠ΅ΡΠΊΠΈ ΠΎΡΠ²ΠΎΠ±ΠΎΠΆΠ΄Π°Π΅Ρ ΠΏΠ°ΠΌΡΡΡ, ΠΊΠΎΠ³Π΄Π° Π²Π»Π°Π΄Π΅Π»Π΅Ρ Π²ΡΡ
ΠΎΠ΄ΠΈΡ ΠΈΠ· ΠΎΠ±Π»Π°ΡΡΠΈ Π²ΠΈΠ΄ΠΈΠΌΠΎΡΡΠΈ.
fn main() { let mut large_array: Vec<f64> = vec![1.0; 1_000_000]; let sum: f64 = large_array.iter().sum(); println!("Π‘ΡΠΌΠΌΠ° ΡΠ»Π΅ΠΌΠ΅Π½ΡΠΎΠ² ΡΠ°Π²Π½Π° {}", sum); }
ΠΠ°ΡΠ°Π»Π»Π΅Π»ΠΈΠ·ΠΌ ΠΈ ΠΌΠ½ΠΎΠ³ΠΎΠΏΠΎΡΠΎΡΠ½ΠΎΡΡΡ
Π Python ΠΌΠ½ΠΎΠ³ΠΎΠΏΠΎΡΠΎΡΠ½ΠΎΡΡΡ ΠΈ ΠΏΠ°ΡΠ°Π»Π»Π΅Π»ΠΈΠ·ΠΌ ΠΌΠΎΠΆΠ½ΠΎ ΡΠ΅Π°Π»ΠΈΠ·ΠΎΠ²Π°ΡΡ ΠΏΠΎΠΌΠΎΡΡΡ ΠΌΠΎΠ΄ΡΠ»Π΅ΠΉ threading ΠΈ multiprocessing, Π½ΠΎ ΠΎΠ½ΠΈ ΠΈΠΌΠ΅ΡΡ ΡΠ²ΠΎΠΈ ΠΎΡΠΎΠ±Π΅Π½Π½ΠΎΡΡΠΈ ΠΈ ΠΎΠ³ΡΠ°Π½ΠΈΡΠ΅Π½ΠΈΡ. Π ΡΠ°ΡΡΠ½ΠΎΡΡΠΈ, ΠΈΠ·-Π·Π° Global Interpreter Lock (GIL) Π² Python, ΠΌΠ½ΠΎΠ³ΠΎΠΏΠΎΡΠΎΡΠ½ΠΎΡΡΡ Π½Π΅ Π²ΡΠ΅Π³Π΄Π° ΠΌΠΎΠΆΠ΅Ρ ΠΏΡΠΈΠ²Π΅ΡΡΠΈ ΠΊ ΡΠ²Π΅Π»ΠΈΡΠ΅Π½ΠΈΡ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΠ΅Π»ΡΠ½ΠΎΡΡΠΈ ΠΏΡΠΈ Π²ΡΠΏΠΎΠ»Π½Π΅Π½ΠΈΠΈ Π·Π°Π΄Π°Ρ, ΠΊΠΎΡΠΎΡΡΠ΅ ΠΈΠ½ΡΠ΅Π½ΡΠΈΠ²Π½ΠΎ Π½Π°Π³ΡΡΠΆΠ°ΡΡ ΠΏΡΠΎΡΠ΅ΡΡΠΎΡ. Π ΡΠΎ ΠΆΠ΅ Π²ΡΠ΅ΠΌΡ ΠΌΠΎΠ΄ΡΠ»Ρ multiprocessing ΠΏΠΎΠ·Π²ΠΎΠ»ΡΠ΅Ρ ΠΎΠ±ΠΎΠΉΡΠΈ GIL, ΡΠΎΠ·Π΄Π°Π²Π°Ρ ΠΎΡΠ΄Π΅Π»ΡΠ½ΡΠ΅ ΠΏΡΠΎΡΠ΅ΡΡΡ, ΠΊΠ°ΠΆΠ΄ΡΠΉ ΠΈΠ· ΠΊΠΎΡΠΎΡΡΡ ΠΈΠΌΠ΅Π΅Ρ ΡΠ²ΠΎΠΉ ΡΠΎΠ±ΡΡΠ²Π΅Π½Π½ΡΠΉ ΠΈΠ½ΡΠ΅ΡΠΏΡΠ΅ΡΠ°ΡΠΎΡ Python ΠΈ ΡΠ²ΠΎΡ ΡΠΎΠ±ΡΡΠ²Π΅Π½Π½ΡΡ ΠΊΠΎΠΏΠΈΡ ΠΏΠ°ΠΌΡΡΠΈ. ΠΡΠΈΠ²Π΅Π΄Π΅Π½Π½ΡΠΉ Π½ΠΈΠΆΠ΅ ΠΏΡΠΈΠΌΠ΅Ρ Π΄Π΅ΠΌΠΎΠ½ΡΡΡΠΈΡΡΠ΅Ρ ΠΌΠ½ΠΎΠ³ΠΎΠΏΡΠΎΡΠ΅ΡΡΠΎΡΠ½ΠΎΡΡΡ, ΠΊΠΎΡΠΎΡΠ°Ρ ΡΠ²Π»ΡΠ΅ΡΡΡ ΡΠΎΡΠΌΠΎΠΉ ΠΏΠ°ΡΠ°Π»Π»Π΅Π»ΠΈΠ·ΠΌΠ°:
import multiprocessing import time def heavy(data, i, proc): for index in range(len(data)): data[index] += 1 print(f"ΠΠ±ΡΠ°Π±ΠΎΡΠΊΠ° β {i} ΡΠ΄ΡΠΎ {proc}") def sequential(calc, proc, data): print(f"ΠΠ°ΠΏΡΡΠΊΠ°Π΅ΠΌ ΠΏΠΎΡΠΎΠΊ β {proc}") for i in range(calc): heavy(data, i, proc) print(f"{calc} ΠΎΠ±ΡΠ°Π±ΠΎΡΠΎΠΊ Π΄Π°Π½Π½ΡΡ Π·Π°Π²Π΅ΡΡΠ΅Π½ΠΎ. ΠΡΠΎΡΠ΅ΡΡΠΎΡ β {proc}") def processesed(procs, calc): # procs - ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠ΄Π΅Ρ # calc - ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΠΎΠΏΠ΅ΡΠ°ΡΠΈΠΉ Π½Π° ΡΠ΄ΡΠΎ processes = [] manager = multiprocessing.Manager() data = manager.list([num for num in range(1, 10)]) # Π΄Π΅Π»ΠΈΠΌ Π²ΡΡΠΈΡΠ»Π΅Π½ΠΈΡ Π½Π° ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠ΄Π΅Ρ for proc in range(procs): p = multiprocessing.Process(target=sequential, args=(calc, proc, data)) processes.append(p) p.start() # ΠΆΠ΄Π΅ΠΌ, ΠΏΠΎΠΊΠ° Π²ΡΠ΅ ΡΠ΄ΡΠ° Π·Π°Π²Π΅ΡΡΠ°Ρ ΡΠ²ΠΎΡ ΡΠ°Π±ΠΎΡΡ for p in processes: p.join() return data start = time.time() # ΡΠ·Π½Π°Π΅ΠΌ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠ΄Π΅Ρ Ρ ΠΏΡΠΎΡΠ΅ΡΡΠΎΡΠ° n_proc = multiprocessing.cpu_count() # Π²ΡΡΠΈΡΠ»ΡΠ΅ΠΌ, ΡΠΊΠΎΠ»ΡΠΊΠΎ ΡΠΈΠΊΠ»ΠΎΠ² Π²ΡΡΠΈΡΠ»Π΅Π½ΠΈΠΉ Π±ΡΠ΄Π΅Ρ ΠΏΡΠΈΡ ΠΎΠ΄ΠΈΡΡΡΡ # Π½Π° 1 ΡΠ΄ΡΠΎ, ΡΡΠΎΠ±Ρ Π² ΡΡΠΌΠΌΠ΅ ΠΏΠΎΠ»ΡΡΠΈΠ»ΠΎΡΡ 80+ calc = 80 // n_proc + 1 data = processesed(n_proc, calc) end = time.time() print(f"ΠΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠ΄Π΅Ρ Π² ΠΏΡΠΎΡΠ΅ΡΡΠΎΡΠ΅: {n_proc}\n" f"ΠΠ° ΠΊΠ°ΠΆΠ΄ΠΎΠΌ ΡΠ΄ΡΠ΅ ΠΏΡΠΎΠΈΠ·Π²Π΅Π΄Π΅Π½ΠΎ ΠΎΠ±ΡΠ°Π±ΠΎΡΠΎΠΊ Π΄Π°Π½Π½ΡΡ : {calc}\n" f"ΠΡΠΎΠ³ΠΎ {n_proc * calc} ΠΎΠ±ΡΠ°Π±ΠΎΡΠΎΠΊ Π·Π°: {end - start}\n" f"ΠΠ±ΡΠ°Π±ΠΎΡΠ°Π½Π½ΡΠ΅ Π΄Π°Π½Π½ΡΠ΅: {data}")
Π Rust Π΅ΡΡΡ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠ° Rayon, ΠΊΠΎΡΠΎΡΠ°Ρ ΠΏΠΎΠ·Π²ΠΎΠ»ΡΠ΅Ρ Π»Π΅Π³ΠΊΠΎ ΠΏΡΠ΅ΠΎΠ±ΡΠ°Π·ΠΎΠ²Π°ΡΡ ΠΏΠΎΡΠ»Π΅Π΄ΠΎΠ²Π°ΡΠ΅Π»ΡΠ½ΡΠ΅ Π²ΡΡΠΈΡΠ»Π΅Π½ΠΈΡ Π² ΠΏΠ°ΡΠ°Π»Π»Π΅Π»ΡΠ½ΡΠ΅. Rayon Π³Π°ΡΠ°Π½ΡΠΈΡΡΠ΅Ρ ΠΎΡΡΡΡΡΡΠ²ΠΈΠ΅ ΡΡΠ»ΠΎΠ²ΠΈΠΉ Π³ΠΎΠ½ΠΊΠΈ Π΄Π°Π½Π½ΡΡ , ΡΡΠΎ ΠΈΠ΄Π΅Π°Π»ΡΠ½ΠΎ ΠΎΠ±Π΅ΡΠΏΠ΅ΡΠΈΠ²Π°Π΅Ρ ΠΏΠ°ΡΠ°Π»Π»Π΅Π»ΡΠ½ΠΎΡΡΡ Π²ΡΡΠΈΡΠ»Π΅Π½ΠΈΠΉ:
use rayon::prelude::*; use num_cpus; fn main() { let mut data: Vec<i32> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9]; // ΠΠΏΡΠ΅Π΄Π΅Π»ΡΠ΅ΠΌ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠ΄Π΅Ρ ΠΏΡΠΎΡΠ΅ΡΡΠΎΡΠ° let num_cpus = num_cpus::get(); // ΠΡΡΠΈΡΠ»ΡΠ΅ΠΌ ΠΊΠΎΠ»ΠΈΡΠ΅ΡΡΠ²ΠΎ ΡΠΈΠΊΠ»ΠΎΠ² Π²ΡΡΠΈΡΠ»Π΅Π½ΠΈΠΉ Π΄Π»Ρ ΠΊΠ°ΠΆΠ΄ΠΎΠ³ΠΎ ΡΠ΄ΡΠ° let num_cycles = 80 / num_cpus + 1; // ΠΡΠΏΠΎΠ»Π½ΡΠ΅ΠΌ ΡΠΈΠΊΠ»Ρ Π²ΡΡΠΈΡΠ»Π΅Π½ΠΈΠΉ for _ in 0..num_cycles { data.par_iter_mut().for_each(|x| { *x += 1; }); } println!("{:?}", data); }
ΠΠΈΠ·ΡΠ°Π»ΠΈΠ·Π°ΡΠΈΡ Π΄Π°Π½Π½ΡΡ
Python ΡΠ°ΡΠΏΠΎΠ»Π°Π³Π°Π΅Ρ Π½Π΅ΡΠΊΠΎΠ»ΡΠΊΠΈΠΌΠΈ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠ°ΠΌΠΈ Π΄Π»Ρ Π²ΠΈΠ·ΡΠ°Π»ΠΈΠ·Π°ΡΠΈΠΈ Π΄Π°Π½Π½ΡΡ : Πatplotlib, Seaborn, Bokeh, Plotly, Altair ΠΈ Ρ.Π΄. Π‘Π°ΠΌΡΠ΅ ΠΏΠΎΠΏΡΠ»ΡΡΠ½ΡΠ΅ ΠΈΠ· Π½ΠΈΡ β Πatplotlib ΠΈ Seaborn. ΠΡΠΈ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠΈ ΠΏΠΎΠ·Π²ΠΎΠ»ΡΡΡ Π»Π΅Π³ΠΊΠΎ ΡΠΎΠ·Π΄Π°Π²Π°ΡΡ Π³ΡΠ°ΡΠΈΠΊΠΈ ΠΈ Π΄ΠΈΠ°Π³ΡΠ°ΠΌΠΌΡ, ΡΡΠΎ Π΄Π΅Π»Π°Π΅Ρ Π²ΠΈΠ·ΡΠ°Π»ΠΈΠ·Π°ΡΠΈΡ Π΄Π°Π½Π½ΡΡ Π² Python ΠΌΠ°ΠΊΡΠΈΠΌΠ°Π»ΡΠ½ΠΎ ΠΏΡΠΎΡΡΠΎΠΉ ΠΈ ΡΠ΄ΠΎΠ±Π½ΠΎΠΉ:
import matplotlib.pyplot as plt # ΠΠ°Π½Π½ΡΠ΅ data = [1, 2, 3, 4, 5] # ΠΠ°Π·Π²Π°Π½ΠΈΡ ΠΌΠ΅ΡΡΡΠ΅Π² months = ['Π―Π½Π²Π°ΡΡ', 'Π€Π΅Π²ΡΠ°Π»Ρ', 'ΠΠ°ΡΡ', 'ΠΠΏΡΠ΅Π»Ρ', 'ΠΠ°ΠΉ'] # Π‘ΠΎΠ·Π΄Π°Π΅ΠΌ Π³ΡΠ°ΡΠΈΠΊ fig, ax = plt.subplots() # ΠΡΠ²ΠΎΠ΄ΠΈΠΌ Π΄Π°Π½Π½ΡΠ΅ ax.plot(months, data) # Π£ΡΡΠ°Π½Π°Π²Π»ΠΈΠ²Π°Π΅ΠΌ Π½Π°Π·Π²Π°Π½ΠΈΡ ΠΎΡΠ΅ΠΉ ax.set_xlabel('ΠΠ΅ΡΡΡ') ax.set_ylabel('ΠΠ°Π½Π½ΡΠ΅') plt.show()
Π Π΅Π·ΡΠ»ΡΡΠ°Ρ:
Π Rust Π΄Π»Ρ Π²ΠΈΠ·ΡΠ°Π»ΠΈΠ·Π°ΡΠΈΠΈ ΠΌΠΎΠΆΠ½ΠΎ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΡ plotters:
use plotters::prelude::*; fn main() -> Result<(), Box<dyn std::error::Error>> { let data = vec![1, 2, 3, 4, 5]; let months = vec!["Π―Π½Π²Π°ΡΡ", "Π€Π΅Π²ΡΠ°Π»Ρ", "ΠΠ°ΡΡ", "ΠΠΏΡΠ΅Π»Ρ", "ΠΠ°ΠΉ"]; let root = BitMapBackend::new("plot.png", (640, 480)).into_drawing_area(); root.fill(&WHITE)?; let mut chart = ChartBuilder::on(&root) .caption("ΠΠ΅ΡΡΡΠ½Π°Ρ ΡΡΠ°ΡΠΈΡΡΠΈΠΊΠ°", ("Arial", 50).into_font()) .margin(5) .x_label_area_size(30) .y_label_area_size(30) .build_cartesian_2d(months.iter().cloned().map(|m| m.to_string()).collect::<Vec<String>>(), 0..10)?; chart.configure_mesh().draw()?; chart.draw_series(LineSeries::new( data.iter().enumerate().map(|(i, &v)| (months[i].to_string(), v)), &BLUE, ))?; Ok(()) }
ΠΠ½ΡΠ΅Π³ΡΠ°ΡΠΈΡ Ρ Π΄ΡΡΠ³ΠΈΠΌΠΈ ΡΠ·ΡΠΊΠ°ΠΌΠΈ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΠΈΡΠΎΠ²Π°Π½ΠΈΡ
Python ΠΌΠΎΠΆΠ΅Ρ Π±Π΅ΡΡΠΎΠ²Π½ΠΎ ΠΈΠ½ΡΠ΅Π³ΡΠΈΡΠΎΠ²Π°ΡΡΡΡ Ρ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠ°ΠΌΠΈ C ΠΈ C++ Ρ ΠΏΠΎΠΌΠΎΡΡΡ Cython. ΠΡΠΎ Π΄Π°Π΅Ρ Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΠΎΡΡΡ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡ ΡΡΠ½ΠΊΡΠΈΠΈ ΠΈ Π΄Π°Π½Π½ΡΠ΅ ΠΈΠ· ΡΡΠΈΡ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊ Π² Python-ΠΊΠΎΠ΄Π΅.
ΠΡΠ»ΠΈ Ρ Π²Π°Ρ Π΅ΡΡΡ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠ° my_lib Π½Π° C:
// my_lib.c #include <stdlib.h> int add(int a, int b) { return a + b; }
ΠΠ΅ ΠΌΠΎΠΆΠ½ΠΎ ΡΠΊΠΎΠΌΠΏΠΈΠ»ΠΈΡΠΎΠ²Π°ΡΡ:
gcc -shared -o my_lib.so my_lib.c
Π Π²ΡΠ·Π²Π°ΡΡ Π² Python:
from ctypes import CDLL # ΠΠ°Π³ΡΡΠ·ΠΊΠ° Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠΈ my_lib = CDLL('./my_lib.so') # ΠΡΠ·ΠΎΠ² ΡΡΠ½ΠΊΡΠΈΠΈ add result = my_lib.add(1, 2) print(result) # ΠΡΠ²ΠΎΠ΄ΠΈΡ: 3
Rust ΠΏΡΠ΅Π΄Π»Π°Π³Π°Π΅Ρ Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΠΎΡΡΠΈ Π΄Π»Ρ ΠΈΠ½ΡΠ΅Π³ΡΠ°ΡΠΈΠΈ Ρ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠ°ΠΌΠΈ C ΡΠ΅ΡΠ΅Π· Foreign Function Interface (FFI). FFI ΠΏΠΎΠ·Π²ΠΎΠ»ΡΠ΅Ρ Π²ΡΠ·ΡΠ²Π°ΡΡ ΡΡΠ½ΠΊΡΠΈΠΈ, ΠΎΠΏΡΠ΅Π΄Π΅Π»Π΅Π½Π½ΡΠ΅ Π² Π΄ΡΡΠ³ΠΎΠΌ ΡΠ·ΡΠΊΠ΅ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΠΈΡΠΎΠ²Π°Π½ΠΈΡ, ΠΈΠ· ΠΊΠΎΠ΄Π° Π½Π° Rust. ΠΡΠΎ Π΄ΠΎΡΡΠΈΠ³Π°Π΅ΡΡΡ ΠΏΡΡΠ΅ΠΌ ΠΎΠΏΡΠ΅Π΄Π΅Π»Π΅Π½ΠΈΡ Π²Π½Π΅ΡΠ½Π΅ΠΉ ΡΡΠ½ΠΊΡΠΈΠΈ Π² Rust Ρ ΡΠΈΠ³Π½Π°ΡΡΡΠΎΠΉ ΡΡΠ½ΠΊΡΠΈΠΈ, ΡΠΎΠ²ΠΌΠ΅ΡΡΠΈΠΌΠΎΠΉ Ρ C, ΠΈ Π·Π°ΡΠ΅ΠΌ Π΄ΠΈΠ½Π°ΠΌΠΈΡΠ΅ΡΠΊΠΎΠ³ΠΎ ΡΠ²ΡΠ·ΡΠ²Π°Π½ΠΈΡ Ρ ΠΎΠ±ΡΠ΅ΠΉ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠΎΠΉ, ΡΠΎΠ΄Π΅ΡΠΆΠ°ΡΠ΅ΠΉ ΡΠ΅Π°Π»ΠΈΠ·Π°ΡΠΈΡ ΡΡΠ½ΠΊΡΠΈΠΈ:
// ΠΡΠΈΠΌΠ΅Ρ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°Π½ΠΈΡ FFI Π΄Π»Ρ Π²ΡΠ·ΠΎΠ²Π° ΡΡΠ½ΠΊΡΠΈΠΈ C ΠΈΠ· Rust extern "C" { fn my_c_function(arg1: i32, arg2: f64) -> f64; } fn main() { let result = unsafe { my_c_function(42, 3.14) }; println!("Result: {}", result); }
Π‘ΡΠΎΠΈΡ Π·Π°ΠΌΠ΅ΡΠΈΡΡ, Π² Python-ΠΏΡΠΎΠ΅ΠΊΡΠ°Ρ ΠΌΠΎΠΆΠ½ΠΎ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡ ΠΌΠΎΠ΄ΡΠ»ΠΈ, Π½Π°ΠΏΠΈΡΠ°Π½Π½ΡΠ΅ Π½Π° Rust, ΠΈ Π½Π°ΠΎΠ±ΠΎΡΠΎΡ, Π² Rust ΠΌΠΎΠΆΠ½ΠΎ Π²ΡΠ·ΡΠ²Π°ΡΡ Python. ΠΡΠΎΡΠ΅ Π²ΡΠ΅Π³ΠΎ ΡΡΠΎ ΡΠ΄Π΅Π»Π°ΡΡ Ρ ΠΏΠΎΠΌΠΎΡΡΡ ΡΡΠ΅ΠΉΠΌΠ²ΠΎΡΠΊΠ° PyO3, ΠΊΠΎΡΠΎΡΡΠΉ ΠΏΠΎΠ·Π²ΠΎΠ»ΡΠ΅Ρ ΡΠΎΠ·Π΄Π°Π²Π°ΡΡ Π½Π°ΡΠΈΠ²Π½ΡΠ΅ ΠΌΠΎΠ΄ΡΠ»ΠΈ Python Π½Π° Rust. PyO3 ΠΎΠ±Π΅ΡΠΏΠ΅ΡΠΈΠ²Π°Π΅Ρ ΠΏΡΠΎΡΡΠΎΡΡ ΠΈ ΡΠ΄ΠΎΠ±ΡΡΠ²ΠΎ Π² ΡΠΎΠ·Π΄Π°Π½ΠΈΠΈ ΠΏΡΠΈΠ²ΡΠ·ΠΎΠΊ ΠΈ ΠΈΠ½ΡΠ΅Π³ΡΠ°ΡΠΈΠΈ ΠΊΠΎΠ΄Π° Rust ΠΈ Python. ΠΠΎΡ ΠΏΡΠΎΡΡΠ΅ΠΉΡΠΈΠΉ ΠΏΡΠΈΠΌΠ΅Ρ ΡΠΎΠ·Π΄Π°Π½ΠΈΡ Python-ΠΌΠΎΠ΄ΡΠ»Ρ Π½Π° Rust:
// Rust ΠΊΠΎΠ΄, ΠΈΡΠΏΠΎΠ»ΡΠ·ΡΡΡΠΈΠΉ PyO3 Π΄Π»Ρ ΡΠΎΠ·Π΄Π°Π½ΠΈΡ ΠΌΠΎΠ΄ΡΠ»Ρ Python use pyo3::prelude::*; use pyo3::wrap_pyfunction; #[pyfunction] fn process(data: Vec<i32>) -> Vec<i32> { data.iter().map(|x| x * 2).collect() } #[pymodule] fn rust_module(py: Python, m: &PyModule) -> PyResult<()> { m.add_function(wrap_pyfunction!(process, m)?)?; Ok(()) }
Π‘ΠΊΠΎΠΌΠΏΠΈΠ»ΠΈΡΠΎΠ²Π°Π½Π½ΡΠΉ ΠΌΠΎΠ΄ΡΠ»Ρ Π² ΠΊΠΎΠ΄Π΅ Python ΠΌΠΎΠΆΠ½ΠΎ ΠΈΡΠΏΠΎΠ»ΡΠ·ΠΎΠ²Π°ΡΡ ΡΠ°ΠΊ:
import rust_module data = [1, 2, 3, 4, 5] result = rust_module.process(data) print(result) # ΠΡΠ²ΠΎΠ΄ΠΈΡ: [2, 4, 6, 8, 10]
ΠΠΎΠ΄Π²Π΅Π΄Π΅ΠΌ ΠΈΡΠΎΠ³ΠΈ
ΠΡΠ±ΠΎΡ ΠΌΠ΅ΠΆΠ΄Ρ Python ΠΈ Rust Π΄Π»Ρ Π°Π½Π°Π»ΠΈΠ·Π° Π΄Π°Π½Π½ΡΡ ΠΈ ΠΌΠ°ΡΠΈΠ½Π½ΠΎΠ³ΠΎ ΠΎΠ±ΡΡΠ΅Π½ΠΈΡ β ΡΠ»ΠΎΠΆΠ½Π°Ρ Π΄ΠΈΠ»Π΅ΠΌΠΌΠ°, ΠΏΠΎΡΠΊΠΎΠ»ΡΠΊΡ ΠΎΠ±Π° ΡΠ·ΡΠΊΠ° ΠΏΡΠ΅Π΄Π»Π°Π³Π°ΡΡ ΡΠ½ΠΈΠΊΠ°Π»ΡΠ½ΡΠ΅ ΠΏΡΠ΅ΠΈΠΌΡΡΠ΅ΡΡΠ²Π°:
- Python ΠΎΠ±Π»Π°Π΄Π°Π΅Ρ ΠΌΠ°ΠΊΡΠΈΠΌΠ°Π»ΡΠ½ΠΎ ΠΏΡΠΎΡΡΡΠΌ, ΠΏΠΎΠ½ΡΡΠ½ΡΠΌ ΠΈ Π³ΠΈΠ±ΠΊΠΈΠΌ ΡΠΈΠ½ΡΠ°ΠΊΡΠΈΡΠΎΠΌ, ΡΠ°ΡΠΏΠΎΠ»Π°Π³Π°Π΅Ρ ΠΎΠ±ΡΠΈΡΠ½ΠΎΠΉ ΡΠΊΠΎΡΠΈΡΡΠ΅ΠΌΠΎΠΉ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊ ΠΈ ΡΡΠ΅ΠΉΠΌΠ²ΠΎΡΠΊΠΎΠ² Π΄Π»Ρ ΠΌΠ°ΡΠΈΠ½Π½ΠΎΠ³ΠΎ ΠΎΠ±ΡΡΠ΅Π½ΠΈΡ ΠΈ ΡΠ°Π±ΠΎΡΡ Ρ Π΄Π°Π½Π½ΡΠΌΠΈ. ΠΡΠΎ Π΄Π΅Π»Π°Π΅Ρ Π΅Π³ΠΎ ΠΎΡΠ»ΠΈΡΠ½ΡΠΌ Π²ΡΠ±ΠΎΡΠΎΠΌ Π΄Π»Ρ ΡΠ°Π·ΡΠ°Π±ΠΎΡΡΠΈΠΊΠΎΠ², ΠΊΠΎΡΠΎΡΡΠ΅ ΡΠΎΠ»ΡΠΊΠΎ Π½Π°ΡΠΈΠ½Π°ΡΡ ΠΈΠ·ΡΡΠ°ΡΡ Π°Π½Π°Π»ΠΈΠ· Π΄Π°Π½Π½ΡΡ ΠΈ ΠΌΠ°ΡΠΈΠ½Π½ΠΎΠ΅ ΠΎΠ±ΡΡΠ΅Π½ΠΈΠ΅.
- Π‘ Π΄ΡΡΠ³ΠΎΠΉ ΡΡΠΎΡΠΎΠ½Ρ, Rust ΠΎΠ±Π΅ΡΠΏΠ΅ΡΠΈΠ²Π°Π΅Ρ ΠΌΠ°ΠΊΡΠΈΠΌΠ°Π»ΡΠ½ΡΡ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΠ΅Π»ΡΠ½ΠΎΡΡΡ, Π±Π΅Π·ΠΎΠΏΠ°ΡΠ½ΠΎΡΡΡ, ΡΡΡΠ΅ΠΊΡΠΈΠ²Π½ΡΡ ΠΏΠΎΠ΄Π΄Π΅ΡΠΆΠΊΡ ΠΌΠ½ΠΎΠ³ΠΎΠΏΠΎΡΠΎΡΠ½ΠΎΡΡΠΈ ΠΈ ΠΏΠ°ΡΠ°Π»Π»Π΅Π»ΠΈΠ·ΠΌΠ°. Rust ΠΎΡΠ»ΠΈΡΠ½ΠΎ ΠΏΠΎΠ΄Ρ ΠΎΠ΄ΠΈΡ Π΄Π»Ρ ΠΏΡΠΎΠ΄Π²ΠΈΠ½ΡΡΡΡ ΡΠ°Π·ΡΠ°Π±ΠΎΡΡΠΈΠΊΠΎΠ², ΡΠΎΠ·Π΄Π°ΡΡΠΈΡ ΠΠ Π΄Π»Ρ ΡΠ°Π±ΠΎΡΡ Ρ Π±ΠΎΠ»ΡΡΠΈΠΌΠΈ Π½Π°Π±ΠΎΡΠ°ΠΌΠΈ Π΄Π°Π½Π½ΡΡ ΠΈ Π²ΡΠΏΠΎΠ»Π½Π΅Π½ΠΈΡ ΡΠ»ΠΎΠΆΠ½ΡΡ Π²ΡΡΠΈΡΠ»ΠΈΡΠ΅Π»ΡΠ½ΡΡ Π·Π°Π΄Π°Ρ.
Π ΠΊΠΎΠ½Π΅ΡΠ½ΠΎΠΌ ΠΈΡΠΎΠ³Π΅ Π²ΡΠ±ΠΎΡ ΠΌΠ΅ΠΆΠ΄Ρ Python ΠΈ Rust Π·Π°Π²ΠΈΡΠΈΡ ΠΎΡ Π²Π°ΡΠΈΡ ΠΊΠΎΠ½ΠΊΡΠ΅ΡΠ½ΡΡ ΠΏΠΎΡΡΠ΅Π±Π½ΠΎΡΡΠ΅ΠΉ ΠΈ ΡΡΠΎΠ²Π½Ρ ΠΎΠΏΡΡΠ°. ΠΡΠ»ΠΈ Π²Ρ ΡΠΎΠ»ΡΠΊΠΎ Π½Π°ΡΠΈΠ½Π°Π΅ΡΠ΅ ΠΈΠ·ΡΡΠ°ΡΡ Π°Π½Π°Π»ΠΈΠ· Π΄Π°Π½Π½ΡΡ ΠΈ ΠΌΠ°ΡΠΈΠ½Π½ΠΎΠ΅ ΠΎΠ±ΡΡΠ΅Π½ΠΈΠ΅, ΡΠΎ Π»ΡΡΡΠ΅ Π²ΡΠ±ΡΠ°ΡΡ Python. ΠΡΠ»ΠΈ Ρ Π²Π°Ρ ΡΠΆΠ΅ Π΅ΡΡΡ ΠΎΠΏΡΡ ΡΠ°Π±ΠΎΡΡ Ρ Π΄ΡΡΠ³ΠΈΠΌΠΈ ΡΠ·ΡΠΊΠ°ΠΌΠΈ ΠΏΡΠΎΠ³ΡΠ°ΠΌΠΌΠΈΡΠΎΠ²Π°Π½ΠΈΡ, Π° Π²Π°Ρ ΠΏΡΠΎΠ΅ΠΊΡ Π½ΡΠΆΠ΄Π°Π΅ΡΡΡ Π² Π±ΠΎΠ»Π΅Π΅ Π²ΡΡΠΎΠΊΠΎΠΉ ΠΏΡΠΎΠΈΠ·Π²ΠΎΠ΄ΠΈΡΠ΅Π»ΡΠ½ΠΎΡΡΠΈ ΠΈ Π±Π΅Π·ΠΎΠΏΠ°ΡΠ½ΠΎΡΡΠΈ, ΡΠΎ Rust Π±ΡΠ΄Π΅Ρ ΡΠ°ΠΌΡΠΌ ΠΏΠΎΠ΄Ρ ΠΎΠ΄ΡΡΠΈΠΌ Π²Π°ΡΠΈΠ°Π½ΡΠΎΠΌ.