Bonjour, j'ai besoin de transformer en format csv d=E9limit=E9, des
fichiers fixes.
Le probl=E8me c'est que ces fichiers peuvent =EAtre tr=E8s gros, plusieurs
millions de lignes et plusieurs milliers de caract=E8res par ligne.
J'ai donc =E9crit ce code sous windows en Python 2.5.2, qui, je pense
pourrait =EAtre bien optimis=E9.
Merci d'avance pour vos suggestions.
=3D=3D=3D=3D=3D=3D=3D=3D=3D
# _*_ coding: utf8 _*_
#!/usr/bin/env python
# Auteur : Philippe Lotton
# Date de cr=E9ation:
import sys
import datetime
if __name__ =3D=3D '__main__':
args =3D sys.argv[1:]
if len(args) =3D=3D 2: # 2 param=E8tres obligatoires
fic_entree =3D args[0] # Fichier source
fic_format =3D args[1] #Fichier format
else:
print '''Vous devez passez 2 arguments, le fichier source et
le fichier param=E8tre
ex: csv.py MonFic.txt MonFormat.txt
Le fichier source doit avoir des enregistrements de longueurs
fixes.
Le fichier format doit =E8tre de la forme: position , longueur
<rc>,
autant de ligne que de champs dans le fichier source.
'''
exit()
print datetime.datetime.now().time()
fic_param =3D open('format.txt', "r") # Lecture du fichier
param=E8tre
format =3D fic_param.readlines() # Cr=E9ation tableaux
des param=E8tres
fic_param.close()
fic_out =3D open('csv.txt', 'w') #Ouverture fichier de sortie
fic_source =3D open(fic_entree, 'r') # Lecture du fichier
source
while 1: #
ligne_source =3D fic_source.readline()
if ligne_source =3D=3D'':
break
else :
ligne_cible =3D '' # Ligne de sortie =E9crite dans
le fichier
for j in format:
params =3D j.split(',') #Cr=E9ation d'un
tableau de param=E8tres
pos1 =3D int(params[0])-1 #Position 1
pos2 =3D pos1 + int(params[1]) #Position 2
temp =3D ligne_source[ pos1:pos2]
ligne_cible =3D ligne_cible + temp + ',' #
Concat=E9nation
ligne_cible =3D ligne_cible[0:-1]
fic_out.write(ligne_cible + "\n")
ligne_cible =3D ''
fic_source.close()
fic_out.close()
print datetime.datetime.now().time()
exit()
Je pensais améliorer les choses en remplacant la concaténation de ma chaine un append dans un tableau, puis un join
(...)
Excès d'autosatisfaction, c'est quif quif, 18s, sur 1 000 000 d'enregistrement avec cette structure
Ah oui, à ce sujet l'implémentation CPython optimise automatiquement les longues suites de concaténations dans une même string de la façon dont tu le fais.
Plus ou moins... la version avec un assignement augmenté (s += xxx) est un poil plus rapide que celle avec un réassignement (s = s + xxx)
Un petit bench valant mieux qu'un long discours:
from timeit import Timer repeat = xrange(100000)
def concat(): s = '' for i in repeat: s = s + 'aaaaa'
def concat_aug(): s = '' for i in repeat: s += 'aaaaa'
def append_join(): s = [] for i in repeat: s.append('aaaaa') s = ''.join(s)
def local_append_join(): s = [] append = s.append for i in repeat: append('aaaaa') s = ''.join(s)
def comp_join(): s = ''.join('aaaaa' for i in repeat)
Le mauvais résultat de append_join par rapport à local_append_join s'explique par le hit dû au lookup de list.append, suivi de l'instanciation de l'objet méthode. Comme quoi cette simple optimisation (localiser les methodes appelées dans une boucle 'intensive') est très payante. Par contre, dans le cas de l'OP, je ne sais pas si ce sera vraiment plus intéressant (pour la boucle intérieure de do_import) dans la mesure où c'est, justement dans une boucle imbriquée. Mais bon, pil, tu peux tester les deux... AMHA, selon le jeu d'essai (données sources), tu aura des résultats en faveur tantôt de la solution local_append_join, tantôt en faveur de la solution comp_join.
Avec une version un peu plus ancienne de Python, tu aurais certainement vu une très grande amélioration.
Aucun doute....
Christophe a écrit :
pil91 a écrit :
(snip)
Je pensais améliorer les choses en remplacant la concaténation de ma
chaine un append dans un tableau, puis un join
(...)
Excès d'autosatisfaction, c'est quif quif, 18s, sur 1 000 000
d'enregistrement avec cette structure
Ah oui, à ce sujet l'implémentation CPython optimise automatiquement les
longues suites de concaténations dans une même string de la façon dont
tu le fais.
Plus ou moins... la version avec un assignement augmenté (s += xxx) est
un poil plus rapide que celle avec un réassignement (s = s + xxx)
Un petit bench valant mieux qu'un long discours:
from timeit import Timer
repeat = xrange(100000)
def concat():
s = ''
for i in repeat:
s = s + 'aaaaa'
def concat_aug():
s = ''
for i in repeat:
s += 'aaaaa'
def append_join():
s = []
for i in repeat:
s.append('aaaaa')
s = ''.join(s)
def local_append_join():
s = []
append = s.append
for i in repeat:
append('aaaaa')
s = ''.join(s)
def comp_join():
s = ''.join('aaaaa' for i in repeat)
Le mauvais résultat de append_join par rapport à local_append_join
s'explique par le hit dû au lookup de list.append, suivi de
l'instanciation de l'objet méthode. Comme quoi cette simple optimisation
(localiser les methodes appelées dans une boucle 'intensive') est très
payante. Par contre, dans le cas de l'OP, je ne sais pas si ce sera
vraiment plus intéressant (pour la boucle intérieure de do_import) dans
la mesure où c'est, justement dans une boucle imbriquée. Mais bon, pil,
tu peux tester les deux... AMHA, selon le jeu d'essai (données sources),
tu aura des résultats en faveur tantôt de la solution local_append_join,
tantôt en faveur de la solution comp_join.
Avec une version un peu plus ancienne de Python, tu aurais
certainement vu une très grande amélioration.
Je pensais améliorer les choses en remplacant la concaténation de ma chaine un append dans un tableau, puis un join
(...)
Excès d'autosatisfaction, c'est quif quif, 18s, sur 1 000 000 d'enregistrement avec cette structure
Ah oui, à ce sujet l'implémentation CPython optimise automatiquement les longues suites de concaténations dans une même string de la façon dont tu le fais.
Plus ou moins... la version avec un assignement augmenté (s += xxx) est un poil plus rapide que celle avec un réassignement (s = s + xxx)
Un petit bench valant mieux qu'un long discours:
from timeit import Timer repeat = xrange(100000)
def concat(): s = '' for i in repeat: s = s + 'aaaaa'
def concat_aug(): s = '' for i in repeat: s += 'aaaaa'
def append_join(): s = [] for i in repeat: s.append('aaaaa') s = ''.join(s)
def local_append_join(): s = [] append = s.append for i in repeat: append('aaaaa') s = ''.join(s)
def comp_join(): s = ''.join('aaaaa' for i in repeat)
Le mauvais résultat de append_join par rapport à local_append_join s'explique par le hit dû au lookup de list.append, suivi de l'instanciation de l'objet méthode. Comme quoi cette simple optimisation (localiser les methodes appelées dans une boucle 'intensive') est très payante. Par contre, dans le cas de l'OP, je ne sais pas si ce sera vraiment plus intéressant (pour la boucle intérieure de do_import) dans la mesure où c'est, justement dans une boucle imbriquée. Mais bon, pil, tu peux tester les deux... AMHA, selon le jeu d'essai (données sources), tu aura des résultats en faveur tantôt de la solution local_append_join, tantôt en faveur de la solution comp_join.
Avec une version un peu plus ancienne de Python, tu aurais certainement vu une très grande amélioration.
Aucun doute....
Bruno Desthuilliers
pil91 a écrit : (snip)
Je pensais améliorer les choses en remplacant la concaténation de ma chaine un append dans un tableau, puis un join
---- else : sortie = [] for j in format: params = j.split(',') #Création d'un tableau de paramètres pos1 = int(params[0])-1 #Position 1 pos2 = pos1 + int(params[1]) #Position 2 temp = ligne_source[ pos1:pos2] sortie.append(temp)
Tu gagnerais beaucoup en 'localisant' la méthode append, cf mon autre post en réponse à Christophe.
result = ','.join(sortie) out.write(result + "n") sortie = [] fic_source.close() out.close() --- Excès d'autosatisfaction, c'est quif quif, 18s, sur 1 000 000 d'enregistrement avec cette structure
Ce que je trouve amusant, c'est que tu n'ai toujours pas vu ce qui est très probablement le problème majeur de ton code !-)
pil91 a écrit :
(snip)
Je pensais améliorer les choses en remplacant la concaténation de ma
chaine un append dans un tableau, puis un join
----
else :
sortie = []
for j in format:
params = j.split(',') #Création d'un
tableau de paramètres
pos1 = int(params[0])-1 #Position 1
pos2 = pos1 + int(params[1]) #Position 2
temp = ligne_source[ pos1:pos2]
sortie.append(temp)
Tu gagnerais beaucoup en 'localisant' la méthode append, cf mon autre
post en réponse à Christophe.
result = ','.join(sortie)
out.write(result + "n")
sortie = []
fic_source.close()
out.close()
---
Excès d'autosatisfaction, c'est quif quif, 18s, sur 1 000 000
d'enregistrement avec cette structure
Ce que je trouve amusant, c'est que tu n'ai toujours pas vu
ce qui est très probablement le problème majeur de ton code !-)
Je pensais améliorer les choses en remplacant la concaténation de ma chaine un append dans un tableau, puis un join
---- else : sortie = [] for j in format: params = j.split(',') #Création d'un tableau de paramètres pos1 = int(params[0])-1 #Position 1 pos2 = pos1 + int(params[1]) #Position 2 temp = ligne_source[ pos1:pos2] sortie.append(temp)
Tu gagnerais beaucoup en 'localisant' la méthode append, cf mon autre post en réponse à Christophe.
result = ','.join(sortie) out.write(result + "n") sortie = [] fic_source.close() out.close() --- Excès d'autosatisfaction, c'est quif quif, 18s, sur 1 000 000 d'enregistrement avec cette structure
Ce que je trouve amusant, c'est que tu n'ai toujours pas vu ce qui est très probablement le problème majeur de ton code !-)
Christophe
Bruno Desthuilliers a écrit :
Christophe a écrit :
Bruno Desthuilliers a écrit :
Christophe a écrit :
pil91 a écrit :
Bonjour, j'ai besoin de transformer en format csv délimité, des fichiers fixes.
(snip)
C'est pas une suggestion d'optim (enfin, ça pourrait le devenir) mais y a-t-il une raison pour laquelle vous n'utilisez pas le module standard csv ?
Peut-être le fait que le format csv soit la cible, pas la source ?-)
Et ? Le module csv fait lecture et écriture.
Oui. Il lit effectivement des csv. Ce qui n'est pas le cas des fichiers sources de l'OP, ni la source de son problème.
Ah, je m'excuse, j'avais mal vu l'énoncé et je confondais le format du fichier de format avec le format du fichier d'entrée de données. Comme quoi il est mal de répondre à ce genre de questions pendant les heures de travail (même pendant une pause) : on va trop vite et on rate des choses importantes :)
Bruno Desthuilliers a écrit :
Christophe a écrit :
Bruno Desthuilliers a écrit :
Christophe a écrit :
pil91 a écrit :
Bonjour, j'ai besoin de transformer en format csv délimité, des
fichiers fixes.
(snip)
C'est pas une suggestion d'optim (enfin, ça pourrait le devenir)
mais y a-t-il une raison pour laquelle vous n'utilisez pas le module
standard csv ?
Peut-être le fait que le format csv soit la cible, pas la source ?-)
Et ? Le module csv fait lecture et écriture.
Oui. Il lit effectivement des csv. Ce qui n'est pas le cas des fichiers
sources de l'OP, ni la source de son problème.
Ah, je m'excuse, j'avais mal vu l'énoncé et je confondais le format du
fichier de format avec le format du fichier d'entrée de données. Comme
quoi il est mal de répondre à ce genre de questions pendant les heures
de travail (même pendant une pause) : on va trop vite et on rate des
choses importantes :)
Bonjour, j'ai besoin de transformer en format csv délimité, des fichiers fixes.
(snip)
C'est pas une suggestion d'optim (enfin, ça pourrait le devenir) mais y a-t-il une raison pour laquelle vous n'utilisez pas le module standard csv ?
Peut-être le fait que le format csv soit la cible, pas la source ?-)
Et ? Le module csv fait lecture et écriture.
Oui. Il lit effectivement des csv. Ce qui n'est pas le cas des fichiers sources de l'OP, ni la source de son problème.
Ah, je m'excuse, j'avais mal vu l'énoncé et je confondais le format du fichier de format avec le format du fichier d'entrée de données. Comme quoi il est mal de répondre à ce genre de questions pendant les heures de travail (même pendant une pause) : on va trop vite et on rate des choses importantes :)
Christophe
pil91 a écrit :
On 10 sep, 17:03, Christophe wrote:
pil91 a écrit :
Bonjour, j'ai besoin de transformer en format csv délimité, des fichiers fixes. Le problème c'est que ces fichiers peuvent être très gros, plusieurs millions de lignes et plusieurs milliers de caractères par ligne. J'ai donc écrit ce code sous windows en Python 2.5.2, qui, je pense pourrait être bien optimisé. Merci d'avance pour vos suggestions. ======== >>> # _*_ coding: utf8 _*_ #!/usr/bin/env python # Auteur : Philippe Lotton # Date de création: import sys import datetime
C'est pas une suggestion d'optim (enfin, ça pourrait le devenir) mais y a-t-il une raison pour laquelle vous n'utilisez pas le module standard csv ? Au début, je pensais que vous aviez écrit votre solution pour justement être plus performant mais en regardant le source de csv.py, je constate que celui-ci délègue la majorité du travail à un module et C.
En fait si, c'est bien une suggestion d'optim après tout.
Je pensais améliorer les choses en remplacant la concaténation de ma chaine un append dans un tableau, puis un join
(...)
Excès d'autosatisfaction, c'est quif quif, 18s, sur 1 000 000 d'enregistrement avec cette structure
Ah oui, à ce sujet l'implémentation CPython optimise automatiquement les longues suites de concaténations dans une même string de la façon dont tu le fais. Avec une version un peu plus ancienne de Python, tu aurais certainement vu une très grande amélioration.
pil91 a écrit :
On 10 sep, 17:03, Christophe <chris.cavala...@free.fr> wrote:
pil91 a écrit :
Bonjour, j'ai besoin de transformer en format csv délimité, des
fichiers fixes.
Le problème c'est que ces fichiers peuvent être très gros, plusieurs
millions de lignes et plusieurs milliers de caractères par ligne.
J'ai donc écrit ce code sous windows en Python 2.5.2, qui, je pense
pourrait être bien optimisé.
Merci d'avance pour vos suggestions.
======== >>> # _*_ coding: utf8 _*_
#!/usr/bin/env python
# Auteur : Philippe Lotton
# Date de création:
import sys
import datetime
C'est pas une suggestion d'optim (enfin, ça pourrait le devenir) mais y
a-t-il une raison pour laquelle vous n'utilisez pas le module standard
csv ? Au début, je pensais que vous aviez écrit votre solution pour
justement être plus performant mais en regardant le source de csv.py, je
constate que celui-ci délègue la majorité du travail à un module et C.
En fait si, c'est bien une suggestion d'optim après tout.
Je pensais améliorer les choses en remplacant la concaténation de ma
chaine un append dans un tableau, puis un join
(...)
Excès d'autosatisfaction, c'est quif quif, 18s, sur 1 000 000
d'enregistrement avec cette structure
Ah oui, à ce sujet l'implémentation CPython optimise automatiquement les
longues suites de concaténations dans une même string de la façon dont
tu le fais. Avec une version un peu plus ancienne de Python, tu aurais
certainement vu une très grande amélioration.
Bonjour, j'ai besoin de transformer en format csv délimité, des fichiers fixes. Le problème c'est que ces fichiers peuvent être très gros, plusieurs millions de lignes et plusieurs milliers de caractères par ligne. J'ai donc écrit ce code sous windows en Python 2.5.2, qui, je pense pourrait être bien optimisé. Merci d'avance pour vos suggestions. ======== >>> # _*_ coding: utf8 _*_ #!/usr/bin/env python # Auteur : Philippe Lotton # Date de création: import sys import datetime
C'est pas une suggestion d'optim (enfin, ça pourrait le devenir) mais y a-t-il une raison pour laquelle vous n'utilisez pas le module standard csv ? Au début, je pensais que vous aviez écrit votre solution pour justement être plus performant mais en regardant le source de csv.py, je constate que celui-ci délègue la majorité du travail à un module et C.
En fait si, c'est bien une suggestion d'optim après tout.
Je pensais améliorer les choses en remplacant la concaténation de ma chaine un append dans un tableau, puis un join
(...)
Excès d'autosatisfaction, c'est quif quif, 18s, sur 1 000 000 d'enregistrement avec cette structure
Ah oui, à ce sujet l'implémentation CPython optimise automatiquement les longues suites de concaténations dans une même string de la façon dont tu le fais. Avec une version un peu plus ancienne de Python, tu aurais certainement vu une très grande amélioration.
Rakotomandimby (R12y) Mihamina
Bruno Desthuilliers wrote:
Ce que je trouve amusant, c'est que tu n'ai toujours pas vu ce qui est très probablement le problème majeur de ton code !-)
Sérieusement: - le nommage des variables? - les commentaires qui en remettent une couche? - l'absence de fonctions?
C'est peut-être hors sujet, mais, perso, lorsque j'utilise des fichiers avec enregistrements à longueur fixe, il n'y a pas de notion de ligne(s). Les données sont toutes accolées, sans séparateurs, ni de champs, ni d'enregistrements.
Du coup, j'ai modifié un peu ton exemple, en ce sens. Voir ci-dessous (mais, il faut que ça rentre en mémoire).
NB : pas testé.
J'ai, vu. Moi, j'ai testé, et j'ai corrigé deux ou trois détails.
Par contre, pour l'optimisation, je voulais comparer read() total et read(size) ; mais, avec 1 million d'enregistrements, sur mon Vista, ça ne prend que 3 secondes, alors...
@+ -- MCI
# -*- coding: utf-8 -*-
import sys import datetime
def parse_params(lines): params = [] for line in lines: line = line.strip() if not line: continue parts = line.split(',') pos1 = int(parts[0])-1 pos2 = pos1 + int(parts[1]) params.append(slice(pos1, pos2)) return params,pos2
def do_import(params, longenregistrement, fic_source, fic_out): write = fic_out.write sep = ',' join = sep.join data_source=fic_source.read() data=(data_source[i:i+longenregistrement] for i in range(0,len(data_source),longenregistrement)) for ligne_source in data: ligne_cible = [ligne_source[slice] for slice in params] write(join(ligne_cible) + "n")
def main(*args): fic_entree="MonFic.txt" fic_format="MonFormat.txt" """ try: fic_entree, fic_format = args except ValueError: sys.exit('''Vous devez passez 2 arguments, le fichier source et le fichier paramètre ex: csv.py MonFic.txt MonFormat.txt Le fichier source doit avoir des enregistrements de longueurs fixes. Le fichier format doit ètre de la forme: position , longueur <rc>, autant de ligne que de champs dans le fichier source. ''') """
# XXX : gérer le cas d'une exception durant le parsing fic_param = open(fic_format) params,longenregistrement = parse_params(fic_param) #+++ fic_param.close() #+++
# XXX : gérer le cas d'une erreur lors de l'ouverture de fic_out fic_source = open(fic_entree, 'r') fic_out = open('csv.txt', 'w') try: do_import(params, longenregistrement, fic_source, fic_out) finally: fic_source.close() fic_out.close()
C'est peut-être hors sujet, mais, perso, lorsque j'utilise des fichiers
avec enregistrements à longueur fixe, il n'y a pas de notion de
ligne(s). Les données sont toutes accolées, sans séparateurs, ni de
champs, ni d'enregistrements.
Du coup, j'ai modifié un peu ton exemple, en ce sens. Voir ci-dessous
(mais, il faut que ça rentre en mémoire).
NB : pas testé.
J'ai, vu. Moi, j'ai testé, et j'ai corrigé deux ou trois détails.
Par contre, pour l'optimisation, je voulais comparer read() total et
read(size) ; mais, avec 1 million d'enregistrements, sur mon Vista, ça
ne prend que 3 secondes, alors...
@+
--
MCI
# -*- coding: utf-8 -*-
import sys
import datetime
def parse_params(lines):
params = []
for line in lines:
line = line.strip()
if not line:
continue
parts = line.split(',')
pos1 = int(parts[0])-1
pos2 = pos1 + int(parts[1])
params.append(slice(pos1, pos2))
return params,pos2
def do_import(params, longenregistrement, fic_source, fic_out):
write = fic_out.write
sep = ','
join = sep.join
data_source=fic_source.read()
data=(data_source[i:i+longenregistrement] for i in
range(0,len(data_source),longenregistrement))
for ligne_source in data:
ligne_cible = [ligne_source[slice] for slice in params]
write(join(ligne_cible) + "n")
def main(*args):
fic_entree="MonFic.txt"
fic_format="MonFormat.txt"
"""
try:
fic_entree, fic_format = args
except ValueError:
sys.exit('''Vous devez passez 2 arguments, le fichier source et
le fichier paramètre
ex: csv.py MonFic.txt MonFormat.txt
Le fichier source doit avoir des enregistrements de longueurs
fixes.
Le fichier format doit ètre de la forme: position , longueur
<rc>,
autant de ligne que de champs dans le fichier source.
''')
"""
# XXX : gérer le cas d'une exception durant le parsing
fic_param = open(fic_format)
params,longenregistrement = parse_params(fic_param) #+++
fic_param.close() #+++
# XXX : gérer le cas d'une erreur lors de l'ouverture de fic_out
fic_source = open(fic_entree, 'r')
fic_out = open('csv.txt', 'w')
try:
do_import(params, longenregistrement, fic_source, fic_out)
finally:
fic_source.close()
fic_out.close()
C'est peut-être hors sujet, mais, perso, lorsque j'utilise des fichiers avec enregistrements à longueur fixe, il n'y a pas de notion de ligne(s). Les données sont toutes accolées, sans séparateurs, ni de champs, ni d'enregistrements.
Du coup, j'ai modifié un peu ton exemple, en ce sens. Voir ci-dessous (mais, il faut que ça rentre en mémoire).
NB : pas testé.
J'ai, vu. Moi, j'ai testé, et j'ai corrigé deux ou trois détails.
Par contre, pour l'optimisation, je voulais comparer read() total et read(size) ; mais, avec 1 million d'enregistrements, sur mon Vista, ça ne prend que 3 secondes, alors...
@+ -- MCI
# -*- coding: utf-8 -*-
import sys import datetime
def parse_params(lines): params = [] for line in lines: line = line.strip() if not line: continue parts = line.split(',') pos1 = int(parts[0])-1 pos2 = pos1 + int(parts[1]) params.append(slice(pos1, pos2)) return params,pos2
def do_import(params, longenregistrement, fic_source, fic_out): write = fic_out.write sep = ',' join = sep.join data_source=fic_source.read() data=(data_source[i:i+longenregistrement] for i in range(0,len(data_source),longenregistrement)) for ligne_source in data: ligne_cible = [ligne_source[slice] for slice in params] write(join(ligne_cible) + "n")
def main(*args): fic_entree="MonFic.txt" fic_format="MonFormat.txt" """ try: fic_entree, fic_format = args except ValueError: sys.exit('''Vous devez passez 2 arguments, le fichier source et le fichier paramètre ex: csv.py MonFic.txt MonFormat.txt Le fichier source doit avoir des enregistrements de longueurs fixes. Le fichier format doit ètre de la forme: position , longueur <rc>, autant de ligne que de champs dans le fichier source. ''') """
# XXX : gérer le cas d'une exception durant le parsing fic_param = open(fic_format) params,longenregistrement = parse_params(fic_param) #+++ fic_param.close() #+++
# XXX : gérer le cas d'une erreur lors de l'ouverture de fic_out fic_source = open(fic_entree, 'r') fic_out = open('csv.txt', 'w') try: do_import(params, longenregistrement, fic_source, fic_out) finally: fic_source.close() fic_out.close()
Ce que je trouve amusant, c'est que tu n'ai toujours pas vu ce qui est très probablement le problème majeur de ton code !-)
Sérieusement: - le nommage des variables? - les commentaires qui en remettent une couche? - l'absence de fonctions?
Ce sont effectivement trois problèmes, mais le seul à avoir un impact (probablement mineur) sur les perfs est le troisième. Mais non, ce n'est pas de ça qu'il s'agit.
Il est tard, je ne vois pas non plus :-)
T'a pas l'impression qu'il y a un calcul qui pourrait être extrait de la boucle sur le fichier source ?
Rakotomandimby (R12y) Mihamina a écrit :
Bruno Desthuilliers wrote:
Ce que je trouve amusant, c'est que tu n'ai toujours pas vu
ce qui est très probablement le problème majeur de ton code !-)
Sérieusement:
- le nommage des variables?
- les commentaires qui en remettent une couche?
- l'absence de fonctions?
Ce sont effectivement trois problèmes, mais le seul à avoir un impact
(probablement mineur) sur les perfs est le troisième. Mais non, ce n'est
pas de ça qu'il s'agit.
Il est tard, je ne vois pas non plus :-)
T'a pas l'impression qu'il y a un calcul qui pourrait être extrait de la
boucle sur le fichier source ?
Ce que je trouve amusant, c'est que tu n'ai toujours pas vu ce qui est très probablement le problème majeur de ton code !-)
Sérieusement: - le nommage des variables? - les commentaires qui en remettent une couche? - l'absence de fonctions?
Ce sont effectivement trois problèmes, mais le seul à avoir un impact (probablement mineur) sur les perfs est le troisième. Mais non, ce n'est pas de ça qu'il s'agit.
Il est tard, je ne vois pas non plus :-)
T'a pas l'impression qu'il y a un calcul qui pourrait être extrait de la boucle sur le fichier source ?
Alain BARTHE
Bruno Desthuilliers a écrit :
Christophe a écrit :
Bruno Desthuilliers a écrit :
Christophe a écrit :
Bruno Desthuilliers a écrit :
Christophe a écrit :
pil91 a écrit :
Bonjour, j'ai besoin de transformer en format csv délimité, des fichiers fixes.
(snip)
C'est pas une suggestion d'optim (enfin, ça pourrait le devenir) mais y a-t-il une raison pour laquelle vous n'utilisez pas le module standard csv ?
Peut-être le fait que le format csv soit la cible, pas la source ?-)
Et ? Le module csv fait lecture et écriture.
Oui. Il lit effectivement des csv. Ce qui n'est pas le cas des fichiers sources de l'OP, ni la source de son problème.
Ah, je m'excuse, j'avais mal vu l'énoncé et je confondais le format du fichier de format avec le format du fichier d'entrée de données. Comme quoi il est mal de répondre à ce genre de questions pendant les heures de travail (même pendant une pause) : on va trop vite et on rate des choses importantes :)
Pas de blème, ça arrive à tout le monde (moi le premier...) !-)
Je pense que tu pourrais aussi utiliser le module struct, qui semble mieux adapté pour ton problème.
Principe : - définir une format décrivant la structure de tes enregistrements:
Exemple : Si ton enregistrement contient : nom 30 caractères prenom 20 caractères tel 10 entiers
Tu crées un format = "30s20s10i"
import struct
format = "30s20s10i" size = struct.calcsize (format)
in = open ("fichier.dat", "r") out = open ("fichier.csv", "w")
while f: data = in.read (size) nom, prenom, tel = struct.unpack (format, data)
print >> out, "%s,%s,%d;", % (nom,prenom,tel)
in.close() out.close()
A tester et vérifier, car je n'ai pas trop le temps maintenant, mais ca me semble une solution plus adaptée à ton besoin.
Par contre, je ne sais pas si ce sera plus efficace.
Bruno Desthuilliers a écrit :
Christophe a écrit :
Bruno Desthuilliers a écrit :
Christophe a écrit :
Bruno Desthuilliers a écrit :
Christophe a écrit :
pil91 a écrit :
Bonjour, j'ai besoin de transformer en format csv délimité, des
fichiers fixes.
(snip)
C'est pas une suggestion d'optim (enfin, ça pourrait le devenir)
mais y a-t-il une raison pour laquelle vous n'utilisez pas le
module standard csv ?
Peut-être le fait que le format csv soit la cible, pas la source ?-)
Et ? Le module csv fait lecture et écriture.
Oui. Il lit effectivement des csv. Ce qui n'est pas le cas des
fichiers sources de l'OP, ni la source de son problème.
Ah, je m'excuse, j'avais mal vu l'énoncé et je confondais le format du
fichier de format avec le format du fichier d'entrée de données. Comme
quoi il est mal de répondre à ce genre de questions pendant les heures
de travail (même pendant une pause) : on va trop vite et on rate des
choses importantes :)
Pas de blème, ça arrive à tout le monde (moi le premier...) !-)
Je pense que tu pourrais aussi utiliser le module struct, qui semble
mieux adapté pour ton problème.
Principe :
- définir une format décrivant la structure de tes enregistrements:
Exemple : Si ton enregistrement contient :
nom 30 caractères
prenom 20 caractères
tel 10 entiers
Tu crées un format = "30s20s10i"
import struct
format = "30s20s10i"
size = struct.calcsize (format)
in = open ("fichier.dat", "r")
out = open ("fichier.csv", "w")
while f:
data = in.read (size)
nom, prenom, tel = struct.unpack (format, data)
print >> out, "%s,%s,%d;", % (nom,prenom,tel)
in.close()
out.close()
A tester et vérifier, car je n'ai pas trop le temps maintenant, mais ca
me semble une solution plus adaptée à ton besoin.
Par contre, je ne sais pas si ce sera plus efficace.
Bonjour, j'ai besoin de transformer en format csv délimité, des fichiers fixes.
(snip)
C'est pas une suggestion d'optim (enfin, ça pourrait le devenir) mais y a-t-il une raison pour laquelle vous n'utilisez pas le module standard csv ?
Peut-être le fait que le format csv soit la cible, pas la source ?-)
Et ? Le module csv fait lecture et écriture.
Oui. Il lit effectivement des csv. Ce qui n'est pas le cas des fichiers sources de l'OP, ni la source de son problème.
Ah, je m'excuse, j'avais mal vu l'énoncé et je confondais le format du fichier de format avec le format du fichier d'entrée de données. Comme quoi il est mal de répondre à ce genre de questions pendant les heures de travail (même pendant une pause) : on va trop vite et on rate des choses importantes :)
Pas de blème, ça arrive à tout le monde (moi le premier...) !-)
Je pense que tu pourrais aussi utiliser le module struct, qui semble mieux adapté pour ton problème.
Principe : - définir une format décrivant la structure de tes enregistrements:
Exemple : Si ton enregistrement contient : nom 30 caractères prenom 20 caractères tel 10 entiers
Tu crées un format = "30s20s10i"
import struct
format = "30s20s10i" size = struct.calcsize (format)
in = open ("fichier.dat", "r") out = open ("fichier.csv", "w")
while f: data = in.read (size) nom, prenom, tel = struct.unpack (format, data)
print >> out, "%s,%s,%d;", % (nom,prenom,tel)
in.close() out.close()
A tester et vérifier, car je n'ai pas trop le temps maintenant, mais ca me semble une solution plus adaptée à ton besoin.
Par contre, je ne sais pas si ce sera plus efficace.
Bruno Desthuilliers
Alain BARTHE a écrit : (snip)
Je pense que tu pourrais aussi utiliser le module struct, qui semble mieux adapté pour ton problème.
doh :(
C'est ça le problème avec Python : y a tellement de trucs dans la biblio standard qu'on oublie fréquemment de vérifier si y a pas déjà une bonne soluce quelque part...
Principe : - définir une format décrivant la structure de tes enregistrements:
Exemple : Si ton enregistrement contient : nom 30 caractères prenom 20 caractères tel 10 entiers
Tu crées un format = "30s20s10i"
import struct
format = "30s20s10i" size = struct.calcsize (format)
in = open ("fichier.dat", "r") out = open ("fichier.csv", "w")
while f: data = in.read (size)
Attention, s'il y a des newlines en fin d'enregistrement, il faut en tenir compte dans la taille (et probablement dans le struct), en tenant compte des problèmes de portabilité entre plateformes pour le format des newlines.
nom, prenom, tel = struct.unpack (format, data)
print >> out, "%s,%s,%d;", % (nom,prenom,tel)
in.close() out.close()
(snip)
Par contre, je ne sais pas si ce sera plus efficace.
<OP> Pil, si tu tentes cette solution, je veux bien savoir le résultat (si ça fonctionne pour ton cas, et si oui si c'est plus performant). </OP>
Alain BARTHE a écrit :
(snip)
Je pense que tu pourrais aussi utiliser le module struct, qui semble
mieux adapté pour ton problème.
doh :(
C'est ça le problème avec Python : y a tellement de trucs dans la biblio
standard qu'on oublie fréquemment de vérifier si y a pas déjà une bonne
soluce quelque part...
Principe :
- définir une format décrivant la structure de tes enregistrements:
Exemple : Si ton enregistrement contient :
nom 30 caractères
prenom 20 caractères
tel 10 entiers
Tu crées un format = "30s20s10i"
import struct
format = "30s20s10i"
size = struct.calcsize (format)
in = open ("fichier.dat", "r")
out = open ("fichier.csv", "w")
while f:
data = in.read (size)
Attention, s'il y a des newlines en fin d'enregistrement, il faut en
tenir compte dans la taille (et probablement dans le struct), en tenant
compte des problèmes de portabilité entre plateformes pour le format des
newlines.
nom, prenom, tel = struct.unpack (format, data)
print >> out, "%s,%s,%d;", % (nom,prenom,tel)
in.close()
out.close()
(snip)
Par contre, je ne sais pas si ce sera plus efficace.
<OP>
Pil, si tu tentes cette solution, je veux bien savoir le résultat (si ça
fonctionne pour ton cas, et si oui si c'est plus performant).
</OP>
Je pense que tu pourrais aussi utiliser le module struct, qui semble mieux adapté pour ton problème.
doh :(
C'est ça le problème avec Python : y a tellement de trucs dans la biblio standard qu'on oublie fréquemment de vérifier si y a pas déjà une bonne soluce quelque part...
Principe : - définir une format décrivant la structure de tes enregistrements:
Exemple : Si ton enregistrement contient : nom 30 caractères prenom 20 caractères tel 10 entiers
Tu crées un format = "30s20s10i"
import struct
format = "30s20s10i" size = struct.calcsize (format)
in = open ("fichier.dat", "r") out = open ("fichier.csv", "w")
while f: data = in.read (size)
Attention, s'il y a des newlines en fin d'enregistrement, il faut en tenir compte dans la taille (et probablement dans le struct), en tenant compte des problèmes de portabilité entre plateformes pour le format des newlines.
nom, prenom, tel = struct.unpack (format, data)
print >> out, "%s,%s,%d;", % (nom,prenom,tel)
in.close() out.close()
(snip)
Par contre, je ne sais pas si ce sera plus efficace.
<OP> Pil, si tu tentes cette solution, je veux bien savoir le résultat (si ça fonctionne pour ton cas, et si oui si c'est plus performant). </OP>
Alain BARTHE
Bruno Desthuilliers a écrit :
Alain BARTHE a écrit : (snip)
Je pense que tu pourrais aussi utiliser le module struct, qui semble mieux adapté pour ton problème.
doh :(
C'est ça le problème avec Python : y a tellement de trucs dans la biblio standard qu'on oublie fréquemment de vérifier si y a pas déjà une bonne soluce quelque part...
Principe : - définir une format décrivant la structure de tes enregistrements:
Exemple : Si ton enregistrement contient : nom 30 caractères prenom 20 caractères tel 10 entiers
Tu crées un format = "30s20s10i"
import struct
format = "30s20s10i" size = struct.calcsize (format)
in = open ("fichier.dat", "r") out = open ("fichier.csv", "w")
while f: data = in.read (size)
Attention, s'il y a des newlines en fin d'enregistrement, il faut en tenir compte dans la taille (et probablement dans le struct), en tenant compte des problèmes de portabilité entre plateformes pour le format des newlines.
On peut ajouter le motif x (padding) dans le format pour prendre en compte le n ou même ignorer un champ dont on n'a pas besoin.
nom, prenom, tel = struct.unpack (format, data)
print >> out, "%s,%s,%d;", % (nom,prenom,tel)
in.close() out.close()
(snip)
Par contre, je ne sais pas si ce sera plus efficace.
<OP> Pil, si tu tentes cette solution, je veux bien savoir le résultat (si ça fonctionne pour ton cas, et si oui si c'est plus performant). </OP>
Concernant le fonctionnement, je pense que ça correspond bien avec son problème. Je n'ai pas pu tester réellement car je n'avais pas le temps de me créer un fichier de test, mais le module semble fait pour.
Pour les perf, j'espère que ça doit être meilleur, le module semble être un .so dont probablement être écrit en C et la découpe des divers champs devrait être plus efficace qu'avec du code Python.
A confirmer quand même.
Bruno Desthuilliers a écrit :
Alain BARTHE a écrit :
(snip)
Je pense que tu pourrais aussi utiliser le module struct, qui semble
mieux adapté pour ton problème.
doh :(
C'est ça le problème avec Python : y a tellement de trucs dans la biblio
standard qu'on oublie fréquemment de vérifier si y a pas déjà une bonne
soluce quelque part...
Principe :
- définir une format décrivant la structure de tes enregistrements:
Exemple : Si ton enregistrement contient :
nom 30 caractères
prenom 20 caractères
tel 10 entiers
Tu crées un format = "30s20s10i"
import struct
format = "30s20s10i"
size = struct.calcsize (format)
in = open ("fichier.dat", "r")
out = open ("fichier.csv", "w")
while f:
data = in.read (size)
Attention, s'il y a des newlines en fin d'enregistrement, il faut en
tenir compte dans la taille (et probablement dans le struct), en tenant
compte des problèmes de portabilité entre plateformes pour le format des
newlines.
On peut ajouter le motif x (padding) dans le format pour prendre en
compte le n ou même ignorer un champ dont on n'a pas besoin.
nom, prenom, tel = struct.unpack (format, data)
print >> out, "%s,%s,%d;", % (nom,prenom,tel)
in.close()
out.close()
(snip)
Par contre, je ne sais pas si ce sera plus efficace.
<OP>
Pil, si tu tentes cette solution, je veux bien savoir le résultat (si ça
fonctionne pour ton cas, et si oui si c'est plus performant).
</OP>
Concernant le fonctionnement, je pense que ça correspond bien avec son
problème. Je n'ai pas pu tester réellement car je n'avais pas le temps
de me créer un fichier de test, mais le module semble fait pour.
Pour les perf, j'espère que ça doit être meilleur, le module semble être
un .so dont probablement être écrit en C et la découpe des divers champs
devrait être plus efficace qu'avec du code Python.
Je pense que tu pourrais aussi utiliser le module struct, qui semble mieux adapté pour ton problème.
doh :(
C'est ça le problème avec Python : y a tellement de trucs dans la biblio standard qu'on oublie fréquemment de vérifier si y a pas déjà une bonne soluce quelque part...
Principe : - définir une format décrivant la structure de tes enregistrements:
Exemple : Si ton enregistrement contient : nom 30 caractères prenom 20 caractères tel 10 entiers
Tu crées un format = "30s20s10i"
import struct
format = "30s20s10i" size = struct.calcsize (format)
in = open ("fichier.dat", "r") out = open ("fichier.csv", "w")
while f: data = in.read (size)
Attention, s'il y a des newlines en fin d'enregistrement, il faut en tenir compte dans la taille (et probablement dans le struct), en tenant compte des problèmes de portabilité entre plateformes pour le format des newlines.
On peut ajouter le motif x (padding) dans le format pour prendre en compte le n ou même ignorer un champ dont on n'a pas besoin.
nom, prenom, tel = struct.unpack (format, data)
print >> out, "%s,%s,%d;", % (nom,prenom,tel)
in.close() out.close()
(snip)
Par contre, je ne sais pas si ce sera plus efficace.
<OP> Pil, si tu tentes cette solution, je veux bien savoir le résultat (si ça fonctionne pour ton cas, et si oui si c'est plus performant). </OP>
Concernant le fonctionnement, je pense que ça correspond bien avec son problème. Je n'ai pas pu tester réellement car je n'avais pas le temps de me créer un fichier de test, mais le module semble fait pour.
Pour les perf, j'espère que ça doit être meilleur, le module semble être un .so dont probablement être écrit en C et la découpe des divers champs devrait être plus efficace qu'avec du code Python.
