ajout séquence fonctions booléennes
This commit is contained in:
BIN
representation_base/.DS_Store
vendored
BIN
representation_base/.DS_Store
vendored
Binary file not shown.
@@ -269,3 +269,10 @@ Exemple : (944)<sub>10</sub> → ( 12234)<sub>5</sub>
|
||||
|
||||
|
||||
|
||||
--------
|
||||
|
||||
Auteur : Florian Mathieu
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
|
||||
@@ -113,3 +113,10 @@ En Python, la taille des entiers est arbitraire (donc non fixe), ainsi les valeu
|
||||
|
||||
Néanmoins, on dispose de la bibliothèque _numpy_ qui permet de forcer une représentation sur 8 bits, par exemple, à l'aide de la fonction *int8*
|
||||
|
||||
--------
|
||||
|
||||
Auteurs : Florian Mathieu - Philippe Boddaert
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
|
||||
@@ -17,14 +17,14 @@ Maintenant que nous allons tenter de coder les réels, les limites de notre mach
|
||||
|
||||
### À Faire
|
||||
|
||||
1. effectuez le calcul $`0.2 + 0.1`$ en Python :
|
||||
Effectuez le calcul $`0.2 + 0.1`$ en Python :
|
||||
|
||||
```python
|
||||
>>> 0.2 + 0.1
|
||||
???
|
||||
```
|
||||
|
||||
2. testez l'égalité suivante :
|
||||
Testez l'égalité suivante :
|
||||
|
||||
```python
|
||||
>>> 0.2 + 0.1 == 0.3
|
||||
@@ -45,7 +45,7 @@ Ainsi, un calcul avec des nombres à virgule ne peut-être qu'__approximatif__.
|
||||
|
||||
Il existe deux façons de coder les nombres réels, en virgule fixe ou virgule flottante.
|
||||
|
||||
### 3.1. Virgule fixe
|
||||
### Virgule fixe
|
||||
|
||||
Le codage en __virgule fixe__ consiste à garder __un nombre fixe de chiffes après la virgule__.
|
||||
|
||||
@@ -63,8 +63,8 @@ L’inconvénient de cette méthode est que, pour un nombre avec peu de chiffres
|
||||
|
||||
Représenter les valeurs suivants sur 8 bits, en virgule fixe :
|
||||
|
||||
1. 7,75
|
||||
2. 0,1
|
||||
- 7,75
|
||||
- 0,1
|
||||
|
||||
### Virgule flottante
|
||||
|
||||
@@ -103,9 +103,7 @@ Par exemple :
|
||||
|
||||
_N.B : Dans le cas de la notation scientifique binaire, le nombre avant la virgule doit être compris entre $`1_2`$ inclus et $`10_2`$ exclus (c'est-à-dire 2 exclus), c'est-à-dire que sa partie entière est nécessairement 1._
|
||||
|
||||
|
||||
|
||||
#### 3.2.3 Passage de l'écriture décimale à l'écriture binaire pour un nombre flottant
|
||||
#### Passage de l'écriture décimale à l'écriture binaire pour un nombre flottant
|
||||
|
||||
Si vous avez bien suivi, vous savez qu'un nombre est composé de deux parties :
|
||||
|
||||
@@ -130,7 +128,7 @@ Exemple :
|
||||
|
||||
0,6875 s'écrit donc 0,1011<sub>2</sub>
|
||||
|
||||
#### 3.2.4. Principe du codage en virgule flottante
|
||||
#### Principe du codage en virgule flottante
|
||||
|
||||
Un nombre flottant est formé de trois éléments : la mantisse, l'exposant et le signe.
|
||||
|
||||
@@ -165,7 +163,7 @@ Le code `1 101 1011` sur un octet utilisant 1 bit de signe, 3 bits pour l'exposa
|
||||
|
||||
----------------
|
||||
|
||||
## 4. La norme IEEE 754
|
||||
## La norme IEEE 754
|
||||
|
||||
> L'__IEEE 754__ est une norme pour la représentation des nombres à virgule flottante en binaire. Elle est la norme la plus employée actuellement pour le calcul des nombres à virgule flottante dans le domaine informatique.
|
||||
|
||||
@@ -179,7 +177,7 @@ Cette norme définit notamment 2 formats pour représenter des nombres à virgul
|
||||
|
||||
|
||||
|
||||
### 4.1. Valeurs remarquables
|
||||
### Valeurs remarquables
|
||||
|
||||
Chaque norme défini aussi des valeurs spéciales, par exemple en double précision:
|
||||
|
||||
@@ -188,7 +186,7 @@ Chaque norme défini aussi des valeurs spéciales, par exemple en double précis
|
||||
- l'infini positif: +∞ = `0 11111111111 0000000000000000000000000000000000000000000000000000`,
|
||||
- l'infini négatif: +∞ = `1 11111111111 0000000000000000000000000000000000000000000000000000`
|
||||
|
||||
### 4.2. Impossibilité de coder tous les nombres réels
|
||||
### Impossibilité de coder tous les nombres réels
|
||||
|
||||
Voici l’écriture binaire en format double précision de deux flottants.
|
||||
|
||||
@@ -230,15 +228,15 @@ Le flottant 2.000000238418579 est donc représenté comme le suivant de 2.0.
|
||||
La précision possible avec une mantisse sur 23 bits se situe au niveau dernier bit qui vaut
|
||||
$`2^{-23}`$ . On ne peut pas trouver un flottant compris entre les deux.
|
||||
|
||||
### 4.3. Conclusion
|
||||
### Conclusion
|
||||
|
||||
Les nombres flottants sont une représentation approximative des nombres réels dans un ordinateur. En particulier, il n’est pas possible de représenter de manière exacte en machine tous les nombres réels. La manipulation de nombres réels par un langage informatique est donc à prendre avec précaution car elle peut engendrer des résultats surprenants, en particulier il ne faut jamais tester l’égalité entre deux flottants.
|
||||
|
||||
----------
|
||||
|
||||
## 5. Exercices
|
||||
## Exercices
|
||||
|
||||
### 5.1. Exercice
|
||||
### Exercice
|
||||
|
||||
On considère des nombres flottants encodés sur un octet avec dans l'ordre:
|
||||
|
||||
@@ -257,7 +255,7 @@ On considère des nombres flottants encodés sur un octet avec dans l'ordre:
|
||||
- Quel est le plus petit nombre à virgule, donc négatif ?
|
||||
- Quel est le plus petit nombre à virgule strictement positif que l'on peut représenter ?
|
||||
|
||||
### 5.2. Exercice
|
||||
### Exercice
|
||||
|
||||
1. Quelles sont les valeurs attendues des instructions suivantes ?
|
||||
|
||||
@@ -300,7 +298,7 @@ On considère des nombres flottants encodés sur un octet avec dans l'ordre:
|
||||
```
|
||||
2. Copier et exécuter les instructions précédentes et comparer avec les résultats attendus.
|
||||
|
||||
### 5.3. Exercice
|
||||
### Exercice
|
||||
|
||||
On considère le programme suivant:
|
||||
|
||||
|
||||
@@ -1,97 +1,57 @@
|
||||
# Les tableaux de Karnaugh
|
||||
## Les tableaux de Karnaugh
|
||||
|
||||
|
||||
------
|
||||
|
||||
## Introduction
|
||||
|
||||
La réduction, pour une même expression, du nombre d'*opérateur*s ***et / ou*** du nombre de *variables*, conduit à une écriture simplifiée de cette expression.
|
||||
La simplification d'une expression booléenne consiste à réduire le nombre d'opérateurs et/ou de variables, permettant ainsi d'obtenir une version plus compacte de cette expression.
|
||||
|
||||
Il existe un grand nombre de méthodes de simplification d'expression booléenne, parmi lesquelles ont peut distinguer :
|
||||
Plusieurs méthodes sont disponibles à cet effet, mais l'une des plus efficaces est l'utilisation du tableau de Karnaugh. Voici comment elle fonctionne :
|
||||
|
||||
- La simplification par **Tableau de Karnaugh**. On fait cela en quelques étapes :
|
||||
- On construit un tableau de la fonction à simplifier
|
||||
- On recherche les cases adjacentes qui ont pour valeur 1
|
||||
- On regroupe ces cases par puissance de 2, en paquets les plus gros possibles.
|
||||
- On crée un tableau pour la fonction à simplifier.
|
||||
- On cherche les cellules adjacentes avec la valeur 1.
|
||||
- On regroupe ces cellules en blocs de 2^n (n étant un nombre entier), en visant à faire des blocs aussi grands que possible.
|
||||
|
||||
Cette méthode s'avère la plus redoutable.
|
||||
|
||||
---------
|
||||
------
|
||||
|
||||
## Construction du tableau de Karnaugh
|
||||
|
||||
- Tableau à 3 variables:
|
||||
- En haut, on regroupe deux variables ensemble (A B)
|
||||
- À gauche, on indique la troisième (C)
|
||||
- S = sortie
|
||||
Pour une fonction à 3 variables :
|
||||
|
||||
| S | 00 | 01 | 11 | 10 |
|
||||
| ---- | ---- | ---- | ---- | ---- |
|
||||
| 0 | | | | |
|
||||
| 1 | | | | |
|
||||
- On met deux variables en haut du tableau (A et B).
|
||||
- On place la troisième variable sur le côté gauche (C).
|
||||
- La sortie (S) est le résultat de la fonction pour chaque combinaison de valeurs des variables.
|
||||
|
||||
Pour une fonction à 4 variables :
|
||||
|
||||
- Deux variables en haut (A et B)
|
||||
- Deux variables à gauche (C et D)
|
||||
|
||||
- Tableau à 4 variables :
|
||||
- Deux variables en haut ( A B)
|
||||
- Deux variables à gauche ( C D)
|
||||
|
||||
| U | 00 | 01 | 11 | 10 |
|
||||
| ---- | ---- | ---- | ---- | ---- |
|
||||
| 00 | | | | |
|
||||
| 01 | | | | |
|
||||
| 11 | | | | |
|
||||
| 10 | | | | |
|
||||
|
||||
|
||||
|
||||
-----------
|
||||
------
|
||||
|
||||
## Exemples
|
||||
|
||||
*Simplification de l'équation logique suivante :*
|
||||
|
||||
```math
|
||||
Considérons la simplification de l'équation logique suivante :
|
||||
$$
|
||||
S = \overline a b \overline c \overline d + abcd + a \overline b c d + ab \overline c \overline d
|
||||
```
|
||||
|
||||
|
||||
|
||||
| S | 00 | 01 | 11 | 10 |
|
||||
| ---- | ---- | ---- | ---- | ---- |
|
||||
| 00 | 0 | 1 | 1 | 0 |
|
||||
| 01 | 0 | 0 | 0 | 0 |
|
||||
| 11 | 0 | 0 | 1 | 1 |
|
||||
| 10 | 0 | 0 | 0 | 0 |
|
||||
|
||||
- On regroupe les 1 collés en haut : a change d'état et est éliminé. Il reste donc :
|
||||
|
||||
```math
|
||||
b \overline c \overline d
|
||||
```
|
||||
|
||||
|
||||
|
||||
- On regroupe les 1 en bas : b change d'état et est éliminé, il reste :
|
||||
|
||||
```math
|
||||
acd
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
On a donc une équation réduite sous forme de polynôme ou canonique en ***OU***
|
||||
|
||||
```math
|
||||
$$
|
||||
En utilisant le tableau de Karnaugh, on peut regrouper les 1 adjacents. Dans le premier regroupement (en haut du tableau), la variable a change d'état et est donc éliminée. Il reste alors :
|
||||
$$
|
||||
b \overline c \overline d
|
||||
$$
|
||||
Dans le second regroupement (en bas du tableau), la variable b change d'état et est éliminée. Il reste alors :
|
||||
$$
|
||||
acd
|
||||
$$
|
||||
L'équation logique simplifiée est donc :
|
||||
$$
|
||||
S = acd + b \overline c \overline d
|
||||
```
|
||||
$$
|
||||
|
||||
|
||||
------
|
||||
|
||||
-------
|
||||
|
||||
|
||||
En utilisant la même méthode, on peut simplifier d'autres équations logiques. Par exemple :
|
||||
|
||||
| S | 00 | 01 | 11 | 10 |
|
||||
| ---- | ---- | ---- | ---- | ---- |
|
||||
@@ -100,13 +60,15 @@ S = acd + b \overline c \overline d
|
||||
| 11 | 1 | 0 | 0 | 0 |
|
||||
| 10 | 1 | 0 | 0 | 0 |
|
||||
|
||||
```math
|
||||
Est simplifiée en :
|
||||
$$
|
||||
S = \overline a \overline b
|
||||
```
|
||||
$$
|
||||
|
||||
|
||||
------
|
||||
|
||||
-------
|
||||
Et de même pour :
|
||||
|
||||
| S | 00 | 01 | 11 | 10 |
|
||||
| ---- | ---- | ---- | ---- | ---- |
|
||||
@@ -115,13 +77,15 @@ S = \overline a \overline b
|
||||
| 11 | 1 | 0 | 0 | 1 |
|
||||
| 10 | 1 | 0 | 0 | 1 |
|
||||
|
||||
```math
|
||||
Qui devient :
|
||||
$$
|
||||
S = \overline b
|
||||
```
|
||||
$$
|
||||
|
||||
|
||||
------
|
||||
|
||||
----------
|
||||
Et encore une fois pour :
|
||||
|
||||
| S | 00 | 01 | 11 | 10 |
|
||||
| ---- | ---- | ---- | ---- | ---- |
|
||||
@@ -130,38 +94,23 @@ S = \overline b
|
||||
| 11 | 0 | 0 | 0 | 0 |
|
||||
| 10 | 1 | 0 | 0 | 1 |
|
||||
|
||||
```math
|
||||
Qui devient :
|
||||
$$
|
||||
S = \overline b \overline d
|
||||
```
|
||||
$$
|
||||
|
||||
|
||||
|
||||
---------
|
||||
------
|
||||
|
||||
## Exercices
|
||||
|
||||
|
||||
|
||||
**Simplifier à l'aide du tableau du Karnaugh l'équation logique suivante** :
|
||||
|
||||
```math
|
||||
Essayez de simplifier l'équation logique suivante à l'aide d'un tableau de Karnaugh :
|
||||
$$
|
||||
T = \overline a b \overline c \overline d + ab \overline c \overline d + \overline a bc \overline d + abc\overline d + \overline a \overline b c \overline d + a \overline b c \overline d
|
||||
```
|
||||
|
||||
|
||||
|
||||
| T | 00 | 01 | 11 | 10 |
|
||||
| ---- | ---- | ---- | ---- | ---- |
|
||||
| 00 | 0 | 1 | 1 | 0 |
|
||||
| 01 | 0 | 0 | 0 | 0 |
|
||||
| 11 | 0 | 0 | 0 | 0 |
|
||||
| 10 | 1 | 1 | 1 | 1 |
|
||||
|
||||
-------------
|
||||
|
||||
D'après le tableau de Karnaugh suivant, rechercher l'équation logique réduite :
|
||||
$$
|
||||
|
||||
|
||||
Puis, en utilisant le tableau de Karnaugh ci-dessous, tentez de trouver l'équation logique réduite correspondante. Astuce : utilisez le théorème de DE MORGAN.
|
||||
|
||||
| U | 00 | 01 | 11 | 10 |
|
||||
| ---- | ---- | ---- | ---- | ---- |
|
||||
@@ -170,13 +119,16 @@ D'après le tableau de Karnaugh suivant, rechercher l'équation logique réduite
|
||||
| 11 | 1 | 1 | 0 | 1 |
|
||||
| 10 | 1 | 1 | 1 | 1 |
|
||||
|
||||
Indice : utiliser le théorème de **DE MORGAN**
|
||||
|
||||
```math
|
||||
$$
|
||||
\overline U = abcd
|
||||
```
|
||||
$$
|
||||
|
||||
|
||||
|
||||
-------------
|
||||
|
||||
Auteur : Florian Mathieu
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
|
||||
@@ -1,8 +1,14 @@
|
||||
# Type Booléen en Python
|
||||
## Introduction
|
||||
|
||||
|
||||
|
||||
> Le type booléen, ou `bool`, est un type de données en Python qui a deux valeurs possibles : `True` (vrai) ou `False` (faux). Il est généralement utilisé pour effectuer des comparaisons et des opérations logiques.
|
||||
|
||||
|
||||
|
||||
## Valeur et Type
|
||||
|
||||
En Python, les booléens sont `True` et `False`, ils sont du type `bool`
|
||||
En Python, les booléens sont représentés par `True` et `False`, et sont du type `bool`. Par exemple :
|
||||
|
||||
```python
|
||||
>>> True
|
||||
@@ -15,11 +21,11 @@ False
|
||||
<class 'bool'>
|
||||
```
|
||||
|
||||
------
|
||||
|
||||
## Comparaison
|
||||
|
||||
Les opérateurs de comparaison courants sont identiques à ceux des mathématiques mais ATTENTION, il ne faut pas confondre l’égalité et l’affectation
|
||||
|
||||
Python
|
||||
Les opérateurs de comparaison en Python sont similaires à ceux utilisés en mathématiques. Il est important de ne pas confondre l'opérateur d'affectation (`=`) avec l'opérateur d'égalité (`==`). Par exemple :
|
||||
|
||||
```python
|
||||
>>> variable = 5 # une affectation
|
||||
@@ -27,22 +33,43 @@ Python
|
||||
False
|
||||
```
|
||||
|
||||
**Le résultat d’une comparaison est toujours un booléen**
|
||||
**Le résultat d'une comparaison est toujours un booléen.**
|
||||
|
||||
------
|
||||
|
||||
## Comparaisons des nombres
|
||||
|
||||
| Comparaison | Symbole | Exemple | Résultat |
|
||||
| ----------------- | ------- | ------------- | -------- |
|
||||
| Égalité | `==` | `1 + 2 == 3` | `True` |
|
||||
| Différence | `!=` | `1 + 2 != 3` | `False` |
|
||||
| Supérieur | `>` | `4 > 3` | `True` |
|
||||
| Inférieur | `<` | `2.2 < 2 * 3` | `True` |
|
||||
| Supérieur ou égal | `>=` | `5 >= 6` | `False` |
|
||||
| Inférieur ou égal | `<=` | `8 <= 3` | `False` |
|
||||
On peut comparer les nombres en utilisant les opérateurs de comparaison suivants :
|
||||
|
||||
- Égalité : `==`
|
||||
- Différence : `!=`
|
||||
- Supérieur : `>`
|
||||
- Inférieur : `<`
|
||||
- Supérieur ou égal : `>=`
|
||||
- Inférieur ou égal : `<=`
|
||||
|
||||
Par exemple :
|
||||
|
||||
```python
|
||||
>>> 1 + 2 == 3
|
||||
True
|
||||
>>> 1 + 2 != 3
|
||||
False
|
||||
>>> 4 > 3
|
||||
True
|
||||
>>> 2.2 < 2 * 3
|
||||
True
|
||||
>>> 5 >= 6
|
||||
False
|
||||
>>> 8 <= 3
|
||||
False
|
||||
```
|
||||
|
||||
------
|
||||
|
||||
## Appartenance à une structure
|
||||
|
||||
On peut tester qu’un élément appartient à une structure avec le mot clé `in`
|
||||
On peut utiliser l'opérateur `in` pour vérifier si un élément est présent dans une structure de données. Par exemple :
|
||||
|
||||
```python
|
||||
>>> "a" in "bonjour" # False
|
||||
@@ -53,31 +80,20 @@ True
|
||||
False
|
||||
```
|
||||
|
||||
# Opérations sur les booléens
|
||||
------
|
||||
|
||||
Les opérateurs sur les booléens sont de deux types :
|
||||
## Opérations sur les booléens
|
||||
|
||||
- opérateur unaire : prend *un* booléen et en renvoie *un*.
|
||||
- opérateur binaire : prend *deux* booléens et en renvoie *un*.
|
||||
|
||||
## Opérateur unaire : la négation
|
||||
|
||||
### La négation: `not`
|
||||
|
||||
C’est le seul opérateur *unaire*, il donne le contraire de ce qu’on lui passe.
|
||||
Les opérations sur les booléens comprennent la négation (`not`), l'opérateur OU (`or`), l'opérateur ET (`and`) et l'opérateur XOR (`^`). Par exemple :
|
||||
|
||||
```python
|
||||
>>> not True # s'évalue à False
|
||||
# La négation
|
||||
>>> not True
|
||||
False
|
||||
>>> not False # s'évalue à True
|
||||
>>> not False
|
||||
True
|
||||
```
|
||||
|
||||
## Opérateur binaire : le OU, noté `or`
|
||||
|
||||
**Il est vrai si l’un des deux booléens est vrai.**
|
||||
|
||||
```python
|
||||
# L'opérateur OU
|
||||
>>> False or False
|
||||
False
|
||||
>>> False or True
|
||||
@@ -86,13 +102,8 @@ True
|
||||
True
|
||||
>>> True or True
|
||||
True
|
||||
```
|
||||
|
||||
## Opérateur binaire : le ET, noté `and`
|
||||
|
||||
**Il est vrai si les deux booléens sont vrais.**
|
||||
|
||||
```python
|
||||
# L'opérateur ET
|
||||
>>> False and False
|
||||
False
|
||||
>>> False and True
|
||||
@@ -101,13 +112,8 @@ False
|
||||
False
|
||||
>>> True and True
|
||||
True
|
||||
```
|
||||
|
||||
## Opérateur binaire : le XOR noté `^`
|
||||
|
||||
**Il est vrai si EXACTEMENT un des deux booléens est vrai**
|
||||
|
||||
```python
|
||||
# L'opérateur XOR
|
||||
>>> False ^ False
|
||||
False
|
||||
>>> False ^ True
|
||||
@@ -118,35 +124,34 @@ True
|
||||
False
|
||||
```
|
||||
|
||||
------
|
||||
|
||||
## Python et les booléens
|
||||
|
||||
Python permet de comparer n’importe quoi à un booleen.
|
||||
|
||||
Par exemple, une chaîne de caractère vide est évaluée à `False`.`
|
||||
Python permet d'évaluer n'importe quel type de donnée comme un booléen. Par exemple :
|
||||
|
||||
```python
|
||||
>>> bool(1)
|
||||
>>> bool(1) # Vrai
|
||||
True
|
||||
>>> bool(0)
|
||||
>>> bool(0) # Faux
|
||||
False
|
||||
>>> bool("")
|
||||
>>> bool("") # Faux
|
||||
False
|
||||
>>> bool("abc")
|
||||
>>> bool("abc") # Vrai
|
||||
True
|
||||
>>> bool([])
|
||||
>>> bool([]) # Faux
|
||||
False
|
||||
>>> bool([1, 2])
|
||||
>>> bool([1, 2]) # Vrai
|
||||
True
|
||||
```
|
||||
|
||||
- 0 est faux, les autres entiers sont vrais,
|
||||
- une structure vide est fausse, les autres sont vraies.
|
||||
En règle générale, zéro, les structures de données vides et `None` sont évalués comme `False`, tandis que les autres valeurs sont évaluées comme `True`.
|
||||
|
||||
## Complément : `None` et l’identité `is`
|
||||
------
|
||||
|
||||
Python propose la valeur `None` (rien) qui est fréquement utilisé pour représenter l’absence d’une valeur.
|
||||
## Complément : `None` et l'identité `is`
|
||||
|
||||
Étant le seul objet du type `NoneType`, on peut tester son *identité* avec `is` :
|
||||
Python propose la valeur `None` pour représenter l'absence d'une valeur. On peut utiliser l'opérateur `is` pour vérifier l'identité d'une valeur. Par exemple :
|
||||
|
||||
```python
|
||||
>>> 1 is None
|
||||
@@ -160,4 +165,38 @@ True
|
||||
False
|
||||
```
|
||||
|
||||
On verra plus tard qu’une _fonction_ qui ne se termine par `return ...` renvoie néanmoins `None`.
|
||||
Une fonction qui ne se termine pas par `return ...` renvoie implicitement `None`.
|
||||
|
||||
--------
|
||||
|
||||
## Opérations bit à bit
|
||||
|
||||
Python, comme de nombreux autres langages de programmation, fournit des opérateurs bit à bit pour manipuler les nombres au niveau des bits.
|
||||
|
||||
Ces opérateurs incluent les opérations AND (&), OR (|), XOR (^), NOT (~), ainsi que les décalages de bits à gauche (<<) et à droite (>>).
|
||||
|
||||
Voici un exemple de leur utilisation :
|
||||
|
||||
```python
|
||||
a = 10 # 1010 en binaire
|
||||
b = 4 # 0100 en binaire
|
||||
|
||||
print(a & b) # Opération AND: 0000 en binaire (0 en decimale)
|
||||
print(a | b) # Opération OR: 1110 en binaire (14 en decimale)
|
||||
print(a ^ b) # Opération XOR: 1110 en binaire (14 en decimale)
|
||||
print(~a) # Opération NOT: 0101 en binaire (-11 en decimale, complément à deux)
|
||||
print(a << 1) # Opération décalage à gauche: 10100 en binaire (20 en decimale)
|
||||
print(a >> 1) # Opération décalage à droite: 0101 en binaire (5 en decimale)
|
||||
```
|
||||
|
||||
|
||||
|
||||
---------
|
||||
|
||||
|
||||
|
||||
Auteur : Florian Mathieu
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
@@ -1,14 +1,16 @@
|
||||
# Codage des booléens
|
||||
## Codage des booléens
|
||||
|
||||
## Attendus
|
||||
> Ce cours fournit une introduction à la logique booléenne et à la manière dont elle s'applique à l'informatique. Vous apprendrez non seulement les bases des opérations booléennes, mais vous comprendrez également comment ces opérations peuvent être utilisées pour créer des structures plus complexes, telles que des additions binaires, des multiplexeurs, des décodeurs et, finalement, un ordinateur entier.
|
||||
|
||||
| Contenus | Capacités attendues |
|
||||
| :--: | :-- |
|
||||
| Valeurs booléennes : 0,1. Opérateurs booléens : and, or, not.<br />Expressions booléennes | Dresser la table d’une expression booléenne |
|
||||
## Le programme
|
||||
|
||||
|
||||
|
||||
---------
|
||||
|
||||
## Définition
|
||||
|
||||
De nombreux dispositifs électroniques, électromécanique, (mécanique, électrique, pneumatique, etc....) fonctionnement en TOUT ou RIEN.
|
||||
De nombreux dispositifs électroniques, électromécaniques, (mécaniques, électriques, pneumatiques, etc....) fonctionnement en TOUT ou RIEN.
|
||||
|
||||
Ceci sous-entend qu'ils peuvent prendre 2 états.
|
||||
|
||||
@@ -23,29 +25,26 @@ Exemples :
|
||||
|
||||
Un système présentera un fonctionnement __logique combinatoire__ si l'état à un instant $`t`$ des variables de sortie ne dépend que de l'état des variables d'entrée au même instant $`t`$.
|
||||
|
||||
---------
|
||||
|
||||
## Variable logique
|
||||
|
||||
Une variable logique ne peut prendre que 2 états:
|
||||
Une variable logique est un type de variable qui peut prendre uniquement l'une de deux valeurs, généralement désignées comme 0 (faux) et 1 (vrai). Ces deux valeurs sont souvent utilisées pour représenter deux états opposés. Par exemple :
|
||||
|
||||
| État Vrai | État Faux |
|
||||
| :--: | :--: |
|
||||
| Oui | Non |
|
||||
| True | False |
|
||||
| 1 | 0 |
|
||||
| Haut | Bas |
|
||||
| High | Low |
|
||||
| :-------: | :-------: |
|
||||
| Oui | Non |
|
||||
| True | False |
|
||||
| 1 | 0 |
|
||||
| Haut | Bas |
|
||||
|
||||
Pour ces raisons, il est beaucoup plus avantageux d'employer un système mathématique n'utilisant que 2 valeurs numériques.
|
||||
*Par exemple, la variable "IsLightOn" peut avoir deux états : 1 (la lumière est allumée) ou 0 (la lumière est éteinte).*
|
||||
|
||||
Par convention, on utilise les valeurs 0 / 1 pour représenter les états d'une variable logique.
|
||||
|
||||
La variable binaire est aussi appelée variable __booléenne__. (De George Boole, mathématicien anglais 1815 - 1864)
|
||||
------
|
||||
|
||||
## Fonction logique
|
||||
|
||||
Une fonction $`S`$ (exemple: allumer une lampe) peut comporter $`n`$ variables logiques.
|
||||
Pour chacune de ces combinaisons, la fonction peut prendre une valeur 0 ou 1.
|
||||
Nous obtenons $`2^n`$ combinaisons pour ces $`n`$ variables.
|
||||
Une fonction logique est une expression qui produit une valeur de vérité à partir d'autres valeurs de vérité. Par exemple, une fonction logique peut comporter des variables logiques $`n`$. Pour chacune de ces combinaisons, la fonction peut prendre une valeur 0 ou 1. Nous obtenons donc $`2^n`$ combinaisons pour ces $`n`$ variables.
|
||||
|
||||
### Table de vérité
|
||||
|
||||
@@ -163,6 +162,36 @@ La table de vérité de l'opérateur OU :
|
||||
\end{aligned}
|
||||
```
|
||||
|
||||
### Portes Logiques de Base
|
||||
|
||||
Une porte logique est un dispositif qui effectue une opération logique sur un ou plusieurs signaux logiques produisant une sortie. Les portes logiques de base sont :
|
||||
|
||||
1. **Porte AND** : Cette porte a deux ou plusieurs entrées et une sortie. La sortie est vraie (1) si toutes les entrées sont vraies.
|
||||
|
||||
|
||||
|
||||
2. **Porte OR** : Cette porte a deux ou plusieurs entrées et une sortie. La sortie est vraie (1) si au moins une des entrées est vraie.
|
||||
|
||||
|
||||
|
||||
3. **Porte NOT** : Cette porte a une seule entrée et une sortie. La sortie est l'inverse de l'entrée. Si l'entrée est vraie (1), la sortie est fausse (0) et vice versa.
|
||||
|
||||
|
||||
|
||||
4. **Porte XOR (OU exclusif)** : Cette porte a deux entrées et une sortie. La sortie est vraie (1) si une, et seulement une, des entrées est vraie.
|
||||
|
||||
|
||||
|
||||
5. **Porte NAND (NON-ET)** : Cette porte a deux ou plusieurs entrées et une sortie. La sortie est fausse (0) uniquement si toutes les entrées sont vraies. C'est l'inverse de la porte AND.
|
||||
|
||||
|
||||
|
||||
6. **Porte NOR (NON-OU)** : Cette porte a deux ou plusieurs entrées et une sortie. La sortie est vraie (1) uniquement si toutes les entrées sont fausses. C'est l'inverse de la porte OR.
|
||||
|
||||
|
||||
|
||||
---------
|
||||
|
||||
### Algèbre de Boole
|
||||
|
||||
#### Définition
|
||||
@@ -196,13 +225,15 @@ S = 1 \text{ si} \left\{
|
||||
|
||||
$`S`$ s'écrit sous sa forme canonique : $`S= (\overline{a} \land b) \lor (\overline{a} \land \overline{b}) \lor (a \land \overline{b})`$
|
||||
|
||||
###
|
||||
--------------
|
||||
|
||||
## Exercices
|
||||
|
||||
### Établir des tables de vérité
|
||||
|
||||
**Travail à effectuer** : Écrire les tables de vérité des expressions booléennes suivantes :
|
||||
**Travail à effectuer** : Écrire les tables de vérité des expressions booléennes suivantes.
|
||||
|
||||
Conseil : essayez d'imaginer comment la lumière d'une maison pourrait être contrôlée par deux interrupteurs (a et b).
|
||||
|
||||
1. $`S(a, b) = \overline{a} \land b`$
|
||||
2. $`S(a, b) = b \lor (a \land b)`$
|
||||
@@ -241,3 +272,20 @@ Les __lois de De Morgan__ sont des identités entre propositions logiques. Elles
|
||||
|
||||
**Travail à effectuer** : Démontrer ces 2 lois.
|
||||
|
||||
----------
|
||||
|
||||
### Ressources supplémentaires
|
||||
|
||||
### NANDGAME
|
||||
|
||||
Si vous êtes intéressé par une approche pratique et interactive pour apprendre ces concepts, je vous recommande fortement de consulter [NANDGAME](http://nandgame.com/). Il s'agit d'un jeu en ligne gratuit où vous pouvez construire un ordinateur à partir de zéro en utilisant uniquement la porte logique NAND.
|
||||
|
||||
À travers une série de défis et d'énigmes, NANDGAME vous guidera à travers les concepts de base de la logique booléenne et vous montrera comment ces concepts peuvent être utilisés pour construire des structures plus complexes. En fin de compte, vous aurez une meilleure compréhension de la manière dont les ordinateurs fonctionnent au niveau le plus fondamental.
|
||||
|
||||
-----------
|
||||
|
||||
Auteurs : Florian Mathieu - Philippe Boddaert
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
|
||||
BIN
representation_base/chapitre_4/assets/bo.png
Normal file
BIN
representation_base/chapitre_4/assets/bo.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 184 KiB |
@@ -1,15 +1,14 @@
|
||||
# Mystère
|
||||
## Mystère
|
||||
|
||||
## Description
|
||||
### Description
|
||||
|
||||
L'idée de ce TP est de manipuler les expressions booléennes.
|
||||
|
||||
Pour cela, vous allez devoir programmer des fonctions booléennes.
|
||||
|
||||
A chaque fonction `mystere` suivante, sont données des doctests.
|
||||
Ces doctests correspondent aux valeurs des tables de vérités.
|
||||
A chaque fonction `mystere` suivante, sont données des doctests. Ces doctests correspondent aux valeurs des tables de vérités.
|
||||
|
||||
## Consignes
|
||||
### Consignes
|
||||
|
||||
Recopier le bloc de code suivant dans un fichier `mystere.py`
|
||||
|
||||
@@ -18,92 +17,125 @@ Vous devez écrire le corps de la fonction sous la forme d'une expression boolé
|
||||
```python
|
||||
def mystere1(a):
|
||||
'''
|
||||
>>> mystere1(True)
|
||||
False
|
||||
>>> mystere1(False)
|
||||
True
|
||||
Cette fonction renvoie l'inverse du paramètre a.
|
||||
|
||||
>>> mystere1(True)
|
||||
False
|
||||
>>> mystere1(False)
|
||||
True
|
||||
'''
|
||||
# Votre code ici.
|
||||
pass
|
||||
|
||||
def mystere2(a, b):
|
||||
'''
|
||||
>>> mystere2(True, True)
|
||||
True
|
||||
>>> mystere2(True, False)
|
||||
True
|
||||
>>> mystere2(False, True)
|
||||
True
|
||||
>>> mystere2(False, False)
|
||||
False
|
||||
Cette fonction renvoie True si au moins l'un des paramètres est True.
|
||||
|
||||
>>> mystere2(True, True)
|
||||
True
|
||||
>>> mystere2(True, False)
|
||||
True
|
||||
>>> mystere2(False, True)
|
||||
True
|
||||
>>> mystere2(False, False)
|
||||
False
|
||||
'''
|
||||
# Votre code ici.
|
||||
pass
|
||||
|
||||
def mystere3(a, b):
|
||||
'''
|
||||
>>> mystere3(True, True)
|
||||
False
|
||||
>>> mystere3(True, False)
|
||||
True
|
||||
>>> mystere3(False, True)
|
||||
True
|
||||
>>> mystere3(False, False)
|
||||
False
|
||||
Cette fonction renvoie True si les paramètres sont différents l'un de l'autre.
|
||||
|
||||
>>> mystere3(True, True)
|
||||
False
|
||||
>>> mystere3(True, False)
|
||||
True
|
||||
>>> mystere3(False, True)
|
||||
True
|
||||
>>> mystere3(False, False)
|
||||
False
|
||||
'''
|
||||
# Votre code ici.
|
||||
pass
|
||||
|
||||
def mystere4(a, b):
|
||||
'''
|
||||
>>> mystere4(True, True)
|
||||
False
|
||||
>>> mystere4(True, False)
|
||||
False
|
||||
>>> mystere4(False, True)
|
||||
False
|
||||
>>> mystere4(False, False)
|
||||
True
|
||||
Cette fonction renvoie True seulement si les deux paramètres sont False.
|
||||
|
||||
>>> mystere4(True, True)
|
||||
False
|
||||
>>> mystere4(True, False)
|
||||
False
|
||||
>>> mystere4(False, True)
|
||||
False
|
||||
>>> mystere4(False, False)
|
||||
True
|
||||
'''
|
||||
# Votre code ici.
|
||||
pass
|
||||
|
||||
def mystere5(a, b):
|
||||
'''
|
||||
>>> mystere5(True, True)
|
||||
True
|
||||
>>> mystere5(True, False)
|
||||
False
|
||||
>>> mystere5(False, True)
|
||||
False
|
||||
>>> mystere5(False, False)
|
||||
True
|
||||
Cette fonction est une équivalence, elle renvoie True si les deux paramètres ont la même valeur.
|
||||
|
||||
>>> mystere5(True, True)
|
||||
True
|
||||
>>> mystere5(True, False)
|
||||
False
|
||||
>>> mystere5(False, True)
|
||||
False
|
||||
>>> mystere5(False, False)
|
||||
True
|
||||
'''
|
||||
# Votre code ici.
|
||||
pass
|
||||
|
||||
def mystere6(a, b):
|
||||
'''
|
||||
>>> mystere6(True, True)
|
||||
False
|
||||
>>> mystere6(True, False)
|
||||
True
|
||||
>>> mystere6(False, True)
|
||||
False
|
||||
>>> mystere6(False, False)
|
||||
False
|
||||
Cette fonction renvoie True si le premier paramètre est True et le deuxième est False.
|
||||
|
||||
>>> mystere6(True, True)
|
||||
False
|
||||
>>> mystere6(True, False)
|
||||
True
|
||||
>>> mystere6(False, True)
|
||||
False
|
||||
>>> mystere6(False, False)
|
||||
False
|
||||
'''
|
||||
# Votre code ici.
|
||||
pass
|
||||
|
||||
def mystere7(a, b):
|
||||
'''
|
||||
>>> mystere7(True, True)
|
||||
False
|
||||
>>> mystere7(True, False)
|
||||
True
|
||||
>>> mystere7(False, True)
|
||||
False
|
||||
>>> mystere7(False, False)
|
||||
True
|
||||
Cette fonction renvoie True si le premier paramètre est False et le deuxième est True, ou si les deux paramètres sont False.
|
||||
|
||||
>>> mystere7(True, True)
|
||||
False
|
||||
>>> mystere7(True, False)
|
||||
True
|
||||
>>> mystere7(False, True)
|
||||
False
|
||||
>>> mystere7(False, False)
|
||||
True
|
||||
'''
|
||||
# Votre code ici.
|
||||
pass
|
||||
|
||||
if __name__ == '__main__':
|
||||
import doctest
|
||||
doctest.testmod(verbose=False)
|
||||
doctest.testmod(verbose=True)
|
||||
```
|
||||
|
||||
A la fin de ce TP, n'oubliez pas de vérifier que toutes les fonctions passent les doctests. Vous pouvez exécuter votre fichier Python en ligne de commande pour voir les résultats des tests. Si une fonction ne passe pas un doctest, revoyez votre logique booléenne pour cette fonction et essayez à nouveau.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Auteur : Florian Mathieu
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
Reference in New Issue
Block a user