Table of Contents

Manipulation des nombres

In [1]:
a=10
In [2]:
b,c=-2,3
In [3]:
print(b,c)

-2 3

Python permet une permutation très simple de deux variables.

In [4]:
b,c=c,b
In [5]:
print(b,c)

3 -2

Python reconnait deux types de nombres : les entiers et les flottants. On peut ici (et ailleurs) faire usage de la fonction type.

In [6]:
print(type(a))

<class 'int'>
In [7]:
print(type(b))

<class 'int'>
In [8]:
d=a/c
In [9]:
type(d)
Out[9]:
float
In [10]:
type(a/b)
Out[10]:
float
In [11]:
type(8/2)
Out[11]:
float
In [12]:
8/2
Out[12]:
4.0
In [13]:
8*2
Out[13]:
16

Méthode rapide d'incrémentation en Python.

In [14]:
a+=1
In [15]:
print(a)

11
In [16]:
a-=1
In [17]:
print(a)

10

Attention premier module en approche ! Le module math est un indispensable pour nous les matheux. Il contient les fonctions et variables pour faire notre bonheur. Le module lycee que l'on trouve aussi dans edupython propose les fonctions de math (et d'autres) en version francisé. L'utilisation des modules usuels nous paraît plus efficace sur le moyen terme.

In [18]:
import math #pour importer le module dans votre programme
In [19]:
print(math.sqrt(9))

3.0
In [20]:
math.pow(10,3)
Out[20]:
1000.0
In [21]:
10**3
Out[21]:
1000

Notons que l'opérateur que ** renvoie un entier quand cela est possible, ce qui n'est pas le cas de math.pow qui va renvoie systématiquement en flottant.

In [22]:
math.log(math.exp(5))
Out[22]:
5.0

Rappelons que Python permet d'obtenir toutes les informations nécessaires sur une fonction ou tout un module en utilisant, dans la console, la fonction help.

In [23]:
help(math.log)

Help on built-in function log in module math:

log(...)
    log(x, [base=math.e])
    Return the logarithm of x to the given base.
    
    If the base not specified, returns the natural logarithm (base e) of x.
In [24]:
math.floor(5.9)
Out[24]:
5
In [25]:
math.floor(-1.2)
Out[25]:
-2

Vous avez reconnu.

In [26]:
print(math.pi," *** ",math.e)

3.141592653589793  ***  2.718281828459045

En trigo, Python fonctionne à priori en radians.

In [27]:
math.sin(math.pi/6)
Out[27]:
0.49999999999999994

Oui, ça nous rappelle que nous sommes sur un ordinateur. C'est le moment de revenir sur les arrondis et valeurs approchées.

Et d'entamer le travail sur les fonctions. Construire une fonction qui renvoie 0.999 si on lui a donné le chiffre 9 et le nombre 3 et 0.3333333 si on lui a donné le chiffre 3 et le nombre 7.

In [28]:
def decimalVirgule(c,n):
    nombre=0
    for i in range(n):
        nombre=nombre+c*math.pow(10,-i-1)
    return(nombre)
In [29]:
decimalVirgule(3,2)
Out[29]:
0.33000000000000007
In [30]:
decimalVirgule(9,12)
Out[30]:
0.999999999999
In [31]:
1==decimalVirgule(9,14)
Out[31]:
False
In [32]:
1==decimalVirgule(9,16)
Out[32]:
False
In [33]:
1==decimalVirgule(9,18)
Out[33]:
True
In [34]:
1==decimalVirgule(9,17)
Out[34]:
True
In [35]:
a=1/3
In [36]:
a==decimalVirgule(3,25)
Out[36]:
False

En plus de floor, vue plus haut, le module math comprend les deux fonctions ceil et trunc.

In [37]:
math.ceil(4.6)
Out[37]:
5
In [38]:
math.ceil(-math.pi)
Out[38]:
-3
In [39]:
math.trunc(math.e)
Out[39]:
2
In [40]:
math.trunc(-3.125)
Out[40]:
-3

Par ailleurs, une fonction d'arrondi existe dans python : round

In [41]:
round(2.55)
Out[41]:
3
In [42]:
round(2.55,1)
Out[42]:
2.5
In [43]:
round(-math.e)
Out[43]:
-3
In [44]:
round(-math.e,2)
Out[44]:
-2.72

Le module sympy permet de faire du calcul formel. Mais il existe d'autres solutions qui ont aussi un intérêt pédagogique, par exemple le module "fractions" et plus précisément la classe "Fraction" de ce module.

In [45]:
from fractions import Fraction

Trois possibilités pour entrer la fraction 2/5 :

In [46]:
ma_fraction=Fraction(2,5)
In [47]:
print(ma_fraction)

2/5
In [48]:
ma_fraction=Fraction('2/5')
In [49]:
print(ma_fraction)

2/5
In [50]:
ma_fraction=Fraction(8,20)
In [51]:
ma_fraction
Out[51]:
Fraction(2, 5)
In [52]:
ma_fraction==Fraction.from_float(0.4)
Out[52]:
False
In [53]:
Fraction.from_float(0.4)
Out[53]:
Fraction(3602879701896397, 9007199254740992)
In [54]:
Fraction.from_float(0.5)
Out[54]:
Fraction(1, 2)
In [55]:
float(ma_fraction)==0.4
Out[55]:
True
In [56]:
ma_fraction+Fraction(1,2)
Out[56]:
Fraction(9, 10)
In [57]:
0.1+0.1+0.1
Out[57]:
0.30000000000000004
In [58]:
un_dixieme=Fraction('1/10')
In [59]:
un_dixieme+un_dixieme+un_dixieme
Out[59]:
Fraction(3, 10)
In [60]:
ma_fraction+0.3
Out[60]:
0.7
In [61]:
trois_dixieme=Fraction(3,10)
In [62]:
ma_fraction+trois_dixieme
Out[62]:
Fraction(7, 10)

Les fonctions

Pour rebondir sur ce qui précède tout en parlant des fonctions, on peut s'imspirer de ce que propose le site https://emilypython.wordpress.com/

Son approche propose de créer les fonctions indispensables pour faire du calcul sur les fractions. Ces activités ont toutes leur place en classe de Seconde où les élèves ont des acquis du collège qu'il faut, d'une part, réanimer et, d'autre part, faire aller plus loin vers le littéral. Cela permet aussi de parler du type List.

In [63]:
frac=[1,2]
In [64]:
frac[0]
Out[64]:
1
In [65]:
frac[1]
Out[65]:
2

On peut déjà chercher à vérifier que deux fractions sont égales. Avec b et d non nuls a/b et c/d sont égales ssi ad=bc.

In [66]:
def egaliteFrac(frac1,frac2):
    nb1 = frac1[0]*frac2[1]   #on calcule a*d
    nb2 = frac1[1]*frac2[0]   #on calcule b*c
    if nb1 == nb2:
        test = True
    else:
        test = False
    return test
In [67]:
egaliteFrac([1,2],[-20,-40])
Out[67]:
True

C'est le moment de parler "Fonctions" en précisant deux points. Il est coseillé de préciser l'utilité d'une fonction que l'on crée afin qu'un autre utilisateur puisse s'en saisir à bon escient.

In [68]:
def egaliteFrac(frac1,frac2):
    """Renvoie un booléen lié à l'égalité des deux fractions entrées en paramètres"""
    nb1 = frac1[0]*frac2[1]   #on calcule a*d
    nb2 = frac1[1]*frac2[0]   #on calcule b*c
    if nb1 == nb2:
        test = True
    else:
        test = False
    return test

Entrer cette fonction dans l'éditeur et lancer le programme. On peut alors utiliser cette fonction dans la console et le simple fait d'entrer au claivier "eg..." fait apparaître une fenêtre qui propose d'utiliser cette fonction et qui affiche son "utilité".

En classe, on peut ainsi définir avec les élèves, le produit de deux fractions, l'inverse d'une fraction ou le quotient (en utilisant les deux précédentes) de deux fractions.

Du bon usage des fonctions dans l'esprit des programmes : le mieux est d'analyser des exemples. Nous allons étudier l'exemple des nombres de Kaprekar (encore des nombres!). Mais tout d'abord, faisons quelques rappels sur les listes.

In [69]:
L1=list() #création d'une liste
In [70]:
L2=[] #autre façon de créer une liste (vide aussi)
In [71]:
L3=list(range(4)) #encore un autre type de création de liste (pas vide celle-ci)
In [72]:
L3
Out[72]:
[0, 1, 2, 3]

Pour compléter une liste, on ne peut pas utiliser un simple "+" comme pour les chaînes de charactères. Les méthodes append et insert sont très utiles.

In [73]:
L1.append("Lundi")
In [74]:
L1.append("Mardi")
In [75]:
L1.append("Vendredi")
In [76]:
L1
Out[76]:
['Lundi', 'Mardi', 'Vendredi']
In [77]:
L1.insert(2,"Mercredi")
In [78]:
L1
Out[78]:
['Lundi', 'Mardi', 'Mercredi', 'Vendredi']
In [79]:
L1.insert(3,"Jeudi")
In [80]:
L1
Out[80]:
['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi']
In [81]:
L1.extend(["Samedi","Dimanche"])
In [82]:
L1
Out[82]:
['Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche']

Comment accéder aux éléments d'une liste ?

In [83]:
L1[2]
Out[83]:
'Mercredi'
In [84]:
L1[:2]
Out[84]:
['Lundi', 'Mardi']
In [85]:
L1[2:]
Out[85]:
['Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche']

Pour supprimer des éléments, la fonction del et la méthode .remove : del L1[1] va supprimer le deuxième élèment de L1 tandis que L1.remove('Jeudi') va chercher 'Jeudi' dans L1 et va le supprimer.

Revenons donc à un exemple de programme : le test pour savoir si un nombre est un nombre de Kaprekar. Un nombre de Kaprekar est tel que son carré forme un nombre qui, si on le sépare au bon endroit, donne deux nombres dont la somme est égale au nombre lui-même. Ci-dessous un programme trouvé dans la documentation d'Edupython et qui permet de déterminer si un nombre est un nombre de Kaprekar.

In [5]:
#tiré de la documentation de edupython http://edupython.tuxfamily.org
# Créé par IANTE, le 20/06/2011


from math import *
n=int(input("Entrez un nombre entier strictement positif : "))
N=n*n
L=[]
trouveG,trouveD=-1,-1
while N!=0 :
    L.insert(0,N%10)
    N=N//10
for i in range(len(L)) :
    gauche=0
    droite=0
    for j in range(i) :
        gauche=gauche*10+L[j]
    for j in range(i,len(L)) :
        droite=droite*10+L[j]
    if gauche+droite==n :
        trouveG,trouveD=gauche,droite
if trouveG>-1:
    print (n,"est nombre de Kaprekar ",end="")
    print (n,"²=",n*n," et ",n,"=",trouveG,"+",trouveD)
else :
    print (n,"n'est pas nombre de Kaprekar")

Entrez un nombre entier strictement positif : 15
15 n'est pas nombre de Kaprekar

Après quelques modifications, on obtient:

In [7]:
#pour info 4879 ou 703 sont des nombres de Kaprekar
def testKaprekar(n):
    N=n*n
    L=[]
    trouveG,trouveD=-1,-1
    while N!=0 :
        L.insert(0,N%10)
        N=N//10
    for i in range(len(L)) :
        gauche=0
        droite=0
        for j in range(i) :
            gauche=gauche*10+L[j]
        for j in range(i,len(L)) :
            droite=droite*10+L[j]
        if gauche+droite==n :
            trouveG,trouveD=gauche,droite
    if trouveG>-1:
        return(True)
    else :
        return(False)
In [8]:
testKaprekar(703)
Out[8]:
True
In [ ]: