Expression régulière pour supprimer les sauts de ligne

Je suis un débutant complet à Python, et je suis coincé avec un problème de regex. Je suis en train de supprimer le caractère de saut de ligne à la fin de chaque ligne d'un fichier texte, mais seulement si elle suit une lettre en minuscule, c'est à dire [a-z]. Si la fin de la ligne se termine dans une lettre minuscule, je veux remplacer le saut de ligne/caractère de saut de ligne avec un espace.

C'est ce que j'ai obtenu jusqu'à présent:

import re
import sys

textout = open("output.txt","w")
textblock = open(sys.argv[1]).read()
textout.write(re.sub("[a-z]\z","[a-z] ", textblock, re.MULTILINE) )
textout.close()

source d'informationauteur Jean77

  1. 21

    Essayer 

    re.sub(r"(?<=[a-z])\r?\n"," ", textblock)

    \Z ne corresponde qu'à la fin de la chaîne, après le dernier saut de ligne, donc ce n'est certainement pas ce que vous avez besoin ici. \z n'est pas reconnu par le Python moteur d'expressions régulières.

    (?<=[a-z]) est un positif lookbehind affirmation qui vérifie si le caractère avant la position actuelle est une minuscule caractère ASCII. Seulement alors, le moteur de regex va essayer de faire correspondre un saut de ligne.

    Aussi, toujours utiliser des chaînes de caractères avec regexes. Rend les barres obliques inverses plus facile à manipuler.

  2. 2

    Tout aussi une alternative la réponse, même si cela prend plus de lignes, je pense que le suivant peut-être plus évident depuis l'expression régulière est plus simple:

    import re
import sys

with open(sys.argv[1]) as ifp:
    with open("output.txt", "w") as ofp:
        for line in ifp:
            if re.search('[a-z]$',line):
                ofp.write(line.rstrip("\n\r")+" ")
            else:
                ofp.write(line)

    ... et qui évite de charger le fichier entier en chaîne de caractères. Si vous souhaitez utiliser le moins de lignes, mais tout de même éviter de postive lookbehind, vous pouvez faire:

    import re
import sys

with open(sys.argv[1]) as ifp:
    with open("output.txt", "w") as ofp:
        for line in ifp:
            ofp.write(re.sub('(?m)([a-z])[\r\n]+$','\ ',line))

    Les pièces de cette expression régulière sont:

    • (?m) [tournez sur la correspondance multi-ligne]
    • ([a-z]) [correspondre à un seul minuscule que le premier groupe]
    • [\r\n]+ [correspondre à un ou plusieurs des retours de chariot ou de retours à la ligne, à couvrir \n\r\n et \r]
    • $ [correspondre à la fin de la chaîne]

    ... et si cela correspond à la ligne, la lettre minuscule et de fin de ligne sont remplacés par \\1qui sera d'une lettre minuscule suivie par un espace.

  3. 1

    mon point était que le fait d'éviter à l'aide de positif lookbehind peut rendre le code plus lisible

    OK. Bien que, personnellement, je ne trouve pas que c'est moins lisible. C'est une question de goût.

    Dans votre EDIT:

    • D'abord, (?m) n'est pas nécessaire puisque pour dans la ligne de l'ifp: sélectionne une ligne à la fois et donc il y a un seul saut de ligne à la fin de chaque ligne de la chaîne de

    • Deuxièmement, $ comme il est placé, n'a pas d'utilité, car il sera toujours correspondre à la fin de la ligne de chaîne.

    Toute façon, l'adoption de votre point de vue, j'ai trouvé deux manières d'éviter la lookbehind affirmation:

    with open(sys.argv[1]) as ifp:
    with open("output.txt", "w") as ofp:
        for line in ifp:
            ante_newline,lower_last = re.match('(.*?([a-z])?$)',line).groups()
            ofp.write(ante_newline+' ' if lower_last else line)

    et

    with open(sys.argv[1]) as ifp:
    with open("output.txt", "w") as ofp:
        for line in ifp:
            ofp.write(line.strip('\r\n')+' ' if re.search('[a-z]$',line) else line)

    le deuxième est le meilleur: une seule ligne , une simple correspondance de test, pas besoin de groupes (de), naturellement logique

    EDIT: oh, je me rends compte que ce deuxième code est tout simplement votre premier code réécrit en une seule ligne, Longair