Discussion :

[berty4242]

Bonjour,

J'ai un code dans lequel je souhaite lire le nombre dans un fichier texte, le multiplier et enregistrer la somme dans ce dernier.
Voici le code :

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
 
import threading
import os
import sys
 
a = 10
 
# Lecture du fichier et tranforme le nombre en float
def fichier_1000():
    fichier = open('.../1000.txt', "r")
    texte = fichier.read()
    valeur = float(texte)
    return valeur
 
# Multiplication
def incrementation_fichier_1000():
    multiplication = fichier_1000() * 1.2
    arrondi = round(multiplication, 6)
    return arrondi
 
# Tranformation du calcul en Str
f_1000 = str(incrementation_fichier_1000())
 
#Enregistrement du résultat dans le fichier
def inscription_new_valeur_1000():
    f = open('.../1000.txt', "w")
    f.write(f_1000)
    f.close()
 
# Le calcul se fait toutes les x secondes, ici 5
def reloadapi():
    threading.Timer(5.0, reloadapi).start()
    if float(a) > 5:
        inscription_new_valeur_1000()
reloadapi()

Quand je lance le code, le calcul se fait correctement ainsi que l'enregistrement la première fois, le problème est à chaque refresh. Le calcul ne se fait plus mais l'enregistrement est lui ok. En dehors du Threading cela fonctionne mais pas dans celui-ci.
Savez vous d'ou peut venir le problème, auriez une astuce s'il vous plait?

Merci

[wiztricks]

Salut,

Savez vous d'ou peut venir le problème, auriez une astuce s'il vous plait?

Le problème vient de la ligne 22.

Lorsque vous demandez à Python d'exécuter des instructions, il le fait (ou il plante) même si vous ne comprenez pas trop ce que vous lui avez demandé de faire.

L'astuce est d'apprendre à relire ses instructions en se mettant à la place de Python pour comprendre ce qu'il va bien pouvoir en faire et de vérifier (avec des "print") que çà fait ce qu'on pense.

- W

[berty4242]

Merci Wiztricks pour votre retour.

J'ai suivi votre conseil et je ne trouve malheureusement pas l'erreur.
Si j’exécute le script sans threading.Timer je n'ai aucun problème, a chaque exécution l'incrémentation du calcul ainsi que la sauvegarde fonctionne correctement. par contre quand je lance le script que j'ai indiqué plus haut le calcul se fait uniquement la première fois mais la sauvegarde est ok toutes les 5 secondes.
J'ai testé également de ne pas indiquer le format "str" mais une erreur indique qu'il faut me le faut...

Cdlt

[Sve@r]

Bonjour

J'ai suivi votre conseil et je ne trouve malheureusement pas l'erreur.

T'as remarqué que dans le thread tu ne fais que récrire encore et toujours la même valeur ??? Si tu veux qu'elle augmente dans le thread, à mon avis il te faudrait la réactualiser aussi dans le thread.
Accessoirement fermer le fichier une fois qu'il a été lu serait aussi un atout pour la réussite. Et puis toutes ces variables globales c'est pas non plus la super idée.

J'ai testé également de ne pas indiquer le format "str" mais une erreur indique qu'il faut me le faut...

Oui il le faut au write donc on peut ne le mettre qu'au moment du write (ie f_1000=incrementation_fichier_1000(); f.write(str(f_1000))). Ca a l'avantage de conserver la data originelle intacte au cas où il faudrait l'utiliser ailleurs.

PS: c'est quoi ce chemin commençant par "..." ??? Et pourquoi, si a vaut 10 (entier) le convertir en float pour le comparer avec 5 (autre entier) ???

[wiztricks]

Salut,

J'ai suivi votre conseil et je ne trouve malheureusement pas l'erreur.

Ben vous devriez utiliser la commande magique "print" pour afficher ce qui est écrit dans le fichier à chaque fois que reloadapi est exécuté:

Code :

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

1
2
3
4
5
def inscription_new_valeur_1000():
    f = open('.../1000.txt', "w")
    print(f_1000)
    f.write(f_1000)
    f.close()

Vous devriez constater que la valeur n'est modifiée qu'une seule fois.
Et donc que f_1000 n'est pas mis à jour.

Vous pourriez aussi supprimer le thread et écrire:

Code :

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

1
2
3
4
5
6
7
#def reloadapi():
#   threading.Timer(5.0, reloadapi).start()
#   if float(a) > 5:
#        inscription_new_valeur_1000()
#reloadapi()
inscription_new_valeur_1000()
inscription_new_valeur_1000()

pour constater que thread ou pas, le problème est encore là.

Et on retombe toujours sur la ligne 22... sans trop comprendre son utilité.

- W

[berty4242]

Salut Sve@r,

J'ai rajouté la notion de fermer le fichier mais cela écrit toujours la même valeur. Une piste pour réactualiser la valeur dans le thread?
Je n'ai pas indiqué le nom du chemin volontairement et effectivement ce sont bien des nombres à virgules (je faisais des tests quand j'ai copié les fonctions). Le a = 10 c'est juste pour déclencher le Thread.

wiztricks

J'ai donc supprimé le Thread comme vous l'avez indiqué et cela fonctionne parfaitement, le fichier est incrémenté avec le calcul et est enregistré.
La ligne 22 c'est pour mettre le format Str lors de l'enregistrement sinon j'ai un message d'erreur avec ceci "f.write(str(incrementation_fichier_1000()))".

Pour info je suis vraiment novice...

Merci à vous

[wiztricks]

Salut,

J'ai donc supprimé le Thread comme vous l'avez indiqué et cela fonctionne parfaitement, le fichier est incrémenté avec le calcul et est enregistré.

Si vous remplacez le thread par:

Code :

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

1
2
inscription_new_valeur_1000()
inscription_new_valeur_1000()

le "print" va vous afficher 2 fois la même valeur.

Pour info je suis vraiment novice...

Dans les tutos. vous trouverez explications et exercices corrigés histoire d'être moins "novice" avant de venir ici.

Un forum de discussion, c'est d'abord pour échanger des idées par pour corriger votre code, et pour pouvoir échanger des idées, partager un minimum de vocabulaire technique est indispensable.

- W

[berty4242]

Le print affiche 2 fois "None".
Concernant mon projet c'est la première fois que je poste quelque chose sur le forum j'ai effectué beaucoup de recherche et je bloque sur cette action mais je comprends.

[wiztricks]

Le print affiche 2 fois "None".

Je ne vois pas ou vous avez mis ces prints: postez le code.

- W

[Sve@r]

Je n'ai pas indiqué le nom du chemin volontairement

Ok. Je pensais à un truc style ".."

J'ai rajouté la notion de fermer le fichier mais cela écrit toujours la même valeur

Oui, ça c'était juste le bonus pour que ça ne plante pas bêtement, pas le truc magique qui manque. Ne pas fermer le fichier c'est un bug en plus, pas le bug que tu cherches.

Une piste pour réactualiser la valeur dans le thread?

Sais pas. Peut-être appeler la fonction incrementation_fichier_1000() dans le thread serait une idée à creuser...

J'ai donc supprimé le Thread comme vous l'avez indiqué et cela fonctionne parfaitement, le fichier est incrémenté avec le calcul et est enregistré.

Oui parce que quand tu exécutes le programme, il actualise la valeur. Donc si tu le lances 10 fois, il actualisera la valeur 10 fois. Mais si tu le lances une fois et qu'il boucle dans une partie du code qui n'actualise pas la valeur, alors elle n'est pas actualisée.

Le a = 10 c'est juste pour déclencher le Thread.

Et le lancer c'est pas un indice suffisant pour indiquer que tu veux qu'il se déclenche ???

Pour info je suis vraiment novice...

Etre novice ne dispense pas de réfléchir.

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
18
19
20
21
22
23
24
25
26
27
28
29
#!/usr/bin/env python3
# coding: utf-8
 
import threading
import os
import sys
 
# Lecture du fichier et tranforme le nombre en float
def fichier_1000(fic):
	with open(fic, "r") as fp: return float(fp.read())
 
# Multiplication
def incrementation_fichier_1000(fic, v, arrondi):
	return round(fichier_1000(fic) * v, arrondi)
 
# Enregistrement du résultat dans le fichier
def inscription_new_valeur_1000(fic, v):
	with open(fic, "w") as fp: fp.write(str(v))
 
# Le calcul se fait toutes les x secondes, ici 5
def reloadapi():
	threading.Timer(5.0, reloadapi).start()
	valeur=incrementation_fichier_1000("1000.txt", 1.2, 6)
	print(valeur)
	inscription_new_valeur_1000("1000.txt", valeur)
# reloadapi()
 
if __name__ == "__main__":
	reloadapi()

Pour info (parce que ça effectivement t'es pas obligé de connaitre), le bloc with s'occupe lui-même de fermer le fichier

sinon j'ai un message d'erreur avec ceci "f.write(str(incrementation_fichier_1000()))".

Surtout ne donne pas le message d'erreur mais surtout surtout ne le lis pas pour essayer de résoudre l'erreur. Pour info, tu vois que moi je n'ai pas de message d'erreur.

[berty4242]

Voici le code :

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
 
import threading
import os
import sys
 
a = 10
 
 
def fichier_1000():
    fichier = open('/1000.txt', "r")
    texte = fichier.read()
    valeur = float(texte)
    fichier.close()
    return valeur
 
def incrementation_fichier_1000():
    multiplication = fichier_1000() * 1.2
    arrondi = round(multiplication,6)
    return arrondi
 
f_1000 = str(incrementation_fichier_1000())
 
def inscription_new_valeur_1000():
    f = open('/1000.txt', "w")
    f.write(f_1000)
    f.close()
 
print(inscription_new_valeur_1000())
print(inscription_new_valeur_1000())

[wiztricks]

Voici le code :

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
 
import threading
import os
import sys
 
a = 10
 
 
def fichier_1000():
    fichier = open('/1000.txt', "r")
    texte = fichier.read()
    valeur = float(texte)
    fichier.close()
    return valeur
 
def incrementation_fichier_1000():
    multiplication = fichier_1000() * 1.2
    arrondi = round(multiplication,6)
    return arrondi
 
f_1000 = str(incrementation_fichier_1000())
 
def inscription_new_valeur_1000():
    f = open('/1000.txt', "w")
    f.write(f_1000)
    f.close()
 
print(inscription_new_valeur_1000())
print(inscription_new_valeur_1000())

Relisez mes réponses: je vous ai suggéré d'écrire:

Code :

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

1
2
inscription_new_valeur_1000()
inscription_new_valeur_1000()

et d'ajouter un print(f_1000) dans la fonction inscription_new_valeur_1000:

Code :

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

1
2
3
4
5
def inscription_new_valeur_1000():
    f = open('.../1000.txt', "w")
    print(f_1000)
    f.write(f_1000)
    f.close()

L'intention étant de vérifier que vous écriviez à chaque fois la même chose dans le fichier avec ou sans thread. print(inscription_new_valeur_1000()) affiche juste le retour de la fonction qui est None, ce n'était même pas la peine de l'écrire.

Je suis désolé mais un code c'est pas juste écrire des lignes et demander à Python de les exécuter en disant "whaouh" ou en venant pleurer ici que çà ne marche pas.

C'est tout un boulot de mise au point (car on écrit rarement juste du premier coup) où on vérifie que la machine fait bien ce qu'on attend d'elle.

Et c'est ce boulot là que vous apprenez à faire en essayant de coder les exercices d'un tuto. vous familiarisez avec la mise au point d'un programme, vous questionner sur ce que fait le code,...

Une fois assimilée les notions de bases et les réflexes à avoir sur de petits exemples, vous pouvez compliquer les choses avec fichiers, threads, boucles,... mais si vous ne maîtriser rien, vous ne savez même pas où chercher.

- W

[berty4242]

Grace à vous, la partie de ce code fonctionne même si à vos yeux je pense que ce n'est pas vraiment propre...:

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
 
import threading
import os
import sys
 
def fichier_1000():
    fichier = open('.../1000.txt', "r")
    texte = fichier.read()
    valeur = float(texte)
    fichier.close()
    return valeur
 
def incrementation_fichier_1000():
    multiplication = fichier_1000() * 1.2
    arrondi = round(multiplication,6)
    return arrondi
 
def inscription_new_valeur_1000(v):
    with open('.../1000.txt', "w") as f: f.write(str(v))
 
def reloadapi():
    threading.Timer(5.0, reloadapi).start()
    valeur = incrementation_fichier_1000()
    inscription_new_valeur_1000(valeur)
    print(fichier_1000())
 
reloadapi()

Merci à vous!

[Sve@r]

Grace à vous, la partie de ce code fonctionne

Et sinon pourquoi tu fais ça dans un thread ? Pour le plaisir de paralléliser un truc unique ???

[berty4242]

Et sinon pourquoi tu fais ça dans un thread ? Pour le plaisir de paralléliser un truc unique ???

Je ne sais pas répondre précisément à ta question, mais ça fait le job!
Pour être plus précis, je me suis lancé dans un script qui consiste à exécuter des ordres sur de la crypto. J’ai établi ma stratégie sur papier et l’ai reproduit sur python (en regardant divers forums ect...)
Le thread refresh le cours de la crypto et en fonction de ce dernier il exécute ou non les fonctions. Le fichier txt est le montant de la transaction qui doit être incrémenté au fur et a mesure des transactions.

[Sve@r]

Je ne sais pas répondre précisément à ta question, mais ça fait le job (est ce grave docteur?).

Ben grave/pas grave c'est relatif. Le parallélisme permet de faire plusieurs choses à la fois. Si tu n'as qu'une chose à faire, alors ça sert à rien et ça complexifie inutilement (le job peut alors très bien être fait dans une simple boucle infinie du programme principal).

Le fichier txt est le montant de la transaction qui doit être incrémenté au fur et a mesure des transactions (cela évite d avoir une base de donnée à gérer et les problèmes liés à un crash de PC).

Alors justement une bdd a l'avantage de pouvoir être déportée (si le PC crashe, la bdd située sur l'autre PC continue à vivre). Et même sans ça, Python intègre en natif l'outil sqlite, une mini bdd en local. En gros c'est une espèce de fichier blob dans lequel tu peux accéder via des ordres SQL (select, insert, update, delete). Bien plus pratique que tes open/read/write/close. Et si la bdd n'a pas besoin d'exister en dehors du programme, alors la bdd peut même être créée en RAM.