Quali consigli generali hai per giocare a golf in Python? Sto cercando idee che possano essere applicate ai problemi del code-golf e che siano almeno in qualche modo specifiche per Python (es. "Rimuovere i commenti" non è una risposta).

Si prega di inviare un suggerimento per risposta.

Usa a=b=c=0invece di a,b,c=0,0,0.

Usa a,b,c='123'invece di a,b,c='1','2','3'.

I condizionali possono essere lunghi. In alcuni casi, è possibile sostituire un semplice condizionale con (a,b)[condition]. Se conditionè vero, bviene restituito.

Confrontare

if a<b:return a
else:return b

A questo

return(b,a)[a<b]

Una grande cosa che ho fatto una volta è:

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

invece di:

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

Gli operatori di confronto di Python oscillano.

Usando che tutto è paragonabile in Python 2, puoi anche evitare l' andoperatore in questo modo. Ad esempio, se a, b, ce dsono numeri interi,

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

può essere abbreviato da un personaggio per:

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

Questo utilizza che ogni elenco è più grande di qualsiasi numero intero.

Se ce dsono liste, questo migliora ancora:

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

Se si utilizza ripetutamente una funzione integrata, potrebbe essere più efficiente in termini di spazio assegnarle un nuovo nome, se si utilizzano argomenti diversi:

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

A volte il tuo codice Python richiede di avere 2 livelli di rientro. La cosa ovvia da fare è usare uno e due spazi per ogni livello di rientro.

Tuttavia, Python 2 considera i caratteri di tabulazione e spazio come livelli di rientro diversi.

Ciò significa che il primo livello di rientro può essere uno spazio e il secondo può essere un carattere di tabulazione.

Per esempio:

if 1:
 if 1:
\tpass

Dov'è \til carattere di tabulazione.

Usa la sostituzione di stringhe e execgestisci parole chiave lunghe come quelle lambdache si ripetono spesso nel tuo codice.

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

La stringa di destinazione è molto spesso 'lambda ', che è lunga 7 byte. Supponiamo che il tuo frammento di codice contenga noccorrenze di 'lambda ', ed è slungo byte. Poi:

• L' plainopzione è slunga byte.
• L' replaceopzione è s - 6n + 29lunga byte.
• L' %opzione è s - 5n + 22 + len(str(n))lunga byte.

Da una trama di byte salvati suplain per queste tre opzioni, possiamo vedere che:

• Per n <5 lambda, è meglio non fare niente di speciale.
• Per n = 5 , la scrittura exec"..."%(('lambda ',)*5)salva 2 byte ed è l'opzione migliore.
• Per n> 5 , la scrittura exec"...".replace('`','lambda ')è l'opzione migliore.

Per altri casi, è possibile indicizzare la tabella seguente:

          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)

Ad esempio, se la stringa lambda x,y:(lunghezza 11) si presenta 3 volte nel codice, è meglio scrivere exec"..."%(('lambda x,y:',)*3).

Utilizzare la divisione estesa per selezionare una stringa tra molte

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

vs

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

In questo caso booleano a due stringhe, si può anche scrivere

b*"string"or"other_string"

per

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

A differenza dell'interlacciamento, questo funziona per stringhe di qualsiasi lunghezza, ma può avere problemi di precedenza dell'operatore se bè invece un'espressione.

Utilizzare `n`per convertire un numero intero in una stringa anziché utilizzare str(n):

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

Memorizza le tabelle di ricerca come numeri magici

Supponi di voler codificare una tabella di ricerca booleana, ad esempio quale dei primi dodici numeri inglesi contiene un 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

Quindi, puoi implementare questa tabella di ricerca in modo conciso come:

3714>>i&1

con il risultato 0o 1uguale Falsea True.

L'idea è che il numero magico memorizzi la tabella come una stringa di bit bin(3714)= 0b111010000010, con la n-esima cifra (dalla fine) corrispondente alla nvoce della tabella th. Accediamo la nvoce di th da bitshifting il numero nspazi a destra e prendere l'ultima cifra da &1.

Questo metodo di archiviazione è molto efficiente. Confronta con le alternative

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

Puoi fare in modo che la tua tabella di ricerca memorizzi voci multibit che possono essere estratte come

 340954054>>4*n&15

per estrarre il relativo blocco a quattro bit.

Comprimi due anelli numerici in uno

Supponiamo che stai ripetendo le celle di una m*ngriglia. Invece di due forloop nidificati , uno per la riga e uno per le colonne, in genere è più breve utilizzare un singolo loop per scorrere le m*ncelle della griglia. È possibile estrarre la riga e la colonna della cella all'interno del ciclo.

Codice originale:

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

Codice golfizzato:

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

In effetti, stai ripetendo il prodotto cartesiano delle due gamme, codificando la coppia (i,j)come x=i*n+j. Hai salvato una rangechiamata costosa e un livello di rientro all'interno del ciclo. L'ordine di iterazione è invariato.

Usa //invece che /in Python 3. Se ti riferisci a ie jmolte volte, potrebbe essere più veloce assegnare i loro valori i=k/n, j=k%nall'interno del loop.

A meno che il seguente token non inizi con eo E. È possibile rimuovere lo spazio seguendo un numero.

Per esempio:

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

diventa:

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

L'uso di questo in complicate istruzioni di una riga può far risparmiare parecchi caratteri.

EDIT: come ha sottolineato @marcog, 4or afunzionerà, ma non a or4perché questo viene confuso con un nome di variabile.

Per intero n, puoi scrivere

• n+1 come -~n
• n-1 come ~-n

perché il bit flip è ~xuguale -1-x. Questo utilizza lo stesso numero di caratteri, ma può tagliare indirettamente spazi o parentesi per la precedenza dell'operatore.

Confrontare:

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

Gli operatori ~e le unari -sono precedenza maggiore rispetto *, /, %, a differenza di binario +.

Un bel modo per convertire un iterabile all'elenco su Python 3 :

immagina di avere un po 'iterabile, come

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

Ma hai bisogno di un elenco:

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

È molto utile creare un elenco di caratteri da una stringa

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

Invece di range(x), puoi usare l' *operatore in un elenco di qualsiasi cosa, se in realtà non hai bisogno di usare il valore di i:

for i in[1]*8:pass

al contrario di

for i in range(8):pass

Se è necessario farlo più di due volte, è possibile assegnare qualsiasi iterabile a una variabile e moltiplicare quella variabile per l'intervallo desiderato:

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

Nota : questo è spesso più lungo di exec"pass;"*8, quindi questo trucco dovrebbe essere usato solo quando non è un'opzione.

Puoi usare la buona vecchia faccina aliena per invertire le sequenze:

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

Disimballaggio iterabile esteso ("Assegnazione speciali", solo Python 3)

Il modo migliore per spiegare questo è tramite un esempio:

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

Abbiamo già visto un uso per questo: trasformare un iterabile in un elenco in Python 3 :

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

Ecco alcuni altri usi.

Ottenere l'ultimo elemento da un elenco

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

In alcune situazioni, questo può essere utilizzato anche per ottenere il primo elemento da salvare su parentesi:

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

Assegnare un elenco vuoto e altre variabili

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

Rimozione del primo o dell'ultimo elemento di un elenco non vuoto

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

Questi sono più brevi rispetto alle alternative L=L[1:]e L.pop(). Il risultato può anche essere salvato in un altro elenco.

Suggerimenti per gentile concessione di @grc

impostare letterali in Python2.7

Puoi scrivere set come questo S={1,2,3}Ciò significa anche che puoi verificare l'appartenenza usando {e}&Sinvece di e in Squale salva un carattere.

Per anni mi ha infastidito il fatto che non potessi pensare a un modo breve per ottenere l'intero alfabeto. Se usi rangeabbastanza che R=rangevale la pena avere nel tuo programma, allora

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

è più breve dell'ingenuo

'abcdefghijklmnopqrstuvwxyz'

, ma per il resto è più lungo di un singolo personaggio. Mi perseguitava il fatto che quello intelligente che richiedeva una certa conoscenza dei valori ASCII finisse per essere più prolisso che scrivere semplicemente tutte le lettere.

Fino a quando non ho visto questa risposta per l'alfabeto di mia figlia . Non riesco a seguire abbastanza bene la cronologia delle modifiche per capire se questo genio fosse opera dell'OP o se fosse un suggerimento di un commentatore, ma questo è (credo) il modo più breve per creare un iterabile delle 26 lettere nell'alfabeto romano.

map(chr,range(97,123))

Se il caso non ha importanza, puoi rimuovere un altro carattere usando le lettere maiuscole:

map(chr,range(65,91))

Uso maptroppo, non so come questo non mi sia mai venuto in mente.

Sebbene Python non abbia istruzioni switch, è possibile emularle con dizionari. Ad esempio, se si desidera un passaggio come questo:

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

È possibile utilizzare le ifistruzioni oppure è possibile utilizzare questo:

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

o questo:

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

che è meglio se tutti i percorsi di codice sono funzioni con gli stessi parametri.

Per supportare un valore predefinito, procedere come segue:

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

(o questo:)

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

Un altro vantaggio di questo è che se si hanno ridondanze, è possibile aggiungerle solo dopo la fine del dizionario:

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

E se volessi semplicemente utilizzare un interruttore per restituire un valore:

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

Potresti semplicemente fare questo:

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

Quando hai due valori booleani ae b, se vuoi scoprire se entrambi ae bsono veri, usa *invece di and:

if a and b: #7 chars

vs

if a*b: #3 chars

se uno dei due valori è falso, verrà valutato come 0in tale istruzione e un valore intero è vero solo se è diverso da zero.

Sfrutta le rappresentazioni di stringa di Python 2

Python 2 ti consente di convertire un oggetto xnella sua rappresentazione di stringa `x`al costo di soli 2 caratteri. Utilizzare questo per attività che sono più facili da eseguire sulla stringa dell'oggetto rispetto all'oggetto stesso.

Unisciti ai personaggi

Dato un elenco di caratteri l=['a','b','c'], si può produrre ''.join(l)come `l`[2::5], che salva un byte.

Il motivo è che `l`è "['a', 'b', 'c']"(con spazi), quindi è possibile estrarre le lettere con una sezione di elenco, iniziando dal secondo carattere con indice zero ae prendendo ogni quinto carattere da lì. Questo non funziona per unire stringhe multi-carattere o caratteri di escape rappresentati come '\n'.

Cifre concatenate

Allo stesso modo, dato un elenco non vuoto di cifre come l=[0,3,5], si possono concatenarle in una stringa '035'come `l`[1::3].

Questo risparmia facendo qualcosa di simile map(str,l). Si noti che devono essere cifre singole e non possono avere float come 1.0mischiati. Inoltre, ciò non riesce nella lista vuota, producendo ].

Controlla gli aspetti negativi

Ora, per un'attività non stringa. Supponiamo di avere un elenco ldi numeri reali e di voler verificare se contiene numeri negativi, producendo un valore booleano.

Tu puoi fare

'-'in`l`

che verifica la presenza di un segno negativo nella stringa rep. Questo più breve di uno dei due

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

Per il secondo, min(l)<0fallirebbe sulla lista vuota, quindi devi coprirti.

Una funzione a una riga può essere eseguita con lambda:

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

può essere convertito in (notare lo spazio mancante 3ande 10or)

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

i loop fino a 4 articoli potrebbero essere meglio per fornire una tupla invece di usare la gamma

for x in 0,1,2:

vs

for x in range(3):

Ceil e pavimento

Se mai vuoi ottenere il risultato arrotondato per divisione, proprio come faresti con //floor, potresti usare math.ceil(3/2)per 15 o molto più breve -(-3//2)per 8 byte.

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

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

Utilizzare +=invece di appendeextend

A.append(B)  

può essere abbreviato in:

A+=B,

B,qui crea una tupla a un elemento che può essere usata per estendere Aproprio come [B]in A+=[B].

A.extend(B)

può essere abbreviato in:

A+=B

Scelta di uno dei due numeri in base a una condizione

Sai già di usare la selezione della lista [x,y][b]con un booleano bper l'espressione ternaria y if b else x. Le variabili x, ye bpossono anche essere espressioni, però notare che sia xe yvengono valutati anche quando non è stato selezionato.

Ecco alcune potenziali ottimizzazioni quando xe ysono numeri.

• [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(o y-z*b), dove z = yx.

È anche possibile cambiare xe yse è possibile riscrivere bper essere invece la sua negazione.

Usa ~ per indicizzare dal retro di un elenco

Se Lè un elenco, utilizzare L[~i]per ottenere l' ielemento th dal retro.

Questo è l i'elemento del rovescio di L. Il complemento di bit è ~iuguale -i-1e quindi corregge l'errore off-by-one da L[-i].

PEP448 - Generalizzazioni aggiuntive sul disimballaggio

Con il rilascio di Python 3.5 , la manipolazione di liste, tuple, set e dicts è appena diventata più golfista.

Trasformare un iterabile in un set / elenco

Confronta le coppie:

set(T)
{*T}

list(T)
[*T]

tuple(T)
(*T,)

Molto più breve! Si noti, tuttavia, che se si desidera convertire qualcosa in un elenco e assegnarlo a una variabile, la decompressione iterabile estesa normale è più breve:

L=[*T]
*L,=T

Una sintassi simile funziona per le tuple:

T=*L,

che è come decomprimere iterabile esteso, ma con l'asterisco e la virgola sull'altro lato.

Elenchi / tuple uniti

Il disimballaggio è leggermente più breve della concatenazione se è necessario aggiungere un elenco / tupla ad entrambi i lati:

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

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

Stampa dei contenuti di più elenchi

Questo non si limita a print, ma è sicuramente da dove arriverà la maggior parte del chilometraggio. PEP448 ora consente il disimballaggio multiplo, in questo modo:

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

Aggiornamento di più voci del dizionario

Questo probabilmente non accadrà molto spesso, ma la sintassi può essere utilizzata per salvare sull'aggiornamento dei dizionari se stai aggiornando almeno tre elementi:

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

Questo praticamente nega qualsiasi necessità dict.update.

Cambia import *inimport*

Se non l'hai sentito, import*salva i caratteri!

from math import*

è solo 1 carattere più lungo di import math as me puoi rimuovere tutte le istanze dim.

Anche un solo utilizzo è un risparmio!

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

se il valore di i è inutile:

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

o

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