IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Replace pour un mot seul


Sujet :

Python

  1. #1
    Membre à l'essai
    Inscrit en
    Juillet 2010
    Messages
    28
    Détails du profil
    Informations forums :
    Inscription : Juillet 2010
    Messages : 28
    Points : 23
    Points
    23
    Par défaut Replace pour un mot seul
    Bonjour a tous.
    Alors voila j'utilise la fonction:
    data = data.replace(x, y)

    qui me permet de remplacer les variables x de data par les variables y. Jusque la aucun souci, ca marche. Mais apres etude de mes resultats je me rend compte que des expressions comme :
    while ( (pThrParams->bRunning)
    sont devenues
    while ( (pThrParams->b_running)

    Or dans ma replace list il n'y a que bRun a modifier. Je vois donc qu'il modifie la chaine de caractere partout (ce qui est logique puisque je lui demande)
    Je voulais donc savoir si il existait une option ou une fonction ne permettant de modifier que le mot complet. Merci d'avance de vos reponses

  2. #2
    Membre expérimenté
    Homme Profil pro
    Inscrit en
    Avril 2004
    Messages
    1 049
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Avril 2004
    Messages : 1 049
    Points : 1 380
    Points
    1 380
    Par défaut
    salut,
    tu peux poster le code ?

  3. #3
    Membre à l'essai
    Inscrit en
    Juillet 2010
    Messages
    28
    Détails du profil
    Informations forums :
    Inscription : Juillet 2010
    Messages : 28
    Points : 23
    Points
    23
    Par défaut
    Voila le code de ma fonction search&replace
    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
     
    def searchandreplace(x, y, setpath):
     
       for root, dirs, files in os.walk(setpath):
          fname = files
          for fname in files:
             if ('.c' in fname or '.h' in fname) and not '.csv' in fname:
                inputFile = file(os.path.join(root,fname), 'r')
                data = inputFile.read()
                inputFile.close()
                search = string.find(data, x)
                if search >=1:
                   data = data.replace(x, y)
                   outputFile = file(os.path.join(root,fname), 'w')
                   outputFile.write(data)
                   outputFile.close()
                   #print "Replacing", x, "with", y, "in", fname

  4. #4
    Membre habitué Avatar de sopsag
    Profil pro
    Inscrit en
    Octobre 2008
    Messages
    224
    Détails du profil
    Informations personnelles :
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Octobre 2008
    Messages : 224
    Points : 190
    Points
    190
    Par défaut
    Il va falloir chercher du coté des expressions régulières (ici).
    En particulier le pattern "\w" qui permet de matcher un identifiant à la C/C++.
    [WinXP sp3 / Visual 2005 / Eclipse Ganymede / Python 2.6]
    Hadrien

  5. #5
    Expert éminent sénior
    Homme Profil pro
    Architecte technique retraité
    Inscrit en
    Juin 2008
    Messages
    21 287
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Manche (Basse Normandie)

    Informations professionnelles :
    Activité : Architecte technique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2008
    Messages : 21 287
    Points : 36 776
    Points
    36 776
    Par défaut
    Salut,
    J'ai compris que vous ne vouliez remplacez que les identifiants "bRun" par... et non les identifiants pouvant contenir "bRun"

    Je ne vois pas trop comment faire cela sans passer par regexp.
    Par contre, la construction '\bMOT\b' me semble plus aisée que de passer par attraper les mots, les comparer à..., les remplacer si.

    Le code, ci dessous, mange un texte et un dict donnant la correspondante quoi => par. i.e. çà remplace "plusieurs mots" - tant qu'à faire!!!

    J'ai fait cela pour jouer: il ne traite peut être pas tous les cas de figures.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    import re
     
    def replace_words(text, words_dict):
        rg = re.compile(r'|'.join([r'\b%s\b' % w for w in words_dict]))
        def translate(match):
            return words_dict[match.group(0)]
        return rg.sub(translate, text)
     
    if __name__ == '__main__':
        wd = { 'ab': 'xy', 'ABC' : 'YYZ' }
        test = "ab- abc *ab ABC ab"
        print replace_words(test, wd)
    - W
    Architectures post-modernes.
    Python sur DVP c'est aussi des FAQs, des cours et tutoriels

  6. #6
    Membre extrêmement actif
    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    1 418
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 1 418
    Points : 1 658
    Points
    1 658
    Par défaut
    J'ai compris que vous ne vouliez remplacez que les identifiants "bRun" par... et non les identifiants pouvant contenir "bRun"
    Moi aussi.



    Je ne vois pas trop comment faire cela sans passer par regexp.
    Moi non plus.



    Par contre, la construction '\bMOT\b' me semble plus aisée que de passer par attraper les mots, les comparer à..., les remplacer si.
    Certes



    Le code, ci dessous, mange un texte et un dict donnant la correspondante quoi => par. i.e. çà remplace "plusieurs mots" - tant qu'à faire!!!
    Les identifiants ne peuvent être écrits qu’avec les caractères suivants: lettres ’a’ à ’z’ minuscules et majuscules, chiffres 0 à 9, underscore ’_’
    http://docs.python.org/reference/lex...ml#identifiers

    Par ailleurs, le symbole spécial \b dans une RE est défini comme la frontière entre les symboles \w et \W ,
    et \w est équivalent à la classe [a-A-Z0-9_] en l’absence de drapeau re.LOCALE ou re.UNICODE.

    Une regex
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    re.compile(’\\b’ + word + ’\\b’)
    avec word ne contenant que des lettres min/MAJ, chiffres et underscore, attrapera donc bien des identifiants.

    Donc code de wiztricks = concis et efficace, et répond bien au problème posé.





    Personnellement je suis parti sur une autre idée:
    détecter toutes les occurences d’un word, aussi bien celles libres c’est à dire entourées seulement de caractères de la “classe blanc“ : \s càd [ \f\n\r\t\v] (je ne sais pas s’il y a aussi les \a , \b et \x, je n’arrive pas à les tester)
    que celles noyées dans un autre mot comportant n’importe quel caractère ( y compris des *&<><:“’ etc).
    Et demander à l’utilisateur s’il veut remplacer certaines des occurences trouvées à l’intérieur de mots.

    Le code suivant peut être utilisé pour remplacer n’importe quelle suite de caractères dans un texte, pas seulement des identifiants.
    Mais ce code ne permet de s’occuper que d’un seul mot à la fois.


    Ce qui se trouve avant la première ligne ###############....
    et après la seconde ligne ############... permet de tester 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
    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
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    from os import makedirs
    from os.path import isdir
    from shutil import rmtree
     
    #if isdir('C:\\ESSAIC\\dedans\\'):
    #    rmtree('C:\\ESSAIC\\dedans\\')
    #if isdir('C:\\ESSAIC\\'):
    #    rmtree('C:\\ESSAIC\\')
     
    makedirs('C:\\ESSAIC\\dedans\\')
     
    for fnm in ('C:\\ESSAIC\\text un.c.txt',
                'C:\\ESSAIC\\texte deux.c.txt'):
        fu = open(fnm,'w')
        fu.write('le rURDUomain fend,URDU\n'
                 'soleil :URDU>> \fURDU URDU URDU\n'
                 'URDUPloyer et\tURDU imperator romURDUain\n'
                 'prunelles uRDU claires ;\n'
                 'le romURDUain sentait\n'
                 'Le romaiURDUn est un romURDUain')
        fu.close()
     
    fu = open('C:\\ESSAIC\\dedans\\wqer.c.txt','w')    
    fu.write('il URDU\nle  \fURDU URDU URDU\n'
             'et\tURDU imperator \nprunelles uRDU claires')
    fu.close()
     
    fu = open('C:\\ESSAIC\\dedans\\derty.c.txt','w')
    fu.write('hhfhfhfhgf kjhkgkgkg\nabcfgedfssubcd')
    fu.close()
     
    fu = open('C:\\ESSAIC\\dedans\\vide.c.txt','w')
    fu.close()
     
    ###################################################
    from os import fsync,walk,path
    import re
     
    def searchandreplace(x, y, setpath):
        minRE = '(?<=\s)'+x+'(?=\s)'
        pat_others = re.compile('\s[^\s]+'+x+'[^\s]*\s|\s'+x+'[^\s]+\s')
        for root, dirs, files in walk(setpath):
            print 8*'---------'+'\n'\
                  +'root  = %r\ndirs  = %r\nfiles = %r\n' % (root,dirs,files)
            gen_fname = (fn for fn in files
                         if ('.c' in fn or '.h' in fn) and not '.csv' in fn )
            for fname in gen_fname:
                print '-*-  Fichier  '+fname+ '   ----------------------'
                inputFile = open(path.join(root,fname), 'r+')
                data = inputFile.read()
                free_chains = re.search(minRE,data)
                autres = set(pat_others.findall(data))
                if autres:
                    cles = map(str,xrange(1,len(autres)+1))
                    deek_autres = dict(zip(cles,autres))
                    bla = "\nJ'ai trouve des occurences de "+x+" a l'interieur de mots.\n"\
                          "Indiquer, au moyen de leur numero, celles que vous voulez substituer aussi:\n"\
                          "   0 :   ~ AUCUNE AUTRE ~\n"\
                          +'\n'.join( num.rjust(4)+' :   '+repr(deek_autres[num]) for num in sorted(deek_autres.keys()))\
                          +"\necrire les nos separes par des blancs : "
                    while 1:
                        linums = raw_input(bla).split()
                        if not linums:
                            bla = "\nUne reponse est demandee. Recommencez:\n ==> : "
                        elif '0' in linums and any(z!='0' for z in linums):
                            bla = "\nVous ne pouvez indiquer un autre nombre en sus de 0."\
                                  " Recommencez:\n ==> : "
                        elif '0' not in linums and any(w not in cles for w in linums):
                            bla = "\nSeuls les nombres  0  a  " + str(len(autres)+1)\
                                  + "  sont autorises. Recommencez:\n ==> : "
                        elif len(set(linums))!=len(linums):
                            bla = "\nVeuillez entrez des nombres tous differents."\
                                  " Recommencez:\n ==> : "
                        else:
                            break
                    linums.sort()
                    if linums!=['0']: # on remplace les x libres et d'autres
                        RENCORE = '|'.join("(?<="+((')'+x+'(?=').join(deek_autres[num].split(x)))+")"
                                       for num in linums )
                        data = re.sub(minRE + '|' + RENCORE,y,data)
                        done = "\nHaving replaced with '" + y + "' in " + fname + ' :\n'\
                               "free '"+x+"' chains , "\
                               + ' , '.join("'"+deek_autres[num]+"'" for num in linums)
                    elif free_chains: # on ne remplace que les x libres
                        data = re.sub(minRE,y,data)
                        done = "\nHaving replaced only free '"+x+"' chains with '" + y + "' in " + fname + '\n'
                    else:
                        done = "\nHaving replaced no occurence of '" + x + "'\n"\
                              "There was no occurence of free '" + x + " chain to replace in " + fname + '\n'
                elif free_chains:
                    data = re.sub(minRE,y,data)
                    done = "\nHaving replaced free '"+x+"' chains with '" + y + "' in " + fname + '\n'
                elif not path.getsize(root+'\\'+fname):
                    print "\nNo replacement to do: this file is empty.\n"
                    done = ''
                else:
                    print "\nNo replacement to do: this file isn't empty,"\
                          "\nbut there is no occurence of '"+x+"' to replace in it.\n"
                    done = ''
     
                if done:
                    inputFile.seek(0)
                    inputFile.write(data)
                    inputFile.flush()
                    fsync(inputFile.fileno())
                    print done
     
                inputFile.close()
     
     
    setpath = 'C:\\ESSAIC\\'
    searchandreplace('URDU', "AGLAGLA", setpath)
     
    ########################################################################
    print 8*'#########'
    for fnm in ('C:\\ESSAIC\\text un.c.txt',
                'C:\\ESSAIC\\texte deux.c.txt',
                'C:\\ESSAIC\\dedans\\wqer.c.txt',
                'C:\\ESSAIC\\dedans\\derty.c.txt',
                'C:\\ESSAIC\\dedans\\vide.c.txt'):
        print '\n-*-  '+fnm
        if not path.getsize(fnm):
            print '  Ce fichier est vide.'
        else:
            fu = open(fnm)
            print '\n'.join(repr(ligne) for ligne in fu.readlines())
            fu.close()
     
    rmtree('C:\\ESSAIC\\dedans\\')
    rmtree('C:\\ESSAIC\\')
    .

  7. #7
    Membre extrêmement actif
    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    1 418
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 1 418
    Points : 1 658
    Points
    1 658
    Par défaut remplacement d'une chaine / suite de caracteres dans un texte
    Mon code d’hier présente deux insuffisances:


    1)
    quand la chaîne à remplacer se trouve en tête ou en fin de fichier, elle n’est pas attrapée.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    “URDU   un.....“
    “  soixante    URDU“
    # ne sont pas attrapées par 
    minRE = '(?<=\s)'+x+'(?=\s)'
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    “URDUcolle.....“
    “......colleURDU“
    # ne sont pas attrapées par
    pat_others = re.compile('\s[^\s]+'+x+'[^\s]*\s|\s'+x+'[^\s]+\s')
    Pour y arriver, il faut utiliser \A et \Z dans la RE





    2)
    je veux attraper non seulement les chaînes x libres (avec minRE) mais aussi les mots = chaînes bordées par des blancs dans lesquels se trouve x (avec pat_others)

    Mais je me suis en plus mis en tête d’attraper chacun de ces mots ci avec le caractère qui le précède et le caractère qui le suit aussi, de façon à distinguer les mots ’ automne\t’ et ’ automne\r’ par exemple. Comme ça, pour le fun...

    C’est à ça que sert le \s dans les parties x+'[^\s]*\s et x+'[^\s]+\s de pat_others: les \s attrapent le premier caractère blanc après les caractères non-blancs qui constituent la fin d’un mot contenant x.

    Le hic, c’est que quand deux mots se suivent séparés par un seul caractère blanc, le second n’est pas attrapé parce que le moteur a déjà consommé le blanc intercalaire en attrapant le premier mot.



    Pour corriger cela, j’ai réécrit une RE qui attrape les mots avec le blanc précédent mais sans le blanc qui suit.
    Mais comme je veux avoir la chaîne constituée du mot et des deux blancs qui l’entoure, je suis obligé de faire un traitement un peu tortu.
    Il repose sur un enregistrement préalable des positions de toutes les occurences de x dans le texte, puis, s’il faut remplacer des x à l’intérieur de mots, sélectionner les positions qui donneront l’autorisation (au sein d’une fonction callback) de remplacer une occurence rencontrée lors de l’action de sub()


    Enfin bref, ça donne le code suivant, qui ne répond à aucune question posée, juste pour le fun, bien qu’il m’ait fait pas mal tirer la langue à cause de quelques points.


    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
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    from os import makedirs
    from os.path import isdir
    from shutil import rmtree
     
    #if isdir('C:\\ESSAIC\\dedans\\'):
    #    rmtree('C:\\ESSAIC\\dedans\\')
    #if isdir('C:\\ESSAIC\\'):
    #    rmtree('C:\\ESSAIC\\')
     
    makedirs('C:\\ESSAIC\\dedans\\')
     
    for fnm in ('C:\\ESSAIC\\texte un.c.txt',
                'C:\\ESSAIC\\texte deux.c.txt'):
        fu = open(fnm,'w') 
        texte12 = 'URDUgle fend,URDU\n'\
                  'soleil :URDU>> \fURDU URDU URDU\n'\
                  'le rURDUoi voile rURDUoi rURDUoi\n'\
                  'URDUPloyer et\tURDU fonte\n'\
                  'prunelles uRDU claires ;URDU\r\n'\
                  '\trURDUoi rURDUoi sel rURDUoi\n'\
                  'Le rURDUomain est un hyURDU'
        fu.write(texte12)
        fu.close()
     
    fu = open('C:\\ESSAIC\\texte trois.c.txt','w')
    texte3 = 'URDU--*  \fURDU URDU papyrus *--URDU'
    fu.write(texte3)
    fu.close()
     
    fu = open('C:\\ESSAIC\\texte quatre.c.txt','w')
    texte4 = 'URDU  \r\nURDU URDU palmierURDU URDU'
    fu.write(texte4)
    fu.close()
     
    fu = open('C:\\ESSAIC\\dedans\\wqer.c.txt','w')
    textewq = 'il URDU\nle  \fURDU URDU URDU\n'\
              'et\tURDU glycine \npois uRDU claires'
    fu.write(textewq)
    fu.close()
     
    fu = open('C:\\ESSAIC\\dedans\\derty.c.txt','w')
    texteko = 'hhfhfhfhgf kjhkgkgkg\nabcfgedfssubcd'
    fu.write(texteko)
    fu.close()
     
    fu = open('C:\\ESSAIC\\dedans\\vide.c.txt','w')
    fu.close()
     
    ###################################################
    from os import fsync,walk,path
    import re
     
    def searchandreplace(x, y, setpath):
        pat_xfree   = re.compile('((?<=\s)|(?<=\A))'+x+'((?=\s)|(?=\Z))')
        pat_xfree_and_mots = re.compile('(?:\s|\A)([^\s]*)'+x+'([^\s]*)')
        pat_x = re.compile(x)
        for root, dirs, files in walk(setpath):
            print (8*'---------')+\
                  '\nroot  = %r'\
                  '\ndirs  = %r'\
                  '\nfiles = %r\n' % (root,dirs,files)
            for fname in files:
                if not('.c' in fname or '.h' in fname) or '.csv' in fname :
                    continue
                print '-*-  Fichier  '+fname+ '   ----------------------'
                inputFile = open(path.join(root,fname), 'r+')
                data = inputFile.read()
                free_chains, deek_str, affiche, deek_pos, cnt = [],{},[],{},0
                for ma in pat_xfree_and_mots.finditer(data):
                    titch  = ma.group()
                    ending = ma.end()
                    if ending!=len(data): # on ajoute le caractere suivant si existe
                        titch = titch + data[ending]
                    if ma.group(1)==''==ma.group(2):
                        free_chains.append(ma.end(1))
                    elif titch not in deek_pos:
                        cnt += 1
                        deek_str[cnt] = titch
                        affiche.append(str(cnt).rjust(4) + ' :   ' + repr(titch))
                        deek_pos[cnt] = [ma.end(1)]
                    else:
                        deek_pos[cnt].append(ma.end(1))
                if cnt:  del ending,titch,ma
     
                if deek_pos:
                    bla = "\nJ'ai trouve des occurences de "+x+" a l'interieur de mots.\n"\
                          "Indiquer, au moyen de leur numero, celles que vous voulez substituer aussi:\n"\
                          "   0 :   ~ AUCUNE AUTRE ~\n"\
                          +'\n'.join( affiche )\
                          +"\necrire les nos separes par des blancs : "
                    while 1:
                        linums = map(int,raw_input(bla).split())
                        if not linums:
                            bla = "\nUne reponse est demandee. Recommencez:\n ==> : "
                        elif 0 in linums and any(z!=0 for z in linums):
                            bla = "\nVous ne pouvez indiquer un autre nombre en sus de 0."\
                                  " Recommencez:\n ==> : "
                        elif 0 not in linums and any(num not in deek_str for num in linums):
                            bla = "\nSeuls les nombres  0  a  " + str(cnt)\
                                  + "  sont autorises. Recommencez:\n ==> : "
                        elif len(set(linums))!=len(linums):
                            bla = "\nVeuillez entrez des nombres tous differents."\
                                  " Recommencez:\n ==> : "
                        else:
                            break
     
                    if linums!=[0]: # on remplace les x libres et d'autres
                        target = sum((li for (num,li) in deek_pos.iteritems()
                                       if num in linums ), []) + free_chains
                        def do(match, to_replace = target):
                            if match.start() in to_replace:  return y
                            else:  return x
                        data = pat_x.sub(do,data)
                        done = "\nHaving replaced with %r in %s:\n"\
                               "free %r chains  and  %r  in :\n%s\n"\
                               % (y,fname,x,x,
                                  ' , '.join(repr(deek_str[num]) for num in linums))
                    elif free_chains: # on ne remplace que les x libres
                        data = pat_xfree.sub(y,data)
                        done = "\nHaving replaced only free %r chains with %r in %s\n"\
                               % (x,y,fname)
                    else:
                        done = "\nHaving replaced no occurence of %r.\n"\
                              "There was no occurence of free %r chain to replace in %s\n"\
                              % (x,x,fname)
                elif free_chains:
                    data = pat_xfree.sub(y,data)
                    done = "\nHaving replaced free %r chains with %r in %s.\n"\
                           "There is no %r chain in any longer chain in this file.\n"\
                           % (x,y,fname,x)
                elif not path.getsize(root+'\\'+fname):
                    print "\nNo replacement to do: this file is empty.\n"
                    done = ''
                else:
                    print "\nNo replacement to do: this file isn't empty,"\
                          "\nbut there is no occurence of %r to replace in it.\n"\
                          %(x,)
                    done = ''
     
                if done:
                    inputFile.seek(0)
                    inputFile.write(data)
                    inputFile.flush()
                    fsync(inputFile.fileno())
                    print done
     
                inputFile.close()
     
     
    setpath = 'C:\\ESSAIC\\'
    searchandreplace('URDU', "AGLAGLA", setpath)
     
    ########################################################################
     
    for fnm,texte in (('C:\\ESSAIC\\texte un.c.txt',texte12),
                      ('C:\\ESSAIC\\texte deux.c.txt',texte12),
                      ('C:\\ESSAIC\\texte trois.c.txt',texte3),
                      ('C:\\ESSAIC\\texte quatre.c.txt',texte4),
                      ('C:\\ESSAIC\\dedans\\wqer.c.txt',textewq),
                      ('C:\\ESSAIC\\dedans\\derty.c.txt',texteko),
                      ('C:\\ESSAIC\\dedans\\vide.c.txt','')):
        print 8*'========='+'\n-*-  '+fnm
        if not path.getsize(fnm):
            print '  Ce fichier est vide.'
        else:
            fu = open(fnm)
            print 'AVANT:\n'\
                  +'\n'.join(repr(lulu) for lulu in texte.splitlines(1))\
                  +'\nAPRES:\n'\
                  +'\n'.join(repr(ligne) for ligne in fu.readlines())
            fu.close()
     
    rmtree('C:\\ESSAIC\\dedans\\')
    .

  8. #8
    Membre à l'essai
    Inscrit en
    Juillet 2010
    Messages
    28
    Détails du profil
    Informations forums :
    Inscription : Juillet 2010
    Messages : 28
    Points : 23
    Points
    23
    Par défaut
    Merci a vous pour toutes ces reponses. Je me suis base sur une version light du code d'Eyquem avec les pattern proposees par Wiztricks.

    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
    def searchandreplace(x, y, setpath):
       minRE = '\\b'+x+'\\b'
       for root, dirs, files in os.walk(setpath):
          fname = files
          for fname in files:
             if ('.c' in fname or '.h' in fname) and not '.csv' in fname:
                inputFile = open(os.path.join(root,fname), 'r+')
                data = inputFile.read()
                free_chains = re.search(minRE,data)
                if free_chains:
                   #print free_chains
                   data = re.sub(minRE,y,data)
                   done = "\nHaving replaced free '"+x+"' chains with '" + y + "' in " + fname + '\n'
                else:
                    #print "\nNo replacement to do: this file isn't empty,"\
                    #      "\nbut there is no occurence of '"+x+"' to replace in it.\n"
                    done = ''
     
                if done:
                    inputFile.seek(0)
                    inputFile.write(data)
                    inputFile.flush()
                    fsync(inputFile.fileno())
    Si vous voulez encore vous creuser les meninges pour le plaisir, je suis en train d'optimiser cette fonction pour pouvoir remplacer des structures . Par exemple:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    typedef struct
    {
    blabla
    }Ma_struct;
    deviendra
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    struct Ma_struct
    {
    blabla
    };
    Enfin bon je devrai m'en sortir
    Bonne fin de journee a vous.

Discussions similaires

  1. Gros soucis pour gérer un seul déplacement!
    Par senseii dans le forum SDL
    Réponses: 2
    Dernier message: 13/01/2007, 11h28
  2. Auto-complétion pour les mots clés Begin/End
    Par Alex Laforest dans le forum EDI
    Réponses: 2
    Dernier message: 21/09/2005, 21h26
  3. Réponses: 6
    Dernier message: 23/05/2005, 15h38
  4. [MSSQL] Problème pour sélectionner une seule occurence
    Par Tinfolley dans le forum Langage SQL
    Réponses: 4
    Dernier message: 02/07/2004, 09h02
  5. Syntaxe pour avoir un seul resultat dans une requete
    Par Pompil dans le forum Requêtes
    Réponses: 2
    Dernier message: 06/09/2003, 15h51

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo