Introduction à Python

Définition #

Calculer avec Python #

Python présente la particularité de pouvoir être utilisé de plusieurs manières différentes. Il est possible de l'utiliser en mode interactif, c'est-à-dire pouvoir dialoguer avec lui directement depuis le clavier. Cela nous permettra de découvrir très rapidement un grand nombre de fonctionnalités du langage. Il est également possible de créer nos premiers programmes (scripts) et les sauvegarder sur disque.

Par exemple, il est possible d'utiliser l'interpréteur comme une simple calculatrice de bureau.

>>> 2+3
5
>>> 5 - 8  # les espaces sont optionnels
-3
>>> 5 + 6 * 2
17
>>> 10/3     # division réelle
3.3333333333333335
>>> 10//3    # division entière
3
>>> 10%3     # reste de la division entière
1

Les opérateurs arithmétiques

Les variables #

Une variable apparaît dans un langage de programmation sous un nom_de_variable qui, pour l'ordinateur, s'agit d'une référence désignant une adresse mémoire, c'est-à-dire un emplacement précis dans la mémoire vive. À cet emplacement est stockée une valeur bien déterminée.

Pour distinguer les divers contenus possibles d'une variable, le langage de programmation fait usage de différents types de variables (le type entier, le type réel, le type chaîne de caractères, le type liste, etc.).

Les types immutables #

Les variables de type immutable ne peuvent pas être modifiées. Python définit les types immutables suivants :

• bool : un booléen (résultat d'un test)
• int : un entier
• float : un réel
• complex : un complexe
• str : une chaîne de caractères (entre guillemets, apostrophes, ou triples guillemets """ pour les chaînes multilignes)
• tuple : une séquence d'éléments entre parenthèses, accessible par indices à partir de 0
• frozenset : analogue au type set mais non modifiable ; collection non ordonnée sans éléments dupliqués

>>> type(1 == 3)
<class 'bool'>
>>> type(5)
<class 'int'>
>>> type(3.2)
<class 'float'>
>>> type(5+2j)
<class 'complex'>
>>> type("Python")
<class 'str'>
>>> type((1,2,3))
<class 'tuple'>
>>> x = frozenset('abaabbcca')
>>> x
frozenset({'a', 'c', 'b'})
>>> type(x)
<class 'frozenset'>

>>> x = 2
>>> id(x)        # adresse mémoire de la valeur 2
140712265996480
>>> x = 3
>>> id(x)        # nouvelle adresse : nouvelle variable x

>>> t = (0, 'a')
>>> t[1]
'a'
>>> t[1] = 'b'   # modification non autorisée !
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> t = (0, 'b') # créer un nouveau tuple

Les types mutables #

Python fournit trois types modifiables :

• list : un tableau permettant de mémoriser un ensemble d'éléments de types variés.
• set : une collection non ordonnée modifiable constituée d'éléments uniques de types immutables. On peut appliquer des opérations propres aux ensembles (union, intersection, différence…).
• dict : une structure mutable, non ordonnée, formée d'enregistrements de type clé : valeur. L'accès à une valeur se fait uniquement via sa clé.

>>> L = [1, 2, 3]
>>> type(L)
<class 'list'>
>>> s = {1, 'a', (5, 6)}
>>> type(s)
<class 'set'>
>>> d = {1: "Python", 2: "C++", 3: "Java"}
>>> type(d)
<class 'dict'>

Affectation #

L'affectation désigne l'opération par laquelle on établit un lien entre le nom de la variable et sa valeur. En Python, l'opération d'affectation est représentée par le signe égale =.

n = 10                        # définir n et lui donner la valeur 10
txt = "bienvenue à l'IPEIS"  # chaîne de caractères
pi = 3.14159                  # nombre réel

Une simple affectation sous Python réalise plusieurs opérations en mémoire : créer et mémoriser un nom de variable, lui attribuer un type, créer et mémoriser une valeur, et établir un lien entre le nom et l'emplacement mémoire.

Affectations multiples

Sous Python, on peut affecter une valeur à plusieurs variables simultanément :

>>> x = y = 2       # affecter 2 à x et y
>>> x, y
(2, 2)
>>> x, y = 5, "BONJOUR"  # affectation parallèle
>>> x
5
>>> y
'BONJOUR'
>>> x, y = 2, 9
>>> x, y = y, x   # permutation de deux variables !
>>> x
9
>>> y
2

Les opérateurs avec assignation

Il est courant d'avoir besoin d'incrémenter une variable. L'instruction i = i + 1 sera avantageusement remplacée par i += 1.

Typage des variables #

Sous Python, il n'est pas nécessaire de déclarer les types des variables. Il suffit d'assigner une valeur à un nom de variable pour que celle-ci soit automatiquement créée avec le type qui correspond au mieux à la valeur fournie. On parle de typage dynamique, par opposition au typage statique (Pascal, C++, Java).

La fonction prédéfinie type() permet de connaître le type d'une variable :

>>> n = 10
>>> txt = "bienvenue à l'IPEIS"
>>> pi = 3.14159
>>> type(n)
<class 'int'>
>>> type(txt)
<class 'str'>
>>> type(pi)
<class 'float'>

Les entrées / sorties #

La fonction input()

En cours d'exécution, il est possible de demander à l'utilisateur de saisir une valeur au clavier grâce à input() :

x = input("Entrer une valeur : ")

x = int(input("Entrer un entier : "))
y = float(input("Entrer un réel : "))

La fonction print()

La fonction print() permet d'afficher n'importe quel nombre de valeurs. Par défaut, elles sont séparées par un espace et le tout se termine par un saut à la ligne.

>>> print("Bienvenue", "à", "l'IPEIS")
Bienvenue à l'IPEIS
>>> print("Bienvenue", "à", "l'IPEIS", sep="-")
Bienvenue-à-l'IPEIS
>>> x, y = 2, 3
>>> print("x =", x, " et y =", y)
x = 2  et y = 3

L'indentation en Python #

Dans de nombreux langages, on est amené à grouper des instructions successives. Python adopte une solution unique : l'indentation est obligatoire et fait partie de la syntaxe du langage. Dans un même bloc, deux instructions de même profondeur logique doivent avoir strictement la même indentation.

Contrôle du flux d'exécution #

Le « chemin » suivi par Python à travers un programme est appelé un flux d'exécution. Les structures de contrôle sont les groupes d'instructions qui déterminent l'ordre dans lequel les actions sont effectuées. Il en existe seulement trois : la séquence, la sélection et la répétition.

Exécution conditionnelle — if / elif / else

a = 0
if a > 0:
    print(a, "est positif")
elif a < 0:
    print(a, "est négatif")
else:
    print(a, "est nul")

Les opérateurs logiques et de comparaison

La boucle while

# Somme des entiers de 1 à 10
s = 0
i = 1
while i <= 10:
    s += i
    i += 1
print("somme =", s)   # somme = 55

La boucle for et range()

La variable element parcourt un itérateur (liste, tuple, chaîne, etc.) et prend successivement chacune des valeurs.

# Afficher les consonnes d'une chaîne
voyelles = 'aeiouy'
for car in 'chaine de caracteres':
    if car not in voyelles:
        print(car, end='')   # affiche : chn d crctrs

# Utiliser range() pour itérer sur des entiers
for x in range(4):         # x = 0, 1, 2, 3
    print(x, x**2)

break, continue, pass et else de boucle

# Exemple break : somme des entiers jusqu'à 10
s = 0
i = 0
while True:       # boucle infinie
    i += 1
    s += i
    if i == 10:
        break     # sortir de la boucle
print("somme =", s)

# Exemple continue : somme des pairs de 1 à 10
s = 0
i = 0
while True:
    i += 1
    if i % 2 != 0:
        continue  # sauter les impairs
    s += i
    if i == 10:
        break
print("somme pairs =", s)   # somme pairs = 30

Les exceptions #

Gérer une exception permet d'intercepter une erreur pour éviter un arrêt brutal du programme. Le mécanisme s'effectue en deux phases : la levée d'exception lors de la détection d'erreur, et le traitement approprié.

Syntaxe complète

try:
    ...                         # séquence normale
except ValueError as e:
    ...                         # traitement ValueError
except ZeroDivisionError as e:
    ...                         # traitement ZeroDivisionError
else:
    ...     # exécuté en l'absence d'erreur
finally:
    ...     # toujours exécuté

try:
    chaine = input('Entrer un nombre : ')
    nombre = float(chaine)
    inverse = 1.0 / nombre
except ValueError:
    print(chaine, "n'est pas un nombre !")
except ZeroDivisionError:
    print("Le dénominateur ne peut pas être nul !")
else:
    print("L'inverse de", nombre, "est :", inverse)

Les fonctions #

On implémente une fonction lorsqu'un ensemble d'instructions est susceptible d'être utilisé plusieurs fois dans un programme. Cette décomposition conduit à du code plus compact, plus lisible et plus efficace.

Définition d'une fonction

def somProd(x, y):
    """Fonction calculant somme et produit de x et y.
    Résultat retourné dans un tuple (somme, produit)."""
    return (x + y, x * y)

# Paramètres optionnels avec valeurs par défaut
def fct(p1, p2=9, p3='abc'):
    return (p1, p2, p3)

print(fct(1))        # (1, 9, 'abc')
print(fct(1, 2))     # (1, 2, 'abc')
print(fct(1, 2, 3))  # (1, 2, 3)

Portée des variables

def incremCompt():
    """Incrémente le compteur global i de 1."""
    global i   # rechercher i en dehors de l'espace local
    i += 1
    print('i =', i)

i = 2
incremCompt()   # affiche 3
incremCompt()   # affiche 4

La fonction lambda

Python permet de créer des fonctions anonymes, très courtes, limitées à une seule expression :

>>> f = lambda x: x**2
>>> f(2)
4
>>> somProd = lambda x, y: (x + y, x * y)
>>> somProd(3, 10)
(13, 30)

La fonction map()

La fonction map(fct, it) crée un itérateur en appliquant une fonction fct sur toutes les valeurs d'un itérable it :

>>> f = lambda x: x**2
>>> L = list(map(f, range(5)))   # carré de chaque entier de [0, 5[
>>> L
[0, 1, 4, 9, 16]

Les modules #

Un module Python est un fichier rassemblant des fonctions relatives à un certain traitement. Pour avoir accès à ses fonctions, il faut le charger avec import :

# Méthode 1 : importer tout (à éviter — risque de conflits de noms)
from math import *
sin(pi/2)           # => 1.0

# Méthode 2 : importer des fonctions spécifiques
from math import pi, sin
sin(pi/2)           # => 1.0

# Méthode 3 : importer le module (recommandé)
import math
math.sin(math.pi/2) # => 1.0

# Méthode 4 : alias local (recommandé)
import math as mt
mt.sin(mt.pi/2)     # => 1.0

Le module math

Le module math donne accès aux fonctions de la librairie mathématique standard :