Discussion :

[Chefcou]

Bonjour,
Je voulais savoir le nom de l'opérateur que je dois utiliser pour supprimer des lignes d'un fichier txt en utilisant python.
Merci

[Captain'Flam]

Le plus simple est d'ouvrir 2 fichiers :
- l'original en lecture
- un nouveau en écriture
Tu lis ton fichier original ligne par ligne.
Pour chaque ligne, si tu veux la conserver, tu l'écris dans ton nouveau fichier.
Si tu veux l'effacer, tu ne l'écris pas.
A la fin, tu fermes les 2 fichiers.
L'original n'aura pas changé.
Le nouveau sera la copie de l'original moins les lignes que tu n'auras pas copiées.

[ZZelle]

Bonjour,
Je voulais savoir le nom de l'opérateur que je dois utiliser pour supprimer des lignes d'un fichier txt en utilisant python.
Merci

Il n'y a pas de fonction pour faire ce genre de choses (en python, et aussi dans tous les langages que je connais). Du coup on doit écrire un nouveau fichier qui contient que ce qu'on ne va pas supprimer ; ceci donne un programme du type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
def to_delete(line):
    # some line based condition
 
with open('file.source') as source, open('file.target', 'w') as target:
    for source_line in source:
        if not to_delete(source_line):
            target.write(source_line)

[fred1599]

Du coup on doit écrire un nouveau fichier qui contient que ce qu'on ne va pas supprimer

T'es sûr?

[wiztricks]

Salut,

Lorsqu'on supprime des lignes, il n'est pas indispensable d'écrire un nouveau fichier: on peut ré-écrire "à la place" des lignes supprimées sans altérer ce qui n'a pas été encore lu.

Cela demande de maîtriser les .tell .seek et gérer ses fins de lignes.
La mise au point d'un tel code est (aujourd'hui) trop compliqué vu le prix du GBi de stockage.

Par contre, si on doit "ajouter" des lignes ailleurs qu'à la fin...
Cordialement,
- W

[plxpy]

Bonjour,

Si l'on doit filtrer certaines lignes, on n'est pas obligé de travailler avec 2 fichiers (un fichier ouvert en lecture, un autre ouvert en écriture) et on peut ouvrir le fichier à traiter en mode "mise à jour". Cela complique un peu l'algorithme et oblige effectivement à jouer avec file.seek() et file.tell(), à conserver un "pointeur en écriture" et à tronquer, si besoin (quand certaines lignes ont été mises de côté), le fichier à la fin.

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
# -*- coding:utf-8 -*-
 
import sys
 
def line_filter(pathname,line_to_keep):
 
    # pathname est le chemin du fichier texte à mettre à jour
    # line_to_keep est une fonction qui prend une ligne comme seul paramètre et retourne un booléen
    # qui indique si la ligne doit être gardée (True) ou non (False).
 
    # offset en écriture initialisé à 0
    write_offset = 0
 
    # ouverture en mise à jour avec r+, on est en début de fichier (offset 0) au départ
    f = open(pathname,'r+')
 
    line = f.readline()
    while line:
 
        # si la ligne est à garder
        if line_to_keep(line):
 
            # taille de la ligne courante et offset courant
            line_length, read_offset = len(line), f.tell()
 
            # si, jusqu'à maintenant, tout n'a pas été gardé
            if write_offset + line_length != read_offset:
                f.seek(write_offset)    # positionnement à l'offset d'écriture
                f.write(line)           # écriture de la ligne
                f.seek(read_offset)     # retour/positionnement à l'offset de lecture
 
            # dans tous les cas (écriture effective ou pas), incrémentation de l'offset d'écriture
            write_offset += line_length
 
        # la ligne est à oublier : on ne fait RIEN
        # (ici, un simple affichage pour suivre le déroulement de la fonction)
        else:
            print "ligne '%s' ignorée" % line.strip()
 
        line = f.readline()
 
    # dans tous les cas, <write_offset> donne la taille effective du fichier résultat
    # la troncature est indispensable si toutes les lignes n'ont pas été gardées
    # un test "if write_offset != f.tell():" pourrait être ajouté avant la troncature
    f.truncate(write_offset)
 
    f.close()
 
if __name__ == '__main__':
 
    if sys.argv[2] == 'True':
        line_to_keep = lambda l: True
 
    elif sys.argv[2] == 'False':
        line_to_keep = lambda l: False
 
    else:
        line_to_keep = eval(sys.argv[2])
 
    line_filter(sys.argv[1],line_to_keep)

A l'utilisation :

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
$ more jours
lundi
mardi
mercredi
jeudi
vendredi
samedi
dimanche
$ python filter.py jours True
$ more jours
lundi
mardi
mercredi
jeudi
vendredi
samedi
dimanche
$ python filter.py jours "lambda l:len(l.strip()) <= 5 or l.startswith('di')"
ligne 'mercredi' ignorée
ligne 'vendredi' ignorée
ligne 'samedi' ignorée
$ more jours
lundi
mardi
jeudi
dimanche
$ python filter.py jours False
ligne 'lundi' ignorée
ligne 'mardi' ignorée
ligne 'jeudi' ignorée
ligne 'dimanche' ignorée
$ more jours
$

Procéder de la sorte est didactique et formateur mais est-ce que le jeu en vaut la chandelle ?

Enfin, s'il s'agit d'ajouter, ça et là (et pas seulement en fin de fichier), des lignes, on peut aussi ne manipuler qu'un seul fichier mais la gymnastique est (encore) plus compliquée.