Premier pas en Python

Premiers pas avec Python
Nous supposerons ici que Python est déjà installé et fonctionnel.
Dans la suite de ce document, nous indiquerons les commandes Python et le résultat donné par
l'interprète. Les commandes venant après les chevrons >>> sont les commandes tapées par
l'utilisateur. Le résultat donné par Python se lit alors sur la ligne suivante. Lorsque Python n'a rien à
renvoyer, la ligne est omise.
Variables et types simples
Premiers pas
On peut utiliser Python comme une calculatrice :
>>> 6 * 7
42
Les entiers en Python ne sont pas limités. Calculons 5 à la puissance 20 :
>>> 5 ** 20
9094947017729282379150390625L
(la lettre L affichée à la fin du résultat signifie simplement que l'entier est un entier « long », c'est-à-
dire trop grand pour être représenté par un mot machine, mais Python sait gérer ces entiers longs. Il
n'y a pas à se soucier de questions d'homogénéité, en cas d'opérations entre un entier standard et un
entier long, Python renvoie toujours un long).
Les opérateurs usuels sur les entiers sont : +, -, *. La précédence entre ces opérateurs est
standard : * est prioritaire sur + ou -.
>> 2 + 3 * 2
8
La division entière se note // et le reste dans la division euclidienne de a par b est noté a % b :
>>> 14 // 3
4
>>> 14 % 3
2
Distribué sous la licence CC BY-SA 3.0 FR Introduction à Python
http://creativecommons.org/licenses/by-sa/3.0/fr/ 1/23

On peut également manipuler des nombres à virgules (nombres flottants). Ici, comme pour les
entiers longs, la simple présence d'un unique flottant dans une expression indique à Python de tout
effectuer avec des nombres à virgules.
>>> 3.12 ** 2
9.7344000000000008
Notez qu'on obtient uniquement une valeur approchée. Notamment, un rationnel comme 1/33
n'existe qu'en tant qu'approximation :
>>> 1.0 / 33.0
0.030303030303030304
(Ici le 4 à la fin illustre bien le problème de l'approximation d'un réel par un flottant).
Si on veut utiliser des fonctions mathématiques, on doit les importer de la bibliothèque math.
Sinon, Python se vexe :
>>> sin(2.5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError : name 'sin' is not defined
sin n'est en effet pas défini par défaut.
>>> from math import sin
>>> sin(2.5)
0.59847214410395655
après importation de la fonction sin du module math, on peut l'utiliser.
Pour importer toutes les fonctions du module math :
>>> from math import *
>>> cos(2.5)
-0.8011436155469337
Notez qu'il y a une différence entre les entiers et les flottants. 42 est un entier
>>> type(42)
<type 'int'>
Mais 42.0 est un flottant :
>>> type(42.0)
<type 'float'>
Distribué sous la licence CC BY-SA 3.0 FR Introduction à Python
http://creativecommons.org/licenses/by-sa/3.0/fr/ 2/23

Il est possible de convertir un entier en flottant :
>>> float(42)
42.0
Et dans l'autre sens :
>>> int(42.4)
42
Attention : int ne calcule pas la partie entière mais arrondit vers 0. Autrement dit int(x) est la
partie entière de x si x est positif et l'opposé de la partie entière de |x| sinon :
>>> int(-42.4)
42
Pour plus de contrôle sur la conversion, on pourra utiliser les fonctions de troncature et d'arrondi.
floor pour la partie entière inférieure, ceil pour la partie entière supérieure et round pour un
arrondi.
>>> floor(42.4)
42.0
>>> ceil(42.4)
43.0
>>> round(42.4)
42.0
>>> round(42.6)
43.0
>>> int(round(42.6))
43
On pourra retrouver la définition de ces fonctions dans l'aide intégrée à Python. On y accède à l'aide
de la fonction help :
>>> help(ceil)
Help on built-in function ceil in module math:
ceil(...)
ceil(x)
Return the ceiling of x as a float.
This is the smallest integral value >= x.
Python convertit automatiquement les entiers en flottants quand cela est pertinent. Ainsi :
>>> from math import sqrt
>>> sqrt(2)
1.4142135623730951
donne la même chose que sqrt(2.0).
Distribué sous la licence CC BY-SA 3.0 FR Introduction à Python
http://creativecommons.org/licenses/by-sa/3.0/fr/ 3/23

Attention cependant au symbole / :
—en Python 2. X, s'il est appliqué à deux entiers, il dénote toujours la division entière, sinon, il
dénote la division en flottants ;
—en Python 3.X (ou en Python 2.7 avec le mode de compatibilité « __future__ »), il
dénote toujours la division en flottants, quels que soient les arguments.
Il est donc préférable d'utiliser // pour la division d'entiers et / pour la division en flottants.
On rappelle que pour qu'un calcul s'effectue en flottants, il suffit qu'un des opérandes soit flottant,
ainsi :
>>> ((1-4)+3*2)/2
1
>>> ((1.0-4)+3*2)/2
1.5
Définitions de variables
Affectation
Le symbole d'affectation pour donner une valeur à une variable est le symbole = :
>>> x = 42
Python ne répond rien : nos entrées précédentes étaient des expressions, qu'il a interprétées comme
des questions et il y a répondu. Ici, nous lui avons donné une instruction, il exécute l'ordre et se
contente d'affirmer qu'il est prêt en nous gratifiant de nouveau d'un
>>>
On peut alors lui demander la valeur de x :
>>> x
42
On peut affecter plusieurs variables simultanément :
>>> a, b = 17, 42
>>> a
17
>>> b
42
Distribué sous la licence CC BY-SA 3.0 FR Introduction à Python
http://creativecommons.org/licenses/by-sa/3.0/fr/ 4/23

L'affectation se fait en parallèle, ce qui est bien pratique pour échanger le contenu de deux
variables :
>>> b, a = a, b
>>> a
42
>>> b
17
Incrémentation
Pour ajouter une valeur (par exemple 3) à une variable, on peut faire comme dans les langages de
programmation classiques :
>>> x = 0
>>> x = x + 3
>>> x
3
Mais on peut aussi utiliser += (c'est la façon de faire idiomatique en Python) :
>>> x += 3
>>> x
6
On dispose de même de *=, -=, /= et //= :
>>> x *= 5
>>> x
30
>>> x -= 7
>>> x
23
Autres types simples
Les booléens
Les booléens, ou valeurs de vérité, peuvent prendre deux valeurs : True ou False. Les opérateurs
de comparaison (<, >, <=, >=) permettent comparer deux nombres :
>>> 17 < 42
True
>>> 17 > 42
False
Distribué sous la licence CC BY-SA 3.0 FR Introduction à Python
http://creativecommons.org/licenses/by-sa/3.0/fr/ 5/23