Les bases de Python : Un guide du débutant pour coder

Python est un langage de programmation polyvalent et largement utilisé, connu pour sa syntaxe claire et sa lisibilité. Cela en fait un choix idéal pour les débutants car il est utilisé dans tous les domaines, du développement web à la science des données, ouvrant de nombreuses perspectives de carrière. Cet article vous guidera à travers les concepts fondamentaux de Python avec des exemples de code simples et faciles à comprendre.

Votre premier programme Python : “Hello, World!”

Commençons par le traditionnel programme "Hello, World!". En Python, c'est exceptionnellement simple :

print("Hello, Beginner!")

Cette seule ligne accomplit ce qui suit :

1. print() : Il s'agit d'une fonction intégrée. Les fonctions sont des blocs de code réutilisables qui effectuent des tâches spécifiques. print() affiche une sortie à l'utilisateur.
2. ("Hello, Beginner!") : Entre les parenthèses se trouve un littéral de chaîne. Une chaîne est une séquence de caractères, entourée de guillemets simples ('...') ou doubles ("...").

Lorsque vous exécutez ceci, l'interpréteur Python exécute print(), affichant “Hello, Beginner!” sur votre écran.

Variables en Python

Les variables sont cruciales pour stocker des données. Considérez-les comme des conteneurs étiquetés. Il est conseillé d'utiliser des noms descriptifs, de commencer par des lettres minuscules et d'utiliser des traits de soulignement pour séparer les mots (par exemple, ma_variable, age_utilisateur). Voici un exemple :

# Affectation de valeurs aux variables
message = "Welcome to Python!"
number = 10
pi = 3.14159

# Affichage des valeurs des variables
print(message)
print(number)
print(pi)

Explication :

1. message = "Welcome to Python!" : Une variable nommée message est créée, stockant la chaîne "Welcome to Python!".
2. number = 10 : Une variable nommée number stocke l'entier 10.
3. pi = 3.14159 : Une variable nommée pi stocke le nombre à virgule flottante 3.14159.

print() affiche ensuite ces valeurs. Python est typé dynamiquement : vous n'avez pas besoin de déclarer explicitement le type de la variable (chaîne, entier, flottant). Python le déduit de la valeur affectée.

Interaction utilisateur en Python

Les programmes interactifs ont souvent besoin de l'entrée de l'utilisateur. Voici comment l'obtenir :

# Obtenir l'entrée de l'utilisateur
name = input("Please enter your name: ")

# Afficher une salutation personnalisée
print("Hello, " + name + "!")  # Concaténation de chaînes

Explication :

1. name = input("Please enter your name: ") : input() met le programme en pause, attend que l'utilisateur tape quelque chose et appuie sur Entrée, et le stocke sous forme de chaîne dans name.
2. print("Hello, " + name + "!") : Ceci affiche une salutation. L'opérateur +, avec des chaînes, effectue une concaténation de chaînes, les joignant. Il est conseillé d'ajouter des espaces autour du + lors de la concaténation pour une meilleure lisibilité.

Logique conditionnelle : if, else, et elif

Les instructions conditionnelles permettent à votre programme de prendre des décisions, en contrôlant quels blocs de code sont exécutés en fonction de la véracité ou de la fausseté des conditions.

age = int(input("Enter your age: "))

if age >= 18:
    print("You are eligible to vote.")
elif age < 0:
    print("That is an incorrect age.")
else:
    print("You are not eligible to vote yet.")

Décomposition :

1. age = int(input("Enter your age: ")) : Prend l'entrée de l'utilisateur pour l'âge. int() convertit l'entrée (une chaîne par défaut) en un entier.
2. if age >= 18: : Vérifie si age est supérieur ou égal à 18. Si c'est vrai, l'instruction print indentée est exécutée.
3. elif age < 0: : Si la condition if précédente est fausse, cette condition sera vérifiée. Si elle est vraie, alors le bloc correspondant sera exécuté. elif signifie “else if” et permet de vérifier plusieurs conditions en séquence.
4. else: : Si aucune des conditions if ou elif n'est vraie, le code indenté sous else est exécuté. L'indentation est vitale en Python ; elle définit les blocs de code associés à if, elif et else. Une indentation cohérente (généralement 4 espaces) est cruciale pour que le code Python fonctionne correctement.

Boucles : Répéter le code avec for

Les boucles répètent des blocs de code. La boucle for itère sur une séquence (par exemple, une liste ou une plage de nombres).

# Affichage des nombres de 0 à 4
for i in range(5):
    print(i)

# Affichage des éléments d'une liste
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

Explication :

1. for i in range(5): : range(5) génère des nombres de 0 jusqu'à (mais sans inclure) 5. La boucle parcourt cette séquence ; à chaque itération, le nombre courant est affecté à i.
2. for fruit in fruits: : Cette boucle parcourt la liste fruits. À chaque itération, l'élément courant de la liste est affecté à fruit.

Boucles: Répéter le code avec while

La boucle while continue tant qu'une condition est vraie.

count = 0
while count < 5:
    print(count)
    count += 1  # Incrémente count

Explication :

1. count = 0 : Initialise count à 0.
2. while count < 5: : La boucle continue tant que count est inférieur à 5.
3. count += 1 : À l'intérieur de la boucle, count est incrémenté de 1 à chaque itération. Ceci empêche une boucle infinie (où la condition resterait toujours vraie).

Fonctions : Blocs de code réutilisables

Les fonctions sont essentielles pour la réutilisation du code, l'organisation et la lisibilité. Au lieu de répéter le même code plusieurs fois, vous pouvez définir une fonction une fois et l'appeler chaque fois que vous avez besoin de cette fonctionnalité spécifique. Définissez les vôtres en utilisant def.

# Définition d'une fonction
def greet(name):
    print("Hello, " + name + "!")

# Appel de la fonction
greet("Alice")
greet("Bob")

Points clés :

1. def greet(name): : Définit une fonction nommée greet qui prend un paramètre appelé name.
2. print("Hello, " + name + "!") : Le corps de la fonction—le code exécuté lorsque la fonction est appelée.
3. greet("Alice") : Appelle la fonction greet, en passant “Alice” comme argument.

Combiner les concepts : Un simple calculateur d'aire

Combinons les concepts dans un programme légèrement plus complexe :

def calculate_area(length, width):
    """Calcule l'aire d'un rectangle."""  # Docstring
    area = length * width
    return area

# Obtenir les dimensions
length = float(input("Enter length: "))
width = float(input("Enter width: "))

# Calculer l'aire
rectangle_area = calculate_area(length, width)

# Afficher le résultat
print("Area:", rectangle_area)

Explication :

1. def calculate_area(length, width): : Définit une fonction pour calculer l'aire d'un rectangle, en prenant length et width comme paramètres. Le """...""" est une docstring, décrivant la fonction. Les docstrings sont utilisées pour la documentation et sont accessibles par la fonction help().
2. return area : La fonction retourne l'aire calculée. L'instruction return quitte la fonction et renvoie la valeur à l'endroit où la fonction a été appelée.
3. Le programme obtient l'entrée de l'utilisateur pour la longueur et la largeur, en les convertissant en nombres à virgule flottante à l'aide de float(). L'utilisation de float() permet d'obtenir des valeurs décimales, ce qui rend le calculateur plus polyvalent.
4. Il appelle calculate_area, en passant les dimensions, et en stockant la valeur retournée dans rectangle_area.
5. Enfin, il affiche l'aire.

Plus d'outils de contrôle de flux

Python fournit d'autres outils pour contrôler le flux du programme.

break, continue, et else dans les boucles

• break : Quitte la boucle for ou while la plus imbriquée.
• continue : Passe à l'itération suivante de la boucle.
• Clause else de la boucle : Dans for, exécutée après la fin de la boucle (sauf si break s'est produit). Dans while, exécutée après que la condition devient fausse (sauf si break s'est produit).

#Exemple pour break
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    if number == 3:
        break  # Quitte la boucle quand number vaut 3
    print(number)  # Sortie : 1 2

#Exemple pour continue
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    if number == 3:
        continue  # Passe à l'itération suivante quand number vaut 3
    print(number)  # Sortie : 1 2 4 5

#Exemple pour else
for i in range(5):
    print(i)
else:
    print("Loop finished") #Sera exécuté

for i in range(5):
    if i==3:
        break
    print(i)
else:
    print("Loop finished") #Ne sera pas exécuté

L'instruction match

match compare une valeur à des motifs. C'est comme les instructions switch dans d'autres langages mais avec une correspondance de motifs plus puissante. Ceci est disponible à partir de Python 3.10.

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 401 | 403 | 404:  # Cas multiples
            return "Not allowed"
        case 418:
            return "I'm a teapot"
        case _:  # Défaut
            return "Something's wrong"

print(http_error(404))
print(http_error(500))

_ est un joker, correspondant à n'importe quoi si aucun autre cas ne correspond.

Structures de données

Python a des structures de données intégrées pour organiser les données.

• Listes : Séquences ordonnées, mutables (modifiables).

my_list = [1, 2, 3, "apple"]
my_list.append("cherry")  # Ajoute un élément à la fin
print(my_list[0])       # Accède à l'élément par son index (commençant à 0)
my_list.remove(2)        # Supprime un élément par sa valeur
print(my_list)

• Tuples : Séquences ordonnées, immuables.

my_tuple = (1, 2, 3, "apple")
# my_tuple[0] = 5  # Erreur (immuable) - Les tuples ne peuvent pas être modifiés après leur création
print(my_tuple[1])

• Ensembles : Collections non ordonnées d'éléments uniques.

my_set = {1, 2, 3, 3, 4, 5}  # Les doublons sont automatiquement supprimés
print(my_set)  # Sortie : {1, 2, 3, 4, 5}

• Dictionnaires : Paires clé-valeur. Les clés doivent être immuables (comme des chaînes, des nombres ou des tuples).

my_dict = {"name": "Alice", "age": 30}
print(my_dict["name"])  # Accède à la valeur par la clé
my_dict["age"] = 31      # Modifie une valeur
print(my_dict)

• Compréhensions de liste : Syntaxe concise pour créer des listes.

squares = [x**2 for x in range(10)]      # Liste de carrés
even = [x for x in range(20) if x % 2 == 0]  # Nombres pairs
print(squares)
print(even)

Modules

Les modules organisent le code en fichiers réutilisables. Utilisez import pour accéder aux fonctionnalités d'autres modules.

import math

print(math.sqrt(16))  # Accède à la fonction sqrt du module math
print(math.pi)        # Accède à la constante pi

from math import sqrt  # Importe une fonction spécifique

print(sqrt(25))

from math import *  # Importe tout (généralement à éviter)

print(pi)

Ceci démontre l'utilisation du module math (qui fournit des fonctions mathématiques). Importer des fonctions ou des constantes spécifiques peut améliorer la lisibilité du code et éviter les conflits de noms. Importer tout avec * est généralement déconseillé dans les grands projets.

Définition de fonctions : Techniques avancées

Valeurs d'arguments par défaut

Les fonctions peuvent avoir des valeurs par défaut pour les arguments.

def greet(name, greeting="Hello"):
    print(greeting + ", " + name + "!")

greet("Bob")           # Utilise la salutation par défaut
greet("Alice", "Hi")  # Remplace la valeur par défaut

Arguments nommés

Appelez les fonctions en utilisant la syntaxe motclé=valeur.

def describe_pet(animal_type, pet_name):
    print("I have a " + animal_type + " named " + pet_name + ".")

describe_pet(pet_name="Harry", animal_type="hamster")  # L'ordre n'a pas d'importance

Listes d'arguments arbitraires

Les fonctions peuvent accepter un nombre arbitraire d'arguments positionnels en utilisant *args.

def make_pizza(*toppings):
    print("Making a pizza with:")
    for topping in toppings:
        print("- " + topping)

make_pizza("pepperoni")
make_pizza("mushrooms", "cheese", "peppers")

*toppings rassemble tous les arguments positionnels dans un tuple nommé toppings.

Arguments nommés arbitraires

Les fonctions peuvent accepter un nombre arbitraire d'arguments nommés en utilisant **kwargs.

def build_profile(first, last, **kwargs):
    # Combine les arguments nommés fixes et arbitraires pour créer un profil utilisateur.
    profile = {'first_name': first, 'last_name': last}
    profile.update(kwargs)  # Met à jour le profil avec les paires clé-valeur de kwargs.
    return profile

user = build_profile("Albert", "Einstein", location="Princeton", field="physics")
print(user)  # Sortie: {'first_name': 'Albert', 'last_name': 'Einstein', 'location': 'Princeton', 'field': 'physics'}

**kwargs signifie “keyword arguments” (arguments nommés) et est une convention de nommage courante pour collecter des arguments nommés supplémentaires dans un dictionnaire. Cela permet aux fonctions de gérer des entrées flexibles.

Expressions Lambda

Petites fonctions anonymes créées avec lambda.

add = lambda x, y: x + y
print(add(5, 3))  # Sortie : 8

pairs = [(1, 'one'), (2, 'two'), (3, 'three')]
pairs.sort(key=lambda pair: pair[1]) #trie par le deuxième élément du tuple
print(pairs)

Les fonctions lambda sont souvent utilisées comme arguments de fonctions d'ordre supérieur (fonctions qui prennent d'autres fonctions comme arguments), comme sort dans cet exemple.

Classes

Les classes offrent un moyen de regrouper des données (attributs) et des fonctionnalités (méthodes) qui opèrent sur ces données. C'est l'une des principales caractéristiques de la programmation orientée objet, vous permettant de créer des plans pour des objets.

class Dog:
    def __init__(self, name, age): #constructeur
        self.name = name
        self.age = age

    def bark(self):
        print("Woof!")

my_dog = Dog("Buddy", 3) #instance de classe
print(my_dog.name)
my_dog.bark()

Explication:

• class Dog:: Définit une classe nommée Dog.
• def __init__(self, name, age):: C'est le constructeur (ou initialiseur). Il est appelé automatiquement lorsque vous créez un nouvel objet Dog.
  • self: Fait référence à l'instance de la classe (l'objet Dog spécifique avec lequel vous travaillez). C'est le premier paramètre de toutes les méthodes d'une classe.
• def bark(self):: C'est une méthode—une fonction qui appartient à la classe Dog. Elle peut accéder aux données du chien (comme self.name, bien qu'elle ne le fasse pas dans cet exemple simple).
• my_dog = Dog("Buddy", 3): Crée une instance de la classe Dog nommée my_dog.

Itérateurs

Un itérateur est un objet qui permet de parcourir tous les éléments d'une collection, quelle que soit son implémentation spécifique.

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))

Générateurs

Les générateurs sont un type d'itérable, comme les listes ou les tuples. Contrairement aux listes, ils ne stockent pas leur contenu en mémoire, générant des valeurs à la volée, en utilisant le mot-clé yield. Cela les rend efficaces en mémoire pour les grandes séquences. Cela les distingue également des compréhensions de liste, qui créent la liste entière en mémoire.

def my_generator():
  yield 1
  yield 2
  yield 3

for value in my_generator():
  print(value)

#expression de générateur
squares = (x*x for x in range(10))
print(list(squares))

Ces fondamentaux fournissent une base solide pour votre parcours en Python. En expérimentant avec ces concepts et en les combinant, vous pouvez construire des programmes de plus en plus sophistiqués. N'oubliez pas que la pratique et l'exploration sont essentielles pour maîtriser n'importe quel langage de programmation.