regex - simple

Version imprimable

15/07/2011, 17h45
____22

regex - simple
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:

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

Utilise re.sub*:

Code:

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?"

;)

merci

mais pour des strings simples
quelles solution est la meilleure
Code:

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

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)

16/07/2011, 08h59
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*! :P

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

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:

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:

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:

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.

@+

Re,

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

Moins rapide mais plus Python : join.

Code:

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:

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:

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

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

Python 2.6*:
Code:

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:

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:

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

16/07/2011, 15h00
PauseKawa

Je confirme que mon ordi est un bourrin.

Bonjour.

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

Code:

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

16/07/2011, 15h10
mont29

C’est bizarre que j’obtienne un si bon score pour join() sous py3k… :calim2:
16/07/2011, 15h36
PauseKawa

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

Code:

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
16/07/2011, 16h47
____22

ben merci pour ces reponses plus que completes

je vais prendre la concatenation +
16/07/2011, 19h17
PauseKawa

Bonjour,

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

@+