>>>
point
=
(1,
2)CPGE OUJDA Sup
Tuples
En Python, un tuple est une séquence de valeurs formée en séparant ces valeurs par des virgules. L’usage des parenthèses est recommandé.
>>>
point
=
(1,
2)
>>> print(point) (1, 2)
>>>
course
=
('INFO',
'H',
100)
>>> print(course) ('INFO', 'H', 100)
On peut assigner les valeurs d’un tuple dans un autre possédant le même nombre de valeurs.
>>>
(x,
y)
=
point
#extraction
>>> print(x)
1
>>> print(y)
2
Une fonction peut prendre un tuple en paramètre.
>>>
def
origin_distance(point):
(x,
y)
=
point
return math.sqrt(x ** 2 + y ** 2)
>>> origin_distance((0, 1))
1.0
Une fonction peut aussi renvoyer un tuple, ce qui lui permet par exemple de renvoyer plusieurs valeurs.
>>>
def
divide_modulo(a,
b):
return (a // b, a % b)
>>> (quotient, remainder) = divide_modulo(5, 2)
>>> print(quotient, remainder)
2 1
Exercices
Ex. 1. Écrire une fonction qui vérifie qu’un point est dans un rectangle horizontal. Un point est repré- senté par un tuple (x,y) et un rectangle est représenté par deux points : le coin supérieur gauche et
le coin inférieur droit. Nous supposons que les x croissent vers la droite et que les y croissent vers le haut.
Ex. 2. Écrire une fonction qui reçoit 4 points et qui vérifie si ces 4 points forment un carré horizontal. Ces 4 points étant respectivement le coin supérieur gauche, le point supérieur droit, le coin inférieur gauche et le coin inférieur droit.
Ex. 3. Écrire une fonction qui reçoit les valeurs de trois dés à six façes et qui vérifie que ces dés forment un 421.
Ex. 4. Écrire une fonction qui reçoit trois nombres et qui renvoie un tuple composé de ces trois nombres dans l’ordre croissant.
Ex. 5. Écrire une fonction qui reçoit trois nombres et qui renvoie les deux plus grands.
Solutions
Ex. 1.
def
is_in_rectangle(point,
upper_left,
lower_right):
""" vérifie si le point (tuple (x, y)) est dans le rectangle défini par ses coins supérieur gauche et inférieur droit"""
(x, y) = point
(x_1, y_1) = upper_left
(x_2, y_2) = lower_right
return (x >= x_1 and x <= x_2 and y >= y_2 and y <= y_1)
print(is_in_rectangle((1, 1), (0, 2), (3, 0))) #prints True print(is_in_rectangle((0, 0), (0, 2), (3, 0))) #prints True print(is_in_rectangle((-1, 0), (0, 2), (3, 0))) #prints False
Solution de l’exercice 2:
def
is_square(upper_l,
upper_r,
lower_l,
lower_r):
"""vérifie que le quadrilatere dont les 4 sommets sont upper_l, upper_r,
lower_l et lower_r, respectivement les coins supérieur gauche, supérieur droit, inférieur gauche et inférieur droit, forme un carré horizontal"""
(x_1, y_1) = upper_l (x_2, y_2) = upper_r (x_3, y_3) = lower_l (x_4, y_4) = lower_r
return (x_1 == x_3 and y_1 == y_2 and x_2 == x_4 and y_3 == y_4 and (x_2 - x_1) == (y_1 - y_3))
print(is_square((0, 1), (1, 1), (0, 0), (1, 0))) #prints True print(is_square((0, 1), (2, 1), (0, 0), (2, 0))) #prints False print(is_square((0, 1), (1, 1), (0, 0), (2, 0))) #prints False
Solution de l’exercice 3:
def
is_421(x,
y,
z):
"""vérifie que les trois entiers x,y et z forment un 421"""
return ((x == 4 or y == 4 or z == 4) and (x == 2 or y == 2 or z == 2) and (x == 1 or y == 1 or z == 1))
Solution naïve :
def
is_421(x,
y,
z):
"""vérifie que les trois entiers x,y et z forment un 421"""
flag = False
if x == 4 and y == 2 and z == 1:
flag = True
elif x == 4 and y == 1 and z == 2:
flag = True
elif x == 2 and y == 4 and z == 1:
flag = True
elif x == 2 and y == 1 and z == 4:
flag = True
elif x == 1 and y == 4 and z == 2:
flag = True
elif x == 1 and y == 2 and z == 4:
flag = True return flag
print(is_421(4,
2,
1))
#prints
True
print(is_421(4,
1,
2))
#prints
True
print(is_421(2,
4,
1))
#prints
True
print(is_421(2,
1,
4))
#prints
True
print(is_421(1,
4,
2))
#prints
True 
print(is_421(4,
2,
2))
#prints
False
print(is_421(-1, 2.0, 4)) #prints False
Autre solution identique au niveau du flot d’exécution :
def
is_421(x,
y,
z):
"""vérifie que les trois entiers x,y et z forment un 421"""
return (x == 4 and y == 2 and z == 1 or x == 4 and y == 1 and z == 2 or x == 2 and y == 4 and z == 1 or x == 2 and y == 1 and z == 4 or x == 1 and y == 4 and z == 2 or x == 1 and y == 2 and z == 4)
Une autre solution plus rapide (analysez le flot d’éxécution) :
def
is_421(x,
y,
z):
"""vérifie que les trois entiers x,y et z forment un 421"""
flag = False if x == 4:
if y == 2:
if z == 1:
flag = True #ordre 4 2 1
elif y == 1:
if z == 2:
flag = True #ordre 4 1 2
elif x == 2:
if y == 4:
if z == 1:
flag = True #ordre 2 4 1
elif y == 1:
if z == 4:
flag = True #ordre 2 1 4
elif x == 1:
if y == 4:
if z == 2:
flag = True #ordre 1 4 2
elif y == 2:
if z == 4:
flag = True #ordre 1 2 4
return flag
Une solution plus élégante est de trier ces trois nombres avant de tester leurs valeurs comme fait dans l’exercice 4 : .
def
is_421(x,
y,
z):
"""vérifie que les trois entiers x,y et z forment un 421""" (x, y, z) = sort_3_items(x, y, z)
return x == 1 and y == 2 and z == 4
Solution basée sur le fait que les dés ont 6 faces de 1 à 6 :
def
is_421(x,
y,
z):
"""vérifie que les trois entiers x,y et z forment un 421"""
return (x + y + z == 7) and (x == 4 or y == 4 or z == 4)
Solution de l’exercice 4:
def
sort_3_items(x,
y,
z):
if x < y:
if y < z:
res = (x, y, z)
elif x < z:
res = (x, z, y)
else:
res = (z, x, y)
else:
if x < z:
res = (y, x, z)
elif y < z:
res = (y, z, x)
else:
res = (z, y, x)
return res
print(sort_3_items(1, 2, 3)) #prints (1, 2, 3) print(sort_3_items(1, 1, 1)) #prints (1, 1, 1) print(sort_3_items(3, 2, 1)) #prints (1, 2, 3) print(sort_3_items(1, 3, 2)) #prints (1, 2, 3) print(sort_3_items(3, 1, 1)) #prints (1, 1, 3)
Solution de l’exercice 5:
def
two_max(a,
b,
c):
if a < b and a < c: #a est le minimum
maximum = (b,c)
elif b < c: #b est le minimum
maximum = (a,c)
else: #c est le minimum
maximum = (a,b)
return maximum
print(two_max(1, 2, 3)) #prints (2, 3) print(two_max(2, 2, 3)) #prints (2, 3) print(two_max(1, 2, 2)) #prints (2, 2) print(two_max(3, 2, 1)) #prints (3, 2) print(two_max(1, 3, 2)) #prints (3, 2)