Introduction à la programmation
1. Qu'est-ce qu'un programme ?
- Programme : suite d'opérations prédéterminées, exécutées automatiquement par un ordinateur pour réaliser des calculs, travaux ou simulations.
- Code source : texte formel écrit par un programmeur, décrivant étape par étape les opérations à effectuer, selon les règles d’un langage de programmation.
- Langage de programmation : langage informatique permettant à un humain d’écrire un code source interprété par une machine (ex. Python, Perl, Java, C++).
Un programme est une suite d’instructions formelles destinées à être exécutées automatiquement par un ordinateur.
2. La vie d’un programme
| Étape | Description |
|---|---|
| 1. Programmation | Saisie du code source dans un éditeur |
| 2. Transformation | Conversion du code source en langage machine |
| 3. Exécution | Exécution du code machine par l’ordinateur |
3. Présentation du langage Python
- Créé en 1990 par Guido van Rossum.
- Langage de script, proche de Perl et Ruby, largement utilisé en bioinformatique et sciences.
- Dispose d’une vaste communauté et de nombreux modules (ex. Biopython, SciPy, NumPy).
- Adopté par des institutions comme Google et la NASA.
4. Modes d’utilisation de Python
| Mode | Description | Exemple d’indication dans les slides |
|---|---|---|
| Mode interprété | Instruction saisie et exécutée immédiatement | In [x]: pour l’entrée, Out[x]: pour la sortie |
| Mode exécuté | Exécution d’un ensemble d’instructions d’un coup | Pas de marque spécifique |
5. Exemples simples en Python
- Mode interprété :
In [1]: 2 + 2 Out[1]: 4 - Mode exécuté :
x = 2 + 2 x = x + 5 print(x) # Affiche 9
6. Syntaxe en programmation
- Syntaxe : ensemble des règles définissant la structure correcte du code.
- Une erreur de syntaxe empêche l’exécution du programme et doit être corrigée avant de continuer.
La syntaxe est la grammaire du langage de programmation, indispensable pour que le code soit compris et exécuté.
Présentation du langage Python
1. Syntaxe de Python
- La casse est sensible :
Bonjour≠BONJOUR. - L'indentation est obligatoire pour délimiter les blocs de code.
- Les espaces entre les éléments n'ont pas d'importance :
x=2+2équivaut àx = 2 + 2.
2. Les commentaires
- Commencent par
#. - Utiles pour :
- Rendre le code plus clair pour les autres.
- Faciliter le débogage.
- Clarifier les idées avant de coder.
- Exemple :
# Ceci est un commentaire x = 2 + 3 # commentaire en fin de ligne
3. Types de données basiques
| Type | Description | Exemples |
|---|---|---|
| Nombres | Entiers, décimaux, complexes | 2, 3.14, 3+2j |
| Chaînes | Texte délimité par guillemets | "Bonjour", 'texte' |
| Booléens | Valeurs logiques True ou False | True, False |
4. Les nombres
- Types numériques :
- Entier (
int) :2,3,-5 - Décimal (
float) :2.94,5e8(notation scientifique) - Complexe (
complex) :3+2j
- Entier (
- Opérateurs principaux :
| Opération | Symbole |
|---|---|
| Addition | + |
| Soustraction | - |
| Multiplication | * |
| Division | / |
| Modulo | % |
| Puissance | ** |
| Comparaison | ==, <, >, <=, >= |
- Remarques :
- La division
/entre entiers retourne un flottant :7 / 2 = 3.5. - Le modulo
%donne le reste de la division euclidienne :7 % 2 = 1.
- La division
5. Les chaînes de caractères
- Délimitées par guillemets simples
'...'ou doubles"...". - Pour inclure un guillemet dans la chaîne, utiliser le backslash
\:
"Il a dit : \"Bonjour\"" - Opérateurs :
| Opération | Symbole |
|---|---|
| Concaténation | + |
| Réplication | * |
| Comparaison | ==, <, >, <=, >= |
- Exemple :
"Bonjour" + ' tout le monde'→'Bonjour tout le monde'
"pa" * 2→'papa'
6. Les booléens
- Deux valeurs :
True(vrai)False(faux)
- Opérateurs logiques :
| Opération | Symbole |
|---|---|
| ET logique | and |
| OU logique | or |
| NON logique | not |
| OU exclusif (différence) | != |
- Table de vérité simplifiée :
| A | B | A and B | A or B | not A |
|---|---|---|---|---|
| True | True | True | True | False |
| True | False | False | True | False |
| False | True | False | True | True |
| False | False | False | False | True |
À retenir : En Python, l'indentation est obligatoire et la casse est sensible. Les types de base sont les nombres, chaînes et booléens, chacun avec ses opérateurs spécifiques.
Les types de données basiques
1. Les types de données basiques
a) Les booléens
- Booléen : type de donnée représentant la valeur True (vrai) ou False (faux).
- Opérateurs logiques usuels :
- and : True si les deux opérandes sont True.
- or : True si au moins un opérande est True.
- Exemples :
True and False→ FalseTrue or False→ True2 < 4 and "romain" < "rome"→ True
Les booléens servent à exprimer des conditions et contrôlent le flux des programmes.
b) Les variables
- Variable : espace de stockage nommé pour une valeur modifiable.
- Affectation avec le symbole
=:x = 3 y = x + 5 - Une variable peut être réaffectée à tout moment :
y = 5 - Exemples d’opérations sur variables :
x % 2 == 0: teste si x est pair (renvoie un booléen).y > 50 and y < 100équivaut à50 < y < 100.
c) Les séquences
- Séquence : conteneur ordonné de valeurs, accessible par index.
- Types principaux utiles en Python :
Type Description Syntaxe exemple Chaîne (str) Suite de caractères "ATTCCGT"Liste (list) Collection ordonnée, hétérogène ['girafe', 'tigre']Tuple (tuple) Collection ordonnée, immuable (1, 2, 3)
Opérations communes sur séquences (s, t sont des séquences)
| Opération | Description |
|---|---|
s[i] | Accès à l’élément d’index i |
x in s | Teste si x est un élément de s |
s + t | Concaténation de s suivi de t |
s * n | Répétition de s n fois |
len(s) | Nombre d’éléments dans s |
min(s) | Plus petit élément (selon ordre) |
max(s) | Plus grand élément |
s.index(x) | Indice de la première occurrence de x dans s |
s.count(x) | Nombre d’occurrences de x dans s |
Exemples
- Pour la chaîne
s = "ATTCCGT":s[1]→'T'len(s)→ 7'X' in s→ Falsemax(s)→'T's.count("T")→ 3
- Pour la liste
animaux = ['girafe', 'tigre', 'singe', 'souris']:animaux[2]→'singe''singe' not in animaux→ False
d) Les listes
- Liste : structure de données ordonnée, mutable, pouvant contenir des éléments de types différents.
- Syntaxe : valeurs séparées par des virgules, encadrées par crochets
[].
Exemple :animaux = ['girafe', 'tigre', 'singe', 'souris'] - Grande flexibilité grâce à l’hétérogénéité des types contenus.
Une liste est idéale pour stocker et manipuler des collections d’éléments variés et modifiables.
Les variables
1. Variables et listes
- Une liste est une collection ordonnée et modifiable d’éléments, pouvant être de types différents.
- Syntaxe :
liste = [élément1, élément2, ...] - Exemple :
animaux = ['girafe', 'tigre', 'singe', 'souris'] tailles = [5, 2.5, 1.75, 0.15] mixte = ['girafe', 5, 'souris', 0.15] - Affichage d’une liste :
print(animaux)→['girafe', 'tigre', 'singe', 'souris']
2. Principales méthodes sur les listes
| Méthode | Description | Remarque |
|---|---|---|
l.append(x) | Ajoute l’élément x à la fin de la liste | Modification en place |
l.insert(i, x) | Insère x à l’indice i | |
del l[i] | Supprime l’élément à l’indice i | |
l.remove(x) | Supprime la première occurrence de x | Erreur si x absent |
l.count(x) | Compte le nombre d’occurrences de x | |
l.sort() | Trie la liste en ordre croissant | Modification en place |
l.reverse() | Inverse l’ordre des éléments | Modification en place |
Attention : Ces méthodes modifient la liste directement, sans créer de copie.
3. Opérations courantes sur les listes
- Ajouter un élément :
x = [1, 2, 3] x.append(5) # x devient [1, 2, 3, 5] - Insérer un élément à un indice donné :
x.insert(2, -15) # x devient [1, 2, -15, 3, 5] - Supprimer un élément par indice :
del x[1] # supprime l’élément à l’indice 1 - Supprimer un élément par valeur :
x.remove(5) # supprime la première occurrence de 5 - Trier et inverser :
x.sort() # trie la liste x.reverse() # inverse la liste - Vérifier la présence d’un élément :
3 in x # True ou False
4. Les tuples (n-uplets)
- Un tuple est une séquence ordonnée mais non modifiable.
- Syntaxe :
t = (élément1, élément2, ...) - Exemple :
x = (1, '2', 3) - Accès aux éléments par indice comme pour les listes.
- Tentative de modification :
x[2] = 15 # Provoque une erreur TypeError
5. Le slicing (découpage de séquences)
- Permet d’extraire un sous-ensemble d’une séquence (liste, tuple, chaîne).
- Syntaxe :
seq[debut:fin_exclue:pas] - Exemples sur une liste
seq = [elt0, elt1, elt2, ..., eltN]:seq[0]: premier élémentseq[N]: (N+1)-ième élémentseq[1:3]: éléments d’indice 1 et 2seq[:]: copie complète de la liste
- Le slicing retourne une nouvelle séquence, sans modifier l’originale.
À retenir : Les listes sont modifiables et disposent de nombreuses méthodes pour ajouter, supprimer ou trier des éléments, tandis que les tuples sont immuables. Le slicing permet d’extraire facilement des sous-séquences.
Les séquences et dictionnaires
1. Séquences
- Une séquence est un ensemble ordonné d’éléments accessibles par un indice entier.
- Exemple : une chaîne de caractères
"girafe tigre"est une séquence de caractères. - La fonction
len()donne la longueur d’une séquence. - L’indexation commence à 0 :
animaux[0]donne le premier élément. - Le slicing permet d’extraire une sous-séquence :
animaux[0:4]extrait les éléments d’indice 0 à 3.animaux[9:]extrait à partir de l’indice 9 jusqu’à la fin.animaux[:-2]extrait tous les éléments sauf les deux derniers.
2. Dictionnaires
- Un dictionnaire est une collection non ordonnée de paires clé : valeur.
- Les clés sont uniques et peuvent être de types variés (souvent chaînes de caractères).
- On accède à une valeur via sa clé :
dic['nom']. - Exemple d’un dictionnaire :
dic = {'nom': 'girafe', 'poids': 1100, 'taille': 5.0} - Les dictionnaires sont modifiables : on peut ajouter ou modifier des paires clé-valeur.
a) Méthodes importantes
| Méthode | Description | Résultat |
|---|---|---|
dic.keys() | Renvoie la liste des clés | ['nom', 'poids', 'taille'] |
dic.values() | Renvoie la liste des valeurs | ['girafe', 1100, 5.0] |
Un dictionnaire est une structure clé pour stocker des données associatives avec accès rapide par clé.
3. Matrices
- Une matrice est un tableau à deux dimensions, avec un nombre de lignes et de colonnes.
- Exemple de matrice 3x2 :
- En Python, une matrice est représentée par une liste de listes :
[[1, 2], [3, 5], [3, 1]]
a) Parcours d’une matrice
- Pour parcourir tous les éléments, on utilise deux boucles imbriquées :
for ligne in matrice: for element in ligne: print(element) - La première boucle itère sur les lignes, la seconde sur les éléments de chaque ligne.
Une matrice est manipulée en Python comme une liste contenant des listes, ce qui facilite l’accès aux éléments par indices
[i][j].
Les matrices
1. Définition d'une matrice
Une matrice est une structure de données à deux dimensions, organisée en lignes et colonnes, permettant de stocker des valeurs homogènes (même type). Elle est souvent représentée comme un tableau à deux indices.
2. Représentation en Python
- Une matrice peut être modélisée par une liste de listes.
- Chaque sous-liste représente une ligne de la matrice.
Exemple :
matrice = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
3. Accès aux éléments
- L'élément à la ligne i et colonne j s'accède par :
matrice[i][j]
avecietjcommençant à 0.
4. Propriétés importantes
| Propriété | Description |
|---|---|
| Dimensions | Nombre de lignes (m) et de colonnes (n) |
| Matrice carrée | m = n |
| Matrice nulle | Tous les éléments sont égaux à zéro |
| Matrice identité | Matrice carrée avec 1 sur la diagonale, 0 ailleurs |
5. Opérations élémentaires
- Addition : somme élément par élément de deux matrices de même dimension.
- Multiplication par un scalaire : chaque élément est multiplié par un nombre.
- Multiplication matricielle : produit de deux matrices A (m×p) et B (p×n) donne une matrice C (m×n) où
.
6. Conditions pour la multiplication
- Le nombre de colonnes de la première matrice doit être égal au nombre de lignes de la seconde.
7. Parcours d'une matrice en Python
Utilisation de boucles imbriquées :
for i in range(len(matrice)):
for j in range(len(matrice[0])):
# traiter matrice[i][j]
8. Exemples d'utilisation
- Représentation de données tabulaires.
- Calculs mathématiques (systèmes linéaires, transformations).
- Traitement d'images (pixels en matrice).
À retenir : Une matrice est une structure bidimensionnelle accessible par indices, essentielle pour manipuler des données organisées en lignes et colonnes.
Les structures conditionnelles
1. Les structures conditionnelles
Les structures conditionnelles permettent d'exécuter un bloc de code uniquement si une condition est vraie. Elles sont essentielles pour contrôler le flux d'exécution d’un programme.
2. La condition if
- Syntaxe générale en Python :
if condition: # bloc de code exécuté si la condition est vraie - La condition est une expression qui retourne un booléen (
TrueouFalse). - Exemple :
age = 18 if age >= 18: print("Vous êtes majeur.")
3. Les extensions : else et elif
| Mot-clé | Fonction |
|---|---|
else | Bloc exécuté si la condition du if est fausse |
elif | Permet de tester une nouvelle condition si la précédente est fausse |
- Exemple :
if age < 18: print("Mineur") elif age == 18: print("Juste majeur") else: print("Adulte")
4. Opérateurs de comparaison utilisés dans les conditions
| Opérateur | Signification | Exemple |
|---|---|---|
== | Égal à | age == 18 |
!= | Différent de | age != 18 |
< | Strictement inférieur | age < 18 |
<= | Inférieur ou égal | age <= 18 |
> | Strictement supérieur | age > 18 |
>= | Supérieur ou égal | age >= 18 |
5. Les expressions booléennes complexes
- On peut combiner plusieurs conditions avec :
and(et logique)or(ou logique)not(négation)
Exemple :
if age >= 18 and citoyen == True:
print("Peut voter")
6. Utilisation dans les boucles
- Les structures conditionnelles sont souvent utilisées dans les boucles pour contrôler l'exécution répétée.
- Exemple avec
while(tant que la condition est vraie) :age = 12 while age <= 18: print("Trop jeune, essaye encore") age += 1 # incrémentation de age
7. La boucle for pour parcourir des séquences
- Syntaxe :
for element in sequence: # bloc de code - Parcourt chaque élément d’une liste, chaîne de caractères, etc.
- Exemple :
my_list = ["toto", "tata", "titi"] for elt in my_list: print(elt) - Affiche successivement chaque élément.
8. Exemple combiné for + if
- On peut filtrer les éléments lors du parcours :
my_string = "bon, jour" i = 0 for letter in my_string: if i % 2 == 0: print(letter) i += 1 - Affiche les lettres d’indice pair : b, n, o, r
À retenir :
Les structures conditionnelles (if,elif,else) permettent de diriger l'exécution du programme selon des conditions booléennes, souvent combinées avec des boucles pour répéter ou filtrer des actions.
Les boucles
1. Les boucles
Les boucles permettent de répéter un bloc d'instructions plusieurs fois, facilitant ainsi la gestion des tâches répétitives en programmation.
2. Types de boucles en Python
| Type de boucle | Description | Syntaxe principale |
|---|---|---|
| while | Répète tant qu'une condition est vraie | while condition: |
| for | Itère sur une séquence (liste, chaîne, etc.) | for variable in sequence: |
3. Boucle while
- Principe : exécute le bloc tant que la condition est vraie.
- Attention : risque de boucle infinie si la condition ne devient jamais fausse.
- Exemple minimal :
i = 0 while i < 5: print(i) i += 1
4. Boucle for
- Parcourt chaque élément d'une séquence.
- Très utilisée pour itérer sur des listes, chaînes, ou plages de nombres.
- Exemple avec
range():for i in range(5): print(i)
5. Contrôle de boucle
| Instruction | Fonction |
|---|---|
break | Sort immédiatement de la boucle |
continue | Passe à l'itération suivante |
6. Bonnes pratiques
- Toujours s'assurer que la condition de sortie d'une boucle
whilesera atteinte. - Préférer
forquand le nombre d'itérations est connu ou limité. - Utiliser
breaketcontinueavec parcimonie pour garder le code lisible.
À retenir : Les boucles permettent d'automatiser la répétition d'instructions, mais il faut impérativement contrôler leur condition d'arrêt pour éviter les boucles infinies.
Les fonctions
1. Fonction : définition et utilité
- Fonction : bloc de code réutilisable, appelé depuis le programme principal.
- Deux types :
- Fonctions built-in : déjà définies en Python (ex.
abs(),int(),round()). - Fonctions définies par l’utilisateur : créées pour des besoins spécifiques.
- Fonctions built-in : déjà définies en Python (ex.
2. Portée des variables
La portée d'une variable détermine où elle est accessible dans le programme.
| Type de variable | Définition | Visibilité |
|---|---|---|
| Globale | Définie hors de toute fonction | Accessible partout |
| Locale | Définie dans une fonction (ex : arguments, variables internes) | Accessible uniquement dans la fonction |
La portée locale masque la variable globale du même nom à l’intérieur de la fonction.
a) Exemple de portée
x = 0 # globale
a = 1 # globale
z = 10 # globale
def f(x, y): # x, y sont locales
b = 2 # locale
z = 4 # locale
return a*x + b*y + z
print(f(3,4)) # 15
print(z) # 10 (globale)
print(a) # 1 (globale)
print(b) # Erreur : b n'est pas défini hors de f
3. Fonctions built-in courantes
| Fonction | Description | Exemple | Résultat |
|---|---|---|---|
abs(x) | Valeur absolue | abs(-2) | 2 |
complex(r,i) | Nombre complexe r + i*j | complex(3,4) | (3+4j) |
float(x) | Conversion en nombre à virgule flottante | float(2) | 2.0 |
int(x) | Conversion en entier | int("2") | 2 |
round(x, n) | Arrondi à n décimales (par défaut 0) | round(2.7) | 3 |
min(a,b,...) | Minimum d’une liste de valeurs | min(2,5,-1) | -1 |
max(a,b,...) | Maximum d’une liste de valeurs | max(2,5,-1) | 5 |
str(x) | Conversion en chaîne de caractères | str(2.78) | '2.78' |
4. Récursivité (rappel)
- Une fonction peut s'appeler elle-même, c’est la récursivité.
- Utile pour résoudre certains problèmes naturellement itératifs (ex. factorielle, Fibonacci).
- Nécessite une condition d'arrêt pour éviter une boucle infinie.
Une fonction est un outil fondamental pour structurer et réutiliser le code, avec des variables dont la portée détermine leur visibilité et leur durée de vie.
La récursivité
1. Fonction et récursivité
- Fonction : bloc de code réutilisable, pouvant prendre des arguments (variables) et retourner un résultat avec
return. - Attention :
returnrenvoie une valeur, différent deprint()qui affiche à l’écran.- La définition d’une fonction n’exécute rien tant qu’elle n’est pas appelée.
- Les arguments sont des variables locales remplacées par les valeurs passées lors de l’appel.
- Le code dans une fonction doit être indenté.
2. Fonction récursive
- Définition : fonction qui s’appelle elle-même dans son propre corps.
- Caractéristiques :
- Cas de terminaison (cas d’arrêt) : condition(s) où la fonction ne s’appelle plus elle-même.
- Cas récursif : cas où la fonction s’appelle elle-même avec un argument modifié.
Une fonction récursive doit toujours posséder au moins un cas d’arrêt pour éviter une boucle infinie.
3. Exemple mathématique : somme des n premiers entiers
-
Définition récursive :
-
Version Python récursive :
def sumRec(n): if n == 0: return 0 else: return n + sumRec(n-1) -
Version itérative pour comparaison :
def sumIt(n): res = 0 i = 0 while i <= n: res += i i += 1 return res
4. Exemples classiques de fonctions récursives
| Fonction | Définition mathématique | Définition Python |
|---|---|---|
| Factorielle | $$ | |
| fact(x) = \begin{cases} | ||
| 1 & \text{si } x=0 \ | ||
| x \times fact(x-1) & \text{sinon} | ||
| \end{cases} |
Les fichiers
1. Ouverture et fermeture des fichiers
-
La fonction open("nom_fichier", mode) ouvre un fichier selon un mode donné :
Mode Description "r" Lire un fichier "w" Écrire au début d’un fichier "a" Écrire à la fin d’un fichier "r+" Lire et écrire dans un fichier -
Toujours fermer le fichier après utilisation avec f.close().
2. Lecture de fichiers
-
f.read() : lit tout le contenu du fichier et renvoie une chaîne de caractères (incluant les
\npour les sauts de ligne). -
f.readlines() : renvoie une liste où chaque élément est une ligne du fichier (avec
\n). -
f.readline() : lit une ligne à la fois, renvoie une chaîne ; à chaque appel, passe à la ligne suivante. Retourne une chaîne vide à la fin du fichier.
-
Lecture ligne par ligne avec une boucle for :
for ligne in f: # traiter chaque ligne
3. Écriture dans un fichier
-
Ouvrir le fichier en mode écriture ("w" ou "a").
-
Utiliser f.write(chaîne) pour écrire une chaîne dans le fichier.
-
Le caractère spécial
\npermet de passer à la ligne suivante dans le fichier.
À retenir : Toujours ouvrir un fichier avec le mode adapté, utiliser les méthodes read(), readline(), readlines() pour lire, et write() pour écrire, puis fermer le fichier avec close().