I Rappels historiques
A partir de 1847, le britannique George Boole propose un mode de calcul.
Celui-ci permet de traduire des raisonnements logiques par des opérations algébriques.
Il crée une branche des mathématiques qui définit des opérations dans un ensemble qui ne contient que deux éléments notés 0 et 1, ou bien Faux et Vrai (logique), ou bien Ouvert et Fermé (électronique) ou en python False et True.
En 1938, l’Américain Claude Shannon prouve que des circuits électriques peuvent résoudre tous les problèmes que l’algèbre de Boole peut résoudre. Avec les travaux d’Alan Turing de 1936, cela constitue les fondements de ce qui deviendra l’informatique.
II Les opérations fondamentales:
La conjonction, notée &, ^ou . et lue « et »
La disjonction, notée I, v ou + et lue « ou » (il s’agit du ou mathématique)
La négation, notée ~, ou - et lue « non »Consultez le cours sur l'algèbre de Boole.Créer une fonction « et() » qui prendra deux paramètres entiers dont les valeurs pourront être 0 ou 1.
Cette fonction devra rendre comme résultat 0 ou 1, conformément à la table de vérité de la conjonction « et ».
Pour cela, vous utiliserez des tests et tiendrez compte du caractère séquentiel de cet opérateur.
Les résultats attendus seront :
et(0,0)=0
et(0,1)=0
et(1,0)=0
et(1,1)=1
Pour retourner un résultat lors de l’utilisation d’une fonction, on utilise la fonction return.
Syntaxe :
return nom_variable(s)
Il reste à afficher la valeur de la fonction pour deux valeurs données.### Section des fonctions
def et(a:int,b:int):
"""Nous recréons la fonction and"""
if a==0:
s=0 # Nous utilisons le caractère séquentiel de l'opérateur, a=0, inutile de regarder b
else:
if b==0: # a étant nul, nous regardons la situation b=0
s=0
else: # a étant nul, nous regardons la situation b=1
s=1
return s # la fonction prendra la valeur de s
### Section main
print(et(0,1)) # Je regarde ce que la fonction donne si l'on entre les valeurs 0 et 1.
Pour tester une fonction, on peut utiliser la fonction assert
Exemple:
assert et(0,0)==0
assert et(0,1)==0
:
:
Vous allez remplacer l'affichage dans le menu principal par les 4 fonctions assert relatant les possiblilités.
Si lorsque vous lancer le programme, aucun message d'erreur ne se produit, c'est que le programme fait ce qui est attendu.### Section des fonctions
def et(a:int,b:int):
"""Nous recréons la fonction and"""
if a==0:
s=0 # Nous utilisons le caractère séquentiel de l'opérateur, a=0, inutile de regarder b
else:
if b==0: # a étant nul, nous regardons la situation b=0
s=0
else: # a étant nul, nous regardons la situation b=1
s=1
return s # la fonction prendra la valeur de s
### Section main
assert et(0,0)==0
assert et(0,1)==0
assert et(1,0)==0
assert et(1,1)==1
Je vous propose de regarder le message d'erreur provoqué si le programme ne fait pas ce qui est attendu.
Pour cela, remplacez le premier assert par: assert et(0,0)==1### Section des fonctions
def et(a:int,b:int):
"""Nous recréons la fonction and"""
if a==0:
s=0 # Nous utilisons le caractère séquentiel de l'opérateur, a=0, inutile de regarder b
else:
if b==0: # a étant nul, nous regardons la situation b=0
s=0
else: # a étant nul, nous regardons la situation b=1
s=1
return s # la fonction prendra la valeur de s
### Section main
assert et(0,0)==1
assert et(0,1)==0
assert et(1,0)==0
assert et(1,1)==1
La localisation de l'erreur vous permet alors de corriger votre fonction.Créez une seconde fonction « et() » qui fait la même chose avec des booléens, c’est à dire avec False et True
Pour la vérification, on utilisera :
assert not et(False,False) *# Le not signifie que la réponse doit être False*
assert not et(False,True)
assert not et(..,..)
assert et(..,..). *# Ici, la réponse doit être True*### Section des fonctions
def et(a:bool,b:bool):
"""Nous recréons la fonction and"""
if a==False:
s=False # Nous utilisons le caractère séquentiel de l'opérateur, a=False, inutile de regarder b
else:
if b==False: # a étant True, nous regardons la situation b=False
s=False
else: # a étant True, nous regardons la situation b=True
s=True
return s # la fonction prendra la valeur de s
### Section main
assert not et(False,False)
assert not et(False,True)
assert not et(True,False)
assert et(True,True)
Créez une fonction ou() reproduisant la disjonction, c'est-à-dire le ou mathématique.
Vous travaillerez avec des valeurs booléennes. Vous utiliserez le caractère séquentiel de cet opérateur.
Vous ferez les quatres vérifications avec la fonction assert. ### Section des fonctions
def ou(a:bool,b:bool):
"""Nous recréons la fonction or"""
if a==True:
s=True # Nous utilisons le caractère séquentiel de l'opérateur, a=True, inutile de regarder b
else:
if b==False: # a étant False, nous regardons la situation b=False
s=False
else: # a étant False, nous regardons la situation b=True
s=True
return s # la fonction prendra la valeur de s
### Section main
assert not ou(False,False)
assert ou(False,True)
assert ou(True,False)
assert ou(True,True)
Nous pouvons observer les lois de l'algèbre de Boole dans le cours.
Nous pouvons à l’aide des opérations fondamentales recréer le « ou » français, c’est à dire le ou exclusif (tu as 16 ans ou 17 ans). Voir le cours. Vous y trouverez également sa table de vérité.
En python, ce sera le : xorDans le shell, tapez :
bin(0b1011011&0b1010101)
Vérifiez que le & (and, et) a bien été effectué bit à bit pour les 7 bits.Même chose, dans le shell, tapez :
bin(0b1011011|0b1010101)
Vérifiez que le | (or, ou mathématique) a bien été effectué bit à bit pour les 7 bits.Même chose, dans le shell, tapez :
bin(0b1011011^0b1010101)
Vérifiez que le ^ (xor, ou français) a bien été effectué bit à bit pour les 7 bits.A l'avenir nous pourrons utiliser les opérateurs, and, or, not et xor.Remarque avec l'instruction return, nous avons vu qu'une fonction pouvait renvoyer une valeur.
Dans notre premier exemple, c'était un entier, dans le second un booléen.
Il est possible de préciser dans le titre de la fonction, le type de rtour, voir les exemples ci-dessous. def et(a:int,b:int)->int:
def ou(a:bool,b:bool)->bool: