UE X22P050 2019 - 2020

Modélisation pour la physique 2

Projet : Resistances Electriques

Bréchault ferdinand & Adrien Dylan
Groupe 461X

1
Table des matières

Résumé du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Nature du Problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
I. Outils utilisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
II. Méthodes utilisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
II..1 Partie "opérationelle" du programme . . . . . . . . . . . . . . . . . . 4
II..2 Partie graphique et interface du programme . . . . . . . . . . . . . . 7
III. Discussions et résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
IV. Références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2
UE X22P050 2019 - 2020
Modélisation pour la physique 2

Résumé du projet
Ce projet avait pour sujet les résistances électriques. Notre programme devait être
capable de reconnaître une résistance électrique à partir des renseignements donnés par
l’utilisateur (les 3 premières bandes de couleurs inscrites sur la résistance.). Il devait aussi
être capable de retrouver les bandes de couleurs à partir de la valeur de la résistance.
Enfin, suite à une recherche dans une liste conetenant plusieurs résistances, le programme
devait être capable de trouver une résistance proche à 5% près, et de faire une association
de résistances en série et en parallèle qui serait équivalente à la résistance donnée par
l’utilisateur. Pour réaliser ce projet on a eu recours à des chaines de caractères, des listes
et une interface graphique Tkinter. Les résultats obtenus sont conformes a ce qui est
attendu, en revanche un certain nombre d’amélioration peuveut être apporté.

Introduction
Notre projet consiste en la réalisation d’un programme qui doit permettre de :
- Déterminer la valeur d’une resistance à partir de ses 3 couleurs
- Déterminer les 3 couleurs d’une résistance à partir de sa valeur
- Rechercher à 5% près la valeur demandé dans un fichier texte :
1. une résistance unique dont la valeur est précisée par l’utilisateur
2. ou une association de 2 résistances en série qui soit équivalente
3. ou une association de 2 résistances en parallèle
Pour ce projet, nous nous sommes organisés tel que Dylan a réalisé la partie "opéra-
tionelle" du programme c’est à dire les fonctions qui permettent de définir les différents
résultats. Pour ma part j’ai réalisé la partie graphique/interface permettant une meilleure
lisibilité des résultats. Évidement une coopération et une entraide étaient de mise pour
réaliser chaque tâches réparties.

Nature du Problème
Le problème posé ici, s’agit de rechercher dans un fichier texte les valeurs de resis-
tances électriques, afin de les traiter pour l’utilisateur. Ce fichier texte peut s’apparenter
à un stock de résistances ; le programme doit permettre d’aider l’utilisateur à trouver sa
résistance dans le stock ou au moins lui proposer une association de résistance en série ou
parralèle qui se rapproche de la valeur demandée initialement.

3
UE X22P050 2019 - 2020
Modélisation pour la physique 2

I. Outils utilisés
Au vu de la situation de confinement qui a duré pendant une période de cours en pré-
sentiel, période qui aurait du permettre la réalisation de ce projet sur les outils disponibles
à la faculté ; ces outils ont dû se substitué à d’autres.

La distribution Linux qui permet d’utiliser le logiciel Geany sur les ordinateurs de la
facultés a été, pour Ferdinand, remplacer par le logiciel Python sous windows [1] couplé au
logiel IDE PyCharm [2] qui est un environnement de développement intégré perméttant
d’exploiter sous une interface claire et pratique l’environement Python.

Pour Dylan la réalisation de ce projet s’est faite grâce à Geany et son interface de
programation sous windows.

II. Méthodes utilisées

II..1 Partie "opérationelle" du programme
La partie opérationelle du programme est décomposé, dans un premier temps, en 3
"sous-programmes" qui réalise les 3 fonctions demandées dans l’énoncé du sujet :
1- Déterminer la valeur d’une resistance à partir de ses 3 couleurs
2- Déterminer les 3 couleurs d’une résistance à partir de sa valeur
3- Rechercher à 5% près la valeur demandé dans un fichier texte et indique les 3 issues
possibles exposées en introduction.
Ces 3 "sous-programmes" sont subdivisés en plusieurs fonctions permettant une meilleure
lisibilité du programme, d’appeler ces fonctions et leurs attribuer des valeurs correspon-
dantes au retour d’autres fonctions. Chaque fonction utilise des structures conditionelles
simples : "Si/sinon/alors" ; "Pour... à...faire..." et "tant que ... faire".

4
UE X22P050 2019 - 2020
Modélisation pour la physique 2

les "sous-programmes" sont sous forme de fonctions dans le programme final et sont notées
c1, c2 et c3. (voir le programme entier en annexe1)

d e f c1 ( ) : ...
d e f c2 ( ) : ...
d e f c3 ( ) : ...

"Sous-programme" c1
Pour ce premier algorithme il a fallu trouver un moyen de disocier la valeur de la
résistance donnée par l’utilisateur afin d’en extraire les deux premiers chiffres significatifs,
et les autres chiffres pour connaître l’odre de grandeur de la résistance. Pour cela on
a transformé la valeur de la resistance, qui est initialement un entier, en une chaîne de
caractère. Ainsi il suffit de regarder les deux premiers caractères de la chaîne pour connaître
les deux chiffres indicatifs. Pour recupèrer ces deux valeurs on a utilisé une fonction appelée
traitement_de_la_valeur. Cette fonction regarde les deux premiers caractères de la
chaîne et leur associe une couleur grâce à une suite de if.

Pour l’ordre de grandeur, on a utilisé une deuxième fonction appelé puissance, où l’on
classe la valeur de la resistance entre deux puissances de 10 consécutives et on en déduit
l’ordre de grandeur de la valeur de la résistance. Cette fonction consiste elle aussi en une
suite de if.

Enfin toutes ces informations sont placées dans une liste de taille 3 noté :
R = ["" , "" , ""]

Le programme prend les variables de cette liste pour pour les associer aux commandes de
l’affichage.

"Sous-programme" c2
Pour le deuxième algorithme on a utilisé des menus déroulants pour que l’utilisateur
puisse entrer les bandes de couleurs présentent sur la résistance. Les couleurs selection-
nées dans les menus déroulants sont ensuite transformés en chaînes de caractère pour être
utilisées par la fonction determination_de_la_couleur. Cette fonction n’est compo-
sée que d’une série de if qui analyse quels sont les caractères qui compose la chaîne de
caractère. Si une suite de caractère prédéfinie par les conditions des if est présente alors
la conditionnelle lui associe un nombre qui sera par la suite stocké dans une liste r pour
être utilisé par la formule :

(r[0] × 10 + r[1]) × (10r [2])

5
UE X22P050 2019 - 2020
Modélisation pour la physique 2

"Sous-programme" c3
Tout d’abord, il a fallu ranger les valeurs du fichier texte dans une liste, puis ordonner
cette liste en rangeant les valeurs de résistance par odre croissant. Pour le remplissage de
la liste il faut noter que ce qui est écrit dans le fichier texte est traité comme une seule
chaîne de carcactère, et que chaque valeur de résistance est séparée par un /n.

Pour remplir la liste on a eu recours à une boucle for ayant pour variable k. Pour
k=0 on a eu besoin d’une boucle while, cette boucle ayant pour condition d’arrêt while
(contenu[i] !="/n"). Dans cette même boucle on fait aussi la somme des contenu[i] qui
sont les caractères de la chaîne de caractère du fichier texte. Cette somme s’arrête donc
au ième+1 caractère, et cela donne la première valeur de résistance du fichier texte. Cette
valeur est ensuite insérée dans une liste via la commande L1.insert(k,somme).

Ensuite, on a défini k comme i+1, et on le fait passer par deux if, le premier sert à ce
que le k ne soit pas plus grand que la taille de la chaîne de caractère, ce qui entraînerait
un arrêt de l’algorithme, tandis que le deuxième if est là pour vérifier que le caractère à
la k ème ne soit pas un "/n" afin de n’avoir que les valeurs dans la liste. Un second while
ayant pour condition d’arrêt (contenu[i] !="/n" and i<=len(contenu)) est noté. La
première condition d’arrêt permet de séparer une valeur d’une autre, car comme ci-dessus
toutes les valeurs sont séparées pas un "/n", alors que la seconde condition est la pour
que la variable i ne dépasse pas la taille de la chaîne de caractère. Dans ce seconde while
on fait aussi la somme des caractères, la différence par rapport au premier while est, ici,
que la somme des caractères est faite depuis le dernier "/n ".

Pour ordonner la liste contenant les valeurs des résistances, on a dans un souci d’op-
timisation d’abord décider de séparer les valeurs de la liste pas ordre de grandeur afin
de former des listes plus petites, pour cela on a utilisé la fonction puissance vu précé-
demment, mais ici au lieu de rentrer une chaîne de caractère correspondant au nom d’une
couleur la fonction puissance insère la valeur dans une liste. Après que les valeurs aient
été rangées par ordre de grandeurs dans des listes plus petites, l’algorithme fait appel à
la fonction rangement, cette nouvelle fonction est composée de deux while, d’un for et
d’un if ; le premier while sert à continuer la recherche de la plus petite valeur tant que
la liste de départ n’est pas vide.

Le for quant à lui sert à prendre une valeur de résistance qui va être comparée à toutes
les autres valeurs de la liste à l’aide du second while, et si une valeur est plus petite que
toutes les autres, alors elle rentre dans le if qui l’ajoute à la liste ordonnée et la supprime
de la liste de départ.

La recherhe d’une résistance proche à 5% près dans la liste ordonnée se fait via la fonction
recherche qui n’est composée que d’un for qui fait le rapport entre une valeur de résis-
tance stocké dans la liste et la résistance donnée par l’utilisateur. Si le rapport est compris
entre 95% et 105% alors la valeur est affichée par le programme. Pour la recherche d’une
association en série de deux résistances qui est équivalente à celle donnée par l’utilisateur,

6
UE X22P050 2019 - 2020
Modélisation pour la physique 2

l’algorithme fait appel à la fonction recherche_de_deux_resistances_en_serie qui

utilise un premier for et donne une valeur de référence avec laquelle on va utiliser la
formule suivante :
l[i] + l[k]
v
avec l[i] la valeur de la liste qui sert de référence, l[k] la valeur d’une autre résistance qui
est associée en série à celle de référence, et v la valeur de résistance donnée par l’utilisateur.
Si ce rapport est compris entre 95% et 105% alors le programme affiche l[i] et l[k].

Pour la recherche d’une association de deux résistances en parallèle qui est équivalente
à la résistance de l’utilisateur on a eu recours à la fonction recherche _de_deux
_resistances_en_parallele qui reprend la même méthode que la fonction précédente
à l’exception du fait que la formule est différente :

l[i] × l[k] 1
×
l[i] + l[k] v

II..2 Partie graphique et interface du programme

Une interface graphique, avec lequel l’utilisateur peut dialoguer nous paraît important,
c’est pour cela que nous avons créer une fenêtre graphique grâce à la bibliothèque Tkinter
Lors du lancement du programme : une fenêtre s’ouvre (voir annexe2) sur laquelle est
disposé plusieurs éléments. La création de la fenêtre se fait par la commande "=Tk()".
Elle s’agrémente d’un titre, d’une taille par défaut et minimale, d’un icone et d’une couleur
de fond. Les éléments de la fenêtre sont disposés dans une ensemeble de boîte et sous-boîte
permettant de les positionner aisément.

Pour le premier programme noté "c1", l’utilisateur entre la valeur de sa résistance dans
un champ de texte( commande : "=Entry()") qui est paramétré afin de lui donné son
apparence. Un bouton perment de valider la saisie ; à ce moment la programme éxecute la
fonction "c1" et paramètre les fonctions suivantes :
t r a i t e m e n t _ d e _ l a _ v a l e u r ( f l o a t ( e1 . g e t ( ) ) )
p u i s s a n c e ( f l o a t ( e1 . g e t ( ) ) )

Ces 2 fonctions recevoient les valeurs de retour de la saisie par "e1.get". Ainsi s’ouvre
une nouvelle fenêtre afficahant la résistance correspondante. Ce shéma est composé de
rectangle de couleur associé aux valeurs de la liste :
R = ["" , "" , ""]

(voir annexe3)

Pour le second programme noté "c2", l’utilisateur entre les couleurs de sa resistance
par le biais de menus déroulants (commande : "=ttk.combobox"). Un bouton perment
de valider la saisie ; à ce moment la programme éxecute la fonction "c2" et paramètre les
fonctions suivantes :

7
UE X22P050 2019 - 2020
Modélisation pour la physique 2

B1 = s t r ( c o u l e u r s 1 . g e t ( ) )
B2 = s t r ( c o u l e u r s 2 . g e t ( ) )
B3 = s t r ( c o u l e u r s 3 . g e t ( ) )

Determination_de_la_couleur ( B1 , 0 )
Determination_de_la_couleur ( B2 , 1 )
Determination_de_la_couleur ( B3 , 2 )

Ces 3 fonctions recevoient les valeurs des variables B1, B2 et B3 qui elle-même recoivent
le retour de la saisie des menus déroulents par "couleurs"...".get". Ainsi s’ouvre une
nouvelle fenêtre afficahant la valeur de la résistance correspondante.(voir annexe4)

Pour le troisème programme noté "c3", l’utilisateur entre la valeur de sa resistance par
le biais d’un champ de saisie. Un bouton perment de valider la saisie ; à ce moment la
programme éxecute la fonction "c3" et paramètre les fonctions suivantes :
r e c h e r c h e (LF , i n t ( e2 . g e t ( ) ) )
r e c h e r c h e _ d e _ d e u x _ r e s i s t a n c e s _ e n _ s e r i e (LF , i n t ( e2 . g e t ( ) ) )
r e c h e r c h e _ d e _ d e u x _ r e s i s t a n c e s _ e n _ p a r a l l e l e (LF , i n t ( e2 . g e t ( )
))

Ces 3 fonctions recevoient les valeurs retour de la saisie par "e2.get". Ainsi s’ouvre une
nouvelle fenêtre afficahant le résultats (voir annexe5).

Toutes les fenêtres des fonctions "c1", "c2" et "c3" sont paramétrées à l’intérieur même
de ces fonctions selon le design de la fenêtre principale.

III. Discussions et résultats

L’utilisateur donne une valeur de résistance et l’algorithme lui renvoie un schéma com-
posée de trois bandes de couleurs, la première correspond au premier chiffre significatif,
de même pour la deuxième bande qui correspond au deuxième chiffre significatif, et enfin
la troisième bande correspond au multiplicateur (la puissance de 10). L’algorithme ne fait
qu’associer un chiffre à une couleur, et ceci donne des résultats qu’on ne peut pas vraiment
critiqué, car facilement vérifiable avec l’aide de l’énoncé. Cependant si on voulait amélio-
rer l’algorithme il faudrait prendre en compte les résistances inférieure à 10 Ω , car si la
valeurs est inférieur à 10 Ω, alors le second caractère de la liste ne serait plus le seconde
chiffre significatif mais un ".".

Le résultat du deuxième algorithme est une valeur de résistance et ne fait qu’une asso-
ciation entre une couleur et une valeur, et il suffit de se réferer à l’énoncé pour vour si la
solution donnée par l’algorithme est correcte. Cependant on peut faire à cette algorithme
la même critique qu’au premier, on pourriat agrandir le nombre de cas traitable par l’al-
gorithme en ajoutant la couleur "Jaune-verts" et "grise", qui permettrait à l’algorithme de
donner des valeurs de résistances décimales.

8
UE X22P050 2019 - 2020
Modélisation pour la physique 2

Pour le résultat de la dernière fonction il est conformes aux attentes malgré quelque
latence. Le résultats graphique de ce dernier pourrait être amélioré en proposant un shéma
des associations des résistances.

Conclusion
Pour finir, nous pensons avoir répondu à l’énoncé, même si certaine optimisation reste
possible. Notamment au niveau de la fonction remplissage et de la fonction rangement,
car avec la liste de résistances qui a été fournie on arrive déjà à 10 secondes de calcul et
ce temps de calcul risque de devenir génant si des listes plus longues sont utilisées pour
le troisième algorithme. De plus l’interface peut être améliorer par un plus joli design
en attribuant des images aux différents éléments de la fenêtre. Ces améliorations sont
superficiels et n’entache pas le bon fonctionnement du programme.

IV. Références
[1] https ://www.python.org/
[2] https ://www.jetbrains.com/fr-fr/pycharm/
[3] https ://www.geany.org/
[4]https ://python.doctor/
[5]https ://www.youtube.com/channel/UCIHVyohXw6j2T-83-uLngEg

9
UE X22P050 2019 - 2020
Modélisation pour la physique 2

Annexes
Annexe1
from t k i n t e r import ∗
from math import ∗
from t k i n t e r import t t k

d e f c1 ( ) :

def puissance (p) :

i f ( 1 0 <= p < 1 0 0 ) :
R[ 2 ] = " black "
i f ( 1 0 0 <= p < 1 0 0 0 ) :
R [ 2 ] = " brown "
i f ( 1 0 0 0 <= p < 1 0 0 0 0 ) :
R[ 2 ] = " red "
i f ( 1 0 0 0 0 <= p < 1 0 0 0 0 0 ) :
R[ 2 ] = " orange "
i f ( 1 0 0 0 0 0 <= p < 1 0 0 0 0 0 0 ) :
R[ 2 ] = " yellow "
i f ( 1 0 0 0 0 0 0 <= p < 1 0 0 0 0 0 0 0 ) :
R[ 2 ] = " green "
i f ( 1 0 0 0 0 0 0 0 <= p < 1 0 0 0 0 0 0 0 0 ) :
R[ 2 ] = " blue "
i f ( 1 0 0 0 0 0 0 0 0 <= p < 1 0 0 0 0 0 0 0 0 0 ) :
R[ 2 ] = " purple "
i f ( 1 0 0 0 0 0 0 0 0 0 <= p < 1 0 0 0 0 0 0 0 0 0 0 ) :
R[ 2 ] = " grey "
i f ( 1 0 0 0 0 0 0 0 0 0 0 <= p ) :
R[ 2 ] = " white "

def traitement_de_la_valeur (b) :

k = str (b)

# premier s i g n i f i c a t i f
i f ( k [ 0 ] == ’ 0 ’ ) :
R[ 0 ] = " black "
i f ( k [ 0 ] == ’ 1 ’ ) :
R [ 0 ] = " brown "
i f ( k [ 0 ] == ’ 2 ’ ) :
R[ 0 ] = " red "
i f ( k [ 0 ] == ’ 3 ’ ) :
R[ 0 ] = " orange "

10
UE X22P050 2019 - 2020
Modélisation pour la physique 2

i f (k [ 0 ] == ’ 4 ’ ) :
R[ 0 ] = " yellow "
i f (k [ 0 ] == ’ 5 ’ ) :
R[ 0 ] = " green "
i f (k [ 0 ] == ’ 6 ’ ) :
R[ 0 ] = " blue "
i f (k [ 0 ] == " 7 " ) :
R[ 0 ] = " purple "
i f (k [ 0 ] == ’ 8 ’ ) :
R[ 0 ] = " grey "
i f (k [ 0 ] == ’ 9 ’ ) :
R[ 0 ] = " white "
# deuxi me chiffre significatif
i f (k [ 1 ] == ’ 0 ’ ) :
R[ 1 ] = " black "
i f (k [ 1 ] == ’ 1 ’ ) :
R[ 1 ] = " brown "
i f (k [ 1 ] == ’ 2 ’ ) :
R[ 1 ] = " red "
i f (k [ 1 ] == ’ 3 ’ ) :
R[ 1 ] = " orange "
i f (k [ 1 ] == ’ 4 ’ ) :
R[ 1 ] = " yellow "
i f (k [ 1 ] == ’ 5 ’ ) :
R[ 1 ] = " green "
i f (k [ 1 ] == ’ 6 ’ ) :
R[ 1 ] = " blue "
i f (k [ 1 ] == ’ 7 ’ ) :
R[ 1 ] = " purple "
i f (k [ 1 ] == ’ 8 ’ ) :
R[ 1 ] = " grey "
i f (k [ 1 ] == ’ 9 ’ ) :
R[ 1 ] = " white "

R = ["" , "" , ""] # c a r a c t r i s t i q u e s de l a r s i s t a n c e

t r a i t e m e n t _ d e _ l a _ v a l e u r ( f l o a t ( e1 . g e t ( ) ) ) # on c h e r c h e l e s
deux p r e m i r e s v a l e u r s de l a r s i s t a n c e s e t l e s bandes
de c o u l e u r s q u i l e u r s s o n t a s s o c i e s

p u i s s a n c e ( f l o a t ( e1 . g e t ( ) ) ) # on c h e r c h e l e c o e f f
m u l t i p l i c a t e u r de l a r s i s t a n c e e t l a bande q u i l u i e s t
associ e

11
UE X22P050 2019 - 2020
Modélisation pour la physique 2

window1 = Tk ( )
window1 . t i t l e ( " r e s i s t a n c e s ␣ dans ␣ t o u s ␣ c e s ␣ tats " )
window1 . geometry ( " 1000 x400 " )
window1 . m i n s i z e ( 1 2 0 0 , 5 0 0 )
window1 . wm_iconbitmap ( "ohm−35900_960_720 . i c o " )
window1 . c o n f i g ( background= ’#FF5733 ’ )
t i 1 = La be l ( window1 , t e x t=" V o i c i ␣ v o t r e ␣ r s i s t a n c e ␣ : " , f o n t
=( " C o u r i e r " , 2 8 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t i 1 . pack ( )
f e 1 = Frame ( window1 , bg= ’#FF5733 ’ )
b1 = Canvas ( f e 1 , width =1000 , h e i g h t =350 , bg= ’ w h i t e ’ )
b1 . c r e a t e _ r e c t a n g l e ( 3 0 0 , 0 , 4 0 0 , 3 5 0 , f i l l =R [ 0 ] )
b1 . c r e a t e _ r e c t a n g l e ( 5 0 0 , 0 , 6 0 0 , 3 5 0 , f i l l =R [ 1 ] )
b1 . c r e a t e _ r e c t a n g l e ( 7 0 0 , 0 , 8 0 0 , 3 5 0 , f i l l =R [ 2 ] )
b1 . pack ( )
f e 1 . pack ( expand=YES)

window1 . mainloop ( )

d e f c2 ( ) :
d e f Determination_de_la_couleur ( c , k ) :

f o r i in range (0 , len ( c ) ) :

i f ( c [ i ] == ’ n ’ and c [ i + 1 ] == ’ o ’ and c [ i + 2 ] ==
’ i ’ and c [ i + 3 ] == ’ r ’ and c [ i + 4 ] == ’ e ’ ) :
r [k] = 0
i f ( c [ i ] == ’m’ and c [ i + 1 ] == ’ a ’ and c [ i + 2 ] ==
’ r ’ and c [ i + 3 ] == ’ r ’ and c [ i + 4 ] == ’ o ’ and c
[
i + 5 ] == ’ n ’ ) :
r [k] = 1
i f ( c [ i ] == ’ r ’ and c [ i + 1 ] == ’ o ’ and c [ i + 2 ] ==
’ u ’ and c [ i + 3 ] == ’ g ’ and c [ i + 4 ] == ’ e ’ ) :
r [k] = 2
i f ( c [ i ] == ’ o ’ and c [ i + 1 ] == ’ r ’ and c [ i + 2 ] ==
’ a ’ and c [ i + 3 ] == ’ n ’ and c [ i + 4 ] == ’ g ’ and c
[
i + 5 ] == ’ e ’ ) :
r [k] = 3
i f ( c [ i ] == ’ j ’ and c [ i + 1 ] == ’ a ’ and c [ i + 2 ] ==
’ u ’ and c [ i + 3 ] == ’ n ’ and c [ i + 4 ] == ’ e ’ ) :
r [k] = 4
i f ( c [ i ] == ’ v ’ and c [ i + 1 ] == ’ e ’ and c [ i + 2 ] ==

12
UE X22P050 2019 - 2020
Modélisation pour la physique 2

’ r ’ and c [ i + 3 ] == ’ t ’ and c [ i + 4 ] == ’ e ’ ) :
r [k] = 5
if ( c [ i ] == ’ b ’ and c [ i + 1 ] == ’ l ’ and c [ i + 2 ] ==
’ e ’ and c [ i + 3 ] == ’ u ’ and c [ i + 4 ] == ’ e ’ ) :
r [k] = 6
if ( c [ i ] == ’ v ’ and c [ i + 1 ] == ’ i ’ and c [ i + 2 ] ==
’ o ’ and c [ i + 3 ] == ’ l ’ and c [ i + 4 ] == ’ e ’ and c
[
i + 5 ] == ’ t ’ and c [ i + 6 ] == ’ t ’ and c [ i + 7 ]
== ’ e ’ ) :
r [k] = 7
if ( c [ i ] == ’ g ’ and c [ i + 1 ] == ’ r ’ and c [ i + 2 ] ==
’ i ’ and c [ i + 3 ] == ’ s ’ and c [ i + 4 ] == ’ e ’ ) :
r [k] = 8
if ( c [ i ] == ’ b ’ and c [ i + 1 ] == ’ l ’ and c [ i + 2 ] ==
’ a ’ and c [ i + 3 ] == ’ n ’ and c [ i + 4 ] == ’ c ’ and c
[
i + 5 ] == ’ h ’ and c [ i + 6 ] == ’e ’) :
r [k] = 9

r = [0 , 0 , 0]

B1 = s t r ( c o u l e u r s 1 . g e t ( ) )
B2 = s t r ( c o u l e u r s 2 . g e t ( ) )
B3 = s t r ( c o u l e u r s 3 . g e t ( ) )

Determination_de_la_couleur ( B1 , 0 )
Determination_de_la_couleur ( B2 , 1 )
Determination_de_la_couleur ( B3 , 2 )

vr = ( r [ 0 ] ∗ 10 + r [ 1 ] ) ∗ ( 1 0 ∗∗ r [ 2 ] )

window2 = Tk ( )
window2 . t i t l e ( " r e s i s t a n c e s ␣ dans ␣ t o u s ␣ c e s ␣ tats " )
window2 . geometry ( " 1000 x400 " )
window2 . m i n s i z e ( 1 2 0 0 , 5 0 0 )
window2 . wm_iconbitmap ( "ohm−35900_960_720 . i c o " )
window2 . c o n f i g ( background= ’#FF5733 ’ )
f e n=Frame ( window2 , bg= ’#f f 5 7 3 3 ’ )
f e n . pack ( expand=YES)
t i 2 = La be l ( fen , t e x t=" v o t r e ␣ r s i s i t a n c e ␣ a ␣ pour ␣ v a l e u r ␣ : ␣ " ,
f o n t =( " C o u r i e r " , 2 8 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t i 2 . pack ( expand=YES)
f e 2=Frame ( fen , bg= ’#FF5733 ’ )

13
UE X22P050 2019 - 2020
Modélisation pour la physique 2

f e 2 . pack ( expand=YES)
t i 3 = La be l ( f e 2 , t e x t=vr , f o n t =( " C o u r i e r " , 2 5 ) , bg= ’ #4065A4 ’
, f g= ’ w h i t e ’ )
t i 3 . g r i d ( row=0, column =0, s t i c k y=W)
t i 4 = La be l ( f e 2 , t e x t="Ohms" , f o n t =( " C o u r i e r " , 2 5 ) , bg= ’
#4065A4 ’ , f g= ’ w h i t e ’ )
t i 4 . g r i d ( row=0, column =1, s t i c k y=W)

window2 . mainloop ( )

d e f c3 ( ) :

window3 = Tk ( )
window3 . t i t l e ( " r e s i s t a n c e s ␣ dans ␣ t o u s ␣ c e s ␣ tats " )
window3 . geometry ( " 1000 x400 " )
window3 . m i n s i z e ( 1 2 0 0 , 5 0 0 )
window3 . wm_iconbitmap ( "ohm−35900_960_720 . i c o " )
window3 . c o n f i g ( background= ’#FF5733 ’ )
f e n 1 = Frame ( window3 , bg= ’#f f 5 7 3 3 ’ )
f e n 1 . pack ( expand=YES)

def puissance ( f ) :

p = int ( f )

i f ( 1 0 <= p < 1 0 0 ) :
LP0 . append ( p )
i f ( 1 0 0 <= p < 1 0 0 0 ) :
LP1 . append ( p )
i f ( 1 0 0 0 <= p < 1 0 0 0 0 ) :
LP2 . append ( p )
i f ( 1 0 0 0 0 <= p < 1 0 0 0 0 0 ) :
LP3 . append ( p )
i f ( 1 0 0 0 0 0 <= p < 1 0 0 0 0 0 0 ) :
LP4 . append ( p )
i f ( 1 0 0 0 0 0 0 <= p < 1 0 0 0 0 0 0 0 ) :
LP5 . append ( p )
i f ( 1 0 0 0 0 0 0 0 <= p < 1 0 0 0 0 0 0 0 0 ) :
LP6 . append ( p )
i f ( 1 0 0 0 0 0 0 0 0 <= p < 1 0 0 0 0 0 0 0 0 0 ) :
LP7 . append ( p )
i f ( 1 0 0 0 0 0 0 0 0 0 <= p < 1 0 0 0 0 0 0 0 0 0 0 ) :
LP8 . append ( p )
i f ( 1 0 0 0 0 0 0 0 0 0 0 <= p ) :
LP9 . append ( p )

14
UE X22P050 2019 - 2020
Modélisation pour la physique 2

d e f r e m p l i s s a g e _ d e _ l a _ l i s t e L 1 ( contenu ) :
p = 0

f o r k i n r a n g e ( 0 , l e n ( contenu ) ) :

i f ( k == 0 ) :

i = 0
somme = " "
w h i l e ( contenu [ i ] != " \n " ) :
somme = somme + contenu [ i ]
i = i + 1

p = i
L1 . i n s e r t ( k , somme )

k = p + 1
i = k

somme = " "

i f ( k <= l e n ( contenu ) − 1 ) :
i f ( contenu [ k ] != " \n " ) :

w h i l e ( contenu [ i ] != " \n " and i <= l e n (

contenu ) ) :
somme = somme + contenu [ i ]
i = i + 1

p = i
L1 . i n s e r t ( k , somme )

d e f rangement ( l ) :
n = 1

w h i l e ( l e n ( l ) != 0 ) :

m= 1

f o r i in range (0 , len ( l ) ) :

k = 0

w h i l e ( ( k <= l e n ( l ) − 1 ) and ( i <= l e n ( l ) − 1 )

and ( l [ i ] <= l [ k ] ) and (m == 1 ) ) :

15
UE X22P050 2019 - 2020
Modélisation pour la physique 2

i f ( k == l e n ( l ) − 1 ) :
LF . i n s e r t ( l e n (LF) , l [ i ] )
l . remove ( l [ i ] )
m= 0
n = n + 1

k = k + 1

def recherche ( l , v) :
m= 1
f o r i in range (0 , len ( l ) ) :

i f ( ( 9 7 . 5 / 1 0 0 ) <= ( ( l [ i ] ) / v ) <= ( ( 1 0 2 . 5 ) / 1 0 0 )
and m == 1 ) :

t c = L ab el ( fen1 , t e x t=" La␣ r s i s t a n c e , ␣ en ␣ s t o c k ,

␣ l a ␣ p l u s ␣ p r o c h e ␣ de ␣ c e l l e ␣ d e m a n d ␣ e s t ␣ de ␣ : ␣ " ,
f o n t =( " C o u r i e r " , 1 8 ) , bg= ’#FF5733 ’ , f g= ’
white ’ )
t c . pack ( expand=YES)
f e c = Frame ( fen 1 , bg= ’#FF5733 ’ )
f e c . pack ( expand=YES)
t c 1 = La be l ( f e c , t e x t=l [ i ] , f o n t =( " C o u r i e r " , 2 5 )
, bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
t c 1 . g r i d ( row=0, column =0, s t i c k y=W)
t c 2 = La be l ( f e c , t e x t="Ohms" , f o n t =( " C o u r i e r " ,
2 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
t c 2 . g r i d ( row=0, column =1, s t i c k y=W)

m= 0

def recherche_de_deux_resistances_en_serie ( l , v ) :
m= 1
f o r i in range (0 , len ( l ) ) :

f o r k in range (0 , len ( l ) ) :

i f ( ( 9 9 . 9 9 9 / 1 0 0 ) <= ( ( l [ i ] + l [ k ] ) / v ) <=
( ( 1 0 0 . 0 0 1 ) / 1 0 0 ) and m == 1 ) :

t c 3 = La be l ( fen1 , t e x t=" La␣ r s i s t a n c e ␣

quivalente ␣ en ␣ s r i e ␣ e s t ␣ l a ␣ c o m b i n a i s o n
␣ d e s ␣ r s i s t a n c e s ␣ de ␣ : ␣ " , f o n t =( " C o u r i e r "
, 1 8 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )

16
UE X22P050 2019 - 2020
Modélisation pour la physique 2

t c 3 . pack ( expand=YES)
f e c 1 = Frame ( fen1 , bg= ’#FF5733 ’ )
f e c 1 . pack ( expand=YES)
t c 4 = La be l ( f e c 1 , t e x t=l [ i ] , f o n t =( " C o u r i e r "
, 2 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
t c 4 . g r i d ( row=0, column =0, s t i c k y=W)
t c 5 = La be l ( f e c 1 , t e x t="Ohms" , f o n t =( "
C o u r i e r " , 2 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
t c 5 . g r i d ( row=0, column =1, s t i c k y=W)
t c 8 = La be l ( f e c 1 , t e x t=" ␣ ␣ e t ␣ ␣ " , f o n t =( "
C o u r i e r " , 2 5 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t c 8 . g r i d ( row=0, column =2, s t i c k y=W)
t c 6 = La be l ( f e c 1 , t e x t=l [ k ] , f o n t =( " C o u r i e r "
, 2 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
t c 6 . g r i d ( row=0, column =3, s t i c k y=W)
t c 7 = La be l ( f e c 1 , t e x t="Ohms" , f o n t =( "
C o u r i e r " , 2 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
t c 7 . g r i d ( row=0, column =4, s t i c k y=W)

#p r i n t ( " l e s r e s i s t a n c e s quivalentes en
serie " , v , " sont , une r s i s t a n c e de " ,
l [ i ] , " ohms e t un a u t r e de " , l [ k ] , " ohms
.")
m= 0

i f (m == 1 ) :
t c 9 = La be l ( fen1 , t e x t=" l a ␣ r e s i s t a n c e ␣ que ␣ vous ␣ avez ␣
d e m a n d ␣ e s t ␣ t r o p ␣ p e t i t e ␣ou␣ t r o p ␣ grande \n␣ e t ␣ i l ␣n
’ e x i s t e ␣ pas ␣ de ␣ r e s i s t a n c e ␣ quivalente ␣ en ␣ s r i e ␣
p o s s i b l e \n␣ dans ␣ l a ␣ b a s e ␣ de ␣ d o n n e s . ␣ " , f o n t =( "
C o u r i e r " , 1 8 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t c 9 . pack ( expand=YES)
#p r i n t ( " l a r e s i s t a n c e que vous avez e s t t r o p p e t i t e
e t i l n ’ e x i s t e pas de r e s i s t a n c e quivalente en
s r i e p o s s i b l e dans l a b a s e \n de d o n n e s , ou
b i e n e l l e t r o p grande e t n ’ a pas de r s i s t a n c e
quivalente dans l a b a s e de d o n n e s " )

def recherche_de_deux_resistances_en_parallele ( l , v) :
p = 1
f o r i in range (0 , len ( l ) ) :

f o r k in range (0 , len ( l ) ) :

i f ( ( 9 9 . 9 / 1 0 0 ) <= ( ( ( l [ i ] ∗ l [ k ] ) / ( l [ i ] + l [

17
UE X22P050 2019 - 2020
Modélisation pour la physique 2

k ] ) ) / v ) <= ( ( 1 0 0 . 1 ) / 1 0 0 ) and p == 1 ) :
t c 1 0 = L ab el ( fen1 , t e x t=" La␣ r s i s t a n c e ␣
quivalente ␣ en ␣ p a r a l l l e ␣ e s t ␣ l a ␣
c o m b i n a i s o n ␣ d e s ␣ r s i s t a n c e s ␣ de ␣ : ␣ " , f o n t
=( " C o u r i e r " , 1 8 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e
’)
t c 1 0 . pack ( expand=YES)
f e c 2 = Frame ( fen1 , bg= ’#FF5733 ’ )
f e c 2 . pack ( expand=YES)
t c 1 1 = L ab el ( f e c 2 , t e x t=l [ i ] , f o n t =( " C o u r i e r
" , 2 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
t c 1 1 . g r i d ( row=0, column =0, s t i c k y=W)
t c 1 2 = L ab el ( f e c 2 , t e x t="Ohms" , f o n t =( "
C o u r i e r " , 2 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
t c 1 2 . g r i d ( row=0, column =1, s t i c k y=W)
t c 1 3 = L ab el ( f e c 2 , t e x t=" ␣ ␣ e t ␣ ␣ " , f o n t =( "
C o u r i e r " , 2 5 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t c 1 3 . g r i d ( row=0, column =2, s t i c k y=W)
t c 1 4 = L ab el ( f e c 2 , t e x t=l [ k ] , f o n t =( " C o u r i e r
" , 2 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
t c 1 4 . g r i d ( row=0, column =3, s t i c k y=W)
t c 1 5 = L ab el ( f e c 2 , t e x t="Ohms" , f o n t =( "
C o u r i e r " , 2 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
t c 1 5 . g r i d ( row=0, column =4, s t i c k y=W)
#p r i n t ( " l e s r e s i s t a n c e s quivalentes en
parall le " , v , " sont , une r s i s t a n c e
de " , l [ i ] , " ohms e t un a u t r e de " , l [ k ] ,
" ohms . " )

p = 0

i f ( p == 1 ) :
t c 1 6 = L ab el ( fen1 , t e x t=" l a ␣ r e s i s t a n c e ␣ que ␣ vous ␣ avez
␣ d e m a n d ␣ e s t ␣ t r o p ␣ p e t i t e ␣ou␣ t r o p ␣ grande \n␣ e t ␣ i l ␣
n ’ e x i s t e ␣ pas ␣ de ␣ r e s i s t a n c e ␣ quivalente ␣ en ␣
p o s s i b l e ␣ p o s s i b l e \n␣ dans ␣ l a ␣ b a s e ␣ de ␣ d o n n e s . ␣ " ,
f o n t =( " C o u r i e r " , 1 8 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t c 1 6 . pack ( expand=YES)
#p r i n t ( " l a r e s i s t a n c e que vous avez d e m a n d e s t
t r o p grande e t i l n ’ e x i s t e pas de r e s i s t a n c e
quivalente en p a r a l l l e p o s s i b l e dans l a b a s e \
n de d o n n e s , ou b i e n e l l e t r o p grande e t n ’ a
pas de r s i s t a n c e quivalente dans l a b a s e de
donn es ")

18
UE X22P050 2019 - 2020
Modélisation pour la physique 2

r e s i s t a n c e s = open ( r ’C: \ U s e r s \ f e r d i n a n d \ PycharmProjects \

f i r s t p r o j e c t \ r e s i s t a n c e s . txt ’ , " r " ) # d o s s i e r contenat
les r sistances
contenu = r e s i s t a n c e s . r e a d ( )

L1 = [ ] # l i s t e dans l a q u e l l e l e s v a l e u r s r s i s t a n c e s vont
tre plac es

LP0 = [ ] # l i s t e c o n t e n a n t l e s r e s i s t a n c e du m m e o r d r e de
grandeur
LP1 = [ ]
LP2 = [ ]
LP3 = [ ]
LP4 = [ ]
LP5 = [ ]
LP6 = [ ]
LP7 = [ ]
LP8 = [ ]
LP9 = [ ]

LF = [ ] # l i s t e d e s r e s i s t a n c e dans l ’ o r d r e c r o i s s a n t

# vr=i n t ( i n p u t ( " Q u e l l e r s i s t a n c e s o u h a i t e z −vous r e c h e r c h e r

? −−−−−−>"))

# p r i n t ( " tape 1/10")

r e m p l i s s a g e _ d e _ l a _ l i s t e L 1 ( contenu )

f o r i i n r a n g e ( 0 , l e n ( L1 ) ) :
p u i s s a n c e ( L1 [ i ] )

rangement ( LP0 )
# p r i n t ( " tape 2/10")
rangement ( LP1 )
# p r i n t ( " tape 3/10")
rangement ( LP2 )
# p r i n t ( " tape 4/10")
rangement ( LP3 )
# p r i n t ( " tape 5/10")
rangement ( LP4 )
# p r i n t ( " tape 6/10")
rangement ( LP5 )
# p r i n t ( " tape 7/10")
rangement ( LP6 )

19
UE X22P050 2019 - 2020
Modélisation pour la physique 2

# p r i n t ( " tape 8/10")

rangement ( LP7 )
# p r i n t ( " tape 9/10")
rangement ( LP8 )
# p r i n t ( " tape 10/10")
rangement ( LP9 )

r e c h e r c h e (LF , i n t ( e2 . g e t ( ) ) )

r e c h e r c h e _ d e _ d e u x _ r e s i s t a n c e s _ e n _ s e r i e (LF , i n t ( e2 . g e t ( ) ) )

r e c h e r c h e _ d e _ d e u x _ r e s i s t a n c e s _ e n _ p a r a l l e l e (LF , i n t ( e2 . g e t ( ) )
)

window3 . mainloop ( )

# c r a t i o n de l a f e n t r e

window= Tk ( )
window . t i t l e ( " r e s i s t a n c e s ␣ dans ␣ t o u s ␣ c e s ␣ tats " )
window . geometry ( " 1000 x400 " )
window . m i n s i z e ( 1 0 0 0 , 4 0 0 )
window . wm_iconbitmap ( "ohm−35900_960_720 . i c o " )
window . c o n f i g ( background= ’#FF5733 ’ )

# lment de l a f e n t r e

#c r a t i o n t i t r e
t i t r e=L ab el ( window , t e x t=" Bienvenue ␣ s u r ␣ l e ␣programme " , f o n t =( "
C o u r i e r " , 2 8 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t i t r e . pack ( )

#c r a t i o n b o i t e
f 1=Frame ( window , bg= ’#FF5733 ’ )
f 1 1=Frame ( f1 , bg= ’#FF5733 ’ )
f 2=Frame ( window , bg= ’#FF5733 ’ )
f 2 1=Frame ( f2 , bg= ’#FF5733 ’ )
f 3=Frame ( window , bg= ’#FF5733 ’ )
f 3 1=Frame ( f3 , bg= ’#FF5733 ’ )

# lment boite

# lmnt correspondant la fonction valeur r s i s t a n c e vers

couleur
t 1=Label ( f1 , t e x t="1−␣ E n t r e r ␣ l a ␣ v a l e u r ␣ de ␣ v o t r e ␣ r s i s t a n c e ␣ pour

20
UE X22P050 2019 - 2020
Modélisation pour la physique 2

␣ c o n n a t r e ␣ s e s ␣ c o u l e u r s ␣ : " , f o n t =( " C o u r i e r " , 1 5 ) , bg= ’#FF5733

’ , f g= ’ w h i t e ’ )
t 1 . pack ( )
e1=Entry ( f11 , f o n t =( " C o u r i e r " , 1 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )
e1 . g r i d ( row=0, column =0, s t i c k y=W)
b1=Button ( f11 , t e x t=" ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ok ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ " , f o n t =( "
A r i a l " , 1 0 ) , bg= ’ w h i t e ’ , f g= ’ #4065A4 ’ , command=c1 )
b1 . g r i d ( row=0, column =1, s t i c k y=W)

# lmnt correspondant la fonction couleur r s i s t a n c e

vers valeur
t 2=Label ( f2 , t e x t="2−␣ E n t r e r ␣ l e s ␣ c o u l e u r s ␣ de ␣ v o t r e ␣ r s i s t a n c e ␣
pour ␣ c o n n a t r e ␣ s a ␣ v a l e u r ␣ : " , f o n t =( " C o u r i e r " , 1 5 ) , bg= ’#
FF5733 ’ , f g= ’ w h i t e ’ )
t 2 . pack ( )
c o u l e u r s =[ ’ n o i r e ’ , ’ marron ’ , ’ r o u g e ’ , ’ o r a n g e ’ , ’ j a u n e ’ , ’ v e r t e ’
, ’ bleue ’ , ’ v i o l e t t e ’ , ’ g r i s e ’ , ’ blanche ’ ]
t 2 1=Lab el ( f21 , t e x t=" c o u l e u r ␣ 1 e r ␣ bande ␣ : ␣ ␣ ␣ ␣ ␣ " , f o n t =( " C o u r i e r "
, 1 0 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t 2 1 . g r i d ( row=0, column =0, s t i c k y=W)
t 2 2=Lab el ( f21 , t e x t=" c o u l e u r ␣ 2eme␣ bande ␣ : ␣ ␣ ␣ ␣ ␣ " , f o n t =( " C o u r i e r "
, 1 0 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t 2 2 . g r i d ( row=0, column =1, s t i c k y=W)
t 2 3=Lab el ( f21 , t e x t=" c o u l e u r ␣ 3eme␣ bande ␣ : ␣ ␣ ␣ ␣ ␣ " , f o n t =( " C o u r i e r "
, 1 0 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t 2 3 . g r i d ( row=0, column =2, s t i c k y=W)
c o u l e u r s 1= t t k . Combobox ( f21 , v a l u e s=c o u l e u r s )
c o u l e u r s 1 . g r i d ( row=1, column =0, s t i c k y=W)
c o u l e u r s 2= t t k . Combobox ( f21 , v a l u e s=c o u l e u r s )
c o u l e u r s 2 . g r i d ( row=1, column =1, s t i c k y=W)
c o u l e u r s 3= t t k . Combobox ( f21 , v a l u e s=c o u l e u r s )
c o u l e u r s 3 . g r i d ( row=1, column =2, s t i c k y=W)
tb=Label ( f21 , t e x t=" ␣ ␣ ␣ ␣ ␣ " , f o n t =( " C o u r i e r " , 1 0 ) , bg= ’#FF5733 ’ ,
f g= ’ w h i t e ’ )
tb . g r i d ( row=2, column =1, s t i c k y=W)
b2=Button ( f21 , t e x t=" ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ok ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ " , f o n t =( "
A r i a l " , 1 0 ) , bg= ’ w h i t e ’ , f g= ’ #4065A4 ’ , command=c2 )
b2 . g r i d ( row=3, column =1, s t i c k y=W)

# lmnt correspondant l a f o n c t i o n r e c h e r c h e dans f i c h i e r

texte a p p a r e n t un s t o c k
t 3=Label ( f3 , t e x t="3−␣ E n t r e r ␣ l a ␣ v a l e u r ␣ de ␣ v o t r e ␣ r s i s t a n c e ␣ pour
␣ c o n n a t r e ␣ s a ␣ d i s p o n i b i l i t ␣ en ␣ s t o c k ␣ : " , f o n t =( " C o u r i e r "
, 1 5 ) , bg= ’#FF5733 ’ , f g= ’ w h i t e ’ )
t 3 . pack ( )

21
UE X22P050 2019 - 2020
Modélisation pour la physique 2

e2=Entry ( f31 , f o n t =( " C o u r i e r " , 1 5 ) , bg= ’ #4065A4 ’ , f g= ’ w h i t e ’ )

e2 . g r i d ( row=0, column =0, s t i c k y=W)
b3=Button ( f31 , t e x t=" ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ok ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ ␣ " , f o n t =( "
A r i a l " , 1 0 ) , bg= ’ w h i t e ’ , f g= ’ #4065A4 ’ , command=c3 )
b3 . g r i d ( row=0, column =1, s t i c k y=W)

#i n s e r t i o n d e s b o i t e s dans l a f e n t r e
f 1 . pack ( expand=YES)
f 2 . pack ( expand=YES)
f 3 . pack ( expand=YES)
f 1 1 . pack ( expand=YES)
f 2 1 . pack ( expand=YES)
f 3 1 . pack ( expand=YES)

#mainloop

window . mainloop ( )

Annexe2

22
UE X22P050 2019 - 2020
Modélisation pour la physique 2

Annexe3

Annexe4

23
UE X22P050 2019 - 2020
Modélisation pour la physique 2

Annexe5

24