Inscription / Connexion Nouveau Sujet
programmation avec python
bonjour ma prof ma donné un dm que je ne comprend pas on doit faire un programme qui détermine si le quadrilaère ABCD est parallélogramme , un rectangle, un losange, ou un carré le début du programme est
xa=demande("abscisse de A")
ya=demande("ordonnée de A")
xb=demande("abscisse de B")
yb=demande("ordonnée de B")
xc=demande("abscisse de C")
yc=demande("ordonnée de C")
xd=demande("abscisse de D")
yd=demande("ordonnée de D")
if xb-xa==xc-xd and yb-ya==yc-yd:
ABCD="parallélogramme"
else:
ABCD="quelconque"
print ("ABCD est un" ABCD)
if ABCD=="parallélogramme":
et je dois faire la suite sauf que je n'y arrive absolument j'ai reussi a faie la première partie qui consistait a montrer que ABCD est un parallélogramme/ un carré grace au vecteur mais la je suis bloquer
Bonjour.
En premier lieu et avant d'écrire du code Python, vous devez définir ce qu'est un parallélogramme , un rectangle, un losange et un carré... Cela vous aidera à distinguer chaque cas et sous-cas si nécessaire.
Ne pas oublier qu'une figure n'est pas forcement qu'horizontale ou que verticale sauf contre-indication.
Bonjour,
au plus complet en lycée/collège on peut donner comme résultats possibles
quadrilatère quelconque
parallélogramme quelconque
rectangle
losange
carré
trapèze quelconque
trapèze rectangle
trapèze isocèle
voire quelques autres
mais le test de tous ces cas étant un peu " filandreux", il est tout à fait réaliste que l'énoncé se limite aux seules "variantes de parallélogrammes"
salut
un parallélogramme est un trapèze !!
la classification exacte est (en considérant des convexes) :
quadrilatère --> (trapèze / pas trapèze)
trapèze --> (parallélogramme / pas parallélogramme)
pas parallélogramme --> (rectangle / isocèle / autre)
parallélogramme --> (rectangle pas carré / losange pas carré / rectangle et losange = carré)
à noter que de moins en moins d'élèves connaissent la notion de trapèze ... et encore moins au collège
PS : dans les quadrilatères on peu aussi distinguer les "cerf-volants" : 2 * 2 côtés consécutifs de même longueur ...
les flèches indiquent "l'héritage" de l'étage du dessous
un carré est ainsi "une sorte de" rectangle (un rectangle avec un propriété supplémentaire : que deux côtés adjacents soient égaux)
mais aussi une sorte de losange (un losange avec une propriété supplémentaire : un angle droit)
etc
si on se restreint comme suggéré dans l'énoncé aux "variantes de parallélogramme"
on part donc de la "racine" :
"parallélogramme ou pas".
(PS : on peut en distinguer bien d'autres encore : inscriptibles, bicentriques etc mais c'est hors de propos ici)
bonjour il ne dit pas que je dois expliquer ce que ces et dans l'énoncé il n'y a que ce que j'ai écrit pas de trapèze ou autre en plus.
Mais ce qui me gène sais la programmation je n'y arrive pas du tout si quelqu'un pourrais m'expliquer sa serais super
Bonjour.
En premier lieu et avant d'écrire du code Python, vous devez définir ce qu'est un parallélogramme , un rectangle, un losange et un carré... Cela vous aidera à distinguer chaque cas et sous-cas si nécessaire.
Ne pas oublier qu'une figure n'est pas forcement qu'horizontale ou que verticale sauf contre-indication.
Bonsoir.
vous devez définir ce qu'est un parallélogramme , un rectangle, un losange et un carré ?
La question en plus simple est comment faites-vous la différence entre ces 4 figures ?
@ carpediem, merci.
Mais je ne pourrais faire qu'une réponse de Normand sur un topic public... ça pourrait aller mieux... ça pourrait aller plus mal voire pire.
Hospitalisé depuis vendredi, les examens se prolongent... je vais essayer de garder un œil sur le site.
Mais les médicaux ont été sympa avec moi. A mon arrivée, ils m'ont demandé si j'étais droitier ou gaucher... j'ai répondu droitier et je me suis retrouvé avec une perfusion à gauche. Heureusement que je ne suis pas ambidextre... 
être ambidextre est plutôt une chance ...
même si je suis "à majorité" gaucher la culture droitière de nos sociétés m'a appris (et parfois je me l'impose) à virer à gauche et à droite !!
en tout cas bon courage
@ carpediem, bonjour.
la culture droitière de nos sociétés m'a appris ... à virer à gauche et à droite !!
Au moins quand tu seras lassé de l'enseignement, tu pourras toujours te recycler en homme politique ( Ministère de la RSN ~ Rééducation Scolaire Nationale ?)
Bonjour,
je pense que l'énoncé est parfaitement clair
le début du programme est même fourni
if xb-xa==xc-xd and yb-ya==yc-yd:
ABCD="parallélogramme"
il calcule les coordonnées des vecteurs AB et DC et vérifie ainsi si oui ou non e
ce qui est l'un des critères possibles pour que ABCD soit un parallélogramme
sinon ce n'est même pas un parallélogramme, donpc en excluant les trapèzes et autres curiosité, ce sera un quadrilatère "quelconque"
maintenant ce qu'il faut compéter c'est le cas où c'est un parallélogramme pour savoir si en plus d'être un parallélogramme c'en est est un "spécial"
c'est à dire un rectangle, un carré ou un losange ...
(on écrasera dans ce cas la variable chaine de caractère ABCD pour y mettre autre chose que le texte "parallélogramme")
if xb-xa==xc-xd and yb-ya==yc-yd:
ABCD="parallélogramme"
if autre critère
ABCD="rectangle"
etc
else
ABCD = "quelconque
etc
si condition
var = B
sinon
var =A
est équivalent à
var = A
si condition
var = B
le début de programme fourni par l'énoncé (tel qu'il est donné ici et dit "à compléter" pas "à refaire") est la première façon de faire
avec un si / sinon (if / else)
à noter que cette première façon de faire fai(sai)t râler certains compilateurs prétendant que la variable pourrait ne pas avoir de valeur ensuite, et exigeant son initialisation en dehors de la structure si / sinon
le début de programme fourni par l'énoncé (tel qu'il est donné ici et dit "à compléter" pas "à refaire") est la première façon de faire avec un si / sinon (if / else)
quand je vois comment certains prof de math "programment" ...
d'autre part ce début de programme sans intérêt (juste une saisie des données) est-il le fait du prof ou de l'élève ...
ensuite programme ou algo ? (parce que rien que déjà les noms de variables ... suivant les langages) et enfin vu comme les élèves ne savent pas écrire (...) combien distinguent les mots "programme" et "algo"
et mon option comme tu le dis toi-même évite ce pb de variable non affectée
juste une saisie des données
non, il y a la structure de base du traitement avec "si / sinon"
mon opinion est que l'énoncé est tel qu'il est donné ici avec cette structure là telle qu'elle est. et qui est donc imposée (et correcte)
il n'y a pas de "variable non affectée"
dans un bloc si / sinon on est certain de passer soit par la branche "si" soit par la branche "sinon" il n'existe pas de cas où aucune des deux ne serait exécutée
c'est le compilo qui se mélange(ait) les pinceaux et sortait un warning (et non une erreur) car il était incapable de le comprendre .
un compilo plus intelligent ne dirait rien du tout car il verrait que quoi qu'il se passe il y a toujours une affection.
il ne râlerait que si une des deux branches n'en comportait pas.
Un programme en python
xa=input('abscisse de A ')
ya=input('ordonnee de A ')
xb=input('abscisse de B ')
yb=input('ordonnee de B ')
xc=input('abscisse de C ')
yc=input('ordonnee de C ')
xd=input('abscisse de D ')
yd=input('ordonnee de D ')
xa =float(xa)
ya =float(ya)
xb =float(xb)
yb =float(yb)
xc =float(xc)
yc =float(yc)
xd =float(xd)
yd =float(yd)
if (xb-xa)==(xc-xd) and (yb-ya)==(yc-yd):
ABCD="parallelogramme"
else:
ABCD="quelconque ou trapeze"
AB2=(xb-xa)*(xb-xa)+(yb-ya)*(yb-ya)
BC2=(xc-xb)*(xc-xb)+(yc-yb)*(yc-yb)
if "parallelogramme" and (AB2==BC2):
ABCD="losange"
if "parallelogramme" and (xb-xa)*(xc-xb)+(yb-ya)*(yc-yb)==0:
ABCD="rectangle"
if ABCD== "rectangle" and AB2==BC2:
ABCD="carre"
print(ABCD)
- if "parallelogramme" and etc ne veut rien dire du tout.
"parallelogramme" est une chaîne de caractères constamment égale au texte immuable "parallelogramme" et rien d'autre
se demander si une telle chaine immuable et constante est "vraie", d'après toi ça veut dire quoi ??
if ABCD== "rectangle" and AB2==BC2
ça je veux bien
est-ce que la variable ABCD contient la chaine de caractère "rectangle", là oui on aura une réponse vrai ou faux et le "if " va avoir un sens
- jadis on représentait les programmes sous forme d'ordinogrammes (ou d'organigramme)
de nos jours c'est complètement "déprécié" au profit de l'utilisation "textuelle" de structures "standardisées" exclusivement "if/else" (si/sinon), "for" (pour), "while" (tant que)
et de l'utilisation intensive de "modules" (ou sous programmes)
l'utilisation (raisonnée) d'ordinogrammes avait pourtant l'avantage d'offrir une vision directe de la structure du programme et de l'arbre des décisions qui lui correspond
cela est déprécié car il était trop facile d'en abuser et d'obtenir un fouillis incompréhensible
ton enchainement de "if" ainsi s'avère loufoque, même si après correction du coup de la chaine de caractère, cela devrait fonctionner.
il revient à se poser la même question à l'identique plusieurs fois
alors qu'on sait déja dans le premier if si oui ou non c'est un parallélogramme !!
comparer avec ce que j'avais proposé :
if xb-xa==xc-xd and yb-ya==yc-yd:
ABCD="parallélogramme"
// ici on va traiter toutes les sortes de parallélogrammes
if autre critère
ABCD="rectangle"
etc
else
ABCD = "quelconque
etc
en imbriquant les if/else les uns dans les autres
ce qui correspond littéralement au parcours de l'arbre de détermination d'un quadrilatère
(en le remontant de bas en haut)
Oui il y a des erreurs ; il faut plutôt lire:
if ABCD=="parallelogramme" and (AB2==BC2):
ABCD="losange"
if ABCD== "parallelogramme" and (xb-xa)*(xc-xb)+(yb-ya)*(yc-yb)==0:
ABCD="rectangle"
là, OK
même si un tel programme n'est absolument pas optimisé à cause du test répété sur une variable chaine de caractères :
tester si ABCD contient la chaine de caractères"parallelogramme" consiste à tester un par un tous les caractères de cette chaine
c'est ce que fait réellement ABCD=="parallelogramme"
Bonjour.
Une proposition à modifier à volonté...
#*******************************************************************************
# IMPORT ***********************************************************************
#*******************************************************************************
# module pour le système d'exploitation
import os
# module specifique pour le systeme
import sys
# module pour les calculs
import math
# module de tracage de courbes
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
#*******************************************************************************
# GLOBAL ***********************************************************************
#*******************************************************************************
epsilon = 1e-10
# coordonnees des sommets
Xa = 0.0
Ya = 0.0
Xb = 0.0
Yb = 0.0
Xc = 0.0
Yc = 0.0
Xd = 0.0
Yd = 0.0
# coordonnees de l'intersection des diagonales, vides par defaut
Xi = 0.0
Yi = 0.0
# vecteurs AB, BC, CD et DA (cotes), nuls par defaut
vectAB = [0.0, 0.0]
vectBC = [0.0, 0.0]
vectCD = [0.0, 0.0]
vectDA = [0.0, 0.0]
# normes des vecteurs AB, BC, CD et DA (cotes), nuls par defaut
normAB = 0.0
normBC = 0.0
normCD = 0.0
normDA = 0.0
# vecteurs AC et BD (diagonales), nuls par defaut
vectAC = [0.0, 0.0]
vectBD = [0.0, 0.0]
# normes des vecteurs AC et BD (diagonales), nulles par defaut
normAC = 0.0
normBD = 0.0
# vecteurs IA IB, IC et ID (demies diagonales), nuls par defaut
vectIA = [0.0, 0.0]
vectIB = [0.0, 0.0]
vectIC = [0.0, 0.0]
vectID = [0.0, 0.0]
# normes des vecteurs IA, IB, IC et ID, nulles par defaut
normIA = 0.0
normIB = 0.0
normIC = 0.0
normID = 0.0
# liste des polygones possibles, False par defaut
est_quadrilatere = False
est_parallelogramme = False
est_rectangle = False
est_cerfvolant = False
est_losange = False
est_carre = False
# -- afficher_vecteurs_semi_diag -----------------------------------------------
#
# Description : affichage des vecteurs relatifs aux demies diagonales
#
# Parameters :
#
# Return :
#
# Notes :
#
def afficher_vecteurs_semi_diag() :
print(" vectIA = [ %9.6f %9.6f ]" % (vectIA[0], vectIA[1]))
print(" vectIB = [ %9.6f %9.6f ]" % (vectIB[0], vectIB[1]))
print(" vectIC = [ %9.6f %9.6f ]" % (vectIC[0], vectIC[1]))
print(" vectID = [ %9.6f %9.6f ]\n" % (vectID[0], vectID[1]))
print(" normIA = %9.6f" % normIA)
print(" normIB = %9.6f" % normIB)
print(" normIC = %9.6f" % normIC)
print(" normID = %9.6f\n" % normID)
# -- initialiser_vect_semi_diag ------------------------------------------------
#
# Description : initialisation des vecteurs relatifs aux demies diagonales
#
# Parameters :
#
# Return :
#
# Notes :
#
def initialiser_vect_semi_diag() :
global normIA
global normIB
global normIC
global normID
# vecteurs IA IB, IC et ID (demies diagonales), nuls par defaut
vectIA[0] = Xa - Xi
vectIA[1] = Ya - Yi
vectIB[0] = Xb - Xi
vectIB[1] = Yb - Yi
vectIC[0] = Xc - Xi
vectIC[1] = Yc - Yi
vectID[0] = Xd - Xi
vectID[1] = Yd - Yi
# normes des vecteurs IA, IB, IC et ID (demies diagonales)
normIA = math.sqrt(vectIA[0]**2 + vectIA[1]**2)
normIB = math.sqrt(vectIB[0]**2 + vectIB[1]**2)
normIC = math.sqrt(vectIC[0]**2 + vectIC[1]**2)
normID = math.sqrt(vectID[0]**2 + vectID[1]**2)
# -- rechercher_point_I --------------------------------------------------------
#
# Description : recherche du point I, intersection des diagonales
#
# Parameters :
#
# Return :
#
# Notes : https://openclassrooms.com/forum/sujet/calcul-du-point-d-intersection-de-deux-segments-21661
#
def rechercher_point_I() :
global Xi
global Yi
alpha_ac = 0.0
beta_ac = 0.0
alpha_bd = 0.0
beta_bd = 0.0
# recherche des coefficients de l'equation de la droite passant par A et C
delta_ac = Xa - Xc
# recherche des coefficients de l'equation de la droite passant par B et D
delta_bd = Xb - Xd
if delta_ac != 0 and delta_bd != 0.0 :
alpha_ac = (Ya - Yc) / delta_ac
beta_ac = (Xa * Yc - Xc * Ya) / delta_ac
alpha_bd = (Yb - Yd) / delta_bd
beta_bd = (Xb * Yd - Xd * Yb) / delta_bd
# calcul de Xi
Xi = (beta_bd - beta_ac) / (alpha_ac - alpha_bd)
# calcul de Yi
Yi = alpha_ac * Xi + beta_ac
# segment AC vertical ?
elif delta_ac == 0 :
alpha_bd = (Yb - Yd) / delta_bd
beta_bd = (Xb * Yd - Xd * Yb) / delta_bd
# calcul de Xi
Xi = Xa
# calcul de Yi
Yi = alpha_bd * Xi + beta_bd
# segment BD vertical ?
elif delta_bd == 0 :
alpha_ac = (Ya - Yc) / delta_ac
beta_ac = (Xa * Yc - Xc * Ya) / delta_ac
# calcul de Xi
Xi = Xb
# calcul de Yi
Yi = alpha_ac * Xi + beta_ac
# -- verifier_quadrilatere -----------------------------------------------------
#
# Description : verification que le polygone est un quadrilatere
#
# Parameters :
#
# Return : - True ~ est un quadrilatere
# - False ~ n'est pas un quadrilatere
#
# Notes : - 4 points distincts et non alignes 3 par 3
#
def verifier_quadrilatere() :
# n'est pas un quadrilatere, par defaut
status = False
# 4 points distincts ?
if normAB > epsilon or normBC > epsilon or normCD > epsilon or normDA > epsilon :
# oui : 3 points alignes ?
#
# A, B et C alignes ?
# ou B, C et D alignes ?
# ou C, D et A alignes ?
# ou D, A et B alignes ?
colinABC = math.fabs(vectAB[0] * vectBC[1] - vectAB[1] * vectBC[0])
colinBCD = math.fabs(vectBC[0] * vectCD[1] - vectBC[1] * vectCD[0])
colinCDA = math.fabs(vectCD[0] * vectDA[1] - vectCD[1] * vectDA[0])
colinDAB = math.fabs(vectDA[0] * vectAB[1] - vectDA[1] * vectAB[0])
if ((colinABC > epsilon) and \
(colinBCD > epsilon) and \
(colinCDA > epsilon) and \
(colinDAB > epsilon)) :
# oui : est un quadrilatere
status = True
# donnee(s) retounee(s)
return status
# -- afficher_vecteurs_cotes ---------------------------------------------------
#
# Description : affichage des vecteurs relatifs aux cotes et aux diagonales
#
# Parameters :
#
# Return :
#
# Notes :
#
def afficher_vecteurs_cotes() :
print(" vectAB = [ %9.6f %9.6f ]" % (vectAB[0], vectAB[1]))
print(" vectBC = [ %9.6f %9.6f ]" % (vectBC[0], vectBC[1]))
print(" vectCD = [ %9.6f %9.6f ]" % (vectCD[0], vectCD[1]))
print(" vectDA = [ %9.6f %9.6f ]" % (vectDA[0], vectDA[1]))
print(" vectAC = [ %9.6f %9.6f ]" % (vectAC[0], vectAC[1]))
print(" vectBD = [ %9.6f %9.6f ]\n" % (vectBD[0], vectBD[1]))
print(" normAB = %9.6f" % normAB)
print(" normBC = %9.6f" % normBC)
print(" normCD = %9.6f" % normCD)
print(" normDA = %9.6f" % normDA)
print(" normAC = %9.6f" % normAC)
print(" normBD = %9.6f\n" % normBD)
# -- initialiser_vecteurs_cotes ------------------------------------------------
#
# Description : initialisation des vecteurs relatifs aux cotes et aux diagonales
#
# Parameters :
#
# Return :
#
# Notes :
#
def initialiser_vecteurs_cotes() :
global normAB
global normBC
global normCD
global normDA
global normAC
global normBD
# vecteurs AB, BC, CD et DA (cotes)
vectAB[0] = Xb - Xa
vectAB[1] = Yb - Ya
vectBC[0] = Xc - Xb
vectBC[1] = Yc - Yb
vectCD[0] = Xd - Xc
vectCD[1] = Yd - Yc
vectDA[0] = Xa - Xd
vectDA[1] = Ya - Yd
# normes des vecteurs AB, BC, CD et DA (cotes)
normAB = math.sqrt(vectAB[0]**2 + vectAB[1]**2)
normBC = math.sqrt(vectBC[0]**2 + vectBC[1]**2)
normCD = math.sqrt(vectCD[0]**2 + vectCD[1]**2)
normDA = math.sqrt(vectDA[0]**2 + vectDA[1]**2)
# vecteurs AC et BD (diagonales)
vectAC[0] = Xc - Xa
vectAC[1] = Yc - Ya
vectBD[0] = Xd - Xb
vectBD[1] = Yd - Yb
# normes des vecteurs AC et BD (diagonales)
normAC = math.sqrt(vectAC[0]**2 + vectAC[1]**2)
normBD = math.sqrt(vectBD[0]**2 + vectBD[1]**2)
# -- afficher_sommets ----------------------------------------------------------
#
# Description : affichage des sommets
#
# Parameters :
#
# Return :
#
# Notes :
#
def afficher_sommets() :
print(" Xa = %9.6f Ya = %9.6f" % (Xa, Ya))
print(" Xb = %9.6f Yb = %9.6f" % (Xb, Yb))
print(" Xc = %9.6f Yc = %9.6f" % (Xc, Yc))
print(" Xd = %9.6f Yd = %9.6f\n" % (Xd, Yd))
#*******************************************************************************
# MAIN *************************************************************************
#*******************************************************************************
# effacement de l'ecran (facultatif)
os.system('cls')
print(" ")
# saisie des coordonnees des 4 sommets
print(" Les couples d'angles (A,C) et (B,D) sont opposes" )
print(" Les couples de cotes (AB,CD) et (BC,DA) sont opposes" )
print(" ")
print(" B .---------. C")
print(" / / ")
print(" / / ")
print(" A .---------. D")
print(" ")
# point A
Xa = float(input(" Entrez Xa : "))
Ya = float(input(" Entrez Ya : "))
print(" ")
# point B
Xb = float(input(" Entrez Xb : "))
Yb = float(input(" Entrez Yb : "))
print(" ")
# point C
Xc = float(input(" Entrez Xc : "))
Yc = float(input(" Entrez Yc : "))
print(" ")
# point D
Xd = float(input(" Entrez Xd : "))
Yd = float(input(" Entrez Yd : "))
print(" ")
# affichage des sommets
afficher_sommets()
# initialisation des vecteurs relatifs aux cotes et aux diagonales
initialiser_vecteurs_cotes()
# affichage des vecteurs relatifs aux cotes et aux diagonales
afficher_vecteurs_cotes()
# polygone = quadrilatere ?
est_quadrilatere = verifier_quadrilatere()
if est_quadrilatere is True :
# recherche du point I, intersection des diagonales
rechercher_point_I()
print(" Xi = %9.6f Yi = %9.6f\n" % (Xi, Yi))
# initialisation des vecteurs relatifs aux demies diagonales
initialiser_vect_semi_diag()
# affichage des vecteurs relatifs aux demies diagonales
afficher_vecteurs_semi_diag()
# classification :
#
# +--> quadrilateres
# !
# +--> cerfs-volants
# ! !
# ! +--> losanges
# ! !
# ! +--> carres
# !
# +--> parallelogrammes
# ! !
# ! +--> rectangles
# !
# +--> trapezes (non traites)
#
# diagonales perpendiculaires ?
if math.fabs(vectAC[0] * vectBD[0] + vectAC[1] * vectBD[1]) < epsilon :
# oui : branche des quadrilateres, des cerfs-volants, losanges, carres
# polygone = cerf-volant par defaut
est_cerfvolant = True
# polygone = losange ?
if ((math.fabs(normIA - normIC) < epsilon and math.fabs(normIB - normID) < epsilon)) and \
math.fabs(normIA - normIB) > epsilon :
# si IA = IC, si IB = ID et si IA <> IB
est_losange = True
# polygone = carre ?
elif ((math.fabs(normIA - normIC) < epsilon and math.fabs(normIB - normID) < epsilon)) and \
math.fabs(normIA - normIB) < epsilon :
# si IA = IC, si IB = ID et si IA = IB
est_carre = True
else :
# non : branche des quadrilateres, des trapezes, parallelogrammes, rectangles
# polygone = parallelogramme (IA = IC et IB = ID) ?
if (math.fabs(normIA - normIC) < epsilon) and (math.fabs(normIB - normID) < epsilon) :
# IA = IC et IB = ID
est_parallelogramme = True
# polygone = rectangle (IA = IB) ?
if math.fabs(normIA - normIB) < epsilon :
# IA = IB = IC = ID
est_rectangle = True
# affichage du résultat --------------------------------------------------------
if est_carre is True :
print (" Le polygone ABCD = carre\n")
elif est_losange is True :
print (" Le polygone ABCD = losange\n")
elif est_cerfvolant is True :
print (" Le polygone ABCD = cerf-volant\n")
elif est_rectangle is True :
print (" Le polygone ABCD = rectangle\n")
elif est_parallelogramme is True :
print (" Le polygone ABCD = parallelogramme\n")
elif est_quadrilatere is True :
print (" Le polygone ABCD = quadrilatere\n")
else :
print (" Le polygone ABCD = inconnu ou non traite\n")
# liste des coordonnees ds points
if est_quadrilatere is True :
l_x = [Xa, Xb, Xc, Xd, Xi]
l_y = [Ya, Yb, Yc, Yd, Yi]
else :
l_x = [Xa, Xb, Xc, Xd]
l_y = [Ya, Yb, Yc, Yd]
# titre du graphique
if est_carre is True :
plt.title(r"$Polygone\ ABCD\ =\ carr\acute{e}$")
elif est_losange is True :
plt.title(r"$Polygone\ ABCD\ =\ losange$")
elif est_cerfvolant is True :
plt.title(r"$Polygone\ ABCD\ =\ cerf-volant$")
elif est_rectangle is True :
plt.title(r"$Polygone\ ABCD\ =\ rectangle$")
elif est_rectangle is False and est_parallelogramme is True :
plt.title(r"$Polygone\ ABCD\ =\ parall\acute{e}logramme$")
elif est_quadrilatere is True :
plt.title(r"$Polygone\ ABCD\ =\ quadrilat\`ere$")
else :
plt.title(r"$Polygone\ ABCD\ =\ inconnu\ ou\ non\ trait\acute{e}$")
# legende de l'axe x
plt.xlabel(r"$x$")
# legende de l'axe y
plt.ylabel(r"$y$")
# affichage en nuage de points
plt.scatter(l_x, l_y)
# affichage du segment AB
plt.plot([Xa, Xb], [Ya, Yb], color = "b")
# affichage du segment BC
plt.plot([Xb, Xc], [Yb, Yc], color = "b")
# affichage du segment CD
plt.plot([Xc, Xd], [Yc, Yd], color = "b")
# affichage du segment DA
plt.plot([Xd, Xa], [Yd, Ya], color = "b")
# annotation des sommets
plt.text(Xa - 0.25, Ya, "A", color = "b")
plt.text(Xb - 0.25, Yb, "B", color = "b")
plt.text(Xc - 0.25, Yc, "C", color = "b")
plt.text(Xd - 0.25, Yd, "D", color = "b")
if est_quadrilatere is True :
plt.text(Xi - 0.25, Yi, "I", color = "r")
# affichage du segment IA
plt.plot([Xi, Xa], [Yi, Ya], color = "r")
# affichage du segment IB
plt.plot([Xi, Xb], [Yi, Yb], color = "r")
# affichage du segment IC
plt.plot([Xi, Xc], [Yi, Yc], color = "r")
# affichage du segment ID
plt.plot([Xi, Xd], [Yi, Yd], color = "r")
plt.xlim(0.0, 10.0)
plt.ylim(0.0, 10.0)
ax = plt.axes()
ax.xaxis.set_major_locator(ticker.MultipleLocator(1.0))
ax.xaxis.set_minor_locator(ticker.MultipleLocator(0.1))
ax.yaxis.set_major_locator(ticker.MultipleLocator(1.0))
ax.yaxis.set_minor_locator(ticker.MultipleLocator(0.1))
# validation de la grille
plt.grid(True)
# affichage
plt.show()
Une exécution :
Les couples d'angles (A,C) et (B,D) sont opposes
Les couples de cotes (AB,CD) et (BC,DA) sont opposes
B .---------. C
/ /
/ /
A .---------. D
Entrez Xa : 4
Entrez Ya : 1
Entrez Xb : 1
Entrez Yb : 4
Entrez Xc : 6
Entrez Yc : 9
Entrez Xd : 9
Entrez Yd : 6
Xa = 4.000000 Ya = 1.000000
Xb = 1.000000 Yb = 4.000000
Xc = 6.000000 Yc = 9.000000
Xd = 9.000000 Yd = 6.000000
vectAB = [ -3.000000 3.000000 ]
vectBC = [ 5.000000 5.000000 ]
vectCD = [ 3.000000 -3.000000 ]
vectDA = [ -5.000000 -5.000000 ]
vectAC = [ 2.000000 8.000000 ]
vectBD = [ 8.000000 2.000000 ]
normAB = 4.242641
normBC = 7.071068
normCD = 4.242641
normDA = 7.071068
normAC = 8.246211
normBD = 8.246211
Xi = 5.000000 Yi = 5.000000
vectIA = [ -1.000000 -4.000000 ]
vectIB = [ -4.000000 -1.000000 ]
vectIC = [ 1.000000 4.000000 ]
vectID = [ 4.000000 1.000000 ]
normIA = 4.123106
normIB = 4.123106
normIC = 4.123106
normID = 4.123106
Le polygone ABCD = rectangle
Une figure :
inutilement compliqué pour un newbie en programmation Python (le demandeur) qui aura vraiment énormément de mal à s'y retrouver dans un tel roman fleuve !!
il ne s'agit pas ici d'exhiber son "habileté" à la programmation mais juste d'aider un demandeur à faire un programme sain et qui fonctionne
ce n'est certes pas le cas de ce que tu proposes (sain ? j'en doute vu que c'est illisible. ce n'est pas en rajoutant une pléthore d'éléments qu'on le rend plus lisible)
Bonjour.
à faire un programme sain et qui fonctionne
ce n'est certes pas le cas de ce que tu proposes (sain ? j'en doute vu que c'est illisible...)
C'est quoi un programme sain pour vous ?
C'est quoi un programme illisible pour vous ?
Avez-vous testé ma proposition de programme avant de juger de son fonctionnement ?
@ alb12, bonjour.
Angelove a decroche, on la comprend
Effectivement, son dernier message date du 06-03-18 à 17:59... soit un silence depuis une semaine.
Mes deux seules interventions durant cette période ont été de lui demander comment distinguer des quadrilatères entre eux et nous passer un énoncé complet...
Avez-vous testé ma proposition de programme avant de juger de son fonctionnement ?
aucun intérêt
je ne doute absolument pas de son fonctionnement ni de ta capacité à programmer !!
je doute que ce soit adapté à la demande
(niveau licence peut être mais certainement pas niveau seconde !!!
en seconde on ne demande certainement pas de faire des main et des tas de modules partout.
ni d'ailleurs des trucs pas demandés dans l'énoncé comme dessiner le quadrilatère etc
c'est tout ça qui rend ton programme illisible par rapport à la demande
Annuler
connectez vous