Rayon polaire.
On appelle rayon polaire d'un point M (relativement à un repère orhtonormé donné), la distance OM (où O est le point origine du repère).
Remarque : si z est le nombre complexe associé à M, le rayon polaire de M est aussi ce que l'on nomme module de z.
Ajoutez aux objets Point (classe définie dans la page de cours) un attribut rayon_polaire.
Une méthode devra être ajoutée aux autres méthodes, cette méthode permettra d'initialiser le rayon polaire du point à l'aide des attributs abscisse et ordonnée.
Vous penserez à modifier la méthode d'affichage afin que le rayon polaire d'un point s'affiche également.
Dans la solution proposée ci-dessous, vous constaterez que l'on fait appel à la méthode rayon() également dans les méthodes translate et déplace : ces méthodes ayant un effet sur l'abscisse et l'ordonnée, il est en effet impératif de mettre également à jour le rayon polaire.
import math
class Point:
""" Représente un point du plan. Chaque point a un nom (qui sera défini par une chaîne de caractères),
une abscisse et une ordonnée (qui seront définis par des nombres).
Chaque point a également un attribut rayon polaire (distance du point à l'origine).
"""
def __init__(self, nom_du_point , x=0, y=0):
""" initialise l'objet point avec une abscisse
et une ordonnée, par défaut toutes deux à 0. """
self.nom = nom_du_point
self.abscisse = x
self.ordonnee = y
# appel de la méthode rayon définie plus loin dans la classe
# permet d'initialiser le rayon polaire du point :
self.rayon_polaire = self.rayon()
def deplace(self, x, y):
""" modifie l'emplacement du point en lui donnant une nouvelle abscisse
et une nouvelle ordonnée."""
self.abscisse = x
self.ordonnee = y
# mise à jour du rayon polaire :
self.rayon_polaire = self.rayon()
def translate(self, dx, dy):
""" translate le point par le vecteur de coordonnées (dx, dy)."""
self.abscisse += dx
self.ordonnee += dy
# mise à jour du rayon polaire :
self.rayon_polaire = self.rayon()
def rayon(self) :
""" méthode retournant le rayon polaire du point à partir des
attributs abscisse et ordonnée. """
return math.sqrt(self.abscisse**2 + self.ordonnee**2)
def __str__(self) :
""" méthode appelée lorsqu'on demandera un print de l'objet."""
chaine1 = "Attributs du point {} :\n".format(self.nom)
chaine2 = "abscisse = {}, ordonnée = {}.\n"\
.format(self.abscisse,self.ordonnee)
chaine3 = "Rayon polaire du point : {}\n".format(self.rayon_polaire)
return chaine1+chaine2+chaine3
if __name__ == '__main__' :
# création de deux objets de type Point :
a = Point('A')
b = Point('B',3, 5)
print(a)
print(b)
# création d'un autre objet de type Point :
c = Point('C', 2,2)
print("Le point C avant translation : ")
print(c)
# translation du point c :
c.translate(3,7)
print("Le point C après translation : ")
print(c)
Attributs du point A :
abscisse = 0, ordonnée = 0.
Rayon polaire du point : 0.0
Attributs du point B :
abscisse = 3, ordonnée = 5.
Rayon polaire du point : 5.830951894845301
Le point C avant translation :
Attributs du point C :
abscisse = 2, ordonnée = 2.
Rayon polaire du point : 2.8284271247461903
Le point C après translation :
Attributs du point C :
abscisse = 5, ordonnée = 9.
Rayon polaire du point : 10.295630140987
Distance entre deux points.
Ajoutez à la classe Point une méthode permettant de déterminer la distance du point défini à un autre point.
Pour déterminer une valeur approximative de la distance entre les points A et B (représentés par les variables a et b), on fera appel à a.distance(b) (ou encore, vu la symétrie de la notion, à b.distance(a) ).
import math
class Point:
""" Représente un point du plan. Chaque point a un nom (qui sera défini par une chaîne de caractères),
une abscisse et une ordonnée (qui seront définis par des nombres).
Chaque point a également un attribut rayon polaire (distance du point à l'origine).
"""
def __init__(self, nom_du_point , x=0, y=0):
""" initialise l'objet point avec une abscisse
et une ordonnée, par défaut toutes deux à 0. """
self.nom = nom_du_point
self.abscisse = x
self.ordonnee = y
# appel de la méthode rayon définie plus loin dans la classe
# permet d'initialiser le rayon polaire du point :
self.rayon_polaire = self.rayon()
def deplace(self, x, y):
""" modifie l'emplacement du point en lui donnant une nouvelle abscisse
et une nouvelle ordonnée."""
self.abscisse = x
self.ordonnee = y
# mise à jour du rayon polaire :
self.rayon_polaire = self.rayon()
def translate(self, dx, dy):
""" translate le point par le vecteur de coordonnées (dx, dy)."""
self.abscisse += dx
self.ordonnee += dy
# mise à jour du rayon polaire :
self.rayon_polaire = self.rayon()
def rayon(self) :
""" méthode retournant le rayon polaire du point à partir des
attributs abscisse et ordonnée. """
return math.sqrt(self.abscisse**2 + self.ordonnee**2)
def distance(self, autre_point) :
""" retourne la distance du point à un autre point."""
d2 = (self.abscisse - autre_point.abscisse)**2
d2 += (self.ordonnee - autre_point.ordonnee)**2
return math.sqrt(d2)
def __str__(self) :
""" méthode appelée lorsqu'on demandera un print de l'objet."""
chaine1 = "Attributs du point {} :\n".format(self.nom)
chaine2 = "abscisse = {}, ordonnée = {}.\n"\
.format(self.abscisse,self.ordonnee)
chaine3 = "Rayon polaire du point : {}\n".format(self.rayon_polaire)
return chaine1+chaine2+chaine3
if __name__ == '__main__' :
# création de deux objets de type Point :
a = Point('A')
b = Point('B',3, 5)
# création d'un autre objet de type Point :
c = Point('C', 2,2)
# translation du point c :
c.translate(3,7)
print( "Distance de A à B : {}. ".format(a.distance(b)) )
print( "Distance de B à C : {}. ".format(b.distance(c)) )
Distance de A à B : 5.830951894845301.
Distance de B à C : 4.47213595499958.
Docstring.
On rappelle ici qu'une bonne pratique est de documenter systématiquement son code. En particulier : les fonctions, les classes...
Reprenez le code du corrigé de l'exercice précédent. Et demandez l'affichage de help(Point).
import math
class Point:
""" Représente un point du plan. Chaque point a un nom (qui sera défini par une chaîne de caractères),
une abscisse et une ordonnée (qui seront définis par des nombres).
Chaque point a également un attribut rayon polaire (distance du point à l'origine).
"""
def __init__(self, nom_du_point , x=0, y=0):
""" initialise l'objet point avec une abscisse
et une ordonnée, par défaut toutes deux à 0. """
self.nom = nom_du_point
self.abscisse = x
self.ordonnee = y
# appel de la méthode rayon définie plus loin dans la classe
# permet d'initialiser le rayon polaire du point :
self.rayon_polaire = self.rayon()
def deplace(self, x, y):
""" modifie l'emplacement du point en lui donnant une nouvelle abscisse
et une nouvelle ordonnée."""
self.abscisse = x
self.ordonnee = y
# mise à jour du rayon polaire :
self.rayon_polaire = self.rayon()
def translate(self, dx, dy):
""" translate le point par le vecteur de coordonnées (dx, dy)."""
self.abscisse += dx
self.ordonnee += dy
# mise à jour du rayon polaire :
self.rayon_polaire = self.rayon()
def rayon(self) :
""" méthode retournant le rayon polaire du point à partir des
attributs abscisse et ordonnée. """
return math.sqrt(self.abscisse**2 + self.ordonnee**2)
def distance(self, autre_point) :
""" retourne la distance du point à un autre point."""
d2 = (self.abscisse - autre_point.abscisse)**2
d2 += (self.ordonnee - autre_point.ordonnee)**2
return math.sqrt(d2)
def __str__(self) :
""" méthode appelée lorsqu'on demandera un print de l'objet."""
chaine1 = "Attributs du point {} :\n".format(self.nom)
chaine2 = "abscisse = {}, ordonnée = {}.\n"\
.format(self.abscisse,self.ordonnee)
chaine3 = "Rayon polaire du point : {}\n".format(self.rayon_polaire)
return chaine1+chaine2+chaine3
if __name__ == '__main__' :
print(help(Point))
Help on class Point in module __main__:
class Point(builtins.object)
| Représente un point du plan.
| Chaque point a un nom (qui sera défini par une chaîne de caractères),
| une abscisse et une ordonnée (qui seront définis par des nombres).
| Chaque point a également un attribut rayon polaire
| (distance du point à l'origine).
|
| Methods defined here:
|
| __init__(self, nom_du_point, x=0, y=0)
| initialise l'objet point avec une abscisse
| et une ordonnée, par défaut toutes deux à 0.
|
| __str__(self)
| méthode appelée lorsqu'on demandera un print de l'objet.
|
| deplace(self, x, y)
| modifie l'emplacement du point en lui donnant une nouvelle abscisse
| et une nouvelle ordonnée.
|
| distance(self, autre_point)
| retourne la distance du point à un autre point.
|
| rayon(self)
| méthode retournant le rayon polaire du point à partir des
| attributs abscisse et ordonnée.
|
| translate(self, dx, dy)
| translate le point par le vecteur de coordonnées (dx, dy).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
(END)
L'objectif est qu'un utilisateur de la classe n'ait pas besoin de lire le code : la lecture du help devrait suffire. Pensez toujours à documenter vos fonctions et classes en pensant à un utilisateur qui ne consulterait que cet affichage du help().
Dans cet objectif, l'exemple ci-dessus n'est pas très bon : l'utilisateur ne sait pas comment s'appelle les attributs par exemple. Mais les commentaires ont été créés ici pour vous aider à comprendre les notions, ce qui ne sera pas l'objectif dans vos projets : l'objectif de vos commentaires devra être de clarifier le rôle de chaque fonction, de chaque classe, de chaque variable, c'est à dire de rendre parfaitement limpide l'utilisation de votre programme.
Remarquons qu'ici il s'agit de l'utilisation par un autre programmeur : il doit pouvoir ajouter des fonctionnalités à votre programme sans avoir à lire votre code.
L'utilisation par exécution doit, quant à elle, être parfaitement clarifiée au niveau de l'interface : tout le nécessaire à une bonne utilisation du programme (au sens de l'exécution, sans ajouter quoique ce soit au code) doit s'afficher à l'exécution (sous forme de messages, sous forme d'un fichier d'aide...).
L'examinateur de votre projet devra pouvoir comprendre la structure de votre programme en ne lisant que le résultat de help() et comprendre votre programme en ne lisant que vos commentaires dans le code. Et il doit pouvoir l'exécuter et l'utiliser sans rentrer dans le code.
Classe Rectangle.
Définir une classe Rectangle.
Cette classe rectangle définira des rectangles de côtés parallèles aux bords de l'écran.
On définira une variable rectangle par a = Rectangle( coin, largeur, hauteur) où coin le sommet supérieur gauche (de type Point, classe utilisée dans le cours et les exercices précédents), largeur est la longueur du côté horizontal et hauteur est la longueur du côté vertical.
Les autres coins seront des attributs du rectangle définis à partir des trois attributs de définition.
Une méthode donnant le périmètre et une méthode donnant l'aire seront également définies.
Une méthode d'affichage affichera tous les attributs ainsi que l'aire et le périmètre.
Un code possible ci-dessous.
On a légèrement redéfini la classe Point afin que l'attribut nom du point devienne facultatif.
Vous remarquerez comment l'appel du constructeur point est effectuée dans ce cas.
import math
class Point:
""" Représente un point du plan.
Chaque point a un nom (qui sera défini par une chaîne de caractères),
une abscisse et une ordonnée (qui seront définis par des nombres).
Chaque point a également un attribut rayon polaire
(distance du point à l'origine).
"""
def __init__(self, nom_du_point=None , x=0, y=0):
""" initialise l'objet point avec une abscisse
et une ordonnée, par défaut toutes deux à 0. """
self.nom = nom_du_point
self.abscisse = x
self.ordonnee = y
# appel de la méthode rayon définie plus loin dans la classe
# permet d'initialiser le rayon polaire du point :
self.rayon_polaire = self.rayon()
def deplace(self, x, y):
""" modifie l'emplacement du point en lui donnant une nouvelle abscisse
et une nouvelle ordonnée."""
self.abscisse = x
self.ordonnee = y
# mise à jour du rayon polaire :
self.rayon_polaire = self.rayon()
def translate(self, dx, dy):
""" translate le point par le vecteur de coordonnées (dx, dy)."""
self.abscisse += dx
self.ordonnee += dy
# mise à jour du rayon polaire :
self.rayon_polaire = self.rayon()
def rayon(self) :
""" méthode retournant le rayon polaire du point à partir des
attributs abscisse et ordonnée. """
return math.sqrt(self.abscisse**2 + self.ordonnee**2)
def distance(self, autre_point) :
""" retourne la distance du point à un autre point."""
d2 = (self.abscisse - autre_point.abscisse)**2
d2 += (self.ordonnee - autre_point.ordonnee)**2
return math.sqrt(d2)
def __str__(self) :
""" méthode appelée lorsqu'on demandera un print de l'objet."""
if self.nom :
chaine1 = "Attributs du point {} :\n".format(self.nom)
else :
chaine1 = "Attributs du point : "
chaine2 = "abscisse = {}, ordonnée = {}.\n"\
.format(self.abscisse,self.ordonnee)
chaine3 = "Rayon polaire du point : {}\n".format(self.rayon_polaire)
return chaine1+chaine2+chaine3
class Rectangle :
""" Définit un rectangle de côtés parallèles aux bords de l'écran.
Un rectangle est défini par trois attributs :
le coin supérieur gauche csg de type Point,
sa largeur largeur de type nombre, sa hauteur hauteur de type nombre.
Les autres coins csd, cig, cid
(coin supérieur droit, inférieur gauche inférieur droit)
tous de type Point
sont des attributs qui s'en déduisent.
On rappelle, pour la bonne compréhension des opérations faites,
que l'axe des ordonnées est orienté vers le bas.
"""
def __init__(self, coin, largeur, hauteur) :
""" Définit le rectangle par sommet supérieur gauche, largeur et hauteur.
En déduit les coordonnées des autres coins par appel de méthodes
définies plus loin."""
self.csg = coin
self.largeur = largeur
self.hauteur = hauteur
self.coinsuperieurdroit()
self.coininferieurgauche()
self.coininferieurdroit()
def coinsuperieurdroit(self) :
""" Calcule les coordonnées du sommet supérieur droit
à l'aide des trois attributs de définition."""
abscisse = self.csg.abscisse + self.largeur
ordonnee = self.csg.ordonnee
self.csd = Point( x=abscisse, y=ordonnee)
def coininferieurgauche(self) :
""" Calcule les coordonnées du sommet inférieur gauche
à l'aide des trois attributs de définition."""
abscisse = self.csg.abscisse
ordonnee = self.csg.ordonnee + self.hauteur
self.cig = Point( x=abscisse, y=ordonnee)
def coininferieurdroit(self) :
""" Calcule les coordonnées du sommet inférieur droit
à l'aide des trois attributs de définition."""
abscisse = self.csg.abscisse + self.largeur
ordonnee = self.csg.ordonnee + self.hauteur
self.cid = Point( x=abscisse, y=ordonnee)
def perimetre(self) :
return 2*(self.largeur + self.hauteur)
def aire(self) :
return self.largeur * self.hauteur
def __str__(self) :
ch = 'Coordonnées du sommet supérieur gauche : ({}, {})\n'\
.format(self.csg.abscisse,self.csg.ordonnee)
ch += 'Largeur du rectangle : {}\n'.format(self.largeur)
ch += 'Hauteur du rectangle : {}\n'.format(self.hauteur)
ch += 'Coordonnées du sommet supérieur droit : ({}, {})\n'\
.format(self.csd.abscisse, self.csd.ordonnee)
ch += 'Coordonnées du sommet inférieur droit : ({}, {})\n'\
.format(self.cid.abscisse, self.cid.ordonnee)
ch += 'Coordonnées du sommet inférieur gauche : ({}, {})\n'\
.format(self.cig.abscisse, self.cig.ordonnee)
ch += 'Périmètre du rectangle : {}\n'.format(self.perimetre())
ch += 'Aire du rectangle : {}\n'.format(self.aire())
return ch
if __name__ == '__main__' :
a=Point(x=10, y=40)
r = Rectangle(a, 10, 20)
print(r)
Coordonnées du sommet supérieur gauche : (10, 40)
Largeur du rectangle : 10
Hauteur du rectangle : 20
Coordonnées du sommet supérieur droit : (20, 40)
Coordonnées du sommet inférieur droit : (20, 60)
Coordonnées du sommet inférieur gauche : (10, 60)
Périmètre du rectangle : 60
Aire du rectangle : 200
Translation d'un rectangle.
Reprenez le code du corrigé de l'exercice précédent. Ajoutez une méthode de translation du rectangle : pour translater le rectangle par la translation de vecteur \( \overrightarrow{u}\left( a, b\right) \), il faut évidemment translater chacun des sommets.
Une solution possible ci-dessous.
On a choisi de translater le coin supérieur gauche par la méthode de translation de la classe Point. Puis on a redéfini les autres sommets à l'aide des méthodes internes à la classe Rectangle.
import math
class Point:
""" Représente un point du plan. Chaque point a un nom (qui sera défini par une chaîne de caractères),
une abscisse et une ordonnée (qui seront définis par des nombres).
Chaque point a également un attribut rayon polaire (distance du point à l'origine).
"""
def __init__(self, nom_du_point=None , x=0, y=0):
""" initialise l'objet point avec une abscisse
et une ordonnée, par défaut toutes deux à 0. """
self.nom = nom_du_point
self.abscisse = x
self.ordonnee = y
# appel de la méthode rayon définie plus loin dans la classe
# permet d'initialiser le rayon polaire du point :
self.rayon_polaire = self.rayon()
def deplace(self, x, y):
""" modifie l'emplacement du point en lui donnant une nouvelle abscisse
et une nouvelle ordonnée."""
self.abscisse = x
self.ordonnee = y
# mise à jour du rayon polaire :
self.rayon_polaire = self.rayon()
def translate(self, dx, dy):
""" translate le point par le vecteur de coordonnées (dx, dy)."""
self.abscisse += dx
self.ordonnee += dy
# mise à jour du rayon polaire :
self.rayon_polaire = self.rayon()
def rayon(self) :
""" méthode retournant le rayon polaire du point à partir des
attributs abscisse et ordonnée. """
return math.sqrt(self.abscisse**2 + self.ordonnee**2)
def distance(self, autre_point) :
""" retourne la distance du point à un autre point."""
d2 = (self.abscisse - autre_point.abscisse)**2
d2 += (self.ordonnee - autre_point.ordonnee)**2
return math.sqrt(d2)
def __str__(self) :
""" méthode appelée lorsqu'on demandera un print de l'objet."""
if self.nom :
chaine1 = "Attributs du point {} :\n".format(self.nom)
else :
chaine1 = "Attributs du point : "
chaine2 = "abscisse = {}, ordonnée = {}.\n"\
.format(self.abscisse,self.ordonnee)
chaine3 = "Rayon polaire du point : {}\n".format(self.rayon_polaire)
return chaine1+chaine2+chaine3
class Rectangle :
""" Définit un rectangle de côtés parallèles aux bords de l'écran.
Un rectangle est défini par trois attributs :
le coin supérieur gauche csg de type Point,
sa largeur largeur de type nombre, sa hauteur hauteur de type nombre.
Les autres coins csd, cig, cid
(coin supérieur droit, inférieur gauche inférieur droit)
tous de type Point
sont des attributs qui s'en déduisent.
On rappelle, pour la bonne compréhension des opérations faites,
que l'axe des ordonnées est orienté vers le bas.
"""
def __init__(self, coin, largeur, hauteur) :
""" Définit le rectangle par sommet supérieur gauche, largeur et hauteur.
En déduit les coordonnées des autres coins par appel de méthodes
définies plus loin."""
self.csg = coin
self.largeur = largeur
self.hauteur = hauteur
self.coinsuperieurdroit()
self.coininferieurgauche()
self.coininferieurdroit()
def coinsuperieurdroit(self) :
""" Calcule les coordonnées du sommet supérieur droit
à l'aide des trois attributs de définition."""
abscisse = self.csg.abscisse + self.largeur
ordonnee = self.csg.ordonnee
self.csd = Point( x=abscisse, y=ordonnee)
def coininferieurgauche(self) :
""" Calcule les coordonnées du sommet inférieur gauche
à l'aide des trois attributs de définition."""
abscisse = self.csg.abscisse
ordonnee = self.csg.ordonnee + self.hauteur
self.cig = Point( x=abscisse, y=ordonnee)
def coininferieurdroit(self) :
""" Calcule les coordonnées du sommet inférieur droit
à l'aide des trois attributs de définition."""
abscisse = self.csg.abscisse + self.largeur
ordonnee = self.csg.ordonnee + self.hauteur
self.cid = Point( x=abscisse, y=ordonnee)
def perimetre(self) :
return 2*(self.largeur + self.hauteur)
def aire(self) :
return self.largeur * self.hauteur
def translate(self, dx, dy) :
self.csg.translate(dx,dy)
self.coinsuperieurdroit()
self.coininferieurgauche()
self.coininferieurdroit()
def __str__(self) :
ch = 'Coordonnées du sommet supérieur gauche : ({}, {})\n'\
.format(self.csg.abscisse,self.csg.ordonnee)
ch += 'Largeur du rectangle : {}\n'.format(self.largeur)
ch += 'Hauteur du rectangle : {}\n'.format(self.hauteur)
ch += 'Coordonnées du sommet supérieur droit : ({}, {})\n'\
.format(self.csd.abscisse, self.csd.ordonnee)
ch += 'Coordonnées du sommet inférieur droit : ({}, {})\n'\
.format(self.cid.abscisse, self.cid.ordonnee)
ch += 'Coordonnées du sommet inférieur gauche : ({}, {})\n'\
.format(self.cig.abscisse, self.cig.ordonnee)
ch += 'Périmètre du rectangle : {}\n'.format(self.perimetre())
ch += 'Aire du rectangle : {}\n'.format(self.aire())
return ch
if __name__ == '__main__' :
a=Point()
r = Rectangle(a, 10, 20)
print('Le rectangle avant translation :\n')
print(r)
r.translate(100, 100)
print('Le rectangle après translation :\n')
print(r)
Le rectangle avant translation :
Coordonnées du sommet supérieur gauche : (0, 0)
Largeur du rectangle : 10
Hauteur du rectangle : 20
Coordonnées du sommet supérieur droit : (10, 0)
Coordonnées du sommet inférieur droit : (10, 20)
Coordonnées du sommet inférieur gauche : (0, 20)
Périmètre du rectangle : 60
Aire du rectangle : 200
Le rectangle après translation :
Coordonnées du sommet supérieur gauche : (100, 100)
Largeur du rectangle : 10
Hauteur du rectangle : 20
Coordonnées du sommet supérieur droit : (110, 100)
Coordonnées du sommet inférieur droit : (110, 120)
Coordonnées du sommet inférieur gauche : (100, 120)
Périmètre du rectangle : 60
Aire du rectangle : 200