Apa arti backticks bagi penerjemah python: `num`

Saya bermain-main dengan pemahaman daftar dan saya menemukan cuplikan kecil ini di situs lain:

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

Saya menghabiskan beberapa menit mencoba untuk mereplikasi fungsi (dengan mengetik) sebelum menyadari `num`bit itu merusaknya.

Apa yang dilakukan dengan menyertakan pernyataan dalam karakter tersebut? Dari apa yang saya lihat itu setara dengan str (num). Tetapi ketika saya menghitung waktunya:

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

Dibutuhkan 4,09s sedangkan:

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

membutuhkan 2,43s.

Keduanya memberikan hasil yang identik tetapi yang satu jauh lebih lambat. Apa yang terjadi disini?

EDIT: Anehnya ... repr()memberikan hasil yang sedikit lebih lambat dari `num`. 2,99s vs 2,43s. Menggunakan Python 2.6 (belum mencoba 3.0).

Backticks adalah alias yang tidak digunakan lagi untuk repr(). Jangan menggunakannya lagi, sintaksnya telah dihapus di Python 3.0.

Menggunakan backticks tampaknya lebih cepat daripada menggunakan repr(num)atau num.__repr__()dalam versi 2.x. Saya kira itu karena pencarian kamus tambahan diperlukan di namespace global (untuk repr), atau di namespace objek (untuk __repr__), masing-masing.

Menggunakan dismodul membuktikan asumsi saya:

def f1(a):
    return repr(a)

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

def f3(a):
    return `a`

Pertunjukan pembongkaran:

>>> 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   

f1melibatkan pencarian global untuk repr, f2pencarian atribut __repr__, sedangkan operator backtick diimplementasikan dalam opcode terpisah. Karena tidak ada overhead untuk pencarian kamus ( LOAD_GLOBAL/ LOAD_ATTR) atau untuk pemanggilan fungsi ( CALL_FUNCTION), backticks lebih cepat.

Saya kira orang-orang Python memutuskan bahwa memiliki operasi tingkat rendah yang terpisah repr()tidak sepadan, dan memiliki keduanya repr()dan backticks melanggar prinsip

"Seharusnya ada satu - dan sebaiknya hanya satu --cara yang jelas untuk melakukannya"

jadi fitur tersebut telah dihapus dengan Python 3.0.

Kutipan backtick umumnya tidak berguna dan hilang dengan Python 3.

Untuk apa nilainya, ini:

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

sedikit lebih cepat daripada versi backtick untuk saya. Tetapi mengkhawatirkan hal ini mungkin merupakan pengoptimalan yang prematur.

Dugaan saya adalah itu numtidak menentukan metode __str__(), jadi str()harus melakukan pencarian kedua __repr__.

Para backticks mencari secara langsung __repr__. Jika itu benar, maka menggunakan repr()sebagai ganti backticks akan memberi Anda hasil yang sama.