Python、rust、Julia的简单对比

Python一门简单易入门的语言，目前在tiobe编程语言流行榜上位列第一，由于其简单的语言，以及能和C的生态很好的互动，Python目前已成为人工智能第一语言，由于GIL的存在，Python无法使用多线程，同时Python的速度也一直受到诟病。

Rust是一门新兴的现代语言，属于静态语言，主打类型安全，内存安全，零成本抽象，rust无垃圾回收机制，这使得rust的速度可以和C++媲美，在rust中独特的所有权以及生命周期概念是巧妙的范式转换，但也增加了rust的学习难度。

Julia是一门年轻的语言，有MIT主导，主要面向科学计算，旨在提供简单的语法和极高的运行效率。由于Julia的主要是面向数据科学家和学术界，在语言的设计上和其他的编程语言有所不同，目前Julia和Python相比还缺少生态。

这一次是一个很简单的对比，使用三个语言完成一个任务，将一个数组中的元素进行排序，并将值为0的元素放到数组的末尾，如：输入[0,5,4,8,3,1,0]，输出[1,3,4,5,8,0,0]

参考了leetcode上的题目力扣

接下来看Python代码

def move_zeros(li):
    a = []
    b = []
    res = []
    for i in li:
        if i == 0:
            a.append(i)
        else:
            b.append(i)

    new = []
    for i in range(len(b)):
        smallest = findSmallest(b)
        new.append(b.pop(smallest))
    
    new.extend(a)
    return new

# 找到最小元素的位置
def findSmallest(arr):
    smallest = arr[0]
    smallest_index = 0
    for i in range(1, len(arr)):
        if arr[i] < smallest:
            smallest = arr[i]
            smallest_index = i
    return smallest_index

rust版本

fn main() {
    let orin = vec![0, 9, 8, 0, 1, 7];
    let res: (Vec<i32>, Vec<i32>) = split_zero(&orin);
    let (mut x, y) = res;
	
    let mut new: Vec<i32> = Vec::new();
    for _i in 0..x.len() {
        let smallest = find_smallest(&x);
        new.push(x.remove(smallest))
    };
    
    //添加0到末尾
    for i in y {
        new.push(i);
    };
    println!("{:?}", new);
}

//找出向量中的最小值的位置
fn find_smallest(arr: &Vec<i32>) -> usize {
    let mut smallest = arr[0];
    let mut smallest_index = 0;
    for i in 1..arr.len() {
        if arr[i] < smallest {
            smallest = arr[i];
            smallest_index = i;
        }
    }
    return smallest_index
}

//将向量中为0的和不为0的分开为两个向量
fn split_zero(li: &Vec<i32>) -> (Vec<i32>, Vec<i32>) {
    let mut a: Vec<i32> = Vec::new();
    let mut b: Vec<i32> = Vec::new();
    for i in li {
        if *i != 0 {
            a.push(*i)
        }
        else {
            b.push(*i)
        }
    }
    return (a, b)
}

Julia的版本（优快云不支持Julia的高亮）

# 将列表的非零和零分开为两个数组
function split(list)
    a = []
    b = []
    for i in list
        if i != 0
            push!(a, i)
        else
            push!(b, i)
        end
    end
    return a, b
end

# 找到数组的最小元素的位置
function smallest(list)
    smallest = list[1]
    smallest_index = 1
    for num in [i for i in 2:length(list)]
        if list[num] < smallest
            smallest = list[num]
            smallest_index = num
        end
    end
    return smallest_index
end

orin = [0,2,8,1,6,0]
x, y = split(orin)
new = []
for i in [i for i in 1:length(x)]
    small = smallest(x)
    push!(new, popat!(x, small))
end
new.append!(new, y)
println(new)

个人认为Julia的语法时最简单的，Julia在使用数组的方式上和Python基本一样，Julia的数组第一个元素的索引是1这个和Python还有rust都不同。在控制语句上三者都基本相同，在Python中通过缩进来标识代码的块，在rust中使用的是大括号，在Julia中用end来标识。由于Python和Julia都是动态类型的语言，相比静态语言的rust代码要简单很多。

总结：使用这三种语言我的感受是，如果要进行比较快速的开发那么Python是首选，因为Python有大量的库，在国内的使用人数也很多，很容易找到教程资料。如果是需要进行的大量的数据计算特别是矩阵运算之类的，Julia会是更好的选择。涉及到更底层的开发选择rust