Manipulation de nombres

Les méthodes

Division, modulo (d'entiers)

Soient $x$ et $y$ deux entiers.

$x//y$

Division entière de $x$ par $y$, c'est-à-dire quotient de cette division.

  >>> 7//3
  2

  >>> 7/3
  2.3333333333333335

$x%y$

"$x$ modulo $y$", qui est le reste de la division entière de $x$ par $y$ :

  >>> 7%3
  1

divmod(nombre1,nombre2)

Renvoie le couple division entière suivie de modulo.

  >>> divmod(7,3)

  >>> x=divmod(7,3)
  >>> x[0]
  2
  >>> x[1] 
  1

Puissances

x**y

Renvoie $x^y$.

pow(x,y)

Comme ci-dessus, mais sous la forme d'une fonction (et non d'un opérateur, ce qui peut s'avérer utile).

pow(x,y,z)

Calcule efficacement $x^y$ modulo $z$, qui sert par exemple dans le cryptage RSA.

Comparaisons

max(sequence)

Renvoie le maximum de la séquence passée en argument.

  >>> max([1,3,5,2])

On peut spécifier comment évaluer le maximum, via l'argument key:

  >>> max(["ici", "c'est", "l'IUT"], key=len)
  "c'est"

min(sequence)

Renvoie le minimum de la séquence passée en argument.

Changement de base

int(nombre,base)

Par exemple

  >>> int('110',2)

bin(nombre)

Valeur binaire d'un décimal.

  >>> bin(14)

Le retour est une chaîne de caractères commençant par 0b. Pour n'obtenir que les bits, on peut prendre une tranche de la chaîne de caractères :

  >>> bin(14)[2:]
  '1110'

On peut encore la compléter à gauche par des zéros, par exemple pour coder 14 sur 8 bits, à l'aide de la méthode zfill.

  >>> bin(14)[2:].zfill(8)
  '00001110'

hex(nombre)

Renvoie la forme hexadécimale (sous la forme d'une chaîne de caractères) du nombre passé en argument.

oct(nombre)

Renvoie la forme octale (sous la forme d'une chaîne de caractères) du nombre passé en argument.

Conversion de type

int(nombre)

Tronque la partie décimale de nombre (ça n'est pas exactement notre partie entière).

  >>> int(3.14)

float(objet)

Transforme l'objet (un caractère ou un entier) en float.

round(x, y)

Un arrondis du réel x à la virgule y.

complex($nb_a$,$nb_b$)

Renvoie un objet de type complexe, égal à $nb_a+nb_b*1j$ où $1j$ est l'imaginaire pur.

  >>> complex(2,3)

  >>> complex(2,3)+complex(4,-1)
  (6+2j)
  >>> complex(0,1)**2
  (-1+0j)

abs(nombre)

Renvoie la valeur absolue (ou le module, si on a affaire à un complexe) de nombre.

Evaluation d'une chaîne de caractères

eval(chaine)

Evalue l'expression mathématique (chaîne de caractères). Par exemple,

  >>> eval('2+3*(4-1)')

Travaux pratiques

1. Tester toutes ces méthodes dans un python interactif.
2. Soit q le quotient de la division de 1234 par 56, et r son reste. Vérifier que 1234 = 56*q+r (en utilisant la division entière, et le modulo).
3. Calculer la somme des multiples de 7 jusqu'à 7777, et ce en utilisant le modulo, le if, ainsi qu'une boucle. (On peut procéder différemment, mais le but est de s'entraîner à utiliser le modulo.)
4. Demander à l'utilisateur de saisir une expression algébrique, comme 7*3+4, ou 2**3+4**2+1, et renvoyez le résultat.

Autres primitives Python

On termine cette courte présentation de Python en dressant la liste de quelques primitives bien utiles.

Constantes

Quelques constantes en python :

  >>> from math import pi, e

pi

La constante π.

True

Le booléen vrai.

False

Le booléen faux.

e

12e2 est égal à 1200.0, par exemple.

Opérateurs

Des opérateurs en python :

x == y

Teste l'égalité (booléenne) entre x et y.

x != y

Teste si x est différent de y.

x >= y

Teste si x est supérieur ou égal à y.

x or y

Le ou booléen.

x and y

Le et booléen.

not x

La négation booléenne.

Manipulation de caractères

chr(nombre)

Renvoie le caractère qui admet nombre pour code ASCII.

  >>> chr(97)

ord(objet)

Renvoie le rang d'un caractère (dans la table ascii).

  >>> ord('a')

len(objet)

Renvoie la longueur de la chaîne de caractères, ou plus généralement de l'objet passé en argument.

str(objet)

Convertit l'objet en chaîne de caractères.

Listes, séquences

map(fonction,sequence)

Applique la fonction à tous les éléments de la séquence.

  >>> list(map(abs,[-2,1.5,7,-3.7]))

range(n)

Renvoie la liste des entiers de $0$ à $n-1$.

range(a,b)

Renvoie la liste des entiers de $a$ à $b-1$.

range(a,b,c)

Renvoie la liste des entiers de $a$ à $b-1$, avec un pas de $c$.

sum(liste)

Renvoie la somme des nombres présents dans la liste.

Divers

help(nom)

Comme son nom l'indique. Par exemple, pour avoir de l'aide sur la méthode abs :

  >>> help(abs)

    abs(number) -> number

    Return the absolute value of the argument.

isinstance(objet,type)

Par exemple,

  >>> isinstance('test', int)

type(objet)

Renvoie le type de l'objet.

Travaux pratiques

• Réalisez un chiffrement par décalage : si l'utilisateur rentre azerty, chiffrez cela en bafsuz (on décale d'une lettre dans l'alphabet).

• On pourra déjà supposer que seuls les minuscules peuvent être saisies, pour ensuite admettre minuscule et majuscule, et enfin admettre tous les caractères.
• Demandez, en plus, à l'utilisateur de préciser de combien de lettres il souhaite son décalage.

N.B.: Une solution, à méditer :

  n [28]: def cesar(txt, dec): return ''.join([chr((ord(k)-97+dec)%26+97) for k in txt])

  In [29]: cesar('azerty', 3)
  Out[29]: 'dchuwb'

  In [30]: cesar(_, -3)
  Out[30]: 'azerty'

Quelques compléments

Les affectations multiples

On peut, en Python, faire des affectations à plusieurs variables :

• en « série »

  >>> x = y = 7

• en « parallèle »

  >>> x, y = 7, 8

Le module math de python

Les modules en python

Python possède des modules permettant d'à peu près tout faire.

• Les modules officiels sont documentés sur le site officiel, ici
• Les modules faits par monsieur tout-le-monde sont centralisés sur le Python package index (Pypi)
• Sur ce wiki, on détaille certains de ces modules ici.

Exemple d'utilisation du module math

Le module math possède la plupart des fonctionnalités de base attendues pour une bibliothèque de mathématiques : fonctions trigonométriques, racine carrée, constantes mathématiques, etc.

Il existe au moins 3 manières d'importer ces fonctions. Dans la première, on importe tout le module math :

  >>> import math
  >>> print(math.pi)
  >>> print(math.sin(2*math.pi))

L'avantage de cette approche est que l'on sait toujours quelle est la méthode ou la constante appelée : ici, la méthode sin du module math. L'inconvénient est de devoir toujours taper le nom du module.

La seconde manière est d'importer immédiatement tout le contenu du module, comme suit :

  >>> from math import *
  >>> print(pi)
  >>> print(sin(2*pi))

L'avantage est la concision de cette approche. Les inconvénients sont multiples :

• Quand on voit apparaître une fonction exotique en plein milieu d'un gros programme, on ne voit pas d'où elle vient. S'il faut la déboguer, cela pose problème.
• Si vous avez créé une fonction toto, et qu'un module que vous importez contient une fonction toto, c'est quelle fonction toto qui est utilisée finalement ?
• Les modules scipy, sympy, numpy et math possèdent toutes une fonction sin. Vous ne pouvez pas savoir laquelle vous utilisez en faisant une telle importation.

La dernière manière d'importer est un compromis :

  >>> from math import pi, sin
  >>> print(pi)
  >>> print(sin(2*pi))

On peut obtenir le détail du module math :

• soit en consultant le lien math des modules officiels
• soit en ligne de commande :

  >>> import math

ou pour une fonction spécifique :

  >>> from math import sin
  >>> help(sin)

Travaux pratiques

1. Faire un programme qui demande à l'utilisateur de saisir un rayon, et qui renvoie le périmètre et l'aire du disque associé.
2. Parcourir la documentation des modules officiels, et le pypi.