python pour débutant
Introduction à la programmation Python
Python est un langage de programmation généraliste, polyvalent et populaire. Il est idéal comme premier langage car il est concis et facile à lire, et il est également un bon langage à avoir dans la pile de tout programmeur car il peut être utilisé pour tout, du développement web au développement logiciel et aux applications scientifiques.
Dans ce cours, vous allez apprendre les principes de base de Python, tels que les variables et les conditionnelles, les fonctions, les classes et la programmation orientée objet. Vous allez également apprendre à interagir avec le web et à manipuler des données avec Python.
Ce cours est destiné aux débutants qui n’ont pas ou peu d’expérience en programmation. Vous aurez besoin d’un ordinateur avec une connexion internet et d’un éditeur de texte comme Visual Studio Code ou Sublime Text.
Plan du cours
Le cours est divisé en cinq modules :
- Module 1 : Les bases de Python
- Module 2 : Les structures de données en Python
- Module 3 : Les fonctions en Python
- Module 4 : La programmation orientée objet en Python
Chaque module contient des leçons théoriques, des exemples pratiques et des exercices à faire par vous-même. À la fin du cours, vous serez capable de créer vos propres programmes en Vous n’avez jamais programmé et vous souhaitez apprendre les bases du langage Python ? Ce cours est fait pour vous ! Vous découvrirez les concepts essentiels de la programmation et vous réaliserez vos premiers programmes en Python.
Module 1 : Les bases de Python
Dans ce module, vous allez apprendre les concepts fondamentaux de la programmation avec Python. Vous allez découvrir comment :
- Installer et exécuter Python sur votre ordinateur
- Écrire et exécuter votre premier programme en Python
- Utiliser des variables pour stocker des valeurs
- Utiliser des types de données comme les nombres, les chaînes de caractères et les booléens
- Utiliser des opérateurs arithmétiques, logiques et de comparaison
- Utiliser des structures conditionnelles comme if, elif et else
- Utiliser des boucles comme for et while
Leçon 1 : Installer et exécuter Python
Python est un langage interprété, ce qui signifie qu’il n’a pas besoin d’être compilé avant d’être exécuté. Pour utiliser Python, vous avez besoin d’un interpréteur, qui est un programme qui lit votre code source et l’exécute ligne par ligne.
Il existe plusieurs versions de Python, mais dans ce cours, nous allons utiliser la version 3.x, qui est la plus récente. Pour installer l’interpréteur Python sur votre ordinateur, vous pouvez suivre ces étapes :
- Allez sur le site officiel de Python1et téléchargez l’installateur correspondant à votre système d’exploitation (Windows, Mac OS ou Linux).
- Exécutez l’installateur et suivez les instructions à l’écran. Assurez-vous de cocher la case “Add Python to PATH” pour pouvoir accéder à l’interpréteur depuis n’importe quel répertoire.
- Pour vérifier que l’installation a réussi, ouvrez une invite de commande (cmd sous Windows ou terminal sous Mac OS ou Linux) et tapez la commande
python --version. Vous devriez voir s’afficher quelque chose commePython 3.x.y, où x.y correspond au numéro de version.
Félicitations ! Vous avez installé l’interpréteur Python sur votre ordinateur !
Pour exécuter un programme en Python, vous avez deux options :
- Utiliser l’interprète interactif (ou shell) : il s’agit d’un mode où vous pouvez taper directement du code dans l’invite de commande et voir le résultat immédiatement. Pour accéder à l’interprète interactif, tapez simplement la commande
pythondans l’invite de commande. Vous verrez apparaître le symbole>>>, qui indique que vous pouvez commencer
D’accord, voici la suite du cours :
écrire du code Python:
- Utiliser un fichier source : il s’agit d’un fichier texte qui contient du code Python, généralement avec l’extension
.py. Pour créer un fichier source, vous pouvez utiliser n’importe quel éditeur de texte, comme Visual Studio Code ou Sublime Text. Pour exécuter un fichier source, vous devez le sauvegarder dans un répertoire de votre choix, puis taper la commandepython nom_du_fichier.pydans l’invite de commande, en remplaçantnom_du_fichier.pypar le nom réel de votre fichier.
Dans ce cours, nous allons utiliser principalement des fichiers sources, car ils sont plus pratiques pour écrire des programmes plus longs et les modifier.
Leçon 2 : Écrire et exécuter votre premier programme en Python
Maintenant que vous savez comment installer et exécuter Python sur votre ordinateur, il est temps d’écrire et d’exécuter votre premier programme en Python !
Un programme est une suite d’instructions qui indique à l’ordinateur ce qu’il doit faire. En Python, chaque instruction se termine par un saut de ligne et peut contenir des commentaires. Les commentaires sont des portions de texte qui ne sont pas exécutées par l’interpréteur et qui servent à expliquer le code ou à le rendre plus lisible.
En Python, les commentaires commencent par le symbole # et se terminent à la fin de la ligne.
Voici un exemple de programme en Python qui affiche le message “Hello, world !” à l’écran :
# Ceci est un commentaire
print("Hello, world !") # Cette instruction affiche le message entre guillemets
Pour exécuter ce programme,
- Ouvrez votre éditeur de texte et copiez-collez le code ci-dessus
- Sauvegardez le fichier sous le nom
hello.pydans un répertoire de votre choix - Ouvrez une invite de commande et naviguez vers le répertoire où vous avez sauvegardé le fichier (par exemple, si vous avez sauvegardé le fichier dans le répertoire
C:\Users\Alice\Documents, tapez la commandecd C:\Users\Alice\Documents) - Tapez la commande
python hello.pyet appuyez sur Entrée
Vous devriez voir s’afficher dans l’invite de commande :
Hello, world !
Félicitations ! Vous avez écrit et exécuté votre premier programme en Python !
Dans ce programme,
-
Nous avons utilisé la fonction
print(), qui permet d’afficher du texte ou des valeurs à l’écran. Une fonction est un bloc de code qui réalise une tâche spécifique et qui peut être appelée avec son nom suivi de parenthèses. Entre les parenthèses, on peut passer des arguments à la fonction, c’est-à-dire des valeurs ou des expressions que la fonction utilise pour réaliser sa tâche. Dans notre cas, nous avons passé comme argument une chaîne de caractères entre guillemets, qui représente du texte.
-
Nous avons utilisé des guillemets doubles (
") pour délimiter la chaîne de caractères. En Python, on peut aussi utiliser des guillemets simples (') pour délimiter les chaînes de caractères. L’important est d’être cohérent et d’utiliser le même type de guillemets au début et à la fin de la chaîne.
Essayez maintenant d’écrire et d’exécuter votre propre programme en Python qui affiche un message différent. Par exemple :
# Mon deuxième programme en Python
print("Bonjour tout le monde !")
Leçon 3 : Utiliser des variables pour stocker des valeurs
Dans un programme, il est souvent utile de stocker des valeurs pour les réutiliser plus tard ou les modifier. Pour cela, on utilise des variables.
Une variable est un nom qui fait référence à une valeur stockée en mémoire. En Python, pour créer une variable, il suffit d’utiliser le symbole = pour affecter une valeur à un nom. Par exemple :
x = 42 # On crée une variable x et on lui affecte la valeur 42
y = "Hello" # On crée une variable y et on lui affecte la valeur "Hello"
Une fois qu’une variable est créée, on peut l’utiliser dans le code comme si c’était sa valeur. Par exemple :
x = 42
y = "Hello"
print(x) # Affiche 42
print(y) # Affiche Hello
print(x + y) # Affiche 42Hello
On peut aussi modifier la valeur d’une variable en lui affectant une nouvelle valeur avec le symbole =. Par exemple :
x = 42
y = "Hello"
print(x) # Affiche 42
x = x + 1 # On modifie la valeur de x en lui ajoutant 1
print(x) # Affiche 43
y = y + " world !" # On modifie la valeur de y en lui concaténant du texte
print(y) # Affiche Hello world !
Quelques règles à respecter pour choisir les noms des variables :
- Les noms des variables doivent commencer par une lettre ou un underscore (
_) - Les noms des variables ne peuvent pas contenir d’espaces ou de caractères spéciaux comme
!,?,@, etc. - Les noms des variables sont sensibles à la casse, c’est-à-dire que
xetXsont deux variables différentes
Quelques bonnes pratiques pour choisir les noms des variables :
- Utiliser des noms significatifs qui décrivent le contenu ou l’usage de la variable (par exemple,
age,name,price, etc.) - Utiliser le style snake_case pour séparer les mots par des underscores (par exemple,
first_name,total_price, etc.) - Éviter d’utiliser des mots réservés du langage Python comme noms de variables (par exemple,
print,if,for, etc.)
Essayez maintenant d’écrire et d’exécuter votre propre programme en Python qui utilise des variables. Par exemple :
Par exemple :
# Un programme qui calcule l'aire d'un rectangle
# On crée deux variables pour stocker la longueur et la largeur du rectangle
length = 10
width = 5
# On calcule l'aire du rectangle en multipliant la longueur par la largeur
area = length * width
# On affiche le résultat à l'écran avec un message explicatif
print("L'aire du rectangle est", area)
Leçon 4 : Utiliser des types de données comme les nombres, les chaînes de caractères et les booléens
En Python, les valeurs que l’on peut stocker dans des variables ou manipuler avec des opérateurs ont un type de données. Le type de données détermine la nature et le comportement de la valeur.
Il existe plusieurs types de données en Python, mais dans ce module, nous allons nous concentrer sur trois types principaux :
- Les nombres : ils représentent des valeurs numériques entières ou décimales. Il existe deux sous-types de nombres en Python : les entiers (
int) et les réels (float). - Les chaînes de caractères : elles représentent du texte entre guillemets. Le type des chaînes de caractères est
str. - Les booléens : ils représentent des valeurs logiques vraies ou fausses. Il existe deux valeurs booléennes en Python :
TrueetFalse. Le type des booléens estbool.
Pour connaître le type d’une valeur ou d’une variable en Python, on peut utiliser la fonction type(), qui renvoie le nom du type entre crochets. Par exemple :
x = 42
y = "Hello"
z = True
print(type(x)) # Affiche <class 'int'>
print(type(y)) # Affiche <class 'str'>
print(type(z)) # Affiche <class 'bool'>
Les différents types de données ont des propriétés et des opérations spécifiques.
Les nombres
Les nombres sont utilisés pour représenter des quantités ou des mesures. On peut effectuer des opérations arithmétiques sur les nombres avec les opérateurs suivants :
- L’addition (
+) : elle permet d’ajouter deux nombres. Par exemple :x + y - La soustraction (
-) : elle permet de soustraire deux nombres. Par exemple :x - y - La multiplication (
*) : elle permet de multiplier deux nombres. Par exemple :x * y - La division (
/) : elle permet de diviser deux nombres. Par exemple :x / y - La division entière (
//) : elle permet de diviser deux nombres et d’obtenir le quotient entier. Par exemple :x // y - Le modulo (
%) : il permet d’obtenir le reste d’une division entière. Par exemple :x % y - L’exponentiation (
**) : elle permet d’élever un nombre à une puissance. Par exemple :x ** y
Par exemple :
x = 10
y = 3
print(x + y) # Affiche 13
print(x - y) # Affiche 7
print(x * y) # Affiche 30
print(x / y) # Affiche 3.3333333333333335
print(x // y) # Affiche 3
print(x % y) # Affiche 1
print(x ** y) # Affiche 1000
Les opérateurs arithmétiques suivent les règles habituelles de priorité et d’associativité. On peut utiliser des parenthèses pour modifier l’ordre d’évaluation des expressions.
Par exemple :
x = 10
y = 3
z = 2
# Sans parenthèses, l'exponentiation est prioritaire sur la multiplication et la division,
# qui sont prioritaires sur l'addition et la soustraction
print(x + y * z ** z) # Équivaut à x + (y * (z ** z))
# Affiche 22
# Avec parenthèses, on change l'ordre d'évaluation
print((x + y) * z ** z) # Équivaut à ((x + y) * (z ** z))
# Affiche 169
Lorsqu’on effectue une opération arithmétique entre un nombre entier et un nombre réel, le résultat est un nombre réel.
Par exemple :
x = 10 # x est un nombre entier (int)
y = 3.5 # y est un nombre réel (float)
z = x + y
# z est un nombre réel (float), car il résulte d'une opération entre un int et un float
print(z)
#
Les chaînes de caractères
Les chaînes de caractères sont utilisées pour représenter du texte ou des données alphanumériques. On peut effectuer des opérations sur les chaînes de caractères avec les opérateurs suivants :
- La concaténation (
+) : elle permet de joindre deux chaînes de caractères. Par exemple :"Hello" + " world !" - La répétition (
*) : elle permet de répéter une chaîne de caractères un certain nombre de fois. Par exemple :"Hello" * 3
Par exemple :
x = "Hello"
y = " world !"
z = x + y # On concatène x et y
print(z) # Affiche Hello world !
w = x * 3 # On répète x 3 fois
print(w) # Affiche HelloHelloHello
Les chaînes de caractères ont une propriété importante : elles sont indexables. Cela signifie qu’on peut accéder à chaque caractère d’une chaîne en utilisant son indice (ou position) entre crochets.
Par exemple :
x = "Hello"
print(x[0]) # Affiche H
print(x[1]) # Affiche e
print(x[2]) # Affiche l
print(x[3]) # Affiche l
print(x[4]) # Affiche o
Remarquez que les indices commencent à 0 et non à 1 en Python.
On peut aussi utiliser des indices négatifs pour accéder aux caractères en partant de la fin de la chaîne.
Par exemple :
x = "Hello"
print(x[-1]) # Affiche o
print(x[-2]) # Affiche l
print(x[-3]) # Affiche l
print(x[-4]) # Affiche e
print(x[-5]) # Affiche H
On peut également utiliser des tranches (ou slices) pour extraire une sous-chaîne d’une chaîne. Une tranche s’écrit avec le symbole : entre deux indices, qui indiquent le début et la fin (exclue) de la sous-chaîne.
Par exemple :
x = "Hello"
y = x[1:4] # On extrait la sous-chaîne qui commence à l'indice 1 et qui se termine
avant l'indice 4
# C'est-à-dire les trois caractères e, l et l
# Remarquez que le premier indice est inclus mais pas le second
print(y) # Affiche ell
z = x[:2] # On extrait la sous-chaîne qui commence au début et qui se termine avant l'indice 2
# C'est-à-dire les deux premiers caractères H et e
# Remarquez qu'on peut omettre le premier indice si on veut partir du début
print(z) #
Affiche He
w = x[3:] # On extrait la sous-chaîne qui commence à l'indice 3 et qui se termine à la fin
# C'est-à-dire les deux derniers caractères l et o
# Remarquez qu'on peut omettre le second indice si on veut aller jusqu'à la fin
print(w) #
Affiche lo
v = x[:] # On extrait toute la chaîne
# C'est équivalent à faire une copie de x
# Remarquez qu'on peut omettre les deux indices si on veut prendre toute la chaîne
print(v) #
Affiche Hello
u = x[-3:-1] # On extrait la sous-chaîne qui commence à l'indice -3 et qui se termine avant l'indice -1
# C'est-à-dire les deux caractères du milieu l et l
# Remarquez qu'on peut utiliser des indices négatifs dans une tranche
print(u) #
Affiche ll
t = x[::-1]
# On extrait toute la chaîne en inversant l'ordre des caractères
# C'est équivalent à faire un renversement de x
# Remarquez qu'on peut utiliser un troisième indice dans une tranche pour indiquer le pas (ou step)
# Le pas est le nombre d'indices que l'on saute entre chaque élément de la tranche
#
Par exemple :
x = "Hello"
print(t) # Affiche olleH
s = x[::2] # On extrait toute la chaîne en sautant un caractère sur deux
# C'est-à-dire les caractères H, l et o
print(s) # Affiche Hlo
Les chaînes de caractères sont immuables en Python, ce qui signifie qu’on ne peut pas modifier un caractère d’une chaîne directement. Si on veut changer une chaîne, il faut créer une nouvelle chaîne avec les modifications voulues.
Par exemple :
x = "Hello"
x[0] = "J" # Erreur : on ne peut pas modifier un caractère d'une chaîne
y = "J" + x[1:] # On crée une nouvelle chaîne en concaténant J et la sous-chaîne x[1:]
# C'est-à-dire les caractères e, l, l et o
print(y) # Affiche Jello
Les chaînes de caractères ont de nombreuses méthodes qui permettent de les manipuler facilement. Une méthode est une fonction qui s’applique à un objet (ici une chaîne) et qui renvoie généralement un résultat. On appelle une méthode en utilisant le symbole . après le nom de l’objet, suivi du nom de la méthode et des éventuels paramètres entre parenthèses.
Par exemple :
x = "Hello"
y = x.upper() # On appelle la méthode upper() sur x
# Cette méthode renvoie une nouvelle chaîne où tous les caractères sont en majuscules
print(y) # Affiche HELLO
z = x.lower() # On appelle la méthode lower() sur x
# Cette méthode renvoie une nouvelle chaîne où tous les caractères sont en minuscules
print(z)
# Affiche hello
w = x.replace("l", "p") # On appelle la méthode replace() sur x avec deux paramètres : "l" et "p"
# Cette méthode renvoie une nouvelle chaîne où toutes les occurrences du premier paramètre sont remplacées par le second paramètre
print(w)#
Affiche Heppo
Il existe beaucoup d’autres méthodes pour les chaînes de caractères, que vous pouvez consulter dans la documentation officielle de Python : https://docs.python.org/fr/3/library/stdtypes.html#string-methods
Les booléens
Les booléens sont utilisés pour représenter des valeurs logiques vraies ou fausses. On peut effectuer des opérations logiques sur les booléens avec les opérateurs suivants :
- Le
etlogique (and) : il renvoieTruesi les deux opérandes sontTrue, sinon il renvoieFalse. Par exemple :True and False - Le
oulogique (or) : il renvoieTruesi au moins un des opérandes estTrue, sinon il renvoieFalse. Par exemple :True or False - La négation logique (
not) : elle inverse la valeur logique d’un opérande. Par exemple :not True
Par exemple :
x = True
y = False
z = x and y
# z vaut False car x et y ne sont pas tous les deux vrais
print(z)
w = x or y
# w vaut True car au moins un des opérandes est vrai
print(w)
v = not x
# v vaut False car on inverse la valeur de x
print(v)
Les opérateurs logiques suivent les règles habituelles de priorité et d’associativité. On peut utiliser des parenthèses pour modifier l’ordre d’évaluation des expressions.
Par exemple :
x = True
y = False
# Sans parenthèses, la négation est prioritaire sur le et logique,
# qui est prioritaire sur le ou logique
print(x and not y or y and not x)
# Équivaut à ((x and (not y)) or (y and (not x)))
# Affiche True
# Avec parenthèses, on change l'ordre d'évaluation
print(not (x and y) or not (x or y))
#
Équivalent à ((not (x and y)) or (not (x or y)))Affiche True
Les booléens sont souvent le résultat de comparaisons entre des valeurs numériques ou des chaînes de caractères.
On peut utiliser les opérateurs de comparaison suivants :
- L'égalité (`==`) : il renvoie `True` si les deux opérandes sont égaux, sinon il renvoie `False`. Par exemple : `3 == 4`
- La différence (`!=`) : il renvoie `True` si les deux opérandes sont différents, sinon il renvoie `False`. Par exemple : `3 != 4`
- Le plus petit que (`<`) : il renvoie `True` si le premier opérande est strictement plus petit que le second, sinon il renvoie `False`. Par exemple : `3 < 4`
- Le plus grand que (`>`) : il renvoie `True` si le premier opérande est strictement plus grand que le second, sinon il renvoie `False`. Par exemple : `3 > 4`
- Le plus petit ou égal (`<=`) : il renvoie `True` si le premier opérande est plus petit ou égal au second, sinon il renvoie `False`. Par exemple : `3 <= 4`
- Le plus grand ou égal (`>=`) : il renvoie `True` si le premier opérande est plus grand ou égal au second, sinon il renvoie `False`. Par exemple : `3 >= 4`
Par exemple :
```python
x = 3
y = 4
z = x == y # z vaut False car x et y ne sont pas égaux
print(z)
w = x != y # w vaut True car x et y sont différents
print(w)
v = x < y # v vaut True car x est plus petit que y
print(v)
u = x > y # u vaut False car x n'est pas plus grand que y
print(u)
t = x <= y # t vaut True car x est plus petit ou égal à y
print(t)
s = x >= y # s vaut False car x n'est pas plus grand ou égal à y
print(s)
Les comparaisons entre des chaînes de caractères se font selon l’ordre alphabétique, en tenant compte des majuscules et des minuscules.
Par exemple :
x = "Hello"
y = "World"
z = "hello"
print(x == z) # Affiche False car les majuscules et les minuscules comptent
print(x < y) # Affiche True car H vient avant W dans l'ordre alphabétique
print(y > z) #
Affiche False car W vient après h dans l'ordre alphabétique
Les variables
Les variables sont utilisées pour stocker des valeurs dans la mémoire de l’ordinateur. On peut affecter une valeur à une variable avec l’opérateur d’affectation (=). On peut accéder à la valeur d’une variable en utilisant son nom.
Par exemple :
x = 3 # On affecte la valeur 3 à la variable x
print(x) # On affiche la valeur de x
y = x + 2 # On affecte la valeur de x + 2 à la variable y
print(y) # On affiche la valeur de y
x = 5 # On change la valeur de x en lui affectant 5
print(x) # On affiche la nouvelle valeur de x
print(y) # On affiche la valeur de y qui n'a pas changé
Les noms des variables doivent respecter certaines règles en Python :
- Ils doivent commencer par une lettre ou un underscore (
_). - Ils ne peuvent contenir que des lettres, des chiffres ou des underscores.
- Ils ne peuvent pas être des mots réservés du langage (comme
and,or,not, etc.). - Ils sont sensibles à la casse (c’est-à-dire que les majuscules et les minuscules comptent).
Par exemple :
x = 3 # Valide
_abc = 4 # Valide
hello_world = 5 # Valide
3x = 6 # Invalide car commence par un chiffre
x+y = 7 # Invalide car contient un caractère spécial (+)
and = 8 #
Invalide car est un mot réservé du langage
X = 9 #
Valide mais différent de x car sensible à la casse
Il est recommandé de choisir des noms de variables explicites et cohérents, qui décrivent le rôle ou le sens de la variable dans le programme.
Par exemple :
age = 25 # Mieux que x ou a
nom = "Alice" # Mieux que y ou n
prix_ttc = prix_ht * (1 + taux_tva / 100) #
Mieux que z ou p
Les variables peuvent être utilisées pour stocker différents types de valeurs, comme des nombres entiers, des nombres réels, des chaînes de caractères ou des booléens. On peut connaître le type d’une variable avec la fonction type().
Par exemple :
x = 3
y = 3.14
z = "Hello"
w =
True
print(type(x)) # Affiche <class ‘int’> car x est un entier print(type(y)) # Affiche <class ‘float’> car y est un réel print(type(z)) # Affiche <class ‘str’> car z est une chaîne de caractères print(type(w)) # Affiche <class ‘bool’> car w est un booléen
On peut changer le type d'une variable avec des fonctions de conversion,
comme `int()`, `float()`, `str()` ou `bool()`.
Par exemple :
```python
x = 3
y = 3.14
z = "Hello"
w = True
x = float(x) # On convertit x en réel
y = int(y) # On convertit y en entier
z = bool(z) # On convertit z en booléen
w = str(w) # On convertit w en chaîne de caractères
print(type(x)) # Affiche <class 'float'> car x est maintenant un réel
print(type(y)) # Affiche <class 'int'> car y est maintenant un entier
print(type(z)) # Affiche <class 'bool'> car z est maintenant un booléen
print(type(w)) #
Affiche <class 'str'> car w est maintenant une chaîne de caractères
En conclusion, nous avons vu comment utiliser les variables en Python, et comment manipuler différents types de valeurs comme les nombres, les chaînes de caractères et les booléens.
Nous avons également appris à effectuer des opérations arithmétiques, logiques et de comparaison sur ces valeurs, et à changer le type d’une variable avec des fonctions de conversion. Les variables sont des éléments essentiels de la programmation en Python, car elles permettent de stocker et de manipuler des données dans la mémoire de l’ordinateur.
Dans le prochain article, nous verrons comment utiliser les structures conditionnelles et les boucles pour contrôler le flux d’exécution d’un programme en Python.
A découvrir aussi
- La programmation orientée objet
- Maîtriser les expressions régulières en Python
- LES OPÉRATEURS EN PYTHON : ARITHMÉTIQUES, COMPARAISONS, LOGIQUES, TERNAIRES
Membres qui aiment ce contenu
Inscrivez-vous au site
Soyez prévenu par email des prochaines mises à jour
Rejoignez les 4 autres membres