在我周围的每个人都知道我是Python 的忠实粉丝。大约15年前，当我对 Mathworks Matlab 感到厌倦时，我开始使用Python。虽然Matlab的理念看起来不错，但在掌握了Python之后，我再也没有回头。我甚至成为了我所在大学的Python传道者，"传播这个词"。

会编码并不等于成为软件开发者。当我了解到强类型、SOLID原则和通用编程架构等主题时，我也瞥见了其他编程语言以及它们如何解决问题。特别是Rust引起了我的兴趣，因为我经常看到基于Rust的Python包（例如Polars）。

为了对Rust有一个合适的介绍，我参加了官方的Rustlings课程，这是一个包含96个小型编码问题的本地Git存储库。尽管这是相当可行的，但Rust与Python非常不同。Rust编译器是一个非常严格的家伙，不接受"也许"这个答案。以下是我认为Rust和Python之间的三个主要区别。

免责声明：虽然我对Python相当熟练，但我对其他语言了解有点生疏。我仍在学习Rust，可能对某些部分有误解。

1. 所有权、借用和生命周期

所有权和借用可能是Rust编程语言最基本的方面。它旨在确保内存安全，而无需所谓的垃圾收集器。这是Rust的一个独特概念，我尚未在其他语言中看到过。让我们以一个例子开始，我们将值42分配给变量answer_of_life。Rust现在将在内存中分配一些空间（这有点复杂，但现在我们简化一下），并将"所有权"附加到这个变量上。重要的是要知道一次只能有一个所有者。一些操作会"转移所有权"，使先前的变量引用无效。这通过防止诸如双重释放内存、数据竞争和悬空引用等问题来确保内存安全。

fn main() {
  let s1 = String::from("Hello, Rust!");
  
  // Ownership of the String is transferred from s1 to s2
  let s2 = s1;
  
  // This results in a compilation
  println!("s1: {}", s1);
} // s2 goes out of scope and memory is freed

一个在其他语言中也使用的术语是作用域。这可以被看作是代码中的一个"生存区"。每当代码离开一个作用域时，所有具有所有权的变量都将被释放。这在Python中是根本不同的事情。Python使用垃圾收集器，在没有对其的引用时释放变量。在Source 1的例子中，将所有权从变量s1转移到s2，此后变量s1将无法使用。

对于Python用户来说，所有权可能会令人困惑，因为在开始阶段确实是一场真正的斗争。在Source 1的例子中有点过于简单了。Rust强制你考虑一个变量是在哪里创建的以及它应该如何被转移。例如，当你将参数传递给函数时，所有权可以如Source 2中所示被转移。

fn take_ownership(some_string: String) {
  // The ownership of the String is transferred to some_string
  println!("Got ownership: {}", some_string);
}  // some_string goes out of scope and the memory is freed


fn main() {
  let my_string = String::from("Hello, ownership!");


  // Ownership is transferred to the function and my_string is
  // no longer valid
  take_ownership(my_string);


  // This results in a compilation error as my_string is no
  // longer the owner of the String.
  println!("my_string: {}", my_string);
} // my_string is no longer valid here, as it was moved to take_ownership

仅仅转移所有权可能很麻烦，对于某些用例甚至可能行不通，因此Rust提出了所谓的借用系统。与转移所有权不同，变量同意借用该变量，而原始变量仍保持所有权。默认情况下，借用变量是不可变的，即只读的，但通过添加mut关键字，借用甚至可以是可变的。在Source 3中，我展示了两个不可变的借用和一个可变的借用的例子。当函数超出范围时，所有变量都将被删除。

fn main() {
  // s is the owner of the mutable String
  let mut s = String::from("Hello, Rust!");


  let r1 = &s;  // Immutable borrow
  let r2 = &s;  // Another immutable borrow


  println!("r1: {}, r2: {}", r1, r2);


  let r3 = &mut s;  // Mutable borrow
  r3.push_str(", and Pythonista!"); // Modifying the borrowed value


  println!("r3: {}", r3);
} // r1, r2, r3, and s go out of scope and memory is automagically freed

生命周期是Rust中与借用和所有权相关的一个概念，它帮助编译器强制规定引用可以有效存在多长时间的规则。你可能会遇到这样一种情况，你创建了一个结构或一个函数，它是使用两个借用构建的。这意味着现在函数或结构的结果可能取决于先前的输入。为了更明确地表示这一点，我们可以通过注释生命周期来表达关系。在Source 4中查看一个例子。

struct Quote<'a> {
  part: &'a str,
}  // We annotated this Struct such that its lifetime is linked to part


fn main() {
  let novel = String::from("Do or do not. There is not try.");


  // We split novel on the period but split returns borrows.
  // This means that if novel goes out of scope, so does first_sentence.
  let first_sentence = novel.split('.')
          .next().expect("No period detected!");
   
  // We have annotated the lifetime to be dependent of part.
  // If first_sentence goes out of scope, so does quote.
  let quote = Quote {
    part: first_sentence,
  };
}  // All will be deallocated

2. Rust 不接受 None 为答案

在Python中非常常见的一点在Rust中是不可能的：拥有一个值被设置为 None。这是一个刻意的设计选择，符合Rust的安全性、可预测性和零成本抽象的目标。安全性方面与Rust的所有权、借用和生命周期方面相似：防止引用指向未分配的内存的可能性。通过不给予返回 None 的可能性，将导致更可预测性，因为它强迫开发者明确处理数字可能不存在的情况。由于内存安全和可预测的行为，Rust可以在不牺牲性能的情况下实现其所有高级语言功能。

仅仅拒绝 None 会使 Rust 变得糟糕，因此，创建者提出了一个不错的替代方案：枚举 Option 和 Result。通过这些枚举，我们可以明确表示值的存在或不存在。它还使错误处理变得非常优雅。让我们考虑 Source 5 中使用 Option 的一个示例。

fn divide(x: f64, y: f64) -> Option<f64> {
  if y == 0.0 {
    None
  } else {
    Some(x / y)
  }
}
  
fn main() {
  let result = divide(10.0, 2.0);
  
  match result {
    Some(value) => println!("Result: {}", value),
    None => println!("Cannot divide by zero!"),
  }
}

等一下！你不是说没有 None 吗？这也是我第一次被欺骗的地方，但在这里，None 是一个不带参数的特殊枚举结构。同样，Some 也是一个特殊的结构，但它可以带一个参数。我们的 divide() 函数返回这些可能的枚举值之一，我们稍后可以检查它是什么并采取相应的操作。

没有 None 并强制返回值使得 Rust 变得非常可预测。

主函数使用 match 结构进行结果处理，这非常方便。这在某种程度上类似于其他语言中的 switch/case 构造，除了 Python（见图2中Guido的回应）。match 检查是枚举 Some 还是枚举 None，并执行相应的操作。

Option 枚举是用于可以返回值或不返回值的函数的特殊结构。对于可以返回值或错误的函数，Rust 还有一个更明确的枚举，称为 Result。思想完全相同，主要区别在于 Option 有一个默认的“错误”值 None，而 Result 需要一个显式的“错误”类型。在 Source 6 中，divide 函数使用 Result 重写。

fn divide(x: f64, y: f64) -> Result<f64, &'static str> {
  if y == 0.0 {
    Err("Cannot divide by zero!")
  } else {
    Ok(x / y)
  }
}
  
fn main() {
  let result = divide(10.0, 0.0);
  
  match result {
    Ok(value) => println!("Result: {}", value),
    Err(err) => println!("Error: {}", err),
  }
}

Rust的开发者们看到match结构有时可能有点繁琐，因此添加了if let和while let运算符。这些运算符类似于match，但通过一些美味的糖分提供了一些不错的语法糖。甚至还有一个非常酷的？运算符（此处未显示），为美味的糖分添加了一颗樱桃！

let mut values = vec![Some(1), Some(2), None, Some(3)];


while let Some(value) = values.pop() {
  if let Some(inner_value) = value {
    println!("Popped: {}", inner_value);
  } else {
    println!("Found None");
  }
}

使用Python时，我学会了使用Optional关键字为结果类型化，可以是值，也可以是None。但我不得不承认Rust非常巧妙地解决了这一部分。我可以想象Python社区也会朝着这种风格发展，类似于强（更强）类型化的趋势。

3. 类在哪里？

Python和Rust都可以用于两种编程范式：函数式编程（FP）和面向对象编程（OOP）。但是Rust在实现这些所谓的对象的方式上有所不同。在Python中，我们有一个典型的类对象，我们可以将变量和方法与之关联。与许多其他语言（如Java）一样，我们现在可以将这个方法用作基础，并通过创建继承方法和变量的新对象来扩展功能。

在Rust中，没有class关键字，对象与Python基本不同。Rust使用Trait系统进行代码重用和多态性，这可以提供与多重继承相同的好处，但不会出现与多重继承相关的问题。多重继承通常用于将多个类的各种功能组合或共享，但它可能使代码变得复杂和模糊。一个著名的问题是所谓的菱形问题，见Source 8。

class A:
    def method(self):
        print("Method in class A")


class B(A):
    def method(self):
        print("Method in class B")


class C(A):
    def method(self):
        print("Method in class C")
        
class D(B, C):
    pass


obj = D()
obj.method()  # Ambiguity arises here

尽管我认为我们可以轻松地解决这个问题，但如果我要创建一种新语言，我也会尝试以不同的方式解决这个问题。对于多重继承，目标主要是与其他对象共享类似的功能。在Rust中，使用Trait系统更加优雅地实现了这一点。这种方法不仅在Rust中使用，在Scala、Kotlin和Haskell等语言中也有类似的系统。

在Rust中，类是由Enums和Structs创建的。就它们自身而言，它们只是数据结构，但我们可以向这些类添加功能。我们可以直接这样做，然而，通过使用traits，这些功能可以与多个“类”共享。使用traits的一个重要好处是我们可以事先检查某个trait是否已实现。请看以下示例：

// Define a trait for characters that can speak
trait Speaker {
    fn speak(&self);
}


// Implement the Speaker trait for a Jedi
struct Jedi {
    name: String,
}


impl Speaker for Jedi {
    fn speak(&self) {
        println!("{} says: May the Force be with you.", self.name);
    }
}


// Implement the Speaker trait for a Droid
struct Droid {
    model: String,
}


impl Speaker for Droid {
    fn speak(&self) {
        println!("{} says: Beep boop beep.", self.model);
    }
}


// Function that takes any type implementing the Speaker trait
fn introduce(character: &dyn Speaker) {
    character.speak();
}


fn main() {
    let obi_wan = Jedi {
        name: String::from("Obi-Wan Kenobi"),
    };


    let r2d2 = Droid {
        model: String::from("R2-D2"),
    };


    // Call the introduce function with instances of Jedi and Droid
    introduce(&obi_wan);
    introduce(&r2d2);
}

在这个例子中，我们有一个Speaker trait，代表可以说话的角色。我们为两种类型实现了这个trait：Jedi和Droid。每种类型都提供了自己的speak方法的实现。introduce函数接受任何实现Speaker trait的类型，并调用speak方法。在主函数中，我们创建了Jedi（奥比-万·克诺比）和Droid（R2-D2）的实例，并将它们传递给introduce函数，展示了多态性。

对于我这个Pythonista  来说，Rust的trait系统曾经非常令人困惑。花了一些时间我才欣赏到其语法的优雅之处。

总结

Rust是一门非常酷的语言，但绝对不是一门容易学习的语言。Rustlings课程向我展示了一些基础知识，但我远远不熟练到能够承担大型项目的程度。但我真的很喜欢Rust是如何迫使你编写更好、更安全的代码的。

Python仍然是我的日常首选。在工作中，我们的文档流水线完全由Python构建，而且在机器学习领域，我并没有看到一切都转向另一种语言。Python太容易学习了，即使你是一个糟糕的开发者，也能完成工作。

然而，有一些小的动向朝着Rust。当然，一些包如Polars和Pydantic是使用Rust构建的，而HuggingFace也发布了他们自己用Rust构建的第一个版本的名为Candle的机器学习框架。因此，我认为学习一点Rust并不是一个坏主意！

·  END  ·

HAPPY LIFE

本文仅供学习交流使用，如有侵权请联系作者删除