মামলা
- সাধারণ ক্ষেত্রে : প্রায় সবসময়, আপনি পাইথনে একটি তালিকা বোঝার ব্যবহার করতে চাইবেন কারণ আপনি আপনার কোডটি পড়ছেন এমন নবাগত প্রোগ্রামারদের সাথে কী করছেন তা আরও স্পষ্ট। (এটি অন্যান্য ভাষাগুলির ক্ষেত্রে প্রযোজ্য নয়, যেখানে অন্যান্য প্রতিমা প্রয়োগ করতে পারে)) পাইথন প্রোগ্রামারদের আপনি কী করছেন তা আরও স্পষ্ট হবে, যেহেতু তালিকা অনুধাবনগুলি পুনরাবৃত্তির জন্য পাইথনের ডি-ফ্যাক্টো স্ট্যান্ডার্ড; তারা হয় প্রত্যাশিত ।
- কম-সাধারণ ক্ষেত্রে : তবে আপনার যদি ইতিমধ্যে কোনও ফাংশন সংজ্ঞায়িত করা থাকে
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যেকোন ডেটা স্ট্রাকচারের উপরে ম্যাপিংকে জেনারেলাইজ করে। এটি অজগরটিতে খুব অস্বাভাবিক কারণ অজগর ব্যাকরণ আপনাকে পুনরাবৃত্তির বিষয়ে কথা বলতে জেনারেটর-স্টাইল ব্যবহার করতে বাধ্য করে; আপনি এটি সহজেই সাধারণ করতে পারবেন না can't (এটি কখনও কখনও ভাল এবং কখনও কখনও খারাপ হয়)) আপনি সম্ভবত বিরল অজগর উদাহরণ নিয়ে আসতে পারেন যেখানে map(f, *lists)করণীয় যুক্তিযুক্ত। নিকটতম উদাহরণটি আমি সামনে আসতে পারি sumEach = partial(map,sum), এটি একটি ওয়ান-লাইনার যা মোটামুটি সমান:
def sumEach(myLists):
return [sum(_) for _ in myLists]
- কেবলমাত্র একটি
forলুপ ব্যবহার করুন : আপনি অবশ্যই একটি লুপ ব্যবহার করতে পারেন। ক্রিয়ামূলক-প্রোগ্রামিং দৃষ্টিকোণ থেকে মার্জিত না হলেও, কখনও কখনও অ-স্থানীয় ভেরিয়েবলগুলি অজগর হিসাবে প্রেরণামূলক প্রোগ্রামিং ভাষাগুলিতে কোড পরিষ্কার করে দেয়, কারণ মানুষ সেভাবে কোড পড়তে অভ্যস্ত। লুপগুলি এছাড়াও, সাধারণত, সবচেয়ে কার্যকর যখন আপনি কেবল কোনও জটিল ক্রিয়াকলাপ করছেন যা তালিকা-বোধগম্যতা এবং মানচিত্রের মতো তালিকা তৈরি করছে না তার জন্য অনুকূলিত করা হয়েছে (উদাহরণস্বরূপ সংক্ষেপণ, বা একটি গাছ তৈরি করা ইত্যাদি) - কমপক্ষে least মেমরির ক্ষেত্রে কার্যকর (সময়ের প্রয়োজনে অগত্যা নয়, যেখানে আমি দুর্লভ স্থিতিশীল ফ্যাক্টরটি আশা করতাম, কিছু বিরল রোগতাত্ত্বিক আবর্জনা-সংগ্রহ হিচকি বাদ দিয়ে)
"Pythonism"
আমি "পাইথোনিক" শব্দটি অপছন্দ করি কারণ আমি পাই না যে পাইথোনিকটি আমার চোখে সর্বদা মার্জিত থাকে। তবুও, mapএবং filterঅন্যান্য অনুরূপ ফাংশন (খুব দরকারী itertoolsমডিউলটির মতো) সম্ভবত শৈলীর দিক থেকে অযৌক্তিক হিসাবে বিবেচিত হয়।
আলস্য
দক্ষতার দিক থেকে, বেশিরভাগ কার্যকরী প্রোগ্রামিং কনস্ট্রাক্টের মতো, ম্যাপটি আলস্য হতে পারে এবং বাস্তবে অজগরটি অলস। তার মানে আপনি এটি করতে পারেন ( পাইথন 3 এ ) এবং আপনার কম্পিউটারের স্মৃতিশক্তি চলে না এবং আপনার সমস্ত সংরক্ষণ করা ডেটা হারাবে:
>>> 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 ^^^^^^^^^
অতএব আপনি যদি আপনার সমস্ত ডেটা ব্যবহার না করে থাকেন, বা আপনাকে কী পরিমাণ ডেটা প্রয়োজন তা সময়ের আগে জানা mapনা গেলে পাইথন 3 (এবং পাইথন 2 বা পাইথন 3 তে জেনারেটর এক্সপ্রেশন) প্রয়োজনীয় মুহুর্ত পর্যন্ত তাদের মানগুলি গণনা করা এড়াতে পারে। সাধারণত এটি ব্যবহার থেকে কোনও ওভারহেড ছাড়িয়ে যায় 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>)
ফলাফলগুলি এএএ / বিবিবি / সিসিসি আকারে রয়েছে যেখানে A একটি সার্কা -২০১০ এর সাথে একটি অজগর ৩.???, এবং বি এবং সি-এর একটি সার্কা -৩০ এএমডি ওয়ার্কস্টেশন দিয়ে অজগর ৩.২.১ সহ সঞ্চালিত হয়েছিল, অত্যন্ত ভিন্ন হার্ডওয়্যার সহ। ফলাফলটি মনে হয় যে মানচিত্র এবং তালিকার বোধগম্যতা পারফরম্যান্সের সাথে তুলনীয়, যা অন্যান্য এলোমেলো কারণগুলির দ্বারা সবচেয়ে দৃ strongly়ভাবে প্রভাবিত হয়। আমরা তালিকা comprehensions আশা যখন একমাত্র জিনিস আমরা বলতে পারেন, যে হবে, অদ্ভুত বলে মনে হয় [...]জেনারেটরের এক্সপ্রেশন বেশী ভালো পারফর্ম করতে (...), 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ক্লাসটি বিযুক্ত করার জন্য কিছুটা অস্বচ্ছ, তবে আমরা আমাদের গতি পরীক্ষা দিয়ে উপযুক্ত করতে পারি।
