(prog1.types)=

# Les types

Dans tous les langages de programmation, un expression ou une variable appartient toujours à un type, ce qui détermine comment sa valeur est enregistrée en mémoire (espace de stockage, structure). En python, les principaux types de base sont les suivants :

- type `int` : les nombre entiers, par exemple 1, 493, -582
- type `float` : les nombres décimaux par exemple 5.7, 2.005
- type `str` : les chaînes de caractères, par exemple ’alpha’, "Bonjour"
- type `bool` : les booléens ou valeurs de vérité, soit True ou False

```{question}
Quelles valeurs sont de type `str` ?

{v}`'Ok'`  
{f}`99`  
{v}`'142'`  
{f}`True`       
```

```{question}
Quelles valeurs sont de type `int` ?

{f}`-1`  
{v}`0`  
{f}`4.5`      
{v}`'1000'`  

```

## Erreur de type
L'exécution d'un programme peut souvent donner lieu à une erreur de type, par exemple

`1 + "4"`

donne l'erreur suivante :

```python
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
```

En effet, l'opérateur + n'est pas défini entre un entier et une chaîne de caractères.

```{question}
Parmi les instructions suivantes, lesquelles donneront une erreur de type ?

{v}`45 + '12'`  
{f}`10/0`  
{f}`'Salut! ' + 'Ça va ?'`  
{v}`'ok' < 2`  
{f}`3 * '!'`  
{f}`5 / 3.2`  
{f}`True - False`  

```

## Opérateurs **, // et %
<span id="operateurs"></span>
L'opérateur `**` permet d'élever un nombre à une certaine puissance. Par exemple, 5² peut s'écrire `5 ** 2` en python.

Calculez 2 puissance 10 et stockez-le dans la variable `res`, puis exécutez le code!

```{codeplay}
:hints: Quel est l'opérateur pour élever à la puissance ?
:assertions: exact:1024; code:**

===
res = 
===
print(res)
```


En python, vous avez utilisez jusqu'à présent l'opérateur `/` pour faire une division. La réponse de cette division est un nombre réel. Néanmoins, il est parfois utile d'obtenir le résultat entier (arrondi à l'inférieur) de la division. Cela se fait avec l'opérateur ``//``.

Exemples :

    Division réelle : 9 / 4 donne 2.25
    Division entière : 9 // 4 donne 2, car on peut mettre 2 fois 4 dans 9.

```{question}
Combien font 26 // 7 ? 

{v}`3`  
{f}`3.7`  
{f}`3.7142857142857144`  
{f}`4`  
{f}`5`  

```

L'opérateur modulo, qui s'écrit en python, `%` sert à redonner le reste de la division entière. Par exemple, Si on divise de manière entière 13 par 3, cela donne 4 (4·3 = 12) et il reste 1 pour arriver à 13. Ainsi, 13 % 3 redonne 1.

```{question}
Combien font 20 % 6 ? 

{v}`2`  
{f}`3`  
{f}`3.3333333333333335`  
{f}`4`  
{f}`14`  

```

L'opérateur modulo peut servir par exemple à savoir si un nombre est pair ou impair. En effet, x modulo 2 fait 0 si x est pair, mais 1 si le nombre est impair.

```{question}
Sachant que `x % 2` est égal à 0, que peut-on dire de x? 

{f}`x est impair`  
{v}`x est pair`  
{f}`x est plus petit que 1`  
{v}`x est un multiple de 2`  
{f}`x est un nombre réel`

```