පයිතන් හි ගොල්ෆ් ක්‍රීඩා කිරීම සඳහා ඔබට ඇති පොදු උපදෙස් මොනවාද? මම සොයන්නේ කේත-ගොල්ෆ් ගැටලුවලට අදාළ කළ හැකි සහ අවම වශයෙන් පයිතන්ට විශේෂිත වූ අදහස් (උදා: "අදහස් ඉවත් කිරීම" පිළිතුරක් නොවේ).

කරුණාකර පිළිතුරකට එක් ඉඟියක් පළ කරන්න.

a=b=c=0වෙනුවට භාවිතා කරන්න a,b,c=0,0,0.

a,b,c='123'වෙනුවට භාවිතා කරන්න a,b,c='1','2','3'.

කොන්දේසි දිගු විය හැකිය. සමහර අවස්ථාවලදී ඔබට සරල කොන්දේසියක් ආදේශ කළ හැකිය (a,b)[condition]. conditionසත්‍ය නම් , bආපසු ලබා දෙනු ලැබේ.

සසඳන්න

if a<b:return a
else:return b

මේ සඳහා

return(b,a)[a<b]

මම වරක් කළ විශාල දෙයක් නම්:

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

ඔබ නැවත නැවත සාදන ලද ශ්‍රිතයක් භාවිතා කරන්නේ නම්, විවිධ තර්ක භාවිතා කරන්නේ නම් එයට නව නමක් ලබා දීම සඳහා එය වඩා අභ්‍යවකාශ කාර්යක්ෂම විය හැකිය:

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

සමහර විට ඔබේ පයිතන් කේතයට ඔබට මට්ටම් 2 ක් අවශ්‍ය වේ. කළ යුතු පැහැදිලි දෙය නම් එක් එක් ඉන්ඩෙන්ටේෂන් මට්ටම සඳහා අවකාශයන් එකක් සහ දෙකක් භාවිතා කිරීමයි.

කෙසේ වෙතත්, පයිතන් 2 ටැබ් සහ අභ්‍යවකාශ අක්ෂර විවිධ ඉන්ඩෙන්ටින් මට්ටම් ලෙස සලකයි.

මෙයින් අදහස් කරන්නේ පළමු ඉන්ඩෙන්ටේෂන් මට්ටම එක් ඉඩක් විය හැකි අතර දෙවැන්න එක් ටැබ් අක්ෂරයක් විය හැකිය.

උදාහරණයක් වශයෙන්:

if 1:
 if 1:
\tpass

\tටැබ් අක්ෂරය කොහිද?

නූල් ආදේශනය භාවිතා කරන්න සහ ඔබේ කේතයේ බොහෝ විට පුනරාවර්තනය වන 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 : මෙම විකල්ප තුනක් සඳහා, බව අපට පෙනෙනවා

• සඳහා 5 n < lambdas, ඔබ වඩා හොඳ ලකුණු සියල්ල කිසිවක් විසිතුරු කරන්නේ නෑ.
• සඳහා n = 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:ඔබේ කේතයේ 3 වතාවක් නූල් (දිග 11) සිදුවුවහොත් , ඔබ ලිවීමට වඩා හොඳය exec"..."%(('lambda x,y:',)*3).

බොහෝ අයගෙන් එක් නූලක් තෝරා ගැනීමට දීර් s පෙති භාවිතා කරන්න

>>> 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ප්‍රකාශනයක් නම් ක්‍රියාකරුගේ ප්‍රමුඛතා ගැටළු තිබිය හැකිය .

බැලීමේ වගු මැජික් අංක ලෙස ගබඩා කරන්න

පළමු ඉංග්‍රීසි අංක දොළහෙන් එකක් අඩංගු වන බූලියන් බැලීමේ වගුවක් දෘඩ කේත කිරීමට ඔබට අවශ්‍ය යැයි පවසන්න 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

එහි ප්‍රති ing ලයක් ලෙස 0හෝ 1සමාන Falseවීම True.

අදහස නම්, මැජික් අංකය වගුව bitstring bin(3714)= ලෙස ගබඩා කර 0b111010000010ඇති අතර, n-වන ඉලක්කම් (අවසානයේ සිට) අනුරූපව nth වන වගුවට ඇතුළත් වේ. nඅංක nඅවකාශය දකුණට හරවා අවසන් ඉලක්කම් මගින් අපි තුන්වන පිවිසුමට පිවිසෙමු &1.

මෙම ගබඩා ක්‍රමය ඉතා කාර්යක්ෂම වේ. විකල්ප සමඟ සසඳන්න

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

ඔබේ විමසුම් වගු ගබඩාවේ බහුකාර්ය ඇතුළත් කිරීම් ලබා ගත හැකිය

 340954054>>4*n&15

අදාළ බිටු හතරේ කොටස ලබා ගැනීමට.

භාවිතා `n`කිරීම වෙනුවට පූර්ණ සංඛ්‍යාවක් නූලකට පරිවර්තනය කිරීමට භාවිතා කරන්න str(n):

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

සංඛ්‍යාත්මක ලූප දෙකක් එකකට කඩා දමන්න

ඔබ ජාලකයක සෛල හරහා ගමන් කරන බව පවසන්න 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ලූපය තුළ මිල අධික ඇමතුමක් සහ ඉන්ඩෙන්ටේෂන් මට්ටමක් ඉතිරි කර ඇත. පුනරාවර්තනයේ අනුපිළිවෙල වෙනස් නොවේ.

භාවිතය //වෙනුවට /Python 3. ඔබ වෙත යොමු නම් iසහ jබොහෝ අවස්ථාවල, තම තමන්ගේ වටිනාකම් අනුයුක්ත කිරීමට වේගවත් විය හැක i=k/n, j=k%nකම්බියක් ඇතුළත.

නිඛිල සඳහා 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

මෙම ක්රියාකරුවන් ~හා ඒකජ -වඩා ඉහළ තැනක්ද වේ *, /, %, මෙන් නොව ද්විමය +.

පහත දැක්වෙන ටෝකනය ආරම්භ වන්නේ eනැතිනම් හෝ E. අංකයක් අනුගමනය කිරීමෙන් ඔබට අවකාශය ඉවත් කළ හැකිය.

උදාහරණයක් වශයෙන්:

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

බවට පත්වේ:

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

මෙය සංකීර්ණ එක් පේළි ප්‍රකාශයකින් භාවිතා කිරීමෙන් අක්ෂර කිහිපයක් ඉතිරි කර ගත හැකිය.

සංස්කරණය කරන්න: @marcog පෙන්වා දුන් පරිදි, ක්‍රියා 4or aකරනු ඇත, නමුත් a or4මෙය විචල්‍ය නාමයක් සමඟ පටලවා ගන්නා පරිදි නොවේ .

පයිතන් 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'

අනුපිළිවෙල ආපසු හැරවීමට ඔබට හොඳ පැරණි පිටසක්වල සිනහමුසු මුහුණ භාවිතා කළ හැකිය:

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

ඒ වෙනුවට 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, එබැවින් මෙම උපක්‍රමය භාවිතා කළ යුත්තේ එය විකල්පයක් නොවන විට පමණි.

විස්තාරණය කළ හැකි නැවත ඉවත් කිරීම ("තරු ලකුණු කිරීම", පයිතන් 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(). ප්‍රති result ලය වෙනත් ලැයිස්තුවකට සුරැකිය හැක.

ඉඟි අනුග්‍රහය @grc

පයිතන් 2.7 හි වචනාර්ථයන් සකසන්න

ඔබට මෙවැනි කට්ටල ලිවිය හැකිය. S={1,2,3}මෙයින් අදහස් කරන්නේ එක් අක්‍ෂරයක් ඉතිරි කරන {e}&Sවෙනුවට සාමාජිකත්වය පරික්ෂා කළ හැකි e in Sබවයි.

මුළු හෝඩියම ලබා ගැනීමට කෙටි ක්‍රමයක් ගැන සිතීමට මට නොහැකි වීම අවුරුදු ගණනාවක් තිස්සේ මට කරදරයක් විය. ඔබේ වැඩසටහන තුළ තිබිය යුතු rangeතරම් ප්‍රමාණයක් ඔබ භාවිතා කරන්නේ R=rangeනම්, එසේ නම්

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

බොළඳට වඩා කෙටි ය

'abcdefghijklmnopqrstuvwxyz'

, නමුත් වෙනත් ආකාරයකින් එය තනි අක්ෂරයකින් දිගු වේ. ඇස්කි සාරධර්ම පිළිබඳ යම් දැනුමක් අවශ්‍ය වූ බුද්ධිමත් තැනැත්තා සියලු අක්ෂර ටයිප් කරනවාට වඩා වාචික බව මට හොල්මන් කළේය.

මගේ දියණියගේ හෝඩිය සඳහා මෙම පිළිතුර දකින තුරු . මෙම බුද්ධිය OP හි කාර්යයක් ද නැතිනම් එය විචාරකයෙකුගේ යෝජනාවක් ද යන්න සොයා ගැනීමට තරම් සංස්කරණ ඉතිහාසය මට අනුගමනය කළ නොහැක, නමුත් මෙය (මම විශ්වාස කරමි) අකුරු 26 න් නැවත සැකසිය හැකි කෙටිම ක්‍රමය මෙයයි. රෝම හෝඩියෙහි.

map(chr,range(97,123))

නඩුව වැදගත් නොවේ නම්, ඔබට ලොකු අකුරක් භාවිතා කර වෙනත් අක්ෂරයක් ඉවත් කළ හැකිය:

map(chr,range(65,91))

මම mapඕනෑවට වඩා මාර්ගය භාවිතා කරමි , මෙය මට කිසිදා සිදු නොවූයේ කෙසේදැයි මම නොදනිමි.

පයිතන්ට ස්විච් ප්‍රකාශ නොමැති වුවද, ඔබට ඒවා ශබ්ද කෝෂවලින් අනුකරණය කළ හැකිය. උදාහරණයක් ලෙස, ඔබට මේ වගේ ස්විචයක් අවශ්‍ය නම්:

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)

වීජ වටිනාකම් දෙකක් ඇති විට aසහ b, ඔබ මේ දෙකම නම් සොයා ගැනීමට අවශ්ය නම්, aහා bසැබෑ වන අතර, භාවිතය *වෙනුවට and:

if a and b: #7 chars

එදිරිව

if a*b: #3 chars

එක්කෝ අගය අසත්‍ය නම්, එය 0එම ප්‍රකාශයේ දී මෙන් ඇගයීමට ලක් කරනු ඇති අතර පූර්ණ සංඛ්‍යාවක් සත්‍ය වන්නේ එය අස්ථිර නම් පමණි.

ලැයිස්තුවක පිටුපස සිට දර්ශකයට ~ භාවිතා කරන්න

නම් Lලැයිස්තුවක්, භාවිතා වේ L[~i]ද ලබා ගැනීමට iපිටුපස සිට 'වැනි අංගයක්.

මෙය iආපසු හැරවීමේ තුන්වන අංගයයි L. බිට් අනුපූරකය ~iසමාන වන අතර -i-1, ඉන් එක් එක් දෝෂය නිවැරදි කරයි L[-i].

ලැම්බඩා සමඟ එක් පේළියේ කාර්යයක් කළ හැකිය:

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

බවට පරිවර්තනය කළ හැකිය (සටහන නැතිවූ ඉඩ 3andසහ 10or)

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

පයිතන් 2 නූල් නිරූපණයන් සූරාකන්න

xඅක්ෂර `x`2 ක වියදමින් වස්තුවක් එහි නූල් නිරූපණයට පරිවර්තනය කිරීමට පයිතන් 2 ඔබට ඉඩ දෙයි . වස්තුවට වඩා වස්තුවේ නූලෙන් පහසුවෙන් කළ හැකි කාර්යයන් සඳහා මෙය භාවිතා කරන්න.

අක්ෂර හා සම්බන්ධ වන්න

අක්ෂර ලැයිස්තුවක් ලබා දී l=['a','b','c'], කෙනෙකුට නිපදවිය ''.join(l)හැකි `l`[2::5]අතර එය බයිට් එකක් ඉතිරි කරයි.

හේතුව බව ය `l`යනු "['a', 'b', 'c']"එක්, ලැයිස්තුවක් පෙත්තක් සමග ලිපි උපුටා හැකි දෙවන ශුන්ය-සුචිගත චරිතය බව ආරම්භ එසේ (හිස් අවකාශයක්), aඅතර, එහි සිට සෑම පස්වන චරිතය ගනිමින්. බහු-අක්ෂර නූල් හෝ සම්බන්ධ වන අක්ෂර වලින් සම්බන්ධ වීමට මෙය ක්‍රියා නොකරයි '\n'.

සංක්ෂිප්ත ඉලක්කම්

ඒ හා සමානව, සමාන අකුරු, හිස්-නොවන ලැයිස්තුව ලබා l=[0,3,5], එක් කෙනෙක් වත් string එකකට concatenate හැකි '035'ලෙස `l`[1::3].

මෙය වැනි දෙයක් කිරීමෙන් ඉතිරි map(str,l)වේ. ඒවා තනි ඉලක්කම් විය යුතු බවත්, 1.0මිශ්‍ර කළ පාවෙන ඒවා තිබිය නොහැකි බවත් සලකන්න . එසේම මෙය හිස් ලැයිස්තුවේ අසමත් වන අතර නිෂ්පාදනය ]කරයි.

නිෂේධනීය දේ සඳහා පරීක්ෂා කරන්න

දැන්, නූල් නොවන කාර්යයක් සඳහා. ඔබ සතුව lතාත්වික සංඛ්‍යා ලැයිස්තුවක් ඇති අතර එහි කිසියම් negative ණ සංඛ්‍යාවක් තිබේදැයි පරීක්ෂා කිරීමට අවශ්‍ය යැයි සිතමු .

ඔබට කළ හැකිය

'-'in`l`

එය නූල් රෙප් එකේ negative ණ ලකුණක් පරික්ෂා කරයි. මෙය දෙකටම වඩා කෙටි ය

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

දෙවැන්න සඳහා, min(l)<0හිස් ලැයිස්තුවේ අසමත් වනු ඇත, එබැවින් ඔබට ආරක්ෂිත විය යුතුය.

සිවිලිම සහ මහල

ඔබට කවදා හෝ බෙදීමක් සඳහා වටකුරු ප්‍රති result ලයක් ලබා ගැනීමට අවශ්‍ය නම් //, ඔබ බිම සඳහා කළ ආකාරයටම , ඔබට 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

අයිතම 4 ක් දක්වා වූ ලූප පරාසය භාවිතා කිරීම වෙනුවට ටුපල් එකක් සැපයීම වඩා හොඳ විය හැකිය

for x in 0,1,2:

එදිරිව

for x in range(3):

කොන්දේසියක් මත පදනම්ව අංක දෙකෙන් එකක් තෝරා ගැනීම

තෘතීය ප්‍රකාශනය සඳහා බූලියන් සමඟ ලැයිස්තු තේරීම භාවිතා කිරීමට ඔබ දැනටමත් දන්නවා . විචල්යයන් , සහ ද යන දෙකම බවයි සටහන් වුවද, ප්රකාශන විය හැකි සහ තෝරා ගෙන නොමැති විට පවා ඇගයීමට ලක් කර ඇත.[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ඒ වෙනුවට එහි නිශේධනය විය.

වෙනස් කරන්න import * කරන්නimport*

ඔබ අසා නොමැති නම්, import* අක්ෂර සුරකිනු ඇත!

from math import*

වඩා අක්ෂර 1 ක් පමණි import math as m අතර ඔබට සියලු අවස්ථා ඉවත් කිරීමට සිදුවේm.

එක් වරක් භාවිතා කිරීම පවා ඉතිරි කරන්නෙකි!

PEP448 - අතිරේක ඉවත් කිරීමේ සාමාන්‍යකරණයන්

මුදා හැරීමත් සමඟ පයිතන් 3.5 , ලැයිස්තු, ටුපල්, කට්ටල සහ අණපනත් හැසිරවීම ගොල්ෆ් ක්‍රීඩකයෙකු බවට පත්විය.

නැවත සැකසිය හැකි කට්ටලයක් / ලැයිස්තුවක් බවට පත් කිරීම

යුගල සසඳා බලන්න:

set(T)
{*T}

list(T)
[*T]

tuple(T)
(*T,)

වඩා කෙටි! කෙසේ වෙතත්, ඔබට යමක් ලැයිස්තුවකට පරිවර්තනය කර විචල්‍යයකට පැවරීමට අවශ්‍ය නම්, සාමාන්‍ය විස්තාරණය කළ හැකි ඉවත් කිරීම කෙටි වේ:

L=[*T]
*L,=T

ඒ හා සමාන සින්ටැක්ස් ටුපල් සඳහා ක්‍රියා කරයි:

T=*L,

එය දිගු කළ හැකි නැවත මුදා හැරීම වැනි ය, නමුත් අනෙක් පැත්තෙන් තරු හා කොමාව සමඟ.

ලැයිස්තු / ටුපල් සමඟ සම්බන්ධ වීම

දෙපැත්තටම ලැයිස්තුවක් / ටුපල් එකක් එකතු කිරීමට අවශ්‍ය නම්, ඇසුරුම් කිරීම සංයුක්තතාවයට වඩා මඳක් කෙටි ය:

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

සහ +=වෙනුවට භාවිතා කරන්නappendextend

A.append(B)  

කෙටි කළ හැක්කේ:

A+=B,

B,මෙහි දීර්ඝ කිරීමට භාවිතා කළ හැකි එක් අංගයක් tuple නිර්මාණය Aවගේ [B]තුළ A+=[B].

A.extend(B)

කෙටි කළ හැක්කේ:

A+=B

දිග වෙළඳාම පිළිබඳ සඳහන

දේවල් කිරීමේ පොදු විකල්ප ක්‍රම සඳහා චරිත ගණනය කිරීමේ වෙනස්කම් සඳහා යොමු කිරීමක් ප්‍රයෝජනවත් වනු ඇතැයි මම සිතමි, එවිට ඒවා භාවිතා කළ යුත්තේ කවදාදැයි මට දැනගත හැකිය. _ප්‍රකාශනයක් හෝ කේතයක් දැක්වීමට මම භාවිතා කරමි .

විචල්යයකට අනුයුක්ත කරන්න: +4

x=_;x
_

ඉතින්, ඔබ පවා මෙය කැඩී යයි

• _දෙවන වරට භාවිතා කරන්න :_ දිග 5 ඇත
• _තෙවන වර භාවිතා කරන්න : _දිග 3 ඇත

විචල්යයන් වෙන වෙනම පවරන්න: 0

x,y=a,b
x=a;y=b

• -2 සඳහා aසමාන වන විටbx=y=a

lambdaක්‍රියාකාරීත්වයට පුළුල් කරන්න def: +7

lambda x:_
def f(x):return _

• -2 නම් කරන ලද කාර්යයන් සඳහා
• -1 නම් _ වමට ස්පර්ශ කළ හැකි
• -1 හැකි නම් පයිතන් 2 හි printනැවත පැමිණීමට වඩා
• තරු ලකුණු කළ ආදානය සඳහා +1 *x

සාමාන්‍යයෙන්, ඔබ defප්‍රකාශනයක් දෙවරක් භාවිතා කරන විචල්‍යයකට සුරැකීමට නම්, ප්‍රකාශනය දිග 12 ක් වුවද මෙය කැඩී යයි.

lambda x:g(123456789012,123456789012)
def f(x):s=123456789012;return g(s,s)

ක්‍රියාකාරීත්වයට වඩා STDIN: +1

def f(x):_;print s
x=input();_;print s

• _තනි පේළියක් නොවන්නේ නම් අවශ්‍ය වන කේත රේඛාව සඳහා -1
• raw_inputපයිතන් 2 හි අවශ්‍ය නම් +4
• -4 යනු ආදාන විචල්‍යය භාවිතා කරනුයේ එක් වරක් පමණි
• පයිතන් 2 returnට වඩා ශ්‍රිතය අවශ්‍ය නම් +1 කරන්නprint

පෙරළීමට execවඩා භාවිතා කරන්න range(n): +0

for i in range(n):_
i=0;exec"_;i+=1;"*n

• පයිතන් 3 සඳහා +2 exec()
• -4 range(c,c+n)තනි වරහන සඳහා පරාසය මාරු කළහොත්c
• -5 සිට ආපස්සට යන විට nකිරීමට 1හරහාrange(n,0,-1)

mapපුඩුවක් තුළ අතින් යොදන්න : +0

for x in l:y=f(x);_
for y in map(f,l):_

mapලැයිස්තු අවබෝධය තුළ අතින් යොදන්න : +8

map(f,l)
[f(x)for x in l]

• -12 කවදාද ප්‍රකාශනය ලෙස fලිවිය යුතු අතර එමඟින් සමස්ත වර්‍ග 4 ක් අහිමි වේ.maplambdalambda x:f(x)

filterලැයිස්තු අවබෝධය තුළ අතින් යොදන්න : +11

filter(f,l)
[x for x in l if f(x)]

• -1 f(x)ප්‍රකාශනයට වම් පැත්තට ස්පර්ශ කළ හැකි නම්
• -12 කවදාද ප්‍රකාශනය ලෙස fලිවිය යුතු අතර එය සමස්ත වර්‍ග 1 ක් අහිමි වේ.filterlambdalambda x:f(x)

ආනයනය * එදිරිව ආනයන තනි භාවිතයට: +4

import _;_.f
from _ import*;f

• _5 දිග ඇති විට පවා කැඩී යයි
• import _ as x;x.f බහු ආනයන හැර සෑම විටම නරක ය
• __import__('_').f එය වඩාත් නරක ය

යෝජනා සහ නිවැරදි කිරීම් සඳහා @ Sp3000 ට ස්තූතියි.