Optimisation de code

**Portus** · 25/10/2009, 16h47

Bonjour, je suis actuellement le cours sur le Python et suite à un TP (5.8. Écrivez un script qui recopie une chaîne (dans une nouvelle variable), en insérant des astérisques entre les caractères.
Ainsi par exemple, « gaston » devra devenir « g*a*s*t*o*n »), j'ai réalisé un code, il fonctionne mais j'aimerais savoir s'il y a moyen de l'optimiser et de le rendre plus propre.

Le voici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
chaine, nouvelle_chaine = "gaston7895", ""
longueur = len(chaine)
i = 0
 
while i < longueur-1 :
	nouvelle_chaine = nouvelle_chaine + chaine[i]+"*"
	i=i+1
nouvelle_chaine = nouvelle_chaine+chaine[longueur-1]
print nouvelle_chaine

Merci d'avance !

**tyrtamos** · 25/10/2009, 17h00

Bonjour,

Il y a une solution super simple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
x = "gaston"
y =  '*'.join(list(x))
print y
'g*a*s*t*o*n'

Tyrtamos

**Portus** · 25/10/2009, 17h09

Merci ! Je n'ai pas encore appris ça mais je le saurai pour la suite

**eyquem** · 25/10/2009, 17h17

Bonjour,

Bien sûr.

Conseils:

- une fois qu’on a trouvé une solution à un problème, le réexaminer en se disant:
je suis sûr qu’il doit être possible de faire plus concis

- si on arrive à faire plus concis, c’est souvent parce que Python dispose d’une fonction qui fait en un appel ce qu’on a fait avec plusieurs lignes de codes

- pour trouver les fonctions sur les chaînes:
http://www.python.org/doc/2.6.2/libr...html#index-585
section 6.6.1

J’aime bien aussi la présentation de la version 2.5
http://www.python.org/doc/2.5.4/lib/...s.html#l2h-233

- proverbe pythonien
Ton code meilleure mine aura
Toutes fois qu’indices élimineras

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
li = [23,56,34,67,56,35]
k = 0
while k<len(li):
    print li[k]

c’est berk, alors qu’on peut faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for u in li:
    print u

Par ailleurs il y a déjà eu deux ou trois files sur ce problème, il sufit de faire une recherche.

**fred1599** · 25/10/2009, 20h23

Un simple boucle for

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for i in chaine: print i+"*",

**Antoine_935** · 25/10/2009, 20h53

Si le but est l'optimisation, des print consécutifs ne sont pas une bonne solution.
Un print, c'est un appel système. Pour l'effectuer, il faut un context switch du processeur. De plus, selon le système d'exploitation, ça peut obliger aussi à sauvegarder tous les registres du processeur. Enfin, ça passe par un fichier (stdout), donc un buffer, donc des fonctions de contrôles.

**eyquem** · 26/10/2009, 09h34

Merci Antoine935 pour ces explications.
Je comprends enfin pourquoi l’affichage d’un grand nombre de courtes chaînes est long.

Mais il y a un moyen de contourner le ralentissement: cumuler dans une seule chaîne plusieurs affichages courts.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
ch = 'gaston'
mh = ch[0]
for c in ch[1:]:
    mh += '*' + c
print mh

Application intéressante:
afficher instantanément sous forme repr(ligne) les lignes d’un code source de site, ligne par ligne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
import urllib
sock = urllib.urlopen('http://www.partir.com/Equateur/Galapagos/')
somt = ''
for ln in sock:
    somt += '\n' + repr(ln)
sock.close()
print somt

'<html>\n'
'<head>\n'
' \n'
"<title>Galapagos - Iles d'Equateur - tr\xe9sor de faune et flore</title>\n"
' <meta name="KeyWords" content="Equateur, Galapagos, Tourisme, voyage, Darwin, iguanes">\n'
'</head>\n'
'<Body BGColor="#FFFFFF" Link="#1580EA" VLink="#0A4075">\n'
'\r\n'
'\n'
'\n'
'\n'
'\n'
'<table>\n'
' <tr> \n'
' <td align=left>\n'
'\n'
'<script type="text/javascript"><!--\n'
'google_ad_client = "pub-5608884666532582";\n'
'google_ad_width = 728;\n'
'google_ad_height = 90;\n'
etc
etc

----------------------------

Petite défi-nette

comment obtenir, sans expression régulière
*c*h*o*c*o*l*a*t*
à partir de
chocolat?
.

**josmiley** · 26/10/2009, 09h41

Envoyé par eyquem

Petite défi-nette

comment obtenir, sans expression régulière
*c*h*o*c*o*l*a*t*
à partir de
chocolat?
.

j'comprends pas la question ....

**fred1599** · 26/10/2009, 10h19

Il veut surement dire un truc de ce genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
>>> chaine="chocolat"
>>> chaine="*".join(chaine)
>>> chaine=list(chaine)
>>> chaine.insert(0, "*")
>>> chaine.insert(len(chaine)+1, "*")
>>> for i in chaine: print i,
... 
* c * h * o * c * o * l * a * t *

**eyquem** · 26/10/2009, 12h29

Allons, allons...
Tu t’es couché tard ce matin, fred1599 ?
On ne peut pas insérer des caractères dans une chaîne, ni au milieu, ni devant, ni derrière, c’est entendu. Mais on peut concaténer des chaînes (catena = chaîne en latin):

Tes lignes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
chaine=list(chaine)
chaine.insert(0, "*")
chaine.insert(len(chaine)+1, "*")
for i in chaine: print i,

se remplacent par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
chaine = '*'+chaine+'*'
print chaine

et même l'ensemble du code par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
chaine = '*'+"*".join(chaine)+'*'
print chaine

ce qui évite la boucle for i in chaine: print i, dont Antoine935 a souligné l’horribilité.

De plus, ta solution affiche des blancs entre les caractères.

Soit dit en passant, avec
chaine = ['*', 'c', '*', 'h', '*', 'o', '*', 'c', '*', 'o', '*', 'l', '*', 'a', '*', 't', '*']
que tu obtiens,
cette horreur de boucle print se remplace avantageusement par
print "".join(chaine)
join() est une fonction très très rapide

Pour ce qui est de ma devinette, on peut obtenir *c*h*o*c*o*l*a*t*
en une seule ligne, avec une certaine fonction, sans concaténation de chaînes évidemment.
Et sans expression régulière; mais rien ne vous empêche de vous demander pourquoi je donne cette restriction.
Je ne pratique pas les jeux vidéos, mais il doit bien y avoir dans ces jeux de semblables procédés pour détourner les intrépides quêteurs d'entrer dans les labyrinthes à deux portes.......

**fred1599** · 26/10/2009, 13h58

J'avoue que je suis un peu fatigué, mais maintenant je suis en vacances, et donc je vais me retaper.

**josmiley** · 27/10/2009, 16h56

sans concatenation .... hummm, achement pas facile.

**eyquem** · 27/10/2009, 18h19

sans concaténation , oui
alors ? vas-y, dis. vas-y. vaaas-y: diiiis. vas-y !

Je viens de penser à une solution avec deux fois join().
Mais c'est possible avec une seule fois une fonction. Comment ?
Je parle de ma devinette.

**tyrtamos** · 27/10/2009, 18h27

Et ça, ça va?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
print '*'+'*'.join('chocolat')+'*'
*c*h*o*c*o*l*a*t*

Tyrtamos

Edit: ah non, s'il ne faut pas de concaténation...

**eyquem** · 27/10/2009, 19h12

Eh non, avec des + ça ne va pas.

C’est artificiel comme devinette, mais c’est pas moi qu’ai commencé, c’est Swinnen.

Rearquez, join() est une concaténation camouflée.
Donc deux fois join(), ça ne va pas
Alors j’y dis la solution avec deux fois join() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
u = 'gaston'
print '*'.join(u).join('**')

Mais il y a une solution avec une seule fonction utilisée une seule fois qui fait ptêt bien de la concaténation cachée, mais on dirait qu’on ferait comme si c’était pas vrai.

**Antoine_935** · 28/10/2009, 00h39

Petite proposition, qui fait usage de ctypes, et ne fait aucune concaténation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> from ctypes import create_string_buffer
>>> 
>>> def doStar(str):
...     l = len(str) * 2
...     b = create_string_buffer(l + 1)
...
...     for i in range(0, l, 2):
...         b[i] = '*'
...         b[i + 1] = str[i / 2]
...
...     b[l] = '*'
...
...     return b.value
...
>>> doStar("chocolat")
'*c*h*o*c*o*l*a*t*'

**josmiley** · 28/10/2009, 04h41

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
a = 'chocolat'
dir(a)

['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

tiens, tiens, à quoi ça sert ça ..... ?
essayons ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

a.replace('','*')

*c*h*o*c*ol*a*t*

mouhahaha, j'ai trouvé.

**eyquem** · 28/10/2009, 12h34

Eh bien, finalement, la question n’était pas si puérile puisqu’elle suscite des réponses intéressantes.

josmiley

. Pas tellement pour la réponse, mais pour la manière rationnelle de la trouver qui fait resortir l’intérêt de l’auto-documentation de Python à laquelle personnellement je ne pense pas assez.

Antoine935, ça ne respecte pas la condition ’en une seule ligne“ que j’ai indiquée en #10, mais pour l’astuce de cette solution et l’aiguillon qu’elle constitue pour s’intéresser au module ctypes :

Quant à moi j’ai trouvé cette solution ainsi:

je me suis demandé comment ferait on avec les expressions régulières et j’ai pensé à la notion d’ «empty string» que j’ai mise longtemps à comprendre.

Il se trouve que print re.sub('\B','*','gaston') marche, en ce sens que ça produit un effet, ça donne bien 'g*a*s*t*o*n'

Mais print re.sub('\b','*','gaston') ne marche pas, parce que \b est en vérité définie comme limite entre \w et \W, la séquence spéciale \w étant équivalente à l’ensemble [a-zA-Z0-9_] et la seconde à [^a-zA-Z0-9_] . Or dans ’gaston’ g est bien \w mais il n’y a pas de \W devant.
De ce fait on ne peut pas faire print re.sub(’\b|\B’,'*','gaston')

Donc avec re, je n’y suis pas arrivé mais ça m’a fait penser à voir ce que ça donnerait avec replace().
C’est pour ça que, dans mon idée, dire «sans expression régulière» consistait aussi bien à fermer une porte vers une possible solution qu’une piste pour entrer dans les expressions régulières et en resotir avec une idée.

Bon, maintenant le problème est:
comment transformer ’gaston’ en ’*g*a*s*t*o*n*’ avec une expression régulières et sub() ??

**Antoine_935** · 28/10/2009, 14h06

Elégante solution que celle de josmiley

Envoyé par eyquem

Antoine935, ça ne respecte pas la condition ’en une seule ligne“ que j’ai indiquée en #10

Arf... avais pas vu cette règle

Ca compte ça ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> str = "chocolat"
>>> exec "l=len(str)*2;b=create_string_buffer(l+1);b[l]='*'\nfor i in range(0, l
, 2):\n\tb[i]='*';b[i+1]=str[i/2]\nprint b.value"
*c*h*o*c*o*l*a*t*

comment transformer ’gaston’ en ’*g*a*s*t*o*n*’ avec une expression régulières et sub() ??

De la même manière qu'avec replace ^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

re.sub("", "*", "gaston")

**eyquem** · 28/10/2009, 14h21

Ah ben fichtre !! Qu’est ce que j’ai foutu dans le module re, moi ?

Je crois que je m’y balade comme dans un dictionnaire, un vrai, genre Larousse: j’y entre pour un mot et j’en resors en ayant vu plein de mots sauf celui que je voulais regarder !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
exec "l=len(str)*2;b=create_string_buffer(l+1);b[l]='*'\nfor i in range(0, l
, 2):\n\tb[i]='*';b[i+1]=str[i/2]\nprint b.value"

Non, ça ne compte pas, il y a plus de 80 caractères.

Optimisation de code

Python

Discussions similaires

Partager

Partager