Python 2.7 - Chercher caractère dans un fichier

Version imprimable

09/09/2013, 09h10
brandtance

Python 2.7 - Chercher caractère dans un fichier

Bonjour,

En Python 2.7, je dois chercher le caractère '}' et juste avant insérer un string.

Actuellement, je parcours le fichier ligne par ligne et en suite caractère par caractère... Mais je trouve ça un peu trop bourrin. Quelle est la meilleure des solutions ?
Je reste bloqué car il ne voit pas forcément le caractère '}' à cause des caractères de retour à ligne, des tabulations, etc...

D'avance merci,
09/09/2013, 09h52
deusyss

Bonjour, la meilleur solution est d'utiliser le module re, avec une REGEX.

Que dois tu faire une fois le caractère trouvé? Il y a peut etre une methode pour string ou un autre module encore mieux adapté fonction de tes besoins précis. Détaille nous un peu plus ce que tu désire faire.
09/09/2013, 10h02
brandtance

Tout d'abord merci pour ta réponse.

En gros, nous avons des fichiers de configuration (qui sont tout pourris :)) )
Le fichier commence par un { et termine par un }. Bon ça c'est en théorie car vu que tout le monde modifie les fichiers il y a parfois des sauts de ligne en plus à la fin.

Le but est d'insérer du texte juste avant le '}' et de sauter une ligne. Exemple :

Citation:

// Avant la modification :
//MonExempleDeFichier
{
maconf = coucou
}

-------
// Après la modification :
//MonExempleDeFichier
{
maconf = coucou
serveur = MonAdresse
}

D'accord, je comprend mieux.

Si tu regarde ici: http://docs.python.org/2/library/std...string-methods, la méthode find devrait te plaire.

Tu lui passes trois paramètres: le premier est la chaine que tu cherches (dans ton cas "}" si j'ai bien compris), le second est l'index du caractère de départ, le troisième l'index de fin de recherche. la méthode find va alors te renvoyer l'index le plus faible s'il trouve quelque chose, sinon il renverra -1.

Utilise du coup la méthode readline:
Code:

1 2 3 4 5 6 7 8 9 10 11 f = open('file','r') f_tmp = open('file_tmp', 'w') f_line = f.readline() while f_line <> "": rtr = f_line.find("}\n") #je cherche, sous linux, le caractère }, sur la ligne entière if rtr <> -1: f_tmp.write("texte en sus") f_tmp.write(f_line) f_line = f.readline #puis reecriture de f_tmp dans f
C'est bien sur juste un code exemple pour illustrer. Là tu lit le fichier ligne à ligne (ce qui est mieux, surtout si tes fichiers sont très gros), puis dans chaque ligne, tu cherche ton caractère. Si tu le détectes, tu peut alors faire un insert.

Cela te convient il?

NB: la méthode replace peut aussi t'interesser, selon ton besoin precis

09/09/2013, 10h29
brandtance

Waouh! Ca c'est de la réponse!
J'étudie tout ça, je test et je reviens vers toi ;)

Merci beaucoup
09/09/2013, 10h35
brandtance

Ben ça n'a pas l'air de fonctionner :

rtr = f_line.find("}\n")
AttributeError: 'builtin_function_or_method' object has no attribute 'find'

EDIT : Il manquait le () à la fin de readline... Je continue à tester ton code ;)
09/09/2013, 10h49
fred1599

C'est encore trop vague comme description de problème.

Il faut être plus précis quand à la mise en forme de ton fichier.

Sont tous-t-ils identiques, même nombre de paramètres, etc... ?

@deussys

Il y a bien longtemps que l'opérateur "différent" est modifié de <> à !=
09/09/2013, 10h49
deusyss

Comme je l'ai précisé, c'était juste un exemple, et de fait non testé. l'erreur est Humaine. Désolé pour ce petit contre temps :mouarf:

EDIT: concernant le <>, je le sait bien. C'est un reste de nombreux autres langages. Il est vrai que je n'y pense pas tant que le compilateur ne m'indique pas d'erreur
09/09/2013, 10h55
brandtance
Je vais essayer de donner plus d'informations.
Nous avons plusieurs fichiers de configurations, qui sont tous différents! Certains contiennent 3 paramètres, d'autres 50! Les règles de syntaxe sont les suivantes :
- Commencer par un {
- Terminer par un }
- Les paramètres sont sous la forme suivante : maVariable = "maValeur"
Le soucis c'est que les fichiers sont modifiés par plusieurs personnes...Et ça devient n'importe quoi! En gros avant ou après un { ou } nous pouvons avoir des saut de lignes, des tabulations, des espaces...

Le but du petit bout de code, c'est de récupérer l'index du caractère '}' pour pouvoir rajouter des paramètres avant.
09/09/2013, 16h13
deusyss

As tu résussit ce que tu voulais faire brandtance?

Bonjour,

Non pas encore...
En fait la j'arrive juste à trouver le caractère '}' en utilisant les Regex.
J'aimerai bien trouvé son emplacement pour pouvoir insérer mon texte...
Code:

1 2 3 4 5 6 7 8 9 10 11 import re test = open('C:\test.cfg','r') dataConf = test.read() myRegex = re.compile(r'{') # strings = re.findall(r'^{',dataConf,re.M) strings = myRegex.findall(dataConf) test.close()

Quelque chose comme ça te convient?

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
#!/usr/bin/env python
#-*- coding:utf-8 -*
 
import re
 
def add_param(file_src, file_dst, param, value):
	f = open(file_src,'r')
	f_tmp = open(file_dst, 'w')
 
	myRegex = re.compile(r'{')
 
	f_line = f.readline()
 
	while f_line <> "":
		f_tmp.write(f_line)
		reg_obj = myRegex.search(f_line)
		if reg_obj != None:
			if reg_obj.pos == 0:
				f_tmp.write(param + "=" + "\"" + value +"\"" + "\n")
		f_line = f.readline()
 
	f.close()
	f_tmp.close()
 
 
def overwrite_config_file(file_src, file_dst):
	f = open(file_src,'w')
	f_tmp = open(file_dst, 'r')
 
	f_complet = f_tmp.read()
	f.write(f_complet)
 
	f.close()
	f_tmp.close()
 
 
if __name__ == "__main__":
	file_src = "./test.cfg"
	file_dst = "./file_tmp.txt"
 
	add_param(file_src, file_dst, "ParametreSus", "Valeur")
	overwrite_config_file(file_src, file_dst)

Salut,

Si tu séparais les blocs compris entre '{' et '}' ce ne serait pas plus facile ?

Avec en plus la possibilité de nettoyer le fichier.

Exemple:

lefichier.conf (salopé par tes collègues)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
{
maconf = coucou
serveur = MonAdresse
}
{
saconf = hello
serveur = SonAdresse
 
}
 
{
taconf = bonjour
 
serveur = TonAdresse
}

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
 
# -*- coding: utf-8 -*-
 
import re
 
FIND_RE = re.compile('(?<={)(.*?)(?=})', re.DOTALL)
 
def parse_config():
    with open('/home/vincent/Bureau/conf.cfg', 'r') as inf:
        txt = inf.read()
        # On sépare les blocs {...}
        confs = FIND_RE.findall(txt)
        out = []
        if confs:
            for conf in confs:
                # On divise en lignes
                lines = conf.split('\n')
                # On nettoye les lignes vides
                lines = [l.strip() for l in lines if l.strip()]
                # On reconstitue
                out.append('{\n' + '\n'.join(lines) + '\n}\n')
 
        # On ajoute un élément par exemple à `hello`
        for idx, item in enumerate(out):
            if 'hello' in item:
                out[idx] = item[:-2] + 'pswd = sdfghjkl54351fogiyfj\n}\n'
 
        # Contrôle
        for o in out:
            print o
 
parse_config()

Le résultat

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
vincent@tiemoko:~/Bureau$ python reader.py 
{
maconf = coucou
serveur = MonAdresse
}
 
{
saconf = hello
serveur = SonAdresse
pswd = sdfghjkl54351fogiyfj
}
 
{
taconf = bonjour
serveur = TonAdresse
}

Bonjour,

Petite proposition:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 import re def sub(g): # la fin de ligne peut être ajustée en fonction de l'OS return '\n' + 'maVariable = "maValeur"' + '\n}' ch = '''xxxx { y = "toto" } xxxx { } xxxx { t = "tata"} xxxx''' motif = r'([^\"{]*})' ch2 = re.sub(motif, sub, ch) print ch2
Ce qui donne:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 xxxx { y = "toto" maVariable = "maValeur" } xxxx { maVariable = "maValeur" } xxxx { t = "tata" maVariable = "maValeur" } xxxx
Pour le motif, pour neutraliser les éventuels fin de ligne avant le '}' trouvé, j'ai dit que avant le '}', il fallait neutraliser tous les caractères jusqu'au '"' ou '{' précédent. A voir si ça convient. Il faudrait modifier si certains paramètres ne se terminaient pas par '"': par exemple x=123.

Au cas où il faudrait paramétrer le remplacement en fonction d'autre choses, le préciser: en plaçant la fonction 'sub' comme méthode d'une classe, on peut faire pas mal de choses plus complexes.

10/09/2013, 09h35
brandtance

Merci à tous, je devrai trouver mon bonheur...
Mais étant débutant il va me falloir du temps.

Encore merci,