Expressions régulières et caractères accentués

Version imprimable

Bonjour à tous,

je viens de débuter avec les regexp sous python.

je cherche à matcher des caractères accentués. D'après la doc rien de bien sorcier à condition de compiler ma regexp avec le flag re.LOCALE (si j'ai bien compris à quoi servait ce flag)

Or je n'y suis pas arrivé sans définir explicitement mes caractères sous forme de code point unicode dans ma regex, ce qui finalement annule un peu l'intérêt des regexp...

Voilà mes tests :

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
Python 2.5.2 (r252:60911, Jan  4 2009, 17:40:26)
[GCC 4.3.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import re
>>> import locale
>>> locale.getdefaultlocale()
('fr_FR', 'UTF8')
>>> locale.setlocale(locale.LC_ALL,  None)
'C'
>>> locale.setlocale(locale.LC_ALL,  '')
'fr_FR.UTF-8'
>>> locale.setlocale(locale.LC_ALL,  None)
'fr_FR.UTF-8'
>>> pattern = ur'^\w+$'
>>> pattern
u'^\\w+$'
>>> ro = re.compile(pattern, re.LOCALE)
>>> ro
<_sre.SRE_Pattern object at 0xb7df3520>
>>> import sys
>>> print sys.stdin.encoding
UTF-8
>>> # mo : match object
>>> # premier essai avec une byte string
>>> # 'frédéric' : 'fr\xc3\xa9d\xc3\xa9ric'
>>> # je suppose que python encode cette chaîne utf-8
>>> # en unicode pour le moteur de regex
>>> # du coup la séquence de deux héxa \xc3\xa9 devrait être
>>> # vue comme un seul caractère é
>>> # compiler avec le flag re.LOCALE \w devrait matcher
>>> # ce é
>>> mo = ro.match('frédéric')
>>> type(mo)
<type 'NoneType'>
 
>>> # test en enlevant les ancres de ma regexp
>>> pattern = ur'\w+'
>>> ro = re.compile(pattern, re.LOCALE)
>>> mo = ro.match('frédéric')
>>> type(mo)
<type '_sre.SRE_Match'>
>>> mo.string
'fr\xc3\xa9d\xc3\xa9ric'
>>> mo.group(0)
'fr'
>>> mo.groups()
()
>>> mo.start(0)
0
>>> mo.end(0)
2
>>> mo.group(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: no such group
>>> # le moteur de regexp n'a donc pas reconnu le é
>>> # test : en admettant que python fournisse une chaîne type latin1 (donc la séquence utf-8 est vue comme
>>> # deux caractères non acceptables dans un mot)
>>> # il faut convertir la chaîne à tester en chaîne unicode
>>> mo = ro.match(u'frédéric')
>>> type(mo)
<type '_sre.SRE_Match'>
>>> mo.string
u'fr\xe9d\xe9ric'
>>> mo.group(0)
u'fr'
>>> # la seule solution que j'ai trouvé c'est d'insérer des code point unicode dans
>>> # mon pattern
>>> # voir http://www.regular-expressions.info/python.html
>>> pattern = ur'^\w+\u00E9\w+\u00E9\w+$'
>>> ro = re.compile(pattern)
>>> mo = ro.match(u'frédéric')
>>> type(mo)
<type '_sre.SRE_Match'>
>>> mo.string
u'fr\xe9d\xe9ric'
>>> mo.group(0)
u'fr\xe9d\xe9ric'
>>> # ça marche

Est-ce que j'aurais loupé quelque chose ? (en tout cas j'espère)

merci par avance,

Frédéric

12/06/2009, 01h58
N.tox
Citation:

Or je n'y suis pas arrivé sans définir explicitement mes caractères sous forme de code point unicode dans ma regex

Je connais que très peu les regexp, mais si tu es sous python 2.x pourquoi ne pas encoder les chaines à matcher en utf-8 avant de les matcher avec deux lignes du genre:
Code:

1 2 3 ligne_a_matcher='éèà' try: ligne_a_matcher=ligne_a_matcher.encode('utf-8') except : None
Comme personne ne t'a encore répondu, tu peux toujours essayer... j'éspère que ça fonctionnera ;)

Edit: pour python 3, la manip devrait être différente mais le fond reste le même
12/06/2009, 21h12
fhebert

Salut,
oui je vais essayer ça et poste le résultat

nb. : j'aime bien ta signature, c'est un peu ce que je me dis tous les matins au boulot...

Frédéric

Bon voilà ce que j'ai pu comprendre du fonctionnement des regex et unicode.

note : les tests sont faits avec les locales suivantes :
Code:

1 2 3 4 5 6 7 8 9 10 >>> import locale >>> locale.getdefaultlocale() ('fr_FR', 'UTF8') >>> locale.setlocale(locale.LC_ALL, None) 'C' >>> locale.setlocale(locale.LC_ALL, '') 'fr_FR.UTF-8' >>> locale.setlocale(locale.LC_ALL, None) 'fr_FR.UTF-8'
et l'interpréteur à l'encodage suivant :
Code:

1 2 3 4 >>> import sys >>> print sys.stdin.encoding UTF-8
1°) Visiblement il n'y a pas de conversion implicite par le moteur de regexp des patterns ou strings. ex. :

a°) un pattern byte string matche une byte string, les deux devant être dans l'encodage donné par les locales (ici utf-8) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41) [GCC 4.3.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import re >>> pat = r'frédéric' >>> ro = re.compile(pat) >>> mo = ro.match('frédéric') >>> mo <_sre.SRE_Match object at 0x98959c0> >>> mo.group() 'fr\xc3\xa9d\xc3\xa9ric'
b°) un pattern unicode matche une string unicode :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41) [GCC 4.3.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import re >>> pat = ur'frédéric' >>> ro = re.compile(pat) >>> mo = ro.match(u'frédéric') >>> mo <_sre.SRE_Match object at 0x98959c0> >>> mo.group() 'fr\xe9d\xe9ric'
c°) mais un pattern unicode ne matche pas une byte string et vice versa :
Code:

1 2 3 4 5 6 7 8 9 10 Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41) [GCC 4.3.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import re >>> pat = ur'frédéric' >>> ro = re.compile(pat) >>> mo = ro.match('frédéric') >>> type(mo) NoneType
2°) d'après la doc, les options re.UNICODE et re.LOCALE modifie l'interprétation des caractères spéciaux dans le pattern : \w \W \d \D \s \S \B \b ...
et selon moi l'encodage de la string représentant le pattern est indépendant de l'option choisie

a°) bizarrement :
Code:

1 2 3 4 5 6 7 8 9 10 Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41) [GCC 4.3.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import re >>> pat = r'\w+' >>> ro = re.compile(pat, re.LOCALE) >>> mo = ro.match('frédéric') >>> type(mo) NoneType
b°) avec l'option re.UNICODE et une string unicode, par contre, les caractères spéciaux sont bien interprétés :
Code:

1 2 3 4 5 6 7 8 9 10 Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41) [GCC 4.3.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import re >>> pat = r'\w+' >>> ro = re.compile(pat, re.UNICODE) >>> mo = ro.match(u'frédéric') >>> mo.group() u'fr\xe9d\xe9ric'
c°) logiquement : si ma chaîne est une byte string, python la comprend comme une suite de points de code unicode;
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 >>> pat = r'\w+' >>> ro = re.compile(pat, re.UNICODE) >>> mo = ro.match('frédéric') >>> mo <_sre.SRE_Match object at 0x9895aa0> >>> mo.group() 'fr\xc3' >>> print u'\u00C3' Ã >>> print u'\u00A9' © >>> pat_1 = ur'\w' >>> ro_1 = re.compile(pat_1, re.UNICODE) >>> mo_1 = ro_1.match(u'©') >>> mo_1 >>> type(mo_1) <type 'NoneType'> >>> pat_1 = ur'\W' >>> ro_1 = re.compile(pat_1, re.UNICODE) >>> mo_1 = ro_1.match(u'©') >>> mo_1 <_sre.SRE_Match object at 0x9895ad8> >>> mo_1.group() u'\xa9'
ici, le 'é' est codé en '\xc3\xa9' puisque ma locale est utf-8, python considère donc \xc3 comme un point de code représentant le 'Ã' et matche, alors que le '©' (point de code \xa9) ne matche pas.

Bon week-end,

Frédéric