Comment puis-je alias les fonctions membres en Python?

En Python, on peut enregistrer des octets en aliasant des fonctions qui sont utilisées à plusieurs reprises. Par exemple:

r=range
a=r(100)
b=r(200)
c=r(300)

Cependant, lorsque les fonctions sont des fonctions membres ensemble, je ne sais pas comment les alias d'une manière qui permette le chaînage. Par exemple:

s='Hello'

// Plain code
s=s.replace('H','J').replace('e','i').replace('l','m').replace('o','y')

// What I am trying to do
q=replace
s=s.q('H','J').q('e','i').q('l','m').q('o','y')

De toute évidence, ce que j'essaie de faire n'est pas valide. Et ce n'est pas non plus:

q=s.replace
s=q('H','J') // Replaces the 'H' in 'Hello'
s=q('e','i') // Replaces the 'e' in 'Hello'... and the J is gone.
s=q('l','m')
s=q('o','y')

Existe-t-il une autre façon d'alias les fonctions membres et les fonctions chaînées qui enregistre les caractères?

Pas de problème! Vous pouvez alias une méthode, mais vous devez savoir comment l'utiliser:

>>> r=str.replace
>>> a='hello'
>>> r(r(r(r(a,'h','j'),'e','i'),'l','m'),'o','y')
'jimmy'

La clé est que vous devez passer selfexplicitement, car l'alias est une sorte de fonction qui prend un argument supplémentaire qui prend self:

>>> type(r)
<type 'method_descriptor'>

Définissez votre propre classe, avec un nom de méthode plus court.

Par exemple, si vous utilisez la méthode replace()appartenant à la Stringclasse, vous pouvez faire en sorte que votre propre classe Sait une méthode appelée qqui fait la même chose.

Voici une implémentation:

class m(str):
 def q(a,b,c):return m(a.replace(b,c))

Voici une bien meilleure implémentation:

class m(str):q=lambda a,b,c:m(a.replace(b,c))

Utilisez-le comme ceci:

s="Hello"
s=m(s).q('H','J').q('e','i').q('l','m').q('o','y')

C'est quand même quelques caractères plus courts

j=iter('HJeilmoy')
for i in j:s=s.replace(i,next(j))

encore plus court pour un petit nombre de remplacements est

for i in['HJ','ei','lm','oy']:s=s.replace(*i)

bien sûr, cela ne couvre qu'un cas particulier. Cependant, le golf de code consiste à trouver ces cas spéciaux qui peuvent vous faire économiser des octets.

Il est possible d'écrire une fonction wrapper qui gère le cas général, mais le code sera trop volumineux pour avoir une place dans la plupart des défis de golf de code.

Au lieu de cela, vous devez penser "Je peux effectuer cette transformation efficacement (en traits) avec str.replace. Puis-je changer la représentation interne de ma solution pour en profiter? (Sans gaspiller autant de traits pour annuler l'avantage)"

Vous pouvez utiliser la reducefonction.

reduce(lambda s,(a,b):s.replace(a,b),[('H','J'),('e','i'),('l','m'),('o','y')],'Hello')

Si vous faites beaucoup de remplacements, vous pouvez le faire:

s=''.join({'H':'J','e':'i','l':'m','o':'y'}[a] for a in list(s))

Que diriez-vous de définir une fonction lambda?

r=lambda s,a,b:s.replace(a,b)

s=r(r(r(r(s,'H','J'),'e','i'),'l','m'),'o','y')

Si vos remplacements n'ont pas besoin d'être enchaînés, vous pouvez utiliser `str.translate '. Les nombres sont les ordinaux ASCII. Son utilisation de cette façon nécessite Python 3:

print("Hello".translate({72:74,101:105,108:109,111:121}))

Essayez-le en ligne