Apprendre Python

Bienvenue sur Python

Python est un langage de programmation polyvalent de haut niveau connu pour sa lisibilité et son large support communautaire. Développé au début des années 1990, il met l'accent sur une syntaxe claire et concise, ce qui en fait un excellent choix pour les débutants comme pour les professionnels. La vaste bibliothèque standard de Python et son écosystème florissant de packages tiers lui permettent d'être utilisé dans de nombreux domaines, du développement Web et de l'analyse de données à l'intelligence artificielle et au calcul scientifique. Sa facilité d'apprentissage, associée à ses puissantes fonctionnalités, fait de Python une compétence précieuse pour quiconque cherche à se lancer dans la programmation ou à faire progresser sa carrière technologique.

Introduction à Python

Comment installer Python et écrire votre premier "Hello, World!" programme.

Python est l'un des langages de programmation les plus populaires en raison de sa simplicité et de sa polyvalence. Que vous soyez débutant ou codeur expérimenté, installer Python et exécuter votre premier script est un processus simple.

Étape 1 : Téléchargez et installez Python

1. Visitez le site Web officiel
   Accédez à Python.org et téléchargez la dernière version stable de Python pour votre système d'exploitation (Windows, macOS ou Linux).

2. Exécutez le programme d'installation

• Pour Windows : double-cliquez sur le fichier .exe téléchargé et cochez "Ajouter Python au PATH" avant de cliquer sur "Installer". Maintenant".

• Pour Mac : téléchargez le programme d'installation de macOS et suivez les instructions de configuration.

• Pour Linux : utilisez le gestionnaire de packages (par exemple, pour Ubuntu).

  shCopy
  sudo apt install python3
  

3. Vérifier l'installation
   Ouvrez un terminal ou une invite de commande et tapez :

shCopy
python --version

ou

shCopy
python3 --version

Cela devrait afficher la version de Python installée.

Étape 2 : Choisissez un IDE ou un éditeur de code

Python est livré avec IDLE, un environnement de développement intégré (IDE), idéal pour les débutants. Cependant, les utilisateurs plus avancés préfèrent souvent les éditeurs tels que :

• VS Code – Léger et puissant, avec des extensions Python.

• PyCharm – IDE riche en fonctionnalités pour les développeurs professionnels.

• Jupyter Notebook – Idéal pour la science des données et le codage interactif.

Pour les débutants, lancer IDLE (installé avec Python) est le moyen le plus simple de commencer à coder.

Étape 3 : Écrivez et exécutez votre premier script Python

1. Utilisation de IDLE :

   • Ouvrir IDLE.

   • Cliquez sur Fichier → Nouveau fichier.

   Tapez le code suivant :

   pythonCopy
   print("Hello, World!")
   

   • Enregistrez le fichier avec une extension .py (par exemple, hello.py).

   • Exécutez-le en sélectionnant Exécuter → Exécuter le module ou en appuyant sur F5.

2. Utilisation de la ligne de commande :

   • Ouvrez un terminal ou une invite de commande.

   • Accédez au dossier dans lequel vous avez enregistré hello.py.

   • Exécutez le script en tapant :

   python bonjour.py
   

   • Vous devriez voir le résultat :

   Bonjour tout le monde !
   

Félicitations ! Vous avez installé Python avec succès et exécuté votre premier script. 🎉

Pour plus de détails, visitez la documentation officielle de Python à docs.python.org. Bon codage ! 🚀

Syntaxe de python

1. Indentation Python (pas d'accolades pour les blocs)

Python utilise indentation (espaces) pour définir des blocs de code au lieu d'accolades {} comme dans d'autres langages. Cela rend le code Python plus lisible, mais signifie également qu'une indentation incorrecte entraînera des erreurs.

Exemple correct :

pythonCopy
if 5 > 3:
    print("Five is greater than three")  # Proper indentation

Exemple incorrect (déclenche une erreur d'indentation) :

pythonCopy
if 5 > 3:
print("This will cause an error!")  # No indentation

Python applique l'indentation pour une meilleure structure et lisibilité du code. L'indentation recommandée est de 4 espaces par niveau.

2. Indexation base zéro

Python suit indexation de base zéro, ce qui signifie que le premier élément d'une séquence (comme une liste, une chaîne ou un tuple) commence à index 0, et non à 1.

Exemple :

pythonCopy
fruits = ["apple", "banana", "cherry"]
print(fruits[0])  # Outputs: apple
print(fruits[2])  # Outputs: cherry

Exemple incorrect (IndexError) :

pythonCopy
print(fruits[3])  # IndexError: list index out of range

Puisque Python commence à compter à partir de 0, toute tentative d'accès à un index égal ou supérieur à la longueur de la séquence entraîne une erreur.

3. Commentaires en Python

Les commentaires aident les développeurs à comprendre le code en ajoutant des explications. Python prend en charge à la fois les single-line et les commentaires multi-lignes.

Commentaire sur une seule ligne :

pythonCopy
# This is a single-line comment
print("Hello, World!")  # Inline comment

Commentaire sur plusieurs lignes :

pythonCopy
"""
This is a multi-line comment.
It is often used for documentation.
"""
print("Hello, World!")

Bien que les guillemets triples puissent être utilisés pour les commentaires sur plusieurs lignes, ils sont principalement destinés aux docstrings, qui sont des commentaires spéciaux placés dans des fonctions de documentation.

4. Sensibilité à la casse

Python est sensible à la casse, ce qui signifie qu'il traite les lettres majuscules et minuscules différemment. Les noms de variables, les noms de fonctions et les mots-clés doivent être utilisés de manière cohérente.

Exemple :

pythonCopy
myVar = 5
MyVar = 10

print(myVar)  # Outputs: 5
print(MyVar)  # Outputs: 10 (different variable)

Ici, myVar et MyVar sont considérées comme deux variables différentes en raison de leur capitalisation.

Exemple incorrect :

pythonCopy
Print("Hello")  # NameError: name 'Print' is not defined

Les fonctions intégrées de Python comme print() doivent être écrites en minuscules.

5. Variables et saisie dynamique

Python est typé dynamiquement, ce qui signifie que vous n'avez pas besoin de déclarer explicitement le type d'une variable. Le type est déterminé automatiquement en fonction de la valeur attribuée.

Exemple :

pythonCopy
x = 10       # Integer
y = 3.14     # Float
z = "Hello"  # String

print(type(x))  # Outputs: <class 'int'>
print(type(y))  # Outputs: <class 'float'>
print(type(z))  # Outputs: <class 'str'>

Réaffectation de différents types de données :

pythonCopy
a = 5        # Initially an integer
a = "Python" # Now reassigned as a string
print(a)     # Outputs: Python

Étant donné que Python autorise le typage dynamique, le type d'une variable peut changer pendant l'exécution.

Conclusion

Comprendre la syntaxe de base de Python est essentiel pour écrire du code propre et efficace. Les principaux points à retenir sont :

• Python applique indentation au lieu d'accolades pour les blocs de code.

• Indexation de base zéro signifie que le premier élément d'une séquence est à l'index 0.

• Comments améliore la lisibilité du code et peut être une seule ligne (#) ou multiligne (""" """).

• Python est sensible à la casse, donc Var et var sont traités comme différents variables.

• Python prend en charge le typage dynamique, permettant aux variables de changer de type.

La maîtrise de ces bases fournira une base solide pour l'apprentissage de concepts Python plus avancés. Bon codage ! 🚀

imprimer

La fonction print() en Python est utilisée pour afficher la sortie à l'écran. C'est l'une des fonctions les plus couramment utilisées, notamment pour le débogage et l'interaction avec l'utilisateur. Dans ce petit guide, nous explorerons différentes manières d'utiliser efficacement print(), notamment comment imprimer plusieurs valeurs, formater la sortie et contrôler les séparateurs et les caractères de fin.

1. Base print() Utilisation

La façon la plus simple d'utiliser print() est de passer une chaîne ou un nombre entre parenthèses :

pythonCopy
print("Hello, World!")  # Outputs: Hello, World!
print(42)               # Outputs: 42

Vous pouvez imprimer plusieurs valeurs en les séparant par une virgule ,:

pythonCopy
print("Hello", "Python")  # Outputs: Hello Python

Par défaut, Python insère un espace entre les valeurs.

2. Utilisation du paramètre sep

Le paramètre sep contrôle le séparateur entre plusieurs valeurs dans print(). Par défaut, il s'agit d'un espace, mais vous pouvez le remplacer par n'importe quoi d'autre :

pythonCopy
print("apple", "banana", "cherry", sep=", ")  
# Outputs: apple, banana, cherry

pythonCopy
print("Python", "is", "fun", sep="-")  
# Outputs: Python-is-fun
```<h2><span style="font-family: Roboto;">3. Utilisation du paramètre <code inline="">end</code></span></h2>
<p><span style="font-family: Roboto;">Par défaut, <code inline="">print()</code> ajoute une nouvelle ligne (<code inline="">\n</code>) à la fin de la sortie. Vous pouvez modifier ce comportement à l'aide du paramètre <code inline="">end</code> :</span></p>


```python
print("Hello", end=" ")
print("World!")  
# Outputs: Hello World! (on the same line)

Ici, end=" " remplace la nouvelle ligne par défaut par un espace.

4. Variables d'impression

Vous pouvez imprimer des variables comme des chaînes littérales :

pythonCopy
name = "Alice"
age = 25
print("Name:", name, "Age:", age)  
# Outputs: Name: Alice Age: 25

Vous pouvez également utiliser f-strings pour un résultat plus propre :

pythonCopy
print(f"Name: {name}, Age: {age}")  
# Outputs: Name: Alice, Age: 25

5. Impression de caractères spéciaux

Utilisez des séquences d'échappement pour formater la sortie :

pythonCopy
print("Hello\nWorld!")  # \n adds a new line
print("This is a tab:\tPython")  # \t adds a tab space
```<hr />
<h2><span style="font-family: Roboto;">Conclusion</span></h2>
<p><span style="font-family: Roboto;">La fonction <code inline="">print()</code> est un outil puissant en Python qui vous permet d'afficher la sortie de différentes manières. Points clés à retenir :</span></p>
<ul>
<li>
<p><span style="font-family: Roboto;">Utilisez <code inline="">print(value1, value2, …)</code> pour imprimer plusieurs valeurs.</span></p>
</li>
<li>
<p><span style="font-family: Roboto;">Modifiez le séparateur en utilisant <code inline="">sep="custom_separator"</code>.</span></p>
</li>
<li>
<p><span style="font-family: Roboto;">Ligne de contrôle se terminant par <code inline="">end="custom_end"</code>.</span></p>
</li>
<li>
<p><span style="font-family: Roboto;">Utilisez <code inline="">f-strings</code> pour un meilleur formatage.</span></p>
</li>
</ul>
<p><span style="font-family: Roboto;">La maîtrise de <code inline="">print()</code> facilitera grandement le débogage et la gestion des sorties en Python.</span></p>

Opérations binaires en Python

1. Opérateurs arithmétiques

Les opérateurs arithmétiques effectuent des calculs mathématiques entre deux opérandes. Python prend en charge l'addition, la soustraction, la multiplication, la division, le modulo, la division au sol et l'exponentiation.

Exemples :

pythonCopy
a = 15
b = 4

print(a + b)   # 19 (addition)
print(a - b)   # 11 (subtraction)
print(a * b)   # 60 (multiplication)
print(a / b)   # 3.75 (true division)
print(a // b)  # 3 (floor division)
print(a % b)   # 3 (modulus)
print(a ** b)  # 50625 (exponentiation)

Les opérateurs arithmétiques renvoient toujours une nouvelle valeur sans modifier les variables d'origine.

2. Opérateurs de comparaison

Les opérateurs de comparaison comparent deux valeurs et renvoient un résultat booléen (True ou False). Ceux-ci incluent l’égalité, l’inégalité, supérieur/inférieur et leurs combinaisons.

Exemples :

pythonCopy
x = 7
y = 10

print(x == y)   # False (equal to)
print(x != y)   # True (not equal to)
print(x > y)    # False
print(x < y)    # True
print(x >= 7)   # True
print(y <= 7)   # False

Les résultats de comparaison sont souvent utilisés dans des instructions ou des boucles if pour contrôler le déroulement du programme.

3. Opérateurs logiques

Les opérateurs logiques combinent des valeurs booléennes et renvoient True ou False. Les trois opérateurs sont et, or et not (unaire).

Exemples :

pythonCopy
is_sunny = True
is_warm = False

print(is_sunny and is_warm)   # False (both must be True)
print(is_sunny or is_warm)    # True  (at least one is True)
print(not is_warm)            # True  (negates the value)

Les opérateurs logiques sont fréquemment utilisés dans des conditions, par ex. vérifier plusieurs exigences à la fois.

4. Opérateurs au niveau du bit

Les opérateurs au niveau du bit agissent sur les représentations binaires d'entiers. Ils incluent & (AND), | (OR), ^ (XOR), << (décalage à gauche) et >> (à droite). décalage).

Exemples :

pythonCopy
a = 6   # binary: 110
b = 3   # binary: 011

print(a & b)   # 2 (binary 010)
print(a | b)   # 7 (binary 111)
print(a ^ b)   # 5 (binary 101)
print(a << 1)  # 12 (binary 1100, shifted left by 1)
print(b >> 1)  # 1 (binary 001, shifted right by 1)

Les opérations au niveau du bit sont souvent utilisées dans la programmation de bas niveau, la cryptographie ou l'optimisation des performances.

5. Opérateurs d'affectation

Les opérateurs d'affectation attribuent des valeurs aux variables. Ils peuvent également combiner l’affectation avec des opérations arithmétiques ou au niveau du bit.

Exemples :

pythonCopy
x = 10   # simple assignment
x += 5   # equivalent to x = x + 5 → 15
x -= 3   # equivalent to x = x - 3 → 12
x *= 2   # equivalent to x = x * 2 → 24
x //= 4  # equivalent to x = x // 4 → 6
x %= 4   # equivalent to x = x % 4 → 2
x **= 3  # equivalent to x = x ** 3 → 8

Les opérateurs d'affectation sont des raccourcis permettant de mettre à jour une variable en place, ce qui rend le code plus concis.

Entiers

Les entiers sont des nombres entiers, positifs, négatifs ou nuls. Ils constituent l'un des types numériques de base de Python et sont utilisés pour les opérations mathématiques.

1. Création d'entiers

Des entiers peuvent être créés en attribuant des valeurs entières aux variables :

pythonCopy
a = 10
b = -5
c = 0
print(a, b, c)

2. Opérations sur les entiers

Les entiers prennent en charge diverses opérations arithmétiques :

pythonCopy
print(5 + 3)   # Addition
print(5 - 3)   # Subtraction
print(5 * 3)   # Multiplication
print(5 / 3)   # Division (returns float)
print(5 // 3)  # Floor division
print(5 % 3)   # Modulus

3. Conversion de type

Conversion d'autres types en entiers :

pythonCopy
num = int("123")
print(num)  # Outputs: 123

num = int(3.1415)
print(num)  # Outputs: 3

Flotteurs

Les flotteurs représentent des nombres réels pouvant avoir des parties fractionnaires. Ils constituent un autre type numérique de base en Python et sont essentiels pour les calculs décimaux.

1. Création de flotteurs

Des flotteurs peuvent être créés en attribuant des valeurs décimales aux variables :

pythonCopy
a = 3.1415
b = -0.5
c = 100.0
print(a, b, c)

2. Opérations flottantes

Les flotteurs prennent en charge diverses opérations arithmétiques :

pythonCopy
print(2.5 + 1.5)  # Addition
print(5.0 / 2)    # Division
print(3.1415 ** 2) # Exponentiation
print(7.3 % 3)    # Modulus

3. Conversion de type

Conversion d'autres types en flottants :

pythonCopy
num = float("123.45")
print(num)  # Outputs: 123.45

num = float(3)
print(num)  # Outputs: 3.0

num = float(5.5)
print(num)  # Outputs: 5.5

Chaînes

Les chaînes sont des séquences de caractères utilisées pour représenter du texte. Ils sont immuables et peuvent être définis à l'aide de guillemets simples, doubles ou triples pour les chaînes multilignes.

1. Création de chaînes

Les chaînes peuvent être créées à l'aide de différents types de guillemets :

pythonCopy
a = 'Hello, World!'
b = "Python is great"
c = """This is a
multi-line string"""
print(a, b, c, sep='\n')

2. Opérations sur les chaînes

Les chaînes prennent en charge diverses opérations telles que la concaténation et la répétition :

pythonCopy
print("Hello" + " World")  # Concatenation
print("Hello" * 3)        # Repetition
print("Hello"[0])        # Accessing characters
print("Hello"[1:3])      # Slicing

3. Méthodes de chaîne

Les chaînes ont diverses méthodes intégrées de manipulation :

pythonCopy
text = "hello world"
print(text.upper())      # Outputs: HELLO WORLD
print(text.lower())      # Outputs: hello world
print(text.replace("world", "earth"))  # Outputs: hello earth

Fonctions de chaîne

Les chaînes disposent de nombreuses méthodes utiles pour couper, diviser et remplacer du texte.

Découpage avec .strip()

pythonCopy
text = "   hello world   "
print(text.strip())   # "hello world"
print(text.lstrip())  # "hello world   "
print(text.rstrip())  # "   hello world"

Diviser les chaînes

pythonCopy
line = "apple,banana,cherry"
print(line.split(","))   # ['apple', 'banana', 'cherry']

words = "one two three".split()
print(words)             # ['one', 'two', 'three']

Remplacement du texte

pythonCopy
sentence = "I like cats"
print(sentence.replace("cats", "dogs"))
# "I like dogs"

Joindre des chaînes

pythonCopy
parts = ["2025", "09", "26"]
date = "-".join(parts)
print(date)   # "2025-09-26"

Pièges courants

• .strip() supprime les espaces par défaut, mais vous pouvez transmettre des caractères : "hello!!".strip("!").
• .split() sans arguments se divise sur n'importe quel espace, pas seulement des espaces.
• .replace() remplace toutes occurrences, sauf si vous transmettez un troisième argument (nombre maximum).
• .join() exige que tous les éléments soient des chaînes (et non des nombres).

Formatage des chaînes et méthodes de casse

Python propose plusieurs méthodes pour formater les chaînes et ajuster leur casse. Cela permet de créer une sortie dynamique et de contrôler l'apparence du texte.

Formatage avec .format()

pythonCopy
# Insert values into placeholders {}
template = "The sum of {0} and {1} is {2}"
msg = template.format(2, 4, 2+4)
print(msg)   # The sum of 2 and 4 is 6

# Named placeholders
info = "Name: {name}, Age: {age}".format(name="Alice", age=30)
print(info)

Conversion de cas

pythonCopy
text = "Hello World"
print(text.upper())   # "HELLO WORLD"
print(text.lower())   # "hello world"

Partitionnement des chaînes

pythonCopy
line = "user:password"
print(line.partition(":"))
# ('user', ':', 'password')

.partition() se divise en un tuple en 3 parties : texte avant, le séparateur lui-même et le texte après.

Pièges courants

• L'utilisation de .format() avec des clés manquantes ou incorrectes génère KeyError ou IndexError.
• .upper() / .lower() créent une nouvelle chaîne, ils ne modifient pas l'original.
• .partition() se divise uniquement lors de la première occurrence du séparateur.

Listes

Les listes sont des séquences polyvalentes et mutables utilisées pour stocker des collections d'éléments. Ils sont définis entre crochets [] et prennent en charge diverses opérations de modification et d'accès.

1. Création d'une liste

Définir une liste avec divers éléments :

pythonCopy
my_list = [1, 2, 3, "Python", True]
print(my_list)

2. Accès et modification des listes

Les listes prennent en charge l'indexation, le découpage et les méthodes de modification de leur contenu :

pythonCopy
# Accessing an element
print(my_list[3])  # Outputs: Python

# Changing an element
my_list[1] = "changed"
print(my_list)

# Appending a new element
my_list.append("new item")
print(my_list)

3. Compréhensions des listes

Les compréhensions de listes fournissent un moyen concis de créer des listes en itérant sur des séquences et en appliquant éventuellement des conditions :

pythonCopy
# Creating a list of squares for numbers 0 to 9
squares = [x**2 for x in range(10)]
print(squares)

Listes d'indexation

En Python, les listes sont des collections ordonnées et vous pouvez accéder aux éléments en utilisant leur index. L'indexation commence à 0 pour le premier élément. Les indices négatifs comptent à partir de la fin de la liste, -1 étant le dernier élément.

Indexation de base

pythonCopy
fruits = ["apple", "banana", "cherry"]
print(fruits[0])   # Outputs: apple
print(fruits[-1])  # Outputs: cherry

Modification d'éléments via l'index

pythonCopy
numbers = [10, 20, 30]
numbers[1] = 25
print(numbers)  # Outputs: [10, 25, 30]

Pièges courants

• IndexError: Accès à un index en dehors de la plage de la liste.
• Mutable vs Immuable : Seules les listes mutables peuvent être modifiées via l'indexation ; les tuples ne prennent pas en charge l'affectation.

Listes de découpage

Slicing vous permet d'extraire une partie d'une liste en utilisant la syntaxe list[start:stop:step]. L'index start est inclusif, stop est exclusif et step définit l'intervalle.

Découpage de base

pythonCopy
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4])    # Outputs: [1, 2, 3]
print(numbers[:3])     # Outputs: [0, 1, 2]
print(numbers[3:])     # Outputs: [3, 4, 5]
print(numbers[::2])    # Outputs: [0, 2, 4] - every 2nd element

Inverser une liste

pythonCopy
print(numbers[::-1])  # Outputs: [5, 4, 3, 2, 1, 0]

Pièges courants

• L'index Stop est exclusif ; list[start:stop] n'inclut pas l'élément à stop.
• Les indices négatifs peuvent être délicats ; assurez-vous qu'ils sont utilisés correctement avec la longueur de la liste.
• Slicing renvoie une nouvelle liste ; il ne modifie pas l'original à moins qu'il ne soit réaffecté.

Fonctions et méthodes spécifiques à une liste

Python fournit de nombreuses fonctions et méthodes intégrées spécifiquement pour les listes afin de manipuler, interroger et transformer efficacement les données.

Méthodes courantes

pythonCopy
fruits = ["apple", "banana", "cherry"]
fruits.append("date")      # Add element at the end
fruits.insert(1, "blueberry")  # Insert at index 1
fruits.remove("banana")    # Remove element by value
popped = fruits.pop()      # Remove and return last element
print(fruits, popped)

Autres méthodes utiles

pythonCopy
numbers = [3, 1, 4, 2]
numbers.sort()     # Sorts in ascending order
numbers.reverse()  # Reverses the list
print(numbers)

Fonctions intégrées pour les listes

pythonCopy
nums = [1, 2, 3, 4]
print(len(nums))   # Number of elements
print(sum(nums))   # Sum of elements
print(max(nums))   # Maximum value
print(min(nums))   # Minimum value

Travailler avec plusieurs listes

pythonCopy
# enumerate() gives index + value when looping
animals = ["cat", "dog", "mouse"]
for index, animal in enumerate(animals):
    print(index, animal)

# zip() pairs elements from multiple lists
names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(name, "scored", score)

enumerate() est utile lorsque vous avez besoin à la fois de la position et de la valeur d'un élément de liste. zip() est utile lors de la combinaison de deux ou plusieurs listes élément par élément.

Pièges courants

• Des méthodes telles que sort() et reverse() modifient la liste sur place et renvoient Aucun.
• La suppression d'éléments qui n'existent pas génère ValueError.
• Soyez prudent avec pop() sur les listes vides ; il génère IndexError.
• zip() s'arrête à la longueur de liste la plus courte.

Tuples

Les tuples sont des séquences immuables utilisées pour stocker une collection d'éléments. Ils sont définis entre parenthèses () et sont utiles lorsque vous souhaitez garantir l'intégrité des données.

1. Création d'un tuple

Un simple tuple contenant différents types de données :

pythonCopy
my_tuple = (10, "hello", 3.14)
print(my_tuple)

2. Accès aux éléments de tuple

Accéder aux éléments par leur index, semblable aux listes :

pythonCopy
# Accessing the first element
print(my_tuple[0])  # Outputs: 10

# Slicing the tuple
print(my_tuple[1:])  # Outputs: ('hello', 3.14)

Étant donné que les tuples sont immuables, leurs valeurs ne peuvent pas être modifiées après leur création.

Dictionnaires

Les dictionnaires stockent les données dans des paires clé-valeur, ce qui rend la recherche de données efficace. Ils sont créés à l'aide d'accolades {} et sont accessibles via leurs clés.

1. Création d'un dictionnaire

Un dictionnaire de base cartographiant les fruits selon leurs couleurs :

pythonCopy
fruit_colors = {
    "apple": "red",
    "banana": "yellow",
    "cherry": "red"
}

2. Accès et modification des données

Accédez à une valeur à l'aide de sa clé, ajoutez une nouvelle paire clé-valeur ou mettez à jour une paire existante :

pythonCopy
# Accessing a value
print(fruit_colors["apple"])  # Outputs: red

# Adding a new entry
fruit_colors["orange"] = "orange"

# Updating an entry
fruit_colors["banana"] = "green"

Parcourir les clés et les valeurs à l'aide de la méthode items() :

pythonCopy
for fruit, color in fruit_colors.items():
    print(f"{fruit} is {color}")

Fonctions du dictionnaire

Dictionaries (dict) stockent les données sous forme de paires clé-valeur. Python fournit des méthodes telles que .keys() et .values() pour accéder aux clés et aux valeurs séparément.

Accès aux clés

pythonCopy
person = {"name": "Alice", "age": 25, "city": "Zurich"}

print(person.keys())   # dict_keys(['name', 'age', 'city'])

# Loop through keys
for key in person.keys():
    print("Key:", key)

Accès aux valeurs

pythonCopy
print(person.values())  # dict_values(['Alice', 25, 'Zurich'])

# Loop through values
for value in person.values():
    print("Value:", value)

Utiliser ensemble des clés et des valeurs

pythonCopy
# Often combined with a for-loop
for key in person.keys():
    print(key, "->", person[key])

Pièges courants

• .keys() et .values() renvoient des vues spéciales, pas des listes normales. Si vous avez besoin d'une liste, enveloppez-la avec list().
• Les dictionnaires ne sont pas ordonnés avant Python 3.7. Dans Python moderne, ils conservent l'ordre d'insertion.

Variables

Les variables sont utilisées pour stocker des données en Python. Ils agissent comme des conteneurs nommés pour des valeurs de différents types (nombres, chaînes, etc.). Les variables Python doivent suivre certaines règles de dénomination :

• Le nom d'une variable doit commencer par une lettre ou un trait de soulignement (__).
• Un nom de variable ne peut pas commencer par un chiffre.
• Une variable ne peut pas utiliser de mots-clés Python réservés (voir le module keyword).

1. Création de variables

En Python, les variables sont créées automatiquement lorsque vous leur attribuez une valeur à l'aide de l'opérateur d'affectation =. Aucune déclaration explicite n’est nécessaire.

pythonCopy
a = 10
b = "Hello"
c = 3.14
print(a, b, c)   # Outputs: 10 Hello 3.14

2. Affectation de plusieurs variables

En cas de modification de deux variables ou plus à la fois et d'utilisation de certaines valeurs pour des calculs en cours, il est utile de changez-le simultanément.

pythonCopy
a, b = 4, 5
print(a)   # Outputs: 4
print(b)   # Outputs: 5
```<h2><span style="font-family: Roboto;">3. Utilisation de l'entrée pour créer des variables</span></h2>
<p><span style="font-family: Roboto;">
Des variables peuvent également être créées à partir de la saisie de l'utilisateur à l'aide de la fonction <code>input()</code>. 
Par défaut, <code>input()</code> renvoie une chaîne, mais vous pouvez la convertir en d'autres types si nécessaire.
</span></p>


```python
name = input("Enter your name: ")
age = int(input("Enter your age: "))  # type conversion to integer
print("Hello", name, "you are", age, "years old.")

4. Conversion de type

Parfois, vous devrez peut-être effectuer une conversion entre types de données (par exemple, d'une chaîne à un entier). Les fonctions courantes incluent int(), float() et str().

pythonCopy
num_str = "123"
num = int(num_str)   # convert string to integer
print(num, type(num))  # Outputs: 123 <class 'int'>

pi = 3.1415
print(str(pi))        # convert float to string → "3.1415"

5. Opérateurs et variables

Les variables peuvent être utilisées avec arithmetic, comparaison, et d'autres opérateurs d'affectation. Voir les sections dédiées aux opérateurs pour plus de détails et d'exemples.

Conditions : if, elif et else

Les instructions conditionnelles en Python vous permettent d'exécuter des blocs de code selon qu'une condition est vraie ou fausse. La structure de base utilise if, suivi éventuellement de elif (else if) et else pour la solution de secours.

1. Instruction if de base

Utilisez l'instruction if pour exécuter du code uniquement lorsqu'une condition est remplie :

pythonCopy
x = 10
if x > 5:
    print("x is greater than 5")  
    # Outputs: x is greater than 5

2. Déclaration if-else

Inclure un bloc else pour exécuter du code lorsque la condition n'est pas remplie :

pythonCopy
x = 3
if x > 5:
    print("x is greater than 5")
else:
    print("x is not greater than 5")  
    # Outputs: x is not greater than 5

3. if-elif-else Chaîne

Pour plusieurs conditions, utilisez elif pour vérifier des conditions supplémentaires :

pythonCopy
x = 5
if x > 5:
    print("x is greater than 5")
elif x == 5:
    print("x is exactly 5")
else:
    print("x is less than 5")
    # Outputs: x is exactly 5

Ces constructions vous permettent de créer des structures de prise de décision robustes dans vos programmes Python.

for-loop (Bases)

Une boucle for en Python répète le code pour chaque élément d'une séquence (comme une liste, une chaîne ou une plage de nombres). Contrairement à while, le nombre de répétitions est généralement connu à l'avance.

Comptage avec range()

pythonCopy
for i in range(5):
    print("Number:", i)
# Prints 0, 1, 2, 3, 4

range(5) génère des nombres de 0 à (mais non compris) 5.

Parcourir une liste

pythonCopy
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print("I like", fruit)

La boucle visite chaque élément de la liste un par un.

Faire une boucle dans une chaîne

pythonCopy
word = "hi!"
for char in word:
    print(char)
# Prints h, i, !

Utilisation de break et continue

pythonCopy
for num in range(1, 6):
    if num == 3:
        continue   # skip number 3
    if num == 5:
        break      # stop the loop completely
    print(num)
# Prints 1, 2, 4

Pièges courants

• Erreurs ponctuelles : N'oubliez pas que range(n) s'arrête avant n.
• Oublier que in vérifie les éléments : pour x dans la liste donne des éléments, pas des index.
• Mélange break et continue: break termine la boucle, continue saute uniquement l'étape en cours.

while-loop (Bases)

Une boucle while répète un bloc de code tant que sa condition est True. Contrairement aux boucles for, le nombre de répétitions n'est pas fixé à l'avance. La condition est vérifiée avant chaque répétition.

Important : Soyez prudent avec l'état. S'il ne devient jamais False, la boucle s'exécutera pour toujours (une boucle infinie).

Exemple de comptage simple

pythonCopy
x = 0
while x < 5:
    print("Counted to:", x)
    x += 1   # Important: update the counter!

Cette boucle commence à x = 0 et s'arrête une fois que x n'est plus inférieur à 5.

Arrêter tôt avec break

pythonCopy
x = 10
while True:       # runs "forever" unless stopped
    if x % 7 == 0:
        print("Found a multiple of 7:", x)
        break     # exit the loop
    x += 1

Ici, nous utilisons while True mais nous nous échappons avec break une fois qu'une condition est remplie.

Saut d'itérations avec continue

pythonCopy
x = -3
while x <= 3:
    x += 1
    if x == 0:       # skip division by zero
        continue
    print("1/", x, "=", 1/x)

L'instruction continue ignore l'étape de boucle actuelle et passe à la suivante.

Pièges de base

• Oubli de mettre à jour la variable : Si x += 1 est manquant, la condition ne change jamais, et la boucle s'exécute pour toujours.
• Conditions trop générales : while True n'est sûr que si vous incluez un break.
approprié

Instructions de contrôle de boucle : break, continue et pass

Python fournit des instructions spéciales qui modifient le flux normal des boucles. Ils sont utiles pour un contrôle précis des itérations, pour gérer les cas exceptionnels et pour rendre le code plus expressif.

break — Sortie d'une boucle

break termine immédiatement la boucle englobante la plus proche, quelle que soit l'état de la boucle. Il est couramment utilisé lorsqu'une condition cible est remplie et qu'aucune autre itération n'est nécessaire.

pythonCopy
nums = [1, 4, 7, 10]
for n in nums:
    if n > 5:
        print(f"Found {n}, stopping loop.")
        break
# Only iterates until 7, then exits

continue — Sauter une itération

continue ignore le reste de l'itération en cours et passe directement à la suivante. Il est souvent utilisé pour filtrer les cas indésirables.

pythonCopy
for n in range(5):
    if n % 2 == 0:
        continue
    print(f"Odd: {n}")
# Prints Odd: 1, 3

pass — Déclaration d'espace réservé

pass ne fait rien et agit comme un espace réservé syntaxique. Ceci est utile lorsqu'un bloc de code est requis syntaxiquement mais qu'aucune action ne doit encore être entreprise (par exemple, pendant le développement ou dans les méthodes de classe abstraite).

pythonCopy
for n in range(3):
    if n == 1:
        pass  # Placeholder for future logic
    else:
        print(n)
# Prints 0 and 2, does nothing on 1
```<h2 class="error">Pièges courants</h2>
<ul>
<li><strong>Confondre <code>break</code> avec <code>return</code>:</strong> <code>break</code> quitte uniquement la boucle, pas la fonction. Utilisez <code>return</code> pour quitter complètement une fonction.</li>
<li><strong>Boucles infinies avec <code>continue</code>:</strong> Dans les boucles <code>while</code>, placer <code>continue</code> avant de mettre à jour les variables de boucle peut empêcher la condition de se produire. changer.</li>
<li><strong>Une utilisation abusive de <code>pass</code>:</strong> Étant donné que <code>pass</code> ne fait rien, le laisser involontairement dans le code de production peut masquer une logique manquante ou des bogues.</li>
</ul>

<h2>Comparaison rapide</h2>
<ul>
<li><code>break</code> : quittez complètement la boucle.</li>
<li><code>continue</code> : passer à l'itération suivante.</li>
<li><code>pass</code> : ne rien faire, espace réservé uniquement.</li>
</ul>

Boucles imbriquées

Les boucles imbriquées sont des boucles à l'intérieur des boucles. La boucle externe s'exécute une fois pour chaque itération de la boucle interne, multipliant le nombre total d'itérations. Ils sont essentiels pour travailler avec des données multidimensionnelles, des problèmes combinatoires et algorithmiques.

Produit cartésien

pythonCopy
colors = ["red", "blue"]
sizes = ["S", "M", "L"]
for color in colors:
    for size in sizes:
        print(color, size)

Imbriqué while

pythonCopy
i = 1
while i <= 3:
    j = 1
    while j <= 2:
        print(i, j)
        j += 1
    i += 1

Pièges

Explosion de complexité : Deux boucles imbriquées sur n éléments entraînent chacune une complexité O(n²). L'ajout de niveaux supplémentaires augmente considérablement la durée d'exécution.

Observation de variables : La réutilisation accidentelle des noms de variables dans les boucles internes et externes peut remplacer les valeurs de manière inattendue.

Fonctions et expressions Lambda

Les fonctions en Python sont définies à l'aide du mot-clé def et vous permettent d'encapsuler du code pour le réutiliser. De plus, les expressions lambda fournissent un raccourci pour créer de petites fonctions anonymes.

1. Définir des fonctions

Utilisez def pour définir une fonction, éventuellement avec des paramètres :

pythonCopy
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))  
# Outputs: Hello, Alice!

2. Fonctions Lambda

Les expressions Lambda créent de petites fonctions anonymes. Ils sont utiles pour les fonctions courtes et simples :

pythonCopy
# A lambda that adds two numbers
add = lambda a, b: a + b
print(add(3, 4))  # Outputs: 7

Les fonctions régulières et les expressions lambda sont des outils essentiels pour organiser et simplifier votre code.

Importation de modules en Python

Python vous permet d'étendre les fonctionnalités en important des modules (fichiers contenant du code, des fonctions et des classes Python). Les modules peuvent être intégrés, personnalisés ou installés à partir de sources externes (comme PyPI).

1. Syntaxe d'importation de base

Utilisez l'instruction import pour introduire un module dans votre programme.

pythonCopy
import math
print(math.sqrt(16))   # Outputs: 4.0

2. Importation de fonctions ou d'alias spécifiques

Vous pouvez importer des fonctions spécifiques ou renommer des modules pour plus de commodité.

pythonCopy
from math import pi, sin
print(pi)        # Outputs: 3.141592653589793
print(sin(90))   # Uses radians by default

import numpy as np
arr = np.array([1, 2, 3])
print(arr)
```<h2><span style="font-family: Roboto;">3. Modules intégrés couramment utilisés</span></h2>
<p><span style="font-family: Roboto;">Certains des modules intégrés les plus utiles incluent :</span></p>
<ul>
<li><span style="font-family: Roboto;"><code>math</code> → Fonctions mathématiques (sqrt, pi, sin, cos...)</span></li>
<li><span style="font-family: Roboto;"><code>aléatoire</code> → Nombres aléatoires, brassage, choix</span></li>
<li><span style="font-family: Roboto;"><code>datetime</code> → Dates et heures</span></li>
<li><span style="font-family: Roboto;"><code>os</code> → Interactions avec le système d'exploitation (fichiers, répertoires)</span></li>
<li><span style="font-family: Roboto;"><code>sys</code> → Paramètres et fonctions spécifiques au système</span></li>
<li><span style="font-family: Roboto;"><code>json</code> → Travailler avec des données JSON</span></li>
</ul>

<h2><span style="font-family: Roboto;">4. Installation de modules externes</span></h2>
<p><span style="font-family: Roboto;">
De nombreux modules populaires ne sont pas intégrés et doivent être installés via <code>pip</code> (le gestionnaire de packages de Python).
</span></p>


```bash
pip install numpy
pip install requests

pythonCopy
import requests
response = requests.get("https://api.github.com")
print(response.status_code)
```<h2><span style="font-family: Roboto;">5. Résolution des erreurs d'importation</span></h2>
<p><span style="font-family: Roboto;">
Problèmes courants lors de l'importation de modules :
</span></p>
<ul>
<li><span style="font-family: Roboto;"><strong>ModuleNotFoundError</strong> : Le module n'est pas installé.  
➝ Correctif : exécutez <code>pip install modulename</code>.</span></li>
<li><span style="font-family: Roboto;"><strong>ImportError</strong> : Une fonction/classe spécifique ne peut pas être importée.  
➝ Correctif : consultez la documentation du module pour connaître les noms de fonctions corrects.</span></li>
<li><span style="font-family: Roboto;"><strong>Conflits de versions</strong> : une version de module peut ne pas prendre en charge votre version de Python.  
➝ Correction : mise à niveau avec <code>pip install --upgrade modulename</code>.</span></li>
<li><span style="font-family: Roboto;"><strong>Problèmes d'environnement virtuel</strong> : Le module est installé dans un environnement différent.  
➝ Correctif : activez le bon environnement avant d'exécuter le script.</span></li>
</ul>

<h2><span style="font-family: Roboto;">6. Vérification des modules installés</span></h2>


```bash
pip list        # Shows installed modules
pip show numpy  # Details about a specific module

Savoir comment importer et gérer des modules vous permet d'étendre les fonctionnalités de Python bien au-delà de ses fonctionnalités principales.

Méthodes de fichiers de base

La fonction intégrée open() renvoie un objet fichier que vous pouvez utiliser pour lire ou écrire dans des fichiers sur le disque. Le mode détermine les actions autorisées : 'r' (lecture, par défaut), 'w' (écriture, écrasement), 'a' (ajouter). L'ouverture d'un fichier ne lit ni n'écrit les données en soi - vous devez appeler les méthodes de fichier indiquées ci-dessous. Fermez toujours les fichiers lorsque vous avez terminé (ou, de préférence, utilisez un gestionnaire de contexte).

Modes — exemples rapides

pythonCopy
# implicit read mode (same as 'r')
f = open("example.txt")
f.close()

# explicit read
f = open("example.txt", "r")
f.close()

# open for writing (will overwrite)
f = open("output.txt", "w")
f.write("line 1\n")
f.close()

# open for appending (adds to end)
f = open("output.txt", "a")
f.write("another line\n")
f.close()

.read() — lire l'intégralité du contenu

read() renvoie le reste du fichier sous la forme d'une seule chaîne. S'il est appelé à nouveau alors qu'il est déjà à la fin, il renvoie une chaîne vide.

pythonCopy
f = open("notes.txt", "r", encoding="utf-8")
all_text = f.read()
print(len(all_text))   # number of characters read
more = f.read()        # already at EOF → returns ''
print(repr(more))      # shows ''
f.close()

.readline() — lire la ligne suivante

readline() renvoie la ligne suivante (y compris la nouvelle ligne de fin si elle est présente). L'appeler à plusieurs reprises avance dans le fichier. Un argument size (par exemple, readline(50)) limite le nombre de caractères renvoyés — il ne pas sélectionne la « nième ligne ».

pythonCopy
f = open("notes.txt", "r", encoding="utf-8")
first = f.readline()
second = f.readline()
print("First:", first)
print("Second:", second)
# to get the 3rd line specifically, iterate 3 times or use itertools.islice
f.close()
```<h2><span style="font-family: Roboto;">.readlines() — récupère toutes les lignes sous forme de liste</span></h2>
<p><span style="font-family: Roboto;">
<code>readlines()</code> renvoie une liste où chaque élément correspond à une ligne du fichier (y compris les caractères de nouvelle ligne). À utiliser avec précaution sur des fichiers très volumineux.
</span></p>


```python
f = open("notes.txt", "r", encoding="utf-8")
lines = f.readlines()
print("Number of lines:", len(lines))
print("Line 0:", lines[0])
f.close()

.write() — écrit des chaînes dans un fichier

write() nécessite une chaîne. Convertissez d'autres types avec str(). Le comportement (écraser ou ajouter) dépend du mode utilisé lors de l'ouverture du fichier.

pythonCopy
# overwrite file
f = open("results.txt", "w", encoding="utf-8")
f.write("score: " + str(42) + "\n")
f.close()

# append
f = open("results.txt", "a", encoding="utf-8")
f.write("score: " + str(100) + "\n")
f.close()

.close() et bonnes pratiques

close() libère le descripteur de fichier et garantit que les données mises en mémoire tampon sont vidées sur le disque. Oublier de fermer peut bloquer d'autres programmes ou perdre des données. Le modèle recommandé est le gestionnaire de contexte qui se ferme automatiquement.

pythonCopy
# manual close (works but easy to forget on errors)
f = open("data.txt", "r", encoding="utf-8")
try:
    content = f.read()
finally:
    f.close()

# preferred: context manager (automatic close)
with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:
        process(line.rstrip("\n"))
# file is closed here automatically

Petits exemples pratiques

pythonCopy
# Example: copy a file line-by-line (memory-friendly)
with open("source.txt", "r", encoding="utf-8") as src, \
     open("copy.txt", "w", encoding="utf-8") as dst:
    for line in src:
        dst.write(line)

# Example: read the 3rd line safely
from itertools import islice
with open("notes.txt", "r", encoding="utf-8") as f:
    third_line = next(islice(f, 2, 3), "")  # returns "" if missing
```<h2><span style="font-family: Roboto;">Erreurs courantes et solutions rapides</span></h2>
<ul>
<li><span style="font-family: Roboto;"><strong>FileNotFoundError</strong> : vérifiez le chemin ou utilisez un chemin absolu.</span></li>
<li><span style="font-family: Roboto;"><strong>PermissionError</strong> : assurez-vous que vous disposez des autorisations d'écriture/lecture pour le dossier cible.</span></li>
<li><span style="font-family: Roboto;"><strong>UnicodeDecodeError</strong> : spécifiez le <code>encoding</code> correct (par exemple, <code>"utf-8"</code>, <code>"latin-1"</code>) ou ouvrir en mode binaire <code>"rb"</code> pour les octets bruts.</span></li>
</ul>

NumPy — Installer et importer

NumPy est le package de base pour le calcul numérique en Python (tableaux, mathématiques rapides, algèbre linéaire). Installez-le avec pip ou votre gestionnaire de packages, puis importez-le (classiquement sous np).

Installer

shellCopy
# with pip
pip install numpy

# or with conda
conda install numpy

Importer

pythonCopy
import numpy as np
# now use np.array, np.linspace, np.zeros, ...

Pièges courants

• Assurez-vous d'installer dans le même environnement Python que celui que vous exécutez (problèmes d'environnement virtualenv/conda).
• L'importation sous un autre format que np est autorisée mais peu courante – d'autres personnes s'attendent à np.

Tableaux NumPy - Créer, indexer, découper

NumPy sont comme des listes mais avec des types numériques fixes et des opérations vectorisées rapides. Vous pouvez convertir des listes, créer des tableaux imbriqués (2D) et les indexer/découper.

Créer à partir de listes

pythonCopy
import numpy as np

a = np.array([1, 2, 3, 4])            # 1D array
b = np.array([[1, 2, 3], [4, 5, 6]])  # 2D array
print(a.shape)   # (4,)
print(b.shape)   # (2, 3)

Indexation (1D et 2D)

pythonCopy
print(a[0])      # first element -> 1
print(b[1, 2])   # second row, third column -> 6
print(b[0][1])   # alternative syntax -> 2

Découpage

pythonCopy
c = np.arange(10)       # array([0,1,2,...,9])
print(c[1:5])             # [1 2 3 4]
print(b[0:2, 1:3])        # rows 0..1 and cols 1..2 (2x2 subarray)

Pièges courants

Les tableaux
• NumPy nécessitent un type uniforme : les objets Python mixtes conduisent à dtype=object.
• Les tranches sont des **vues**, pas des copies : la modification d'une tranche peut modifier le tableau d'origine.

Forme du tableau et propriété .shape

.shape renvoie un tuple avec la taille de chaque dimension. C'est une propriété (pas de parenthèses).

Exemples

pythonCopy
import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array([[1,2,3],[4,5,6]])

print(a.shape)   # (4,)
print(b.shape)   # (2, 3)

# reshape if needed
c = a.reshape((2,2))
print(c.shape)   # (2, 2)

Pièges courants

• Appeler .shape() avec des parenthèses est incorrect : c'est une propriété, pas une fonction.
• reshape nécessite des tailles qui se multiplient par le même nombre d'éléments (ou utilisez -1 pour l'inférence automatique).

NumPy — Fonctions de base (linspace, zéros, aléatoire, ...)

NumPy propose des constructeurs et des assistants pratiques pour les tableaux et séquences couramment utilisés.

Constructeurs communs

pythonCopy
import numpy as np

# even spacing: start, stop, num-values
x = np.linspace(0, 1, num=5)    # [0.  0.25 0.5  0.75 1. ]

# zeros with shape / dtype
Z = np.zeros((2,3), dtype=float)  # 2x3 array of zeros

# arange like Python range -> integers
r = np.arange(0, 10, 2)           # [0 2 4 6 8]

Numéros aléatoires

pythonCopy
# modern usage (numpy >= 1.17) prefers Generator, but simple forms below:
rand = np.random.rand(3)       # 3 uniform floats in [0,1)
rnorm = np.random.randn(3)     # 3 standard normal samples
rint = np.random.randint(0, 10, size=4)  # 4 ints in [0,10)

Comportement du type de données

pythonCopy
a = np.array([1, 2, 3], dtype=int)
a[0] += 0.2
print(a)  # still integer array; fractional part lost (a[0] remains 1)

• Si un tableau a un type entier, les opérations sur place seront converties en ce type (troncation possible).
• Pour autoriser les flottants, créez le tableau avec dtype=float ou lancez avec .astype().

Matplotlib — Installer et importer

Matplotlib est la bibliothèque de traçage standard pour Python. Installez-le avec votre gestionnaire de packages et importez le module pyplot (généralement sous le nom plt).

Installer

shellCopy
# with pip
pip install matplotlib

# or with conda
conda install matplotlib

Importer

pythonCopy
import matplotlib.pyplot as plt
# optionally import numpy for data
import numpy as np

Pièges courants

• Installer dans l'environnement actif (virtualenv/conda) utilisé par votre script ou notebook.
• Dans certains environnements (par exemple, les serveurs sans tête), vous aurez peut-être besoin d'un backend non interactif pour enregistrer les chiffres.

Matplotlib — Utilisation de base (plt.plot, plt.show, save)

Flux de travail de traçage simple : créez des données, appelez des fonctions de traçage, puis affichez ou enregistrez la figure.

Tracé linéaire simple

pythonCopy
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)

plt.plot(x, y)       # plot the line
plt.show()           # display the plot window (or inline in notebooks)

Séries multiples et sauvegarde

pythonCopy
plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.legend()
plt.savefig('sincos.png')  # save to file
plt.show()

Pièges courants

• Appelez plt.show() après avoir configuré le tracé — sinon certains backends risquent de ne pas afficher le style complet.
• Lorsque vous tracez plusieurs figures, utilisez plt.figure() ou fig, ax = plt.subplots() pour les séparer.

Matplotlib — Modificateurs et style (titre, légende, axes, aspect)

Utilisez des étiquettes, des limites, des légendes et des méthodes d'axe pour ajuster l'apparence et la disposition des tracés.

Étiquettes, titre, légende

pythonCopy
plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.xlabel('x (rad)')
plt.ylabel('value')
plt.title('Sine & Cosine')
plt.legend()  # show labels in top-right by default
plt.show()

Limites et aspect des axes

pythonCopy
plt.plot([0,1,2], [0,1,4])
plt.xlim(0, 2)        # set x limits
plt.ylim(0, 5)        # set y limits

ax = plt.gca()        # get current Axes
ax.set_aspect('equal')   # equal scaling for x and y units
plt.show()

Masquer les axes ou les graduations

pythonCopy
ax = plt.gca()
ax.xaxis.set_visible(False)   # hide x-axis
ax.yaxis.set_visible(False)   # hide y-axis

Pièges courants

• La modification des propriétés de l'axe nécessite un objet Axes (depuis plt.gca() ou le retour de plt.subplots()).
• De nombreuses options de style sont persistantes pour la figure/les axes actuels : appelez-les dans le bon ordre ou créez une nouvelle figure pour des tracés séparés.

Concepts Python avancés

Au-delà des bases, Python offre de nombreuses fonctionnalités avancées pour écrire du code concis, efficace et robuste. Des sujets tels que la compréhension des listes, les générateurs et la gestion des exceptions peuvent vous aider à faire passer vos compétences en programmation au niveau supérieur.

1. Compréhensions des listes

Les compréhensions de listes fournissent un moyen concis de créer des listes. Ils peuvent remplacer les boucles dans de nombreux cas :

pythonCopy
# Traditional loop
squares = []
for i in range(10):
    squares.append(i ** 2)

# Using list comprehension
squares = [i ** 2 for i in range(10)]
print(squares)

2. Gestion des exceptions

Utilisez des blocs try-sauf pour gérer efficacement les erreurs et les exceptions :

pythonCopy
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    # is executed if try did not work
    # and the exception is not the same as in except
    print("Not execute but no ZeroDivisionError.")
finally:
    # is always executed
    print("Execution complete.")
    # Outputs an error message 
    # and a final execution statement

3. Générateurs

Les générateurs vous permettent d'itérer efficacement sur de grands ensembles de données sans stocker la séquence entière en mémoire :

pythonCopy
def count_up_to(n):
    count = 1
    while count <= n:
        yield count
        count += 1

for number in count_up_to(5):
    print(number)
    # Outputs: 1 2 3 4 5

L'exploration de ces sujets avancés peut améliorer considérablement vos capacités de programmation Python.