Discussion :

[tittoto]

Bonjour à tous,

J'ai un petit soucis avec l'utilisation des regex pour extraire quelques blocs d'une page HTML.

Cette page que je récupère liste plusieurs objets. Le code HTML les représentant est identique et à la forme suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
<img src="URL_1_TO_PARSE" style...></a>
... Diverses balise HTML
				</tr>
... Diverses balise HTML

	<td nowrap="nowrap">
		
		<a href="URL_2_TO_PARSE">
		"TEXT_1_TO_PARSE"</a>

<br>
		"TEXT_2_TO_PARSE"

Récupérer l'URL 1 n'est pas un problème. Les autres aussi d'ailleurs.. Seulement, je n'arrive pas à récupérer toutes les valeurs qui m'intéressent d'un coup. C'est à dire que je n'arrive pas à créer ma regex de telle sorte de lui dire :

Code :

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

1
2
<img src=\"(.*/thumbs/[0-9]*.jpg)\" // Get URL_1_TO_PARSE
n'importe quoi JUSQUE <a href="MA_REGEX_POUR_URL_2_TO_PARSE

Je bloque sur le "n'importe quoi jusqu'une certaine chaîne". J'ai essayé [\w\s\S]*, mais il prend tous le reste du code avec cette regex (normale..).

Quelqu'un aurait une idée ?

Merci :-)

[kango]

bonjour,

"n'importe quoi jusqu'une certaine chaîne" = r"\.*CERTAINECHAINE"

[eyquem]

Bonjour,



J’aimerais savoir ce qu’il y a réellement à la place des
... Diverses balise HTML
leur nombre,
si les tabulations en tête sont toujours les mêmes.



Plus bas
<td nowrap="nowrap"> est précédé d’une tabulation ’\t’
<a href="URL_2_TO_PARSE"> est précédé de deux tabulations ’\t\t’
Cela se voit en sélectionnant le texte.
Ces tabulations sont -elles fixes ?



Le problème , quand on doit capturer des choses qui s’étalent sur plusieurs lignes, c’est de savoir comment on fait passer les fins de ligne au moteur de regex:
- par le métacaractère point avec l’option re.MULTILINE
- ou par une écriture de caractèes ’\n’ aux bons endroits
- ou par ’\s’ , car j’ai pris conscience récemment que ’\s’ matche avec ’\n’






Pourquoi y a-t-il ’//’ dans le code ?
En Python, les commentaires sont ouverts dans une ligne par ’#’







’\s’ matche les caractères ’\f’ , ’\n’ , ’\r’ , ’\t’ , ’\v’
’\S’ tous les caractères différents ’\f’ , ’\n’ , ’\r’ , ’\t’ , ’\v’
Donc [\s\S] matche avec n’importe quel caractère -> intérêt = zéro
Et au passage ajouter \w dans [\s\S] c’est inutile au carré.

[kango]

bonjour,

"n'importe quoi jusqu'une certaine chaîne" = r".*CERTAINECHAINE"

désolé, je me suis trompé. Pas d'anti-slash devant le point.

[eyquem]

kango,

sans option re.MULTILINE , le point ne matche pas avec ’\n’

r".*CERTAINECHAINE" ne va donc pas matcher s’il y a des fins de ligne entre la position où débute l’application de cette RE et ’CERTAINECHAINE’

Mais de mon point de vue, ce n’est pas très bon de rendre le métacaractère point apte à matcher ’\n’ sans savoir ce qu’il peut y avoir entre <img src="URL_1_TO_PARSE" style...></a> et <a href="URL_2_TO_PARSE">

On risque de noyer dans un matching avec .* des trucs inatendus qu’il vaudrait mieux traiter pour ce qu’ils sont au lieu de passer éventuellement dessus sans s’apercevoir des bizarreries inatendues. Les regex sont tellement compliquées et parfois surprenantes que je me méfie.


PS
Pour ne pas être mal compris:
je suis partisan d’écrire dans les RE le maximum de caractères littéraux, pour les rendre précises, efficaces et rapides.
"Le maximum“, ça veut dire “le plus qu’il soit possible“ (sans blague ?...)
Car évidemment il y a des limites, sinon, s’il n’y avait pas de variabilité dans les chaînes qu’on veut soumettre à regex, il n’y aurait pas besoin de regex.
Quand on atteint les limites, on recourt au point et autres symboles polysémiques. Mais pas avant, de mon point de vue.

[tittoto]

Pour répondre à tes questions, je poste le bloc exacte qui se répète dans le code :

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
	<td class="Img">
			
		<table class="ct">
			<tbody>
				<tr>				
					<a href="/link.html"><img src="URL_1_TO_PARSE" border="0" alt="Description"></a>
					

					</td>
					<td valign="top" class="emr"><img src="/img/thumb_extra_m.gif" /></td>
				</tr>
				<tr>
					<td></td>
					<td valign="top" class="ebc"><img src="/img/thumb_extra_l.gif"></td>

					<td><img src="/img/thumb_extra_r.gif"></td>
				</tr>
			</tbody>
		</table>
	
	</td>
	<td nowrap="nowrap">
		
		<a href="URL_2_TO_PARSE">
		TEXT_1_TO_PARSE</a>

<br>
		TEXT_2_TO_PARSE
		
	</td>

Bonjour,

J’aimerais savoir ce qu’il y a réellement à la place des
... Diverses balise HTML
leur nombre,
si les tabulations en tête sont toujours les mêmes.

Les tabulations sont effectivement toujours les mêmes.

Plus bas
<td nowrap="nowrap"> est précédé d’une tabulation ’\t’
<a href="URL_2_TO_PARSE"> est précédé de deux tabulations ’\t\t’
Cela se voit en sélectionnant le texte.
Ces tabulations sont -elles fixes ?

Oui.

Le problème , quand on doit capturer des choses qui s’étalent sur plusieurs lignes, c’est de savoir comment on fait passer les fins de ligne au moteur de regex:
- par le métacaractère point avec l’option re.MULTILINE
- ou par une écriture de caractèes ’\n’ aux bons endroits
- ou par ’\s’ , car j’ai pris conscience récemment que ’\s’ matche avec ’\n’

J'ai justement pensé à réécrire toutes les lignes en passant les espaces et sauts de lignes avec "\s". Mais.. vu le nombre de balise entre chaque bloc devant être capturé, j'ai peur que cela pèse en terme de perf :-/. Non ?
D'où mon idée de passer toutes les balises entre le 1er et second bloc "jusqu'à" rencontrer une chaîne qui indique l'arrivé du prochain bloc.

Pourquoi y a-t-il ’//’ dans le code ?
En Python, les commentaires sont ouverts dans une ligne par ’#’

Désolé, j'ai écris rapidement et je n'ai pas fait attention à respecter la syntaxe python


Enfin, concernant le flag MULTILINE. J'ai tenté, mais comme tu le précises, pas adapté à mon besoin.

[eyquem]

Merci.
Ce qui serait bien c’est d’avoir la chaîne du code non interprétée, pour confirmation. C’est à dire quelque chose comme

'\t<td class="Img">\n\t\t\t\n<table class="ct">\n\t\t\t<tbody>\n\t\t\t\t<tr>\t\t\t\t\n\t\t\t\t\t<a href="/link.html"><img src="URL_1_TO_PARSE" border="0" alt="Description"></a>\n\t\t\t\t\t\n\n\t\t\t\t\t</td>\n\t\t\t\t\t<td valign="top" class="emr"><img src="/img/thumb_extra_m.gif" /></td>\n\t\t\t\t</tr>\n\t\t\t\t<tr>\n....'


J’ai reconstitué ça en sélectionnant le texte, mais c’est du bricolage.





C’est important.

Par exemple, après le premier '<tr>' il y a des ’\t’
Mais pas après le second '<tr>' .
Pour quelle raison ? C’est le texte du code qui est originellement ainsi ou c’est introduit par mégarde lors de copier-coller ?

De même , après la première ligne contenant '<a href="/link.html"><img etc' , la ligne blanche suivante comporte en fait 5 ’\t’. C’est normal ?







Bon, en fait j’ai fait un copier-coller de ton texte et

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
code = '''     <td class="Img">
                        
                <table class="ct">
                        <tbody>
                                <tr>                            
                                        <a href="/link.html"><img src="URL_1_TO_PARSE" border="0" alt="Description"></a>
                                        
 
                                        </td>
                                        <td valign="top" class="emr"><img src="/img/thumb_extra_m.gif" /></td>
                                </tr>
                                <tr>
                                        <td></td>
                                        <td valign="top" class="ebc"><img src="/img/thumb_extra_l.gif"></td>
 
                                        <td><img src="/img/thumb_extra_r.gif"></td>
                                </tr>
                        </tbody>
                </table>
        
        </td>
        <td nowrap="nowrap">
                
                <a href="URL_2_TO_PARSE">
                TEXT_1_TO_PARSE</a>
 
<br>
                TEXT_2_TO_PARSE
                
        </td>'''
 
print repr(code)

et ça m’a donné ceci:

'\t<td class="Img">\n\t\t\t\n\t\t<table class="ct">\n\t\t\t<tbody>\n\t\t\t\t<tr>\t\t\t\t\n\t\t\t\t\t<a href="/link.html"><img src="URL_1_TO_PARSE" border="0" alt="Description"></a>\n\t\t\t\t\t\n\n\t\t\t\t\t</td>\n\t\t\t\t\t<td valign="top" class="emr"><img src="/img/thumb_extra_m.gif" /></td>\n\t\t\t\t</tr>\n\t\t\t\t<tr>\n\t\t\t\t\t<td></td>\n\t\t\t\t\t<td valign="top" class="ebc"><img src="/img/thumb_extra_l.gif"></td>\n\n\t\t\t\t\t<td><img src="/img/thumb_extra_r.gif"></td>\n\t\t\t\t</tr>\n\t\t\t</tbody>\n\t\t</table>\n\t\n\t</td>\n\t<td nowrap="nowrap">\n\t\t\n\t\t<a href="URL_2_TO_PARSE">\n\t\tTEXT_1_TO_PARSE</a>\n\n<br>\n\t\tTEXT_2_TO_PARSE\n\t\t\n\t</td>'

À partir de quoi j’ai écrit une RE
- en gardant ce qu’on peut supposer être stable
- en symbolisant par .+? les parties qui risquent d’être variables
- et en attrapant ce qu’on veut avec (.+?)

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
import re
 
code = '''     <td class="Img">
                        
                <table class="ct">
                        <tbody>
                                <tr>                            
                                        <a href="/link.html"><img src="URL_1_TO_PARSE" border="0" alt="Description"></a>
                                        
 
                                        </td>
                                        <td valign="top" class="emr"><img src="/img/thumb_extra_m.gif" /></td>
                                </tr>
                                <tr>
                                        <td></td>
                                        <td valign="top" class="ebc"><img src="/img/thumb_extra_l.gif"></td>
 
                                        <td><img src="/img/thumb_extra_r.gif"></td>
                                </tr>
                        </tbody>
                </table>
        
        </td>
        <td nowrap="nowrap">
                
                <a href="URL_2_TO_PARSE">
                TEXT_1_TO_PARSE</a>
 
<br>
                TEXT_2_TO_PARSE
                
        </td>'''
 
RE = ('\t<td class="Img">\n\t\t\t\n'
      '\t\t<table class="ct">\n'
      '\t\t\t<tbody>\n'
      '\t\t\t\t<tr>\t\t\t\t\n'
      '\t\t\t\t\t<a href="/link.html"><img src="(.+?)" border="0" alt="Description"></a>\n'
      '\t\t\t\t\t\n\n'                          # ^ URL_1_TO_PARSE
      '\t\t\t\t\t</td>\n'
      '\t\t\t\t\t<td valign="top" class="emr"><img src=".+?" /></td>\n'
      '\t\t\t\t</tr>\n'
      '\t\t\t\t<tr>\n'
      '\t\t\t\t\t<td></td>\n'
      '\t\t\t\t\t<td valign="top" class="ebc"><img src=".+?"></td>\n\n'
      '\t\t\t\t\t<td><img src=".+?"></td>\n'
      '\t\t\t\t</tr>\n'
      '\t\t\t</tbody>\n'
      '\t\t</table>\n'
      '\t\n'
      '\t</td>\n'
      '\t<td nowrap="nowrap">\n\t\t\n'
      '\t\t<a href="(.+?)">\n' # URL_2_TO_PARSE
      '\t\t(.+?)</a>\n\n' # TEXT_1_TO_PARSE
      '<br>\n'
      '\t\t(.+?)\n' # TEXT_2_TO_PARSE
      '\t\t\n'
      '\t</td>')
 
pat = re.compile(RE)
print 'repr(code) =\n',repr(code)
print '\npat.findall(code) =',pat.findall(code)

Ce qui donne:

repr(code) =
'\t<td class="Img">\n\t\t\t\n\t\t<table class="ct">\n\t\t\t<tbody>\n\t\t\t\t<tr>\t\t\t\t\n\t\t\t\t\t<a href="/link.html"><img src="URL_1_TO_PARSE" border="0" alt="Description"></a>\n\t\t\t\t\t\n\n\t\t\t\t\t</td>\n\t\t\t\t\t<td valign="top" class="emr"><img src="/img/thumb_extra_m.gif" /></td>\n\t\t\t\t</tr>\n\t\t\t\t<tr>\n\t\t\t\t\t<td></td>\n\t\t\t\t\t<td valign="top" class="ebc"><img src="/img/thumb_extra_l.gif"></td>\n\n\t\t\t\t\t<td><img src="/img/thumb_extra_r.gif"></td>\n\t\t\t\t</tr>\n\t\t\t</tbody>\n\t\t</table>\n\t\n\t</td>\n\t<td nowrap="nowrap">\n\t\t\n\t\t<a href="URL_2_TO_PARSE">\n\t\tTEXT_1_TO_PARSE</a>\n\n<br>\n\t\tTEXT_2_TO_PARSE\n\t\t\n\t</td>'

pat.findall(code) = [('URL_1_TO_PARSE', 'URL_2_TO_PARSE', 'TEXT_1_TO_PARSE', 'TEXT_2_TO_PARSE')]

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

Mais ce n’est pas fini.

Il faut s’assurer que la regex n’est pas trop restrictive et qu’elle est adaptée à tous les cas de code dans lesquels on veut attraper les 3 chaines en question


Ainsi, entre <table class="ct"> et </table> , n’y a-t-il bien toujours qu’une balise <tbody> </tbody> ?


Dans une balise <tbody> </tbody> , n’y a-t-il toujours que deux balises <tr> </tr> ?


Pourquoi y a-t-il un <br> qui se balade tout seul avant la ligne TEXT_1_TO_PARSE</a> ?



À la 9 ième ligne, le premier </td> n’est pas précédé d’un <td> quelque part.



y a-t-il toujours les lignes avec
<img src="/img/thumb_extra_m.gif" />
<img src="/img/thumb_extra_l.gif">
<img src="/img/thumb_extra_r.gif">
?

Y en a-t-il des supplémentaires ?

J'ai justement pensé à réécrire toutes les lignes en passant les espaces et sauts de lignes avec "\s".

Mais ce qui n’est pas espaces et fin de ligne ??

vu le nombre de balise entre chaque bloc devant être capturé, j'ai peur que cela pèse en terme de perf :-/. Non ?
D'où mon idée de passer toutes les balises entre le 1er et second bloc "jusqu'à" rencontrer une chaîne qui indique l'arrivé du prochain bloc.

Il est plus efficace et donc plus performant de passer d’un bloc recherché au suivant en indiquant dans la RE les caractères les plus précis possibles qui seront rencontrés, que de faire avancer le moteur de regex avec .+?

concernant le flag MULTILINE. J'ai tenté, mais comme tu le précises, pas adapté à mon besoin.

J’ai fait une confusion. C’est DOTALL qui fait matcher le métacaractère point avec ’\n’ , et non pas MULTILINE. Excuse.

On peut rendre tel le point, ça marche aussi.

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
RE2 = ('\t<td class="Img">.+?'
      '<table class="ct">.+?'
      '<tbody>.+?'
      '<tr>.+?'
      '<a href="/link.html"><img src="(.+?)" border="0" alt="Description"></a>'
      '.+?'                          # ^ URL_1_TO_PARSE
      '<a href="(.+?)">\n' # URL_2_TO_PARSE
      '\t\t(.+?)</a>\n\n' # TEXT_1_TO_PARSE
      '<br>\n'
      '\t\t(.+?)\n' # TEXT_2_TO_PARSE
      '\t\t\n'
      '\t</td>')
 
pit = re.compile(RE2,re.DOTALL)
print '\npit.findall(code) =',pit.findall(code)

Mais j’aime moins. Si on fait une comoparaison de performance, cette solution sera moins rapide.Et je ne vois pas comment faire autrement qu’indiquer '\t\t’ devant TEXT_1_TO_PARSE et TEXT_2_TO_PARSE
ainsi que ’\n’ après TEXT_2_TO_PARSE






Dernière possibilité aussi

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
RE3 = ('\t<td class="Img">[\n\t]+'
      '<table class="ct">[\n\t]+'
      '<tbody>[\n\t]+'
      '<tr>[\n\t]+'
      '<a href="/link.html"><img src="(.+?)" border="0" alt="Description"></a>[\n\t]+'
      '</td>[\n\t]+'                          # ^ URL_1_TO_PARSE
      '<td valign="top" class="emr"><img src=".+?" /></td>[\n\t]+'
      '</tr>[\n\t]+'
      '<tr>[\n\t]+'
      '<td></td>[\n\t]+'
      '<td valign="top" class="ebc"><img src=".+?"></td>[\n\t]+'
      '<td><img src=".+?"></td>[\n\t]+'
      '</tr>[\n\t]+'
      '</tbody>[\n\t]+'
      '</table>[\n\t]+'
      '</td>[\n\t]+'
      '<td nowrap="nowrap">[\n\t]+'
      '<a href="(.+?)">[\n\t]+' # URL_2_TO_PARSE       
      '(.+?)</a>[\n\t]+' # TEXT_1_TO_PARSE
      '<br>[\n\t]+'
      '(.+?)[\n\t]+' # TEXT_2_TO_PARSE
      '</td>' )

Ce sera un petit peu moins rapide qu'avec RE mais plus qu'avec RE2.
Avantage: s’il y a des variations dans les nombres de ’\t’, ce sera absorbé par [\t\n]+ sans empêcher le matching




J’attends le retour sur tout ça.

[tittoto]

Merci.

Je regarde tous ça tête reposé, car on commence à cramer au bureau !
Apres essai, je reviendrais vers toi

[Zavonen]

J'ai un petit soucis avec l'utilisation des regex pour extraire quelques blocs d'une page HTML.

Pourquoi réinventer la roue ?
Il existe des bibliothèques chargées d'analyser le code html et qui connaissent a priori toutes les balises.
Un exemple parmi d'autres: "beautifulsoup"
Doc sur le produit

[tittoto]

@eyquem
Merci ça fonctionne correctement. J'ai opté pour la dernière méthode pour absorber les possibles variations de tabulations et sauts de lignes.

@Zavonen
Je connais bien ce dernier, mais (j'aurais du le préciser), j'ai choisie une regex, car mon application sera portée sur Android par la suite. Et pour le moment, je n'ai trouvé aucun parseur adaptée sur cet environnement.

Je cloture le post. Encore Merci