Які загальні поради щодо гольфу в Python? Я шукаю ідеї, які можна застосувати до проблем із кодом-гольфу, які також принаймні дещо специфічні для Python (наприклад, "видалити коментарі" - це не відповідь).

Будь ласка, опублікуйте одну пораду на відповідь.

Використовуйте 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()

Оператори порівняння Python рок.

Використовуючи, що в Python 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

Іноді для вашого коду Python потрібно мати два рівні відступи. Очевидно, що потрібно використовувати один і два пробіли для кожного рівня відступу.

Однак Python 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 для цих трьох варіантів, ми бачимо, що:

• Для n <5 лямбдів вам краще взагалі нічого не робити.
• Для 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:(довжина 11) трапляється у вашому коді 3 рази, вам краще писати exec"..."%(('lambda x,y:',)*3).

Використовуйте розширені нарізки, щоб вибрати один рядок з багатьох

>>> 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`для перетворення цілого числа в рядок замість використання str(n):

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

Зберігайте таблиці пошуку як магічні числа

Скажімо, ви хочете жорстко кодувати булеву таблицю пошуку, наприклад, який із перших дванадцяти англійських номерів містить 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цифра (з кінця) відповідає запису nth-й таблиці. Ми nотримуємо доступ до цього запису, перемістивши бітовий nпробіл праворуч і взявши останню цифру на &1.

Цей спосіб зберігання дуже ефективний. Порівняйте з альтернативами

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

Ви можете мати багатобітові записи таблиці зберігання таблиці, які можна витягнути

 340954054>>4*n&15

витягти відповідний чотирибітний блок.

Згорніть дві числові петлі в одну

Скажіть, ви повторюєте клітинки 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всередині циклу.

Якщо наступний маркер починається з eабо E. Ви можете видалити пробіл після номера.

Наприклад:

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

Стає:

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

Використовуючи це у складних операторах одного рядка, можна зберегти досить багато символів.

EDIT: як зазначав @marcog, 4or aбуде працювати, але не так, a or4як це плутається з ім'ям змінної.

Для цілого числа 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

Оператори ~і Унарний -вище пріоритет , ніж *, /, %, в відміну від виконуваного файлу +.

Хороший спосіб перетворити ітерабельний список у список на Python 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'

Замість цього 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, тому цей трюк слід використовувати лише тоді, коли це не є можливим.

Ви можете використовувати старий добрий чужий смайлик для зворотної послідовності:

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

Розширене ітерабельне розпакування ("Призначення зірочкою", лише Python 3)

Найкращий спосіб пояснити це на прикладі:

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

Ми вже бачили користь для цього - перетворення ітерабельного списку в список на Python 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

встановити літерали в Python2.7

Ви можете писати такі набори, як це. S={1,2,3}Це також означає, що ви можете перевірити на членство, використовуючи {e}&Sзамість e in Sних збереження одного символу.

Протягом століть мене це непокоїло, що я не міг придумати короткий спосіб отримати весь алфавіт. Якщо ви використовуєте rangeдостатньо, що R=rangeварто мати у своїй програмі, то

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

коротший, ніж наївний

'abcdefghijklmnopqrstuvwxyz'

, але в іншому випадку це більше одного символу. Мене переслідувало, що розумний, який вимагав певних знань про значення ascii, виявився більш багатослівним, ніж просто набравши всі літери.

Поки я не побачив цю відповідь за алфавітом моєї дочки . Я не можу досить добре відслідковувати історію редагування, щоб зрозуміти, чи був цей геній роботою ОП чи це була пропозиція коментодавця, але це (я вважаю) найкоротший спосіб створити ітерабельний з 26 листів в римському алфавіті.

map(chr,range(97,123))

Якщо справа не має значення, ви можете зняти інший символ, використовуючи великі регістри:

map(chr,range(65,91))

Я mapзанадто багато використовую, не знаю, як це мені ніколи не приходило в голову.

Хоча у python не є операторів перемикання, ви можете імітувати їх словниками. Наприклад, якщо ви хотіли такий перемикач:

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у цьому висловлюванні, а ціле значення є істинним, лише якщо воно не є нульовим.

Використовуйте представлення рядків Python 2

Python 2 дозволяє перетворити об'єкт xу його рядкове представлення `x`вартістю лише 2 символи. Використовуйте це для завдань, які легше виконувати на рядку об'єкта, ніж сам об'єкт.

Приєднуйтесь до персонажів

Давши список символів 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в порожньому списку не вдасться, тому вам доведеться хеджувати.

Функцію однієї лінії можна виконати за допомогою лямбда:

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

можна перетворити на (зауважте, що немає місця 3andта 10or)

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

петлі до 4-х елементів можуть бути краще поставити кортеж, а не використовувати діапазон

for x in 0,1,2:

проти

for x in range(3):

Стеля і підлога

Якщо ви хочете отримати результат округлення для поділу, як і //для підлоги, ви можете використовувати 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

Використовуйте +=замість appendіextend

A.append(B)  

можна скоротити до:

A+=B,

B,тут створюється одноелементний кортеж, який можна використовувати для розширення так Aсамо, як [B]у A+=[B].

A.extend(B)

можна скоротити до:

A+=B

Вибір одного з двох чисел на основі умови

Ви вже знаєте використовувати вибір списку [x,y][b]з булевим bдля потрійного виразу y if b else x. Змінні x, yі bтакож можуть бути виразами, хоча зауважте, що обидва xі yоцінюються, навіть якщо вони не обрані.

Ось деякі потенційні оптимізації, коли 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замість цього переписати, це його заперечення.

Використовуйте ~ для індексації із зворотного боку списку

Якщо Lце список, використовуйте L[~i]для отримання i'-го елемента зі зворотного боку.

Це i'-вий елемент реверсу L. Бітове доповнення ~iдорівнює -i-1, і таким чином виправляє помилку "за одним" L[-i].

PEP448 - Додаткові узагальнення розпакування

З випуском Python 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.

Змінити import *наimport*

Якщо ви ще не чули, import*зберігає символи!

from math import*

на 1 символ більше, ніж import math as mви можете видалити всі екземпляриm.

Навіть одноразове використання - це економія!

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

якщо значення i є марним:

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

або

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