पायथन में गोल्फ के लिए टिप्स

Question

पायथन में गोल्फिंग के लिए आपके पास क्या सामान्य सुझाव हैं? मैं उन विचारों की तलाश कर रहा हूं, जिन्हें कोड-गोल्फ समस्याओं पर लागू किया जा सकता है और जो कि पायथन के लिए कम से कम कुछ हद तक विशिष्ट हैं (उदाहरण के लिए "टिप्पणियां हटाएं" एक उत्तर नहीं है)।

कृपया प्रति उत्तर एक टिप पोस्ट करें।

Comments

ओह, मैं इस तरह के सवालों का एक पूरा सेट देख सकता हूं, जैसे प्रत्येक भाषा के लिए आने वाला ...

— आर। मार्टिनो फर्नांडीस

@ मेरातिंहो मैं सहमत हूँ। बस एक C ++ समकक्ष शुरू किया । मुझे नहीं लगता कि यह एक बुरी बात है, जब तक कि हम इन सवालों के कई प्रकारों में पुन: पोस्ट किए गए समान उत्तरों को नहीं देखते हैं।

— '12:

सवाल से प्यार करो, लेकिन मुझे खुद को बताना होगा "यह केवल प्रोडक्शन कोड के लिए मज़ेदार नहीं है"

— ग्रेग गिडा

क्या यह सवाल सामुदायिक विकि पद नहीं होना चाहिए?

— दिनुकायन

@dorukayhan नोप; यह एक मान्य कोड-गोल्फ टिप्स प्रश्न है, जो CG'ing प्रयोजनों के लिए अजगर कोड को छोटा करने के लिए सुझाव मांग रहा है। इस तरह के प्रश्न साइट के लिए पूरी तरह से मान्य हैं, और इनमें से कोई भी टैग स्पष्ट रूप से यह नहीं कहता है कि यह प्रश्न SO के विपरीत CW'd होना चाहिए, जिसके लिए CG चुनौती के लिए CW'd की आवश्यकता थी। इसके अलावा, एक अच्छा उत्तर लिखना, और इस तरह की युक्तियों को ढूंढना हमेशा कुछ का हकदार होता है, जो कि दूर ले जाया जाता है यदि प्रश्न सामुदायिक विकि (प्रतिनिधि) है

— आउटगॉल्फ

Answer 1

के a=b=c=0बजाय का उपयोग करें a,b,c=0,0,0।

के a,b,c='123'बजाय का उपयोग करें a,b,c='1','2','3'।

Comments

यह सामान्य रूप से अच्छी टिप है :)

ध्यान दें कि यह आवश्यक रूप से उन उत्परिवर्तित वस्तुओं को परिभाषित करने के लिए काम नहीं करेगा जिन्हें आप इन-प्लेस संशोधित कर रहे हैं। a = b = [१] वास्तव में a = [१] से अलग है; b = [१]

— isaacg

पहले टिप के बारे में मजेदार बात यह है कि यह जावा में भी काम करता है।

— जस्टिन

@ जस्टिन हां, लेकिन केवल आदिम प्रकारों के साथ

— हाइपरनेट्रिनो

लेकिन कभी भी एक = b = c = [] या किसी ऑब्जेक्ट इंस्टेंस का उपयोग न करें क्योंकि सभी चर एक ही उदाहरण को इंगित करेंगे। जो शायद आप नहीं चाहते हैं।

— PhE

Answer 2

सशर्त लंबा हो सकता है। कुछ मामलों में, आप एक साधारण सशर्त को बदल सकते हैं (a,b)[condition]। अगर conditionसच है, तो bवापस कर दिया जाता है।

तुलना

if a<b:return a
else:return b

इसके लिए

return(b,a)[a<b]

Comments

ये बिल्कुल समान नहीं हैं। पहला व्यक्ति केवल उस अभिव्यक्ति का मूल्यांकन करता है जिसे वापस लौटा दिया जाता है जबकि दूसरा हमेशा उन दोनों का मूल्यांकन करता है। : इन लोगों को शॉर्ट सर्किट करना a if a<b else bऔरa<b and a or b

— मारीनस

(lambda(): b, lambda(): a)[a < b]()लैम्ब्डा के साथ अपना शॉर्ट-सर्किट बनाएं

— मिंग-तांग

@marinus, वे समान नहीं हैं: बस P and A or Bकिसी भी ए के लिए विचार करें जो देता है bool(A)=False। लेकिन (P and [A] or [B])[0]काम करेगा। संदर्भ के लिए diveintopython.net/power_of_introspection/and_or.html देखें ।

— किलोडेक

लैंबडास सशर्त अभिव्यक्ति की तुलना में अधिक लंबा है।

— user2357112

@ user2357112 लेकिन जब आप उनका उपयोग करते हैं तो वे आपको बहुत अच्छे लगते हैं। :]

— चेस रीज़ २०'१४ को

Answer 3

एक बार मैंने एक महान काम किया है:

if 3 > a > 1 < b < 5: foo()

के बजाय:

if a > 1 and b > 1 and 3 > a and 5 > b: foo()

पायथन की तुलना ऑपरेटरों ने रॉक की।

---

पायथन 2 में सब कुछ तुलनीय होने का उपयोग करते हुए, आप andऑपरेटर को इस तरह से बचा सकते हैं । उदाहरण के लिए, यदि a, b, cऔर dपूर्णांक हैं,

if a<b and c>d:foo()

एक चरित्र से छोटा किया जा सकता है:

if a<b<[]>c>d:foo()

यह उपयोग करता है कि हर सूची किसी पूर्णांक से बड़ी है।

यदि cऔर dसूचियाँ हैं, तो यह और भी बेहतर हो जाता है:

if a<b<c>d:foo()

Comments

बेशक अगर यह वास्तव में गोल्फ होता तो यह होता3>a>1<b<5

— Rafe Kettler

समरूपता को प्यार करो। $ A और $ b के मिनट खोजने के लिए पुराने पर्ल गोल्फ ट्रिक की याद दिलाता है: [$a => $b]->[$b <= $a]:)

— साइमन व्हिटकेर

ध्यान दें कि दूसरा उदाहरण (कोई सूची नहीं) के साथ भी किया जा सकता हैif(a<b)+(c>d):foo()

— WorldSEnder

द + क होना चा हए *। एक orहोगा+

— WorldSEnder

foo()if 3>a>1<b<5

— एर्ग आउटफोलर

Answer 4

यदि आप बार-बार एक अंतर्निहित फ़ंक्शन का उपयोग कर रहे हैं, तो विभिन्न तर्कों का उपयोग करते हुए इसे नया नाम देने के लिए अधिक स्थान-कुशल हो सकता है:

r=range
for x in r(10):
 for y in r(100):print x,y

Comments

हालांकि वास्तव में किसी भी बाइट को नहीं बचाया।

— user2357112

आर = रेंज और अन्य दो आर 9 अक्षर हैं; दो बार सीमा का उपयोग करना 10 वर्ण है। इस उदाहरण में बहुत बड़ी बचत नहीं है, लेकिन एक महत्वपूर्ण बचत को देखने के लिए रेंज का एक और उपयोग करना होगा।

— फ्रैंक

@ फ्रेंक अतिरिक्त न्यूलाइन एक और चरित्र है।

— L3viathan

वास्तव में दो पुनरावृत्ति लंबाई पांच फ़ंक्शन नाम पर सहेजने के लिए बहुत कम है। आपको आवश्यकता है: लंबाई 2: 6 प्रतिनिधि, लंबाई 3: 4 प्रतिनिधि, लंबाई 4 या 5: 3 प्रतिनिधि, लंबाई> = 6: 2 प्रतिनिधि। AKA (लंबाई -1) * (प्रतिनिधि -1)> 4।

— अर्जन जोहान्सन

ध्यान दें कि यह प्रथम श्रेणी के कार्यों वाली सभी भाषाओं पर लागू है।

— 22

Answer 5

कभी-कभी आपके पायथन कोड को आपको इंडेंटेशन के 2 स्तरों की आवश्यकता होती है। स्पष्ट बात यह है कि प्रत्येक इंडेंटेशन स्तर के लिए एक और दो रिक्त स्थान का उपयोग करें।

हालांकि, पायथन 2 टैब और अंतरिक्ष वर्णों को अलग-अलग इंडेंटिंग स्तर मानता है।

इसका मतलब है कि पहला इंडेंटेशन लेवल एक जगह हो सकता है और दूसरा एक टैब कैरेक्टर हो सकता है।

उदाहरण के लिए:

if 1:
 if 1:
\tpass

\tटैब कैरेक्टर कहां है।

Comments

कूल, मैंने इस बारे में कभी नहीं सोचा था!

— जूल्स ऑलोन

यह python3 में विफल रहता है: आप अधिक मिश्रण रिक्त स्थान और टैब (कोडगोल्फ के लिए एक बुरी चीज नहीं, लेकिन अन्य सभी मामलों में एक अच्छी बात हो सकती है)।

— बकुरीउ

अजगर 3.4 में यह ठीक काम करने लगता है।

— ट्राइकोप्लेक्स

@trichoplax , अजगर 3.4.3 में मुझे मिलता हैTabError: inconsistent use of tabs and spaces in indentation.

— छत पर

संदर्भ के लिए, एक टैब 8 रिक्त स्थान के लायक है।

— २१:३५ पर आउटगोल्फर

Answer 6

स्ट्रिंग प्रतिस्थापन का उपयोग करें और execलंबे कीवर्ड से निपटने के लिए lambdaजो आपके कोड में अक्सर दोहराया जाता है।

a=lambda b:lambda c:lambda d:lambda e:lambda f:0   # 48 bytes  (plain)
exec"a=`b:`c:`d:`e:`f:0".replace('`','lambda ')    # 47 bytes  (replace)
exec"a=%sb:%sc:%sd:%se:%sf:0"%(('lambda ',)*5)     # 46 bytes  (%)

लक्ष्य स्ट्रिंग बहुत बार होती है 'lambda ', जो 7 बाइट्स लंबी होती है। मान लीजिए कि आपके कोड स्निपेट में nघटनाएँ हैं 'lambda ', और sबाइट्स लंबा है। फिर:

• plainविकल्प है sबाइट्स लंबे।
• replaceविकल्प है s - 6n + 29बाइट्स लंबे।
• %विकल्प है s - 5n + 22 + len(str(n))बाइट्स लंबे।

इन तीन विकल्पों के लिए बचाए गए बाइट्स के एक प्लॉट सेplain , हम यह देख सकते हैं:

• के लिए n <5 lambdas, तो आप कुछ भी कल्पना नहीं कर बेहतर कर रहे हैं।
• के लिए एन = 5 , लेखन exec"..."%(('lambda ',)*5)2 बाइट्स बचाता है, और आपका सबसे अच्छा विकल्प है।
• के लिए n> 5 , लेखन exec"...".replace('`','lambda ')आपका सबसे अच्छा विकल्प है।

अन्य मामलों के लिए, आप नीचे दी गई तालिका को अनुक्रमित कर सकते हैं:

          1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 (occurences)
       +---------------------------------------------------------
     3 |  -  -  -  -  -  -  -  -  -  -  -  -  -  -  r  r  r  r  r  
     4 |  -  -  -  -  -  -  -  -  -  r  r  r  r  r  r  r  r  r  r  
     5 |  -  -  -  -  -  -  -  r  r  r  r  r  r  r  r  r  r  r  r  
     6 |  -  -  -  -  -  r  r  r  r  r  r  r  r  r  r  r  r  r  r  
     7 |  -  -  -  -  %  r  r  r  r  r  r  r  r  r  r  r  r  r  r  
     8 |  -  -  -  %  %  r  r  r  r  r  r  r  r  r  r  r  r  r  r  
     9 |  -  -  -  %  %  r  r  r  r  r  r  r  r  r  r  r  r  r  r  
    10 |  -  -  %  %  %  r  r  r  r  r  r  r  r  r  r  r  r  r  r  
    11 |  -  -  %  %  %  r  r  r  r  r  r  r  r  r  r  r  r  r  r  
    12 |  -  -  %  %  %  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r = replace
    13 |  -  -  %  %  %  r  r  r  r  r  r  r  r  r  r  r  r  r  r   % = string %
    14 |  -  %  %  %  %  r  r  r  r  r  r  r  r  r  r  r  r  r  r   - = do nothing
    15 |  -  %  %  %  %  r  r  r  r  r  r  r  r  r  r  r  r  r  r  
  (length)

उदाहरण के लिए, यदि स्ट्रिंग lambda x,y:(लंबाई 11) आपके कोड में 3 बार होती है, तो आप लिखना बंद कर सकते हैं exec"..."%(('lambda x,y:',)*3)।

Comments

इसे अधिक वोट मिलना चाहिए, यह एक बहुत उपयोगी टिप है।

— bigblind

यह अत्यंत दुर्लभ है कि यह काम करता है। की लागत replaceबहुत बड़ी है।

— 2

जब यह काम करता है, हालांकि, यह बहुत मदद करता है।

— अंडरग्राउंडोरेल

दिलचस्प है, यह भी कभी नहीं सोचा!

— क्लाउडी सिप

मैंने अजगर के आधार पर लैम्बडा के लिए एक नया ऑपरेटर जोड़ा है: =>बस स्ट्रिंग है = lambda । उदाहरण के लिए, f=>:0होगा f = lambda: 0।

— NoOneIsHere

Answer 7

कई में से एक स्ट्रिंग को चुनने के लिए विस्तारित स्लाइसिंग का उपयोग करें

>>> for x in 0,1,2:print"fbboaaorz"[x::3]
... 
foo
bar
baz

बनाम

>>> for x in 0,1,2:print["foo","bar","baz"][x]
... 
foo
bar
baz

इस बूलियन टू-स्ट्रिंग मामले में, कोई भी लिख सकता है

b*"string"or"other_string"

के लिये

["other_string","string"][b]

इंटरलेयिंग के विपरीत, यह किसी भी लंबाई के तारों के लिए काम करता है, लेकिन ऑपरेटर की पूर्ववर्ती समस्याएं हो सकती हैं यदि bइसके बजाय एक अभिव्यक्ति है।

Comments

ध्यान दें कि पहला उदाहरण ठीक वैसी ही लंबाई है जैसा किfor x in ("foo","bar","baz"): print x

— मतीन उल्हाक

@MateenUlhaq, यह सिर्फ एक उदाहरण है कि कैसे विभिन्न मूल्यों का xप्रतिपादन किया जाता है। गोल्फ का हिस्सा "fbboaaorz"[x::3]बनाम ["foo","bar","baz"][x]कैसे xमूल्य प्राप्त होता है, यह आपके गोल्फ समाधान का एक और हिस्सा होगा।

— gnibbler

Answer 8

उपयोग `n`करने के बजाय एक पूर्णांक को स्ट्रिंग में बदलने के लिए उपयोग करें str(n):

>>> n=123
>>> `n`
'123'

Comments

अच्छा है, लेकिन पायथन 3 के साथ काम नहीं करता है।

— अलेक्जेंड्रू

ध्यान दें: वास्तव में पूर्णांक के लिए काम करता है, लेकिन तार के लिए नहीं, उदाहरण के लिए।

— ०२:१२

btw। `` repr के लिए कम है

— अलेक्जेंड्रू

-2 ** 31 से छोटा या 2 ** 31-1 (Longs) से बड़ा पूर्णांक अंत में 'L' से निबटा जाता है।

— हॉलवबो

इसका उपयोग फ्लोट्स को पूरी सटीकता से प्रिंट करने के लिए भी किया जा सकता है

— gnibbler

Answer 9

मैजिक नंबर के रूप में लुकअप टेबल स्टोर करें

कहते हैं कि आप एक बूलियन लुकअप टेबल को हार्डकोड करना चाहते हैं, जैसे पहले बारह अंग्रेजी नंबरों में से कौन सा एक है n।

0: False
1: True
2: False
3: False
4: False
5: False
6: False
7: True
8: False
9: True
10:True
11:True
12:False

फिर, आप इस लुकअप तालिका को इस प्रकार लागू कर सकते हैं:

3714>>i&1

परिणामी 0या के 1बराबर होने Falseके साथ True।

विचार यह है कि जादू संख्या तालिका को बिटस्ट्रिंग bin(3714)= के रूप में संग्रहीत करती है 0b111010000010, -थ अंक के साथ n(अंत से) nवें तालिका प्रविष्टि के अनुरूप है । हम सही स्थानों पर nसंख्या nस्थानों को बिट्स करके और अंतिम अंक लेकर , वें प्रविष्टि का उपयोग करते हैं &1।

यह भंडारण विधि बहुत कुशल है। विकल्पों की तुलना करें

n in[1,7,9,10,11]
'0111010000010'[n]>'0'

आपके पास अपना लुकअप टेबल स्टोर मल्टीबेट एंट्री हो सकता है जिसे पसंद किया जा सकता है

 340954054>>4*n&15

प्रासंगिक चार-बिट ब्लॉक निकालने के लिए।

Comments

क्या हमारे पास चार-बिट ब्लॉक के लिए एक उदाहरण परिणाम हो सकता है? क्या आपने n-bit ब्लॉक के लिए एक नियम का उपयोग किया है?

— जेरोमजे

हेक्स कभी-कभी और भी छोटा हो सकता है।

— जूनून 21

यह बहुत सी भाषाओं के लिए उपयोगी है।

— Cycece

@ जूनाज़ान हेक्स 999 999 से अधिक की संख्या के लिए छोटा है ।

— मतीन उल्हाक

Answer 10

एक में दो संख्यात्मक छोरों को संक्षिप्त करें

कहते हैं कि आप एक m*nग्रिड की कोशिकाओं पर पुनरावृत्ति कर रहे हैं । दो नेस्टेड forछोरों के बजाय , एक पंक्ति और स्तंभों में से एक के लिए, यह आमतौर पर m*nग्रिड की कोशिकाओं पर पुनरावृति करने के लिए एक लूप का उपयोग करने के लिए छोटा होता है । आप लूप के अंदर सेल की पंक्ति और कॉलम निकाल सकते हैं।

मूल कोड:

for i in range(m):
 for j in range(n):
  do_stuff(i,j)

गोल्फ कोड:

for k in range(m*n):
  do_stuff(k/n,k%n)

वास्तव में, आप दो श्रेणियों के कार्टेशियन उत्पाद पर ध्यान केंद्रित कर रहे हैं, जोड़ी (i,j)को एन्कोडिंग के रूप में x=i*n+j। आपने rangeलूप के अंदर एक महंगा कॉल और इंडेंटेशन के स्तर को बचाया है । पुनरावृत्ति का क्रम अपरिवर्तित है।

पाइथन 3. के //बजाय का उपयोग करें /। यदि आप संदर्भित करते हैं iऔर jकई बार, यह लूप के अंदर i=k/n, उनके मूल्यों को निर्दिष्ट करने के लिए तेज़ हो सकता है j=k%n।

Comments

यह कमाल का है। मुझे कभी इस बात का एहसास नहीं हुआ कि यह संभव है!

— theonlygusti 19

मैंने इसे जावास्क्रिप्ट के लिए युक्तियों में देखा। यह ज्यादातर भाषाओं में एक बहुत ही उपयोगी ट्रिक है।

— साइओस

संदर्भ के लिए, इसे 3 छोरों तक विस्तारित करने के लिए:for i in range(m*n*o): do_stuff(i/n/o,i%(n*o)/o,i%o)

— mbomb007

के लिए nछोरों: repl.it/EHwa

— mbomb007

कुछ मामलों में, itertools.productनेस्टेड छोरों की तुलना में बहुत अधिक संक्षिप्त हो सकता है, खासकर जब कार्टेशियन उत्पादों का निर्माण होता है। a1, a2, b1, b2के कार्टेशियन उत्पाद के उदाहरण हैं'ab''12'

— आरोन 3468

Answer 11

जब तक निम्नलिखित टोकन के साथ eया शुरू नहीं होता है E। आप एक नंबर के बाद स्पेस हटा सकते हैं।

उदाहरण के लिए:

if i==4 and j==4:
    pass

हो जाता है:

if i==4and j==4:
    pass

जटिल एक लाइन स्टेटमेंट में इसका उपयोग करने से काफी कुछ अक्षर बच सकते हैं।

संपादित करें: जैसा कि @marcog ने बताया है, 4or aकाम करेगा, लेकिन ऐसा नहीं है a or4क्योंकि यह एक चर नाम के साथ भ्रमित हो जाता है।

Comments

if(i,j)==(4,4):और भी छोटा है और इस विशेष मामले मेंif i==j==4:

— gnibbler

संबंधित: 4or aकाम करता है, लेकिन नहींa or4

— marcog

0orयह भी काम नहीं करता है ( 0oअष्टक संख्याओं के लिए एक उपसर्ग है)।

— नबंवर

@ नबब यह नहीं है कि यह वैसे भी मायने रखता है, क्योंकि 0 or xहमेशा वापसी होने वाली है x। साथ ही बाहर कट सकता है 0 or।

— atı 12uʎs

0orहालांकि एक लंबी संख्या के हिस्से के रूप में ठीक है। 10 or xके बराबर है 10or x।

— trichoplax

Answer 12

पूर्णांक के लिए n, आप लिख सकते हैं

• n+1 जैसा -~n
• n-1 जैसा ~-n

क्योंकि बिट फ्लिप ~xबराबर होता है -1-x। यह समान संख्या में वर्णों का उपयोग करता है, लेकिन अप्रत्यक्ष रूप से ऑपरेटर पूर्वता के लिए रिक्त स्थान या परेंस काट सकता है।

की तुलना करें:

while n-1:  #Same as while n!=1 
while~-n:

c/(n-1)
c/~-n

or f(n)+1
or-~f(n) 

(n-1)/10+(n-1)%10
~-n/10+~-n%10

ऑपरेटरों ~और एकल -से अधिक पूर्वता हैं *, /, %, द्विआधारी के विपरीत +।

Comments

इस चाल पर एक बदलाव मैं आज में भाग गया: -~-xएक बाइट बनाम बचाता है (1-x)।

— लिन

एक और उपयोगी अनुप्रयोग यह है कि a+b+1इसे और अधिक संक्षिप्त रूप में लिखा जा सकता है a-~b।

— स्ट्राइगोइड्स

और n-i-1बस है n+~i।

— रूहोला

Answer 13

पायथन 3 पर सूची में चलने के लिए एक अच्छा तरीका बदलने के लिए :

कल्पना कीजिए कि आपके पास कुछ चलने योग्य हैं, जैसे

i = (1,2,3,4)
i = range(4)
i = (x**2 for x in range(5))

लेकिन आपको एक सूची चाहिए:

x=list(i)  #the default way
*x,=i      #using starred assignment -> 4 char fewer

यह एक स्ट्रिंग से बाहर की सूची बनाने के लिए बहुत उपयोगी है

s=['a','b','c','d','e']
s=list('abcde')
*s,='abcde'

Comments

टाइपिंग *s,='abcde'और फिर sएक segfault के साथ मेरी इंटरैक्टिव python3 दुर्घटनाओं :(

— daniero

@daniero वाह। केवल इंटरैक्टिव कंसोल पर? बहुत अजीब लगता है। इसे एक साफ कंसोल पर आज़माएं या बग की रिपोर्ट करें

— JBernardo

मेरा पायथन 3.5 ठीक काम करता है।

— NoOneIsHere

i = के लिए (x ** 2 के लिए x श्रेणी में (5)) मुझे यह कोड लौटाया गया है <जनरेटर वस्तु <genxpr> पर 0x03321690>

— जॉर्ज

और यदि आप एक अभिव्यक्ति में ऐसा कर रहे हैं, तो आप कर सकते हैं [*'abcde']।

— फल जूं

Answer 14

इसके बजाय range(x), आप *किसी भी चीज़ की सूची में ऑपरेटर का उपयोग कर सकते हैं , अगर आपको वास्तव में मूल्य का उपयोग करने की आवश्यकता नहीं है i:

for i in[1]*8:pass

विरोध के रूप में

for i in range(8):pass

यदि आपको इसे दो बार से अधिक करने की आवश्यकता है, तो आप किसी चर के लिए किसी भी चलने योग्य को असाइन कर सकते हैं, और उस चर को उस सीमा से गुणा कर सकते हैं जो आप हैं:

r=1,
for i in r*8:pass
for i in r*1000:pass

नोट : यह अक्सर की तुलना में अधिक लंबा होता है exec"pass;"*8, इसलिए इस ट्रिक का उपयोग केवल तभी किया जाना चाहिए जब कोई विकल्प न हो।

Comments

@proudhaskeller मुझे लगता है कि आपके द्वारा हटाए गए लाइन का बिंदु यह था कि "स्पष्ट चरित्र बचत के [1]*8अलावा range(8), क्योंकि आप इससे छोटे हैं , इसलिए आपको एक स्थान बचाने के लिए भी मिलता है क्योंकि for i in[...कानूनी for i in range...नहीं है"।

— अंडरग्राउंडोरेल

ओह, ठीक है, मुझे समझ नहीं आया। अभी तय किया गया

— गर्वित हैस्केलर

exec"pass;"*8काफी छोटा है।

— DJMcMayhem

यदि r=1, r*88 है, और आप एक संख्या के माध्यम से पुनरावृति नहीं कर सकते। मुझे लगता है कि आप का मतलब हैr=[1]

— आर्टेमिस फॉवेल

@ArtemisFowl, नहीं, यह ठीक नहीं है, 1 के बाद अल्पविराम एक ट्यूपल बनाता है जो कि चलने योग्य है।

— साशा

Answer 15

आप अच्छे पुराने एलियन स्माइली फेस को रिवर्स सिक्वेंस के लिए इस्तेमाल कर सकते हैं:

[1, 2, 3, 4][::-1] # => [4, 3, 2, 1]

Answer 16

विस्तारित चलने योग्य अनपैकिंग ("तारांकित असाइनमेंट", पायथन 3 केवल)

इसे समझाने का सबसे अच्छा तरीका एक उदाहरण है:

>>> a,*b,c=range(5)
>>> a
0
>>> b
[1, 2, 3]
>>> c
4

हमने पहले ही इसके लिए एक उपयोग देखा है - पायथन 3 की सूची में एक पुनरावृत्ति को मोड़ते हुए :

a=list(range(10))
*a,=range(10)

यहाँ कुछ और उपयोग दिए गए हैं।

किसी सूची से अंतिम तत्व प्राप्त करना

a=L[-1]
*_,a=L

कुछ स्थितियों में, इसका उपयोग पहले तत्व को बचाने के लिए किया जा सकता है:

a=(L+[1])[0]
a,*_=L+[1]

एक खाली सूची और अन्य चर असाइन करना

a=1;b=2;c=[]
a,b,*c=1,2

गैर-रिक्त सूची का पहला या अंतिम तत्व निकालना

_,*L=L
*L,_=L

इन विकल्पों की तुलना में कम कर रहे हैं L=L[1:]और L.pop()। परिणाम को एक अलग सूची में भी सहेजा जा सकता है।

युक्तियाँ @grc के सौजन्य से

Comments

वाह! मैंने a=1;L=[]कई बार लिखा है। यह आश्चर्यजनक है कि आप किसी चीज़ पर चार्ट को इस तरह सीधा कर सकते हैं।

— xnor

@xnor है कि किसी को धन्यवाद करने के लिए grc। केवल एक अन्य तत्व के साथ यह उतना अच्छा नहीं है ( a,*L=1,), लेकिन यह अभी भी एक चार बचाता है :)

— Sp3000

मत भूलो कि तुम भी एक सूची के पहले और अंतिम दोनों तत्व प्राप्त कर सकते हैंa,*_,b=L

— साइओस

Answer 17

पायथन 2.7 में शाब्दिक सेट करें

आप इस तरह से सेट लिख सकते S={1,2,3}हैं इसका मतलब यह भी है कि आप सदस्यता का उपयोग कर सकते हैं जिसके {e}&Sबजाय e in Sएक चरित्र बचाता है।

Comments

और यह चरित्र को भी बचाता है ifक्योंकि कोई स्थान नहीं है ( if{e}&S:)

— आर्टीयर

ध्यान दें कि आप की जगह ले सकता not inसे {e}-Sहै कि चाल के साथ

— काले उल्लू काई

Answer 18

उम्र के लिए यह मुझे परेशान करता है कि मैं पूरी वर्णमाला प्राप्त करने के लिए एक छोटे तरीके के बारे में नहीं सोच सकता था। यदि आप rangeपर्याप्त उपयोग करते हैं जो R=rangeआपके कार्यक्रम में होने लायक है, तो

[chr(i+97)for i in R(26)]

भोले से छोटा है

'abcdefghijklmnopqrstuvwxyz'

, लेकिन अन्यथा यह एक एकल चरित्र द्वारा लंबा है। इसने मुझे बहुत परेशान किया कि जिस चतुरता के लिए कुछ ज्ञान की आवश्यकता होती है, वह सभी अक्षरों को लिखने की तुलना में अधिक क्रियात्मक होता है।

जब तक मैंने अपनी बेटी की वर्णमाला के लिए यह जवाब नहीं देखा । अगर यह प्रतिभा ओपी का काम है या यदि यह एक टिप्पणीकार द्वारा एक सुझाव था, तो यह पता लगाने के लिए मैं संपादित इतिहास का अच्छी तरह से पालन नहीं कर सकता, लेकिन यह है (मेरा मानना ​​है) 26 अक्षरों का चलने योग्य बनाने का सबसे छोटा तरीका रोमन वर्णमाला में।

map(chr,range(97,123))

यदि मामला मायने नहीं रखता है, तो आप अपरकेस का उपयोग करके किसी अन्य वर्ण को अलग कर सकते हैं:

map(chr,range(65,91))

मैं mapबहुत अधिक उपयोग करता हूं , मुझे नहीं पता कि यह मेरे साथ कैसे हुआ।

Comments

वास्तविक कोडिंग में इसका उपयोग कर सकते हैं, इन चीजों को हार्डकोड करते समय मैं बहुत बेवकूफ महसूस करता हूं: ')

— टूनऑल्फ्रिंक

वास्तविक कोडिंग में, उपयोग करें string.lowercase- यही वह है जिसके लिए यह है।

— केविन एस

अगर आपको दोनों मामलों की जरूरत है, तो सबसे छोटा तरीका मुझे पता है फ़िल्टर (str.isalpha, map (chr, range (256)))। यह s = map (chr, range (256)) के मुकाबले मुश्किल से कम है, s + = map (str.lower, s)

— quintopia

@ क्विंटोपिया: 122 की जगह 256 ( ord('z')) क्यों? इसके अलावा यह समान लंबाई का है ... इसके अलावा, यदि आपको अल्फ़ान्यूमेरिक्स की आवश्यकता है, तो str.isalpha@ क्विंटोपिया के संस्करण के साथ बदलें str.isalnum। (लेकिन अगर आपको केवल एक मामले की आवश्यकता है, तो पूरे 36-वर्ण स्ट्रिंग से अधिक नहीं है filter(str.isalnum,map(chr,range(90)))।)

— टिम पेडरिक

यदि आप अनुचित हैं और रेंज का उपयोग करते हैं R, तो मेरा संस्करण आपके मूल से छोटा है: '%c'*26%tuple(R(97,123))(केवल 24 वर्ण) यदि आप rangeइसे वर्तनी करते हैं तो यह वर्णमाला के समान है - अपरकेस संस्करण छोटा है

— Jernernardo

Answer 19

हालांकि अजगर के पास स्विच स्टेटमेंट नहीं हैं, आप उन्हें शब्दकोशों के साथ अनुकरण कर सकते हैं। उदाहरण के लिए, यदि आप इस तरह से एक स्विच चाहते हैं:

switch (a):
    case 1:
        runThisCode()
        break
    case 2:
        runThisOtherCode()
        break
    case 3:
        runThisOtherOtherCode()
        break

आप ifकथन का उपयोग कर सकते हैं , या आप इसका उपयोग कर सकते हैं:

exec{1:"runThisCode()",2:"runThisOtherCode()",3:"runThisOtherOtherCode()"}[a]

या यह:

{1:runThisCode,2:runThisOtherCode,3:runThisOtherOtherCode}[a]()

यदि सभी कोड पथ समान मापदंडों के साथ कार्य करते हैं तो बेहतर है।

डिफ़ॉल्ट मान का समर्थन करने के लिए यह करें:

exec{1:"runThisCode()"}.get(a,"defaultCode()")

(या यह:)

­­{1:runThisCode}.get(a,defaultCode)()

इसका एक अन्य लाभ यह है कि यदि आपके पास अतिरेक है, तो आप शब्दकोश के अंत के बाद उन्हें जोड़ सकते हैं:

exec{'key1':'code','key2':'code'}[key]+';codeThatWillAlwaysExecute'

और यदि आप किसी मान को वापस करने के लिए स्विच का उपयोग करना चाहते हैं:

def getValue(key):
    if key=='blah':return 1
    if key=='foo':return 2
    if key=='bar':return 3
    return 4

आप ऐसा कर सकते हैं:

getValue=lambda key:{'blah':1,'foo':2,'bar',3}.get(key,4)

Comments

यह एक ऐसी चीज है जिसका मैं गहराई से जंगली में उपयोग करने पर विचार करूंगा। मुझे अपने स्विच स्टेटमेंट की याद आती है! +1

— हालोसगॉस्ट 12

हालाँकि पहले उदाहरण में गिने हुए कुंजियों के साथ एक शब्दकोश का उपयोग करने के बजाय, आपको बस एक सूची का उपयोग करना चाहिए

— Cyoce

यदि आपके पास चाबी के रूप में तार हैं, तो 2 * n-4 बाइट्स के dict(s1=v1,s2=v2,...,sn=vn)बजाय का उपयोग करके {'s1':v1,'s2':v2,...,'sn':vn}और n> = 3

— ब्लैक उल्लू काई

Answer 20

जब आपके पास दो बूलियन मान होते हैं, aऔर b, यदि आप यह पता लगाना चाहते हैं कि क्या दोनों सही हैं aऔर इसके बजाय b, का उपयोग करें :*and

if a and b: #7 chars

बनाम

if a*b: #3 chars

यदि कोई मान गलत है, तो यह 0उस कथन के रूप में मूल्यांकन करेगा , और एक पूर्णांक मान केवल सत्य है यदि यह गैर-शून्य है।

Comments

या फिर आप इस्तेमाल कर सकते हैं &: a=b=False,a&b

— ɐɔıʇǝɥʇuʎs

का उपयोग +करने के लिए orयदि आप गारंटी ले सकते हैंa != -b

— undergroundmonorail

|सभी स्थितियों में काम करता है।

— कैलक्यूलेटरफल

*के बजाय and/ &&कई भाषाओं में कुछ बाइट्स बचाता है।

— अपरान्ह

Answer 21

पायथन 2 स्ट्रिंग का प्रतिनिधित्व करें

पायथन 2 आपको केवल 2 वर्णों की लागत पर एक वस्तु xको इसके स्ट्रिंग प्रतिनिधित्व `x`में बदलने की सुविधा देता है । इसका उपयोग उन कार्यों के लिए करें, जो ऑब्जेक्ट की तुलना में ऑब्जेक्ट की स्ट्रिंग पर आसान होते हैं।

पात्रों से जुड़ें

वर्णों की एक सूची को देखते हुए l=['a','b','c'], एक का उत्पादन कर सकते ''.join(l)के रूप में `l`[2::5]जो एक बाइट बचाता है,।

कारण यह है कि है `l`है "['a', 'b', 'c']", (रिक्तियों के साथ) तो एक एक सूची टुकड़ा के साथ पत्र निकाल सकते हैं, शुरू करने कि दूसरी शून्य अनुक्रमित चरित्र aऔर वहां से हर पांचवें चरित्र लेने। यह मल्टी-कैरेक्टर स्ट्रिंग्स में शामिल होने या ऐसे वर्णों से बचने के लिए काम नहीं करता है, जिनका प्रतिनिधित्व किया गया है '\n'।

समवर्ती अंक

इसी तरह, अंकों के एक गैर खाली सूची की तरह दिया l=[0,3,5], उन्हें एक तार में जोड़ सकते हैं '035'के रूप में `l`[1::3]।

यह कुछ ऐसा करने से बचाता है map(str,l)। ध्यान दें कि वे एकल अंक होने चाहिए, और इसमें 1.0मिश्रित की तरह फ्लोट नहीं हो सकते हैं । इसके अलावा, यह खाली सूची में विफल रहता है, उत्पादन करता है ]।

नकारात्मक के लिए जाँच करें

अब, एक गैर-स्ट्रिंग कार्य के लिए। मान लीजिए कि आपके पास lवास्तविक संख्याओं की एक सूची है और परीक्षण करना चाहते हैं कि क्या इसमें कोई नकारात्मक संख्या है, जो बूलियन का निर्माण कर रही है।

तुम कर सकते हो

'-'in`l`

जो स्ट्रिंग प्रतिनिधि में एक नकारात्मक संकेत के लिए जाँच करता है। दोनों में से यह छोटा है

any(x<0for x in l)
min(l+[0])<0   

दूसरे के लिए, min(l)<0खाली सूची में विफल हो जाएगा, इसलिए आपको हेज करना होगा।

Comments

पाइथन 3 में भी एक अंक वाले स्ट्रिंग स्लाटरिंग को प्रभावी बनाना, कम से कम इतना है: str(l)[2::5]12 बाइट्स, बनाम 19 के लिए ''.join(map(str,l))। एक वास्तविक स्थिति जहां यह आया था (जहां lएक जनरेटर स्टेटमेंट था, सूची नहीं) मुझे सिर्फ एक बाइट बचा लिया ... जो अभी भी इसके लायक है!

— टिम पैडरिक

Answer 22

एक पंक्ति समारोह लंबोदर के साथ किया जा सकता है:

def c(a):
  if a < 3: return a+10
  else: return a-5

(नोट लापता अंतरिक्ष में बदला जा सकता 3andहै और 10or)

c=lambda a:a<3and a+10or a-5

Comments

या c=lambda a:a+[-5,10][a<3]। और / या चाल अधिक उपयोगी है जब आप

— शॉर्टक्रिटक

आपके फ़ंक्शन में, फ़ंक्शन को निष्पादित करना बंद else: कर दिया जा सकता है return, इसलिए जो कुछ भी है वह केवल तभी निष्पादित किया जाता है यदि ifस्थिति विफल हो, उर्फ ​​यदि elseस्थिति सही है। इस प्रकार elseसुरक्षित रूप से गर्भाशय हो सकता है। (वहाँ बाहर neophytes के लिए विवरण में समझाया)

— जेरोमेज

c (-10) रिटर्न -15 जबकि यह 0 पर वापस आना चाहिए

— एनविट

याc=lambda a:a-5+15*(a<3)

— JayXon

Answer 23

4 आइटम तक छोरों का उपयोग सीमा के बजाय एक टपल आपूर्ति करने के लिए बेहतर हो सकता है

for x in 0,1,2:

बनाम

for x in range(3):

Answer 24

छत और फर्श

यदि आप कभी भी विभाजन के लिए गोल-गोल परिणाम प्राप्त करना चाहते हैं, तो जैसे आप //फर्श के लिए करते हैं, आप math.ceil(3/2)15 या -(-3//2)8 बाइट्स के लिए बहुत कम उपयोग कर सकते हैं ।

math.floor(n)   : 13 bytes+12 for import
n//1            : 4  bytes

math.ceil(n)    : 12 bytes+12 for import
-(-n//1)        : 8  bytes

Comments

इसने मुझे 20 बाइट्स के करीब बचाया, धन्यवाद!

— मॉर्गन थ्रैप

कभी-कभी आप n//1+1छत के बजाय दूर जा सकते हैं लेकिन इसका मतलब छत (n) = n + 1 है लेकिन यह सभी गैर पूर्णांक मानों के लिए काम करना चाहिए

— fejfo

round(x)है (x+.5)//1, +1 बाइट, लेकिन बाद वाला ए से शुरू होता है (, और यदि xकोई सम्‍मिलित राशि है , तो यह उपयोगी हो सकता है।

— user202729

Answer 25

का प्रयोग करें +=के बजाय appendऔरextend

A.append(B)  

इसे छोटा किया जा सकता है:

A+=B,

B,यहां एक-एक तत्व टपल का निर्माण किया जाता है जिसका उपयोग Aउसी तरह करने के लिए किया जा सकता [B]है A+=[B]।

---

A.extend(B)

इसे छोटा किया जा सकता है:

A+=B

Comments

कई में (लेकिन सभी नहीं) के मामलों, return 0या return 1के बराबर है return Falseया return True।

— अंडरग्राउंडोरेल

(1) केवल तभी काम करता है जब आप पहले से ही जानते हैं कि संख्या ऋणात्मक है, इस स्थिति में आप केवल एक ऋण चिह्न का उपयोग करके आगे के 2 वर्णों को बचा सकते हैं। -xके बजाय x*-1। --8.32के बजाय -8.32*-1। या बस 8.32...

— ट्राइकोप्लेक्स

ओपी का हवाला देते हुए: कृपया प्रति उत्तर एक टिप पोस्ट करें।

— nyuszika7h

ध्यान दें कि A+=B Bएक में है tuple।

— आउटगोल्फ

Answer 26

एक शर्त के आधार पर दो में से एक संख्या चुनना

आप पहले से ही टर्नरी अभिव्यक्ति के लिए [x,y][b]बूलियन के साथ सूची चयन का उपयोग करना जानते हैं । चर , और भी अभिव्यक्ति हो सकते हैं, हालांकि ध्यान दें कि दोनों औरby if b else xxybxy चयन किया जाता है चयनित नहीं होने पर भी मूल्यांकन किया जाता है।

यहाँ कुछ संभावित अनुकूलन जब xऔर yनंबर दिए गए हैं।

• [0,y][b] -> y*b
• [1,y][b] -> y**b
• [x,1][b] -> b or x
• [x,x+1][b] -> x+b
• [x,x-1][b] -> x-b
• [1,-1][b] -> 1|-b
• [x,~x][b] -> x^-b
• [x,y][b] -> x+z*b(या y-z*b), जहां z = yx।

आप स्विच भी कर सकते हैं xऔर yयदि आप bइसके स्थान पर इसके नकारात्मक होने को फिर से लिख सकते हैं ।

Answer 27

किसी सूची के पीछे से ~ अनुक्रमणिका का उपयोग करें

यदि Lएक सूची है, तो पीछे से 'तत्व' L[~i]प्राप्त करने के लिए उपयोग करें i।

यह is का iउल्टा तत्व ’है L। बिट पूरक ~iबराबर होता है -i-1, और इसलिए ऑफ-बाय-वन त्रुटि को ठीक करता है L[-i]।

Answer 28

PEP448 - अतिरिक्त अनपैकिंग सामान्यीकरण

पायथन 3.5 के जारी होने के साथ , सूचियों, टुपल्स, सेटों और डाइक का हेरफेर सिर्फ गोल्फर को मिला।

एक सेट / सूची में चलने योग्य मोड़

जोड़े की तुलना करें:

set(T)
{*T}

list(T)
[*T]

tuple(T)
(*T,)

बहुत कम! हालाँकि, ध्यान दें कि यदि आप किसी चीज़ को किसी सूची में बदलना चाहते हैं और उसे एक चर में नियत करते हैं , तो सामान्य रूप से विस्तारित चलने योग्य अनपैक छोटा होता है:

L=[*T]
*L,=T

ट्यूपल्स के लिए एक समान वाक्य रचना काम करती है:

T=*L,

जो विस्तारित पुनरावृत्ति की तरह है, लेकिन दूसरी तरफ तारांकन और अल्पविराम के साथ।

सूचियों / tuples में शामिल होना

यदि आप दोनों पक्षों को एक सूची / टपल संलग्न करने की आवश्यकता है, तो अनपैकिंग संघनन से थोड़ा छोटा है:

[1]+T+[2]
[1,*T,2]

(1,)+T+(2,)
(1,*T,2)

एकाधिक सूचियों की सामग्री को प्रिंट करना

यह सीमित नहीं है print, लेकिन यह निश्चित रूप से है कि अधिकांश लाभ कहां से आएगा। PEP448 अब कई अनपैकिंग की अनुमति देता है, जैसे:

>>> T = (1, 2, 3)
>>> L = [4, 5, 6]
>>> print(*T,*L)
1 2 3 4 5 6

कई शब्दकोश आइटम अपडेट कर रहे हैं

यह शायद बहुत बार नहीं होगा, लेकिन अगर आप कम से कम तीन वस्तुओं को अपडेट कर रहे हैं, तो शब्दकोशों को अपडेट करने के लिए सिंटैक्स का उपयोग किया जा सकता है:

d[0]=1;d[1]=3;d[2]=5
d={**d,0:1,1:3,2:5}

यह मूल रूप से किसी भी आवश्यकता के लिए उपेक्षा करता है dict.update।

Comments

यह पर्ल से भी बदतर लग रहा है, लेकिन यह काम करता है ...

— मेगा मैन

Answer 29

बदले import *के लिएimport*

---

यदि आपने नहीं सुना है, तो import*चार्ट बचाता है!

from math import*

की तुलना में केवल 1 वर्ण लंबा है import math as mऔर आपको सभी उदाहरणों को निकालना हैm.

यहां तक ​​कि एक समय का उपयोग एक बचतकर्ता है!

Answer 30

>>> for i in range(x):s+=input()

अगर मैं का मूल्य बेकार है:

>>> for i in[0]*x:s+=input()

या

>>> exec's+=input();'*x

Comments

for i in[0]*x:s+=input()दूसरे स्थान को बचाने के लिए आप दूसरा उदाहरण बना सकते हैं । इसके अलावा, आप प्राप्त करने के लिए निष्पादन और पहले उद्धरण चिह्न के बीच के स्थान को हटा सकते हैंexec's+=input();'*x

— जस्टिन पील

दूसरी पंक्ति नहीं होनी चाहिए:for i in[0]*x:s+=input()

— micsthepick

डूपे (नया लेकिन अधिक

— अपवित्र