Python en Mathématiques - Niveau 2

Des objets mathématiques avec deux champs

Plus tard ! Les exercices de cette page peuvent (doivent) être réservés à une seconde lecture.

colinéarité avec plusieurs structures.

Écrire une fonction Python nommée colineaire() qui renvoie True ou False suivant que les deux vecteurs donnés en entrée sont colinéaires ou non.
Écrire une version en reprenant chacun des choix faits dans les exercices et exemples de la page sur la distance entre deux points.

  • Quatre nombres
  • Deux tuples
  • Deux listes
  • Deux dictionnaires
  • namedtuple
  • class

On représente ici un vecteur par deux nombres ("indépendants") représentant son abscisse et son ordonnée dans un repère fixé.


##----- Définition des fonctions -----##
def colineaire(ux, uy, vx, vy) :
	return ux * vy - uy * vx == 0
	
	
##----- Tests et interaction -----##
ux, uy = 2, 3
vx, vy = 6, 9	
print("Les vecteurs u({}, {}) et v({}, {}) sont-ils colinéaires ?".format(ux, uy, vx, vy))
print(colineaire(ux, uy, vx, vy))


ux, uy = 2, 3
vx, vy = 6, 10	
print("Les vecteurs u({}, {}) et v({}, {}) sont-ils colinéaires ?".format(ux, uy, vx, vy))
print(colineaire(ux, uy, vx, vy))

Rappelons en passant qu'il est prudent de se limiter à des coordonnées de type int pour avoir une garantie sur le test d'égalité.


##----- Définition des fonctions -----##
def colineaire(u, v) :
	return u[0] * v[1] - u[1] * v[0] == 0
	
	
##----- Tests et interaction -----##
U = (2, 3)
V = (6, 9)	
print("Les vecteurs u({}, {}) et v({}, {}) sont-ils colinéaires ?".format(U[0], U[1], V[0],  V[1]))
print(colineaire(U,V))


U = (2, 3)
V = (6, 10)	
print("Les vecteurs u({}, {}) et v({}, {}) sont-ils colinéaires ?".format(U[0], U[1], V[0],  V[1]))
print(colineaire(U, V))

##----- Définition des fonctions -----##
def colineaire(u, v) :
	return u[0] * v[1] - u[1] * v[0] == 0
	

##----- Tests et interaction -----##
U = [2, 3]
V = [6, 9]	
print("Les vecteurs u({}, {}) et v({}, {}) sont-ils colinéaires ?".format(U[0], U[1], V[0],  V[1]))
print(colineaire(U, V))


U = [2, 3]
V = [6, 10]
print("Les vecteurs u({}, {}) et v({}, {}) sont-ils colinéaires ?".format(U[0], U[1], V[0],  V[1]))
print(colineaire(U, V))

##----- Définition des fonctions -----##
def colineaire(u, v) :
	return u['abs'] * v['ord'] - u['ord'] * v['abs'] == 0
	

##----- Tests et interaction -----##
U = {'abs' : 2, 'ord' : 3}
V = {'abs' : 6, 'ord' : 9}
print("Les vecteurs u({}, {}) et v({}, {}) sont-ils colinéaires ?".format(U['abs'], U['ord'], V['abs'],  V['ord']))
print(colineaire(U, V))


U = {'abs' : 2, 'ord' : 3}
V = {'abs' : 6, 'ord' : 10}
print("Les vecteurs u({}, {}) et v({}, {}) sont-ils colinéaires ?".format(U['abs'], U['ord'], V['abs'],  V['ord']))
print(colineaire(U, V))

from collections import namedtuple

##----- Définition de la nouvelle structure -----##
Vecteur = namedtuple('Vecteur', ['x', 'y'])
 

##----- Définition des fonctions -----##
def colineaire(u, v) :
	return u.x * v.y - u.y * v.x == 0
	

##----- Tests et interaction -----##
U = Vecteur(2, 3)
V = Vecteur(6, 9)
print("{} et {} sont-ils colinéaires ?".format(U, V))
print(colineaire(U, V))


U = Vecteur(2, 3)
V = Vecteur(6, 10)
print("{} et {} sont-ils colinéaires ?".format(U, V))
print(colineaire(U, V))


##----- Définition de la classe -----##
class Vecteur :
	def __init__(self, abscisse = 0, ordonnee = 0) :
		self.x = abscisse
		self.y = ordonnee
		
	def __str__(self) :
		return "({}, {})".format(self.x, self.y)

 
##----- Définition des fonctions -----##
def colineaire(u, v) :
	return u.x * v.y - u.y * v.x == 0
	

##----- Tests et interaction -----##
U = Vecteur(2, 3)
V = Vecteur(6, 9)
print("Les vecteurs de coordonnées  {} et {} sont-ils colinéaires ?".format(U, V))
print(colineaire(U, V))


U = Vecteur(2, 3)
V = Vecteur(6, 10)
print("Les vecteurs de coordonnées  {} et {} sont-ils colinéaires ?".format(U, V))
print(colineaire(U, V))

Somme de fractions.

Écrire une fonction Python nommée somme() qui renvoie la somme de deux rationnels
Écrire une version en reprenant chacun des choix faits dans les exercices et exemples de la page sur la distance entre deux points.

  • Quatre nombres
  • Deux tuples
  • Deux listes
  • Deux dictionnaires
  • namedtuple
  • class

On représente ici une fraction par deux nombres (« indépendants ») représentant son numérateur et son dénominateur.


##----- Définition des fonctions -----##
def somme(f1num, f1den, f2num, f2den) :
	num = f1num * f2den + f2num * f1den
	den = f1den * f2den
	return  num, den


##----- Tests et interaction -----##
a, b = 2, 3
c, d = 3, 4

s = somme(a, b, c, d)
print("La somme de {}/{} et de {}/{} est égale à {}/{}.".format(a, b, c, d, s[0], s[1]))

##----- Définition des fonctions -----##
def somme(f1, f2) :
	num = f1[0] * f2[1] + f2[0] * f1[1]
	den = f1[1] * f2[1]
	return  (num, den)


##----- Tests et interaction -----##
q1 = (2, 3)
q2 = (3, 4)

s = somme(q1, q2)
print("La somme de {}/{} et de {}/{} est égale à {}/{}.".format(q1[0], q1[1], q2[0], q2[1], s[0], s[1]))

##----- Définition des fonctions -----##
def somme(f1, f2) :
	num = f1[0] * f2[1] + f2[0] * f1[1]
	den = f1[1] * f2[1]
	return  [num, den]


##----- Tests et interaction -----##
q1 = [2, 3]
q2 = [3, 4]

s = somme(q1, q2)
print("La somme de {}/{} et de {}/{} est égale à {}/{}.".format(q1[0], q1[1], q2[0], q2[1], s[0], s[1]))

##----- Définition des fonctions -----##
def somme(f1, f2) :
	num = f1['num'] * f2['den'] + f2['num'] * f1['den']
	den = f1['den'] * f2['den']
	return  {'num': num, 'den': den}


##----- Tests et interaction -----##
q1 = {'num': 2, 'den': 3}
q2 = {'num': 3, 'den': 4}

s = somme(q1, q2)
print("La somme de {}/{} et de {}/{} est égale à {}/{}.".format(q1['num'], q1['den'], q2['num'], q2['den'], s['num'], s['den']))


from collections import namedtuple

##----- Définition de la nouvelle structure -----##
Rationnel = namedtuple('fraction', ['numerateur', 'denominateur'])


##----- Définition des fonctions -----##
def somme(f1, f2) :
	num = f1.numerateur * f2.denominateur + f2.numerateur * f1.denominateur
	den = f1.denominateur * f2.denominateur
	return  Rationnel(num, den)


##----- Tests et interaction -----##
q1 = Rationnel(2, 3)
q2 = Rationnel(3, 4)
s = somme(q1, q2)

print("La somme de {}/{} et de {}/{} ".format(q1.numerateur, q1.denominateur, q2.numerateur, q2.denominateur), end= " est égale à ")
print("{}/{}.".format(s.numerateur, s.denominateur))

##----- Définition de la classe -----##
class Rationnel :
	def __init__(self, num = 0, den = 1) :
		self.numerateur = num
		self.denominateur = den
		
	def __str__(self) :
		return "{}/{}".format(self.numerateur, self.denominateur)
		
		
##----- Définition des fonctions -----##
def somme(f1, f2) :
	num = f1.numerateur * f2.denominateur + f2.numerateur * f1.denominateur
	den = f1.denominateur * f2.denominateur
	return  Rationnel(num, den)


##----- Tests et interaction -----##
q1 = Rationnel(2, 3)
q2 = Rationnel(3, 4)
s = somme(q1, q2)

print("La somme de {} et {}".format(q1, q2), end= " est égale à ")
print("{}.".format(s))

L'utilisation des class permet d'aller plus loin. On peut par exemple définir l'addition avec le symbole + :


##----- Définition de la classe -----##
class Rationnel :
	def __init__(self, num = 0, den = 1) :
		self.numerateur = num
		self.denominateur = den
		
	def __str__(self) :
		return "{}/{}".format(self.numerateur, self.denominateur)
		
	def __add__(self, rationnel) :
		num = self.numerateur * rationnel.denominateur + rationnel.numerateur * self.denominateur
		den = self.denominateur * rationnel.denominateur
		return  Rationnel(num, den)


##----- Tests et interaction -----##
q1 = Rationnel(2, 3)
q2 = Rationnel(3, 4)
s = q1 + q2
print("La somme de {} et {}".format(q1, q2), end= " est égale à ")
print(s, end = ".")

On obtient :

 
La somme de 2/3 et 3/4 est égale à 17/12.