O que crases significam para o interpretador Python: `num`

Estou brincando com as compreensões de listas e encontrei este pequeno trecho em outro site:

return ''.join([`num` for num in xrange(loop_count)])

Passei alguns minutos tentando replicar a função (digitando) antes de perceber que o `num`bit a estava quebrando.

O que incluir uma declaração nesses caracteres? Pelo que posso ver, é o equivalente a str (num). Mas quando eu cronometrei:

return ''.join([str(num) for num in xrange(10000000)])

Leva 4,09s, enquanto:

return ''.join([`num` for num in xrange(10000000)])

leva 2,43s.

Ambos fornecem resultados idênticos, mas um é muito mais lento. O que está acontecendo aqui?

EDIT: Estranhamente ... repr()dá resultados ligeiramente mais lentos do que `num`. 2,99s vs 2,43s. Usando Python 2.6 (não tentei 3.0 ainda).

Backticks são um alias obsoleto para repr() . Não os use mais, a sintaxe foi removida no Python 3.0.

Usar crases parece ser mais rápido do que usar repr(num)ou num.__repr__()na versão 2.x. Acho que é porque a pesquisa de dicionário adicional é necessária no namespace global (for repr) ou no namespace do objeto (for __repr__), respectivamente.

Usar o dismódulo prova minha suposição:

def f1(a):
    return repr(a)

def f2(a):
    return a.__repr__()

def f3(a):
    return `a`

Desmontando programas:

>>> import dis
>>> dis.dis(f1)
  3           0 LOAD_GLOBAL              0 (repr)
              3 LOAD_FAST                0 (a)
              6 CALL_FUNCTION            1
              9 RETURN_VALUE
>>> dis.dis(f2)
  6           0 LOAD_FAST                0 (a)
              3 LOAD_ATTR                0 (__repr__)
              6 CALL_FUNCTION            0
              9 RETURN_VALUE        
>>> dis.dis(f3)
  9           0 LOAD_FAST                0 (a)
              3 UNARY_CONVERT       
              4 RETURN_VALUE   

f1envolve uma pesquisa global para repr, f2uma pesquisa de atributo para __repr__, enquanto o operador crase é implementado em um opcode separado. Uma vez que não há sobrecarga para pesquisa de dicionário ( LOAD_GLOBAL/ LOAD_ATTR) nem para chamadas de função (CALL_FUNCTION ), crases são mais rápidos.

Acho que o pessoal do Python decidiu que repr()não vale a pena ter uma operação de baixo nível separada para , e ter ambos os repr()crases viola o princípio

"Deve haver uma - e de preferência apenas uma - maneira óbvia de fazer isso"

portanto, o recurso foi removido no Python 3.0.

As citações de backtick geralmente não são úteis e desapareceram no Python 3.

Por que vale a pena, isto:

''.join(map(repr, xrange(10000000)))

é ligeiramente mais rápido do que a versão backtick para mim. Mas se preocupar com isso é provavelmente uma otimização prematura.

Meu palpite é que numisso não define o método __str__(), então str()é necessário fazer uma segunda pesquisa para __repr__.

Os acúmulos procuram diretamente __repr__. Se isso for verdade, usar em repr()vez dos crases deve dar os mesmos resultados.