Matplotlib

import matplotlib

import random
import matplotlib.pyplot as plt
random_numbers = [random.randint(1, 14) for _ in range(10)]
plt.plot(random_numbers)
plt.show()

x = [5, 4, 2, 3, 0]
y = [2, 3, 1, 5, 4]
plt.plot(x, y)
plt.show()

plt.plot(x, y)
plt.axis([-7, 7, 1, 11])
plt.show()

import numpy as np
x = np.linspace(-3, 3, 100)
y = x**2

plt.plot(x, y)
plt.xlabel("x")
plt.ylabel("y = x^2")
plt.title("Plot of y = x^2")
plt.show()

x_filtered = x[x >= 0]
y = np.sqrt(x_filtered)

plt.plot(x_filtered, y)
plt.xlabel("x")
plt.ylabel("y = sqrt(x)")
plt.title("Plot of y = sqrt(x)")
plt.show()

x = np.linspace(-1, 5, 100)
y = np.sin(x)

plt.plot(x, y)
plt.xlabel("x")
plt.ylabel("y = sin(x)")
plt.title("Plot of y = sin(x)")
plt.show()

x = np.linspace(-1, 5, 100)
y = np.cos(x)

plt.plot(x, y)
plt.xlabel("x")
plt.ylabel("y = cos(x)")
plt.title("Plot of y = cos(x)")
plt.show()

plt.plot(x, y, 'y--')
plt.xlabel("x")
plt.ylabel("y = cos(x)")
plt.title("Plot of y = cos(x) (yellow, dashed)")
plt.show()

plt.plot(x, y, color='red', linestyle='--')
plt.title("Le graphique de la fonction Cosinus")
plt.xlabel("Axe des x")
plt.ylabel("Axe des y = cos(x) (yellow, tirets)")
plt.grid(True)
plt.show()

x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

plt.plot(x, y1, label='sin(x)')
plt.plot(x, y2, label='cos(x)')

plt.xlabel("x")
plt.ylabel("y")
plt.title("Graphique de sin(x) et cos(x)")
plt.legend()
plt.grid(True)
plt.show()

x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

plt.plot(x, y1, label='sin(x)')
plt.plot(x, y2, label='cos(x)')

plt.xlabel("x")
plt.ylabel("y")
plt.title("Graphique de sin(x) et cos(x)")
plt.legend()
plt.grid(True)
plt.show()
plt.savefig("sin_cos.png")
print("Le graphique a été enregistré sous le nom de sin_cos.png")

x = np.linspace(0, 10, 500)
y1 = np.sin(x)
y2 = np.cos(x)

# Tracer sin et cos sur des sous-graphiques
fig, axes = plt.subplots(1, 2, figsize=(10, 4))

# Tracer sin(x) sur le premier sous-graphique
axes[0].plot(x, y1, label='sin(x)', color='blue')
axes[0].set_xlabel("x")
axes[0].set_ylabel("y")
axes[0].set_title("Graphique de sin(x)")
axes[0].grid(True)
axes[0].legend()

# Tracer cos(x) sur le deuxième sous-graphique
axes[1].plot(x, y2, label='cos(x)', color='red')
axes[1].set_xlabel("x")
axes[1].set_ylabel("y")
axes[1].set_title("Graphique de cos(x)")
axes[1].grid(True)
axes[1].legend()

# Ajuster l'espacement entre les sous-graphiques
plt.tight_layout()
plt.show()

x = np.linspace(-2, 2, 500)
y = y1
y2 = y2

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))

ax1.plot(x, y, color='blue', linestyle='--')
ax1.set_title('Fonction sinn(x)')
ax1.grid(True)

ax2.plot(x, y2, color='green', linestyle='-')
ax2.set_title('Fonction cos(x)')
ax2.grid(True)

plt.show()

fig1 = plt.figure()
plt.plot(x, y, color='blue')
plt.title('Fonction sin(x)')
plt.grid(True)

fig2 = plt.figure()
plt.plot(x, y2, color='green')
plt.title('Fonction cos(x)')
plt.grid(True)

plt.show()

x = np.linspace(0, 5, 100)

# La façon simple (implicite)
plt.plot(x, np.sin(x))
plt.plot(x, np.cos(x))
plt.show()

x = np.linspace(0, 5, 100)

# La façon plus claire (explicite)
# On crée une figure (fig) et un graphique (ax)
fig, ax = plt.subplots()
# Et on dit à notre graphique "ax" de dessiner
ax.plot(x, np.sin(x))
ax.plot(x, np.cos(x))
plt.show()

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2.5, 50)
px = 0.8
py = np.sqrt(px)

fig, ax = plt.subplots()

# On dessine la courbe et un point rouge
ax.plot(x, np.sqrt(x), "y--", px, py, "ro")

# On ajoute du texte. On peut même utiliser une notation mathématique !
ax.text(0.5, 1.2, "Équation : $y = \sqrt{x}$", fontsize=15, ha="center")
ax.text(px + 0.1, py - 0.1, "un point important", ha="left")
ax.grid(True)
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_title("Plot of y = sqrt(x)")
plt.show()

x = np.linspace(0, 10, 100) # Création de 100 points pour x entre 0 et 10

# La façon plus claire (explicite)
# On crée une figure (fig) et un graphique (ax)
fig, ax = plt.subplots()
# Et on dit à notre graphique "ax" de dessiner
# On donne un "label" (une étiquette) à chaque courbe en français
ax.plot(x, np.sin(x), label='sinus')
ax.plot(x, np.cos(x), label='cosinus')
# La fonction legend() affiche la boîte avec les étiquettes
ax.legend()
plt.show()

x = np.linspace(0.1, 15, 500)
y = np.sin(x)

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))

# À gauche, l'échelle normale
ax1.plot(x, y)
ax1.set_title('Échelle normale')
ax1.grid(True)

# À droite, l'échelle spéciale (logarithmique sur l'axe Y)
ax2.semilogy(x, y)
ax2.set_title('Échelle spéciale (log)')
ax2.grid(True, which="both")
plt.show()

x = np.linspace(-2, 2, 100)

fig, ax = plt.subplots()
ax.plot(x, np.cos(x)) # Tracer la fonction cosinus
# On choisit où mettre les barres...
ax.set_xticks([-2, -1, 0, 1, 2])
# ...et on écrit le texte qu'on veut à la place des chiffres.
ax.set_xticklabels(['moins deux', 'moins un', 'zéro', 'un', 'deux'])
plt.show()

# Créer des points pour l'angle theta sur un tour complet (0 à 2*pi)
theta = np.linspace(0, 2 * np.pi, 400) # Augmenter les points pour des pétales plus lisses

# Créer une nouvelle figure
fig = plt.figure()
# Ajouter un sous-graphique polaire à la figure
ax = fig.add_subplot(111, projection='polar') # On dit qu'on veut un graphique polaire

# Tracer 5 formes de fleurs différentes en variant le nombre de pétales
ax.plot(theta, np.cos(2 * theta), color='r', label='2 pétales') # Fleur à 2 pétales (cosinus)
ax.plot(theta, np.sin(3 * theta), color='g', label='3 pétales') # Fleur à 3 pétales (sinus)
ax.plot(theta, np.cos(4 * theta), color='b', label='4 pétales') # Fleur à 4 pétales (cosinus)
ax.plot(theta, np.sin(5 * theta), color='purple', label='5 pétales') # Fleur à 5 pétales (sinus)
ax.plot(theta, np.cos(6 * theta), color='orange', label='6 pétales') # Fleur à 6 pétales (cosinus)


# Ajouter un titre au graphique
plt.title("Graphique Polaire - Plusieurs Formes de Fleurs") # Ajouter un titre
# Ajouter une grille pour une meilleure lisibilité
ax.grid(True) # Ajouter une grille
# Ajouter une légende pour identifier chaque fleur (placée à l'extérieur en bas à gauche)
ax.legend(loc='lower left', bbox_to_anchor=(1, 0.5)) # Ajouter une légende à l'extérieur du graphique

# Ajuster les limites radiales si nécessaire pour s'assurer que les pétales sont entièrement visibles
ax.set_rlim(-1, 1)

# Afficher le graphique
plt.show()

from mpl_toolkits.mplot3d import Axes3D

# On prépare une grille de points en 3D
x = np.linspace(-5, 5, 50)
y = np.linspace(-5, 5, 50)
X, Y = np.meshgrid(x, y)
R = np.sqrt(X**2 + Y**2)

# Calculer Z pour une forme différente (par exemple, un sombrero)
Z = np.sin(R) / R # Sombrero function

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d') # On active la 3D
ax.plot_surface(X, Y, Z, cmap='viridis') # On dessine une surface

ax.set_title("Graphique 3D - Forme Sombrero")
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")

plt.show()

# Créer des données pour un nuage de points différent (par exemple, une spirale)
theta = np.linspace(0, 2 * np.pi, 100) # Angle de 0 à 2*pi
r = theta # Rayon qui augmente avec l'angle

# Convertir les coordonnées polaires (r, theta) en coordonnées cartésiennes (x, y)
x = r * np.cos(theta)
y = r * np.sin(theta)

# Ajouter un peu de bruit pour rendre le nuage plus "nuageux"
noise_x = np.random.randn(100) * 0.5
noise_y = np.random.randn(100) * 0.5
x = x + noise_x
y = y + noise_y

# Créer des couleurs et des tailles aléatoires pour les points
colors = np.random.rand(100)
area = (20 * np.random.rand(100))**2

# Dessiner le nuage de points
plt.scatter(x, y, s=area, c=colors, alpha=0.7) # s: taille, c: couleur, alpha: transparence

# Ajouter des titres et étiquettes en français
plt.title("Nuage de points en forme de spirale (avec bruit)")
plt.xlabel("Axe des x")
plt.ylabel("Axe des y")

plt.show()

x = np.linspace(0, 10, 100)

plt.plot(x, np.sin(x), linestyle='-')  # Ligne normale
plt.plot(x, np.sin(x - 1), linestyle='--') # Tirets
plt.plot(x, np.sin(x - 2), linestyle='-.') # Tirets et points
plt.plot(x, np.sin(x - 3), linestyle=':')  # Petits points
plt.show()

# On génère 1000 nombres aléatoires
data = np.random.randn(1000)
# On crée l'histogramme avec 30 "boîtes" (bins)
plt.hist(data, bins=30)
plt.show()

from sklearn.datasets import load_sample_images

# On charge des images d'exemple
china = load_sample_images().images[0]
flower = load_sample_images().images[1]

fig, (ax1, ax2) = plt.subplots(1, 2)
ax1.imshow(china)
ax2.imshow(flower)
plt.show()

from matplotlib.animation import FuncAnimation

fig, ax = plt.subplots()
line, = ax.plot([], [], 'b--')
ax.set_xlim(0, 2)
ax.set_ylim(-1.1, 1.1)

# Cette fonction dessine chaque image de l'animation
def animate(i):
    x = np.linspace(0, 2, 1000)
    y = np.cos(2 * np.pi * (x - 0.01 * i))
    line.set_data(x, y)
    return line,

# On lance l'animation
ani = FuncAnimation(fig, animate, frames=200, interval=20, blit=True)

plt.show()

from matplotlib import animation

# Note : Il faut avoir installé FFmpeg pour que ça marche.
Writer = animation.writers['ffmpeg']
writer = Writer(fps=15, metadata=dict(artist='Moi'), bitrate=1800)

# On enregistre l'animation créée juste avant
ani.save('mon_animation.mp4', writer=writer)