Welche allgemeinen Tipps haben Sie zum Golfen in Python? Ich bin auf der Suche nach Ideen, die sich auf Code-Golf-Probleme anwenden lassen und die zumindest etwas spezifisch für Python sind (z. B. "Kommentare entfernen" ist keine Antwort).

Bitte posten Sie einen Tipp pro Antwort.

Verwenden Sie a=b=c=0anstelle von a,b,c=0,0,0.

Verwenden Sie a,b,c='123'anstelle von a,b,c='1','2','3'.

Bedingungen können langwierig sein. In einigen Fällen können Sie eine einfache Bedingung durch ersetzen (a,b)[condition]. Wenn dies conditionzutrifft, bwird zurückgegeben.

Vergleichen Sie

if a<b:return a
else:return b

Dazu

return(b,a)[a<b]

Eine großartige Sache, die ich einmal gemacht habe, ist:

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

Anstatt von:

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

Pythons Vergleichsoperatoren rocken.

Wenn in Python 2 alles vergleichbar ist, können Sie auf anddiese Weise auch den Operator umgehen . Wenn zum Beispiel a, b, cund dganze Zahlen sind,

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

kann um ein Zeichen gekürzt werden, um:

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

Dabei ist jede Liste größer als eine ganze Zahl.

Wenn cund dsind Listen, wird dies noch besser:

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

Wenn Sie eine integrierte Funktion wiederholt verwenden, ist es möglicherweise platzsparender, wenn Sie einen neuen Namen vergeben, wenn Sie andere Argumente verwenden:

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

Manchmal erfordert Ihr Python-Code zwei Einrückungsstufen. Es ist naheliegend, für jede Einrückungsstufe ein und zwei Leerzeichen zu verwenden.

Python 2 betrachtet die Tabulator- und Leerzeichen jedoch als unterschiedliche Einrückungsstufen.

Dies bedeutet, dass die erste Einrückungsstufe ein Leerzeichen und die zweite ein Tabulatorzeichen sein kann.

Zum Beispiel:

if 1:
 if 1:
\tpass

Wo \tist das Tabulatorzeichen?

Verwenden Sie die Zeichenfolgensubstitution und verwenden Sie execlange Schlüsselwörter lambda, die in Ihrem Code häufig vorkommen.

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

Die Zielzeichenfolge ist sehr häufig 'lambda 'und 7 Byte lang. Angenommen, Ihr Code-Snippet enthält nVorkommen von 'lambda 'und ist sbytelang. Dann:

• Die plainOption ist sbytelang.
• Die replaceOption ist s - 6n + 29bytelang.
• Die %Option ist s - 5n + 22 + len(str(n))bytelang.

Aus einer Darstellung von Bytes, dieplain für diese drei Optionen gespeichert wurden , können wir Folgendes ersehen:

• Für n <5 Lambdas ist es besser, überhaupt nichts Besonderes zu tun.
• Bei n = 5 werden beim Schreiben exec"..."%(('lambda ',)*5)2 Bytes gespart, und dies ist die beste Option.
• Für n> 5 ist das Schreiben exec"...".replace('`','lambda ')die beste Option.

In anderen Fällen können Sie die folgende Tabelle indizieren:

          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)

Wenn die Zeichenfolge lambda x,y:(Länge 11) beispielsweise dreimal in Ihrem Code vorkommt, sollten Sie besser schreiben exec"..."%(('lambda x,y:',)*3).

Verwenden Sie Extended Slicing, um eine Zeichenfolge aus vielen auszuwählen

>>> 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 diesem booleschen 2-String-Fall kann man auch schreiben

b*"string"or"other_string"

zum

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

Im Gegensatz zum Interleaving funktioniert dies für Zeichenfolgen beliebiger Länge, es können jedoch Probleme mit der Operatorpriorität auftreten, wenn bes sich stattdessen um einen Ausdruck handelt.

Verwenden Sie `n`diese Option , um eine Ganzzahl in eine Zeichenfolge zu konvertieren, anstatt Folgendes zu verwenden str(n):

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

Speichern Sie Nachschlagetabellen als magische Zahlen

Angenommen, Sie möchten eine Boolesche Nachschlagetabelle fest codieren, z. B. welche der ersten zwölf englischen Zahlen eine enthält 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

Dann können Sie diese Nachschlagetabelle kurz und bündig implementieren als:

3714>>i&1

mit dem resultierenden 0oder 1gleich zu Falsesein True.

Die Idee ist, dass die magische Zahl die Tabelle als Bitstring bin(3714)= speichert 0b111010000010, wobei die n-te Ziffer (vom Ende) dem nEintrag in der th-Tabelle entspricht. Wir greifen auf den ndritten Eintrag zu, indem wir die Ziffernfelder nnach rechts verschieben und die letzte Ziffer um nehmen &1.

Diese Speichermethode ist sehr effizient. Vergleichen Sie mit den Alternativen

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

Sie können Ihre Nachschlagetabelle Multibit-Einträge speichern lassen, die wie folgt extrahiert werden können

 340954054>>4*n&15

um den relevanten 4-Bit-Block zu extrahieren.

Reduzieren Sie zwei numerische Schleifen zu einer

Angenommen, Sie iterieren über die Zellen eines m*nGitters. Anstelle von zwei verschachtelten forSchleifen, eine für die Zeile und eine für die Spalte, ist es normalerweise kürzer, eine einzelne Schleife zu verwenden, um über die m*nZellen des Rasters zu iterieren . Sie können die Zeile und Spalte der Zelle in der Schleife extrahieren.

Originalcode:

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

Golf Code:

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

Tatsächlich iterieren Sie über das kartesische Produkt der beiden Bereiche und codieren das Paar (i,j)als x=i*n+j. Sie sparen sich einen teuren rangeAnruf und eine gewisse Einrückung in der Schleife. Die Reihenfolge der Iteration bleibt unverändert.

Verwenden Sie //statt /in Python 3. Wenn Sie beziehen iund jviele Male, kann es schneller sein , ihre Werte zuweisen i=k/n, j=k%ninnerhalb der Schleife.

Es sei denn, das folgende Token beginnt mit eoder E. Sie können das Leerzeichen nach einer Zahl entfernen.

Zum Beispiel:

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

Wird:

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

Wenn Sie dies in komplizierten einzeiligen Anweisungen verwenden, können einige Zeichen gespart werden.

BEARBEITEN: wie @marcog hervorhob, 4or awird funktionieren, aber nicht, a or4da dies mit einem Variablennamen verwechselt wird.

Für eine Ganzzahl nkönnen Sie schreiben

• n+1 wie -~n
• n-1 wie ~-n

weil das Bit Flip ~xgleich ist -1-x. Dies verwendet die gleiche Anzahl von Zeichen, kann jedoch indirekt Leerzeichen oder Parens aus Gründen der Operatorpriorität entfernen.

Vergleichen Sie:

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

Die Betreiber ~und einstelligen -sind höhere Priorität als *, /, %, im Gegensatz zu binären +.

Eine gute Möglichkeit, eine iterable in eine Liste in Python 3 zu konvertieren :

Stellen Sie sich vor, Sie haben einige iterable, wie

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

Aber du brauchst eine Liste:

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

Es ist sehr nützlich, aus einer Zeichenfolge eine Liste von Zeichen zu erstellen

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

Stattdessen range(x)können Sie den *Operator für eine Liste von allem verwenden, wenn Sie den Wert von nicht wirklich verwenden müssen i:

for i in[1]*8:pass

im Gegensatz zu

for i in range(8):pass

Wenn Sie dies mehr als zweimal ausführen müssen, können Sie einer Variablen eine beliebige Iterationsvariable zuweisen und diese Variable mit dem gewünschten Bereich multiplizieren:

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

Hinweis : Dies ist oft länger als exec"pass;"*8, daher sollte dieser Trick nur verwendet werden, wenn dies keine Option ist.

Sie können das gute alte fremde Smiley-Gesicht verwenden, um Sequenzen umzukehren:

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

Erweitertes iterierbares Entpacken ("Markierte Zuweisung", nur Python 3)

Dies lässt sich am besten anhand eines Beispiels erklären:

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

Wir haben bereits eine Verwendung dafür gesehen - eine iterable in eine Liste in Python 3 verwandeln :

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

Hier sind noch ein paar Anwendungen.

Das letzte Element aus einer Liste holen

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

In einigen Situationen kann dies auch verwendet werden, um das erste Element zum Speichern von Parens abzurufen:

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

Zuweisen einer leeren Liste und anderer Variablen

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

Erstes oder letztes Element einer nicht leeren Liste entfernen

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

Diese sind kürzer als die Alternativen L=L[1:]und L.pop(). Das Ergebnis kann auch in einer anderen Liste gespeichert werden.

Trinkgelder mit freundlicher Genehmigung von @grc

setze Literale in Python2.7

Sie können Sets wie dieses schreiben S={1,2,3}Dies bedeutet auch Sie für die Mitgliedschaft überprüfen können mit {e}&Sstatt e in Sdem speichert ein Zeichen.

Für eine Ewigkeit störte es mich, dass ich mir keinen kurzen Weg vorstellen konnte, um das gesamte Alphabet zu bekommen. Wenn Sie rangegenug verwenden, das R=rangees wert ist, in Ihrem Programm enthalten zu sein, dann

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

ist kürzer als die naive

'abcdefghijklmnopqrstuvwxyz'

, aber sonst ist es länger von einem einzelnen Zeichen. Es verfolgte mich, dass der Kluge, der etwas Wissen über die ASCII-Werte benötigte, ausführlicher war, als nur alle Buchstaben zu tippen.

Bis ich diese Antwort für das Alphabet meiner Tochter sah . Ich kann den Bearbeitungsverlauf nicht gut genug verfolgen, um herauszufinden, ob dieses Genie das Werk des OP war oder ob es ein Vorschlag eines Kommentators war, aber dies ist (glaube ich) der kürzeste Weg, um einen iterablen der 26 Buchstaben zu erstellen im römischen Alphabet.

map(chr,range(97,123))

Wenn die Groß- / Kleinschreibung keine Rolle spielt, können Sie ein anderes Zeichen mit Großbuchstaben entfernen:

map(chr,range(65,91))

Ich benutze mapviel zu viel, ich weiß nicht, wie mir das noch nie in den Sinn gekommen ist.

Obwohl Python keine switch-Anweisungen hat, können Sie sie mit Wörterbüchern emulieren. Zum Beispiel, wenn Sie einen Schalter wie diesen wollten:

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

Sie könnten ifAnweisungen verwenden, oder Sie könnten dies verwenden:

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

oder dieses:

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

Das ist besser, wenn alle Codepfade Funktionen mit denselben Parametern sind.

So unterstützen Sie einen Standardwert:

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

(oder dieses:)

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

Ein weiterer Vorteil ist, dass Sie Redundanzen einfach nach dem Ende des Wörterbuchs hinzufügen können:

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

Und wenn Sie nur einen Schalter verwenden wollten, um einen Wert zurückzugeben:

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

Sie könnten dies einfach tun:

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

Wenn Sie zwei boolesche Werte haben aund bherausfinden möchten, ob beide aund bwahr sind, verwenden Sie *anstelle von and:

if a and b: #7 chars

vs

if a*b: #3 chars

Wenn einer der Werte falsch ist, wird er wie 0in dieser Anweisung ausgewertet , und ein ganzzahliger Wert ist nur dann wahr, wenn er ungleich Null ist.

Exploit Python 2-Zeichenfolgendarstellungen

Mit Python 2 können Sie ein Objekt xzu `x`einem Preis von nur 2 Zeichen in seine Zeichenfolgendarstellung konvertieren . Verwenden Sie diese Option für Aufgaben, die für die Zeichenfolge des Objekts einfacher sind als für das Objekt selbst.

Verbinde Charaktere

Ausgehend von einer Liste von Zeichen l=['a','b','c']kann man ''.join(l)as erzeugen `l`[2::5], wodurch ein Byte eingespart wird.

Der Grund hierfür ist , dass `l`ist "['a', 'b', 'c']"(mit Leerzeichen), so dass man die Buchstaben mit einer Liste slice extrahieren kann, ausgehend , dass der zweite Null-indizierte Charakter a, und von dort jedes fünften Zeichen nehmen. Dies funktioniert nicht, um Zeichenfolgen mit mehreren Zeichen oder Escape-Zeichen zu verbinden, die wie dargestellt werden '\n'.

Zahlen verketten

In ähnlicher Weise eine nicht-leere Liste der Stellen gegeben wie l=[0,3,5], man sich in eine String verketten kann '035'wie `l`[1::3].

Das spart so etwas wie map(str,l). Beachten Sie, dass es sich um einzelne Ziffern handeln muss und dass keine Gleitkommazahlen wie 1.0gemischt verwendet werden dürfen ].

Auf Negative prüfen

Nun zu einer Aufgabe ohne Zeichenfolge. Angenommen, Sie haben eine Liste lvon reellen Zahlen und möchten testen, ob sie negative Zahlen enthalten, wodurch ein Boolescher Wert erzeugt wird.

Du kannst tun

'-'in`l`

Das prüft auf ein negatives Vorzeichen in der Zeichenfolge rep. Dies ist kürzer als eines von beiden

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

Zum zweiten min(l)<0würde das auf der leeren Liste scheitern, so dass man sich absichern muss.

Eine einzeilige Funktion kann mit Lambda ausgeführt werden:

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

kann konvertiert werden zu (notiere fehlendes Leerzeichen 3andund 10or)

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

Schleifen von bis zu 4 Elementen sind möglicherweise besser, um ein Tupel zu liefern, als range zu verwenden

for x in 0,1,2:

vs

for x in range(3):

Decke und Boden

Wenn Sie jemals das aufgerundete Ergebnis für eine Division erhalten möchten, wie Sie es //für Floor tun würden , können Sie es math.ceil(3/2)für 15 oder das viel kürzere -(-3//2)für 8 Bytes verwenden.

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

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

Verwenden Sie +=anstelle von appendundextend

A.append(B)  

kann gekürzt werden auf:

A+=B,

B,Hier wird ein Tupel mit einem Element erstellt, mit dem Sie die Erweiterung Awie [B]in ausführen können A+=[B].

A.extend(B)

kann gekürzt werden auf:

A+=B

Auswahl einer von zwei Zahlen basierend auf einer Bedingung

Es ist bereits bekannt , die Listenauswahl [x,y][b]mit einem Booleschen Wert bfür den ternären Ausdruck zu verwenden y if b else x. Die Variablen x, yund bkönnen auch Ausdrücke, obwohl beachten Sie, dass beide xund ywerden auch ausgewertet , wenn sie nicht ausgewählt.

Hier sind einige mögliche Optimierungen, wenn xund ysind Zahlen.

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

Sie können auch wechseln xund ywenn Sie umschreiben kann bseine Negation anstatt zu sein.

Verwenden Sie ~, um am Ende einer Liste zu indizieren

Wenn Les sich um eine Liste handelt, verwenden Sie L[~i]diese Option, um das i'te Element von hinten abzurufen.

Dies ist das i'te Element der Umkehrung von L. Das Bitkomplement ist ~igleich -i-1und behebt so den Fehler von Off-by-One L[-i].

PEP448 - Zusätzliche Verallgemeinerungen beim Auspacken

Mit der Veröffentlichung von Python 3.5 wurde die Manipulation von Listen, Tupeln, Sätzen und Dikten noch golfer.

Aus einer Iteration wird eine Menge / Liste

Vergleichen Sie die Paare:

set(T)
{*T}

list(T)
[*T]

tuple(T)
(*T,)

Viel kürzer! Beachten Sie jedoch, dass das normale, erweiterte, wiederholbare Entpacken kürzer ist , wenn Sie nur etwas in eine Liste konvertieren und einer Variablen zuweisen möchten :

L=[*T]
*L,=T

Eine ähnliche Syntax funktioniert für Tupel:

T=*L,

das ist wie ausgedehntes iterables Auspacken, aber mit dem Sternchen und dem Komma auf der anderen Seite.

Listen / Tupel verbinden

Das Entpacken ist etwas kürzer als das Verketten, wenn Sie eine Liste / ein Tupel an beide Seiten anhängen müssen:

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

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

Inhalt mehrerer Listen drucken

Dies ist nicht beschränkt auf print, aber es ist definitiv, wo der größte Teil der Laufleistung herkommt. PEP448 ermöglicht jetzt das mehrfache Auspacken wie folgt:

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

Aktualisieren mehrerer Wörterbuchelemente

Dies wird wahrscheinlich nicht sehr oft vorkommen, aber die Syntax kann verwendet werden, um beim Aktualisieren von Wörterbüchern zu sparen, wenn Sie mindestens drei Elemente aktualisieren:

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

Dies negiert grundsätzlich jegliche Notwendigkeit dict.update.

Wechseln Sie import *zuimport*

Wenn Sie nicht gehört haben, import*speichert Zeichen!

from math import*

ist nur 1 Zeichen länger als import math as mund Sie können alle Instanzen von entfernenm.

Schon der einmalige Gebrauch spart!

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

wenn der Wert von i nutzlos ist:

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

oder

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