Listes et fonctions

Graphique de fonctions

Nous allons tracer la représentation graphique de

$$ f : x \mapsto x^2 - 10x + 20 $$

Recopier le programme suivant, compléter les pointillés et calculer les images jusqu'à 8.

def f(x):
    return x**2 - 10*x + 20

# image de 0
print("L'image de", "..."," est", "...")
# image de 1
print("L'image de", "..."," est", "...")

L'image de ...  est ...
L'image de ...  est ...

Pour tracer le graphique de cette fonction, il faudrait enregistrer toutes ces valeurs et donc utiliser des variables.

Mettre plusieurs valeurs dans une seule variable c'est possible, on utilise des listes (on les a déjà rencontré plusieurs fois).

Recopier et compléter ce programme pour enregistrer les images et les antécédents jusqu'à 10.

def f(x):
    return x**2/10 - 5

images = [] # La liste est vide
antecedents = []


# image de 0
print("L'image de", "..."," est", "...", "On l'ajoute à la liste")
antecedents.append(0) # On ajoute (append) 0 à la liste des antecedents
# image de 1
print("L'image de", "..."," est", "...")

L'image de ...  est ... On l'ajoute à la liste
L'image de ...  est ... On l'ajoute à la liste

Nous allons maintenant enfin pouvoir tracer le graphique.

Ajouter la ligne suivante au début de votre programme.

import matplotlib.pyplot as plt

Ajouter cette ligne à la fin.

plt.plot(antecedants, images)
plt.show()

Vous avez tracer la courbe représentative de de la fonction $f$.

Dans un nouveau fichier, tracer la courbe représentative pour x allant de 0 à 15 de la fonction $g$ tel que $$ g : x \mapsto -(x - 5)^2 + 5$$

Précision et controle du tracé

Pour le moment, on sait donner un maximum à l'antécédent $x$ mais on ne peut pas contrôler le minimum ni le pas (l'écart en 2 valeurs de $x$).

Or pour tracer précisément la représentation graphique d'une fonction, nous avons besoin de contrôler la fenêtre (minimum et maximum) et le pas.

Boucle while (tant que )

Une boucle while permet de répeter une ou plusieurs actions tant qu' une condition est vérifiée.

Les 2 programmes ci-dessous font la même chose.

x = 0

print(x)
x = x+1

print(x)
x = x+1

print(x)
x = x+1

print(x)
x = x+1

print(x)
x = x+1

print(x)
x = x+1

print(x)
x = x+1

print(x)
x = x+1

print(x)
x = x+1

print(x)
x = x+1

0
1
2
3
4
5
6
7
8
9

x = 0
while x < 10:
    print(x)
    x = x + 1

0
1
2
3
4
5
6
7
8
9

Commenter le programme avec le while.

Que se passe-t-il si on inverse les 2 dernières lignes?

Réécrire le programme suivant en utilisant une boucle while et en stockant les antécédents.

from math import sin, pi

def h(x):
    return sin(x*pi/2)

images = []
antecedants = []

# image de 0
print("L'image de", "..."," est", "...", "On les ajoute à la liste")
antecedents.append(0)
images.append(h(0))

# image de 1
print("L'image de", "..."," est", "...", "On les ajoute à la liste")
antecedents.append(1)
images.append(h(1))

# ....

# image de 20
print("L'image de", "..."," est", "...", "On les ajoute à la liste")
antecedents.append(20)
images.append(h(20))

print("Les images sont ", images)

Les images sont  [0.0, 1.0, 1.2246467991473532e-16, -1.0, -2.4492935982947064e-16, 1.0, 3.6739403974420594e-16, -1.0, -4.898587196589413e-16, 1.0, 6.123233995736766e-16, -1.0, -7.347880794884119e-16, 1.0, 8.572527594031472e-16, -1.0, -9.797174393178826e-16, 1.0, 1.102182119232618e-15, -1.0]

Modifier votre programme pour que les antécédents aillent de -2 à 2.

Modifier votre programme pour que les antécédents augmentent avec un pas de 0.5 au lieu de 1.

Tracer sa représentation graphique pour $x$ allant de -2 à 2 avec un pas de 1.

Tracer sa représentation graphique pour $x$ allant de -2 à 2 avec un pas de 0.5.

Tracer sa représentation graphique pour $x$ allant de -2 à 2 avec un pas de 0.1.

En regroupant les 3 programmes écrit précedement, tracer sur le même graphique les 3 représentations pour observer l'amélioration de la précision.

Astuce: pour tracer 3 graphiques en 1, on fait les plt.plot(...) de chaque graphique et uniquement à la fin on lance plt.show().