Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
je cherche à définir un petit formalisme de fichier de configurati on
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
je cherche à définir un petit formalisme de fichier de configurati on
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
je cherche à définir un petit formalisme de fichier de configurati on
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
je cherche à définir un petit formalisme de fichier de configurat ion
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Voir jsonwww.json.org
Voir yamlwww.yaml.org
Les 2 sont bons et simple
il doit y en avoir d'autres mais je debute en python
A+
chris
Bonjour,
je cherche à définir un petit formalisme de fichier de configurat ion
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Voir jsonwww.json.org
Voir yamlwww.yaml.org
Les 2 sont bons et simple
il doit y en avoir d'autres mais je debute en python
A+
chris
Bonjour,
je cherche à définir un petit formalisme de fichier de configurat ion
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Voir jsonwww.json.org
Voir yamlwww.yaml.org
Les 2 sont bons et simple
il doit y en avoir d'autres mais je debute en python
A+
chris
On 19 fév, 10:15, Jerome wrote:Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
tu peux utiliser le module pickle (ou cPickle)
On 19 fév, 10:15, Jerome <jer...@nospam.com> wrote:
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
tu peux utiliser le module pickle (ou cPickle)
On 19 fév, 10:15, Jerome wrote:Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
tu peux utiliser le module pickle (ou cPickle)
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Autre pise: utiliser ConfigObj
http://www.voidspace.org.uk/python/configobj.html
Vu ce que tu cherches à exprimer, YAML semblerais adapté.
Pour pyparsing, je suis en train de m'y mettre, c'est sympa, et rapide.
Manque une doc synthétique AMA (ou je ne l'ai pas trouvée). Par contre,
ça pourrais te permettre de réaliser rapidement ton module de lecture.
Précédemment, pour PyExp, j'avais fait un module de configuration
pouvant utiliser des fichiers textes, avec un format:
@XXXXX
[YYYYY]
ZZZZ=VVVV
(l'indentation n'est là que pour la lisibilité - le gros ajout était un
niveau hiérarchique de plus par rapport au format des fichiers à la ".ini").
Mais, sauf à avoir des besoins très spéciaux (typiquement dans PyExp
j'ai une couche d'abstraction qui permet éventuellement d'utiliser
d'autres backend de stockage que des fichiers textes), j'éviterais
autant que possible de réinventer ça.
J'ai une question par rapport à ton format désiré. Si tu supprime le
séparateur entre les valeurs, pourquoi le conserves-tu lorsque tu es
entre () et entre [] ?
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Autre pise: utiliser ConfigObj
http://www.voidspace.org.uk/python/configobj.html
Vu ce que tu cherches à exprimer, YAML semblerais adapté.
Pour pyparsing, je suis en train de m'y mettre, c'est sympa, et rapide.
Manque une doc synthétique AMA (ou je ne l'ai pas trouvée). Par contre,
ça pourrais te permettre de réaliser rapidement ton module de lecture.
Précédemment, pour PyExp, j'avais fait un module de configuration
pouvant utiliser des fichiers textes, avec un format:
@XXXXX
[YYYYY]
ZZZZ=VVVV
(l'indentation n'est là que pour la lisibilité - le gros ajout était un
niveau hiérarchique de plus par rapport au format des fichiers à la ".ini").
Mais, sauf à avoir des besoins très spéciaux (typiquement dans PyExp
j'ai une couche d'abstraction qui permet éventuellement d'utiliser
d'autres backend de stockage que des fichiers textes), j'éviterais
autant que possible de réinventer ça.
J'ai une question par rapport à ton format désiré. Si tu supprime le
séparateur entre les valeurs, pourquoi le conserves-tu lorsque tu es
entre () et entre [] ?
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Autre pise: utiliser ConfigObj
http://www.voidspace.org.uk/python/configobj.html
Vu ce que tu cherches à exprimer, YAML semblerais adapté.
Pour pyparsing, je suis en train de m'y mettre, c'est sympa, et rapide.
Manque une doc synthétique AMA (ou je ne l'ai pas trouvée). Par contre,
ça pourrais te permettre de réaliser rapidement ton module de lecture.
Précédemment, pour PyExp, j'avais fait un module de configuration
pouvant utiliser des fichiers textes, avec un format:
@XXXXX
[YYYYY]
ZZZZ=VVVV
(l'indentation n'est là que pour la lisibilité - le gros ajout était un
niveau hiérarchique de plus par rapport au format des fichiers à la ".ini").
Mais, sauf à avoir des besoins très spéciaux (typiquement dans PyExp
j'ai une couche d'abstraction qui permet éventuellement d'utiliser
d'autres backend de stockage que des fichiers textes), j'éviterais
autant que possible de réinventer ça.
J'ai une question par rapport à ton format désiré. Si tu supprime le
séparateur entre les valeurs, pourquoi le conserves-tu lorsque tu es
entre () et entre [] ?
Laurent Pointal wrote:Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
<zip>
J'ai une question par rapport à ton format désiré. Si tu supprime le
séparateur entre les valeurs, pourquoi le conserves-tu lorsque tu es
entre () et entre [] ?
Les espaces servent à séparer les différents types de donnés, les
virgules à séparer les valeurs dans les types (certaines peuvent être
absentes). Je veux être assez souple s'il manque un espace ou s'il y a
des tabulations par exemple.
Laurent Pointal wrote:
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
<zip>
J'ai une question par rapport à ton format désiré. Si tu supprime le
séparateur entre les valeurs, pourquoi le conserves-tu lorsque tu es
entre () et entre [] ?
Les espaces servent à séparer les différents types de donnés, les
virgules à séparer les valeurs dans les types (certaines peuvent être
absentes). Je veux être assez souple s'il manque un espace ou s'il y a
des tabulations par exemple.
Laurent Pointal wrote:Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
<zip>
J'ai une question par rapport à ton format désiré. Si tu supprime le
séparateur entre les valeurs, pourquoi le conserves-tu lorsque tu es
entre () et entre [] ?
Les espaces servent à séparer les différents types de donnés, les
virgules à séparer les valeurs dans les types (certaines peuvent être
absentes). Je veux être assez souple s'il manque un espace ou s'il y a
des tabulations par exemple.
Bonjour,
je cherche à définir un petit formalisme de fichier de configurati on
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
(...)
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
je cherche à définir un petit formalisme de fichier de configurati on
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
(...)
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
je cherche à définir un petit formalisme de fichier de configurati on
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
(...)
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
On 19 fév, 10:15, Jerome wrote:Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
(...)
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
La solution standard en Python pour les fichiers de configuration est
d'utiliser le module ConfigParser
L'utilisateur édite un fichier texte (disons config.txt) du genre :
[MesOptions]
values = 12,23,45
val1 = (12, 34, 44.5)
val2 = [23,45.3]
C'est plus lisible que ce que tu proposes avec toutes les valeurs sur
une seule ligne, et l'utilisateur n'a pas besoin de connaître Python
A+
Pierre
On 19 fév, 10:15, Jerome <jer...@nospam.com> wrote:
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
(...)
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
La solution standard en Python pour les fichiers de configuration est
d'utiliser le module ConfigParser
L'utilisateur édite un fichier texte (disons config.txt) du genre :
[MesOptions]
values = 12,23,45
val1 = (12, 34, 44.5)
val2 = [23,45.3]
C'est plus lisible que ce que tu proposes avec toutes les valeurs sur
une seule ligne, et l'utilisateur n'a pas besoin de connaître Python
A+
Pierre
On 19 fév, 10:15, Jerome wrote:Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
(...)
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
La solution standard en Python pour les fichiers de configuration est
d'utiliser le module ConfigParser
L'utilisateur édite un fichier texte (disons config.txt) du genre :
[MesOptions]
values = 12,23,45
val1 = (12, 34, 44.5)
val2 = [23,45.3]
C'est plus lisible que ce que tu proposes avec toutes les valeurs sur
une seule ligne, et l'utilisateur n'a pas besoin de connaître Python
A+
Pierre
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
Bonjour,
je cherche à définir un petit formalisme de fichier de configuration
qui me permettra de stocker facilement des informations structurées
(tuples, listes, ...) dans des fichiers textes.
par exemple :
"values = 12 23 (12, 34, 44.5) 45 [23,45.3]" dans le fichier texte me
donne trois choses différentes :
- des valeurs spécifiques 12, 23, 45
- un tuple de 3 valeurs : (12, 34, 44.5)
- un intervalle : [23, 45.3]
Actuellement je connais plusieurs moyens de le faire mais je cherche des
moyens plus simples à mettre en oeuvre.
1/ Utiliser la fonction eval. Le problème est de devoir écrire la
structure en python, ce que je ne veux pas imposer.
2/ Utiliser un parsing à base de split. Difficile à maintenir et à étendre.
3/ Utiliser le module re. Plus simple que les split mais les regexp sont
vite complexes.
4/ Utiliser pyparsing. Je n'ai pas encore pu tester.
Est-ce que vous auriez d'autres pistes à me faire partager ou bien un
retour d'expérience ?
Merci,
Jérôme
