Discussion :

[jujulips]

Hello

je débute en python, pour le moment le Batch me suffisait pour retraiter automatiquement mes fichiers txt.
Mais voila après de multiples recherches sur internet je calle pour copier une collone d'un fichier texte délimité par des espaces et le coller dans un nouveau fichier texte.
Quelqu'un peut il me donner un coup de pouce ?


Merci d'avance !

[mont29]

je suppose que ton fichier d’entrée est du style:

Code :

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

1
2
3
aaa bbbb    ccccc
ddd  ee f
a third line

Tu dois « éclater » chaque ligne en un tableau, puis en récupérer l’élément qui t’intéresse. Par exemple:

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
 
# Ouvrir le fichier source et y récupérer la colonne voulue
result = []
file = open("chemin/vers/fichier.txt", "r")
for line in file:
    # Ajoute à result le deuxième élément de chaque ligne
    # string.split() sans argument découpe la string selon les espaces :D
    result.append(line.split()[1])
 
file.close()
 
# Reste à écrire tout ça dans le fichier de sortie…
file = open("chemin/vers/fichier/a/ecrire.txt", "w")
# Ici, on écrit tout d’un coup, en rassemblant tous les éléments de résult dans
# une seule string, séparés par un retour à la ligne ("\n")
file.write("\n".join(result))
file.close()

[PauseKawa]

Bonjour,

test.txt

Code :

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

1
2
3
col1 100 12
col2 101 13
col3 102 14

Code Python

Code :

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

1
2
3
4
with open('outtest.txt', 'w') as outfile:
    with open('test.txt', 'r') as infile:
        for l in infile.readlines():
            outfile.write(l.split( )[0] + '\n')

Fichier en sortie (outttest.txt)

Code :

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

1
2
3
col1
col2
col3

@+

Edit : Tu sélectionne la colonne ici l.split( )[0]

[PauseKawa]

Et un petit bonus Python 3

Code :

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

1
2
3
with open('outtest.txt', 'w') as outfile, open('test.txt', 'r') as infile:
    for l in infile.readlines():
        outfile.write(l.split( )[0] + '\n')

@++

[mont29]

Plus court et plus élégant, PauseKawa – faut vraiment que je me mette à utiliser with

[fatbob]

Et un petit bonus Python 3

Code :

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

1
2
3
with open('outtest.txt', 'w') as outfile, open('test.txt', 'r') as infile:
    for l in infile.readlines():
        outfile.write(l.split( )[0] + '\n')

@++

Pourquoi le readlines() ?

Code :

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

1
2
3
with open('outtest.txt', 'w') as outfile, open('test.txt', 'r') as infile:
    for l in infile:
        outfile.write(l.split( )[0] + '\n')

Fonctionne aussi... Et ça évite le chargement du fichier complet en mémoire. Y a-t-il un avantage à mettre le readlines() ?

Sinon, pour le fun, la version oneliner

Code :

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

open('outtest.txt', 'w').write("\n".join([l.split( )[0] for l in open('test.txt', 'r')]))

[PauseKawa]

Bonsoir,

Y a-t-il un avantage à mettre le readlines()

Ben... En fait non je pense.
readlines() fonctionne sur le principe l.read().split('\n') alors que for l in infile c'est plutôt iter(l). A confirmer.
Utiliser readlines() est avoir du deprecated par la suite (vu les évolutions) ?
for l in infile me semble direct alors que readlines() fais un appel externe (certes à un Builtin) : A tester avec time sur un gros fichier.

Ceci dit pour ce qui est des oneliner et des pythoneries cela me rappelle un sujet. : Retour aux sources > lisible et 'simple'

@+

[PauseKawa]

Bonjour,

Y a-t-il un avantage à mettre le readlines() ?

Ben... En fait non, définitivement.

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
def test1():
    with open('outtest1.txt', 'w') as outfile:
        with open('test.txt', 'r') as infile:
            for l in infile.readlines():
                outfile.write(l.split( )[0] + '\n')
 
def test2():
    with open('outtest2.txt', 'w') as outfile:
        with open('test.txt', 'r') as infile:
            for l in infile:
                outfile.write(l.split( )[0] + '\n')
 
def test3():
    with open('outtest3.txt', 'w') as outfile:
        with open('test.txt', 'r') as infile:
            for l in iter(infile):
                outfile.write(l.split( )[0] + '\n')
 
def test4():
    open('outtest4.txt', 'w').write("\n".join([l.split( )[0] for l in
        open('test.txt', 'r')]))
 
import time
 
def testfunc(func, t):
    print('test de ' + func.__name__ + ':')
    r = []
    for t in range(t):
        t1 = time.clock()
        func()
        t2 = time.clock()
        r.append(t2-t1)
    return sum(r)/len(r)
 
print('readlines() ' + str(testfunc(test1, 10)))
print('for l in infile ' + str(testfunc(test2, 10)))
print('iter(infile) ' + str(testfunc(test3, 10)))
print('oneshoot ;) ' + str(testfunc(test4, 10)))

test de test1:
readlines() 21.292999999999999
test de test2:
for l in infile 20.298000000000002
test de test3:
iter(infile)' 20.195
test de test4:
oneshoot 13.761000000000001

Il en ressort de mes tests que les résultats de readlines sont complètements aléatoires et globalement plus lents.
La version oneliner est toujours la plus rapide.

Donc

Ceci dit pour ce qui est des oneliner et des pythoneries cela me rappelle un sujet. : Retour aux sources > lisible et 'simple'

Disons que je n'ai rien dit.

@+

[fatbob]

Bonjour,
La version oneliner est toujours la plus rapide.

Donc

Disons que je n'ai rien dit.

@+

Je n'avais jamais fait de test... C'est intéressant :-)
En réalité (comme noté dans le post), c'est plutôt pour le fun. Pour ma part, j'utilise ce genre de truc lorsque je fais des traitements de fichiers jetables parce que c'est souvent plus ardu à maintenir et à débugger.
La remarque est donc tout à fait pertinente, au contraire, parce que la performance n'est clairement pas le seul critère pour définir un bon programme. A mon avis, la maintenabilité passe avant.
La recherche de la performance n'est utile que lorsque cela présente un intérêt (pas mal, hein, cet argument :-) ). Si l'utilisateur ne se rend compte de rien...

Par contre, je pense que c'est très instructif d'approfondir les list comprehensions car c'est un outil franchement puissant et qui permet souvent d'écrire de façon très concise des instructions dont le détail n'est pas intéressant pour la compréhension de l'algorithme.
Genre :

Code :

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

1
2
 
for l in [l for l in my_file if l.strip() != '']:

Les one liners sont, à mon avis, intéressants dans cette optique et c'est plutôt pour cette raison que je l'avais postée, n'ayant rien à ajouter sur les façons conventionnelles que vous avez parfaitement décrites.

Voici d'ailleurs, en bonus, un lien intéressant pour l'utilisation des lists comprehensions et autres générateurs dans le traitement de fichiers

http://www.dabeaz.com/generators/

[PauseKawa]

+1 Lorsque tu écrit ton code, pense à demain lorsque tu le liras.

La recherche de la performance n'est utile que lorsque cela présente un intérêt (pas mal, hein, cet argument :-) ).

Oui, par contre la suite...

Si l'utilisateur ne se rend compte de rien...

Par contre c'est bien de tester : Dans le lien que j'ai donner on en arrive à la conclusion que la fonction toute simple issorted et préférable au niveau lisibilité (difficile de faire mieux) et rapidité. Ma remarque était dans ce sens.
Cela n'enlève en rien à la puissance des list comprehensions (à comprendre à tout pris) mais donne à réfléchir quand même pour ce qui est de la notion de code 'optimisé'.

@+

[dividee]

Bonsoir,

En réalité, l'utilisation d'une list comprehension n'y est pas pour beaucoup dans la rapidité de la fonction test4; c'est surtout le fait qu'on ne fait qu'une seul write qui donne cette différence. La fonction suivante est presque aussi rapide et n'utilise pas de comprehension:

Code :

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

1
2
3
4
5
6
7
def test5():
    with open('outtest5.txt', 'w') as outfile:
        with open('test.txt', 'r') as infile:
            result = []
            for l in infile:
                result.append(l.split()[0])
            outfile.write('\n'.join(result))

Evidemment, cela semble artificiel ne pas utiliser de comprehension dans ce contexte... Ma version préférée est donc celle-ci:

Code :

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

1
2
3
4
def test6():
    with open('outtest6.txt', 'w') as outfile:
        with open('test.txt', 'r') as infile:
            outfile.write('\n'.join(l.split()[0] for l in infile))

On garde la sécurité du context manager tout en utilisant une generator expression (pourquoi en faire une list comprehension en ajoutant une paire de crochets ?).
Mais si le fichier en entrée est vraiment très gros, il vaut mieux échanger un peu de vitesse contre une utilisation de mémoire constante en utilisant test2.

[PauseKawa]

Bonjour dividee,

En réalité, l'utilisation d'une list comprehension n'y est pas pour beaucoup dans la rapidité de la fonction test4; c'est surtout le fait qu'on ne fait qu'une seul write qui donne cette différence.

Passons à la suite...

(pourquoi en faire une list comprehension en ajoutant une paire de crochets ?).

Dans le cadre de test4 et par rapport à

Code :

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

1
2
    open('outtest9.txt', 'w').write("\n".join(l.split( )[0] for l in
        open('test.txt', 'r')))

le gain n'est pas négligeable.

test de test4:
2.862
test de test9:
3.03

Ce qui n'est pas le cas dans le cadre d'un code plus lisible

Code :

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

1
2
3
4
5
6
7
8
9
def test6():
    with open('outtest6.txt', 'w') as outfile:
        with open('test.txt', 'r') as infile:
            outfile.write('\n'.join(l.split()[0] for l in infile))
 
def test8():
    with open('outtest8.txt', 'w') as outfile:
        with open('test.txt', 'r') as infile:
            outfile.write("\n".join([l.split( )[0] for l in infile]))

test de test6:
2.967
test de test8:
2.999

Dans ce cas là autant s'en passer effectivement.

J'aime bien le code de test6 aussi.

@+

Edit : Pour ce qui est du résultat par rapport aux précédents j'ai réduit le fichier test.txt au quart.