Apprenez à programmer en Python
Last updated on Monday, September 8, 2014
  • 4 semaines
  • Facile

Ce cours est visible gratuitement en ligne.

Paperback available in this course

Ce cours existe en eBook.

Certificate of achievement available at the end this course

Got it!

Un peu de mathématiques

Dans ce chapitre, nous allons découvrir trois modules. Je vous ai déjà fait utiliser certains de ces modules, ce sera ici l'occasion de revenir dessus plus en détail.

  • Le module math qui propose un bon nombre de fonctions mathématiques.

  • Le module fractions, dont nous allons surtout voir la classe Fraction, permettant… vous l'avez deviné ? De modéliser des fractions.

  • Et enfin le module random que vous connaissez de par nos TP et que nous allons découvrir plus en détail ici.

Pour commencer, le module math

Le module math, vous le connaissez déjà : nous l'avons utilisé comme premier exemple de module créé par Python. Vous avez peut-être eu la curiosité de regarder l'aide du module pour voir quelles fonctions y étaient définies. Dans tous les cas, je fais un petit point sur certaines de ces fonctions.

Je ne vais pas m'attarder très longtemps sur ce module en particulier car il est plus vraisemblable que vous cherchiez une fonction précise et que la documentation sera, dans ce cas, plus accessible et explicite.

Fonctions usuelles

Vous vous souvenez des opérateurs +, -, *, / et % j'imagine, je ne vais peut-être pas y revenir.

Trois fonctions pour commencer notre petit tour d'horizon :

>>> math.pow(5, 2) # 5 au carré
25.0
>>> 5 ** 2 # Pratiquement identique à pow(5, 2)
25
>>> math.sqrt(25) # Racine carrée de 25 (square root)
5.0
>>> math.exp(5) # Exponentielle
148.4131591025766
>>> math.fabs(-3) # Valeur absolue
3.0
>>>

Il y a bel et bien une différence entre l'opérateur ** et la fonction math.pow. La fonction renvoie toujours un flottant alors que l'opérateur renvoie un entier quand cela est possible.

Un peu de trigonométrie

Avant de voir les fonctions usuelles en trigonométrie, j'attire votre attention sur le fait que les angles, en Python, sont donnés et renvoyés en radians (rad).

Pour rappel :

Citation

1 rad = 57,29 degrés

Cela étant dit, il existe déjà dans le module math les fonctions qui vont nous permettre de convertir simplement nos angles.

math.degrees(angle_en_radians) # Convertit en degrés
math.radians(angle_en_degrés) # Convertit en radians

Voyons maintenant quelques fonctions. Elles se nomment, sans surprise :

  • cos : cosinus ;

  • sin : sinus ;

  • tan : tangente ;

  • acos : arc cosinus ;

  • asin : arc sinus ;

  • atan : arc tangente.

Arrondir un nombre

Le module math nous propose plusieurs fonctions pour arrondir un nombre selon différents critères :

>>> math.ceil(2.3) # Renvoie le plus petit entier >= 2.3
3
>>> math.floor(5.8) # Renvoie le plus grand entier <= 5.8
5
>>> math.trunc(9.5) # Tronque 9.5
9
>>>

Quant aux constantes du module, elles ne sont pas nombreuses : math.pi naturellement, ainsi que math.e.

Voilà, ce fut rapide mais suffisant, sauf si vous cherchez quelque chose de précis. En ce cas, un petit tour du côté de la documentation officielle du module math s'impose.

Des fractions avec le module fractions

Ce module propose, entre autres, de manipuler des objets modélisant des fractions. C'est la classe Fraction du module qui nous intéresse :

from fractions import Fraction

Créer une fraction

Le constructeur de la classe Fraction accepte plusieurs types de paramètres :

  • Deux entiers, le numérateur et le dénominateur (par défaut le numérateur vaut 0 et le dénominateur 1). Si le dénominateur est 0, une exception ZeroDivisionError est levée.

  • Une autre fraction.

  • Une chaîne sous la forme 'numerateur/denominateur'.

>>> un_demi = Fraction(1, 2)
>>> un_demi
Fraction(1, 2)
>>> un_quart = Fraction('1/4')
>>> un_quart
Fraction(1, 4)
>>> autre_fraction = Fraction(-5, 30)
>>> autre_fraction
Fraction(-1, 6)
>>>

Ne peut-on pas créer des fractions depuis un flottant ?

Si, mais pas dans le constructeur. Pour créer une fraction depuis un flottant, on utilise la méthode de classe from_float :

>>> Fraction.from_float(0.5)
Fraction(1, 2)
>>>

Et pour retomber sur un flottant, rien de plus simple :

>>> float(un_quart)
0.25
>>>

Manipuler les fractions

Maintenant, quel intérêt d'avoir nos nombres sous cette forme ? Surtout pour la précision des calculs. Les fractions que nous venons de voir acceptent naturellement les opérateurs usuels :

>>> un_dixieme = Fraction(1, 10)
>>> un_dixieme + un_dixieme + un_dixieme
Fraction(3, 10)
>>>

Alors que :

>>> 0.1 + 0.1 + 0.1
0.30000000000000004
>>>

Bien sûr, la différence n'est pas énorme mais elle est là. Tout dépend de vos besoins en termes de précision.

D'autres calculs ?

>>> un_dixieme * un_quart
Fraction(1, 40)
>>> un_dixieme + 5
Fraction(51, 10)
>>> un_demi / un_quart
Fraction(2, 1)
>>> un_quart / un_demi
Fraction(1, 2)
>>>

Voilà. Cette petite démonstration vous suffira si ce module vous intéresse. Et si elle ne suffit pas, rendez-vous sur la documentation officielle du module fractions.

Du pseudo-aléatoire avec random

Le module random, vous l'avez également utilisé pendant nos TP. Nous allons voir quelques fonctions de ce module, le tour d'horizon sera rapide !

Du pseudo-aléatoire

L'ordinateur est une machine puissante, capable de faire beaucoup de choses. Mais lancer les dés n'est pas son fort. Une calculatrice standard n'a aucune difficulté à additionner, soustraire, multiplier ou diviser des nombres. Elle peut même faire des choses bien plus complexes. Mais, pour un ordinateur, choisir un nombre au hasard est bien plus compliqué qu'il n'y paraît.

Ce qu'il faut bien comprendre, c'est que derrière notre appel à random.randrange par exemple, Python va faire un véritable calcul pour trouver un nombre aléatoire. De ce fait, le nombre généré n'est pas réellement aléatoire puisqu'un calcul identique, effectué dans les mêmes conditions, donnera le même nombre. Cependant, les algorithmes mis en place pour générer de l'aléatoire sont maintenant suffisamment complexes pour que les nombres générés ressemblent bien à une série aléatoire. Souvenez-vous toutefois que, pour un ordinateur, le véritable hasard ne peut pas exister.

La fonction random

Cette fonction, on ne l'utilisera peut-être pas souvent de manière directe mais elle est implicitement utilisée par le module quand on fait appel à randrange ou choice que nous verrons plus bas.

Elle génère un nombre pseudo-aléatoire compris entre 0 et 1. Ce sera donc naturellement un flottant :

>>> import random
>>> random.random()
0.9565461152605507
>>>

randrange et randint

La fonction randrange prend trois paramètres :

  • la marge inférieure de l'intervalle ;

  • la marge supérieure de l'intervalle ;

  • l'écart entre chaque valeur de l'intervalle (1 par défaut).

Que représente le dernier paramètre ?

Prenons un exemple, ce sera plus simple :

random.randrange(5, 10, 2)

Cette instruction va chercher à générer un nombre aléatoire entre 5 inclus et 10 non inclus, avec un écart de 2 entre chaque valeur. Elle va donc chercher dans la liste des valeurs [5, 7, 9].

Si vous ne précisez pas de troisième paramètre, il vaudra 1 par défaut (c'est le comportement attendu la plupart du temps).

La fonction randint prend deux paramètres :

  • là encore, la marge inférieure de l'intervalle ;

  • la marge supérieure de l'intervalle, cette fois incluse.

Pour tirer au hasard un nombre entre 1 et 6, il est donc plus intuitif de faire :

random.randint(1, 6)

Opérations sur des séquences

Nous allons voir deux fonctions : la première, choice, renvoie au hasard un élément d'une séquence passée en paramètre :

>>> random.choice(['a', 'b', 'k', 'p', 'i', 'w', 'z'])
'k'
>>>

La seconde s'appelle shuffle. Elle prend en paramètre une séquence et la mélange ; elle modifie donc la séquence qu'on lui passe et ne renvoie rien :

>>> liste = ['a', 'b', 'k', 'p', 'i', 'w', 'z']
>>> random.shuffle(liste)
>>> liste
['p', 'k', 'w', 'z', 'i', 'b', 'a']
>>>

Voilà. Là encore, ce fut rapide mais si vous voulez aller plus loin, vous savez ou aller… droit vers la documentation officielle de Python sur random.

En résumé

  • Le module math possède plusieurs fonctions et constantes mathématiques usuelles.

  • Le module fractions possède le nécessaire pour manipuler des fractions, parfois utiles pour la précision des calculs.

  • Le module random permet de générer des nombres pseudo-aléatoires.

Example of certificate of achievement
Example of certificate of achievement