Quels conseils généraux avez-vous pour jouer au golf en Python? Je cherche des idées qui puissent être appliquées aux problèmes de code-golf et qui soient aussi au moins quelque peu spécifiques à Python (par exemple, "supprimer les commentaires" n'est pas une réponse).

Merci de poster un pourboire par réponse.

Utilisez a=b=c=0au lieu de a,b,c=0,0,0.

Utilisez a,b,c='123'au lieu de a,b,c='1','2','3'.

Les conditions peuvent être longues. Dans certains cas, vous pouvez remplacer un simple conditionnel par (a,b)[condition]. Si conditionest vrai, alors best retourné.

Comparer

if a<b:return a
else:return b

Pour ça

return(b,a)[a<b]

Une bonne chose que j'ai faite une fois est:

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

au lieu de:

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

Les opérateurs de comparaison de Python basculent.

En utilisant tout ce qui est comparable dans Python 2, vous pouvez également éviter l' andopérateur de cette façon. Par exemple, si a, b, cet dsont des nombres entiers,

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

peut être raccourci d'un caractère à:

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

Cela utilise que chaque liste est plus grande que n'importe quel entier.

Si cet dsont des listes, cela devient encore meilleur:

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

Si vous utilisez une fonction intégrée à plusieurs reprises, il pourrait être plus efficace de lui attribuer un nouveau nom si vous utilisez des arguments différents:

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

Parfois, votre code Python nécessite 2 niveaux d’indentation. La chose évidente à faire est d'utiliser un et deux espaces pour chaque niveau d'indentation.

Cependant, Python 2 considère que les caractères de tabulation et d'espace sont des niveaux d'indentation différents.

Cela signifie que le premier niveau d'indentation peut être d'un espace et le second peut être un caractère de tabulation.

Par exemple:

if 1:
 if 1:
\tpass

Où \test le caractère de tabulation.

Utilisez la substitution de chaîne et execles mots-clés longs lambdasont souvent répétés dans votre code.

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 chaîne cible est très souvent 'lambda 'longue de 7 octets. Supposons que votre extrait de code contienne des noccurrences de 'lambda 'et qu'il sdure longtemps. Ensuite:

• L' plainoption est soctets longs.
• L' replaceoption est s - 6n + 29octets longs.
• L' %option est s - 5n + 22 + len(str(n))octets longs.

À partir d'un tracé d' octets enregistrésplain pour ces trois options, nous pouvons voir que:

• Pour n <5 lambdas, il est préférable de ne rien faire d’extraordinaire.
• Pour n = 5 , l'écriture exec"..."%(('lambda ',)*5)enregistre 2 octets et constitue votre meilleure option.
• Pour n> 5 , l'écriture exec"...".replace('`','lambda ')est votre meilleure option.

Pour les autres cas, vous pouvez indexer le tableau ci-dessous:

          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)

Par exemple, si la chaîne lambda x,y:(longueur 11) apparaît 3 fois dans votre code, vous feriez mieux d'écrire exec"..."%(('lambda x,y:',)*3).

Utilisez le découpage étendu pour sélectionner une chaîne parmi plusieurs

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

contre

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

Dans ce cas booléen à deux cordes, on peut aussi écrire

b*"string"or"other_string"

pour

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

Contrairement à l'entrelacement, cela fonctionne pour les chaînes de n'importe quelle longueur, mais peut avoir des problèmes de priorité d'opérateur s'il bs'agit plutôt d'une expression.

Utilisez `n`pour convertir un entier en chaîne au lieu de str(n):

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

Stocker les tables de consultation sous forme de nombres magiques

Supposons que vous vouliez coder en dur une table de recherche booléenne, par exemple, lequel des douze premiers nombres anglais contient 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

Ensuite, vous pouvez implémenter cette table de recherche de manière concise en tant que:

3714>>i&1

avec le résultat 0ou 1étant égal à Falseà True.

L'idée est que le nombre magique stocke la table sous la forme d'une chaîne de bits bin(3714)= 0b111010000010, avec le ntroisième chiffre (à partir de la fin) correspondant à la troisième nentrée de la table. On accède à la ne entrée en décalant un peu le nombre d’ nespaces à droite et en prenant le dernier chiffre par&1 .

Cette méthode de stockage est très efficace. Comparer aux alternatives

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

Vous pouvez avoir vos entrées multibits de magasin de table de recherche qui peuvent être extraites comme

 340954054>>4*n&15

extraire le bloc de quatre bits correspondant.

Réduire deux boucles numériques en une

Supposons que vous parcouriez les cellules d'une m*ngrille. Au lieu de deux forboucles imbriquées , une pour la ligne et une des colonnes, il est généralement plus court d'utiliser une seule boucle pour parcourir les m*ncellules de la grille. Vous pouvez extraire la ligne et la colonne de la cellule à l'intérieur de la boucle.

Code d'origine:

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

Code de golf:

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

En effet, vous itérer sur le produit cartésien des deux plages, codant pour la paire (i,j)comme x=i*n+j. Vous avez économisé un rangeappel coûteux et un niveau d'indentation dans la boucle. L'ordre des itérations est inchangé.

Utilisez //plutôt que /dans Python 3. Si vous vous référez ài et jplusieurs fois, il peut être plus rapide d’affecter leurs valeurs i=k/n, j=k%nà l’intérieur de la boucle.

Sauf si le jeton suivant commence par e ou E. Vous pouvez supprimer l'espace après un numéro.

Par exemple:

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

Devient:

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

L'utilisation de ceci dans des instructions compliquées d'une ligne peut sauver un nombre considérable de caractères.

EDIT: comme @marcog l’a souligné, 4or acela fonctionnera, mais pas a or4parce que cela est confondu avec un nom de variable.

Pour un entier n, vous pouvez écrire

• n+1 comme -~n
• n-1 comme ~-n

parce que le bit bascule ~xest égal -1-x. Ceci utilise le même nombre de caractères, mais peut indirectement couper des espaces ou des parenthèses pour la priorité des opérateurs.

Comparer:

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

Les opérateurs ~et unaire -sont plus élevés que la priorité *, /, %, à la différence binaire +.

Un bon moyen de convertir une liste itérable en une liste sur Python 3 :

imaginez que vous en ayez un, comme

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

Mais vous avez besoin d'une liste:

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

C'est très utile de faire une liste de caractères d'une chaîne

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

Au lieu de range(x), vous pouvez utiliser l' *opérateur sur une liste de tout, si vous n'avez pas réellement besoin d'utiliser la valeur de i:

for i in[1]*8:pass

par opposition à

for i in range(8):pass

Si vous devez le faire plus de deux fois, vous pouvez affecter n'importe quelle variable à une variable et multiplier cette variable par la plage souhaitée:

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

Note : c'est souvent plus long que exec"pass;"*8ça, donc cette astuce ne devrait être utilisée que quand ce n'est pas une option.

Vous pouvez utiliser le bon vieux smiley extraterrestre pour inverser les séquences:

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

Déballage itératif étendu ("Affectation étoilée", Python 3 uniquement)

La meilleure façon de l'expliquer consiste à utiliser un exemple:

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

Nous avons déjà vu une utilisation pour cela: transformer une liste itérable en une liste dans Python 3 :

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

Voici quelques utilisations supplémentaires.

Obtenir le dernier élément d'une liste

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

Dans certaines situations, cela peut également être utilisé pour obtenir le premier élément à économiser sur les parenthèses:

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

Assigner une liste vide et d'autres variables

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

Supprimer le premier ou le dernier élément d'une liste non vide

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

Celles-ci sont plus courtes que les alternatives L=L[1:]et L.pop(). Le résultat peut également être enregistré dans une liste différente.

Astuces courtoisie de @grc

définir des littéraux en Python2.7

Vous pouvez écrire des ensembles comme celui-ci. S={1,2,3}Cela signifie également que vous pouvez vérifier l’appartenance à la {e}&Splace de celle e in Squi enregistre un caractère.

Pendant des siècles, cela me dérangeait de ne pas pouvoir trouver un moyen rapide d’obtenir l’alphabet complet. Si vous en utilisez rangesuffisamment R=rangedans votre programme, alors

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

est plus court que le naïf

'abcdefghijklmnopqrstuvwxyz'

, mais sinon c'est plus long d'un seul personnage. Cela me hantait que l'intelligent qui nécessitait une connaissance des valeurs ascii finissait par être plus bavard que simplement taper toutes les lettres.

Jusqu'à ce que je voie cette réponse pour l'alphabet de ma fille . Je ne peux pas suivre suffisamment l'historique de montage pour savoir si ce génie était l'oeuvre de l'OP ou s'il s'agissait d'une suggestion de la part d'un commentateur, mais c'est (je crois) le moyen le plus rapide de créer un éditable des 26 lettres. dans l'alphabet romain.

map(chr,range(97,123))

Si l'affaire n'a pas d'importance, vous pouvez supprimer un autre personnage en utilisant des majuscules:

map(chr,range(65,91))

J'utilise mapbeaucoup trop, je ne sais pas comment cela ne m'est jamais arrivé.

Bien que python ne possède pas d'instructions switch, vous pouvez les émuler avec des dictionnaires. Par exemple, si vous vouliez un commutateur comme celui-ci:

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

Vous pouvez utiliser des ifdéclarations, ou ceci:

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

ou ca:

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

ce qui est mieux si tous les chemins de code sont des fonctions avec les mêmes paramètres.

Pour prendre en charge une valeur par défaut, procédez comme suit:

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

(ou ca:)

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

Un autre avantage est que si vous avez des redondances, vous pouvez simplement les ajouter après la fin du dictionnaire:

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

Et si vous vouliez simplement utiliser un commutateur pour renvoyer une valeur:

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

Vous pouvez simplement faire ceci:

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

Lorsque vous avez deux valeurs booléennes aet b, si vous voulez savoir si les deux aet bsont vraies, utilisez *plutôt and:

if a and b: #7 chars

contre

if a*b: #3 chars

si l'une des valeurs est false, elle sera évaluée comme 0dans cette instruction et une valeur entière n'est vraie que si elle est différente de zéro.

Exploiter les représentations de chaîne Python 2

Python 2 vous permet de convertir un objet xen représentation de chaîne`x` pour un coût de 2 caractères seulement. Utilisez cette option pour les tâches plus faciles à effectuer sur la chaîne de l'objet que sur l'objet lui-même.

Rejoindre des personnages

Avec une liste de caractères l=['a','b','c'], on peut produire en ''.join(l)tant que `l`[2::5], ce qui enregistre un octet.

La raison est que `l`est "['a', 'b', 'c']"(avec des espaces), on peut donc extraire les lettres avec une tranche de liste, en commençant que le second caractère zéro indexé a, et en prenant chaque cinquième caractère à partir de là. Cela ne fonctionne pas pour joindre des chaînes multi-caractères ou des caractères d'échappement représentés comme '\n'.

Concaténer les chiffres

De même, étant donné une liste de chiffres non vide l=[0,3,5], vous pouvez les concaténer dans une chaîne en '035'tant que `l`[1::3].

Cela évite de faire quelque chose comme map(str,l) . Notez qu'il doit s'agir de chiffres simples et que les flottants ne peuvent pas être 1.0mélangés. Cela échoue également sur la liste vide ].

Vérifier les négatifs

Maintenant, pour une tâche non-chaîne. Supposons que vous ayez une listel de nombres réels et que vous souhaitiez vérifier si elle contient des nombres négatifs, produisant ainsi un booléen.

Tu peux faire

'-'in`l`

qui vérifie la présence d’un signe négatif dans la chaîne rep. Ce plus court que l'un des

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

Pour le second, min(l)<0échouerait sur la liste vide, vous devez donc vous couvrir.

Une fonction d'une ligne peut être réalisée avec lambda:

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

peut être converti en (notez l'espace manquant 3andet 10or)

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

les boucles allant jusqu’à 4 éléments peuvent être mieux pour fournir un tuple au lieu d’utiliser une plage

for x in 0,1,2:

contre

for x in range(3):

Ceil et sol

Si vous souhaitez obtenir le résultat arrondi pour une division, comme vous le feriez //pour le sol, vous pouvez utiliser math.ceil(3/2)15 ou le nombre beaucoup plus court -(-3//2)pour 8 octets.

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

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

Utiliser +=au lieu de appendetextend

A.append(B)  

peut être réduit à:

A+=B,

B,crée ici un tuple à un élément qui peut être utilisé pour s'étendre Acomme [B]dans A+=[B].

A.extend(B)

peut être réduit à:

A+=B

Choisir l'un des deux nombres en fonction d'une condition

Vous savez déjà utiliser la sélection de liste [x,y][b]avec un booléen bpour l'expression ternaire y if b else x. Les variables x, yet bpeuvent également être des expressions, même si elles sont évaluées xet ysont évaluées même si elles ne sont pas sélectionnées.

Voici quelques optimisations possibles quand xet ysont des nombres.

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

Vous pouvez également basculer xet ysi vous pouvez réécrire bpour être sa négation à la place.

Utilisez ~ pour indexer à partir du dos d'une liste

Si Lest une liste, utilisez L[~i]pour obtenir le iième élément à l'arrière.

C'est le iième élément de l'inverse de L. Le complément de bit ~iest égal à -i-1, et corrige donc l'erreur de décalage par un L[-i].

PEP448 - Généralisations de supplémentaires

Avec la sortie de Python 3.5 , la manipulation de listes, de tuples, de décors et de dict est devenue encore plus golfeuse.

Transformer un itérable en un ensemble / une liste

Comparez les paires:

set(T)
{*T}

list(T)
[*T]

tuple(T)
(*T,)

Plus court! Notez cependant que si vous souhaitez simplement convertir quelque chose en liste et l'affecter à une variable, la décompression itérative étendue normale est plus courte:

L=[*T]
*L,=T

Une syntaxe similaire fonctionne pour les tuples:

T=*L,

ce qui ressemble à un décompression itérative prolongée, mais avec l'astérisque et une virgule de l'autre côté.

Rejoindre des listes / tuples

La décompression est légèrement plus courte que la concaténation si vous devez ajouter une liste / un nuplet aux deux côtés:

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

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

Imprimer le contenu de plusieurs listes

Ce n’est pas limité à print, mais c’est bien d’où viendra la plus grande partie du kilométrage parcouru. PEP448 permet maintenant le décompactage multiple, comme suit:

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

Mise à jour de plusieurs éléments du dictionnaire

Cela n'arrivera probablement pas très souvent, mais la syntaxe peut être utilisée pour économiser sur la mise à jour de dictionnaires si vous mettez à jour au moins trois éléments:

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

Cela annule fondamentalement tout besoin de dict.update.

Changer import *enimport*

Si vous ne l'avez pas entendu, import*sauve des caractères!

from math import*

est seulement 1 caractère plus long que import math as m et vous arrivez à supprimer toutes les instances dem.

Même une utilisation ponctuelle est un économiseur!

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

si la valeur de i est inutile:

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

ou

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