Bases du langage Python

Syntaxe de base⚓︎

Affecter une variable⚓︎

Affectation d'une valeur à une variable

Interprétation	Pseudo-code	Python	Illustration
x prend la valeur 8	x ← 8	`x = 8`

Principaux types de données⚓︎

Principaux types de données

Les principaux types de données manipulées en Python sont :

Les entiers (type int) ;
Les flottants (type float, assimilables aux décimaux) ;
Les booléens (type bool) de valeurs True ou False, résultats d'un test ;
Les chaînes de caractères (type str) qui représentent les textes ;
Les listes (type list) qui sont des séquences d'objets.

Noms des variables en Python⚓︎

Noms des variables en Python

Règles à retenir d'après les règles PEP 8 \(^{(*)}\) :

Un nom de variable peut commencer avec une lettre minuscule (a à z) ou un underscore (_) pas avec un chiffre.
Il peut contenir des lettres minuscules, des chiffres et des underscores.
Il ne peut pas être un mot-clé réservé de Python (ex : if, else, while, etc.).
Il ne peut pas contenir d'espaces ou de caractères spéciaux (sauf _).

\(^{(*)}\) : PEP 8 : recommandations officielles pour uniformiser le code et respecter de bonnes pratiques)

Noms de variables conformes à la PEP 8 :

La PEP 8 recommande d'utiliser des noms en minuscules, avec des underscores pour séparer les mots (style « snake_case »).

Nom de variable	Explication
`ma_variable`	Minuscules et underscore pour séparer les mots.
`nombre_etudiants`	Clair et descriptif, en snake_case.
`compteur`	Simple et en minuscules.
`_variable_interne`	Underscore initial pour indiquer une variable « interne » (convention).
`VALEUR_MAX`	Constante en majuscules (convention PEP 8 pour les constantes).

Noms de variables non conformes à la PEP 8 :

Ces noms sont techniquement valides en Python, mais ne respectent pas les conventions de la PEP 8 :

Nom de variable	Raison de non-conformité
`MaVariable`	Utilise le style « CamelCase » (réservé aux noms de classes).
`nombreEtudiants`	CamelCase au lieu de snake_case.
`VALEUR_max`	Constante en majuscules partielles (il aurait fallu écrire : `VALEUR_MAX`).
`variable1`	Pas assez descriptif (même si techniquement valide).

Recommandations conformes aux règles PEP 8 :

Minuscules et underscores (_) : utilisez le style snake_case pour les variables et fonctions (ex: ma_variable).
Majuscules et underscores pour les constantes : les constantes (valeurs immuables) doivent être en majuscules avec des underscores (ex: VALEUR_MAX).
Évitez les noms trop courts : préférez des noms descriptifs (ex: nbre_etudiants plutôt que n).
Pas de style CamelCase : réservé aux noms de classes (ex: MaVoiture).
Underscore initial : pour les variables « internes » ou « privées » (ex: _variable_interne).

Exemples concrets

Type de variable	Nom de la variable	Exemple de valeur
Entier (`int`)	`age_utilisateur`	`18`
"	`TAUX_TVA`	`20`
Flottant (`float`)	`prix_produit`	`19.99`
"	`PI`	`3.14159`
Booléen (`bool`)	`est_connecte`	`True`
Chaîne de caractères (`str`)	`message_bienvenue`	`"Bonjour !"`
Liste (`list`)	`notes_etudiants`	`[12, 15, 18, 9]`

Pourquoi suivre ces conventions ?

Lisibilité : le code est plus facile à comprendre pour toi et les autres développeurs.
Maintenabilité : un code cohérent est plus simple à modifier ou à déboguer.
Professionnalisme : respecter le PEP 8 est une marque de qualité en Python.

Commentaires⚓︎

Commentaires

En Python, les commentaires sont des lignes de texte ignorées par l’interpréteur. Ils servent juste à expliquer le code pour les développeurs. Voici comment les utiliser :

Commentaire sur une seule ligne

Pour commenter une ligne entière ou une partie de ligne, utilisez le symbole #.

🐍 Editeur

# Ceci est un commentaire sur une seule ligne
age = 25  # Ce commentaire explique la variable 'age'

Commentaire multilignes

Pour commenter plusieurs lignes, utilisez des chaînes de caractères multiligne (triples apostrophes ''' ou triples guillemets """).

🐍 Editeur

"""
Ceci est un commentaire multiligne.
Utile pour documenter du code.
"""
'''
Ceci est un autre commentaire multiligne.
Utile pour documenter du code.
'''

Bonnes pratiques

Clarté : expliquez pourquoi le code fait quelque chose, pas ce qu’il fait (le code doit être lisible).

Éviter les commentaires évidents :

🐍 Editeur

# Incrémente x de 1 (inutile, le code est clair)
x = x + 1

Documentation (ou « Docstrings ») : utilisez les chaînes de documentation ('''…''' ou """…""") pour documenter les fonctions, classes et modules.

Synthèse

Type	Rôle
`# commentaire`	Ajouter un commentaire monoligne en début ou en fin de ligne
`"""` `commentaire` `"""` ou `'''` `commentaire` `'''`	Ajouter un commentaire multiligne

Indentation du code⚓︎

Indentation du code

En Python, l’indentation joue un rôle fondamental et unique par rapport à la plupart des autres langages. Voici pourquoi elle est si importante :

Définition de l’indentation

L’indentation est l’espace (généralement 4 espaces ou une tabulation) placé au début d’une ligne de code pour structurer visuellement et logiquement les blocs d’instructions.

Rôle principal : Définir les blocs de code

En Python, l’indentation remplace les accolades ({}) ou les mots-clés comme end utilisés dans d’autres langages (C, Java, Ruby, etc.). Elle permet de :

Délimiter les blocs de code (boucles, conditions, fonctions, classes, etc.).
Indiquer l’appartenance d’une ligne à un bloc spécifique.
Exemple :

🐍 Editeur

if age >= 18:
    print("Majeur")  # Ce print appartient au bloc 'if'
    print("Bienvenue")  # Toujours dans le bloc 'if'
print("Fin du programme")  # Hors du bloc 'if' (pas d'indentation)

Règles à respecter

4 espaces par niveau : c’est la convention officielle (PEP 8). Évitez les tabulations pour éviter les incompatibilités.
Alignement strict : toutes les lignes d’un même bloc doivent avoir la même indentation.
Erreur de syntaxe : une mauvaise indentation provoque une erreur (IndentationError).

Problème d'indentationProblème résolu

Évaluations restantes : ∞/∞

Les sorties⚓︎

La fonction print

Pour afficher du texte ou des nombres, on utilise la fonction print.

Affichage d'une chaîneAffichage d'un entierAffichages mutliplesAffichages sans saut de ligne

Évaluations restantes : ∞/∞

Les entrées⚓︎

La fonction input

Lorsqu’un programme demande de saisir des informations au clavier on utilise la fonction input.

Saisie d’une chaîneSaisie d’un entierSaisie d’un nombre à virgule

Évaluations restantes : ∞/∞

Les calculs avec Python⚓︎

Principaux opérateurs en Python

opérateur	opération
`+`	addition
`-`	soustraction
*``**	multiplication
`/`	division
``**	puissance
`//`	quotient de la division entière
`%`	reste de la division entière
`int`	partie entière
`round`	valeur approchée

Utilisation des opérateurs

Lorsqu’un programme demande de saisir des informations au clavier on utilise la fonction input.

Addition, soustraction, multiplication et divisionPuissance, quotient et resteFonctions int et round

Évaluations restantes : ∞/∞

Ecriture des nombres⚓︎

Ecriture des nombres

Nombres entiersNombres décimauxEcriture scientifiqueLa fonction type

Nombres de type int (pour « integer »)

Évaluations restantes : ∞/∞

Nombres de type float pour « floating-point numbers », nombres à virgule flottante)

Évaluations restantes : ∞/∞

Pour déterminer le type d'une variable, on peut utiliser la fonction type.

Évaluations restantes : ∞/∞

Instructions conditionnelles⚓︎

Rôles de `if`, `elif` et `else`⚓︎

L’instruction if permet d’exécuter un bloc de code uniquement si une condition est vraie.
L'instruction elif (contraction de else if) permet de tester une nouvelle condition si la précédente était fausse. On peut enchaîner plusieurs elif.
L'instruction else permet d’exécuter un bloc de code si aucune des conditions précédentes n’est vraie. Il n’y a pas de condition à spécifier après else.

Instructions conditionnelles

Utilisation de ifUtilisation de if et elseUtilisation de if, elif et else

Évaluations restantes : ∞/∞

Les opérateurs de test⚓︎

Tests en Python 3

Test en Python 3	Teste si
`if (n == 0):`	`n` est égal à `0` (zéro)
`if (n > 0):`	`n` est positif
`if (n != 34 ):`	`n` est différent de `34`
`if (n > 0) and (n < 10):`	`n` est compris strictement entre `0` et `10`
`if 0 < n < 10 :`	`n` est compris strictement entre `0` et `10`
`if (n < 0) or (n >= 10):`	`n` est négatif ou supérieur ou égal à `10`
`if (n%5 == 0):`	`n` est divisible par `5`

Différence entre `=` et `==`⚓︎

= est un opérateur d'affectation permettant d'affecter une valeur à une varaiable.
n = 10 équivaut à stocker 10 dans la variable n : n \(\gets\) 10.
== est un opérateur de comparaison (test d'égalité).
n == 10 équivaut à se poser la question est-ce que n vaut 10 ? : n \(\overset{?}{=}\) 10

Différence entre affectation (=) et comparaison (==)

Affectation =Comparaison ==

Évaluations restantes : ∞/∞

Boucles bornées `for … in …`⚓︎

En Python, les boucles bornées (ou boucles for) jouent un rôle central pour itérer sur des séquences ou des collections d’éléments un nombre déterminé de fois.
Les boucles bornées sont idéales pour :
- Répéter une action un nombre connu de fois (ex : traiter chaque ligne d’un fichier).
- Éviter les erreurs de dépassement (contrairement aux boucles while, où la condition doit être soigneusement gérée).

Boucles `for` avec `range`⚓︎

Boucles for avec range

Avec range(n)Avec range(debut, fin)Avec range(debut, fin, pas)Décroissante avec range(debut, fin, pas)

Remarque : Toute instruction indentée à partir de l'instrction for fait partie de la boucle.

Évaluations restantes : ∞/∞

Remarque : Ce programme affiche les nombres de 3 à 7 (8 non inclus).

Évaluations restantes : ∞/∞

Remarque : Ce programme affiche les nombres pairs de 2 à 10 (pas de 3).

Évaluations restantes : ∞/∞

Remarque : Ce programme affiche un compte à rebours de 5 à 1.

Évaluations restantes : ∞/∞

Boucles `for` avec itération sur des séquences⚓︎

Les boucles for permettent de parcourir chaque élément d’une séquence (liste, tuple, chaîne de caractères, dictionnaire, etc.) sans avoir à gérer manuellement un compteur.

Boucles for avec itération sur des séquences

Boucle sur une listeBoucle sur un tupleBoucle sur une chaîne

Évaluations restantes : ∞/∞

Boucles non bornées `while`⚓︎

Les boucles non bornées (ou boucles indéfinies) sont implémentées avec la structure while (« tant que »). Contrairement aux boucles bornées for, qui s'exécutent un nombre prédéfini de fois, les boucles while continuent de s'exécuter tant qu'une condition est vraie.
Les boucles bornées sont idéales pour :
- Exécuter une action (lecture de données, attente entrée utilisateur, traitement d'évènements en temps réel) jusqu'à ce qu'une condition soit remplie.
- Gérer des processus continus (tâches tournant en continu).
- Itérer jusqu'à ce qu'une ressource soit épuisée (lecture d'un flux de données).
- Implémenter des algorithmes itératifs (recherche dichotomique, métodes numériques).

Attention aux risques !!!

Boucles infinies : si la condition ne devient jamais fausse, la boucle ne s'arrête jamais. Il faut toujours prévoir une condition de sortie (ou utiliser break).
Consommation de ressources : une boucle mal conçue peut bloquer le programme ou consommer trop de mémoire/CPU.

Nombre d’itérations connu à l’avance⚓︎

Exemple de deux programmes équivalents

Boucle forBoucle while

Évaluations restantes : ∞/∞

Nombre d’itérations non connu à l’avance⚓︎

Exemple de programme

Évaluations restantes : ∞/∞

Les chaînes de caractères⚓︎

Chaîne délimitée avec " " ou ' '⚓︎

En Python, les chaînes de caractères (ou strings) sont des séquences de caractères (de type str pour « string ») utilisées pour représenter du texte.

Initialisation d'une chaîne de caractères

Avec des guillemets "…"Avec des apostrophes '…'Pour aller plus loin …

Évaluations restantes : ∞/∞

Remarques :

\n insère un retour à la ligne.
\' insère une apostrophe dans une chaîne délimitée par des apostrophes.
\" insère des guillemets dans une chaîne délimitée par des guillemets.
\ est un caractère d'échappement qui permet :
- d'éviter les erreurs de syntaxe : sans \' ou \", Python interpréterait l'apostrophe comme la fin de la chaîne.
- plus de clarté en permettant d'inclure des caractères spéciaux sans changer le type de délimiteur de la chaîne.

Évaluations restantes : ∞/∞

Accès aux caractères d’une chaîne⚓︎

Indices des caractères d'une chaîne

Accès par indice positifAccès par indice négatif

Évaluations restantes : ∞/∞

Opérations sur les chaînes⚓︎

Opérations sur chaînes

Concaténation de chaînes

La concaténation est l’opération qui consiste à assembler deux ou plusieurs chaînes de caractères (ou d’autres types de données compatibles) pour en former une seule.

Concaténation n° 1Concaténation n° 2

Évaluations restantes : ∞/∞

Autres opérations sur les chaînes

Fonction len()Fonction str()Fonction int()Fonction float

La fonction len() est utilisée pour obtenir la longueur (le nombre de caractères) d'une chaîne de caractères (str)

Évaluations restantes : ∞/∞

La fonction str() permet de convertir un objet en chaîne de caractères (type str). Elle est particulièrement utile pour transformer des nombres(int ou float), des listes (list), des booléens (bool), ou d'autres types de données en texte, afin de les afficher, les concaténer ou les manipuler comme des chaînes.

Évaluations restantes : ∞/∞

La fonction int() permet de convertir un objet en un nombre entier (type int). Elle est très utile pour transformer des chaînes de caractères (str), des flottants (float) ou d'autres types de données en entiers.

Évaluations restantes : ∞/∞

La fonction float() permet de convertir un objet en un nombre à virgule flottante (type float). Elle est très utile pour transformer des chaînes de caractères (str), des entiers (int), ou d'autres types de données en nombres décimaux.

Évaluations restantes : ∞/∞

Les listes⚓︎

Une liste est une collection d’éléments écrits entre crochets [] et séparés par des virgules ,.

Exemples : ["pomme", "poire" , "banane"], [1, 2, 5, 10, 20 , 50, 100, 200]

Indices des éléments d'une liste⚓︎

Indices des éléments d'une liste

Accèder à un élément d'une listeModifier un élément d'une liste

Évaluations restantes : ∞/∞

Fonctions et méthodes liées aux listes⚓︎

Fonctions et méthodes liées aux listes

Fonction len()Fonction del()Méthode .append()Méthode .index()Méthode .remove()

La fonction len() permet de connaître la longueur (ou le nombre d'éléments) d'une liste. Elle retourne un entier (int) représentant le nombre total d'éléments dans la liste.

Évaluations restantes : ∞/∞

La fonction del() permet de supprimer un élément ou une tranche d'une liste (ou d'autres objets comme des dictionnaires, des variables, etc.).

Évaluations restantes : ∞/∞

La méthode .append() est utilisée pour ajouter un élément à la fin d'une liste. Elle modifie la liste en place (c'est-à-dire qu'elle ne crée pas une nouvelle liste, mais ajoute l'élément directement à la liste existante).

Évaluations restantes : ∞/∞

La méthode .index() permet de trouver l'index de la première occurrence d'une valeur donnée dans une liste. Si la valeur n'est pas trouvée, elle lève une erreur ValueError.

Évaluations restantes : ∞/∞

La méthode .remove() en Python est utilisée pour supprimer la première occurrence d'une valeur spécifique dans une liste. Si la valeur n'est pas trouvée, elle lève une erreur ValueError.

Évaluations restantes : ∞/∞

Listes en compréhension⚓︎

Listes avec range()

Une liste en compréhension s'obtient en seule ligne de code :
Exemple :liste = [i for i in range(start, stop, step)]

Avantages des listes en compréhension :

Plus lisibles que les boucles for classiques pour des opérations simples.
Plus rapides dans certains cas, car optimisées par Python.
Moins de code pour une même fonctionnalité.

Avec range(n)Avec range(debut, fin)Avec range(debut, fin, pas)Avec une condition

Évaluations restantes : ∞/∞

Fonctions et procédures⚓︎

Les fonctions⚓︎

Définition :

Une fonction est un bloc de code qui effectue une tâche spécifique et retourne un résultat.
En Python, une fonction est définie avec le mot-clé def. Tout le corps de la fonction doit être indenté.

Rôles principaux :

Réutilisabilité : Éviter de répéter le même code en le regroupant dans une fonction.
Modularité : Diviser un programme complexe en petites tâches simples et indépendantes.
Abstraction : Masquer les détails de l'implémentation pour se concentrer sur ce que fait la fonction, et non sur comment elle le fait.
Clarté : Rendre le code plus lisible et plus facile à maintenir.

Exemples de fonctions

Une fonction admet un ou plusieurs paramètres et retourne une valeur.

Fonction à 1 paramètreFonction à 2 paramètresFonction à 3 paramètres

Évaluations restantes : ∞/∞

Les procédures⚓︎

Définition :

Une procédure est un bloc de code qui effectue une tâche spécifique, mais ne retourne pas de résultat.
En Python, une procédure est simplement une fonction qui ne contient pas d'instruction return (ou qui retourne implicitement None).

Rôles principaux :

Exécuter des actions : Effectuer une série d'opérations sans avoir besoin de retourner un résultat.
Encapsulation : Regrouper des instructions pour éviter la répétition et améliorer la lisibilité.
Effets de bord : Les procédures peuvent modifier des variables globales ou des états externes (comme afficher un message ou écrire dans un fichier).

Exemples de procédures

Une fonction qui n’admet pas d’argument ou qui ne retourne pas de valeur est appelée procédure.

Procédure sans paramètreProcédure à 2 paramètresProcédure à 3 paramètres

Évaluations restantes : ∞/∞

Variable globale ou locale ?⚓︎

Portée des variables

Les effets de bord d'une procédure sont des modifications de l'état du programme qui ne sont pas directement liées à la valeur de retour de la procédure. En d'autres termes, une procédure avec des effets de bord modifie quelque chose en dehors de sa propre portée (par exemple, une variable globale, un fichier, l'affichage à l'écran, etc.).

Même nom mais variables différentesProgramme qui ne fonctionne pasVariable globale et effet de bord

Évaluations restantes : ∞/∞

Modules ou bibliothèques utiles⚓︎

Différence entre un module et une bibliothèque⚓︎

Module : un fichier Python contenant des fonctions, des classes et des variables.
Par exemple, math est un module.

Bibliothèque : une collection de modules.
Par exemple, la bibliothèque standard de Python contient plusieurs modules, dont math.

Déclaration des modules/bibliothèques utiles⚓︎

Déclaration des modules ou bibliothèques utiles

Avec rappel du nom obligatoireSans rappel du nom

Évaluations restantes : ∞/∞

Fonctions mathématiques⚓︎

Les fonctions mathématiques sont par exemple : sqrt(x), cos(x), sin(x), pi, …

Utilisation de fonctions mathématiques

Pour utiliser ces fonctions, il faut les importer à partir du module math.

Évaluations restantes : ∞/∞

Fonctions aléatoires⚓︎

Utilisation du module random

Le module random dispose des fonctions aléatoires random(), choice(), randint, …, que l'on peut importer pour si besoin.

Fonction random()Fonction choice()Fonction randint()

Évaluations restantes : ∞/∞

Graphiques avec la bibliothèque `matplotlib`⚓︎

Types et couleurs des points

Formes des points :

Type	Description
`'o'`	Cercle
`'s'`	Carré
`'^'`	Triangle haut

Couleurs des points :

Code	Couleur
`'b'`	Bleu
`'g'`	Vert
`'r'`	Rouge

Utilisation du module matplotlib

Au minimumAvec plus d’options

🐍 Editeur

import matplotlib.pyplot as plt  # as = alias pour raccourcir le nom

x, y = 0, 0
plt.plot(x, y, "ro")  # afficher un point rouge et rond
plt.show()            # terminer et montrer le graphique

Affichage :

🐍 Editeur

import matplotlib.pyplot as plt  # as = alias pour raccourcir le nom

x, y = 50, 20
plt.plot(x, y, "bs")  # afficher un point rouge (r) et carré (s)
plt.title("Titre du graphique")
xmin, xmax, ymin, ymax = -100, 100, -50, 50
plt.axis([xmin, xmax, ymin, ymax])  # Fenêtre d'affichage
plt.grid(True)  # afficher la grille
plt.ylabel("Texte pour les ordonnées")
plt.xlabel("Texte pour les abscisses")
plt.show()

Affichage :

Bases du langage Python

Syntaxe de base⚓︎

Affecter une variable⚓︎

Principaux types de données⚓︎

Noms des variables en Python⚓︎

Commentaires⚓︎

Indentation du code⚓︎

Les sorties⚓︎

Les entrées⚓︎

Les calculs avec Python⚓︎

Ecriture des nombres⚓︎

Instructions conditionnelles⚓︎

Rôles de if, elif et else⚓︎

Les opérateurs de test⚓︎

Différence entre = et ==⚓︎

Boucles bornées for … in …⚓︎

Boucles for avec range⚓︎

Boucles for avec itération sur des séquences⚓︎

Boucles non bornées while⚓︎

Nombre d’itérations connu à l’avance⚓︎

Nombre d’itérations non connu à l’avance⚓︎

Les chaînes de caractères⚓︎

Chaîne délimitée avec " " ou ' '⚓︎

Accès aux caractères d’une chaîne⚓︎

Opérations sur les chaînes⚓︎

Les listes⚓︎

Indices des éléments d'une liste⚓︎

Fonctions et méthodes liées aux listes⚓︎

Listes en compréhension⚓︎

Fonctions et procédures⚓︎

Les fonctions⚓︎

Les procédures⚓︎

Variable globale ou locale ?⚓︎

Modules ou bibliothèques utiles⚓︎

Différence entre un module et une bibliothèque⚓︎

Déclaration des modules/bibliothèques utiles⚓︎

Fonctions mathématiques⚓︎

Fonctions aléatoires⚓︎

Graphiques avec la bibliothèque matplotlib⚓︎

Rôles de `if`, `elif` et `else`⚓︎

Différence entre `=` et `==`⚓︎

Boucles bornées `for … in …`⚓︎

Boucles `for` avec `range`⚓︎

Boucles `for` avec itération sur des séquences⚓︎

Boucles non bornées `while`⚓︎

Graphiques avec la bibliothèque `matplotlib`⚓︎