Table des matières

Sujet précédent

3. Premier programme en Python

Sujet suivant

5. Instructions d’entrées/sorties

4. Expressions

Dans cette partie, nous utiliserons l’interpréteur Python pour présenter les éléments fondamentaux du langage : valeur, type, variable, expression.

Avant de commencer, vérifiez que vous avez une invite de commande semblable à celle-ci :

Python 3.4.0 (default, Mar 17 2014, 23:20:09)
[GCC 4.8.2 20140206 (prerelease)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Assurez-vous que l’invite de commande commence bien par “Python 3” (et non “Python 2”).

Nous allons travailler en mode intéractif. L’invite de commande principale est représentée par >>>. Pour une commande sur plusieurs lignes, l’invite de commande des lignes suivantes sera ....

Un certain nombre d’erreurs courantes sont expliquées à la fin de ce chapitre.

4.1. Valeur, type, variable...

4.1.1. Valeur

Tout d’abord Python permet de gérer des valeurs telles que des entiers (18, -5, 0, etc), des réels (3.1415, -1.25, 5e-6, etc.), des chaînes de caractères (entre guillements "exemple" ou apostrophes 'exemple').

Quand on tape une valeur à l’invite de l’interprète Python, il affiche la valeur.

>>> 18
18
>>> -1.25
-1.25
>>> 1e-2
0.01
>>> "exemple"
'exemple'

4.1.2. Type

Python est un langage typé dynamiquement. Ceci signifie que chaque valeur a un type. On obtient le type d’une expression, d’une valeur en particulier avec la fonction type.

>>> type(18)
<class 'int'>
>>> type(1e-2)
<class 'float'>
>>> type(-1.25)
<class 'float'>
>>> type("exemple")
<class 'str'>

La définition généralement utilisé d’un type comporte deux parties. Un type définit un ensemble de valeur et les opérateurs (et fonctions) que l’on peut leur appliquer.

Par exemple, la division entière se note // en Python.

>>> 11 // 4         # division entière sur les entiers
2
>>> 11 // 4.0       # division entière sur les réels
2.0
>>> 11 / 4          # divison sur les réels (résultat réel)
2.75

4.1.3. Variable

Une variable permet d’associer un nom à une valeur et de retrouver cette valeur grâce à ce nom. Pour créer (ou déclarer, ou définir) une variable, il suffit d’affecter son nom avec une valeur. Par exemple, age = 42 consiste à définir une variable nommé age dont la valeur associée est 42.

>>> age = 42

Pour accéder à cette valeur, il suffit d’utiliser le nom de la variable.

>>> age
42

4.1.4. Affectation

L’affectation est une instruction qui permet de changer la valeur stockée dans une variable. Elle est noteé avec le signe =.

>>> age
42
>>> age = age + 1   # une année passe
>>> age
43

L’instruction age = age + 1 peut paraître surprenante. Il faut bien comprendre que = correspond ici à une affectation et non à un test d’égalité. L’instruction d’affectation s’évalue ainsi :

  1. La partie à droite de l’affectation est évaluée et donne une valeur
  2. Cette valeur est stockée dans la variable (associée à la variable)

Ici, on commence donc à évaluer age + 1 qui donne la valeur 43. Cette valeur est ensuite stockée dans age (qui contient donc 43).

4.1.5. Type d’une variable

Définition : Le type d’une variable est le type de la valeur qu’elle contient. Ainsi, le type d’une variable peut changer lors de l’éxécution d’un programme.

>>> age = 42
>>> type(age)
<class 'int'>
>>> age = 6.5       # J'ai six ans et demi
>>> type(age)
<class 'float'>

Conseil : En général, il est déconseillé de stocker des valeurs de types différents dans une même variable. Si le type change, c’est certainement qu’utiliser plusieurs variables seraient une meilleure solution.

Remarque : Dans un langage typé statiquement, on définit le type d’une variable au moment de sa déclaration et seule des variables compatibles avec ce type peuvent être stockées dans la variable. Ceci permet au compilateur de détecter des erreurs dans les programmes. L’exemple ci-dessus le type de déclaration de la variable serait réel est l’entier 42 serait convertit dans le réel 42.0.

Dans l’exemple de l’age ci-dessous, on a deux types différents mais proches : ce sont des nombres. Dans un langage typé statiquement, on aura déclarée la variable age du type float qui est plus large que int et il y a généralement conversion automatique des entiers vers les réels.

4.2. Types de base et opérateurs associés

Python dispose d’un certain nombre de types de base. Nous allons en étudier cinq fondamentaux : les booléens, les nombres entiers, les nombres à virgule flottante, les nombres complexes et les chaînes de caractères.

4.2.1. Booléens

4.2.1.1. Le type bool

Un booléen est un type de variable à deux états. En programmation, il s’agira généralement de “vrai” et “faux”. En Python, ils sont respectivement notés True et False.

>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>

4.2.1.2. Le “ou” logique (la disjonction)

La disjonction est réalisée par l’opérateur or.

>>> False or False or True
True

4.2.1.3. Le “et” logique (la conjonction)

La conjonction est réalisée par l’opérateur and.

>>> True and (False or True)
True

4.2.1.4. Le “non” logique (la négation)

La négation est réalisée par l’opérateur not.

>>> (not True) or (not False)
True

4.2.2. Entiers

4.2.2.1. Le type int

En Python, les nombres entiers (dans Z), ont le type int (pour integers). Contrairement à beaucoup d’autres languages, les entiers en Python ont une taille infinie, c’est-à-dire qu’en interne, Python choisira la représentation adaptée, permettant à l’utilisateur de lui faire manipuler des entiers quelle que soit leur taille.

>>> type(1)
<class 'int'>
>>> type(-6)
<class 'int'>
>>> 2 ** 222
6739986666787659948666753771754907668409286105635143120275902562304

(L’opérateur ** est l’élévation à la puissance)

4.2.2.2. Les différentes bases

Il est très facile d’écrire des littéraux entiers en base 2, 8 ou 16. Il suffit pour cela de préfixer la valeur respectivement par 0b, 0o ou 0x.

>>> 10
10
>>> 0x10
16
>>> 0b10
2
>>> 0o10
8

4.2.2.3. L’addition

>>> 23 + 56
79

4.2.2.4. La soustraction

>>> 34 - 278
-244

4.2.2.5. L’opposé

>>> a = 5
>>> - a
-5

4.2.2.6. La multiplication

>>> 2 * 78
156

4.2.2.7. La division

>>> 3 / 5
0.6
>>> 8 / 5
1.6
>>> 10 / 5
2.0
>>> type(10 / 5)
<class 'float'>

Attention : vous noterez que le type du résultat d’une division avec / sera toujours de type float (voir ci-dessous), même si la division a un reste nul.

4.2.2.8. La division entière (division Euclidienne)

>>> 3 // 5
0
>>> 8 // 5
1
>>> 10 // 5
2
>>> -5 // 2
-3

Attention : le résultat est toujours arrondi vers \(-\infty\).

4.2.2.9. Le reste de la division entière (modulo)

>>> 23 % 5
3

4.2.2.10. La valeur absolue

>>> abs(-45)
45

4.2.2.11. L’élévation à une puissance

>>> 2 ** 8
256
>>> pow(2,8)
256
>>> 0 ** 0
1

Python défini : \(0^0 = 1\).

4.2.3. Flottants

4.2.3.1. Le type float

En Python, les nombres à virgule flottante ont le type float.

>>> type(1.0)
<class 'float'>
>>> 2.56e-7   # écriture scientifique
2.56e-07

Pour plus d’information sur les nombres à virgule flottante, se reporter au chapitre “Représentation des nombres”.

4.2.3.2. L’addition

>>> 1.2 + 6.576557
7.776557

4.2.3.3. La soustraction

>>> 2.456 - 6.0
-3.544

4.2.3.4. L’opposé

>>> - (- 2.8)
2.8

4.2.3.5. La multiplication

>>> 1.3 * 4.89
6.357

4.2.3.6. La division

>>> 10.0 / 2.0
5.0
>>> 10.0 / 3.0
3.3333333333333335

4.2.3.7. La division entière (division Euclidienne)

>>> 10.0 // 2.0
5.0
>>> 10.0 // 3.0
3.0
>>> -5.4 // 2.2
-3.0

Attention : le résultat est toujours arrondi vers \(-\infty\).

4.2.3.8. Le reste de la division entière (modulo)

>>> 10.0 % 2.0
0.0
>>> 10.0 % 3.0
1.0

4.2.3.9. La valeur absolue

>>> abs(- 3.89)
3.89

4.2.3.10. L’élévation à une puissance

>>> 1.2 ** 3.67
1.952518569734174
>>> pow(1.2, 3.67)
1.952518569734174
>>> 0.0 ** 0.0
1.0

Python défini : \(0^0 = 1\).

4.2.4. Les nombres complexes

4.2.4.1. Le type complex

Il existe deux manières de définir des nombres complexes : soit en utilisant le suffixe j ou le suffixe J directement après un nombre, soit en utilisant la fonction complex(re, im).

>>> type(2+3j)
<class 'complex'>
>>> type(4J)
<class 'complex'>
>>> complex(3,-6)
(3-6j)
>>> type(2)
<class 'int'>
>>> type(2+0j)
<class 'complex'>

4.2.4.2. L’addition, la soustraction, l’opposé, la multiplication, la division, l’élévation à une puissance

Similaires à int et float.

>>> (2+6j) / (2-4j)
(-1+1j)
>>> (1+1j) * 2
(2+2j)
>>> (1+1j) ** (2j)
(0.15990905692806806+0.13282699942462056j)

Remarque : la division entière et le modulo ne sont pas défini sur les complexes.

4.2.4.3. Les parties réelle et imaginaire

>>> (2+3j).real
2.0
>>> a = 2 + 7j
>>> a.real
2.0
>>> a.imag
7.0

Remarque : Les parties réelle et imaginaire de nombres complexes seront retournées avec le type float.

4.2.4.4. Le conjugé

>>> (2 + 7j).conjugate()
(2-7j)

4.2.4.5. Le module

>>> abs(5j)
5.0
>>> abs(1+1j)
1.4142135623730951

Remarque : Le module sera toujours un float.

4.2.5. Chaînes de caractères

4.2.5.1. Le type str

Pour écrire une chaîne de caractères, il faut l’écrire entre deux ' ou deux ".

>>> type('b')
<class 'str'>
>>> type('bonjour')
<class 'str'>
>>> type("test")
<class 'str'>

Astuce : Pour écrire une chaîne de caractère contenant ", préférez ', et inversement. Sinon, il est toujours possible d’échapper le caractère avec le caractère \.

>>> "Cette chaîne contient plusieurs symboles : \", `, ', ^, ..."
'Cette chaîne contient plusieurs symboles : ", `, \', ^, ...'

4.2.5.2. Longeur d’une chaîne de caractères

>>> len('test')
4

4.2.5.3. Lecture d’un nombre dans une chaîne de caractères en nombre

>>> int('  0034')
34
>>> float('00.7800')
0.78

4.2.5.4. Concaténation de deux chaînes de caractères

>>> 'bonjour ' + 'monsieur'
'bonjour monsieur'

4.2.5.5. Sous-chaîne d’une chaîne de caractères

Pour une chaîne ch, ch[i,j] donne accès à la sous-chaîne contenant les caractères \(i\) (inclu) à \(j\) (exclu) de ch. (Comme dans un grand nombre de language de programmation, les indices commencent à 0.)

>>> ch = '0123456789'
>>> ab = ch[3:8]
>>> ab
'34567'

4.2.5.6. Obtention d’une représentation textuelle de la value d’une expression

4.2.5.6.1. Représentation lisible
>>> str(34 * 8)
'272'
>>> str("a\"b")
'a"b'
4.2.5.6.2. Représentation canonique (non ambigüe)
>>> repr(4+7j)
'(4+7j)'
>>> repr("a\"b")
'\'a"b\''

4.2.6. Conversion de type sur les nombres

4.2.6.1. Convertir explicitement un entier en flottant

>>> float(3)
3.0

4.2.6.2. Convertir explicitement un flottant en entier (arrondis)

>>> int(2.56)
2

Attention : il est fortement recommandé de ne pas utiliser cette fonction dont le comportement est mal défini, mais plutôt une des fonctions suivantes :

  • math.floor(x) : le plus grand entier inférieur ou égal à x
  • math.ceil(x) : le plus petit entier supérieur ou égal à x
  • math.trunc(x) : la troncature de x
>>> import math
>>> math.floor(2.78)
2
>>> math.floor(-2.78)
-3
>>> math.ceil(2.78)
3
>>> math.ceil(-2.78)
-2
>>> math.trunc(2.78)
2
>>> math.trunc(-2.78)
-2

4.2.6.3. Conversion implicite

Si un opérateur arithmétique binaire est utilisé avec des opérandes de types différents, Python va automatiquement convertir l’opérande dont le type est plus “étroit” vers le type le plus “large”.

int est plus étroit que float

float est plus étroit que complex

On peut alors effectuer des calculs en mélangeant les types des opérandes :

>>> 4 + 3.1 + (2-6j)
(9.1-6j)

Attention : il est important de bien être conscient de ces conversions de type, afin de bien comprendre quelles opérations seront réellement effectuées.

4.2.7. Comparaison

En Python, on retrouve les opérateurs de comparaison classiques :

Opérateur Signification
< strictement inférieur à
<= inférieur ou égal à
> strictement supérieur à
>= supérieur ou égal à
== égal à
!= différent de

Ces opérateurs de comparaison ne sont pas disponibles sur les complexes, car le type complex est considéré non ordonnable. Par contre, l’orde lexicographique est défini sur les chaînes de caractères.

>>> 3 >= 26
False
>>> 2.78 > 2
True
>>> 'aac' < 'aaf'
True
>>> 'aac' < 'aa'
False

4.3. Évaluation

>>> 4 - 5 ** 6
-15621
>>> 4 - (5 ** 6)
-15621
>>> (4 - 5) ** 6
1

4.3.1. Priorité opérateurs

Opérateurs, classés par priorité. Le plus prioritaire en haut.

  • **
  • - (opposé)
  • *, /, //, %
  • +, - (soustraction)
  • <, <=, >, >=, !=, ==
  • not
  • and
  • or

4.4. Obtenir de l’aide dans l’interpréteur

Aide sur un module :

>>> help('math')
Help on module math:

NAME
    math

DESCRIPTION
    This module is always available.  It provides access to the
    mathematical functions defined by the C standard.

FUNCTIONS
    acos(...)
        acos(x)

        Return the arc cosine (measured in radians) of x.

    acosh(...)
        acosh(x)

        Return the hyperbolic arc cosine (measured in radians) of x.

...

Aide sur une fonction :

>>> help('math.cos')
Help on built-in function cos in math:

math.cos = cos(...)
    cos(x)

    Return the cosine of x (measured in radians).

4.5. Messages d’erreur

4.5.1. SyntaxError

>>> 3 *
  File "<stdin>", line 1
    3 *
      ^
SyntaxError: invalid syntax

Nous avons fait une erreur de syntaxe, c’est-à-dire que l’instruction que nous avons entrée ne respecte pas la grammaire du langage. En effet, ici, l’opérateur * est binaire (il a deux arguments).

4.5.2. NameError

>>> xxx + 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'xxx' is not defined

Cette erreur signifie que le nom xxx n’est pas défini.

>>> math.floor(6.7)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'math' is not defined

Ici, l’interpréteur nous indique qu’il ne connait pas math. Nous cherchons à utiliser la fonction math.floor() du module math, mais nous n’avons pas importé ce module, Python ne le connait donc pas encore. Pour corriger l’erreur, il faut donc dans un premier temps importer ce module comme suit :

>>> import math
>>> math.floor(6.7)
6

Une fois que le module est importé, nous pouvons nous en servir. Une seule importation par session suffit.

4.5.3. AttributeError

>>> import math
>>> math.flor(3.89)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'flor'

L’interpréteur indique qu’il n’existe pas d’élément nommé flor dans ce module. En effet, le nom correct est math.floor().