Introduction à la Programmation Python : Concepts Essentiels et Syntaxe de Base

  1. Les Commentaires ===================

Les commentaires sont des notes explicatives incluses dans le code source d'un programme. Ils sont ignorés par l'interpréteur Python et ne sont pas exécutés. Leur objectif principal est d'améliorer la lisibilité du code pour les développeurs.

1.1. Utilité

  • Explication du code : Ils servent à clarifier des sections complexes du code, à documenter les décisions de conception ou à expliquer la logique derrière une implémentation particulière. Il est plus utile d'expliquer *pourquoi* une partie du code existe plutôt que de paraphraser ce qu'elle fait.
  • Débogage temporaier : Les commentaires peuvent être utilisés pour désactiver temporairement des lignes de code suspectes lors du processsus de débogage, aidant à isoler les problèmes.

1.2. Types de Commentaires

1.2.1. Commentaire sur une seule ligne

Utilisez le symbole dièse (#) pour marquer une ligne de commentaire. Tout ce qui suit # sur cette ligne est considéré comme un commentaire.

Exemple :

# Ceci est un commentaire d'une seule ligne
print("Bonjour le monde!")  # Affichage d'un message de bienvenue

message = "Apprendre Python"
# Le code ci-dessous pourrait contenir une logique complexe à expliquer
print(message)

Résultat :

Bonjour le monde!
Apprendre Python

1.2.2. Commentaires multi-lignes

Bien que Python ne dispose pas d'une syntaxe spécifique pour les commentaires multi-lignes comme d'autres langages, les chaînes de caractères littérales non assignées peuvent être utilisées comme commentaires. Elles sont généralement placées entre trois guillemets simples (''') ou trois guillemets doubles (""").

Exemple :

"""
Ceci est un commentaire
sur plusieurs lignes.
Il peut servir à décrire une fonction
ou un module entier.
"""
print("Exemple de texte.")

Résultat :

Exemple de texte.
  1. Variables et Constantes ==========================

2.1. Variables

2.1.1. Définition

Une variable est un conteneur nommé qui stocke une valeur. En Python, les variables sont créées au moment de l'affectation et peuvent changer de valeur au cours de l'exécution du programme. Elles permettent de référencer des données en mémoire.

Exemple :

valeur_initiale = 100
print(valeur_initiale)

valeur_initiale = 250 # La valeur de la variable est modifiée
print(valeur_initiale)

Résultat :

100
250

2.1.2. Règles de nommage des variables

  • Les noms de variables doivent commencer par une lettre (a-z, A-Z) ou un underscore (_).
  • Ils peuvent contenir des lettres, des chiffres (0-9) et des underscores.
  • Les noms de variables ne peuvent pas commencer par un chiffre.
  • Les noms ne doivent pas être des mots-clés réservés de Python (ex : if, for, while, class, etc. – les IDE les affichent souvent dans une couleur différente).
  • Il est recommandé d'utiliser des noms descriptifs et concis.
  • Évitez les noms trop courts ou non significatifs (ex : x, y à moins que ce ne soit pour des boucles simples).
  • Les noms de variables sont sensibles à la casse (maVariable est différent de mavarible).
  • Conventions :
    • Utilisez le snake_case (mots en minuscules séparés par des underscores) pour les noms de variables et de fonctions (ex : nom_utilisateur, calculer_somme).
    • Utilisez le CamelCase (chaque mot commence par une majuscule sauf le premier) ou le PascalCase (chaque mot commence par une majuscule) pour les noms de classes (ex : MaClasse).

Exemples de noms valides :

nombre = 10
_identifiant = "XYZ"
mon_texte = "texte"

Attention : L'affectation d'une chaîne de caractères diffère de l'affichage d'un nom de variable. Les guillemets indiquent une chaîne littérale.

prenom = "Alice"
print(prenom)      # Affiche la valeur de la variable 'prenom'
print("prenom")    # Affiche la chaîne littérale "prenom"

Résultat :

Alice
prenom

2.2. Constantes

Python n'a pas de mécanisme strict pour déclarer des constantes comme certains autres langages. Cependant, une convention est suivie pour indiquer qu'une variable ne doit pas être modifiée : on lui donne un nom en majuscules avec des underscores.

Exemple :

PI = 3.1415926535
MAX_UTILISATEURS = 1000

print(PI)
# Il est techniquement possible de modifier PI, mais ce n'est pas la convention
PI = 3.14
print(PI)

Résultat :

3.1415926535
3.14

Cette modification n'est pas recommandée car elle rompt la convention qui suggère que PI est une valeur fixe.

  1. Types de Données Fondamentaux ================================

Les types de données catégorisent les valeurs qu'une variable peut contenir et déterminent les opérations qui peuvent être effectuées sur ces valeurs.

3.1. Nombres

Python prend en charge les nombres entiers (int) et les nombres à virgule flottante (float).

age = 30         # int (entier)
prix = 99.99     # float (nombre à virgule flottante)

resultat_addition = age + 5
resultat_multiplication = prix * 2
print(f"Age: {age}, Prix: {prix}")
print(f"Age + 5: {resultat_addition}")
print(f"Prix * 2: {resultat_multiplication}")

Résultat :

Age: 30, Prix: 99.99
Age + 5: 35
Prix * 2: 199.98

3.2. Chaînes de Caractères (str)

Une chaîne de caractères est une séquence de caractères. Elles sont fondamentales pour manipuler du texte.

3.2.1. Déclaration de chaînes de caractères

Les chaînes peuvent être définies en utilisant des guillemets simples (' '), des guillemets doubles (" "), ou des triples guillemets (''' ''' ou """ """) pour des chaînes multi-lignes.

chaine_simple = 'Un mot'
chaine_double = "Une phrase entière"
chaine_multi_lignes = """Ceci est
une chaîne
sur plusieurs lignes."""

print(chaine_simple)
print(chaine_double)
print(chaine_multi_lignes)

Résultat :

Un mot
Une phrase entière
Ceci est
une chaîne
sur plusieurs lignes.

3.2.2. Opérations sur les chaînes de caractères

  • Concaténation (+) : Combine deux chaînes ou plus.
  • Répétition (*) : Répète une chaîne un certain nombre de fois.

Exemple de concaténation :

partie1 = "Salut, "
partie2 = "monde!"
message_complet = partie1 + partie2
print(message_complet)

Résultat :

Salut, monde!

Erreur courante : Tenter de concaténer une chaîne avec un nombre sans conversion explicite provoquera une erreur.

# cela générerait une erreur :
# print("Mon âge est : " + 25)

Exemple de répétition :

mot_repete = "Python " * 3
print(mot_repete)

Résultat :

Python Python Python

3.3. Booléens (bool)

Les booléens représentent des valeurs de vérité : True (vrai) ou False (faux). Ils sont cruciaux pour les conditions et les contrôles de flux.

est_majeur = True
a_un_permis = False

print(f"Est majeur : {est_majeur}")
print(f"A un permis : {a_un_permis}")

# Les booléens résultent souvent d'opérations de comparaison
print(10 > 5)  # True
print(20 < 15)  # False

Résultat :

Est majeur : True
A un permis : False
True
False
  1. Interaction Utilisateur Simple =================================

La fonction native input() permet de recevoir des données de l'utilisateur via la console. Elle affiche un message (facultatif) et attend que l'utilisateur entre du texte et appuie sur Entrée.

4.1. Utilisation de input()

La valeur retournée par input() est toujours une chaîne de caractères.

saisie1 = input("Entrez votre nom : ")
saisie2 = input("Entrez votre âge : ")

print(f"Bonjour, {saisie1}! Vous avez {saisie2} ans.")

Exemple d'exécution :

Entrez votre nom : Jean
Entrez votre âge : 30
Bonjour, Jean! Vous avez 30 ans.

4.2. Vérification du type de donnée

La fonction type() permet de connaître le type d'une variable ou d'une valeur.

valeur_saisie = input("Saisissez quelque chose : ")
print(f"Vous avez saisi : {valeur_saisie}")
print(f"Le type de la saisie est : {type(valeur_saisie)}")

Exemple d'exécution :

Saisissez quelque chose : 42
Vous avez saisi : 42
Le type de la saisie est : <class 'str'>

4.3. Conversion de type

Pour utiliser une saisie numérique comme un nombre, il est nécessaire de la convertir explicitement. Les fonctions de conversion courantes sont int() pour les entiers et float() pour les nombres décimaux.

nombre1_str = input("Saisissez le premier nombre : ")
nombre2_str = input("Saisissez le deuxième nombre : ")

# Conversion des chaînes en entiers
nombre1_int = int(nombre1_str)
nombre2_int = int(nombre2_str)

somme = nombre1_int + nombre2_int
print(f"La somme est : {somme}")

Exemple d'exécution :

Saisissez le premier nombre : 15
Saisissez le deuxième nombre : 25
La somme est : 40

Il est également possible de combiner input() et la conversion de type en une seule ligne :

nombre_a = int(input("Entrez un nombre A : "))
nombre_b = int(input("Entrez un nombre B : "))
produit = nombre_a * nombre_b
print(f"Le produit de A et B est : {produit}")

Exemple d'exécution :

Entrez un nombre A : 7
Entrez un nombre B : 6
Le produit de A et B est : 42
  1. Instructions Conditionnelles (if) ======================================

Les instructions conditionnelles permettent d'exécuter différents blocs de code en fonction de la vérité d'unee condition.

5.1. Syntaxe de base du if

L'instruction if évalue une expression booléenne. Si la condition est vraie, le bloc de code indenté est exécuté.

solde = 500
if solde > 200:
    print("Vous avez un solde suffisant.")
    print("Paiement autorisé.")
print("Opération terminée.")

Si solde est supérieur à 200, les deux lignes indentées s'affichent, suivies de "Opération terminée.". Sinon, seule "Opération terminée." s'affiche.

Résultat (avec solde = 500) :

Vous avez un solde suffisant.
Paiement autorisé.
Opération terminée.

Résultat (avec solde = 150) :

Opération terminée.

5.2. Structure if-else

Le bloc else est exécuté si la condition if est fausse.

age_saisi = int(input("Quel est votre âge ? "))
if age_saisi >= 18:
    print("Vous êtes majeur.")
else:
    print("Vous êtes mineur.")

Exemple d'exécution :

Quel est votre âge ? 20
Vous êtes majeur.
---
Quel est votre âge ? 16
Vous êtes mineur.

5.3. Structure if-elif-else (conditions multiples)

La structure elif (pour "else if") permet de tester plusieurs conditions de manière séquentielle. Seul le bloc de code de la première condition vraie sera exécuté.

note = int(input("Entrez votre note (sur 100) : "))
if note >= 90:
    print("Excellent!")
elif note >= 70:
    print("Bon travail.")
elif note >= 50:
    print("Satisfaisant.")
else:
    print("À revoir.")

Exemple d'exécution :

Entrez votre note (sur 100) : 95
Excellent!
---
Entrez votre note (sur 100) : 75
Bon travail.
---
Entrez votre note (sur 100) : 40
À revoir.

5.4. Instructions conditionnelles imbriquées

Il est possible de placer des instructions if à l'intérieur d'autres instructions if. L'indentation est cruciale pour définir la portée.

temperature = int(input("Quelle est la température en °C ? "))
pluie = input("Pleut-il ? (oui/non) ").lower()

if temperature > 25:
    if pluie == "non":
        print("C'est une belle journée ensoleillée !")
    else:
        print("Il fait chaud mais il pleut.")
elif temperature > 10:
    print("Il fait frais mais agréable.")
else:
    print("Il fait froid.")

Exemple d'exécution :

Quelle est la température en °C ? 28
Pleut-il ? (oui/non) non
C'est une belle journée ensoleillée !
---
Quelle est la température en °C ? 15
Pleut-il ? (oui/non) oui
Il fait frais mais agréable.
  1. Boucles while ==================

La boucle while exécute un bloc de code de manière répétée tant qu'une condition spécifiée reste vraie.

6.1. Syntaxe de base

compteur = 0
while compteur < 5:
    print(f"Le compteur est à : {compteur}")
    compteur += 1 # Incrémentation du compteur pour éviter une boucle infinie
print("Fin de la boucle while.")

Résultat :

Le compteur est à : 0
Le compteur est à : 1
Le compteur est à : 2
Le compteur est à : 3
Le compteur est à : 4
Fin de la boucle while.

6.2. Exemples d'utilisation

6.2.1. Calcul de la somme des N premiers nombres

limite = 50
somme = 0
nombre_actuel = 1
while nombre_actuel <= limite:
    somme += nombre_actuel
    nombre_actuel += 1
print(f"La somme des nombres de 1 à {limite} est : {somme}")

Résultat :

La somme des nombres de 1 à 50 est : 1275

6.2.2. Somme alternée

Calculer 1 - 2 + 3 - 4 + ... + N

n_valeur = 100
total_alterne = 0
i = 1
while i <= n_valeur:
    if i % 2 == 1: # Si i est impair
        total_alterne += i
    else: # Si i est pair
        total_alterne -= i
    i += 1
print(f"Le total alterné jusqu'à {n_valeur} est : {total_alterne}")

Résultat :

Le total alterné jusqu'à 100 est : -50

6.3. Contrôle de boucle : break et continue

6.3.1. break : Arrêter la boucle

L'instruction break arrête immédiatement la boucle la plus proche qui la contient, et le contrôle du programme passe à l'instruction suivant la boucle.

while True:
    commande = input("Entrez une commande (tapez 'stop' pour quitter) : ").lower()
    if commande == 'stop':
        print("Arrêt de la session de commande.")
        break # Sort de la boucle
    print(f"Exécution de la commande : {commande}")

Exemple d'exécution :

Entrez une commande (tapez 'stop' pour quitter) : bonjour
Exécution de la commande : bonjour
Entrez une commande (tapez 'stop' pour quitter) : help
Exécution de la commande : help
Entrez une commande (tapez 'stop' pour quitter) : STOP
Arrêt de la session de commande.

6.3.2. continue : Passer à l'itération suivante

L'instruction continue met fin à l'itération actuelle de la boucle et passe à l'itération suivante (en réévaluant la condition de la boucle while).

nombre = 0
while nombre < 10:
    nombre += 1
    if nombre == 5:
        print(f"Skipping nombre {nombre}")
        continue # Passe directement à la prochaine itération
    print(f"Traitement du nombre : {nombre}")
print("Boucle terminée.")

Résultat :

Traitement du nombre : 1
Traitement du nombre : 2
Traitement du nombre : 3
Traitement du nombre : 4
Skipping nombre 5
Traitement du nombre : 6
Traitement du nombre : 7
Traitement du nombre : 8
Traitement du nombre : 9
Traitement du nombre : 10
Boucle terminée.
  1. Boucles for ================

La boucle for est utilisée pour itérer sur une séquence (comme une liste, un tuple, une chaîne, ou un objet range) ou d'autres objets itérables.

7.1. Syntaxe de base

phrase = "Apprendre le Python"
for caractere in phrase:
    print(f"Caractère actuel : '{caractere}'")

Résultat :

Caractère actuel : 'A'
Caractère actuel : 'p'
Caractère actuel : 'p'
Caractère actuel : 'r'
Caractère actuel : 'e'
Caractère actuel : 'n'
Caractère actuel : 'd'
Caractère actuel : 'r'
Caractère actuel : 'e'
Caractère actuel : ' '
Caractère actuel : 'l'
Caractère actuel : 'e'
Caractère actuel : ' '
Caractère actuel : 'P'
Caractère actuel : 'y'
Caractère actuel : 't'
Caractère actuel : 'h'
Caractère actuel : 'o'
Caractère actuel : 'n'

7.2. La fonction range()

La fonction range() génère une séquence de nombres et est couramment utilisée avec les boucles for pour itérer un nombre spécifique de fois.

7.2.1. range(stop)

Génère des nombres de 0 jusqu'à stop-1.

for i in range(4): # Itère de 0, 1, 2, 3
    print(f"Numéro : {i}")

Résultat :

Numéro : 0
Numéro : 1
Numéro : 2
Numéro : 3

7.2.2. range(start, stop)

Génère des nombres de start jusqu'à stop-1.

for k in range(2, 7): # Itère de 2, 3, 4, 5, 6
    print(f"Séquence : {k}")

Résultat :

Séquence : 2
Séquence : 3
Séquence : 4
Séquence : 5
Séquence : 6

7.2.3. range(start, stop, step)

Génère des nombres de start jusqu'à stop-1, avec un incrément de step.

for j in range(1, 10, 2): # Itère de 1, 3, 5, 7, 9
    print(f"Pas de deux : {j}")

Résultat :

Pas de deux : 1
Pas de deux : 3
Pas de deux : 5
Pas de deux : 7
Pas de deux : 9
  1. Instruction pass =====================

L'instruction pass est une opération nulle ; quand elle est exécutée, rien ne se passe. Elle est utilisée comme un placeholder là où une instruction est syntaxiquement requise mais où vous ne voulez pas encore exécuter de code.

def ma_fonction_future():
    # Je vais implémenter cette fonction plus tard
    pass

class MaClasseFuture:
    # Cette classe sera définie plus tard
    pass

age_utilisateur = 15
if age_utilisateur < 18:
    # Logique pour les mineurs à ajouter
    pass
else:
    print("Accès autorisé.")

print("Programme continue.")

Résultat :

Accès autorisé.
Programme continue.

Étiquettes: Python Syntaxe Python variables types de données Conditions

Publié le 12 juin à 01h32

Étiquettes Populaires

©2026 L'Atelier Monstre