Programmer en Python en 2nde

Opérateurs sur booléens

Opérateur and

and peut se définir facilement par son graphe (ou table de vérité) : 


print("False and False = ", False and False)
print("False and True = ", False and True)
print("True and False = ", True and False) 
print("True and True = ", True and True)

Affichage obtenu : 

False and False =  False
False and True =  False
True and False =  False
True and True =  True
  • Pour aller plus loin Plus tard !

On propose ci-dessous la même table de vérité en utilisant une fonction (sans paramètre) et une boucle for : 


def table_du_et() :
    for x in (False, True) :
        for y in (False, True) :
            print("{} and {} = {}.".format(x, y, x and y))

 

table_du_et()

intervalle

  1. On considère le programme suivant : 
    
x = float(input("Entrez un nombre réel : "))
print( x > 2 and x < 7)
    Décrire avec la notation des intervalles l'ensemble des réels x pour lesquels l'affichage obtenu sera True.
  2. Donnez le code qui correspondrait à des réponses True pour les réels x de l'intervalle \( ] -2 ; 21 ] \) et False pour les autres réels.
  3. Écrire une fonction Python qui respecte la spécification suivante :
    Paramètres trois réels \(x\), \(a\), \(b\) (où \( a \leqslant b \) )
    Valeur renvoyée True si \( x\in [a;b[\), False sinon.
  • Commentaire
  • Question 1
  • Question 2
  • Question 3
  • Complément à la question 3
Il s'agit d'un exercice élémentaire qui peut permettre à la fois la prise en main des notations sur les intervalles, un travail simple de logique et une prise en main de la syntaxe Python.

L'intervalle est bien entendu l'intervalle \( ] 2 ; 7 [ \).

Notez que Python autorise de ne pas utiliser and : 


x = float(input("Entrez un nombre réel : "))
print(  2 < x < 7)
	

x = float(input("Entrez un nombre réel : "))
print(  -2 < x and x <= 21)

ou encore : 


x = float(input("Entrez un nombre réel : "))
print(  -2 < x <= 21)
	

def est_dans_fo(x, a, b) :
    return x >= a and x < b
	

nombre = float(input("Entrez un nombre x : "))
borne_inf = float(input("Entrez la borne inférieure de l'intervalle : "))
borne_sup = float(input("Entrez la borne supérieure de l'intervalle : "))


print("{} est-il dans [{};{}[ ? ".format(nombre, borne_inf, borne_sup))
print(est_dans_fo(nombre, borne_inf, borne_sup))

On a utilisé "fo" dans le nom de la fonction pour : fermé (à gauche), ouvert (à droite).

Remarquons qu'une fois de plus, une séparation algorithme - programme serait ici bienvenue.

Si l'instruction x >= a and x < b de la fonction est_dans_fo(x, a, b) correspond bien, du point de vue algorithmique (i.e. mathématique), à la caractérisation de l'intervalle [a ; b [, c'est nettement plus ambigu en machine comme le montre un exemple déjà utilisé auparavant. Le code : 


def est_dans_fo(x, a, b) :
    return x >= a and x < b


print(est_dans_fo(2 + 3.001, 5.001, 10))

renvoie 

False

Opérateur or

or peut se définir facilement par son graphe (ou table de vérité) : 


print("False or False = ", False or False)
print("False or True = ", False or True)
print("True or False = ", True or False) 
print("True or True = ", True or True)

Affichage obtenu : 

False or False =  False
False or True =  True
True or False =  True
True or True =  True
  • Pour aller plus loin Plus tard !

On propose ci-dessous la même table de vérité en utilisant une fonction (sans paramètre) et une boucle for : 


def table_du_ou() :
    for x in (False, True) :
        for y in (False, True) :
            print("{} or {} = {}.".format(x, y, x or y))

 

table_du_ou()

réunion d'intervalles

  1. On considère le programme suivant : 
    
x = float(input("Entrez un nombre réel : "))
print( x > 17 or x < 7 )
    Décrire avec la notation des intervalles l'ensemble des réels x pour lesquels l'affichage obtenu sera True.
  2. Donnez le code qui afficherait True pour les réels de l'ensemble \( [ -10; 5 ] \cup ] 7; +\infty [ \) et False pour les autres réels.
  3. Écrire une fonction Python qui respecte la spécification suivante :
    Paramètres trois réels x, a, b
    Valeur renvoyée True si \( x\in ]-\infty; a] \cup [b; +\infty[ \), false sinon.
  • Question 1
  • Question 2
  • Question 3
\( ] -\infty; 7 [ \cup ] 17; +\infty [ \) 

x = float(input("Entrez un nombre réel : "))
print(  (-10 <= x and x <= 5) or  x >  7 )

ou encore : 


x = float(input("Entrez un nombre réel : "))
print(  (-10 <= x  <= 5) or  x >  7 )


def est_dans_union(x, a, b) :
    return x <= a or x >= b
	

nombre = float(input("Entrez un nombre x : "))
borne1 = float(input("Entrez la borne supérieure de l'intervalle ]-inf; a] : "))
borne2 = float(input("Entrez la borne inférieure de l'intervalle [b; +inf[ : "))


print("{} est-il dans  ]-inf; {}] union [{};+inf[ ? ".format(nombre, borne1, borne2))
print(est_dans_union(nombre, borne1, borne2))

Opérateur not

not peut se définir facilement par son graphe (ou table de vérité) : 


print("not(False) = ", not(False))
print("not(True) = ", not(True))

Affichage obtenu : 

not(False) =  True
not(True) =  False

réunion d'intervalles

  1. On considère le programme suivant : 
    
x = float(input("Entrez un nombre réel : "))
print( x > 17 or x < 7 )
    Donnez un code qui donnera les mêmes réponses mais utilisant not et and au lieu de or.
  2. Donnez un code affichant True pour tous les réels (et uniquement ceux-là) qui ne sont pas dans l'ensemble \( [ -10; 5 ] \cup ] 7; +\infty [ \).
  3. Écrire une fonction Python qui respecte la spécification suivante :
    Paramètres trois réels x, a, b
    Valeur renvoyée False si \( x\in ]-\infty; a] \cup [b; +\infty[ \), True sinon.
  • Question 1
  • Question 2
  • Question 3

Être dans \( ]-\infty; 7 [ \cup ] 17; +\infty[ \), c'est ne pas être dans \( [7; 17 ] \). 


x = float(input("Entrez un nombre réel : "))
print( not( 7 <= x and  x <= 17)  )

ou encore :


x = float(input("Entrez un nombre réel : "))
print( not( 7 <= x <= 17)  )


x = float(input("Entrez un nombre réel : "))
print( not( (-10 <= x  <= 5) or  x > 7 ) )


def est_dans_union(x, a, b) :
    return x <= a or x >= b
	
def n_est_pas_dans_union(x, a, b) :
    return not(est_dans_union(x, a, b))
	

nombre = float(input("Entrez un nombre x : "))
borne1 = float(input("Entrez la borne supérieure de l'intervalle ]-inf; a] : "))
borne2 = float(input("Entrez la borne inférieure de l'intervalle [b; +inf[ : "))


print("{} est-il hors de   ]-inf; {}] union [{};+inf[ ? ".format(nombre, borne1, borne2))
print(n_est_pas_dans_union(nombre, borne1, borne2))

Nature d'un quadrilatère

Quatre points $A$, $B$, $C$, $D$ sont donnés par leurs coordonnées (entières pour éviter les problèmes de représentation des nombres en machine) $x_A$, $y_A$, $x_B$, $y_B$, $x_C$, $y_C$, $x_D$, $y_D$.

Écrire des fonctions retournant True ou False selon que le quadrilatère $ABCD$ est un parallélogramme, un losange, un carré, etc...

  • Un code possible

# Pour simplifier les tests d'égalité, on se place dans
# le cas où tous les sommets ont des coordonnées entières.

def vecteur(xA,yA,xB,yB) :
    """ Renvoie le couple de coordonnées du vecteur AB."""
    return (xB-xA, yB-yA)
	

def carre_longueur(xA, yA, xB, yB):
    """ Renvoie le carré de la longueur AB.
    On retourne le carré pour éviter les pb d'arrondis avec la racine.
    """
    xAB, yAB = vecteur(xA, yA, xB, yB)
    return xAB*xAB + yAB*yAB 

def est_parallelogramme(xA, yA, xB, yB, xC, yC, xD, yD):
    """ Renvoie True si ABCD est plg, False sinon."""
    return vecteur(xA,yA, xB,yB) == vecteur(xD,yD, xC, yC)
	
	
def sont_alignes(xA, yA, xB, yB, xC, yC):
    """ Renvoie True si les trois points A, B, C sont alignés, False sinon."""
    xAB, yAB = vecteur(xA, yA, xB, yB)
    xAC, yAC = vecteur(xA, yA, xC, yC)
    return xAB * yAC == yAB * xAC
	
def est_parallelogramme_nonaplati(xA, yA, xB, yB, xC, yC, xD, yD):
    """ Renvoie True si ABCD est un parallélogramme non aplati, False sinon."""
    plg = est_parallelogramme(xA, yA, xB, yB, xC, yC, xD, yD)
    alignement = sont_alignes(xA, yA, xB, yB, xC, yC)
    return plg and not(alignement)
	
def ont_meme_longueur(xA, yA, xB, yB, xC, yC, xD, yD):
    """ Renvoie True si les segments AB et CD ont même longueur."""
    return carre_longueur(xA, yA, xB, yB) == carre_longueur(xC, yC, xD, yD)
	
def est_losange(xA, yA, xB, yB, xC, yC, xD, yD):
    """ Renvoie True si ABCD est un losange, False sinon."""
    return est_parallelogramme_nonaplati(xA, yA, xB, yB, xC, yC, xD, yD) and ont_meme_longueur(xA, yA, xB, yB, xB, yB, xC, yC)
	
	
def est_carre(xA, yA, xB, yB, xC, yC, xD, yD):
    """ Renvoie True si ABCD est un carré, False sinon."""
    return est_losange(xA, yA, xB, yB, xC, yC, xD, yD) and  ont_meme_longueur(xA, yA, xC, yC, xB, yB, xD, yD)
	
	
def est_rectangle(xA, yA, xB, yB, xC, yC, xD, yD):
    """ Renvoie True si ABCD est un rectangle, False sinon."""
    return est_parallelogramme_nonaplati(xA, yA, xB, yB, xC, yC, xD, yD) and  ont_meme_longueur(xA, yA, xC, yC, xB, yB, xD, yD)



print(" A(0;0), B(1;0), C(1;1), D(0;1)")
xA, yA = 0, 0
xB, yB = 1, 0
xC, yC = 1, 1
xD, yD = 0, 1
print("Parallélogramme ? ", est_parallelogramme(xA, yA, xB, yB, xC, yC, xD, yD))
print("Alignés ?", sont_alignes(xA, yA, xB, yB, xC, yC))
print("Parallélogramme non aplati ? ", est_parallelogramme_nonaplati(xA, yA, xB, yB, xC, yC, xD, yD))
print("Losange ? ", est_losange(xA, yA, xB, yB, xC, yC, xD, yD))
print("Carré ? ", est_carre(xA, yA, xB, yB, xC, yC, xD, yD))
print("Rectangle ? ", est_rectangle(xA, yA, xB, yB, xC, yC, xD, yD))

Année bissextile

On rappelle que les années bissextiles sont les années divisibles par 4, à l'exception de celles qui sont divisibles par 100 sans l'être par 400.

Par exemple :

  • 2000 est une année bissextile (2000 est divisible par 4. 2000 est divisible par 100 mais aussi par 400 : ne fait donc pas partie des exceptions).
  • 2012 est divisible par 4 (et pas par 100) : 2012 est bissextile.
  • 1900 est divisible par 4, par 100 mais pas par 400. 1900 n'est pas bissextile.

Écrire une fonction Python qui respecte la spécification suivante :

Paramètre un entier naturel n
Valeur renvoyée True si l'année n est bissextile, False sinon
  • Un code possible

def bissextile(n) :
    regle = (n%4 == 0)
    exception = (n%100 == 0 and n%400 != 0)
    return regle and not(exception)

print(bissextile(1900))
print(bissextile(2000))
print(bissextile(2002))
print(bissextile(2012))