Comment modifier le programme pour qu'il demande à l'utilisateur d'entrer deux entiers n et  p differents de 0 et qu'en sortie le programme python affiche la fraction irréductible.
Entrer n
Entrer p
Return (n/a) /(p/a)
Mais je ne sais pas trop programmer en python
Vous pouvez m'aider ?

Comment modifier le programme pour qu'il demande à l'utilisateur d'entrer deux entiers n et  p differents de 0 et qu'en sortie le programme python affiche la fraction irréductible.
Entrer n
Entrer p
Return (n/a) /(p/a)
Mais je ne sais pas trop programmer en python
Vous pouvez m'aider ?

Je propose pour demander à l'utilisateur d'entrer 2 nombres entiers différents de 0:
n=int(input("valeur de n ?")
p=int(input("valeur de p ?")
Juste ?

Bonjour,
Le d=1 de la deuxième ligne est une initialisation de d à n'importe quoi de différent de 0 pour pouvoir entrer dans la boucle while

sinon (sans cette ligne) soit il y aurait une erreur "d inconnu" au moment d'exécuter l'instruction while,
soit si d était initialisé par défaut (à 0) on n'exécuterait aucune boucle vu que d serait déja à 0

pour calculer la fraction irréductible égale à n/p il faut calculer le pgcd a
(donc appeler la fonction a=pg_div(n, p))
puis calculer (séparément) n/a et p/a
(Python ou pas)

pour écrire cette fraction (en texte), cette écriture se compose de trois parties distinctes

la valeur du numérateur (le résultat du calcul de n/a)
le TEXTE "/"
la valeur du dénominateur (le résultat du calcul de p/a)

ce que tu as écrit (n/a) / (p/a) va calculer la valeur (décimale) de la fraction !

bonsoir

Je ne comprends pas ce que signifie le d=1 de la 2ème ligne.
ce programme permet la recherche de PGCD par l'algorithme des soustractions successives.
on réitère tant que l'on ne trouve pas une différence = 0

c'est pour cela que l'on initialise d à 1 (une valeur non nulle), afin de pouvoir rentrer dans la boucle.

fraction irréductible :
d'accord pour tes saisies de n et p.
que vas-tu faire ensuite ?

bonsoir mathafou, désolée, j'ai oublié de rafraichir la page. :/
je vous laisse poursuivre tranquillement.

Donc
n=int(input("valeur de n ?"))
p=int(input("valeur de p ?"))
Lignes 1a 9 de l'algorithme de départ
Return n/a"/"p/a

Mieux ?

Bonjour carita
Pas de problème ... (et si je quitte, ne te prive pas d'intervenir au besoin sans attendre trop longtemps que je revienne)

l'algorithme de départ est une fonction
on ne la recopie pas là où on en a besoin mais on l'appelle.

Return n'est pas destiné à afficher un résultat mais à quitter la fonction, (retourner au programme appelant) en lui renvoyant une valeur

ici au plus propre tu auras deux fonctions

la fonction d'origine pg_div() telle quelle, inchangée

et une autre fonction à créer

def reduire(n,p) :
    ...
    # dans laquelle on appelle, invoque pg_div pour calculer le pgcd
    a=pg_div(n,p)
    ...
    return les deux valeurs réduites
    # ou un texte contenant ces deux valeurs séparées par le "/"

def pg_div(a,b):
    # telle quelle
    ...
    return a

# et le programme (programme principal)
n=int(input("valeur de n ?"))
p=int(input("valeur de p ?"))
a = pg_div(n,p)
..
print(.., "/", ...) # et non pas return qui n'a aucun sens ici

au passage le programme d'origine ne marche pas

exemple d'exécution pas à pas :
>>> pg_div(4,6)
d = 1 != 0
d = a - b = 4 -( 6 ) = -2
d < b ? -2 < 6
a = b = 6
b = d = -2
d = -2 != 0
d = a - b = 6 -( -2 ) = 8
d < b ? 8 > -2
a = d = 8 b reste = -2
d = 8 != 0
d = a - b = 8 -( -2 ) = 10
d < b ? 10 > -2
a = d = 10 b reste = -2
d = 10 != 0
d = a - b = 10 -( -2 ) = 12
d < b ? 12 > -2
a = d = 12 b reste = -2
d = 12 != 0
d = a - b = 12 -( -2 ) = 14
d < b ? 14 > -2
a = d = 14 b reste = -2

etc
donc ça boucle sans fin !

il faut déja corriger le programme d'origine pour qu'il fonctionne quels que soient a et b entiers
que a soit < b ou a > b

une fois corrigé on doit avoir :
>>> pg_div(4,6)
d = 1 != 0
d = |a - b| = |4 - 6| = 2
d < b ? 2 < 6
a = b = 6
b = d = 2
d = 2 != 0
d = |a - b| = |6 - 2| = 4
d < b ? 4 > 2
a = d = 4 b reste = 2
d = 4 != 0
d = |a - b| = |4 - 2| = 2
d < b ? 2 > 2
a = d = 2 b reste = 2
d = 2 != 0
d = |a - b| = |2 - 2| = 0
d < b ? 0 < 2
a = b = 2
b = d = 0
d = 0, fini
2

A la suite du programme def pg_div (a,b)
def reduire (n,p)
n=int(input("valeur de n ?"))
p=int(input("valeur de p ?"))
a = pg_div(n,p)
n/a"/"p/a

je n'ai pas mélangé les variables?
a est le pgcd alors que dans la première fonction c'est un entier

chaque variable est ici "locale" à la fonction qui la définit et l'utilise.

dans la fonction reduire(n, p)
les valeurs de paramètres d'appel n et p sont définis lors de l'appel (de l'utilisation) de la fonction

les demander ensuite par input n'a aucun sens

tu ne sembles pas avoir vraiment compris ce qu'est une fonction
la différence entre la définir (def) et l'utiliser avec des valeurs
(cf un autre exo, c'est pareil)

revenons à la première fonction
quand j'écris dans un module Python (un ensemble de définitions de fonctions et d'autres instructions à exécuter, que l'on peut sauvegarder dans un fichier)

def pg_div(a,b) :    # (les ":" obligatoires, syntaxe)
    d = 1             # (indentation !!! syntaxe)
    ...
    ...
    return # quelque chose
# ici ce n'est plus la fonction (indentation nulle)

def pg_div(a,b) :
    d = 1 
    ...
    ...
    return #quelque chose
#ici ce n'est plus la fonction (indentation nulle)

a =  pg_div(342,pg_div(436,364)) # appel(s) de la fonction

    ..
    return n/a, p/a

    ..
    print (n/a, "/", p/a)

    ..
    print (int(n/a), "/", int(p/a))