0%
Les bases de Python : syntaxe et fondamentaux

Syntaxe de base

Les fondamentaux pour commencer à coder

10-15 min

Les bases de Python : syntaxe et fondamentaux

Une fois Python installé, il est temps de se familiariser avec sa syntaxe et ses concepts fondamentaux. Ce tutoriel vous guidera à travers les bases essentielles de Python : variables, types de données, opérateurs et structures de contrôle de flux.

Python est réputé pour sa syntaxe claire et lisible, qui met l’accent sur la simplicité et la cohérence. C’est l’une des raisons qui en font un excellent premier langage de programmation.

La syntaxe Python

La première chose à comprendre avec Python est sa syntaxe particulière.

L’indentation et les blocs de code

Contrairement à de nombreux langages qui utilisent des accolades {} pour délimiter les blocs de code, Python utilise l’indentation (généralement 4 espaces) :

# Exemple d'indentation en Python
if condition:
    # Ce bloc est indenté avec 4 espaces
    instruction1
    instruction2
    if autre_condition:
        # Bloc imbriqué - 8 espaces
        instruction3
# Retour au niveau principal - pas d'indentation
instruction_suivante

Cette approche rend le code naturellement plus lisible, mais elle signifie que les espaces sont importants en Python !

Commentaires

Les commentaires permettent d’ajouter des notes explicatives dans le code :

# Ceci est un commentaire sur une ligne

"""
Ceci est un commentaire
sur plusieurs lignes (docstring)
"""

Variables et types de données

En Python, vous n’avez pas besoin de déclarer le type d’une variable avant de l’utiliser. Le type est déterminé automatiquement lors de l’affectation.

Affectation de variables

# Affectation simple
nom = "Alice"
age = 30

# Affectations multiples
x, y, z = 1, 2, 3

# Affectation de la même valeur à plusieurs variables
a = b = c = 0

Conventions de nommage

  • Les noms de variables sont sensibles à la casse (nom et Nom sont différents)
  • Ils doivent commencer par une lettre ou un underscore
  • Ils peuvent contenir des lettres, des chiffres et des underscores
  • Par convention, on utilise snake_case pour les variables en Python
# Bon nommage
user_name = "Alice"
age_utilisateur = 30
_variable_privee = "secret"

# Mauvais nommage (à éviter)
UserName = "Alice"  # Style CamelCase (réservé aux classes)
1variable = 10      # Commence par un chiffre (erreur de syntaxe)
nom-utilisateur = "Bob"  # Contient un tiret (erreur de syntaxe)

Types de données de base

Python possède plusieurs types de données intégrés :

1. Nombres

# Entiers (int)
age = 30
code_postal = 75000

# Nombres à virgule flottante (float)
prix = 19.99
pi = 3.14159

# Nombres complexes
complexe = 3 + 4j

2. Chaînes de caractères (str)

# Chaînes simples
prenom = "Marie"
nom = 'Dupont'

# Chaînes multilignes
description = """Ceci est une chaîne
qui s'étend sur plusieurs
lignes."""

# Formatage de chaînes (f-strings - Python 3.6+)
message = f"Bonjour {prenom} {nom}, vous avez {age} ans."

# Méthodes de chaînes utiles
print(prenom.upper())         # MARIE
print(nom.lower())            # dupont
print("  texte  ".strip())    # "texte"
print(",".join(["a", "b"]))   # "a,b"
print("abc,def".split(","))   # ["abc", "def"]

3. Booléens (bool)

# Valeurs booléennes
est_majeur = True
est_inscrit = False

# Expressions conditionnelles donnant des booléens
a = 5
b = 10
print(a < b)       # True
print(a == b)      # False
print(a >= 5)      # True

4. Valeur None

None est l’équivalent de null dans d’autres langages, représentant l’absence de valeur :

resultat = None

# Vérifier si une variable est None
if resultat is None:
    print("Aucun résultat disponible")

Vérification de types

Pour connaître le type d’une variable, utilisez la fonction type() :

x = 10
print(type(x))     # <class 'int'>

y = "bonjour"
print(type(y))     # <class 'str'>

Conversion de types (transtypage)

# Conversion en entier
age_str = "30"
age = int(age_str)         # 30 (entier)

# Conversion en chaîne
nombre = 42
nombre_str = str(nombre)   # "42" (chaîne)

# Conversion en flottant
prix = float("19.99")      # 19.99 (flottant)

# Conversion en booléen
valeur = bool(0)           # False (0, "", [], {}, None sont évalués à False)

Opérateurs

Opérateurs arithmétiques

a = 10
b = 3

addition = a + b       # 13
soustraction = a - b   # 7
multiplication = a * b # 30
division = a / b       # 3.3333... (retourne toujours un float)
division_entiere = a // b  # 3 (division entière)
modulo = a % b         # 1 (reste de la division)
puissance = a ** b     # 1000 (a élevé à la puissance b)

Opérateurs de comparaison

a = 10
b = 5

egal = a == b              # False
different = a != b         # True
superieur = a > b          # True
inferieur = a < b          # False
superieur_ou_egal = a >= b # True
inferieur_ou_egal = a <= b # False

Opérateurs logiques

x = True
y = False

et = x and y   # False (les deux doivent être True)
ou = x or y    # True (au moins un doit être True)
non = not x    # False (inverse la valeur)

Opérateurs d’assignation

x = 10

x += 5      # x = x + 5 (x vaut maintenant 15)
x -= 3      # x = x - 3 (x vaut maintenant 12)
x *= 2      # x = x * 2 (x vaut maintenant 24)
x /= 4      # x = x / 4 (x vaut maintenant 6.0)
x //= 2     # x = x // 2 (x vaut maintenant 3.0)
x %= 2      # x = x % 2 (x vaut maintenant 1.0)
x **= 3     # x = x ** 3 (x vaut maintenant 1.0)

Opérateurs d’appartenance

liste = [1, 2, 3, 4, 5]

print(3 in liste)      # True (3 est dans la liste)
print(6 not in liste)  # True (6 n'est pas dans la liste)

Opérateurs d’identité

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a is c)  # True (a et c référencent le même objet)
print(a is b)  # False (a et b sont des objets différents)
print(a == b)  # True (a et b ont la même valeur)

Structures de contrôle

Les structures de contrôle vous permettent de diriger le flux d’exécution de votre programme.

Structures conditionnelles (if, elif, else)

age = 18

if age < 18:
    print("Mineur")
elif age == 18:
    print("Tout juste majeur")
else:
    print("Majeur")

Expression conditionnelle (opérateur ternaire)

# structure: valeur_si_vrai if condition else valeur_si_faux
statut = "majeur" if age >= 18 else "mineur"

Boucles

Boucle for

La boucle for en Python est une boucle “pour chaque” qui itère sur une séquence :

# Itération sur une liste
fruits = ["pomme", "banane", "cerise"]
for fruit in fruits:
    print(fruit)

# Itération sur une plage de nombres
for i in range(5):  # 0, 1, 2, 3, 4
    print(i)

# range avec début et fin
for i in range(2, 6):  # 2, 3, 4, 5
    print(i)

# range avec pas
for i in range(0, 10, 2):  # 0, 2, 4, 6, 8
    print(i)

# Énumération (index et valeur)
for index, fruit in enumerate(fruits):
    print(f"Index {index}: {fruit}")

Boucle while

La boucle while continue tant que la condition est vraie :

compteur = 0
while compteur < 5:
    print(compteur)
    compteur += 1

Contrôle des boucles

# break - sort de la boucle
for i in range(10):
    if i == 5:
        break  # Sortir de la boucle quand i atteint 5
    print(i)   # Affiche 0, 1, 2, 3, 4

# continue - passe à l'itération suivante
for i in range(10):
    if i % 2 == 0:
        continue  # Sauter les nombres pairs
    print(i)      # Affiche 1, 3, 5, 7, 9

# else dans les boucles - exécuté si la boucle se termine normalement (sans break)
for i in range(5):
    print(i)
else:
    print("Boucle terminée sans break")

Entrées et sorties de base

Affichage (sortie standard)

# Affichage simple
print("Bonjour, monde!")

# Affichage avec variables
nom = "Alice"
print("Bonjour,", nom)

# Formatage avec f-strings (Python 3.6+)
age = 30
print(f"{nom} a {age} ans.")

# Plusieurs arguments
print("Nom:", nom, "Age:", age)

# Contrôle du séparateur et de la fin de ligne
print("a", "b", "c", sep="-", end="!\n")  # Affiche "a-b-c!"

Lecture d’entrées utilisateur

# Lire une entrée utilisateur (retourne toujours une chaîne)
nom = input("Entrez votre nom: ")
print(f"Bonjour, {nom}!")

# Convertir l'entrée en nombre
age_str = input("Entrez votre âge: ")
age = int(age_str)  # Conversion en entier

Exemple complet

Voici un exemple qui utilise plusieurs concepts que nous avons appris :

# Programme qui calcule la moyenne d'une liste de nombres

def calculer_moyenne(nombres):
    """Calcule la moyenne d'une liste de nombres."""
    if not nombres:  # Si la liste est vide
        return 0
    return sum(nombres) / len(nombres)

# Demander le nombre de valeurs
try:
    n = int(input("Combien de nombres voulez-vous entrer? "))
    
    # Collecter les nombres
    nombres = []
    for i in range(n):
        valeur = float(input(f"Entrez le nombre {i+1}: "))
        nombres.append(valeur)
    
    # Calculer et afficher la moyenne
    moyenne = calculer_moyenne(nombres)
    print(f"La moyenne des nombres entrés est: {moyenne:.2f}")
    
    # Afficher si chaque nombre est supérieur ou inférieur à la moyenne
    print("\nComparaison avec la moyenne:")
    for i, nombre in enumerate(nombres):
        if nombre > moyenne:
            relation = "supérieur à"
        elif nombre < moyenne:
            relation = "inférieur à"
        else:
            relation = "égal à"
        print(f"Nombre {i+1} ({nombre}) est {relation} la moyenne.")
        
except ValueError:
    print("Erreur: Veuillez entrer un nombre valide.")

Ce programme:

  1. Définit une fonction pour calculer la moyenne
  2. Demande à l’utilisateur combien de nombres il souhaite entrer
  3. Collecte ces nombres
  4. Calcule et affiche leur moyenne
  5. Compare chaque nombre à la moyenne

Bonnes pratiques et conseils

Pour écrire du code Python propre et lisible, suivez ces directives :

  1. Indentation cohérente : Utilisez toujours 4 espaces pour l’indentation (pas de tabulations).

  2. Nommage descriptif : Choisissez des noms qui expliquent clairement à quoi servent vos variables.

  3. Docstrings : Documentez vos fonctions avec des chaînes de documentation.

  4. DRY (Don’t Repeat Yourself) : Évitez la répétition en utilisant des fonctions et des boucles.

  5. KISS (Keep It Simple, Stupid) : Privilégiez la simplicité et la clarté à l’astuce.

  6. Une ligne, une instruction : Évitez de mettre plusieurs instructions sur une même ligne.

  7. Gestion des erreurs : Utilisez try/except pour gérer les erreurs possibles.

  8. PEP 8 : Suivez les conventions de style Python (PEP 8) pour la cohérence.

Exercices pratiques

Pour solidifier vos connaissances, essayez ces exercices :

  1. Écrivez un programme qui convertit une température de Celsius en Fahrenheit (formule: F = C * 9/5 + 32).

  2. Créez un programme qui détermine si un nombre entré par l’utilisateur est pair ou impair.

  3. Écrivez un programme qui affiche la table de multiplication d’un nombre entré par l’utilisateur.

  4. Créez un programme qui compte à rebours de 10 à 1, puis affiche “Décollage !”.

  5. Écrivez un programme qui demande l’âge de l’utilisateur et affiche un message différent selon la tranche d’âge.

Conclusion

Dans ce tutoriel, nous avons couvert les bases fondamentales de Python :

  • La syntaxe et l’indentation
  • Les variables et les types de données
  • Les opérateurs (arithmétiques, de comparaison, logiques)
  • Les structures de contrôle (if/elif/else, for, while)
  • Les entrées/sorties de base

Ces concepts constituent les fondements sur lesquels vous construirez votre compréhension de Python. À mesure que vous progresserez, vous découvrirez comment ces éléments s’assemblent pour créer des programmes plus complexes et puissants.

Dans le prochain tutoriel, nous explorerons les structures de données en Python : listes, tuples, dictionnaires et ensembles, qui vous permettront d’organiser et de manipuler vos données efficacement.


Besoin de réviser l’installation de Python ? Consultez notre guide d’installation.

Commentaires

Les commentaires sont alimentés par GitHub Discussions

Connectez-vous avec GitHub pour participer à la discussion

Lien copié !