variable dynamiquement indexée

Bonjour,

C'est pour ça que je parle, maladroitement, de nom de variables dynamique.

Et surtout que vous évitez soigneusement de répondre à la question :
pourquoi faire ?

Arf, oui, c'est vrai, désolé.
Mon projet est d'alimenter une FAQ (PHP+Mysql) à partir d'une fichier
*.tex très simple. Pour info, c'est une FAQ "droit et TICE".

Le *.tex ressemble par endroits à ça :
###########
[...]
section{Sites web des étab scolaires}

Ici on va parler de ce qui est dans le titre

subsection{Puis-je mettre la photo d'un élève sur la page d'acc ?}

Et ben non, car d'après l'article XXX du code tant et d'après telle
jurisprudence et le bon sens !...

subsection{Que dois-je faire avec les "logs" de
connexion Internet des utilisateurs ?}

les diffuser dans la presse locale...
############

Pour cela, un script python m'enverrai les titre des sections, texte
d'intro de section, titres de subsection, réponse dans un base de
données et ce de manière +/- automatisée...

On m'a conseillé de d'abord le convertir en xml valide (mais pas plus)
d'où mes questions actuelles. Pourquoi ? Car en xml, il serait plus
facilement manipulable par python (pleins de modules faits pour) pour le
convertir, à nouveau, en un fichier sql prêt à être envoyé dans la db.

J'ai pour le moment découpé mon texte en tranches avec :
###########
sect = r'\section{(.*)}'
Je suppose qu'il faut lire :

sect = r'section{(.*)}'
pour n'avoir qu'une barre iclinée inverse au début.

motif1 = re.compile(sect)
contents_list = re.split(motif1,contents)
Avec la dite « regexp » vous n'avez pas de subsection

Je n'ai pas la doc sous les yeux mais il me semble que .spli est aussi
une méthode d'un objet « re », ici motif1. Tant qu'à faire, frimez un
peu et tenter motif1.finditer() :-) (Le help(motif.finditer) ne donne
rien)

###########

contents_list est une liste du type :
['Intro','titre section1', 'texte section1 avec les
subsections','section2'....]
Vous avez vérifié directement avec l'interpréteur (lancer python -i

script_de_test.py et print contents_list[:3] ..)

J'ai essayé ça :

############
dict = {}
for item in contents_list:
dict["s_%d" % len(dict)] = item
for i in dict: exec(i+"=dict[i]") # permet de créer les s_i
############
et maintenant, je pense que cela sera plus simpe à "xmliser" (à coups de
sub())en traitant plus ou moins séparemment les s_i...mais peut-être que
je fais fausse route ?
Et comment ! Si j'étais votre prof et que vous me donniez une copie

avec de telles âneries, vous auriez droit à un beau zéro pointé. :-)

J''espère ne pas avoir été trop long...
Merci en tout cas.
Rémi

Bon reprenons. Je suppose que par la magie des expressions régulières
(ou tout simplement en utilisant des tests du genre if
line.startswith(r'section{'): vous arrivez à obtenir « contents_list »
c'est-à-dire si je ne m'abuse une séquence de chaînes de caractères avec
en premier ce qui est avant le première section, puis le titre de
section suivi de son contenu et ainsi de suite pour les sections
suivantes. En bricolant l'expression régulière de départ ou mieux en
appliquant une re basée sur r'subsection{(*)}' aux éléments d'indices
2, 4, ... vous pouvez affiner ladite partie du document et donc insérer
les éléments XML correspondants aux sous-sections.
Autrement dit : contents_list[0] va se placer dans un « tag »
"introduction" ou je ne sais quoi
from cStringIO import StringIO
fout = StringIO()
fout.write('header XMLn') # plein de lignes magiques pour déclarer
document XML
fout.write('<intro>%s</intro>n' % contents_list[0] )
print fout.getvalue()
# donne :
header XML
<intro>c'est l'intro</intro>

On se définit un petit générateur pour regrouper deux par deux les
informations relatives à une section (il aurait été préférable de ne pas
saboter la structure au moment de la construction de contents_list et de
mettre un tuple (titre, contenu) dans chaque « case » de la liste au
lieu d'utiliser deux cases)
def pardeux(iterable, n=2):
"""renvoie les items de la séquence groupés deux par deux (ou par
n)"""
it = iter(iterable)
next = it.next
while True:
yield next(), next()

# Traitement pour une section :
for titre, contenu in pardeux(contents_list[1:]):
# ouvrir un élément avec tag correspondant à section, avec un
# attribut titre="%s" (ou un début de contenu faudrait nous
# expliquer précisément la sortie)
# éclater contenu en sous-sections et écrire les informations avec
# les tags correspondant aux dites sous-sections
# fermer la section courante "</%s>n" % (tag_de_section,)

Bref, rien que de la programmation simple, aux ras des pâquerettes,
séquences toutes bêtes, même pas de dictionnaire.
De toutes manières pour le chef, vous dites que vous utilisez les
dernières techniques à la mode : générateurs, itérateurs, XML, DOM,
métaclasses et décorateurs et cela devrait être suffisamment «
buzzword compliant » pour demander une augmentation ou au moins
justifier les retards (vous attendez toujours cette formation aux
métaclasses n'est-ce-pas ?)
En pratique, terminez toujours vos modules avec
if __name__ == '__main__':
"""quelques tests évidents qui montrent l'utilisation du module"""
seq = ....
print ....
Et n'hésitez pas à essayer avec python -i NomDuModule.py

On Tue, 29 Mar 2005 21:37:35 +0200, remi <remi@non.com> wrote:

Bonjour,

Arf, oui, c'est vrai, désolé.
Mon projet est d'alimenter une FAQ (PHP+Mysql) à partir d'une fichier
*.tex très simple. Pour info, c'est une FAQ "droit et TICE".

Rien à voir avec Python, mais es-tu sûr que ce format soit un bon
choix ?

Personnellement, je trouve que la page html unique est le format
fonctionnellement le plus riche pour une FAQ.

Evidemment, ça suppose que le lecteur maîtrise les fonctions de
recherche de son navigateur.

--
Yves

On Tue, 29 Mar 2005 21:37:35 +0200, remi <remi@non.com> wrote:

Bonjour,

Arf, oui, c'est vrai, désolé.
Mon projet est d'alimenter une FAQ (PHP+Mysql) à partir d'une fichier
*.tex très simple. Pour info, c'est une FAQ "droit et TICE".

Rien à voir avec Python, mais es-tu sûr que ce format soit un bon
choix ?

Disons que je maîtrise assez bien LaTeX et que je peux le convertir en
*.pdf, *.ps, *.sxw et aussi *.html voire *.xml (mais avec un code trop
touffu). Les fichiers *.tex sont très petits. Une faq de 12 pages fait
22 Ko.
Rémi.

Personnellement, je trouve que la page html unique est le format
fonctionnellement le plus riche pour une FAQ.

Evidemment, ça suppose que le lecteur maîtrise les fonctions de
recherche de son navigateur.

On Wed, 30 Mar 2005 19:28:07 +0200, remi <remi@non.com> wrote:

Disons que je maîtrise assez bien LaTeX et que je peux le convertir en
*.pdf, *.ps, *.sxw et aussi *.html voire *.xml (mais avec un code trop
touffu). Les fichiers *.tex sont très petits. Une faq de 12 pages fait
22 Ko.

En fait je pensais au format PHP + Mysql.
Par exemple, certaines Faq de Free sont faites comme ça, par exemple:

http://questions.free.fr/index.php?sid˜969&aktion=anzeigen&rubrik1004

Franchement, je n'aime pas ça. On ne peut pas les exploiter
efficacement.

Sinon LaTeX, non, très bien.

--
Yves

Bonjour et merci pour votre réponse !
Que les dieux vous accompagnent ! ;-)

###########
sect = r'\section{(.*)}'

Je suppose qu'il faut lire :
sect = r'section{(.*)}'
pour n'avoir qu'une barre iclinée inverse au début.

Euh, non, c'est bien ça à cause du "backslash plague" ;-)
http://www.amk.ca/python/howto/regex/regex.html#SECTION000420000000000000000

motif1 = re.compile(sect)
contents_list = re.split(motif1,contents)

Avec la dite « regexp » vous n'avez pas de subsection
Je n'ai pas la doc sous les yeux mais il me semble que .spli est aussi
une méthode d'un objet « re », ici motif1. Tant qu'à faire, frimez un
peu et tenter motif1.finditer() :-) (Le help(motif.finditer) ne donne
rien)

###########

contents_list est une liste du type :
['Intro','titre section1', 'texte section1 avec les
subsections','section2'....]

Vous avez vérifié directement avec l'interpréteur (lancer python -i
script_de_test.py et print contents_list[:3] ..)

J'ai essayé ça :

############
dict = {}
for item in contents_list:
dict["s_%d" % len(dict)] = item
for i in dict: exec(i+"=dict[i]") # permet de créer les s_i
############
et maintenant, je pense que cela sera plus simpe à "xmliser" (à coups de
sub())en traitant plus ou moins séparemment les s_i...mais peut-être que
je fais fausse route ?

Et comment ! Si j'étais votre prof et que vous me donniez une copie
avec de telles âneries, vous auriez droit à un beau zéro pointé. :-)

lol mais msieur ?! Je sais faire un dictionnaire au moins ! ;-)

J''espère ne pas avoir été trop long...
Merci en tout cas.
Rémi

Bon reprenons. Je suppose que par la magie des expressions régulières
(ou tout simplement en utilisant des tests du genre if
line.startswith(r'section{'): vous arrivez à obtenir « contents_list »
c'est-à-dire si je ne m'abuse une séquence de chaînes de caractères avec
en premier ce qui est avant le première section, puis le titre de
section suivi de son contenu et ainsi de suite pour les sections
suivantes.

Toutafé.

En bricolant l'expression régulière de départ ou mieux en
appliquant une re basée sur r'subsection{(*)}' aux éléments d'indices
2, 4, ... vous pouvez affiner ladite partie du document et donc insérer
les éléments XML correspondants aux sous-sections.

Oui, c'est le but. En plus, les titres de sections sont dans les indices
pairs...

Autrement dit : contents_list[0] va se placer dans un « tag »
"introduction" ou je ne sais quoi
from cStringIO import StringIO
fout = StringIO()
fout.write('header XMLn') # plein de lignes magiques pour déclarer
document XML

Si j'ai bien compris, le module StringIO permet de créer un fichier mais
dans la mémoire vive ? C'est donc plus rapide...

fout.write('<intro>%s</intro>n' % contents_list[0] )
print fout.getvalue()
# donne :
header XML
<intro>c'est l'intro</intro>

On se définit un petit générateur pour regrouper deux par deux les
informations relatives à une section (il aurait été préférable de ne pas
saboter la structure au moment de la construction de contents_list et de
mettre un tuple (titre, contenu) dans chaque « case » de la liste au
lieu d'utiliser deux cases)

Hum... Une liste composée de couples

def pardeux(iterable, n=2):
"""renvoie les items de la séquence groupés deux par deux (ou par
n)"""
it = iter(iterable)
next = it.next
while True:
yield next(), next()

J'ai pas tout compris là mais bon...

# Traitement pour une section :
for titre, contenu in pardeux(contents_list[1:]):
# ouvrir un élément avec tag correspondant à section, avec un
# attribut titre="%s" (ou un début de contenu faudrait nous
# expliquer précisément la sortie)
# éclater contenu en sous-sections et écrire les informations avec
# les tags correspondant aux dites sous-sections
# fermer la section courante "</%s>n" % (tag_de_section,)

Bref, rien que de la programmation simple, aux ras des pâquerettes,
séquences toutes bêtes, même pas de dictionnaire.

C'est bien plus simple donc c'est plus joli. Dire que je m'étais lancé
dans une numérotation "dynamique" des variables ! En tout cas, c'était
très formateur (surtout pour un newbie mauvais élève comme moi ;-))
Voici le code obtenu avec cette aide (très) précieuse :
Allez, je colle tout (cela peut servir à d'autres), tous les
commentaires sont les bienvenus !
#####################
# -*- coding: Latin-1 -*-
import re # importation du module RE
#
http://www.amk.ca/python/howto/regex/regex.html

# on stocke le fichier brut dans une variable

file_in = open('in.tex','r') # on cree l'objet file_in avec le fichier
latex d'entree
file_string = file_in.read() # file_in est stocke en tant que string
dans file_string
file_in.close() # fermeture du fichier d'entrée

# on ne veut que la partie du fichier entre begin{document} et
end{document}...

corps = r"""\begin{document}(?P<contents>.*)\end{document}""" # la
RE correspondante au corps du doc

compile_obj = re.compile(corps, re.IGNORECASE| re.DOTALL) # on
compile cette RE (gain de temps)
match_obj = compile_obj.search(file_string) #

contents = match_obj.group('contents') # on
stocke dans contents le corps du texte en tant que string

# remplacer section{titre} ...texte... section{titre2}... par
<section><titre>titre<titre><texte>blabla<texte><section>

sect = r'\section{(.*)}' #
Python's raw string notation for regular expressions
motif1 = re.compile(sect)

ssect = r'\subsection{(.*)}'
motif2 = re.compile(ssect)

# ###################"
# Fabrication du corps du fichier xml

contents_list = re.split(motif1,contents) # on découpe avec motif1

from cStringIO import StringIO # reads and writes a string buffer (also
known as memory files)
fout = StringIO()
fout.write('<?xml version="1.0" encoding="ISO-8859-1"?>n')
fout.write('<!--fichier *.tex "xmlisé" par montex2xml.py-->n')
fout.write('<document>n')
fout.write('<introduction>%s</introduction>n' % contents_list[0] )

##On se définit un petit générateur pour regrouper deux par deux les
##informations relatives à une section (il aurait été préférable de ne pas
##saboter la structure au moment de la construction de contents_list et de
##mettre un tuple (titre, contenu) dans chaque « case » de la liste au
## lieu d'utiliser deux cases)
## Merci à F. Petitjean !

def pardeux(iterable, n=2): #renvoie les items de la séquence groupés
deux par deux (ou par n)
it = iter(iterable)
next = it.next
while True:
yield next(), next()

# Traitement pour une section :
for titre, contenu in pardeux(contents_list[1:]):
fout.write('<section>nn')
fout.write('<titreSection>%s</titreSection>n' % titre) # titre
des sections
# éclater contenu en sous-sections
contenus_sections = re.split(motif2,contenu)
fout.write('<texte>%s</texte>n' % contenus_sections[0]) #
l'intro de section
for titre_ssect, contenu_sect in pardeux(contenus_sections[1:]):
fout.write('<sousSection>n')
fout.write('<titreSousSection>%s</titreSousSection>n' %
titre_ssect)
fout.write('<texte>%s</texte>' % contenu_sect)
fout.write('</sousSection>n')
fout.write('</section>n')

fout.write('</document>')

print fout.getvalue()


# On écrit le fichier final
output = open('out2.xml','w')
output.write(fout.getvalue())
output.close()
#######################"
Voilà.
Il me reste à vérifie que le XML sorti n'est pas trop laid pour être
traité avec les outils pythons avant de le transformer en fichier *.sql.

De toutes manières pour le chef, vous dites que vous utilisez les
dernières techniques à la mode : générateurs, itérateurs, XML, DOM,
métaclasses et décorateurs et cela devrait être suffisamment «
buzzword compliant »

lol, c'est une bien belle expression idomatique !
(il faut que je creuse un peu les iétrateurs... ;-))

pour demander une augmentation ou au moins
justifier les retards (vous attendez toujours cette formation aux
métaclasses n'est-ce-pas ?)
En pratique, terminez toujours vos modules avec
if __name__ == '__main__':
"""quelques tests évidents qui montrent l'utilisation du module"""
seq = ....
print ....
Et n'hésitez pas à essayer avec python -i NomDuModule.py

Merci beaucoup :-)
Rémi qui ne sera augmenté que de 0,8% ;-)

Bonjour et merci pour votre réponse !
Que les dieux vous accompagnent ! ;-)
il n'y a pas de quoi

###########
sect = r'\section{(.*)}'

Je suppose qu'il faut lire :
sect = r'section{(.*)}'
pour n'avoir qu'une barre iclinée inverse au début.

Euh, non, c'est bien ça à cause du "backslash plague" ;-)
http://www.amk.ca/python/howto/regex/regex.html#SECTION000420000000000000000
Ah oui et pourquoi

map(len, ('1234', r'1234', r'\123'))
me donne [4, 4, 5] et non [4, 4, 4] ?

contents_list est une liste du type :
['Intro','titre section1', 'texte section1 avec les
subsections','section2'....]

Vous avez vérifié directement avec l'interpréteur (lancer python -i
script_de_test.py et print contents_list[:3] ..)

je fais fausse route ?

Et comment ! Si j'étais votre prof et que vous me donniez une copie
avec de telles âneries, vous auriez droit à un beau zéro pointé. :-)

lol mais msieur ?! Je sais faire un dictionnaire au moins ! ;-)

J''espère ne pas avoir été trop long...
Merci en tout cas.
Rémi

Bon reprenons. Je suppose que par la magie des expressions régulières
(ou tout simplement en utilisant des tests du genre if
line.startswith(r'section{'): vous arrivez à obtenir « contents_list »
c'est-à-dire si je ne m'abuse une séquence de chaînes de caractères avec
en premier ce qui est avant le première section, puis le titre de
section suivi de son contenu et ainsi de suite pour les sections
suivantes.

Toutafé.

En bricolant l'expression régulière de départ ou mieux en
appliquant une re basée sur r'subsection{(*)}' aux éléments d'indices
2, 4, ... vous pouvez affiner ladite partie du document et donc insérer
les éléments XML correspondants aux sous-sections.

Oui, c'est le but. En plus, les titres de sections sont dans les indices
pairs...

Autrement dit : contents_list[0] va se placer dans un « tag »
"introduction" ou je ne sais quoi
from cStringIO import StringIO
fout = StringIO()
fout.write('header XMLn') # plein de lignes magiques pour déclarer
document XML

Si j'ai bien compris, le module StringIO permet de créer un fichier mais
dans la mémoire vive ? C'est donc plus rapide...
Toutafé. Comme en plus vous trater des petits volumes ...

On se définit un petit générateur pour regrouper deux par deux les
informations relatives à une section (il aurait été préférable de ne pas
saboter la structure au moment de la construction de contents_list et de
mettre un tuple (titre, contenu) dans chaque « case » de la liste au
lieu d'utiliser deux cases)

Hum... Une liste composée de couples

def pardeux(iterable, n=2):
"""renvoie les items de la séquence groupés deux par deux (ou par
n)"""
it = iter(iterable)
next = it.next
while True:
yield next(), next()

J'ai pas tout compris là mais bon...
Il y a plus simple (mais hier soir j'étais un peu pressé)

it = iter(iterable)
pardeux = (it,)*2 # (it, it)
pardeux = zip(*pardeux) # ou zip(it, it) ou itertools.izip(it, it)

# terable = range(10)
# it = iter(iterable)
# list(zip(it, it))
# [(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)]

# Traitement pour une section :
for titre, contenu in pardeux(contents_list[1:]):
# ouvrir un élément avec tag correspondant à section, avec un
# attribut titre="%s" (ou un début de contenu faudrait nous
# expliquer précisément la sortie)
# éclater contenu en sous-sections et écrire les informations avec
# les tags correspondant aux dites sous-sections
# fermer la section courante "</%s>n" % (tag_de_section,)

Bref, rien que de la programmation simple, aux ras des pâquerettes,
séquences toutes bêtes, même pas de dictionnaire.

C'est bien plus simple donc c'est plus joli. Dire que je m'étais lancé
dans une numérotation "dynamique" des variables ! En tout cas, c'était
très formateur (surtout pour un newbie mauvais élève comme moi ;-))
Voici le code obtenu avec cette aide (très) précieuse :
Allez, je colle tout (cela peut servir à d'autres), tous les
commentaires sont les bienvenus !
#####################
# -*- coding: Latin-1 -*-
import re # importation du module RE
#
http://www.amk.ca/python/howto/regex/regex.html

# on stocke le fichier brut dans une variable

import sys

file_in = open('in.tex','r') # on cree l'objet file_in avec le fichier
latex d'entree
# remplacez 'in.tex' par sys.argv[1] au cas où

file_string = file_in.read() # file_in est stocke en tant que string
dans file_string
file_in.close() # fermeture du fichier d'entrée

# on ne veut que la partie du fichier entre begin{document} et
end{document}...

corps = r"""\begin{document}(?P<contents>.*)\end{document}""" # la
RE correspondante au corps du doc
Voir plus haut pour r"""begin...."""

compile_obj = re.compile(corps, re.IGNORECASE| re.DOTALL) # on
compile cette RE (gain de temps)
# ce n'est pas un gain de temps puisque on utilise une seule fois

# Vous pouvez arguer en invoquant la necessité d'avoir les drapeaux
# re.IGNORECASE| re.DOTALL (encore que je ne suis pas sûr que laTeX
# comprenne begin[DOCUMENT} ou BEGIN[document}

match_obj = compile_obj.search(file_string) #

contents = match_obj.group('contents') # on
stocke dans contents le corps du texte en tant que string

# remplacer section{titre} ...texte... section{titre2}... par
<section><titre>titre<titre><texte>blabla<texte><section>

sect = r'\section{(.*)}' #
Python's raw string notation for regular expressions
# let you write more simply r'section...'

motif1 = re.compile(sect)

ssect = r'\subsection{(.*)}'
un seul « » suffira

motif2 = re.compile(ssect)

# ###################"
# Fabrication du corps du fichier xml

contents_list = re.split(motif1,contents) # on découpe avec motif1
ou motif1.split(contents) non ?

from cStringIO import StringIO # reads and writes a string buffer (also
known as memory files)
fout = StringIO()
fout.write('<?xml version="1.0" encoding="ISO-8859-1"?>n')
fout.write('<!--fichier *.tex "xmlisé" par montex2xml.py-->n')
fout.write('<document>n')
fout.write('<introduction>%s</introduction>n' % contents_list[0] )

##On se définit un petit générateur pour regrouper deux par deux les
##informations relatives à une section (il aurait été préférable de ne pas
##saboter la structure au moment de la construction de contents_list et de
##mettre un tuple (titre, contenu) dans chaque « case » de la liste au
## lieu d'utiliser deux cases)
## Merci à F. Petitjean !

def pardeux(iterable, n=2): #renvoie les items de la séquence groupés
deux par deux (ou par n)
it = iter(iterable)
it2 = (it,)*n

return zip(*it2)

# next = it.next
# while True:
# yield next(), next()

# Traitement pour une section :
for titre, contenu in pardeux(contents_list[1:]):
fout.write('<section>nn')
fout.write('<titreSection>%s</titreSection>n' % titre) # titre
des sections
# éclater contenu en sous-sections
contenus_sections = re.split(motif2,contenu)
fout.write('<texte>%s</texte>n' % contenus_sections[0]) #
l'intro de section
Vous ne testez pas s'il y a des sous-sections ?

for titre_ssect, contenu_sect in pardeux(contenus_sections[1:]):
fout.write('<sousSection>n')
fout.write('<titreSousSection>%s</titreSousSection>n' %
titre_ssect)
fout.write('<texte>%s</texte>' % contenu_sect)
fout.write('</sousSection>n')
fout.write('</section>n')

fout.write('</document>')

# print fout.getvalue()


# On écrit le fichier final
output = open('out2.xml','w')
output.write(fout.getvalue())
output.close()

Vous pourriez modulariser un peu avec quelques fonctions qui font un
travail bien différent : lire entrée, transformer le contenu, écrire le
fichier final

Vous pourriez modulariser un peu avec quelques fonctions qui font un
travail bien différent : lire entrée, transformer le contenu, écrire le
fichier final.

#######################"
Voilà.
Il me reste à vérifie que le XML sorti n'est pas trop laid pour être
traité avec les outils pythons avant de le transformer en fichier *.sql.

De toutes manières pour le chef, vous dites que vous utilisez les
dernières techniques à la mode : générateurs, itérateurs, XML, DOM,
métaclasses et décorateurs et cela devrait être suffisamment «
buzzword compliant »

lol, c'est une bien belle expression idomatique !
(il faut que je creuse un peu les iétrateurs... ;-))

pour demander une augmentation ou au moins
justifier les retards (vous attendez toujours cette formation aux
métaclasses n'est-ce-pas ?)

Merci beaucoup :-)
Rémi qui ne sera augmenté que de 0,8% ;-)

Bonsoir,

sect = r'section{(.*)}'
pour n'avoir qu'une barre iclinée inverse au début.

Euh, non, c'est bien ça à cause du "backslash plague" ;-)
http://www.amk.ca/python/howto/regex/regex.html#SECTION000420000000000000000

Ah oui et pourquoi
map(len, ('1234', r'1234', r'\123'))
me donne [4, 4, 5] et non [4, 4, 4] ?

Dans le "code" en LaTeX, il y a section{Titre} et effectivement
map(len, ('1234', r'1234', r'\section')) renvoie :
[4, 4, 9]
et :
map(len, ('1234', r'1234', r'section')) renvoie :
[4, 4, 8]

par contre dans le code, le découpage (méthode split) ne se fait pas si
je mets sect = r'section{(.*)}' au lieu de sect = r'\section{(.*)}'
étrange mais voir plus bas.

[...]

def pardeux(iterable, n=2):
"""renvoie les items de la séquence groupés deux par deux (ou par
n)"""
it = iter(iterable)
next = it.next
while True:
yield next(), next()

J'ai pas tout compris là mais bon...

Il y a plus simple (mais hier soir j'étais un peu pressé)
it = iter(iterable)
pardeux = (it,)*2 # (it, it)
pardeux = zip(*pardeux) # ou zip(it, it) ou itertools.izip(it, it)

# terable = range(10)
# it = iter(iterable)
# list(zip(it, it))
# [(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)]

import sys

Pourquoi charger sys ? Il y a quelque chose que j'ai du mal comprendre.

file_in = open('in.tex','r') # on cree l'objet file_in avec le fichier
latex d'entree

# remplacez 'in.tex' par sys.argv[1] au cas où

[...]

compile_obj = re.compile(corps, re.IGNORECASE| re.DOTALL) # on
compile cette RE (gain de temps)

# ce n'est pas un gain de temps puisque on utilise une seule fois
# Vous pouvez arguer en invoquant la necessité d'avoir les drapeaux
# re.IGNORECASE| re.DOTALL (encore que je ne suis pas sûr que laTeX
# comprenne begin[DOCUMENT} ou BEGIN[document}

C'est vrai. Merci.

[...]

contents_list = re.split(motif1,contents) # on découpe avec motif1

ou motif1.split(contents) non ?

D'accord ! En fait avec
sect = r'section{(.*)}'
contents_list = re.split(motif1,contents) ne marche pas
mais ce que vous proposez oui.
Merci.

Oups c'est tard, j'étudie la suite dans le week-end.
Merci bcp en tout cas !! C'est très instructif !!
Rémi.
[...]

def pardeux(iterable, n=2): #renvoie les items de la séquence groupés
deux par deux (ou par n)
it = iter(iterable)

it2 = (it,)*n
return zip(*it2)

# next = it.next
# while True:
# yield next(), next()

# Traitement pour une section :
for titre, contenu in pardeux(contents_list[1:]):
fout.write('<section>nn')
fout.write('<titreSection>%s</titreSection>n' % titre) # titre
des sections
# éclater contenu en sous-sections
contenus_sections = re.split(motif2,contenu)
fout.write('<texte>%s</texte>n' % contenus_sections[0]) #
l'intro de section

Vous ne testez pas s'il y a des sous-sections ?

for titre_ssect, contenu_sect in pardeux(contenus_sections[1:]):
fout.write('<sousSection>n')
fout.write('<titreSousSection>%s</titreSousSection>n' %
titre_ssect)
fout.write('<texte>%s</texte>' % contenu_sect)
fout.write('</sousSection>n')
fout.write('</section>n')

fout.write('</document>')

# print fout.getvalue()


# On écrit le fichier final
output = open('out2.xml','w')
output.write(fout.getvalue())
output.close()

Vous pourriez modulariser un peu avec quelques fonctions qui font un
travail bien différent : lire entrée, transformer le contenu, écrire le
fichier final

Vous pourriez modulariser un peu avec quelques fonctions qui font un
travail bien différent : lire entrée, transformer le contenu, écrire le
fichier final.

#######################"
Voilà.
Il me reste à vérifie que le XML sorti n'est pas trop laid pour être
traité avec les outils pythons avant de le transformer en fichier *.sql.

De toutes manières pour le chef, vous dites que vous utilisez les
dernières techniques à la mode : générateurs, itérateurs, XML, DOM,
métaclasses et décorateurs et cela devrait être suffisamment «
buzzword compliant »

lol, c'est une bien belle expression idomatique !
(il faut que je creuse un peu les iétrateurs... ;-))

pour demander une augmentation ou au moins
justifier les retards (vous attendez toujours cette formation aux
métaclasses n'est-ce-pas ?)

Merci beaucoup :-)
Rémi qui ne sera augmenté que de 0,8% ;-)

F. Petitjean wrote:

sect = r'\section{(.*)}'

Je suppose qu'il faut lire :
sect = r'section{(.*)}'
pour n'avoir qu'une barre iclinée inverse au début.

Euh, non, c'est bien ça à cause du "backslash plague" ;-)
http://www.amk.ca/python/howto/regex/regex.html#SECTION000420000000000000000

Ah oui et pourquoi
map(len, ('1234', r'1234', r'\123'))
me donne [4, 4, 5] et non [4, 4, 4] ?
J'ai cru comprendre qu'il y a deux niveaux d'échappement. Celui pour

python et celui de l'expression régulière.
Le mode brut indiqué par r'...' permet de demander à python de ne pas
tenter d'en changer le contenu mais il faut toujours indiquer à
l'expression régulière que c'est le caractère backslash qui nous
intéresse et pas un éventuel caractère 's'.

F. Petitjean wrote:

sect = r'\section{(.*)}'

Je suppose qu'il faut lire :
sect = r'section{(.*)}'
pour n'avoir qu'une barre iclinée inverse au début.

Euh, non, c'est bien ça à cause du "backslash plague" ;-)
http://www.amk.ca/python/howto/regex/regex.html#SECTION000420000000000000000

Ah oui et pourquoi
map(len, ('1234', r'1234', r'\123'))
me donne [4, 4, 5] et non [4, 4, 4] ?
J'ai cru comprendre qu'il y a deux niveaux d'échappement. Celui pour

python et celui de l'expression régulière.
Le mode brut indiqué par r'...' permet de demander à python de ne pas
tenter d'en changer le contenu mais il faut toujours indiquer à
l'expression régulière que c'est le caractère backslash qui nous
intéresse et pas un éventuel caractère 's'.
Effectivement vous avez raison. Après vérification l'expression

régulière considère toujours la barre inverse comme un caractère
d'échappement. Peut être pas dans un contexte [ ... ] mais ce n'est pas
le cas ici.
Merci d'avoir corrigé.