Processamento de texto-Python vs desempenho Perl [fechado]

Uma otimização fácil no seu código Python seria pré-compilar esses regexes, então eles não estão sendo recompilados de cada vez.

exists_re = re.compile(r'^(.*?) INFO.*Such a record already exists')
location_re = re.compile(r'^AwbLocation (.*?) insert into')

E depois no teu círculo:

mprev = exists_re.search(currline)

E

mcurr = location_re.search(currline)

Que por si só não vai por magia o seu script Python em linha com o seu script Perl, mas chamar repetidamente a re em um loop sem compilar primeiro é mau pratica em Python.

Hipótese: o Perl passa menos tempo a recuar em linhas que não correspondem devido às optimizações que tem que o Python não.

O que ganhas ao substituir

^(.*?) INFO.*Such a record already exists

Com

^((?:(?! INFO).)*?) INFO.*Such a record already 

Ou

^(?>(.*?) INFO).*Such a record already exists

As chamadas de funções são um pouco caras em termos de tempo em Python. E ainda assim você tem uma chamada de função invariante de loop para obter o nome do arquivo dentro do loop:

fn = fileinput.filename()

Mova esta linha acima do laço for e deverá ver alguma melhoria no seu timing em Python. Provavelmente não o suficiente para derrotar o Perl.

No entanto, você pode seguir algumas das dicas postadas aqui:

Http://wiki.python.org/moin/PythonSpeed/PerformanceTips

#!/usr/bin/python

import re
import glob
import sys
import os

exists_re = re.compile(r'^(.*?) INFO.*Such a record already exists', re.I)
location_re = re.compile(r'^AwbLocation (.*?) insert into', re.I)

for mask in sys.argv[1:]:
    for fname in glob.glob(mask):
        if os.path.isfile(fname):
            f = open(fname)
            for line in f:
                mex = exists_re.search(line)
                if mex:
                    xlogtime = mex.group(1)

                mloc = location_re.search(line)
                if mloc:
                    print fname, xlogtime, mloc.group(1)
            f.close()

Actualizar como reacção a "é demasiado complexo" .

while (<>) {
    ...
}

... também esconde um monte de coisas que têm de ser feitas de alguma forma em um mais geral idioma. Por outro lado, é muito fácil tornar o código Python mais legível Se você mover a parte ilegível para fora:

#!/usr/bin/python

import re
import glob
import sys
import os

def input_files():
    '''The generator loops through the files defined by masks from cmd.'''
    for mask in sys.argv[1:]:
        for fname in glob.glob(mask):
            if os.path.isfile(fname):
                yield fname


exists_re = re.compile(r'^(.*?) INFO.*Such a record already exists', re.I)
location_re = re.compile(r'^AwbLocation (.*?) insert into', re.I)

for fname in input_files():
    with open(fname) as f:        # Now the f.close() is done automatically
        for line in f:
            mex = exists_re.search(line)
            if mex:
                xlogtime = mex.group(1)

            mloc = location_re.search(line)
            if mloc:
                print fname, xlogtime, mloc.group(1)

Aqui o def input_files() pode ser colocado noutro local (por exemplo, noutro módulo), ou pode ser reutilizado. É possível imitar até mesmo o Perl ' s while (<>) {...} facilmente, embora não da mesma forma sintaticamente:

#!/usr/bin/python

import re
import glob
import sys
import os

def input_lines():
    '''The generator loops through the lines of the files defined by masks from cmd.'''
    for mask in sys.argv[1:]:
        for fname in glob.glob(mask):
            if os.path.isfile(fname):
                with open(fname) as f: # now the f.close() is done automatically
                    for line in f:
                        yield fname, line

exists_re = re.compile(r'^(.*?) INFO.*Such a record already exists', re.I)
location_re = re.compile(r'^AwbLocation (.*?) insert into', re.I)

for fname, line in input_lines():
    mex = exists_re.search(line)
    if mex:
        xlogtime = mex.group(1)

    mloc = location_re.search(line)
    if mloc:
        print fname, xlogtime, mloc.group(1)

Então o último for pode parecer tão fácil (em princípio) como o Perl while (<>) {...}. Estes melhoramentos de legibilidade são mais difíceis de Perl.