मामले
- सामान्य मामला : लगभग हमेशा, आप अजगर में एक सूची समझ का उपयोग करना चाहेंगे क्योंकि यह अधिक स्पष्ट होगा कि आप अपने कोड को पढ़ रहे नौसिखिए प्रोग्रामर को क्या कर रहे हैं। (यह अन्य भाषाओं पर लागू नहीं होता है, जहां अन्य मुहावरे लागू हो सकते हैं।) यह और भी स्पष्ट होगा कि आप अजगर प्रोग्रामर के लिए क्या कर रहे हैं, क्योंकि सूची बोध के बाद से पुनरावृत्ति के लिए अजगर में डी-फैक्टो मानक हैं; वे अपेक्षित हैं ।
- कम-सामान्य मामला : हालांकि यदि आपके पास पहले से ही कोई फ़ंक्शन परिभाषित है , तो इसका उपयोग करना अक्सर उचित होता है
map, हालांकि इसे 'अनीफैथोनिक' माना जाता है। उदाहरण के लिए, map(sum, myLists)की तुलना में अधिक सुरुचिपूर्ण / कविता है [sum(x) for x in myLists]। आपको डमी वैरिएबल (जैसे sum(x) for x...या sum(_) for _...या sum(readableName) for readableName...) जो आपको दो बार टाइप करना है, केवल इट्रेट करने के लिए नहीं होने की लालित्य प्राप्त करता है । एक ही तर्क मॉड्यूल के लिए filterऔर reduceकुछ भी रखता है itertools: यदि आपके पास पहले से ही कोई फ़ंक्शन है, तो आप आगे बढ़ सकते हैं और कुछ कार्यात्मक प्रोग्रामिंग कर सकते हैं। यह कुछ स्थितियों में पठनीयता हासिल करता है, और इसे दूसरों में खो देता है (जैसे नौसिखिए प्रोग्रामर, कई तर्क) ... लेकिन आपके कोड की पठनीयता वैसे भी आपकी टिप्पणियों पर निर्भर करती है।
- लगभग कभी नहीं : आप
mapकार्यात्मक प्रोग्रामिंग करते समय एक शुद्ध सार फ़ंक्शन के रूप में फ़ंक्शन का उपयोग करना चाह सकते हैं , जहां आप मैपिंग कर रहे हैं map, या करी कर रहे हैं map, या अन्यथा mapफ़ंक्शन के बारे में बात करने से लाभ उठा सकते हैं । उदाहरण के लिए हास्केल में, एक फ़ंक्शनल इंटरफ़ेस जिसे fmapकिसी भी डेटा संरचना पर मैपिंग को सामान्यीकृत किया जाता है। यह अजगर में बहुत ही असामान्य है क्योंकि अजगर व्याकरण आपको पुनरावृत्ति के बारे में बात करने के लिए जनरेटर-शैली का उपयोग करने के लिए मजबूर करता है; आप इसे आसानी से सामान्य नहीं कर सकते। (यह कभी-कभी अच्छा होता है और कभी-कभी बुरा होता है।) आप शायद दुर्लभ अजगर उदाहरणों के साथ आ सकते हैं, जहां map(f, *lists)करना उचित है। निकटतम उदाहरण मैं साथ आ सकता हूं sumEach = partial(map,sum), जो कि एक-लाइनर है जो बहुत ही समान है:
def sumEach(myLists):
return [sum(_) for _ in myLists]
- सिर्फ
for-लूप का उपयोग करना : आप निश्चित रूप से सिर्फ फॉर-लूप का उपयोग कर सकते हैं। हालांकि एक कार्यात्मक-प्रोग्रामिंग दृष्टिकोण से उतना सुंदर नहीं है, कभी-कभी गैर-स्थानीय चर, अनिवार्य प्रोग्रामिंग भाषाओं जैसे अजगर में कोड को स्पष्ट कर देते हैं, क्योंकि लोग उस तरह से कोड पढ़ने के लिए उपयोग किए जाते हैं। फ़ोर-लूप भी हैं, आम तौर पर, सबसे अधिक कुशल जब आप किसी भी जटिल ऑपरेशन को कर रहे होते हैं जो सूची-बोध और मानचित्र जैसी सूची का निर्माण नहीं कर रहे होते हैं (जैसे संक्षेप में, या एक पेड़ बनाने के लिए, आदि) - कम से कम स्मृति के संदर्भ में कुशल (समय के संदर्भ में जरूरी नहीं, जहां मैं सबसे खराब कारक की उम्मीद करूं, कुछ दुर्लभ रोग-कचरा-संग्रह हिचकी को रोकना)।
"Pythonism"
मैं "पाइथोनिक" शब्द को नापसंद करता हूं क्योंकि मुझे नहीं लगता कि पाइथोनिक मेरी आंखों में हमेशा सुरुचिपूर्ण है। फिर भी, mapऔर filter(इसी तरह के उपयोगी itertoolsमॉड्यूल की तरह) कार्यों को शैली के संदर्भ में संभवतः अनैफोनिक माना जाता है।
आलस्य
दक्षता के संदर्भ में, अधिकांश कार्यात्मक प्रोग्रामिंग निर्माणों की तरह, MAP CAN BE LAZY , और वास्तव में अजगर में आलसी है। इसका मतलब है कि आप ऐसा कर सकते हैं ( python3 में ) और आपका कंप्यूटर मेमोरी से बाहर नहीं चलेगा और आपके सभी सहेजे न गए डेटा को खो देगा:
>>> map(str, range(10**100))
<map object at 0x2201d50>
एक सूची समझने की कोशिश करें:
>>> [str(n) for n in range(10**100)]
# DO NOT TRY THIS AT HOME OR YOU WILL BE SAD #
ध्यान दें कि सूची की समझ भी स्वाभाविक रूप से आलसी है, लेकिन अजगर ने उन्हें गैर-आलसी के रूप में लागू करने के लिए चुना है । फिर भी, अजगर जनरेटर के रूप में आलसी सूची समझ का समर्थन करता है, जो निम्नानुसार है:
>>> (str(n) for n in range(10**100))
<generator object <genexpr> at 0xacbdef>
आप मूल रूप से [...]वाक्य रचनाकार को सूची निर्माणकर्ता की तरह जनरेटर अभिव्यक्ति में पास करने के बारे में सोच सकते हैं , जैसे list(x for x in range(5))।
संक्षिप्त संक्षिप्त उदाहरण
from operator import neg
print({x:x**2 for x in map(neg,range(5))})
print({x:x**2 for x in [-y for y in range(5)]})
print({x:x**2 for x in (-y for y in range(5))})
सूची की समझ गैर-आलसी है, इसलिए अधिक मेमोरी की आवश्यकता हो सकती है (जब तक कि आप जनरेटर की समझ का उपयोग न करें)। वर्ग कोष्ठक [...]अक्सर चीजों को स्पष्ट करते हैं, खासकर जब कोष्ठक की गड़बड़ी में। दूसरी ओर, कभी-कभी आप अंत में टाइपिंग की तरह क्रिया करते हैं [x for x in...। जब तक आप अपने पुनरावृत्तियों को छोटा रखते हैं, तब तक सूची बोध सामान्य रूप से स्पष्ट हो जाता है यदि आप अपने कोड को इंडेंट नहीं करते हैं। लेकिन आप हमेशा अपने कोड को इंडेंट कर सकते हैं।
print(
{x:x**2 for x in (-y for y in range(5))}
)
या चीजों को तोड़ना:
rangeNeg5 = (-y for y in range(5))
print(
{x:x**2 for x in rangeNeg5}
)
पायथन 3 के लिए दक्षता तुलना
map अब आलसी है:
% python3 -mtimeit -s 'xs=range(1000)' 'f=lambda x:x' 'z=map(f,xs)'
1000000 loops, best of 3: 0.336 usec per loop ^^^^^^^^^
इसलिए यदि आप अपने सभी डेटा का उपयोग नहीं कर रहे हैं, या समय से पहले नहीं जानते हैं कि आपको कितने डेटा की आवश्यकता है, तो mappython3 में (और python2 या python3 में जनरेटर के भाव) अंतिम मूल्यों की आवश्यकता होने तक उनके मूल्यों की गणना करने से बचें। आमतौर पर यह आमतौर पर किसी भी उपरि का उपयोग करने से आगे निकल जाएगा map। नकारात्मक पक्ष यह है कि यह सबसे कार्यात्मक भाषाओं के विपरीत अजगर में बहुत सीमित है: आपको यह लाभ केवल तभी मिलता है जब आप अपने डेटा को बाएं से दाएं "क्रम में" तक पहुंचते हैं, क्योंकि अजगर जनरेटर के अभिव्यक्तियों का केवल आदेश का मूल्यांकन किया जा सकता है x[0], x[1], x[2], ...।
हालाँकि हम कहते हैं कि हमारे पास एक पूर्व-निर्मित कार्य है fजिसे हम करना चाहते हैं map, और हम mapतुरंत के साथ मूल्यांकन को मजबूर करके आलस्य को अनदेखा करते हैं list(...)। हम कुछ बहुत ही रोचक परिणाम प्राप्त करते हैं:
% python3 -mtimeit -s 'xs=range(1000)' 'f=lambda x:x' 'z=list(map(f,xs))'
10000 loops, best of 3: 165/124/135 usec per loop ^^^^^^^^^^^^^^^
for list(<map object>)
% python3 -mtimeit -s 'xs=range(1000)' 'f=lambda x:x' 'z=[f(x) for x in xs]'
10000 loops, best of 3: 181/118/123 usec per loop ^^^^^^^^^^^^^^^^^^
for list(<generator>), probably optimized
% python3 -mtimeit -s 'xs=range(1000)' 'f=lambda x:x' 'z=list(f(x) for x in xs)'
1000 loops, best of 3: 215/150/150 usec per loop ^^^^^^^^^^^^^^^^^^^^^^
for list(<generator>)
परिणाम एएए / बीबीबी / सीसीसी के रूप में हैं, जहां ए को एक सर्पा-2010 इंटेल वर्कस्टेशन पर पायथन 3 के साथ प्रदर्शन किया गया था। और, और बी और सी को एक ए -2013 एएमडी वर्कस्टेशन के साथ अजगर 3.2.1 के साथ प्रदर्शन किया गया था। बेहद अलग हार्डवेयर के साथ। परिणाम यह प्रतीत होता है कि प्रदर्शन में मानचित्र और सूची की समझ तुलनीय है, जो अन्य यादृच्छिक कारकों से सबसे अधिक प्रभावित होता है। केवल एक चीज जो हम बता सकते हैं, वह यह है कि अजीब तरह से, जबकि हम उम्मीद करते हैं कि सूची [...]अभिव्यक्तियाँ जनरेटर के अभिव्यक्तियों की तुलना में बेहतर प्रदर्शन करती हैं (...), mapयह भी अधिक कुशल है कि जनरेटर अभिव्यक्ति (फिर से यह मानकर कि सभी मूल्यों का मूल्यांकन / उपयोग किया जाता है)।
यह महसूस करना महत्वपूर्ण है कि ये परीक्षण एक बहुत ही सरल कार्य (पहचान समारोह) मानते हैं; हालांकि यह ठीक है क्योंकि यदि फ़ंक्शन जटिल था, तो कार्यक्रम में अन्य कारकों की तुलना में प्रदर्शन ओवरहेड नगण्य होगा। (यह अभी भी अन्य सरल चीजों के साथ परीक्षण करने के लिए दिलचस्प हो सकता है f=lambda x:x+x)
यदि आप अजगर विधानसभा को पढ़ने में कुशल हैं, तो आप disमॉड्यूल का उपयोग करके देख सकते हैं कि क्या वास्तव में पर्दे के पीछे चल रहा है:
>>> listComp = compile('[f(x) for x in xs]', 'listComp', 'eval')
>>> dis.dis(listComp)
1 0 LOAD_CONST 0 (<code object <listcomp> at 0x2511a48, file "listComp", line 1>)
3 MAKE_FUNCTION 0
6 LOAD_NAME 0 (xs)
9 GET_ITER
10 CALL_FUNCTION 1
13 RETURN_VALUE
>>> listComp.co_consts
(<code object <listcomp> at 0x2511a48, file "listComp", line 1>,)
>>> dis.dis(listComp.co_consts[0])
1 0 BUILD_LIST 0
3 LOAD_FAST 0 (.0)
>> 6 FOR_ITER 18 (to 27)
9 STORE_FAST 1 (x)
12 LOAD_GLOBAL 0 (f)
15 LOAD_FAST 1 (x)
18 CALL_FUNCTION 1
21 LIST_APPEND 2
24 JUMP_ABSOLUTE 6
>> 27 RETURN_VALUE
>>> listComp2 = compile('list(f(x) for x in xs)', 'listComp2', 'eval')
>>> dis.dis(listComp2)
1 0 LOAD_NAME 0 (list)
3 LOAD_CONST 0 (<code object <genexpr> at 0x255bc68, file "listComp2", line 1>)
6 MAKE_FUNCTION 0
9 LOAD_NAME 1 (xs)
12 GET_ITER
13 CALL_FUNCTION 1
16 CALL_FUNCTION 1
19 RETURN_VALUE
>>> listComp2.co_consts
(<code object <genexpr> at 0x255bc68, file "listComp2", line 1>,)
>>> dis.dis(listComp2.co_consts[0])
1 0 LOAD_FAST 0 (.0)
>> 3 FOR_ITER 17 (to 23)
6 STORE_FAST 1 (x)
9 LOAD_GLOBAL 0 (f)
12 LOAD_FAST 1 (x)
15 CALL_FUNCTION 1
18 YIELD_VALUE
19 POP_TOP
20 JUMP_ABSOLUTE 3
>> 23 LOAD_CONST 0 (None)
26 RETURN_VALUE
>>> evalledMap = compile('list(map(f,xs))', 'evalledMap', 'eval')
>>> dis.dis(evalledMap)
1 0 LOAD_NAME 0 (list)
3 LOAD_NAME 1 (map)
6 LOAD_NAME 2 (f)
9 LOAD_NAME 3 (xs)
12 CALL_FUNCTION 2
15 CALL_FUNCTION 1
18 RETURN_VALUE
ऐसा लगता है कि [...]सिंटैक्स का उपयोग करना बेहतर है list(...)। अफसोस की बात है कि mapक्लास डिसाइड करने के लिए थोड़ा अपारदर्शी है, लेकिन हम अपनी गति परीक्षण के कारण बना सकते हैं।
