Discussion :

[____22]

Bonjour

est-ce que vous sauriez comment remplacer dans une chaine

tous les "~56d" par des "#5566dd", occurences de couleurs
changement de ~ en # ok mais je cherche une methode regex pour doubler les valeur rgb

ou sinon si je n'utilise que les "~56d"
j'ai pensé à

Code :

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

1
2
3
s='#0af'
'{1}{1}{2}{2}{3}{3}'.format(*s)
# retourne 00aaff sans le #

[mont29]

Utilise re.sub*:

Code :

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

1
2
3
4
5
6
7
import re
 
test = "~2a3 dummy test ~88c isn't it?"
regex = "~([0123456789abcdefABCDEF])([0123456789abcdefABCDEF])([0123456789abcdefABCDEF])"
re.sub(regex, r"#\1\1\2\2\3\3", t)
 
# donne*: "#22aa33 dummy test #8888cc isn't it?"

[____22]

merci

mais pour des strings simples
quelles solution est la meilleure

Code :

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

1
2
s='~0af'
'#{1}{1}{2}{2}{3}{3}'.format(*s)

Code :

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

1
2
regex = "~[a-fA-F0-9][a-fA-F0-9][a-fA-F0-9]"
re.sub(regex, r"#\1\1\2\2\3\3", s)

[mont29]

Ben, pour des str ne contenant qu’un code couleur et rien d’autre, l’utilisation de format() est très probablement préférable –*ne serait-ce que parce que ça t’évite d’importer re, sans compter un code plus lisible*!

Mais même au niveau des performances, il y a des chances que ça aille plus vite…

[PauseKawa]

Bonjour,

S'il y a pas mal de données à traiter et que le format est fixe ('~000') l'opérateur + est bien plus performant.

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#! /usr/bin/env/ python
# -*- coding: utf-8 -*-
# 
#
import time
import re
 
#def testjoin(s, n):
#    for i in range(0, n):
#        result = '#' + ''.join([i*2 for i in s[1:]])
#    print(result)
 
def testformat(s, n):
    for i in range(0, n):
        result = '#{1}{1}{2}{2}{3}{3}'.format(*s)
    print(result)
 
def testplus(s, n):
    for i in range(0, n):
        result = '#' + 2*s[1] + 2*s[2] + 2*s[3]
    print(result)
 
def testre(s, n):
    r = re
    regex = "~([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])"
    for i in range(0, n):
        result = r.sub(regex, r"#\1\1\2\2\3\3", s)
    print(result)
 
if __name__ == "__main__":
    nb = 1000000
    s = '~0af'
#    print('test join')
#    t1 = time.clock()
#    testjoin(s, nb)
#    t2 = time.clock()
#    print(t2-t1)
    print('test format')
    t1 = time.clock()
    testformat(s, nb)
    t2 = time.clock()
    print(t2-t1)
    print('test plus:')
    t1 = time.clock()
    testplus(s, nb)
    t2 = time.clock()
    print(t2-t1)
    print('test re:')
    t1 = time.clock()
    testre(s, nb)
    t2 = time.clock()
    print(t2-t1)

Python 3.1

Code :

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

1
2
3
4
5
6
7
8
9
test format
#00aaff
2.45
test plus:
#00aaff
1.74
test re:
#00aaff
36.75

Python 2.6

Code :

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

1
2
3
4
5
6
7
8
9
test format
#00aaff
3.29
test plus:
#00aaff
1.21
test re:
#00aaff
27.52

Cela n’enlève rien à la lisibilité de format.

@+

[PauseKawa]

Re,

Petit complément sur la même idée.

Moins rapide mais plus Python : join.

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#! /usr/bin/env/ python
# -*- coding: utf-8 -*-
# 
#
import time
import re
 
def testjoin(s, n):
    for i in range(0, n):
        result = ''.join(('#', s[1], s[1], s[2], s[2], s[3], s[3]))
    print(result)
 
def testjoinx(s, n):
    for i in range(0, n):
        result = ''.join(('#', 2*s[1], 2*s[2], 2*s[3]))
    print(result)
 
def testformat(s, n):
    for i in range(0, n):
        result = '#{1}{1}{2}{2}{3}{3}'.format(*s)
    print(result)
 
def testplus(s, n):
    for i in range(0, n):
        result = '#' + 2*s[1] + 2*s[2] + 2*s[3]
    print(result)
 
def testre(s, n):
    r = re
    regex = "~([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])"
    for i in range(0, n):
        result = r.sub(regex, r"#\1\1\2\2\3\3", s)
    print(result)
 
if __name__ == "__main__":
    nb = 1000000
    s = '~0af'
    print('test join')
    t1 = time.clock()
    testjoin(s, nb)
    t2 = time.clock()
    print(t2-t1)
    print('test join plus *')
    t1 = time.clock()
    testjoinx(s, nb)
    t2 = time.clock()
    print(t2-t1)
    print('test format')
    t1 = time.clock()
    testformat(s, nb)
    t2 = time.clock()
    print(t2-t1)
    print('test plus:')
    t1 = time.clock()
    testplus(s, nb)
    t2 = time.clock()
    print(t2-t1)
    #print('test re:')
    #t1 = time.clock()
    #testre(s, nb)
    #t2 = time.clock()
    #print(t2-t1)

Python 3.1

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
test join
#00aaff
1.56
test join plus *
#00aaff
1.6
test format
#00aaff
2.44
test plus:
#00aaff
1.66

Python 2.6

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
test join
#00aaff
1.58
test join plus *
#00aaff
1.57
test format
#00aaff
3.35
test plus:
#00aaff
1.28

@+

[mont29]

Héhé, j’ai testé ton code chez moi, PauseKawa, et voici ce que j’obtiens*:

Python 2.6*:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
test join
#00aaff
0.75
test join plus *
#00aaff
0.9
test format
#00aaff
1.77
test plus:
#00aaff
0.74

Python 3.2*:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
test join
#00aaff
0.52
test join plus *
#00aaff
0.59
test format
#00aaff
0.9700000000000002
test plus:
#00aaff
0.71

(Comme quoi, py3k n’est pas toujours plus lent que py2 )

Pypy 1.5*:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
test join
#00aaff
0.652041
test join plus *
#00aaff
0.348022
test format
#00aaff
2.224139
test plus:
#00aaff
0.128008

[PauseKawa]

Je confirme que mon ordi est un bourrin.

[rambc]

Bonjour.

Pour info., sur mon Mac O$, j'obtiens :

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
---------------------
python2.7 (enthought)
---------------------
 
#00aaff
0.974596
test join plus *
#00aaff
1.112493
test format
#00aaff
2.108912
test plus:
#00aaff
0.942704
 
---------
python3.2
---------
 
test join
#00aaff
0.709512
test join plus *
#00aaff
0.758019
test format
#00aaff
1.3495789999999999
test plus:
#00aaff
0.6739509999999997

[mont29]

C’est bizarre que j’obtienne un si bon score pour join() sous py3k…

[PauseKawa]

Ce qui confirme (Sauf les résultats de mont29 sous 3.2) que

Code :

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

result = '#' + 2*s[1] + 2*s[2] + 2*s[3]

est bien plus rapide.
Cela me semble normal puisqu'on ne fait appel qu'à un opérateur (pas de built in, import etc).
Mais c'est vrais que c'est moche
Les différences avec format montre que le code est optimiser (sans doute la réponse aux résultats sous Python 3.2). Normal puisqu'il est sensé remplacer le formatage avec % sous Python 3.

Edit: sans doute la réponse aux résultats sous Python 3.2 pour join

[____22]

ben merci pour ces reponses plus que completes

je vais prendre la concatenation +

[PauseKawa]

Bonjour,

Perso je préfère ceci:
result = '#%s%s%s'%(2*s[1], 2*s[2], 2*s[3])

@+