Je suis en train d'écrire un petit programme en python, rien de bien
contraignant : j'ai un fichier texte de plusieurs milliers de nombres
entiers séparés par des virgules que je voudrais segmenter en paragraphe
pour le mettre en page via LaTeX. Donc, je veux le découper en
paragraphe de 1000 nombres. Je cherche donc les occurrences de "," dans
le fichier et tous les 1000 j'ajoute '/n/n' pour créer un saut de
paragraphe.
La fin du fichier est atteinte lorsque la commande
"chaine.find(',',debut) renvoie -1.
La question est de savoir ce qui est le plus "économique" : tester une
égalité du type 'index == -1' ou une inégalité 'index < 0' : j'ai le
sentiment que la deuxième solution est plus économique (juste un bit à
tester si mes souvenirs sur le codage des entiers est exact).
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Nicolas
Bonjour, Le 17/02/2016 10:01, pierre a écrit :
Bonjour,
Je suis en train d'écrire un petit programme en python, rien de bien contraignant : j'ai un fichier texte de plusieurs milliers de nombres entiers séparés par des virgules que je voudrais segmenter en paragraphe pour le mettre en page via LaTeX. Donc, je veux le découper en paragraphe de 1000 nombres. Je cherche donc les occurrences de "," dans le fichier et tous les 1000 j'ajoute '/n/n' pour créer un saut de paragraphe. La fin du fichier est atteinte lorsque la commande "chaine.find(',',debut) renvoie -1. La question est de savoir ce qui est le plus "économique" : tester une égalité du type 'index == -1' ou une inégalité 'index < 0' : j'ai le sentiment que la deuxième solution est plus économique (juste un bit à tester si mes souvenirs sur le codage des entiers est exact).
Python n'est pas du C. L'implémentation est différente suivant l'interpréteur (C Pyhton, J Python, IronPython, PyPy...). Je doute que l'on puisse trouver une différence de timing entre ces deux opérateurs. Peut-être qu'un spécialiste Python pourrait donner une réponse.
Par contre, gagner en vitesse peut se faire en "pensant" Python. Par exemple, si la taille du fichier n'est pas trop grosse :
# Lecture de tout le fichier f = open("nom du fichier d'entree", "r") data = f.read() f.close()
# Transformation en liste numbers = [n.strip() for n in data.split(",")]
# Liste de liste block_size = 1000 data_b = [numbers[i:i+block_size] for i in range(0, len(numbers), block_size)]
# Ecriture du fichier de sortie f = open("nom du fichier de sortie", "w") f.write(",n".join([", ".join(d) for d in data_b])) f.close()
Nicolas
Merci de vos réponses.
Cordialement Pierre
Bonjour,
Le 17/02/2016 10:01, pierre a écrit :
Bonjour,
Je suis en train d'écrire un petit programme en python, rien de bien
contraignant : j'ai un fichier texte de plusieurs milliers de nombres
entiers séparés par des virgules que je voudrais segmenter en paragraphe
pour le mettre en page via LaTeX. Donc, je veux le découper en
paragraphe de 1000 nombres. Je cherche donc les occurrences de "," dans
le fichier et tous les 1000 j'ajoute '/n/n' pour créer un saut de
paragraphe.
La fin du fichier est atteinte lorsque la commande
"chaine.find(',',debut) renvoie -1.
La question est de savoir ce qui est le plus "économique" : tester une
égalité du type 'index == -1' ou une inégalité 'index < 0' : j'ai le
sentiment que la deuxième solution est plus économique (juste un bit à
tester si mes souvenirs sur le codage des entiers est exact).
Python n'est pas du C. L'implémentation est différente suivant
l'interpréteur (C Pyhton, J Python, IronPython, PyPy...).
Je doute que l'on puisse trouver une différence de timing entre ces deux
opérateurs. Peut-être qu'un spécialiste Python pourrait donner une réponse.
Par contre, gagner en vitesse peut se faire en "pensant" Python.
Par exemple, si la taille du fichier n'est pas trop grosse :
# Lecture de tout le fichier
f = open("nom du fichier d'entree", "r")
data = f.read()
f.close()
# Transformation en liste
numbers = [n.strip() for n in data.split(",")]
# Liste de liste
block_size = 1000
data_b = [numbers[i:i+block_size] for i in range(0, len(numbers),
block_size)]
# Ecriture du fichier de sortie
f = open("nom du fichier de sortie", "w")
f.write(",n".join([", ".join(d) for d in data_b]))
f.close()
Je suis en train d'écrire un petit programme en python, rien de bien contraignant : j'ai un fichier texte de plusieurs milliers de nombres entiers séparés par des virgules que je voudrais segmenter en paragraphe pour le mettre en page via LaTeX. Donc, je veux le découper en paragraphe de 1000 nombres. Je cherche donc les occurrences de "," dans le fichier et tous les 1000 j'ajoute '/n/n' pour créer un saut de paragraphe. La fin du fichier est atteinte lorsque la commande "chaine.find(',',debut) renvoie -1. La question est de savoir ce qui est le plus "économique" : tester une égalité du type 'index == -1' ou une inégalité 'index < 0' : j'ai le sentiment que la deuxième solution est plus économique (juste un bit à tester si mes souvenirs sur le codage des entiers est exact).
Python n'est pas du C. L'implémentation est différente suivant l'interpréteur (C Pyhton, J Python, IronPython, PyPy...). Je doute que l'on puisse trouver une différence de timing entre ces deux opérateurs. Peut-être qu'un spécialiste Python pourrait donner une réponse.
Par contre, gagner en vitesse peut se faire en "pensant" Python. Par exemple, si la taille du fichier n'est pas trop grosse :
# Lecture de tout le fichier f = open("nom du fichier d'entree", "r") data = f.read() f.close()
# Transformation en liste numbers = [n.strip() for n in data.split(",")]
# Liste de liste block_size = 1000 data_b = [numbers[i:i+block_size] for i in range(0, len(numbers), block_size)]
# Ecriture du fichier de sortie f = open("nom du fichier de sortie", "w") f.write(",n".join([", ".join(d) for d in data_b])) f.close()
Nicolas
Merci de vos réponses.
Cordialement Pierre
Benoit Izac
Bonjour,
Le 17/02/2016 à 11:19, Nicolas a écrit dans le message <56c4492a$0$665$ :
Je suis en train d'écrire un petit programme en python, rien de bien contraignant : j'ai un fichier texte de plusieurs milliers de nombres entiers séparés par des virgules que je voudrais segmenter en paragraphe pour le mettre en page via LaTeX. Donc, je veux le découper en paragraphe de 1000 nombres. Je cherche donc les occurrences de "," dans le fichier et tous les 1000 j'ajoute '/n/n' pour créer un saut de paragraphe. La fin du fichier est atteinte lorsque la commande "chaine.find(',',debut) renvoie -1. La question est de savoir ce qui est le plus "économique" : tester une égalité du type 'index == -1' ou une inégalité 'index < 0' : j'ai le sentiment que la deuxième solution est plus économique (juste un bit à tester si mes souvenirs sur le codage des entiers est exact).
Python n'est pas du C. L'implémentation est différente suivant l'interpréteur (C Pyhton, J Python, IronPython, PyPy...).
Même en C, on ne se pose pas ce genre de question. Si la documentation de la fonction indique qu'elle renvoie « -1 » alors on teste si elle vaut « -1 », tout simplement.
[bons conseils] f.write(",n".join([", ".join(d) for d in data_b]))
^^^^^ ",nn"
Par curiosité, quel est l'intérêt de mettre en pages des milliers de nombres entiers ?
-- Benoit Izac
Bonjour,
Le 17/02/2016 à 11:19, Nicolas a écrit dans le message
<56c4492a$0$665$426a34cc@news.free.fr> :
Je suis en train d'écrire un petit programme en python, rien de bien
contraignant : j'ai un fichier texte de plusieurs milliers de nombres
entiers séparés par des virgules que je voudrais segmenter en paragraphe
pour le mettre en page via LaTeX. Donc, je veux le découper en
paragraphe de 1000 nombres. Je cherche donc les occurrences de "," dans
le fichier et tous les 1000 j'ajoute '/n/n' pour créer un saut de
paragraphe.
La fin du fichier est atteinte lorsque la commande
"chaine.find(',',debut) renvoie -1.
La question est de savoir ce qui est le plus "économique" : tester une
égalité du type 'index == -1' ou une inégalité 'index < 0' : j'ai le
sentiment que la deuxième solution est plus économique (juste un bit à
tester si mes souvenirs sur le codage des entiers est exact).
Python n'est pas du C. L'implémentation est différente suivant
l'interpréteur (C Pyhton, J Python, IronPython, PyPy...).
Même en C, on ne se pose pas ce genre de question. Si la documentation
de la fonction indique qu'elle renvoie « -1 » alors on teste si elle
vaut « -1 », tout simplement.
[bons conseils]
f.write(",n".join([", ".join(d) for d in data_b]))
^^^^^
",nn"
Par curiosité, quel est l'intérêt de mettre en pages des milliers de
nombres entiers ?
Le 17/02/2016 à 11:19, Nicolas a écrit dans le message <56c4492a$0$665$ :
Je suis en train d'écrire un petit programme en python, rien de bien contraignant : j'ai un fichier texte de plusieurs milliers de nombres entiers séparés par des virgules que je voudrais segmenter en paragraphe pour le mettre en page via LaTeX. Donc, je veux le découper en paragraphe de 1000 nombres. Je cherche donc les occurrences de "," dans le fichier et tous les 1000 j'ajoute '/n/n' pour créer un saut de paragraphe. La fin du fichier est atteinte lorsque la commande "chaine.find(',',debut) renvoie -1. La question est de savoir ce qui est le plus "économique" : tester une égalité du type 'index == -1' ou une inégalité 'index < 0' : j'ai le sentiment que la deuxième solution est plus économique (juste un bit à tester si mes souvenirs sur le codage des entiers est exact).
Python n'est pas du C. L'implémentation est différente suivant l'interpréteur (C Pyhton, J Python, IronPython, PyPy...).
Même en C, on ne se pose pas ce genre de question. Si la documentation de la fonction indique qu'elle renvoie « -1 » alors on teste si elle vaut « -1 », tout simplement.
[bons conseils] f.write(",n".join([", ".join(d) for d in data_b]))
^^^^^ ",nn"
Par curiosité, quel est l'intérêt de mettre en pages des milliers de nombres entiers ?
-- Benoit Izac
pierre
Le 17/02/2016 17:09, Benoit Izac a écrit :
Bonjour,
Le 17/02/2016 à 11:19, Nicolas a écrit dans le message <56c4492a$0$665$ :
Je suis en train d'écrire un petit programme en python, rien de bien contraignant : j'ai un fichier texte de plusieurs milliers de nombres entiers séparés par des virgules que je voudrais segmenter en paragraphe pour le mettre en page via LaTeX. Donc, je veux le découper en paragraphe de 1000 nombres. Je cherche donc les occurrences de "," dans le fichier et tous les 1000 j'ajoute '/n/n' pour créer un saut de paragraphe. La fin du fichier est atteinte lorsque la commande "chaine.find(',',debut) renvoie -1. La question est de savoir ce qui est le plus "économique" : tester une égalité du type 'index == -1' ou une inégalité 'index < 0' : j'ai le sentiment que la deuxième solution est plus économique (juste un bit à tester si mes souvenirs sur le codage des entiers est exact).
Python n'est pas du C. L'implémentation est différente suivant l'interpréteur (C Pyhton, J Python, IronPython, PyPy...).
Même en C, on ne se pose pas ce genre de question. Si la documentation de la fonction indique qu'elle renvoie « -1 » alors on teste si elle vaut « -1 », tout simplement.
[bons conseils] f.write(",n".join([", ".join(d) for d in data_b]))
^^^^^ ",nn"
Par curiosité, quel est l'intérêt de mettre en pages des milliers de nombres entiers ?
Aucun si ce n'est l'aspect didactique. Il faut bien se poser des questions à la portée de mes connaissances qui ne sont pas très étendues. Donc, je m'amuse sur des pb simples mais sans beaucoup d'intérêt autre que d'apprendre...
En l’occurrence, il s'agit de la période du développement en fraction continue de sqrt(410286423278424) que l'on peut utiliser pour résoudre l'équation x^2 - 410286423278424 y^2 = 1 (dans Z^2), elle même étant issue du problème "Les bœufs d'Hélios" du à Archimède.
Le 17/02/2016 à 11:19, Nicolas a écrit dans le message
<56c4492a$0$665$426a34cc@news.free.fr> :
Je suis en train d'écrire un petit programme en python, rien de bien
contraignant : j'ai un fichier texte de plusieurs milliers de nombres
entiers séparés par des virgules que je voudrais segmenter en paragraphe
pour le mettre en page via LaTeX. Donc, je veux le découper en
paragraphe de 1000 nombres. Je cherche donc les occurrences de "," dans
le fichier et tous les 1000 j'ajoute '/n/n' pour créer un saut de
paragraphe.
La fin du fichier est atteinte lorsque la commande
"chaine.find(',',debut) renvoie -1.
La question est de savoir ce qui est le plus "économique" : tester une
égalité du type 'index == -1' ou une inégalité 'index < 0' : j'ai le
sentiment que la deuxième solution est plus économique (juste un bit à
tester si mes souvenirs sur le codage des entiers est exact).
Python n'est pas du C. L'implémentation est différente suivant
l'interpréteur (C Pyhton, J Python, IronPython, PyPy...).
Même en C, on ne se pose pas ce genre de question. Si la documentation
de la fonction indique qu'elle renvoie « -1 » alors on teste si elle
vaut « -1 », tout simplement.
[bons conseils]
f.write(",n".join([", ".join(d) for d in data_b]))
^^^^^
",nn"
Par curiosité, quel est l'intérêt de mettre en pages des milliers de
nombres entiers ?
Aucun si ce n'est l'aspect didactique. Il faut bien se poser des
questions à la portée de mes connaissances qui ne sont pas très
étendues. Donc, je m'amuse sur des pb simples mais sans beaucoup
d'intérêt autre que d'apprendre...
En l’occurrence, il s'agit de la période du développement en fraction
continue de sqrt(410286423278424) que l'on peut utiliser pour résoudre
l'équation x^2 - 410286423278424 y^2 = 1 (dans Z^2), elle même étant
issue du problème "Les bœufs d'Hélios" du à Archimède.
Le 17/02/2016 à 11:19, Nicolas a écrit dans le message <56c4492a$0$665$ :
Je suis en train d'écrire un petit programme en python, rien de bien contraignant : j'ai un fichier texte de plusieurs milliers de nombres entiers séparés par des virgules que je voudrais segmenter en paragraphe pour le mettre en page via LaTeX. Donc, je veux le découper en paragraphe de 1000 nombres. Je cherche donc les occurrences de "," dans le fichier et tous les 1000 j'ajoute '/n/n' pour créer un saut de paragraphe. La fin du fichier est atteinte lorsque la commande "chaine.find(',',debut) renvoie -1. La question est de savoir ce qui est le plus "économique" : tester une égalité du type 'index == -1' ou une inégalité 'index < 0' : j'ai le sentiment que la deuxième solution est plus économique (juste un bit à tester si mes souvenirs sur le codage des entiers est exact).
Python n'est pas du C. L'implémentation est différente suivant l'interpréteur (C Pyhton, J Python, IronPython, PyPy...).
Même en C, on ne se pose pas ce genre de question. Si la documentation de la fonction indique qu'elle renvoie « -1 » alors on teste si elle vaut « -1 », tout simplement.
[bons conseils] f.write(",n".join([", ".join(d) for d in data_b]))
^^^^^ ",nn"
Par curiosité, quel est l'intérêt de mettre en pages des milliers de nombres entiers ?
Aucun si ce n'est l'aspect didactique. Il faut bien se poser des questions à la portée de mes connaissances qui ne sont pas très étendues. Donc, je m'amuse sur des pb simples mais sans beaucoup d'intérêt autre que d'apprendre...
En l’occurrence, il s'agit de la période du développement en fraction continue de sqrt(410286423278424) que l'on peut utiliser pour résoudre l'équation x^2 - 410286423278424 y^2 = 1 (dans Z^2), elle même étant issue du problème "Les bœufs d'Hélios" du à Archimède.
