Feuille exos 1

L2 Informatique - 2016–2017
——
Algorithmes et Programmation 2
——
TD : Modules
——
Exercice 1 Le module complex1
Dans les sessions des premières questions de cet exercice, on suppose que le module complex1 (vu en cours) a
été importé avec la commande import complex1 as cplx.
Voici la documentation de ce module qui permet de travailler avec des nombres complexes :
>>> help(cplx)
Help on module Complex.src.complex1 in Complex.src:
NAME
Complex.src.complex1 - :mod:`complex1` module : version 1 of a (simple) module for compl
DESCRIPTION
:author: `FIL - IEEA - Univ. Lille1.fr <http://portail.fil.univ-lille1.fr>`_
:date: 2015, september. Last revised : 2016, september
Complex numbers are represented with dictionaries
.. seealso::
:mod:`complex2`
FUNCTIONS
add(z1, z2)
return the sum of the two complex numbers z1 and z2
:param z1: a complex number
:type z1: complex
:param z2: a complex number
:type z2: complex
:return: z1 + z2
:rtype: complex
:UC: none
:Example:
>>> z = add(create(1, 2), create(3, 4))
>>> get_real_part (z)
4
>>> get_imag_part (z)
6
are_equals(z1, z2)
return True if complex numbers z1 and z2 are equals
False otherwise
:param z1: a complex number
:type z1: complex
:param z2: a complex number
:type z2: complex
:return: True if z1 = z2, False otherwise
:rtype: bool
1
:UC: none
:Example:
>>> z1 = create(1,
>>> z2 = create(1,
>>> z3 = create(1,
>>> are_equals(z1,
True
>>> are_equals(z1,
False
2)
2)
-1)
z2)
z3)
create(x, y)
create a complex number with real part x and imaginary part y
:param x: the real part of the complex number to create
:type x: int or float
:param y: the imaginary part of the complex number to create
:type y: int or float
:return: the complex number x + iy
:rtype: complex
:UC: none
:Example:
>>> z = create(1, 2)
>>> get_real_part(z)
1
>>> get_imag_part(z)
2
from_real_number(x)
create the complex number x + i0 from real number x
:param x: a real number
:type x: int or float
:return: the complex number x + 0i
:rtype: complex
:UC: none
:Example:
>>> z = from_real_number (1)
>>> get_real_part(z)
1
>>> get_imag_part(z)
0
get_imag_part(z)
return the imaginary part of complex number z
:param z: a complex number
:type z: complex
:return: the imaginary part of z
:rtype: int or float
:UC: none
:Example:
>>> z = create(1, 2)
>>> get_imag_part(z)
2
get_real_part(z)
return the real part of complex number z
2
:param z: a complex number
:type z: complex
:return: the real part of z
:rtype: int or float
:UC: none
:Example:
>>> z = create(1, 2)
>>> get_real_part(z)
1
modulus(z)
return the modulus of complex number z, ie :math:`\sqrt{x^2 + y^2}`
if $z=x+yi$
:param z: a complex number
:type z: complex
:return: his modulus
:rtype: float
:UC: none
:Example:
>>> modulus(create(0, 0))
0.0
>>> modulus(create(3, 4))
5.0
mult(z1, z2)
return the product of the two complex numbers z1 and z2
:param z1: a complex number
:type z1: complex
:param z2: a complex number
:type z2: complex
:return: z1 * z2
:rtype: complex
:UC: none
:Example:
>>> z = mult(create(1, 2), create(3, 4))
>>> get_real_part(z)
-5
>>> get_imag_part(z)
10
print(z, end=’\n’)
print the complex number z with algebraic form `x + yi`
where x = real part of z and y = imaginary part
:param z: complex number to print
:type z: complex
:param end: [optional] separator (default is ’\\n’)
:type end: string
:return: None
:UC: none
FILE
/home/eric/Enseignement/Licence/AP2/Modules/Complex/src/complex1.py
Question 1 Quels sont les constructeurs et sélecteurs définis dans ce module ?
3
Question 2 La lecture de cette documentation laisse-t-elle entrevoir de quelle façon les nombres complexes sont implantés ?
Du point de vue de l’utilisateur du module, cette connaissance est-elle importante ?
Question 3 Indiquez comment créer les trois nombres complexes z1 = 1 + 2i et z2 = 3 + 4i et z3 = z1 + z2, puis imprimer
le nombre z3 .
Question 4 Comment imprimer le nombre z3 sous la forme z3 = ... + ... i ?
Dans les sessions des questions qui suivent, le module complex1 a été importé avec la commande
from complex1 import *
Question 5 Réécrivez les instructions des questions 3 et 4 dans ce contexte.
Exercice 2 Les cartes
Dans cet exercice on souhaite réaliser un module pour représenter les cartes à jouer du jeu de bataille. Ce module
sera nommé card.
Un jeu de bataille est constitué de 32 cartes, chacune d’elles étant caractérisée par
— une valeur qui est un élément de l’ensemble {7, 8, 9, 10, J, Q, K, A} (J pour jack, Q pour queen, K pour king
et A pour ace) ; vous pourrez supposer que cet ensemble de valeurs est défini par la constante
VALUES = ["7", "8", "9", "10", "Jack", "Queen", "King", "Ace"] ;
— une couleur qui est un élément de l’ensemble {♣, ♦, ♥, ♠, } ; vous pourrez supposer que cet ensemble de
couleurs est défini dans le module par la constante
COLORS = ["club", "diamond", "heart", "spade"].
Question 1 En supposant déjà réalisés dans ce module
— le constructeur create qui à partir d’une valeur et d’une couleur valides renvoie une carte de cette valeur et de cette
couleur ;
— et les sélecteurs get_color et get_value renvoyant respectivement la couleur et la valeur d’une carte, couleur et
valeur étant l’une des chaînes de caractères des constantes COLORS et VALUES
>>> c = card.create(’Ace’, ’heart’)
>>> card.get_color(c)
’heart’
>>> card.get_value(c)
’Ace’
réalisez dans ce module les fonctions suivantes :
— une fonction random_card (sans paramètre) de création aléatoire d’une carte ;
— un prédicat are_equals qui renvoie True si les deux cartes passées en paramètres sont égales (même couleur et
même valeur) et False sinon ;
— une fonction to_string de conversion d’une carte en une représentation sous forme de chaîne de caractères.
>>> card.to_string(c)
’Ace of heart’
Question 2 En utilisant le module card, réalisez une fonction deck sans paramètre qui renvoie un jeu complet des 32
cartes.
Question 3 Proposez des réalisations du constructeur create et des sélecteurs get_color et get_value.
4