python - 解析和搜索字符串的更好方法？

Question

我一直在寻求加速一个基本的 Python 函数，它基本上只接受一行文本并检查该行的子字符串。 Python程序如下:

import time

def fun(line):
    l = line.split(" ", 10)
    if 'TTAGGG' in l[9]:
        pass  # Do nothing

line = "FCC2CCMACXX:4:1105:10758:14389# 81 chrM 1 32 10S90M = 16151 16062 CATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTTTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCTTAGGGGATAGCATTG bbb^Wcbbbbccbbbcbccbba]WQG^bbcdcb_^_c_^`ccdddeeeeeffggggiiiiihiiiiihiiihihiiiihghhiihgfgfgeeeeebbb NM:i:1 AS:i:85 XS:i:65 RG:Z:1_DB31"

time0 = time.time()
for i in range(10000):
    fun(line)
print time.time() - time0

我想看看我是否可以使用 Rust 的一些高级功能来获得一些性能，但代码运行速度相当慢。 Rust 转换是:

extern crate regex;
extern crate time;
use regex::Regex;

fn main() {
    let line = "FCC2CCMACXX:4:1105:10758:14389# 81 chrM 1 32 10S90M = 16151 16062 CATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTTTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCTTAGGGGATAGCATTG bbb^Wcbbbbccbbbcbccbba]WQG^bbcdcb_^_c_^`ccdddeeeeeffggggiiiiihiiiiihiiihihiiiihghhiihgfgfgeeeeebbb NM:i:1 AS:i:85 XS:i:65 RG:Z:1_DB31";    
    let substring: &str = "TTAGGG";
    let time0: f64 = time::precise_time_s();

    for _ in 0..10000 {
        fun(line, substring);
    }

    let time1: f64 = time::precise_time_s();
    let elapsed: f64 = time1 - time0;
    println!("{}", elapsed);
}


fn fun(line: &str, substring: &str) {
    let l: Vec<&str> = line.split(" ")
                .enumerate()
                .filter(|&(i, _)| i==9)
                .map(|(_, e) | e)
                .collect();

    let re = Regex::new(substring).unwrap();    
    if re.is_match(&l[0]) {
        // Do nothing
    }
}

在我的机器上，Python 的时间为 0.0065 秒，而 Rusts 为 1.3946 秒。

仅检查一些基本时间，代码的 line.split() 部分耗时约 1 秒，正则表达式步骤约 0.4 秒。这真的是正确的吗，或者是否正确安排了时间？

Answer 1

作为基准，我使用 Python 2.7.6 运行了您的 Python 程序。在 10 次运行中，它的平均时间为 12.2 毫秒，标准偏差为 443 微秒。我不知道你是怎么得到6.5ms这个非常好的时间的。

使用 Rust 1.4.0-dev (febdc3b20) 运行你的 Rust 代码，没有优化，我得到了 958ms 的平均值和 33ms 的标准偏差。

通过优化 (cargo run --release) 运行您的代码，我得到的平均值为 34.6 毫秒，标准差为 495 微秒。 始终在 Release模式下进行基准测试。

您还可以进行进一步的优化:

在计时循环之外编译正则表达式一次:

fn main() {
    // ...
    let substring = "TTAGGG";
    let re = Regex::new(substring).unwrap();

    // ...

    for _ in 0..10000 {
        fun(line, &re);
    }

    // ...
}

fn fun(line: &str, re: &Regex) {
    // ...
}

平均产生 10.4 毫秒，标准偏差为 678 微秒。

切换到子字符串匹配:

fn fun(line: &str, substring: &str) {
    // ...

    if l[0].contains(substring) {
        // Do nothing
    }
}

均值为 8.7 毫秒，标准差为 334 微秒。

最后，如果您只查看一个结果而不是将所有内容都收集到一个向量中:

fn fun(line: &str, substring: &str) {
    let col = line.split(" ").nth(9);

    if col.map(|c| c.contains(substring)).unwrap_or(false) {
        // Do nothing
    }
}

均值为 6.30 毫秒，标准差为 114 微秒。