Fonctions

Symétrie Centrale

Ecrire une fonction en Python de paramètres les coordonnées de deux points A et I qui renvoie les coordonnées d'un point B symétrique de A par rapport à I

Une solution de l'exercice "Symétrie centrale".

def f(x,a) :
	return 2x - a
def symetrique(xA,yA,xI,yI)
		return f(xI,xA),f(yI,yA)

Translation de vecteur $\overrightarrow{AB}$

Ecrire une fonction en Python de paramètres les coordonnées de trois points A, B et C qui renvoie les coordonnées d'un point D image de C par la translation de vecteur $\overrightarrow{AB}$

Une solution de l'exercice "translation".

def vecteur(xA,yA,xB,yB) :
	return (xB-xA,yB-yA)
def translation(xA,yA,xB,yB,xC,yC) :
	xAB,yAB=vecteur(xA,yA,xB,yB)
	return xAB+xC,yAB+yC

Parallélogramme (Académie de Lyon)

  • Ecrire une fonction en Python de paramètres les coordonnées de quatre points A, B, C et D qui renvoie True si ABCD est un parallélogramme et False sinon
  • Ecrire une fonction en Python de paramètres les coordonnées de quatre points A, B, C et D qui renvoie True si ABCD est un parallélogramme non applati et False sinon
  • Remarque

    Pour éviter les problèmes de représentation des nombres machines on donne aux sommets des coordonnées entières.

    Parallélogramme : question 1

    def parallelogramme(xA,yA,xB,yB,xC,yC,xD,yD) :
    	if (xB-xA == xC-xD and yB-yA == yC-yD) : return True
    	else : return False

    Parallélogramme : question 2

    def vecteursEgaux(xA,yA,xB,yB,xD,yD,xC,yC) :
    	if (xB-xA == xC-xD and yB-yA == yC-yD) : return True
    	else : return False
    def alignement(xA,yA,xB,yB,xC,yC) :
    	if ((xB-xA)*(yC-YA) == (xC-xA)*(yB-YA)) : return True
    	else : return False
    
    def parallelogrammeNonAplati(xA,yA,xB,yB,xC,yC,xD,yD) :
    	VE = vecteursEgaux(xA,yA,xB,yB,xD,yD,xC,yC) 
    	Al = alignement(xA,yA,xB,yB,xC,yC)
    	return VE and not Al

    Carré (Académie de Lyon)

  • Ecrire une fonction en Python de paramètres les coordonnées de quatre points A, B, C et D qui renvoie True si ABCD est un losange et False sinon
  • Ecrire une fonction en Python de paramètres les coordonnées de quatre points A, B, C et D qui renvoie True si ABCD est un carré non applati et False sinon
  • Remarque

    Pour éviter les problèmes de représentation des nombres machines on donne aux sommets des coordonnées entières.

    Losange : question 1

    def vecteurs(xA,yA,xB,yB) :
    	return (xB-xA,yB-yA)
    def alignement(xA,yA,xB,yB,xC,yC) :
    	xAB,yAB=vecteurs(xA,yA,xB,yB)
    	xAC,yAC=vecteurs(xA,yA,xC,yC)
    	if xAB*yAC == xAC*YAB : return True
    	else : return False
    	
    def orthoVecteurs(xA,yA,xB,yB,xC,yC,xD,yD) :
    	xAB,yAB=vecteurs(xA,yA,xB,yB)
    	xCD,yCD=vecteurs(xC,yC,xD,yD)
    	if xAB*xCD + yAB*YCD == 0 : return True
    	else : return False
    
    def parallelogrammeNonAplati(xA,yA,xB,yB,xC,yC,xD,yD) :
    	VE = (vecteurs(xA,yA,xB,yB) == vecteurs(xD,yD,xC,yC) 
    	Al = alignement(xA,yA,xB,yB,xC,yC)
    	return VE and not Al
    	
    def losange(xA,yA,xB,yB,xC,yC,xD,yD):
    	PNA = parallelogrammeNonAplati(xA,yA,xB,yB,xC,yC,xD,yD)
    	VO = orthoVecteurs(xA,yA,xC,yC,xD,yD,xB,yB)
    	return PNA and VO 

    Carré : question 2

    def vecteurs(xA,yA,xB,yB) :
    	return (xB-xA,yB-yA)
    def alignement(xA,yA,xB,yB,xC,yC) :
    	xAB,yAB=vecteurs(xA,yA,xB,yB)
    	xAC,yAC=vecteurs(xA,yA,xC,yC)
    	if xAB*yAC == xAC*YAB : return True
    	else : return False
    	
    def orthoVecteurs(xA,yA,xB,yB,xC,yC,xD,yD) :
    	xAB,yAB=vecteurs(xA,yA,xB,yB)
    	xCD,yCD=vecteurs(xC,yC,xD,yD)
    	if xAB*xCD + yAB*YCD == 0 : return True
    	else : return False
    
    def parallelogrammeNonAplati(xA,yA,xB,yB,xC,yC,xD,yD) :
    	VE = (vecteurs(xA,yA,xB,yB) == vecteurs(xD,yD,xC,yC) 
    	Al = alignement(xA,yA,xB,yB,xC,yC)
    	return VE and not Al
    	
    def longueur(xA,yA,xB,yB) :
    	xAB,yAB=vecteurs(xA,yA,xB,yB)
    	return xAB*xAB + yAB+yAB
    
    def losange(xA,yA,xB,yB,xC,yC,xD,yD):
    	PNA = parallelogrammeNonAplati(xA,yA,xB,yB,xC,yC,xD,yD)
    	VO = orthoVecteurs(xA,yA,xC,yC,xD,yD,xB,yB)
    	return PNA and VO 
    	
    def carre(xA,yA,xB,yB,xC,yC,xD,yD):
    	losange = losange(xA,yA,xB,yB,xC,yC,xD,yD)
    	ML = longueur(xA,yA,xB,yB) ==longueur(xB,yB,xC,yC)
    	return losange and ML 

    Méthode de Dichotomie (Eduscol)

    Cette situation peut donner lieu à des activités en classe de seconde.

    La méthode de dichotomie constitue un procédé dont la compréhension et la mise en oeuvre peuvent être particulièrement délicates pour les élèves. Le détour par l'algorithmique permet de « faire fonctionner » la méthode et de l'observer en acte. Cette activité peut se décliner de façons multiples pour les élèves. Il peut être simplement question de relier les blocs d'instructions aux éléments correspondant dans le texte qui décrit l'algorithme.

    Soit \(f\) une fonction continue sur un intervalle I. Soit a et b deux points de I tels que \(a < b \text{ et } f(a)×f(b)< 0 \). On sait qu’il existe au moins une solution de l’équation \(f(x) = 0\) sur l’intervalle [a ; b]. Le principe de l’algorithme de dichotomie consiste à considérer le point \(c = \frac{a+b}{2}\). Si \(f(a)×f(c)\leq 0\), on sait qu’il existe une solution sur l’intervalle [a ; c]. Sinon, on a \(f(b)×f(c)\leq 0\), et il existe une solution sur l’intervalle [c ; b]. Ainsi, à chaque étape on passe d’un intervalle contenant une solution à un intervalle de longueur moitié contenant une solution. On itère le procédé jusqu’à obtenir un intervalle de longueur inférieure à la précision requise.

  • Ecrire une fonction en Python permettant de renvoyer une valeur approchée de la solution de l'équation \(f(x) = 0\)
  • Une solution de l'exercice Méthode de Dichotomie.

    def dichotomie(f,a,b,epsilon=0.0001):
    	assert(f(a)*f(b)< 0  and a < b)	#vérifie les hypothèses requises
    	while b-a > epsilon:
    		c = (a+b)/2
    		if f(a)*f(c) <= 0:
    			a,b = a,c
    		else:
    			a,b = c,b
    	return (a+b)/2

    On remarque que dans la définition de la fonction, une valeur par défaut est fournie pour epsilon. Cela signifie que l’appel dichotomie(f,a,b) est équivalent à l’appel dichotomie(f,a,b,0.0001).

    Pour imposer une précision différente de la valeur par défaut, il suffit de la préciser, dichotomie(f,a,b,0.0000001) par exemple.

    Après avoir ouvert la bibliothèque math par la commande from math import *, on obtient pour epsilon = 0,0001 :

    >>>from math import *
    >>>dichotomie(cos,0,2)
    1.570770263671875.

    PGCD.

    Ecrire une fonction permettant de déterminer le pgcd de deux entiers naturels \( a \) et \( b \).

    Résolution de l'exercice PGCD

    Premier programme.

    
    def pgcd(a , b) :
        
        """
        Cette fonction permet de calculer le PGCD de deux entiers naturels a et b
        """
        while b!=0 :
            aux= a
            a=b
            b= aux%b
        return a
    
    >>>c = pgcd(72 , 48)
    24
    >>>

    Second programme.

    On peut en python se passer de la variable intermédiaire aux utilisée dans le programme précédent à l'aide d'affectations parallèles.

    Par exemple, si l'on veut échanger les valeurs des variables a et b, il suffit d'écrire a,b=b,a en langage python (dans la plupart des autres langages, une variable auxiliaire serait nécessaire).

    Cette particularité permet d'écrire un programme plus proche de notre descriptif :

    def pgcd(a , b) :
        
        """
        Cette fonction permet de calculer le PGCD de deux entiers naturels a et b
        """
    	assert(a>0 and type(a)==type(b)==int and b>0) # vérifie que a et b sont des entiers positifs
        while (b!=0):
            a,b =b, a%b
        return a
    
    >>>c = pgcd(72 , 48)
    24
    >>>

    Décompositions en facteurs premiers (Eduscol)

    Écrire une fonction, de paramètre un entier naturel n, qui renvoie une liste de facteurs premiers de n

    Résolution de l'exercice "Factorisation en facteurs premiers".

    def factorisation(n):
    	assert(n>=2 and type(n)==int)	#vérifie que n est un entier supérieur ou égal à 2
    	L = []
    	d = 2
    	while n>1:
    		if n%d == 0:			# on a trouvé un diviseur !
    			while n%d == 0:		# on le factorise autant que possible et
    				L.append(d)		# on l’ajoute à chaque fois dans la liste
    				n = n//d
    		d = d + 1
    	return L

    L'indentation ici est cruciale

    >>> factorisation(24)
    [2, 2, 2, 3]