Selectionner une colonne et la copier

Version imprimable

17/04/2011, 19h38
jujulips

Selectionner une colonne et la copier

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 !

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

Code:

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:

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()

Bonjour,

test.txt
Code:

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

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:

1 2 3 col1 col2 col3
@+

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

Et un petit bonus Python 3

Code:

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')

@++

17/04/2011, 21h22
mont29

Plus court et plus élégant, PauseKawa – faut vraiment que je me mette à utiliser with ;)
20/04/2011, 14h17
fatbob
Citation:
Envoyé par PauseKawa

Et un petit bonus Python 3

Code:

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:

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:

open('outtest.txt', 'w').write("\n".join([l.split( )[0] for l in open('test.txt', 'r')]))
20/04/2011, 21h58
PauseKawa

Bonsoir,

Citation:

Envoyé par fatbob

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' ;)

@+

Bonjour,

Citation:

Envoyé par fatbob

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

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

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
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)))

Citation:

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

Citation:

Envoyé par PauseKawa

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.

@+

21/04/2011, 09h54
fatbob
Citation:

Envoyé par PauseKawa

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:

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/
21/04/2011, 10h32
PauseKawa

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

Citation:

Envoyé par fatbob

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...

Citation:

Envoyé par fatbob

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

:lol:

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é'.

@+

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:

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:

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.

Bonjour dividee,

Citation:

Envoyé par 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.

:oops: Passons à la suite...

Citation:

Envoyé par dividee

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

Dans le cadre de test4 et par rapport à
Code:

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.

Citation:

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:

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]))
Citation:

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.