Inscription / Connexion Nouveau Sujet
Niveau seconde
Partager :

programmation avec python

Posté par
Angelove
04-03-18 à 18:33

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

Posté par
bbomaths
re : programmation avec python 06-03-18 à 10:57

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.

Posté par
vham
re : programmation avec python 06-03-18 à 11:06

Bonjour,

Sans peut-être oublier les trapèzes avant de classifier en "quadrilatère quelconque"

Posté par
bbomaths
re : programmation avec python 06-03-18 à 12:03

@ vham, bonjour.

Bien vu... peut-être est-ce un cas oublié dans la recopie de l'énoncé ?

Posté par
mathafou Moderateur
re : programmation avec python 06-03-18 à 13:07

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"

Posté par
carpediem
re : programmation avec python 06-03-18 à 13:38

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 ...

Posté par
mathafou Moderateur
re : programmation avec python 06-03-18 à 13:58

programmation avec python

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)

Posté par
Angelove
re : programmation avec python 06-03-18 à 17:59

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

Posté par
carpediem
re : programmation avec python 06-03-18 à 18:05

bbomaths @ 06-03-2018 à 10:57

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.

Posté par
bbomaths
re : programmation avec python 06-03-18 à 18:07

Bonsoir.

Citation :
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 ?

Posté par
carpediem
re : programmation avec python 06-03-18 à 18:10

bbomaths : j'espère que tu vas mieux !!

Posté par
bbomaths
re : programmation avec python 06-03-18 à 20:54

@ 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...

Posté par
carpediem
re : programmation avec python 06-03-18 à 21:20

ê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

Posté par
bbomaths
re : programmation avec python 07-03-18 à 09:10

@ carpediem, bonjour.

Citation :
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 ?)

Posté par
carpediem
re : programmation avec python 07-03-18 à 13:47

Posté par
bbomaths
re : programmation avec python 10-03-18 à 09:36

@ Angelove, bonjour.

Pourriez-vous nous donner l'énoncé complet?

Posté par
mathafou Moderateur
re : programmation avec python 10-03-18 à 12:29

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 \vec{AB} = \vec{DC}
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

Posté par
carpediem
re : programmation avec python 10-03-18 à 13:38

moi je commencerai par

ABCD = quelconque

si ...

pour "descendre" vers les cas particuliers

Posté par
mathafou Moderateur
re : programmation avec python 10-03-18 à 13:59

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

Posté par
carpediem
re : programmation avec python 10-03-18 à 15:43

Citation :
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)
et alors ?

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

Posté par
mathafou Moderateur
re : programmation avec python 10-03-18 à 16:02

Citation :
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.

Posté par
pseudodk
re : programmation avec python 11-03-18 à 18:34

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)
    

Posté par
mathafou Moderateur
re : programmation avec python 11-03-18 à 19:08


- 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)

programmation avec python

Posté par
pseudodk
re : programmation avec python 12-03-18 à 00:47

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"

Posté par
mathafou Moderateur
re : programmation avec python 12-03-18 à 10:42

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"

Posté par
bbomaths
re : programmation avec python 13-03-18 à 10:32

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 :

programmation avec python

Posté par
mathafou Moderateur
re : programmation avec python 13-03-18 à 10:56

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)

Posté par
alb12
re : programmation avec python 13-03-18 à 11:03

salut,
Angelove a decroche, on la comprend

Posté par
bbomaths
re : programmation avec python 13-03-18 à 11:08

Bonjour.

Citation :
à 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 ?

Posté par
alb12
re : programmation avec python 13-03-18 à 11:12

encore un fil qui rate sa cible ... dommage.

Posté par
bbomaths
re : programmation avec python 13-03-18 à 11:20

@ alb12, bonjour.

Citation :
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...

Posté par
mathafou Moderateur
re : programmation avec python 13-03-18 à 11:37

Citation :
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

Posté par
alb12
re : programmation avec python 13-03-18 à 12:25

au bac les algos n'excedent pas une dizaine de lignes
en general dans un programme les fonctions ne depassent guere 50 lignes.



Vous devez être membre accéder à ce service...

Pas encore inscrit ?

1 compte par personne, multi-compte interdit !

Ou identifiez-vous :


Rester sur la page

Inscription gratuite

Fiches en rapport

parmi 1501 fiches de maths

Désolé, votre version d'Internet Explorer est plus que périmée ! Merci de le mettre à jour ou de télécharger Firefox ou Google Chrome pour utiliser le site. Votre ordinateur vous remerciera !