Deuxième série d'exercices

Répéter une action

Les deux exercices suivants consistent à calculer les valeurs d'une fonction de votre choix dans l'intervalle $x\in[-5;5]$ avec

un pas de 1
un pas de 0.5

Vous tacherez de définir une fonction pour votre fonction mathématique et afficherez les valeurs de x et les valeurs de la fonction.

Suite de fibonacci

Calculer les termes de la suite de Fibonacci définis de la façon suivante :

$\begin{equation} \begin{cases} U_{n} & = U_{n-1} + U_{n-2} \\ U_0 & = 0 \\ U_1 & = 1 \\ \end{cases} \end{equation}$

Manipuler une liste

Ces deux exercices ont pour objectif d'introduire la manipulation des listes.

Écrire un programme qui crée une liste contenant les premiers entiers impairs et affiche cette liste.
Écrire un programme qui crée une liste contenant une série de nombres pseudo-aléatoires compris entre -1 et 1 et affiche cette liste. On utilisera pour cela la fonction random du module random.
Amusons nous un peu.

Le bouclier déflecteur de l'étoile de la mort (Star Wars, épisode VI) est composé de plusieurs couches de plasma thermo-magnétique. En traversant la couche n, l'intensité du laser d'un X-Wing Starfighter diminue d'un facteur $\alpha(n)$ dont l'expression est : $\alpha(n) = 0.83 \exp\left( - 0.04982 ( n - 1 ) \right)$
- Combien de couches le laser aura-t-il traversé s'il a perdu les trois quart de son intensité ?
- Sachant que l'intensité initiale du laser est $I_o = 112358 W$ , combien de couches doit contenir le bouclier déflecteur pour que l'intensité du laser soit inférieure à 10 W lorsque le tir atteint sa cible.

Corrections

ATTENTION : Vous êtes sûr d'avoir suffisament essayé avant de voir la correction ?

Valeurs d'une fonction

On se donne tout d'abord une fonction, par exemple la fonction suivante sur l'intervalle $x\in[-1; 3[$

$f(x) = \frac{(4x^3 - 6x^2 + 1)\sqrt{x+1}}{3 - x}$

Écrivons cette fonction en prennant garde de rester dans le bon intervalle. Il ne faut pas oublier d'importer la fonction sqrt du module math.

from math import sqrt
def f(x):
    """ ma fonction """
    if -1 <= x < 3:
        return (4 * x**3 - 6 * x**2 + 1) * sqrt(x + 1)/ (3 - x)
    else:
        print("WARNING : x n'est pas dans l'intervalle de définition de f")
        return None

On va maintenant calculer les valeurs de la fonction par pas de 1 :

for x in range(6):
    print(x, f(x))

Ce qui donne

0 0.3333333333333333
1 -0.7071067811865476
2 15.588457268119894
WARNING : x n'est pas dans l'intervalle de définition de f
3 None
WARNING : x n'est pas dans l'intervalle de définition de f
4 None
WARNING : x n'est pas dans l'intervalle de définition de f
5 None

Il serait préférable de faire

for x in range(-1, 3):
    print(x, f(x))

-1 -0.0
0 0.3333333333333333
1 -0.7071067811865476
2 15.588457268119894

Passons maintenant à un pas de 0.5. Nous allons utiliser une boucle while :

# initialisation
x = -1
pas = 0.5
# boucle
while x < 3:
    print(x, f(x))
    x += pas

Ce qui donne :

-1 -0.0
-0.5 -0.20203050891044216
0.0 0.3333333333333333
0.5 0.0
1.0 -0.7071067811865476
1.5 1.0540925533894598
2.0 15.588457268119894
2.5 97.28309205612247

Suite de Fibonacci

Les termes de la suite de Fibonacci sont définis par :

$\begin{equation} \begin{cases} U_{n} & = U_{n-1} + U_{n-2} \\ U_0 & = 0 \\ U_1 & = 1 \\ \end{cases} \end{equation}$

On peut calculer les termes de cette liste avec une boucle while ou une boucle for.

def fibonacci(n):
    """ Calcule les n premiers éléments de la suite de fibonacci """

    # initialisation
    u = [0, 1]

    # calcul des valeurs avec une boucle while
    i = 2
    while i < n:
        u.append(u[i-1] + u[i-2])
        i += 1

    return u

print(fibonacci(10))

Résultat :

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

On peut faire la même chose avec une boucle for :

def fibonacci(n):
    """ Calcule les n premiers éléments de la suite de fibonacci """

    # initialisation
    u = [0, 1]

    # calcul des valeurs
    for i in range(2, n):
        u.append(u[i-1] + u[i-2])

    return u

Utilisation des listes

Liste contenant les premiers entiers impairs et affiche cette liste.

En fait on peut obtenir très simplement cette liste à partir de la fonction range().

>>> impairs = list(range(1, 20, 2))
>>> print(impairs)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

C'est également l'occasion de découvrir les listes en compréhension ou list comprehension en anglais qui permettent de construire une liste avec une boucle for mais sur une seule ligne. Par exemple, les lignes suivantes :

>>> malist = list()
>>> for i in range(5):
...     malist.append(3 * i - 1)
>>> print(malist)
[-1, 2, 5, 8, 11]

peuvent être remplacées par l'unique ligne suivante :

>>> malist = [3 * i - 1 for i in range(5)]
>>> print(malist)
[-1, 2, 5, 8, 11]

Une autre façon de créer une liste de nombres impairs est donc :

>>> impairs = [2 * i + 1 for i in range(10)]
>>> print(impairs)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

Essayons maintenant d'avoir une fonction qui renvoie le nombre souhaité de nombres impairs :

def get_odd(n):
    """ retourne les n premiers nombres impairs """
    return [2 * i + 1 for i in range(n)]
impairs = get_odd(5)
print(impairs)

[1, 3, 5, 7, 9]

Liste de nombres aléatoires entre -1 et 1.

Première version sans compréhension de listes.

from random import random
def nombre_aleatoire(n):
    """ retoune une liste de n nombres aleatoires dans l'intervalle ]-1;1[] """
    # creation de la liste
    maListe = list()

    # remplissage et affichage de la liste
    for i in range(n):
        x = 2 * random() - 1
        maListe.append(x)

    # renvoie de la liste
    return maListe

liste_aleatoire = nombre_aleatoire(10)
print(liste_aleatoire)

[-0.6046927445855892, -0.878348850701256, -0.8226590776853149,
  0.9461206300847769, 0.006834292886062965, 0.13024638273947442,
 -0.7178558215419062, 0.8398222023594819, -0.03999145945919658,
  0.3536726384249611]

Deuxième version avec compréhension de listes.

from random import random
def nombre_aleatoire(n):
    """ retoune une liste de n nombres aleatoires dans l'intervalle ]-1;1[] """
    return [2 * random() - 1 for i in range(n)]

liste_aleatoire = nombre_aleatoire(10)
print(liste_aleatoire)

[-0.8038590712419067, -0.3459227696759206, -0.44087135408816436,
  0.25538004239761736, -0.8050229532763393, 0.19489054235953884,
 -0.7613568207194763, 0.31555687563975554, 0.26278528290623804,
 -0.14809381625603346]

Star Wars

Rappel du facteur d'atténuation :

$\alpha(n) = 0.83 \exp\left( - 0.04982 ( n - 1 ) \right)$

def attenuation(n):
    """ facteur d'attenuation du laser en fonction du nombre de couche """
    return 0.83 * np.exp(-0.04982 * (n - 1))

# Calcul du nombre de couche après avoir perdu 3/4 de l'intensité initiale
# initialisation :
I = Io = 112358
n = 0
# boucle :
while I > 0.25 * Io:
    n += 1
    I = attenuation(n) * I
    print("%3d %12.2f %12.2f" % (n, I, 0.25 * Io))

print("Nombre de couches nécessaires : ", n)

# calcul du nombre de couche nécessaires pour que l'intensité chute à 10 W
# initialisation :
I = 112358
n = 0
# boucle :
while I > 10:
    n += 1
    I = attenuation(n) * I
    print("%3d %12.2f" % (n, I))

print("Nombre de couches nécessaires : ", n)

On notera l'utilisation d'un format dans la fonction print() pour améliorer l'affichage des résultats.

Exercices : série 2