Systèmes Distribués

Ce document présente une introduction complète au langage de programmation Python, destinée aux étudiants de première année de Master en systèmes distribués. Il couvre les bases du langage, son mode interactif, les structures de données fondamentales, les instructions de contrôle, les fonctions, les scripts, les modules, ainsi que la programmation orientée objet avec les classes. Des exemples concrets et des exercices pratiques accompagnent chaque notion pour faciliter l'apprentissage.

Avant Propos

Python est un langage de programmation open source, orienté objet, multi-paradigme et multi-plateformes. Il a été développé par Guido van Rossum, dont le rôle est celui de "Benevolent Dictator For Life" (dictateur bienveillant à vie), ce qui signifie qu'il continue à superviser le développement du langage et prend des décisions importantes si nécessaire. Le nom "Python" est un hommage à la série télévisée britannique Monty Python's Flying Circus.

Prise en main

Hello World !

En mode interactif, on lance Python depuis le shell Linux avec la commande $ python, puis on exécute la commande suivante :

print('hello world')

En mode script, on crée un fichier helloworld.py :

$ touch helloworld.py

On insère ensuite le code :

print('hello world')

Et on exécute le script avec :

$ python helloworld.py

Python en mode interactif

input() et print() : lecture et affichage

La fonction input() permet de lire des données depuis l'entrée standard. La valeur lue est stockée sous forme de chaîne de caractères. La fonction print() sert à afficher des données sur la sortie standard.

nom = input("Entrez votre nom : ")
print("Bonjour", nom)

Les nombres

• Les opérateurs +, -, *, / fonctionnent comme en C ou Pascal.
• Les entiers (exemple : 1, 2, 3) sont de type int.
• Les nombres décimaux (exemple : 1.333, 5.6) sont de type float.
• // est l'opérateur de division entière.
• % donne le reste de la division entière.
• ** est l'opérateur de puissance.
• = est l'opérateur d'affectation.

x = 5
y = 2
print(x + y)    # 7
print(x // y)   # 2
print(x % y)    # 1
print(x ** y)   # 25

Les chaînes de caractères

Une chaîne de caractères peut contenir des caractères spéciaux comme \n pour un retour à la ligne.

s = 'Première ligne.\nSeconde ligne'
print(s)

Les chaînes peuvent être concaténées avec + et répétées avec * :

'ha' + 'ou'      # 'haou'
'ha' * 3           # 'hahaha'

On peut aussi concaténer une chaîne avec une variable :

prenom = 'Alice'
message = 'Bonjour ' + prenom
print(message)      # Bonjour Alice

Les chaînes sont indexées à partir de 0 (de gauche à droite) ou avec des indices négatifs (de droite à gauche, où -1 est le dernier caractère). On peut extraire une sous-chaîne (slice) :

s = 'Python'
print(s[0])     # 'P'
print(s[-1])    # 'n'
print(s[1:4])   # 'yth'

Les chaînes sont immuables : on ne peut pas modifier un caractère directement. Pour modifier une chaîne, il faut en créer une nouvelle :

s = 'Python'
# s[0] = 'J'  # Erreur
s2 = 'J' + s[1:]
print(s2)      # 'Jython'

La fonction len() renvoie la longueur d'une chaîne :

len('Python')  # 6

Les listes

Les listes regroupent plusieurs valeurs, pas forcément du même type. Elles sont définies par des éléments séparés par des virgules et entourés de crochets. Comme les chaînes, elles sont indexées et peuvent être découpées. Contrairement aux chaînes, les listes sont modifiables :

liste = [1, 'deux', 3.0]
print(liste[1])    # 'deux'
liste[1] = 'two'
print(liste)       # [1, 'two', 3.0]

On peut concaténer des listes :

liste2 = liste + [4, 5]
print(liste2)      # [1, 'two', 3.0, 4, 5]

La méthode append() ajoute un élément à la fin :

liste.append(6)
print(liste)       # [1, 'two', 3.0, 6]

La fonction len() s'applique aussi aux listes :

len(liste)        # 4

Les tuples

Les tuples sont similaires aux listes mais immuables et utilisent moins d’espace mémoire. Ils sont définis par des éléments séparés par des virgules et entourés de parenthèses :

t = (1, 2, 3)
print(t[0])        # 1
# t[0] = 4         # Erreur

Premier exemple : la suite de Fibonacci

Ce programme calcule les termes de la suite de Fibonacci inférieurs à 10 :

a, b = 0, 1
while a < 10:
    print(a)
    a, b = b, a + b

Explications :

• Affectation multiple : a, b = 0, 1 affecte 0 à a et 1 à b simultanément.
• La boucle while s'exécute tant que la condition a < 10 est vraie.
• L'indentation est obligatoire pour délimiter le corps de la boucle.
• print() affiche les valeurs.

Les instructions de contrôle

L'instruction if

La syntaxe est :

if condition:
    instructions
elif condition2:
    instructions
else:
    instructions

Exemple :

x = 5
if x > 0:
    print("Positif")
elif x == 0:
    print("Zéro")
else:
    print("Négatif")

La boucle for

En Python, la boucle for itère sur les éléments d'une séquence dans l'ordre :

for element in [1, 2, 3]:
    print(element)

Exemple :

for i in range(3):
    print(i)

La boucle while

La boucle while exécute les instructions tant qu'une condition est vraie :

while condition:
    instructions

Exemple :

i = 0
while i < 3:
    print(i)
    i += 1

La fonction range()

Utilisée avec for, range() génère une séquence de nombres :

for i in range(1, 5):
    print(i)  # Affiche 1, 2, 3, 4

break(), continue() et else()

• break() interrompt la boucle for ou while.
• continue() passe à l'itération suivante de la boucle.
• else attaché à une boucle s'exécute si la boucle se termine normalement (sans interruption par break).

Les fonctions

Définition d'une fonction :

def nomDeLaFonction(liste_de_paramètres):
    ...
    return résultat

Le mot-clé def est suivi du nom de la fonction et de ses paramètres entre parenthèses, puis de deux-points. Le corps de la fonction est indenté. Le return est facultatif.

Exemple simple

def carre(x):
    return x * x

print(carre(4))  # 16

Récursivité

Exemple de fonction récursive calculant la factorielle :

def factorielle(n):
    if n == 0:
        return 1
    else:
        return n * factorielle(n - 1)

print(factorielle(5))  # 120

Arguments des fonctions

Les arguments peuvent être des variables ou des fonctions de rappel (callbacks).

def appliquer(fonction, x):
    return fonction(x)

def carre(x):
    return x * x

print(appliquer(carre, 3))  # 9

Arguments facultatifs

On peut définir une valeur par défaut pour un argument :

def saluer(nom=None):
    if nom is None:
        print("Bonjour")
    else:
        print("Bonjour", nom)

saluer()          # Bonjour
saluer("Alice")   # Bonjour Alice

Les scripts

Utilisation d'une fonction dans un script

Un script peut contenir plusieurs fonctions et un corps principal qui les appelle :

def cube(x):
    return x ** 3

def volumeSphere(rayon):
    from math import pi
    return (4/3) * pi * rayon ** 3

rayon = 3
print("Volume de la sphère :", volumeSphere(rayon))

Les modules

Un module est un fichier regroupant des fonctions. On peut importer un module avec :

import module1
import module2
import module3, module4
from math import *
from math import cos

Exemple d'utilisation dans un script :

import math

print(math.sqrt(16))  # 4.0

Créer son module

On peut créer un module personnalisé, par exemple operation.py :

def addition(a, b):
    return a + b

def multiplication(a, b):
    return a * b

Puis l'utiliser dans un script :

import operation

print(operation.addition(2, 3))        # 5
print(operation.multiplication(2, 3))  # 6

Point d'entrée du script

L'instruction suivante placée à la fin d'un module permet de déterminer si le module est exécuté directement ou importé :

if __name__ == "__main__":
    # Code à exécuter uniquement si le module est lancé directement
    pass

Cela permet d'inclure des tests ou du code d'exécution dans un module sans qu'il soit exécuté lors de son importation.

Les classes

Définition d'une classe en Python :

class NomDeLaClasse:
    attribut_1 = valeur
    attribut_2 = valeur

    def methode_1(self, ...):
        ...

    def methode_2(self, ...):
        ...

On instancie un objet :

var = NomDeLaClasse()
print(var.attribut_1)
var.methode_1()

Le premier argument des méthodes doit toujours être self, représentant l'instance de la classe.

La méthode constructeur s'écrit :

def __init__(self, ...):
    # Initialisation de l'objet

Exemple :

class Personne:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

    def se_presenter(self):
        print("Je m'appelle", self.nom, "et j'ai", self.age, "ans.")

p = Personne("Alice", 30)
p.se_presenter()  # Je m'appelle Alice et j'ai 30 ans.

Glossaire des termes clés

• Python : Langage de programmation open source, multi-paradigme et multi-plateformes.
• input() : Fonction pour lire une entrée utilisateur sous forme de chaîne.
• print() : Fonction pour afficher des données à l'écran.
• int : Type entier.
• float : Type nombre décimal.
• Liste : Structure de données modifiable regroupant plusieurs éléments.
• Tuple : Structure de données immuable similaire à une liste.
• Slice : Opération d'extraction d'une sous-partie d'une chaîne ou d'une liste.
• Boucle for : Instruction d'itération sur une séquence.
• Boucle while : Instruction d'itération tant qu'une condition est vraie.
• Fonction : Bloc de code réutilisable pouvant prendre des paramètres et retourner un résultat.
• Module : Fichier regroupant des fonctions ou classes réutilisables.
• Classe : Modèle définissant des objets avec attributs et méthodes.
• Instance : Objet créé à partir d'une classe.
• self : Référence à l'instance dans les méthodes d'une classe.
• Constructeur (__init__) : Méthode spéciale appelée lors de la création d'une instance.

Points clés à retenir

• Python est simple à apprendre grâce à sa syntaxe claire et à son mode interactif.
• Les chaînes de caractères sont immuables, tandis que les listes sont modifiables.
• Les boucles for et while permettent d’itérer sur des séquences ou tant qu’une condition est vraie.
• Les fonctions facilitent la modularité et la réutilisation du code, avec possibilité d’arguments facultatifs et de récursivité.
• Les modules permettent d’organiser le code en fichiers réutilisables.
• La programmation orientée objet en Python utilise les classes, les instances, et la méthode constructeur __init__.
• L’instruction if __name__ == "__main__" permet de distinguer l’exécution directe d’un module de son importation.