Discussion :

[clement_74]

Bonjour,
j'ai eu besoin de concatener le contenu de plusieurs dizaines de fichiers texte.
pour cela j'ai réalisé le code ci-dessous:

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
import os
 
liste_fichier_texte = os.listdir(r"fichiers_text_a_concat")
full_single_text = ""
 
 
for i in range (0, len(liste_fichier_texte), 1):
    fichier_text = open("fichiers_text_a_concat" + os.sep + liste_fichier_texte[i])
    text = fichier_text.readlines()
    fichier_text.close()
    for i in range(0, len(text), 1):
        full_single_text = full_single_text + text[i].strip("\n") + "\n"
 
 
new_fichier_full_txt = open(r"Full_concat_text.txt", "w")
new_fichier_full_txt.write(full_single_text)
new_fichier_full_txt.close()

Il marche, mais lors de l’exécution, j'ai constaté que le temps de traitement de chaque fichier texte était de plus en plus long... alors que les fichiers qui se succédaient n'étaient pas forcément de plus en plus lourd. Au final mes 150 fichiers texte se sont concaténés en un seul fichier texte en un peu moins de 10minutes.. pour 1 fichier de seulement 25Mo.

il existe un moyen d'accélérer ce type de traitement?

merci,
cordialement,
clem

[wiztricks]

Salut,

il existe un moyen d'accélérer ce type de traitement?

Peut être que le temps devient de plus en plus long parce que vous accumulez le contenu de tous les fichiers lus dans une chaîne de caractères full_single_text qu'il faut réallouer à chaque itération.

Puisque vous allez de toutes façons écrire les données dans le fichier de sortie, ça ne sert à rien de les garder en mémoire, écrire le contenu du fichier lu dans le fichier de sortie directement serait plus simple et irait plus vite.

Si vous voulez garder tout çà en mémoire, éviter les réallocations et utilisez une liste de... lignes ou de contenu de fichiers (des gros blocs).
note: il n'y a aucun intérêt à poser dans un forum PyQt une question où PyQt n'est pas concerné.


- W

[clement_74]

Bonjour, merci pour la réponse,
je viens d'essayer la solution proposée mais, à priori, ça rend la chose plus lente...
mais je ne poursuit pas ici, en effet, pas de pyqt sur ces lignes donc hors sujet!

[wiztricks]

Salut,

je viens d'essayer la solution proposée mais, à priori, ça rend la chose plus lente...

Bizarre! postez le code.

- W

[Sve@r]

Bonjour

Code python :

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
import os
 
liste_fichier_texte = os.listdir(r"fichiers_text_a_concat")
full_single_text = ""
 
 
for i in range (0, len(liste_fichier_texte), 1):
    fichier_text = open("fichiers_text_a_concat" + os.sep + liste_fichier_texte[i])
    text = fichier_text.readlines()
    fichier_text.close()
    for i in range(0, len(text), 1):
        full_single_text = full_single_text + text[i].strip("\n") + "\n"
 
 
new_fichier_full_txt = open(r"Full_concat_text.txt", "w")
new_fichier_full_txt.write(full_single_text)
new_fichier_full_txt.close()

Code python :

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

1
2
3
4
5
6
import os
 
with open(r"Full_concat_text.txt", "w") as f_out:
	for f in os.listdir(r"fichiers_text_a_concat"):
		with open(os.path.join("fichiers_text_a_concat", f), "r") as f_in:
			f_out.write(f_in.read())

Attention que os.listdir() ne donne pas les fichiers dans l'ordre alphabétique. Pour cela rajouter un sorted().

[clement_74]

Bonjour,

suite à la proposition de wiztricks, j'ai d'abord essayé d'enregistrer le fichier texte (de sortie) au fur et à mesure de la lecture de chaque fichier source.
au final, c'était pas super rapide et je me suis dis que c'était peut être le simple fait que l'incrément d'un fichier qui grossit avait le même problème que la chaine de caractère qui grossit.

donc j'ai opté pour la deuxième solution de wiztrick (qui elle marche tip top) à savoir que j'enregistre d'abord chaque contenu de chaque fichier texte dans un index d'une liste.
Et là, étrangement (pour moi) il semble plus rapide de faire appel à une liste pour lui ajouter un index rempli de données que de d'ajouter du texte à un fichier texte.

ci dessous le code qui marche (beaucoup mieux que la version précédente):
NB: même pour une valeur de fichier texte final de plusieurs dizaines de Mo, l'enchainement des "print(i)" apparait homogène en termes de temps (et rapide).
le plus long au final, c'est la dernière boucle (mais là , je pense que c'est juste normal que ça prenne 3-4 secondes pour enregistrer un ficher texte "lourd".

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
import os
import csv
import pandas as pd
 
liste_fichier_texte = os.listdir(r"fichiers_text_a_concat")
full_single_text = ""
full_text = []
 
new_fichier_full_txt = open(r"Full_concat_text.txt", "w")
new_fichier_full_txt.close()
 
for i in range (0, len(liste_fichier_texte), 1):
    fichier_text = open("fichiers_text_a_concat" + os.sep + liste_fichier_texte[i])
    text = fichier_text.readlines()
    fichier_text.close()
    for j in range(0, len(text), 1):        
        full_text.append(text[j].strip("\n") + "\n")
    print(i)
 
new_fichier_full_txt = open(r"Full_concat_text.txt", "a")
for k in range(0, len(full_text), 1):
    new_fichier_full_txt.write(full_text[k])
 
new_fichier_full_txt.close()

encore merci :-)

[wiztricks]

Et là, étrangement (pour moi) il semble plus rapide de faire appel à une liste pour lui ajouter un index rempli de données que de d'ajouter du texte à un fichier texte.

Comme c'est un problème que je n'arrive pas à reproduire chez moi, j'aimerai (toujours) voir le code qui va avec...

- W

[clement_74]

Bonjour,
ci dessous, le code de la version "incrément du fichier texte" que j'estimais plus lente que le code ci dessus.

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
 
import os
 
liste_fichier_texte = os.listdir(r"fichiers_text_a_concat")
full_single_text = ""
 
new_fichier_full_txt = open(r"Full_concat_text.txt", "w")
new_fichier_full_txt.close()
 
for i in range (0, len(liste_fichier_texte), 1):
    fichier_text = open("fichiers_text_a_concat" + os.sep + liste_fichier_texte[i])
    text = fichier_text.readlines()
    fichier_text.close()
    for j in range(0, len(text), 1):
        new_fichier_full_txt = open(r"Full_concat_text.txt", "a")
        new_fichier_full_txt.write(text[j].strip("\n") + "\n")
    print(i)
 
 
print("Terminé!")

Après relecture, je pense qu'il était maladroit, d'ouvrir/écrire ligne par ligne le fichier texte de sortie.
c'est probablement cette lourdeur de code et d'organisation de de la donnée finale qui fait que la solution soit apparue moins bonne.


merci encore pour le support!

[Sve@r]

Après relecture, je pense qu'il était maladroit, d'ouvrir/écrire ligne par ligne le fichier texte de sortie.

Oui. C'est pour ça que je t'ai montré une façon de faire qui prend 3 lignes. Mais si tu prèfères ta solution abracadabrante, en stockant tout pour ensuite tout réécrire, en supprimant le '\n' de chaque ligne pour le réécrire après la ligne, bah l'important c'est le résultat

[clement_74]

Oui en effet, tes 3 lignes sont carrément plus élégantes!

En première lecture, elles n'ont pas été intuitives (pour moi).

aujourd'hui cela me semble plus évident... Mais il me reste encore pas mal de chemin à faire pour que ce type de structure de code me vienne aussi spontanément.
merci en tout cas :-)

[Sve@r]

En première lecture, elles n'ont pas été intuitives (pour moi).

Peut-être le with qui permet d'encapsuler une ressource (ici l'ouverture du fichier) dans un bloc de travail. Quand tu quittes le bloc, la ressource est nettoyée (ici le fichier est fermé) et qui n'est pas intuitif.

Mais même sans ça, pour copier un fichier je reste assez basique. Même si readlines() n'existait pas (d'ailleurs je ne m'en suis jamais servi), même si read() n'était pas si puissant, copier c'est lire X puis écrire X sans se poser de question sur la nature de X (oui ok ce sont des lignes mais c'est avant tout de la data) et surtout sans toucher à X !!!
De là, on peut très bien partir sur un truc de base sans se prendre la tête, du style

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
f_out=open(r"Full_concat_text.txt", "w")
for f in os.listdir(r"fichiers_text_a_concat"):
	f_in=open(os.path.join("fichiers_text_a_concat", f), "r")
	while True:
		data=f_in.read(1)
		if not data: break
		f_out.write(data)
	# while
	f_in.close()
# for
f_out.close()

Et on peut même utiliser "rb" et "wb" au lieu de "r" et "w" et là on n'a même plus à se soucier de la nature du fichier qu'on copie.

[wiztricks]

Salut,

En première lecture, elles n'ont pas été intuitives (pour moi).

Lire le contenu d'un fichier pour l'écrire dans un autre se fait de plusieurs façons suivant le Python que l'on maîtrise. Et ça n'a rien d'intuitif: ou on reconnaît les constructions de base ou on regarde comment elles fonctionnent (on peut jouer avec le code, regarder dans un tuto., poser des questions,...) si on veut progresser.

De là, on peut très bien partir sur un truc de base sans se prendre la tête, du style

Code python :

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

1
2
3
4
5
6
7
...
	while True:
		data=f_in.read(1)
		if not data: break
		f_out.write(data)
	# while
	f_in.close()

Sûr que ça "fonctionne" mais lire le fichier caractère par caractère? Déjà savoir qu'on peut passer un nombre d'octets en paramètre du .read demande de farfouiller dans la documentation (et une intention délibérée...) à moins qu'on ait recopié un code qui marche sans se poser de questions.

- W

[Sve@r]

Sûr que ça "fonctionne" mais lire le fichier caractère par caractère?

Je voulais montrer que même si read() n'avait pas été ce qu'il est ça marchait quand-même (un peu comme un code C qui passerait par fgetc())

[wiztricks]

Je voulais montrer que même si read() n'avait pas été ce qu'il est ça marchait quand-même (un peu comme un code C qui passerait par fgetc())

On peut montrer que la lecture après la fin du fichier ne retourne rien(*) avec:

Code :

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

1
2
3
4
5
6
       while True:
		data=f_in.read()
		if not data: break
		f_out.write(data)
	# while
	f_in.close()

(*) pour éviter le ligne à ligne de .readline.

- W