Aller au contenu

Types et expressions en Python

Dans ce chapitre, nous allons voir un peu plus en détails 4 types que Python nous permet de manipuler, et les expressions, qui combinent des valeurs.

  • Les entiers, int, qui représentent des valeurs entières. (ex : 10, -30)
  • Les flottants, float, qui représentent des valeurs décimales. (ex : 120.3, 0.5)
  • Les Chaînes de caractères, str, qui représentent du texte. (ex : "texte")
  • Les booléens, bool, qui représentent une valeur qui est soit "vrai" (True), soit "faux" (Faux).

Nous allons voir des opérations sur les différents types. Elle seront présentées dans un tableau de cette forme :

Opérateur Usage Explication Exemples
  • Opérateur est l'opérateur utilisé pour effectuer l'opération.
  • Usage est une vision schématique de la façon de représenter comment l'opérateur s'utilise, et quelle valeur il produit, du point de vue des types. Par exemple int + int -> int veut dire "additionner deux entiers produit un entier". Attention, ce n'est pas du Python !
  • Une explication en français de ce que produit l'opération
  • Quelques exemples en Python de l'usage et du résultat, par exemple 10 + 2 vaut 12.

N'essayez pas d'apprendre par coeur ce chapite, lisez ce chapitre puis continuez le cours. Revenez ici quand vous aurez besoin de ces info au moment pendant la pratique, vous apprendrez sans vous en rendre compte !

Les entiers

Les entiers sont les nombres entier relatifs. On les désignera par int quand on aura besoin d'être concis. On crée un entier en utilisant uniquement des chiffres : 

a = 1000

Voici une partie des opérations supportées par les entiers :

Opérateur Usage Explication Exemples
+ int + int -> int Addition 10 + 2 vaut 12
- int - int -> int Soustraction 10 - 2 vaut 8
* int * int -> int Multiplication 10 * 2 vaut 12
// int // int -> int Division entière (avec reste) 11 // 2 vaut 5
% int % int -> int Module (reste division entière) 11 % 2 vaut 1
/ int / int -> float Division, produit un flottant 11 / 2 vaut5.5`
** int ** int -> int Elévation à la puissance 10 ** 2 vaut100`

Les flottants

Les flottants représentent des nombres décimaux. On les appelera parfois float pour la concision. On crée un flottant en utilisant des chiffres, séparés par un point, qui représente la virgule décimale ..

a = 1.2
b = 0.32

Voici une partie des opérations supportées par les flottants :

Opérateur Usage Explication Exemples
+ float + float -> float Addition 10.0 + 2.5 vaut 12.5
- float - float -> float Soustraction 10.0 - 2.5 vaut 7.5
* float * float -> float Multiplication 10.5 * 2.0 vaut 21.0
/ float / float -> float Division 10.5 / 2.0 vaut 5.25
** float ** float -> float Elévation à la puissance 10.0 ** 2.0 vaut 100.0

Dans une opération, on peut mixer des flottants et des entiers. Dans ce cas là, le résultat sera flottant :

  • 1.0 + 1 vaut 2.0
  • 1.0 * 2 vaut 2.0

Les chaînes de caractères

Les chaînes de caractères représentent du texte. On les appelera parfois str ou string pour la concision. On crée une chaîne de caractère en encadrant du texte avec des guillemets ou des apostrophes (en anglais simple quotes et double quotes).

a = "guillements"
b = 'apostrophes'

Si on veut une chaîne qui contient des guillemets, on peut utiliser des apostrophes pour encadrer, et vice versa : 

guillemet = 'voici un guillement :" '
apostrophe = "voici une apostrophe :' "
print(guillemet)
print(apostrophe)

voici un guillement :"
voici une apostrophe :'

Alternativement, on peut utiliser le caractère d'échappement, \, qui permet de dire que le caractère qui le suit fait partie de la chaîne et non du code: 

echappement = 'J\'échappe l\'apostrophe'
print(echappement)

J'échappe l'apostrophe

Il existe aussi des caractères spéciaux, qui permettent par exemple de faire des tabulations \t ou des retours à la ligne \n:

print("\tCette chaine est tabulée")
print("mais pas celle-ci")
print("retour à la ligne dans 3, 2, 1\nVoilà !")

    Cette chaine est tabulée
mais pas celle-ci
retour à la ligne dans 3, 2, 1
Voilà !

Finalement, si on doit rentrer du texte très long, on peut utiliser des chaines de caractères multilignes, qui se font en triplant les apostrophes ou les guillements.

a = """Ceci est une chaine
qui
    est
        sur
            plusieurs
                lignes.
Pratique, non ?"""
print(a)

Ceci est une chaine
qui
    est
        sur
            plusieurs
                lignes.
Pratique, non ?

Voici une partie des opérations supportées par les chaînes de caractères :

Opérateur Usage Explication Exemples
+ str + str -> str Concaténation, met deux chaînes bout à bout "a" + "b" vaut "ab"
* str - int -> str Répétition "ab" * 3 vaut "ababab"

Remarque, on peut créer une chaine vide, sans aucun caractère, avec deux guilemets ou apostrophes successifs :

a = ""
print("Ci dessous, une chaîne vide...")
print(a)
print("Ci dessus, une chaîne vide...")

Ci dessous, une chaîne vide...

Ci dessus, une chaîne vide...

Booléens

Les booléens, bool par concision, n'ont que deux valeurs possibles, vrai (True), et faux (False). On crée un booléen avec une des deux valeurs.

vrai = True
faux = False

Voici une partie des opérations supportées par les booléens :

Opérateur Usage Explication Exemples
and bool and bool -> bool ET logique. Vaut True si les deux valeurs vaut True True and False vaut "False". True and True vaut True. False and False vaut False
or bool or bool -> bool OU logique. Vaut True si une des deux valeus vaut True True or False vaut "True". True or True vaut True. False and False or False

Il existe également un opérateur unaire (qui n'agit que sur une seule valeur et pas deux), not, le NON logique, qui vaut la valeur inverse du booléen. not True vaut False. not False vaut True.

Comparaisons

En plus d'opérations de calcul, nous pouvons aussi comparer des valeurs entre elles, à l'aide d'opérateurs de comparaison. Tous les opérateurs de comparaison produisent une valeur booléenne, ils sont au nombre de 6.

Opérateur Description
== Egalité
!= Inégalité
< Infériorité stricte
> Supériorité stricte
<= Infériorité
>= Supériorité

Le résultat de ces opérateurs dépends du type des ses opérandes a et b.

A noter qu'il y a de nombreuses autres possibilités, ne sont détaillées ici que celles que nous utiliserons.

Opérateur d'égalité a == b

a et b sont Vaut True si Exemple
int ou float a et b ont la même valeur numérique 1.0 == 1 vaut True. 1.0 == 2 vaut False. 2==3 vaut False.
str a et b sont identiques "aa" == "aa" vaut True. "aa" == "ab" vaut False.

Opérateur d'inégalité a != b

a et b sont Vaut True si Exemple
int ou float a et b ont des valeurs numériques différentes 1.0 != 1 vaut False. 1.0 != 2 vaut True. 2 != 3 vaut True.
str a et b sont différentes "aa" != "aa" vaut False. "aa" != "ab" vaut False.

Opérateur d'infériorité stricte a < b

a et b sont Vaut True si Exemple
int ou float a a une valeur numérique strictement inférieure à celle de b 1.0 < 1 vaut False. 1.0 < 2 vaut True. 3 < 2 vaut False.
str a est avant b dans l'ordre alphabétique "aa" < "aa" vaut False. "aac" < "ab" vaut True. "abc" < "aa" vaut False.

Opérateur de supériorité stricte a > b

a et b sont Vaut True si Exemple
int ou float a a une valeur numérique strictement supérieure à celle de b 1.0 > 1 vaut False. 1 > 2 vaut False. 3 > 2.0 vaut True.
str a est après b dans l'ordre alphabétique "aa" > "aa" vaut False. "aac" > "ab" vaut False. "abc" > "aa" vaut True.

Opérateur d'infériorité a <= b

a et b sont Vaut True si Exemple
int ou float a a une valeur numérique inférieure ou égale à celle de b 1.0 <= 1 vaut True. 1.0 <= 2 vaut True. 3 <= 2 vaut False.
str a est avant b dans l'ordre alphabétique, ou a et b sont identiques "aa" <= "aa" vaut True. "aac" <= "ab" vaut True. "abc" <= "aa" vaut False.

Opérateur de supériorité a >= b

a et b sont Vaut True si Exemple
int ou float a a une valeur numérique supérieure ou égale à celle de b 1.0 >= 1 vaut True. 1 >= 2 vaut False. 3 >= 2.0 vaut True.
str a est après b dans l'ordre alphabétique, ou a et b sont identiques "aa" >= "aa" vaut True. "aac" >= "ab" vaut False. "abc" >= "aa" vaut True.

Transtypage

Parfois, on veut pouvoir convertir une valeur d'un type vers une valeurs equivalente, mais d'un autre type. Par exemple, si on demande à l'utilisateur de rentrer un nombre, input nous renvoie une chaîne de caractère qui représente le nombre, que l'on voudra transformer en un entier ou un flottant. Cette opération s'appelle le transtypage. Elle est parfois appelé conversion. En anglais, le transtypage est appelé transtyping ou type casting.

En python, d'une manière générale, pour convertir une valeur d'un type vers un autre, on utilise cette syntaxe : 

type(valeur)

Essayons ça pour transformer la chaîne en entier (int) dans le programme que nous avions fait. Celui ci, vous vous rappelez ? 

a = input("a : ")
res = a + 1
print(res)

Avec la conversion, ça donne ça : 

a = input("a : ")
res = int(a) + 1
print(res)
Et ça marche ! 

a : 1
2

Remarque : si on rentre une chaîne qui ne représente pas un entier, la conversion échouera et finira en erreur. 

a : un
Traceback (most recent call last):
  File "/home/felix/erreur.py", line 2, in <module>
    res = int(a) + 1
ValueError: invalid literal for int() with base 10: 'un'

Dans quelques chapitres nous verrons comment traiter ce genre de cas.

Parfois Python fais des conversions automatiquement, qu'on appelle conversions implicites. Par exemple, une chaîne est automatiquement convertie en booléen si elle est opérande d'un opérateur booléen.

print("chaine" or False)

True

Ce tableau récapitule quelques unes des conversions automatiques que fait Python :

De Vers Résultat
int bool False si l'entier est égal à zéro, True sinon
str bool False si la chaîne est vide (""), True sinon

Imprécision des flottants

Il est important de noter que la représentation des flottants dans la mémoire de la machine fait qu'ils sont parfois légèrement différents de la valeur à laquelle on s'attends : ce ne sont que des approximations.

Quand Python affiche un flottant avec print, il fait un arrondi pour plus de lisibilité, et donc on ne voit pas cette imprécision. 

print(0.1)

0.1

Le code suivant affiche la valeur exacte du flottant 0.1 tel qu'il est stocké dans la mémoire : 

print(format(0.1, '.60g'))

0.1000000000000000055511151231257827021181583404541015625

Cette erreur de précision peut créer des problèmes quand on fait des calculs et qu'on veut comparer des valeurs.

Le code suivant : 

a = 0.2 * 0.1
print(a == 0.02)

affiche 

False

C'est surprenant, et il faut s'en rappeler : à part pour de très rare cas, tester l'égalité ou l'inégalité entre deux flottants conduira à une erreur, et il vaut mieux tester un encadrement:

a = 0.2 * 0.1
p = 0.001 #la précision que l'on veut avoir dans l'égalité
print(0.02 - p < a < 0.02 + p) #python nous autorise à écrire a < b < c pour tester si a est compris entre b et c.
affiche 
True

Connaître le type d'une valeur

L'opérateur type permet produit une chaîne de caractère qui renvoie le type d'une valeur : 

print(type(1))
print(type(1.0))
print(type("un"))
print(type(True))

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

Sauf dans de rare cas, tester le type d'une valeur dans le code est une mauvaise pratique. En revanche, afficher le type d'une valeur peut aider au debogage dans certains cas.

Expressions

Nous l'avons déjà dit, une expression est un bout de code qui est évalué à une valeur. Être évalué veut dire que quand on rencontre notre expression dans le code, elle est substitué par la valeur qu'elle vaut.

Dans le code suivant : 

a = 2 + 3

2 + 3 est une expression, qui sera évaluée à 5. Donc la valeur que recevra la variable a sera 5. D'ailleurs, 5 est aussi une expression. En fait, tout ce qui peut donner lieu à une valeur est une expression. Par exemple, dans une expression, le nom d'une variable sera évalué à la valeur contenue dans la variable.

a = 5
b = a + 2

Ici, dans l'expression a+2, Python va d'abord évaluer a, la valeur stockée dans a est 5. Donc après une étape, l'expression sera 5 + 2. L'opération + sera alors évaluée, et l'expression vaudra 7. Donc b recevra la valeur 7.

La précédence des opérateurs

On appelle la précédence des opérateurs l'ordre dans lequel les opérateurs sont évalués dans une expression.

Par exemple, dans l'expression 

2 + 3 * 4

3 * 4 est évaluée en premier, ce qui donne : 

2 + 3 * 4 = 2 + 12 = 14

On peut parenthéser, comme en maths, pour choisir quel opérateur sera évalué en premier

(2 + 3) * 4 = 5 * 4 = 20

Plus la précédence d'un opérateur est élévé, et plus il est évalué en priorité. Voilà la liste des opérateurs que nous avons vus, classés par précédence décroissante1 :

Préc. max
()
**
* / // %
+ -
< > >= <= != == <>
not
and
or
Prec. min

Quand deux opérateur ont une précédence égale, on considérera que l'odre d'évaluation est arbitraire. En général, ça n'a pas d'importance, parce que ce sont des opérateur qui ont des effets similaires ((2 * 3) / 5 est égal à 2 * (3/ 5)). Si on veut fixer l'ordre dans ce cas, on utilise des parenthèses.

Nous verrons d'autres opérateurs au long de ce cours.

Exercices

Dans les exercices, quand des nombres de lignes sont données, vous pouvez de faire autant ou moins, mais ce n'est pas obligatoire. N'essayez pas de faire le code le plus court possible, mais du code compréhensible, en particulier pour vous.

Si vous allez voir la solution, pensez bien à CORRIGER votre code (eventuellement sans regarder la solution) à la main jusqu'à ce qu'il marche, ne vous contentez pas de juste lire la solution et de passer à autre chose.

Complétez le code suivant : 

a = input("Entrez du texte : ")
#completez ici (1 ligne)
print(s)
pour obtenir exactement cette sortie : 
Entrez du texte : du texte
la variable a contient du texte

  • L'opérateur de concaténation est +
  • N'oubliez pas d'ajouter un espace !
a = input("Entrez du texte : ")
s = "la variable a contient " + a
print(s)

Ecrivez un programme (3 lignes) qui :

  • Demande un nombre à l'utilisateur (entier ou flottant, vous avez le choix)
  • Demande une chaîne à l'utilisateur
  • Affiche la chaîne et le nombre + 1 sur la même ligne.

Exemple de sortie possible : 

Nombre ? 10
Chaine ? python
python 11

  • Il vous faudra convertir le nombre en chaîne à l'aide de str(nombre)
  • Puis concaténer les chaines avant de les afficher
  • N'oubliez pas les espaces ! 
nombre = int(input("Nombre ? "))
nombre = nombre + 1
chaine = input("Chaines ? ")
nb_str = str(nombre)
res = chaine + " " + nb_str
print(res)

nb = int(input("Nombre ? "))
ch = input("Chaine ? ") #n'appelez JAMAIS une variable "str", c'est un mot réservé ! 
print(chaine + " " + str(nb + 1))

Les essentiels

Au Programme

En Python et dans la plupart des langages de programmation, les valeurs sont typées. Le type d'une valeur définit ce que la valeur réprésente, et les opérations que l'on peut faire dessus.

Par exemple, additionner deux entiers a du sens, mais ajouter un entier et un texte n'a pas de sens.

Les types permettent de faire des vérifications automatiques, et donc de détecter des erreurs d'inatention.

On a pour le moment vu 4 types

  • Les entiers, int, qui correspondent aux nombres entiers relatifs
  • Les flottants, float, qui correspondent aux nombres réels
  • Les booléens, bool, qui peuvent prendre uniquement deux valeurs, True et False.
  • Les chaînes de caractères, str, qui correspondent à du texte.

Les types supportent des opérations sous forme d'opérateurs. Voir le cours pour les opérateurs supportés par chaque type. Voici les principaux :

opérateur types opération
+ int, float addition
+ str concaténation (mise bout à bout)
- int, float soustraction
* int, float multiplication
/ int, float division, resultat type float
// int, int division entière
and bool ET logique
or bool OU logique
not bool NON logique

Combiner les valeur avec des opérateurs donne des expressions. Une expression est évaluée à l'execution pour connaître sa valeur.

Exemple d'expression : 

20 - 4 + 3

On peut utiliser des variables dans une expression, la variable sera alors remplacée par sa valeur au moment de l'évaluation. En général, partout où on utilise des valeurs, on peut utiliser des expressions.

a = 20 - 4

L'ordre d'évaluation des opérations d'une expression s'effectue dans un ordre précis. L'ordre est d'une manière générale similaire à l'ordre que l'on retrouve en mathématique, c'est à dire d'abord l'addition et la division, puis l'addition et la soustraction.

  1. https://pythongeeks.org/python-operator-precedence/ ↩