Tutoriel sur les calculs mathématiques

Intermediate

This tutorial is from open-source community. Access the source code

Introduction

Cette section traite des calculs mathématiques.

Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau intermédiaire avec un taux de réussite de 66%. Il a reçu un taux d'avis positifs de 91% de la part des apprenants.

Types of Numbers

Python a 4 types de nombres :

  • Booléens
  • Entiers
  • Nombres à virgule flottante
  • Nombres complexes (nombres imaginaires)

Booléens (bool)

Les booléens ont deux valeurs : True (vrai) et False (faux).

a = True
b = False

Numériquement, ils sont évalués comme des entiers avec les valeurs 1 et 0.

c = 4 + True ## 5
d = False
if d == 0:
    print('d est Faux')

Mais n'écrivez pas votre code de cette manière. Cela serait étrange.

Entiers (int)

Valeurs signées de taille et de base arbitraires :

a = 37
b = -299392993727716627377128481812241231
c = 0x7fa8      ## Hexadécimal
d = 0o253       ## Octal
e = 0b10001111  ## Binaire

Opérations courantes :

x + y      Addition
x - y      Soustraction
x * y      Multiplication
x / y      Division (produit un flottant)
x // y     Division entière (produit un entier)
x % y      Modulo (reste)
x ** y     Puissance
x << n     Décalage binaire vers la gauche
x >> n     Décalage binaire vers la droite
x & y      ET binaire
x | y      OU binaire
x ^ y      XOR binaire
~x         NON binaire
abs(x)     Valeur absolue

Nombres à virgule flottante (float)

Utilisez une notation décimale ou exponentielle pour spécifier une valeur à virgule flottante :

a = 37.45
b = 4e5 ## 4 x 10**5 ou 400 000
c = -1.345e-10

Les flottants sont représentés en double précision en utilisant la représentation native de la CPU IEEE 754. C'est la même chose que le type double dans le langage de programmation C.

17 chiffres de précision
Exposant de -308 à 308

Sachez que les nombres à virgule flottante sont imprécis lorsqu'ils représentent des décimales.

>>> a = 2.1 + 4.2
>>> a == 6.3
Faux
>>> a
6.300000000000001
>>>

Ceci n'est pas un problème de Python, mais le matériel à virgule flottante sous-jacent de la CPU.

Opérations courantes :

x + y      Addition
x - y      Soustraction
x * y      Multiplication
x / y      Division
x // y     Division entière
x % y      Modulo
x ** y     Puissance
abs(x)     Valeur absolue

Ce sont les mêmes opérateurs que pour les entiers, sauf pour les opérateurs bit-à-bit. D'autres fonctions mathématiques se trouvent dans le module math.

import math
a = math.sqrt(x)
b = math.sin(x)
c = math.cos(x)
d = math.tan(x)
e = math.log(x)

Comparaisons

Les opérateurs de comparaison / relationnels suivants fonctionnent avec les nombres :

x < y      Moins que
x <= y     Moins ou égal à
x > y      Plus que
x >= y     Plus ou égal à
x == y     Égal à
x!= y     Différent de

Vous pouvez former des expressions booléennes plus complexes en utilisant

et, ou, non

Voici quelques exemples :

if b >= a et b <= c:
    print('b est compris entre a et c')

if non (b < a ou b > c):
    print('b est toujours compris entre a et c')

Conversion de nombres

Le nom du type peut être utilisé pour convertir des valeurs :

a = int(x)    ## Convertit x en entier
b = float(x)  ## Convertit x en nombre à virgule flottante

Essayez-le.

>>> a = 3.14159
>>> int(a)
3
>>> b = '3.14159' ## Cela fonctionne également avec des chaînes de caractères contenant des nombres
>>> float(b)
3.14159
>>>

Rappel : Ces exercices supposent que vous travaillez dans le répertoire ~/projet. Recherchez le fichier mortgage.py.

Exercice 1.7 : Hypothèque de Dave

Dave a décidé de souscrire une hypothèque à taux fixe de 30 ans de 500 000 $ auprès de la société de crédit immobilier, d'investissement en actions et de trading de Bitcoin de Guido. Le taux d'intérêt est de 5 % et le paiement mensuel est de 2684,11 $.

Voici un programme qui calcule le montant total que Dave devra payer au cours de la durée de l'hypothèque :

## mortgage.py

principal = 500000.0
taux = 0.05
paiement = 2684.11
total_payé = 0.0

while principal > 0:
    principal = principal * (1+taux/12) - paiement
    total_payé = total_payé + paiement

print('Total payé', total_payé)

Entrez ce programme et exécutez-le. Vous devriez obtenir une réponse de 966279.5999999957.

Exercice 1.8 : Paiements supplémentaires

Supposons que Dave paie 1000 $ de plus par mois pendant les 12 premiers mois de l'hypothèque?

Modifiez le programme pour prendre en compte ce paiement supplémentaire et faites en sorte qu'il affiche le montant total payé ainsi que le nombre de mois nécessaires.

Lorsque vous exécutez le nouveau programme, il devrait indiquer un paiement total de 929965.6199999959 sur 342 mois.

Exercice 1.9 : Création d'un calculateur de paiement supplémentaire

Modifiez le programme de manière à ce que les informations sur les paiements supplémentaires puissent être traitées de manière plus générale. Améliorez-le de sorte que l'utilisateur puisse définir les variables suivantes :

extra_payment_start_month = 61
extra_payment_end_month = 108
extra_payment = 1000

Faites en sorte que le programme examine ces variables et calcule le montant total payé en conséquence.

Combien Dave paiera-t-il s'il paie 1000 $ de plus par mois pendant 4 ans, à partir du moment où les cinq premières années auront été payées?

Exercice 1.10 : Création d'un tableau

Modifiez le programme pour qu'il affiche un tableau montrant le numéro du mois, le montant total payé jusqu'à présent et le principal restant. La sortie devrait ressembler à ceci :

1 2684.11 499399.22
2 5368.22 498795.94
3 8052.33 498190.15
4 10736.44 497581.83
5 13420.55 496970.98
...
308 874705.88 3478.83
309 877389.99 809.21
310 880074.10 -1871.53
Total payé 880074.10
Mois 310

Exercice 1.11 : Prime

Pendant que vous y êtes, corrigez le programme pour compenser le trop-paiement qui se produit au dernier mois.

Exercice 1.12 : Un mystère

int() et float() peuvent être utilisés pour convertir des nombres. Par exemple,

>>> int("123")
123
>>> float("1.23")
1.23
>>>

Ayant cela à l'esprit, pouvez-vous expliquer ce comportement?

>>> bool("False")
True
>>>

Sommaire

Félicitations! Vous avez terminé le laboratoire sur les nombres. Vous pouvez pratiquer d'autres laboratoires sur LabEx pour améliorer vos compétences.