rust python example
1.0.0
Rust เป็นภาษาการเขียนโปรแกรมระบบที่ทำงานได้อย่างรวดเร็วอย่างรวดเร็วป้องกัน Segfaults และรับประกันความปลอดภัยของด้าย
การแสดงผล
นำมาจาก: จาก Rust-lang.org
คำอธิบายที่ดีกว่าของสนิมที่ฉันได้ยินจาก อีเลียส เป็นสมาชิกและ กูรูสนิม ของ กลุ่ม Rust Brazil Telegram
Rust เป็น ภาษาที่ช่วยให้คุณสร้าง abstractions ระดับสูง แต่โดยไม่ให้การควบคุมระดับต่ำ - นั่นคือการควบคุมวิธีการแสดงข้อมูลในหน่วยความจำการควบคุมของรูปแบบการทำเกลียวที่คุณต้องการใช้ ฯลฯ
Rust เป็น ภาษาที่สามารถตรวจจับได้ในระหว่างการรวบรวมข้อผิดพลาดการขนานและการจัดการหน่วยความจำที่เลวร้ายที่สุด (เช่นการเข้าถึงข้อมูลในเธรดที่แตกต่างกันโดยไม่ต้องซิงโครไนซ์หรือใช้ข้อมูลหลังจากที่พวกเขาได้รับการจัดการ) แต่ให้คุณหลบหนีจากกรณีที่คุณรู้ว่าคุณกำลังทำอะไรอยู่
Rust เป็น ภาษาที่ไม่มีรันไทม์สามารถใช้ในการรวมเข้ากับรันไทม์ใด ๆ คุณสามารถเขียนส่วนขยายดั้งเดิมในสนิมที่เรียกโดยโปรแกรม node.js หรือโดยโปรแกรม Python หรือโดยโปรแกรมใน Ruby, Lua ฯลฯ และในทางกลับกันคุณสามารถเขียนโปรแกรมใน Rust โดยใช้ภาษาเหล่านี้ - "Elias Gabriel Amaral da Silva"
มีแพ็คเกจสนิมมากมายเพื่อช่วยให้คุณขยายงูหลามด้วยสนิม
ฉันสามารถพูดถึง Milksnake ที่สร้างโดย Armin Ronacher (ผู้สร้าง Flask) และ PYO3 การผูกสนิมสำหรับล่าม Python
ดูรายการอ้างอิงที่สมบูรณ์ที่ด้านล่าง
สำหรับโพสต์นี้ฉันจะใช้ Rust Cpython มันเป็นสิ่งเดียวที่ฉันได้ทดสอบมันเข้ากันได้กับ Rust เวอร์ชันที่เสถียร และพบว่ามันตรงไปตรงมา
หมายเหตุ : PYO3 เป็นส้อมของ Rust-cpython มาพร้อมกับการปรับปรุงมากมาย แต่ใช้งานได้กับ Rust เวอร์ชันกลางคืนเท่านั้นดังนั้นฉันจึงชอบใช้ความมั่นคงสำหรับโพสต์นี้อย่างไรก็ตามตัวอย่างที่นี่จะต้องใช้งานกับ PYO3
จุดเด่น: มันง่ายมากที่จะเขียนฟังก์ชั่นสนิมและนำเข้าจาก Python และอย่างที่คุณจะเห็นโดยมาตรฐานที่คุ้มค่าในแง่ของประสิทธิภาพ
จุดด้อย: การกระจายของ โครงการ/lib/framework ของคุณจะเรียกร้องให้โมดูลสนิมถูกรวบรวมในระบบเป้าหมายเนื่องจากการเปลี่ยนแปลงของสภาพแวดล้อมและสถาปัตยกรรมจะมีขั้นตอน การรวบรวม ที่คุณไม่มีเมื่อติดตั้งไลบรารี Python บริสุทธิ์คุณสามารถทำให้ง่ายขึ้น
ใช่ Python เป็นที่รู้จักกันดีว่า "ช้า" ในบางกรณีและข่าวดีก็คือสิ่งนี้ไม่สำคัญขึ้นอยู่กับเป้าหมายและลำดับความสำคัญของโครงการของคุณ สำหรับโครงการส่วนใหญ่รายละเอียดนี้จะไม่สำคัญมาก
อย่างไรก็ตามคุณอาจเผชิญกับกรณี ที่หายาก ที่ฟังก์ชั่นหรือโมดูลเดียวใช้เวลามากเกินไปและตรวจพบเป็นคอขวดของประสิทธิภาพโครงการของคุณมักจะเกิดขึ้นกับการแยกวิเคราะห์สตริงและการประมวลผลภาพ
สมมติว่าคุณมีฟังก์ชั่น Python ซึ่งทำการประมวลผลสตริงบางชนิดให้ใช้ตัวอย่างง่าย ๆ ต่อไปนี้ของ counting pairs of repeated chars แต่โปรดทราบว่าตัวอย่างนี้สามารถทำซ้ำได้ด้วยฟังก์ชั่น string processing อื่น ๆ หรือกระบวนการอื่น ๆ ที่ช้าโดยทั่วไปใน Python
# How many subsequent-repeated group of chars are in the given string?
abCCdeFFghiJJklmnopqRRstuVVxyZZ... {millions of chars here}
1 2 3 4 5 6 Python ค่อนข้างช้าสำหรับการประมวลผล string ขนาดใหญ่เพื่อให้คุณสามารถใช้ pytest-benchmark เพื่อเปรียบเทียบฟังก์ชั่น Pure Python (with Iterator Zipping) กับการใช้งาน Regexp
# Using a Python3.6 environment
$ pip3 install pytest pytest-benchmark
จากนั้นเขียนโปรแกรม Python ใหม่ที่เรียกว่า doubles.py
import re
import string
import random
# Python ZIP version
def count_doubles ( val ):
total = 0
for c1 , c2 in zip ( val , val [ 1 :]):
if c1 == c2 :
total += 1
return total
# Python REGEXP version
double_re = re . compile ( r'(?=(.)1)' )
def count_doubles_regex ( val ):
return len ( double_re . findall ( val ))
# Benchmark it
# generate 1M of random letters to test it
val = '' . join ( random . choice ( string . ascii_letters ) for i in range ( 1000000 ))
def test_pure_python ( benchmark ):
benchmark ( count_doubles , val )
def test_regex ( benchmark ):
benchmark ( count_doubles_regex , val )เรียกใช้ pytest เพื่อเปรียบเทียบ:
$ pytest doubles.py
=============================================================================
platform linux -- Python 3.6.0, pytest-3.2.3, py-1.4.34, pluggy-0.4.
benchmark: 3.1.1 (defaults: timer=time.perf_counter disable_gc=False min_roun
rootdir: /Projects/rustpy, inifile:
plugins: benchmark-3.1.1
collected 2 items
doubles.py ..
-----------------------------------------------------------------------------
Name (time in ms) Min Max Mean
-----------------------------------------------------------------------------
test_regex 24.6824 (1.0) 32.3960 (1.0) 27.0167 (1.0)
test_pure_python 51.4964 (2.09) 62.5680 (1.93) 52.8334 (1.96)
-----------------------------------------------------------------------------
ให้ค่า Mean สำหรับการเปรียบเทียบ:
ลัง คือวิธีที่เราเรียกแพ็คเกจสนิม
มีการติดตั้ง Rust (วิธีที่แนะนำคือ https://www.rustup.rs/) Rust ยังมีอยู่ใน Fedora และ Rhel Rust-Toolset
ฉันใช้
rustc 1.21.0
ในโฟลเดอร์เดียวกันรัน:
cargo new pyext-myrustlib มันสร้างโครงการสนิมใหม่ในโฟลเดอร์เดียวกันที่เรียกว่า pyext-myrustlib ที่มี Cargo.toml (Cargo เป็นผู้จัดการแพ็คเกจสนิม) และ src/lib.rs (ที่เราเขียนการใช้งานห้องสมุดของเรา)
มันจะใช้ rust-cpython Crate เป็นการพึ่งพาและบอกให้ขนส่งสินค้าเพื่อสร้าง dylib ที่จะนำเข้าจาก Python
[ package ]
name = " pyext-myrustlib "
version = " 0.1.0 "
authors = [ " Bruno Rocha <[email protected]> " ]
[ lib ]
name = " myrustlib "
crate-type = [ " dylib " ]
[ dependencies . cpython ]
version = " 0.1 "
features = [ " extension-module " ]สิ่งที่เราต้องทำ:
นำเข้ามาโครทั้งหมดจาก cpython Crate
ใช้ประเภท Python และ PyResult จาก cpython ในขอบเขต lib ของเรา
เขียนการใช้งานฟังก์ชั่น count_doubles ใน Rust โปรดทราบว่าสิ่งนี้คล้ายกับรุ่น Python บริสุทธิ์ยกเว้น::
Python เป็นอาร์กิวเมนต์แรกซึ่งเป็นการอ้างอิงถึงล่าม Python และอนุญาตให้เกิดสนิมในการใช้ Python GIL&str Typed val เป็นข้อมูลอ้างอิงPyResult ซึ่งเป็นประเภทที่อนุญาตให้เพิ่มข้อยกเว้น PythonPyResult ใน Ok(total) ( ผลลัพธ์ เป็นประเภท enum ที่แสดงถึงความสำเร็จ (ตกลง) หรือความล้มเหลว (ERR)) และตามที่ฟังก์ชั่นของเราคาดว่าจะส่งคืน PyResult คอมไพเลอร์จะดูแล การห่อ Ok เราในประเภทนั้น (โปรดทราบว่า Pyresult ของเราคาดว่า u64 เป็นค่าคืนสินค้า) ใช้ py_module_initializer! มาโครเราลงทะเบียนแอตทริบิวต์ใหม่ไปยัง LIB รวมถึง __doc__ และเราเพิ่มแอตทริบิวต์ count_doubles ที่อ้างอิง Rust implementation of the function ของเรา
try! มาโครซึ่งเทียบเท่ากับ try.. exceptOk(()) - () เป็น tuple ผลลัพธ์ที่ว่างเปล่าเทียบเท่ากับ None ใน Python # [ macro_use ]
extern crate cpython ;
use cpython :: { Python , PyResult } ;
fn count_doubles ( _py : Python , val : & str ) -> PyResult < u64 > {
let mut total = 0u64 ;
for ( c1 , c2 ) in val . chars ( ) . zip ( val . chars ( ) . skip ( 1 ) ) {
if c1 == c2 {
total += 1 ;
}
}
Ok ( total )
}
py_module_initializer ! ( libmyrustlib , initlibmyrustlib , PyInit_myrustlib , | py , m | {
try ! ( m . add ( py , " __doc__ " , " This module is implemented in Rust " ) ) ;
try! ( m . add ( py , " count_doubles " , py_fn ! ( py , count_doubles ( val : & str ) ) ) ) ;
Ok ( ( ) )
} ) ;ตอนนี้ให้สร้างในสินค้า
$ cargo build --release
Finished release [optimized] target(s) in 0.0 secs
$ ls -la target/release/libmyrustlib *
target/release/libmyrustlib.d
target/release/libmyrustlib.so * < -- Our dylib is here ตอนนี้ให้คัดลอก lib .so สร้างขึ้นไปยังโฟลเดอร์เดียวกันกับที่ doubles.py ของเราคือ:
หมายเหตุ: ใน Fedora คุณต้องได้รับ
.soในระบบอื่นคุณอาจได้รับ.dylibและคุณสามารถเปลี่ยนชื่อมันเปลี่ยนส่วนขยายเป็น.so
$ cd ..
$ ls
doubles.py pyext-myrustlib/
$ cp pyext-myrustlib/target/release/libmyrustlib.so myrustlib.so
$ ls
doubles.py myrustlib.so pyext-myrustlib/การมี
myrustlib.soในโฟลเดอร์เดียวกันหรือเพิ่มลงในเส้นทาง Python ของคุณอนุญาตให้นำเข้าโดยตรงอย่างโปร่งใสเนื่องจากเป็นโมดูล Python
แก้ไข doubles.py ของคุณตอนนี้นำเข้าเวอร์ชัน Rust implemented ของเราและยังเพิ่ม benchmark สำหรับมัน
import re
import string
import random
import myrustlib # <-- Import the Rust implemented module (myrustlib.so)
def count_doubles ( val ):
"""Count repeated pair of chars ins a string"""
total = 0
for c1 , c2 in zip ( val , val [ 1 :]):
if c1 == c2 :
total += 1
return total
double_re = re . compile ( r'(?=(.)1)' )
def count_doubles_regex ( val ):
return len ( double_re . findall ( val ))
val = '' . join ( random . choice ( string . ascii_letters ) for i in range ( 1000000 ))
def test_pure_python ( benchmark ):
benchmark ( count_doubles , val )
def test_regex ( benchmark ):
benchmark ( count_doubles_regex , val )
def test_rust ( benchmark ): # <-- Benchmark the Rust version
benchmark ( myrustlib . count_doubles , val )$ pytest doubles.py
==============================================================================
platform linux -- Python 3.6.0, pytest-3.2.3, py-1.4.34, pluggy-0.4.
benchmark: 3.1.1 (defaults: timer=time.perf_counter disable_gc=False min_round
rootdir: /Projects/rustpy, inifile:
plugins: benchmark-3.1.1
collected 3 items
doubles_rust.py ...
-----------------------------------------------------------------------------
Name (time in ms) Min Max Mean
-----------------------------------------------------------------------------
test_rust 2.5555 (1.0) 2.9296 (1.0) 2.6085 (1.0)
test_regex 25.6049 (10.02) 27.2190 (9.29) 25.8876 (9.92)
test_pure_python 52.9428 (20.72) 56.3666 (19.24) 53.9732 (20.69)
----------------------------------------------------------------------------- ให้ค่า Mean สำหรับการเปรียบเทียบ:
การใช้งานสนิมสามารถ เร็ว กว่า Python Regex และเร็วกว่ารุ่น Python ที่บริสุทธิ์ 21 เท่า
น่าสนใจว่าเวอร์ชัน Regex นั้นเร็วกว่า Pure Python เพียง 2 เท่า :)
หมายเหตุ: ตัวเลขนั้นเหมาะสมสำหรับสถานการณ์นี้โดยเฉพาะสำหรับกรณีอื่น ๆ ที่การเปรียบเทียบอาจแตกต่างกัน
หลังจากบทความนี้ได้รับการเผยแพร่แล้วฉันได้รับความคิดเห็นเกี่ยวกับ R/Python และใน R/Rust
ผลงานมาเป็นคำขอดึงและคุณสามารถส่งใหม่ได้หากคุณคิดว่าฟังก์ชั่นสามารถปรับปรุงได้
ขอบคุณ: Josh Stone เราได้รับการใช้งานที่ดีกว่าสำหรับการเกิดสนิมซึ่งทำซ้ำสตริงเพียงครั้งเดียวและยังเทียบเท่า Python
ขอบคุณ: Purple Pixie เราได้รับการใช้งาน Python โดยใช้ itertools แต่รุ่นนี้ไม่ได้ทำงานได้ดีกว่านี้ต้องการการปรับปรุง
fn count_doubles_once ( _py : Python , val : & str ) -> PyResult < u64 > {
let mut total = 0u64 ;
let mut chars = val . chars ( ) ;
if let Some ( mut c1 ) = chars . next ( ) {
for c2 in chars {
if c1 == c2 {
total += 1 ;
}
c1 = c2 ;
}
}
Ok ( total )
} def count_doubles_once ( val ):
total = 0
chars = iter ( val )
c1 = next ( chars )
for c2 in chars :
if c1 == c2 :
total += 1
c1 = c2
return total import itertools
def count_doubles_itertools ( val ):
c1s , c2s = itertools . tee ( val )
next ( c2s , None )
total = 0
for c1 , c2 in zip ( c1s , c2s ):
if c1 == c2 :
total += 1
return total ตกลงนั่นไม่ใช่จุดประสงค์ของโพสต์นี้โพสต์นี้ไม่เคยเปรียบเทียบ Rust X other language โพสต์นี้เป็นพิเศษเกี่ยวกับ วิธีการใช้ Rust เพื่อขยายและเร่งความเร็วงูเหลือม และการทำเช่นนั้นหมายความว่าคุณมีเหตุผลที่ดีในการเลือก สนิม แทน other language หรือระบบนิเวศ
ฉัน (โดยส่วนตัว) อาจบอกว่า Rust เป็น future proof มากขึ้นเนื่องจากเป็นเรื่องใหม่และมีการปรับปรุงมากมายที่จะมาถึงเช่นกันเพราะระบบนิเวศเครื่องมือและชุมชนและเพราะฉันรู้สึกสบายใจกับไวยากรณ์สนิมฉันชอบมันมาก!
ดังนั้นตามที่คนอื่นคาดไว้เริ่มบ่นเกี่ยวกับการใช้ภาษาอื่น ๆ และมันก็กลายเป็นมาตรฐานและฉันคิดว่ามันเจ๋งมาก!
ดังนั้นในฐานะที่เป็นส่วนหนึ่งของคำขอของฉันสำหรับการปรับปรุงบางคนในข่าวแฮ็กเกอร์ก็ส่งความคิดมาร์ตินซ์ซิซส่ง applementaion โดยใช้ C และ Swig ที่ทำงานได้ดีมาก
รหัส C (Swig Boilerplate ommited)
uint64_t count_byte_doubles ( char * str ) {
uint64_t count = 0 ;
while ( str [ 0 ] && str [ 1 ]) {
if ( str [ 0 ] == str [ 1 ]) count ++ ;
str ++ ;
}
return count ;
} และเพื่อนของเรา Red Hatter Josh Stone ได้ปรับปรุงการใช้งานสนิมอีกครั้งโดยแทนที่ chars ด้วย bytes ดังนั้นจึงเป็นการแข่งขันที่ยุติธรรมกับ C เนื่องจาก C กำลังเปรียบเทียบไบต์แทนที่จะเป็น unicode chars
fn count_doubles_once_bytes ( _py : Python , val : & str ) -> PyResult < u64 > {
let mut total = 0u64 ;
let mut chars = val . bytes ( ) ;
if let Some ( mut c1 ) = chars . next ( ) {
for c2 in chars {
if c1 == c2 {
total += 1 ;
}
c1 = c2 ;
}
}
Ok ( total )
} นอกจากนี้ยังมีแนวคิดในการเปรียบเทียบ list comprehension Python และ numpy ดังนั้นฉันจึงรวมไว้ที่นี่
numpy:
import numpy as np
def count_double_numpy ( val ):
ng = np . fromstring ( val , dtype = np . byte )
return np . sum ( ng [: - 1 ] == ng [ 1 :])รายการความเข้าใจ
def count_doubles_comprehension ( val ):
return sum ( 1 for c1 , c2 in zip ( val , val [ 1 :]) if c1 == c2 ) กรณีทดสอบที่สมบูรณ์อยู่ในไฟล์ที่เก็บ test_all.py
-------------------------------------------------------------------------------------------------
Name (time in us) Min Max Mean
-------------------------------------------------------------------------------------------------
test_rust_bytes_once 476.7920 (1.0) 830.5610 (1.0) 486.6116 (1.0)
test_c_swig_bytes_once 795.3460 (1.67) 1,504.3380 (1.81) 827.3898 (1.70)
test_rust_once 985.9520 (2.07) 1,483.8120 (1.79) 1,017.4251 (2.09)
test_numpy 1,001.3880 (2.10) 2,461.1200 (2.96) 1,274.8132 (2.62)
test_rust 2,555.0810 (5.36) 3,066.0430 (3.69) 2,609.7403 (5.36)
test_regex 24,787.0670 (51.99) 26,513.1520 (31.92) 25,333.8143 (52.06)
test_pure_python_once 36,447.0790 (76.44) 48,596.5340 (58.51) 38,074.5863 (78.24)
test_python_comprehension 49,166.0560 (103.12) 50,832.1220 (61.20) 49,699.2122 (102.13)
test_pure_python 49,586.3750 (104.00) 50,697.3780 (61.04) 50,148.6596 (103.06)
test_itertools 56,762.8920 (119.05) 69,660.0200 (83.87) 58,402.9442 (120.02)
-------------------------------------------------------------------------------------------------
new Rust implementation comparing bytes นั้น ดีกว่า 2x เมื่อเปรียบเทียบกับ Unicode charsRust ยังคงดีกว่า C โดยใช้ SwigRust เปรียบเทียบ unicode chars ยังคงดีกว่า numpyNumpy นั้นดีกว่า first Rust implementation ซึ่งมีปัญหาใน การทำซ้ำสองครั้งเหนือ Unicode Charslist comprehension ไม่ได้สร้างความแตกต่างอย่างมีนัยสำคัญมากกว่าการใช้ pure Pythonหมายเหตุ: หากคุณต้องการเสนอการเปลี่ยนแปลงหรือการปรับปรุงส่ง PR ที่นี่: https://github.com/rochacbruno/rust-python-example/
ฉันได้รับเงินช่วยเหลือมากขึ้นเนื่องจากการร้องขอแบบดึงหนึ่งในนั้นคือ Jason Knight เพื่อปรับปรุง Rust โดยใช้
RUSTFLAGS= " -C target-cpu=native " cargo build --release และสำหรับผู้ที่อยากรู้อยากเห็นเกี่ยวกับการเปรียบเทียบกับ numba ดังนั้น Shyba จึงนำไปใช้และมีอยู่ในสาขา NUMBA https://github.com/rochacbruno/rust-python-example/tree/numba
from numba import jit
@ jit ( nopython = True , cache = True )
def count_doubles_once_numba ( val ):
total = 0
chars = iter ( val )
c1 = next ( chars )
for c2 in chars :
if c1 == c2 :
total += 1
c1 = c2
return totalดูผลลัพธ์ใหม่ด้วย Numba ที่ด้านบนสวยใกล้กับ สนิม
----------------------------------------------------------------------------------------------------
Name (time in us) Min Max Mean
----------------------------------------------------------------------------------------------------
test_pure_python_once_numba 292.0990 (1.0) 317.7590 (1.0) 296.7477 (1.0)
test_numpy_numba 326.2470 (1.12) 526.1350 (1.66) 338.1704 (1.14)
test_rust_bytes_once 336.0620 (1.15) 1,053.0090 (3.31) 342.5122 (1.15)
test_c_swig_bytes_once 375.6310 (1.29) 1,389.9070 (4.37) 388.9181 (1.31)
test_rust_once 986.0360 (3.38) 2,498.5850 (7.86) 1,006.5819 (3.39)
test_numpy 1,137.1750 (3.89) 2,000.5430 (6.30) 1,167.2551 (3.93)
test_rust 2,555.1400 (8.75) 3,645.3900 (11.47) 2,592.0419 (8.73)
test_regex 22,597.1750 (77.36) 25,027.2820 (78.76) 22,851.8456 (77.01)
test_pure_python_once 32,418.8830 (110.99) 34,818.0800 (109.57) 32,756.3244 (110.38)
test_pure_python 43,823.5140 (150.03) 45,961.8460 (144.64) 44,367.1028 (149.51)
test_python_comprehension 46,360.1640 (158.71) 50,578.1740 (159.17) 46,986.8058 (158.34)
test_itertools 49,080.8640 (168.03) 51,016.5230 (160.55) 49,405.2562 (166.49)
---------------------------------------------------------------------------------------------------- และยังมีการใช้งาน Cython โดย Mike Fletcher ในสาขา cython https://github.com/rochacbruno/rust-python-example/tree/cython
กับผลลัพธ์:
----------------------------------------------------------------------------------------------------
Name (time in us) Min Max Mean
----------------------------------------------------------------------------------------------------
test_rust_bytes_once 336.7590 (1.0) 806.2610 (1.0) 346.5317 (1.0)
test_cython 756.1610 (2.25) 2,343.3680 (2.91) 785.6455 (2.27)
test_c_swig_bytes_once 802.4250 (2.38) 1,632.4290 (2.02) 840.8603 (2.43)
----------------------------------------------------------------------------------------------------กลับไปที่จุดประสงค์ของโพสต์นี้ วิธีการเร่งความเร็วงูหลามด้วยสนิม ที่เราเริ่มต้นด้วย:
ในตัวอย่างนี้ Rust ดำเนินการเร็วกว่า Python บริสุทธิ์ ของเรา 100 เท่า
Rust จะไม่ช่วยคุณอย่างน่าอัศจรรย์คุณต้องรู้ภาษาเพื่อให้สามารถใช้โซลูชันที่ชาญฉลาดและเมื่อนำไปใช้ในด้านที่ถูกต้องมันคุ้มค่ากับ C ในแง่ของประสิทธิภาพและมาพร้อมกับเครื่องมือที่น่าทึ่งระบบนิเวศชุมชนและโบนัสความปลอดภัย
Rust อาจ ยัง ไม่ได้เป็น general purpose language ที่เลือกตามระดับความซับซ้อนและอาจไม่ใช่ตัวเลือกที่ดี กว่า ที่จะเขียน applications ง่าย ๆ ทั่วไปเช่น web และสคริปต์ test automation
อย่างไรก็ตามสำหรับ specific parts ของโครงการที่ Python เป็นที่รู้จักกันว่าเป็นคอขวดและตัวเลือกที่เป็นธรรมชาติของคุณจะใช้ส่วนขยาย C/C++ การเขียนส่วนขยายนี้ในสนิมดูเหมือนง่ายและดีกว่าที่จะรักษา
ยังมีการปรับปรุงอีกมากมายที่จะเกิดขึ้นในสนิมและลังอื่น ๆ อีกมากมายที่จะนำเสนอ Python <--> Rust แม้ว่าคุณจะไม่รวมภาษาในเข็มขัดเครื่องมือของคุณในตอนนี้ แต่ก็คุ้มค่าที่จะเปิดตาสู่อนาคต!
ตัวอย่างเกี่ยวกับสิ่งพิมพ์นี้ได้รับแรงบันดาลใจจาก Extending Python with Rust Talk โดย Samuel Cormier-iijima ใน Pycon Canada วิดีโอที่นี่: https://www.youtube.com/watch?v=-ylbuezkg4m
และโดย My Python is a little Rust-y โดย Dan Callahan ใน Pycon Montreal วิดีโอที่นี่: https://www.youtube.com/watch?v=3CWJ0MH-4MA
ข้อมูลอ้างอิงอื่น ๆ :
เข้าร่วมชุมชน:
เข้าร่วมชุมชน Rust คุณสามารถค้นหาลิงก์กลุ่มได้ใน https://www.rust-lang.org/en-us/community.html
หากคุณพูดภาษาโปรตุเกส ฉันขอแนะนำให้คุณเข้าร่วม https://t.me/rustlangbr และยังมี http://bit.ly/canalrustbr บน YouTube
Bruno Rocha
ข้อมูลเพิ่มเติม: http://about.me/rochacbruno และ http://brunorocha.org
