Python: Mengapa functools.partial diperlukan?

Aplikasi parsial keren. Fungsi apa yang functools.partialditawarkan yang tidak bisa Anda dapatkan melalui lambdas?

>>> sum = lambda x, y : x + y
>>> sum(1, 2)
3
>>> incr = lambda y : sum(1, y)
>>> incr(2)
3
>>> def sum2(x, y):
    return x + y

>>> incr2 = functools.partial(sum2, 1)
>>> incr2(4)
5

Apakah functoolsentah bagaimana lebih efisien, atau dapat dibaca?

Fungsi apa yang functools.partialditawarkan yang tidak bisa Anda dapatkan melalui lambdas?

Tidak banyak dalam hal fungsi tambahan (tapi, lihat nanti) - dan, keterbacaan ada di mata yang melihatnya.
Kebanyakan orang yang terbiasa dengan bahasa pemrograman fungsional (khususnya yang berada dalam keluarga Lisp / Skema) tampaknya sangat menyukai lambda- saya katakan "sebagian besar", jelas tidak semua, karena Guido dan saya pasti termasuk di antara mereka yang "akrab dengan" (dll. ) namun dianggap lambdasebagai anomali yang merusak pemandangan di Python ...
Dia menyesal telah menerimanya ke Python sementara berencana untuk menghapusnya dari Python 3, sebagai salah satu "gangguan Python".
Saya sepenuhnya mendukungnya dalam hal itu. (Saya suka lambda Skema ... sementara keterbatasannya dalam Python , dan cara anehnya hanya tidak dengan sisa bahasa, buat kulit saya merangkak).

Namun tidak demikian bagi gerombolan lambdakekasih - yang melakukan salah satu hal paling dekat dengan pemberontakan yang pernah terjadi dalam sejarah Python, sampai Guido mundur dan memutuskan untuk pergi lambda.
Beberapa kemungkinan penambahan functools(untuk membuat fungsi mengembalikan konstanta, identitas, dll) tidak terjadi (untuk menghindari duplikasi lambdafungsi yang lebih eksplisit ), meskipun partialtentu saja tetap (tidak ada duplikasi total , juga tidak merusak pemandangan).

Ingat lambdatubuh itu terbatas pada ekspresi , jadi punya keterbatasan. Sebagai contoh...:

>>> import functools
>>> f = functools.partial(int, base=2)
>>> f.args
()
>>> f.func
<type 'int'>
>>> f.keywords
{'base': 2}
>>> 

functools.partialFungsi yang dikembalikan dihiasi dengan atribut yang berguna untuk introspeksi - fungsi yang dibungkus, dan argumen posisional dan bernama apa yang diperbaiki di dalamnya. Lebih jauh, argumen yang dinamai dapat ditimpa segera kembali ("memperbaiki" agaknya, dalam arti, pengaturan default):

>>> f('23', base=10)
23

Jadi, seperti yang Anda lihat, itu pasti tidak sesederhanalambda s: int(s, base=2) ! -)

Ya, Anda dapat memutarbalikkan lambda Anda untuk memberi Anda ini - misalnya, untuk kata kunci-override,

>>> f = lambda s, **k: int(s, **dict({'base': 2}, **k))

tapi saya sangat berharap bahwa bahkan yang paling bersemangat lambda-lover tidak menganggap kengerian ini lebih mudah dibaca daripada partialpanggilan! -). Bagian "pengaturan atribut" bahkan lebih sulit, karena batasan "tubuh adalah ekspresi tunggal" dari Python lambda(ditambah fakta bahwa penugasan tidak pernah dapat menjadi bagian dari ekspresi Python) ... Anda akhirnya "memalsukan penugasan dalam ekspresi" dengan memperluas daftar pemahaman jauh melampaui batas desainnya ...:

>>> f = [f for f in (lambda f: int(s, base=2),)
           if setattr(f, 'keywords', {'base': 2}) is None][0]

Sekarang gabungkan override-argumen-nama yang dinamai, ditambah pengaturan tiga atribut, ke dalam satu ekspresi, dan katakan betapa mudahnya itu dibaca ...!

Nah, inilah contoh yang menunjukkan perbedaan:

In [132]: sum = lambda x, y: x + y

In [133]: n = 5

In [134]: incr = lambda y: sum(n, y)

In [135]: incr2 = partial(sum, n)

In [136]: print incr(3), incr2(3)
8 8

In [137]: n = 9

In [138]: print incr(3), incr2(3)
12 8

Pos-pos ini oleh Ivan Moore memperluas "keterbatasan lambda" dan penutupan dengan python:

• Closures in Python (bagian 2)
• Closures in Python (bagian 3)

Dalam versi terbaru Python (> = 2.7), Anda bisa picklea partial, tetapi bukan lambda:

>>> pickle.dumps(partial(int))
'cfunctools\npartial\np0\n(c__builtin__\nint\np1\ntp2\nRp3\n(g1\n(tNNtp4\nb.'
>>> pickle.dumps(lambda x: int(x))
Traceback (most recent call last):
  File "<ipython-input-11-e32d5a050739>", line 1, in <module>
    pickle.dumps(lambda x: int(x))
  File "/usr/lib/python2.7/pickle.py", line 1374, in dumps
    Pickler(file, protocol).dump(obj)
  File "/usr/lib/python2.7/pickle.py", line 224, in dump
    self.save(obj)
  File "/usr/lib/python2.7/pickle.py", line 286, in save
    f(self, obj) # Call unbound method with explicit self
  File "/usr/lib/python2.7/pickle.py", line 748, in save_global
    (obj, module, name))
PicklingError: Can't pickle <function <lambda> at 0x1729aa0>: it's not found as __main__.<lambda>

Apakah functools entah bagaimana lebih efisien ..?

Sebagai jawaban sebagian untuk ini saya memutuskan untuk menguji kinerja. Ini contoh saya:

from functools import partial
import time, math

def make_lambda():
    x = 1.3
    return lambda: math.sin(x)

def make_partial():
    x = 1.3
    return partial(math.sin, x)

Iter = 10**7

start = time.clock()
for i in range(0, Iter):
    l = make_lambda()
stop = time.clock()
print('lambda creation time {}'.format(stop - start))

start = time.clock()
for i in range(0, Iter):
    l()
stop = time.clock()
print('lambda execution time {}'.format(stop - start))

start = time.clock()
for i in range(0, Iter):
    p = make_partial()
stop = time.clock()
print('partial creation time {}'.format(stop - start))

start = time.clock()
for i in range(0, Iter):
    p()
stop = time.clock()
print('partial execution time {}'.format(stop - start))

pada Python 3.3 itu memberi:

lambda creation time 3.1743163756961392
lambda execution time 3.040552701787919
partial creation time 3.514482823352731
partial execution time 1.7113973411608114

Yang berarti bahwa sebagian membutuhkan sedikit lebih banyak waktu untuk pembuatan tetapi jauh lebih sedikit waktu untuk eksekusi. Ini bisa jadi efek dari ikatan awal dan akhir yang dibahas dalam jawaban dari ars .

Selain fungsi ekstra yang disebutkan Alex, keunggulan lain dari functools.partial adalah kecepatan. Dengan parsial Anda dapat menghindari membangun (dan merusak) bingkai tumpukan lain.

Baik fungsi yang dihasilkan oleh parsial maupun lambdas tidak memiliki dokumen secara default (meskipun Anda dapat mengatur string doc untuk objek apa pun melalui __doc__).

Anda dapat menemukan rincian lebih lanjut di blog ini: Aplikasi Fungsi Sebagian dengan Python

Saya memahami maksud tercepat dalam contoh ketiga.

Ketika saya mengurai lambdas, saya mengharapkan lebih banyak kompleksitas / keanehan daripada yang ditawarkan oleh perpustakaan standar secara langsung.

Anda juga akan melihat bahwa contoh ketiga adalah satu-satunya yang tidak bergantung pada tanda tangan lengkap dari sum2; sehingga membuatnya sedikit lebih longgar digabungkan.