Moyen d'analyser AVANT/APRÈS

Version imprimable

Bonjour,

Mon programme comporte de nombreuses lignes et quelques modules.

Les print m'aident à y voir clair lorsque je cherche une ou des solutions.
C'est en retirant l'instruction print que je me suis apperçu de ce phénomène que je ne comprend pas.

En exécutant ce petit code :
Code:

1 2 3 4 5 6 7 8 9 def inv_acc(n): print(f' Plouc {n}') if __name__ == '__main__': print(f' GEM Quelle seption !') inv_acc(1)
Code:

1 2 GEM Quelle seption ! Plouc 1
En exécutant celui-ci :
Code:

1 2 3 4 5 6 7 8 9 def inv_acc(n): (f' Plouc {n}') if __name__ == '__main__': print(f' GEM Quelle seption !') inv_acc(1)
Code:

GEM Quelle seption !

Ainsi qu'avec IDLE :
Code:

1 2 3 4 5 Type "help", "copyright", "credits" or "license()" for more information.>>> >>> print('Hello', 4) Hello 4 >>> ('Hello', 4) ('Hello', 4)
Si je poste ce message qui n'est pas un réel problème, sinon que de voir cette hallucination perdurer dans le temps.
Car cet effet de codage m'intéresse vraiment, et je suggère de ne pas enlever cette possibilité. Et l'améliorer si besoin.

Rectification :
Code:

1 2 3 4 5 6 7 8 9 10 11 if dan == 66: """Initialisation des tableaux majeurs du 66""" # Recherche Point Go & tonic [0, 0, 0, 0, 0, 0, 0] :maj_mode[66] # Enregistrement Poids modaux :maj_poids[66] (lineno(), 'Dana', dana[dan], dan) # 84 Dana [[[0, 0, 0, 5, 0, 0, 0], [588, 84.0, 12.0, 1.7142857142857142, # 0.24489795918367346]], [[0, -3, -4, 0, 0, -7, -8], [0]], [[0, 0, -4, 0, 0, 0, -8], # [490, 70.0, 10.0, 1.4285714285714286, 0.20408163265306123]], [[0, 0, 0, 0, 0, 0, 0], # [833, 119.0, 17.0, 2.4285714285714284, 0.3469387755102041]], [[0, -3, -4, 0, -6, -7, -8], # [196, 28.0, 4.0, 0.5714285714285714]], [[0, 0, -4, 0, 0, -7, -8], [343, 49.0, 7.0, 1.0]], # [[0, 0, 0, 0, 0, 0, -8], [784, 112.0, 16.0, 2.2857142857142856, 0.32653061224489793]]] 66 for dn in range(7):

21/09/2021, 11h23
wiztricks
Salut,

Lorsqu'on exécute un script, seules les sorties des "print" s'affichent.
Avec l'interpréteur Python (les ">>>" qui s'affichent) le résultat de l'évaluation de l'instruction s'affiche (même si on n'a rien demandé) sauf si c'est None:
Code:

1 2 3 4 5 6 >>> (1,2) (1, 2) >>> 1 1 >>> None >>>
- W

Belle réponse merci wiztricks

Un dernier questionnement, existe t'il une esquive permettant de reproduire ceci :

Code:

1
2
3
4
5
6
7
8
9
if dan == 66:"""Initialisation des tableaux majeurs du 66"""# Recherche Point Go & tonic [0, 0, 0, 0, 0, 0, 0] :maj_mode[66]
    # Enregistrement Poids modaux :maj_poids[66]
(lineno(), 'Dana', dana[dan], dan)
    # 84 Dana [[[0, 0, 0, 5, 0, 0, 0], [588, 84.0, 12.0, 1.7142857142857142,
    # 0.24489795918367346]], [[0, -3, -4, 0, 0, -7, -8], [0]], [[0, 0, -4, 0, 0, 0, -8],
    # [490, 70.0, 10.0, 1.4285714285714286, 0.20408163265306123]], [[0, 0, 0, 0, 0, 0, 0],
    # [833, 119.0, 17.0, 2.4285714285714284, 0.3469387755102041]], [[0, -3, -4, 0, -6, -7, -8],
    # [196, 28.0, 4.0, 0.5714285714285714]], [[0, 0, -4, 0, 0, -7, -8], [343, 49.0, 7.0, 1.0]],
    # [[0, 0, 0, 0, 0, 0, -8], [784, 112.0, 16.0, 2.2857142857142856, 0.32653061224489793]]] 66 for dn in range(7):

En programmant j'ai parfois besoin de me raffraichir la mémoire, et je le fais en revoyant cette petite aide.

Existe t-il une solution pour assister la gestion du code ? La detection des erreurs n'est pas le sujet.

21/09/2021, 12h27
Arioch

Citation:

Envoyé par toumic2.0

Existe t-il une solution pour assister la gestion du code ? La detection des erreurs n'est pas le sujet.

Assister la gestion du code, c'est à dire ?

Tu parles de tester le code ?
21/09/2021, 14h00
toumic2.0
Citation:

Envoyé par Arioch

Assister la gestion du code, c'est à dire ?

Tu parles de tester le code ?
- Assister la gestion du code, c'est à dire ?
Quand je code je fais évoluer le programme, et pendant ce temps à un moment donné de cette exécution il est probable de vouloir se rafraichir la mémoire. Car les codes peuvent dériver & alors les 1ers éléments s'en trouvent éloignés. Par conséquent la création d'une bibliothèque avec des appelants venant basculer les parties du code à un mode print automatisé.
- Tu parles de tester le code ?
Non.
21/09/2021, 15h26
wiztricks
Salut,

Pas sûr d'avoir tout compris mais rien n'empêche d'avoir des "print" conditionnels du genre:
Code:

1 2 if DEBUG_XYZ: print(...)
lorsqu'on veut afficher les messages de la partie XYZ, on définit DEBUG_XYZ à True et voilà.

note: le module logging intègre aussi ce genre de fonctionnalités/possibilités.

- W
21/09/2021, 15h44
toumic2.0
Citation:
Envoyé par wiztricks

Salut,

Pas sûr d'avoir tout compris mais rien n'empêche d'avoir des "print" conditionnels du genre:

Code:

1 2 if DEBUG_XYZ: print(...)

lorsqu'on veut afficher les messages de la partie XYZ, on définit DEBUG_XYZ à True et voilà.

note: le module logging intègre aussi ce genre de fonctionnalités/possibilités.

- W
À 1^ére vue ça ressemble pas mal du tout à çà :)

Je proposerais également le logging. On l'utilise dans ma société de manière à uniformiser nos logs de tous horizons, les rassembler et faire du monitoring dessus.

Sinon, une petite fonction toute bête :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 def print_debug(debug: bool, msg: str) -> None: if debug: print(msg) def main() -> None: '''Main function''' print_debug(True, "ce texte doit s'afficher") print_debug(False, "mais pas celui-ci") if __name__ == '__main__': main()

Citation:
Envoyé par Arioch
Je proposerais également le logging. On l'utilise dans ma société de manière à uniformiser nos logs de tous horizons, les rassembler et faire du monitoring dessus.

Sinon, une petite fonction toute bête :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 def print_debug(debug: bool, msg: str) -> None: if debug: print(msg) def main() -> None: '''Main function''' print_debug(True, "ce texte doit s'afficher") print_debug(False, "mais pas celui-ci") if __name__ == '__main__': main()
Code:

1 2 # OK MERCI :) """Utile pour activer les print"""
8-)

Juste comme ça

Employer logging à partir de différents modules

Si votre programme est composé de plusieurs modules,
voici une façon d'organiser l'outil de journalisation :# myapp.py
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 import logging import mylib def main(): logging.basicConfig(filename='myapp.log', level=logging.INFO) logging.info('Started') mylib.do_something() logging.info('Finished') if __name__ == '__main__': main() # mylib.py import logging def do_something(): logging.info('Doing something')

Une dernière instruction

Warnin pour écrire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
# Python3 UTF-8# Utilité : Module logging
 
 
import logging
import mylib
 
 
def main():
    logging.warning('Ligne 12')
    print('#mylog', 'Ligne 12')
    mylib.funfonc()
 
 
('#mylog')
 
 
if __name__ == '__main__':
    main()

Pour ce résultat

Code:

1
2
3
4
5
 
=== RESTART: C:/Users/Vincent/Desktop/Python Perso/mylog.py ==#mylib
WARNING:root:Ligne 12
#mylog Ligne 12
WARNING:root:mylib.funfonc

23/09/2021, 10h52
Bayard
Il existe également le débugueur python
Code:

1 2 3 4 import pdb if a == 2: pdb.set_trace()
quand a vaudra 5, il y a un point d'arrêt et on peut faire du pas à pas ou regarder l'historique

plus d'information: https://docs.python.org/fr/3/library/pdb.html

Bonne journée

1 pièce(s) jointe(s)

Ainsi qu'une méthode fort simple

Citation:

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
39
""" { *** | MODE ONE | HORS MODE RUN | *** } Retrouver l'oubli ?Assimiler avec un programme ayant trois sections.
    1. Section Table [Légumes] *
    2. Section Menus [Enfants] *
    3. Section Music [Gammics] *
______________________________ *
# Utilitaire Dictionnaire.traceur Fonction.{DICTrace}
### Code bidule.py  # Module principal
               |Table.[Légumes].Fonction.[]
Traçage Section Menus.[Enfants].Fonction.[]
               |Music.[Gammics].Fonction.[]
Écriture codée du bidule.[Légumes]
Bidule donne du travail à ventre
### Code ventre.py  # Sous Module
Traçage informations comme bidule.py {DICTrace}
Écriture codée du ventre.[Enfants]
Ventre donne du travail à écoute
### Code écoute.py  # Sous Module
Traçage informations comme bidule.py {DICTrace}
Écriture codée d'écoute.[Gammics]
"""  # Gagner en visibilité ~ Prints de recherche en moins
# Création dictionnaire traceur {DICTrace}
# En cours des 1ères lignes de codage...
# Enregistrement des ancrages {DICTrace}
#   Ancrage ; (chemin.)Module.Section.Fonction.[Print]
# Mise à jour {DICTrace}
# Informations sensibles :
#   Organisation des points de consultation
#       Section[Table].[] ou [Table].Fonction.[] ou {DICTrace}
# {DICTrace} dissémine des ancres(print) dans l'application
# {DICTrace} accessible culbuteur print(défaut.ONE)
"""Autre(s) Ancre.(print).(ONE, OFF, ISO, OUT)"""
# {DICTrace} gestion parenthèses sans print
""" # {DICTrace} Print Parent
Ancre(print).ONE = print()
Ancre(print).OFF = rien
Ancre(print).ISO = info_bulle.Origine + .Locale hypertexte
    Origine : À l'emplacement de l'ancrage.
    Locale : Notification utilisateur ailleurs
Ancre(print).OUT = info_bulle.Locale hypertexte """

Pièce jointe 605343

Code:

1
2
3
4
5
6
7
8
 
for fk, fv in fondre.items():  # fondre: Binaires + Poids basic (de 1 à 66)    
    (lineno(), 'Fondre', fk, fv)
    # 67 Fondre 66 [(('101010110101', 5), 66), (('101011010101', 0), 66)]
for uk, uv in unic.items():  # unic: Tonalités à deux altérations
    (lineno(), 'Unic', uk, uv[:12], '\n', uv[12:])
    # 70 Unic 66 ['1', '0', '2', '0', '3', '4', '0', '5', '0', '6', '0', '7']
    # [[((0, 66), '101011010101')]]

Et en plus ça ne crée pas d'erreur, et ça évite d'écrire pass ou break.
Si ça ne vous dérange pas d'attendre les fins des boucles for
Ok c'est rectifié :D