Florian/1ereNSI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ajout séquence fonctions booléennes

Browse Source
This commit is contained in:
Florian Mathieu
2023-07-03 17:54:40 +02:00
parent 02967d029f
commit 1ae2f22c46
9 changed files with 347 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
representation_base/chapitre_4/PYTHON.md
View File

@@ -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>.